@jixo/cli 0.23.7 → 0.24.0

package/assets/bundle/groq.browser.js

@@ -0,0 +1,3714 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+const obj_lazify = /* @__NO_SIDE_EFFECTS__ */ (obj, target = obj) => {
+	for (const [prop, desp] of obj_all_descriptors(obj)) _set_lazify(target, prop, desp);
+	return target;
+};
+const _set_lazify = (target, prop, desp) => {
+	if (desp.get !== void 0 && desp.set === void 0 && desp.configurable) {
+		const source_get = desp.get;
+		const cache_get = function() {
+			const cache = source_get.call(this);
+			delete desp.get;
+			delete desp.set;
+			desp.value = cache;
+			Object.defineProperty(target, prop, desp);
+			return cache;
+		};
+		desp.get = cache_get;
+		Object.defineProperty(target, prop, desp);
+	}
+};
+const obj_all_descriptors = (obj) => {
+	const desps = Object.getOwnPropertyDescriptors(obj);
+	return Reflect.ownKeys(desps).map((prop) => [prop, desps[prop]]);
+};
+const obj_delegate_by = (target, proto, getBy = () => proto, options) => {
+	const recursive = options?.recursive ?? false;
+	const omit = new Set(options?.omit);
+	_delegate_by(target, proto, getBy, recursive, omit);
+	return omit;
+};
+const _delegate_by = (target, proto, getBy, recursive, omit) => {
+	for (const [prop, desp] of obj_all_descriptors(proto)) {
+		if (omit.has(prop)) continue;
+		omit.add(prop);
+		let can_delegate = false;
+		if (desp.get != null) {
+			can_delegate = true;
+			const source_get = desp.get;
+			desp.get = function() {
+				return source_get.call(getBy(this));
+			};
+		}
+		if (desp.set != null) {
+			can_delegate = true;
+			const source_set = desp.set;
+			desp.set = function(value) {
+				return source_set.call(getBy(this), value);
+			};
+		}
+		if (typeof desp.value === "function") {
+			can_delegate = true;
+			const source_func = desp.value;
+			desp.value = function(...args) {
+				return source_func.apply(getBy(this), args);
+			};
+		} else {
+			delete desp.value;
+			desp.set = function(value) {
+				return Reflect.set(getBy(this), prop, value, this);
+			};
+			desp.get = function() {
+				return Reflect.get(getBy(this), prop, this);
+			};
+		}
+		if (can_delegate) Object.defineProperty(target, prop, desp);
+	}
+	if (recursive) {
+		const source_proto = Object.getPrototypeOf(proto);
+		if (source_proto !== null && source_proto !== Object.prototype) return _delegate_by(target, source_proto, getBy, recursive, omit);
+	}
+};
+const isPromiseLike = (value) => value !== null && typeof value?.then === "function";
+const arr_set_next = (arr, item) => {
+	arr[arr.length] = item;
+};
+const iter_map_async_try = (values, callbackfn) => {
+	const result = [];
+	let index = 0;
+	for (const item of values) result.push(callbackfn(item, index++, values));
+	return Promise.allSettled(result);
+};
+const iter_map_not_null = (values, callbackfn) => {
+	const result = [];
+	let index = 0;
+	if (callbackfn) for (const value of values) {
+		const r = callbackfn(value, index++, values);
+		if (r != null) result.push(r);
+	}
+	else for (const value of values) if (value != null) result.push(value);
+	return result;
+};
+var PureEvent = class {
+	constructor() {
+		this.watch = this.watch.bind(this);
+		this.on = this.on.bind(this);
+		this.once = this.once.bind(this);
+		this.off = this.off.bind(this);
+		this.unwatch = this.unwatch.bind(this);
+		this.emit = this.emit.bind(this);
+	}
+	events = /* @__PURE__ */ new Map();
+	get size() {
+		return this.events.size;
+	}
+	has(key) {
+		return this.events.has(key);
+	}
+	on(cb, options) {
+		return this.watch(cb, options);
+	}
+	watch(cb, options) {
+		const key = options?.key ?? cb;
+		this.off(key);
+		let onDispose = options?.onDispose;
+		if (typeof onDispose !== "function") onDispose = void 0;
+		const off = () => this.off(key);
+		this.events.set(key, {
+			cb,
+			onDispose,
+			off
+		});
+		return off;
+	}
+	off(key) {
+		return this.unwatch(key);
+	}
+	unwatch(key) {
+		const event = this.events.get(key);
+		if (event == null) return false;
+		this.events.delete(key);
+		if (event.onDispose == null) return true;
+		return promise_try(event.onDispose);
+	}
+	cleanSync() {
+		const dels = iter_map_not_null(this.events, ([key, event]) => {
+			this.events.delete(key);
+			return {
+				key,
+				disposeReturn: event.onDispose ? promise_try(event.onDispose) : void 0
+			};
+		});
+		return dels;
+	}
+	async clean() {
+		const dels = this.cleanSync();
+		const results = [];
+		for (const del of dels) {
+			const disposeReturn = await del.disposeReturn;
+			results.push({
+				key: del.key,
+				disposeReturn
+			});
+		}
+		return results;
+	}
+	async emit(data) {
+		if (this.size === 0) return;
+		const errors = [];
+		const results = await iter_map_async_try(this.events.values(), (cb) => cb.cb(data));
+		for (const item of results) if (item.status === "rejected") arr_set_next(errors, item.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "emit error");
+	}
+	once(cb_or_options, options) {
+		let cb;
+		if (typeof cb_or_options === "function") cb = cb_or_options;
+		else if (cb_or_options != null) options = cb_or_options;
+		const filter = options?.filter ?? (() => true);
+		if (cb == null) {
+			const onDispose = options?.onDispose;
+			const off$1 = this.on((data) => {
+				if (filter(data)) {
+					promiseWithResolvers.resolve(data);
+					off$1();
+				}
+			}, {
+				...options,
+				onDispose() {
+					if (false === resolved) promiseWithResolvers.reject(/* @__PURE__ */ new Error("listener dispose"));
+					onDispose?.();
+				}
+			});
+			const job = Promise.withResolvers();
+			let resolved = false;
+			const promiseWithResolvers = Object.assign(job.promise, {
+				resolve(data) {
+					resolved = true;
+					job.resolve(data);
+				},
+				reject(reason) {
+					job.reject(reason);
+				}
+			});
+			return promiseWithResolvers;
+		}
+		const off = this.watch(async (data) => {
+			if (filter(data)) {
+				const disposeReturn = off();
+				if (disposeReturn !== false) try {
+					return cb(data);
+				} finally {
+					if (disposeReturn instanceof Promise) await disposeReturn;
+				}
+			}
+		}, options);
+		return off;
+	}
+};
+const pureEvent = () => {
+	const pe = new PureEvent();
+	const watch = pe.watch;
+	Object.setPrototypeOf(watch, pe);
+	return watch;
+};
+var PureEventDelegate = class extends PureEvent {
+	byPureEvent;
+	constructor(byPureEvent = new PureEvent()) {
+		super();
+		this.byPureEvent = byPureEvent;
+	}
+};
+obj_delegate_by(PureEventDelegate.prototype, PureEvent.prototype, (target) => target.byPureEvent);
+const func_remember = /* @__NO_SIDE_EFFECTS__ */ (func, key) => {
+	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)
+		};
+		return result.res;
+	};
+	const once_fn_mix = Object.assign(once_fn, {
+		get source() {
+			return func;
+		},
+		get key() {
+			return result?.key;
+		},
+		get runned() {
+			return result != null;
+		},
+		get returnValue() {
+			return result?.res;
+		},
+		reset() {
+			result = void 0;
+		},
+		rerun(...args) {
+			once_fn_mix.reset();
+			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) => {
+	return Object.defineProperties([void 0, result], {
+		success: {
+			value: true,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		result: {
+			value: result,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		error: {
+			value: void 0,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		}
+	});
+};
+const wrapError = (err, errorParser) => {
+	const error = errorParser ? errorParser(err) : err;
+	return Object.defineProperties([error, void 0], {
+		success: {
+			value: false,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		result: {
+			value: void 0,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		error: {
+			value: error,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		}
+	});
+};
+const func_catch = /* @__PURE__ */ Object.assign((fn, errorParser) => {
+	return Object.assign(function() {
+		try {
+			const res = fn.apply(this, arguments);
+			if (isPromiseLike(res)) return res.then((value) => wrapSuccess(value), (err) => wrapError(err, errorParser));
+			return wrapSuccess(res);
+		} catch (err) {
+			return wrapError(err, errorParser);
+		}
+	}, { catchType(errorParser$1) {
+		return func_catch(fn, errorParser$1);
+	} });
+}, {
+	wrapSuccess,
+	wrapError
+});
+const effect_symbol = Symbol.for("effect");
+const promise_try = async (fn) => {
+	try {
+		const value = await fn();
+		return {
+			status: "fulfilled",
+			value
+		};
+	} catch (reason) {
+		return {
+			status: "rejected",
+			reason
+		};
+	}
+};
+const binary_to_base64_string = (u8a) => {
+	if ("base64Slice" in u8a) return u8a.toString("base64");
+	let binaryString = "";
+	for (let i = 0; i < u8a.length; i++) binaryString += binary_base64_table[u8a[i]];
+	return btoa(binaryString);
+};
+const binary_base64_table = /* @__PURE__ */ Object.freeze(Array.from({ length: 256 }, (_, index) => {
+	return String.fromCharCode(index);
+}));
+const binary_hex_table = /* @__PURE__ */ obj_lazify({
+	get hex16() {
+		return Object.freeze(Array.from({ length: 2 ** 16 }, (_, index) => {
+			return index.toString(16).padStart(4, "0");
+		}));
+	},
+	get hex8() {
+		return Object.freeze(Array.from({ length: 256 }, (_, index) => {
+			return index.toString(16).padStart(2, "0");
+		}));
+	}
+});
+const str_to_base64_binary = (str) => {
+	const binaryString = atob(str);
+	const uint8Array = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) uint8Array[i] = binaryString.charCodeAt(i);
+	return uint8Array;
+};
+const hex_binary_table = /* @__PURE__ */ obj_lazify({ get hex8() {
+	const hex8_binary_ver_table = [];
+	for (let a = 0; a < 16; a++) {
+		const bs = hex8_binary_ver_table[a.toString(16).charCodeAt(0)] = [];
+		for (let b = 0; b < 16; b++) bs[b.toString(16).charCodeAt(0)] = (a << 4) + b;
+		Object.freeze(bs);
+	}
+	return Object.freeze(hex8_binary_ver_table);
+} });
+let rootDirHandle;
+const prepareDirHandle = async () => {
+	if (rootDirHandle) return rootDirHandle;
+	const ti = setTimeout(() => {
+		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) {
+		clearTimeout(ti);
+		if (e instanceof Error) {
+			if (e.name === "SecurityError" || e.name === "NotAllowedError") {
+				console.log("%c请将鼠标聚焦到窗口视图中", styles.info);
+				await delay(1e3);
+				return prepareDirHandle();
+			}
+			if (e.name === "AbortError") throw new DOMException("用户取消了文件夹选择", "AbortError");
+		}
+		throw e;
+	}
+};
+const getEasyFs = /* @__PURE__ */ func_remember(async () => {
+	const [error, dirHandle] = await func_catch(prepareDirHandle)();
+	if (!dirHandle) {
+		getEasyFs.reset();
+		throw error;
+	}
+	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 writeFile = async (filePath, data, opts) => {
+		const { getFile } = await getHandle(filePath, { create: true });
+		const handle = await getFile();
+		const w$1 = await handle.createWritable();
+		if (!opts?.append) await w$1.truncate(0);
+		await w$1.write(data);
+		await w$1.close();
+	};
+	const createWriteStream = async (filePath) => {
+		const { getFile } = await getHandle(filePath, { create: true });
+		const handle = await getFile();
+		return handle.createWritable();
+	};
+	const readFileText = async (filePath) => {
+		const { getFile } = await getHandle(filePath);
+		const file = await (await getFile()).getFile();
+		return file.text();
+	};
+	const readFileBinary = async (filePath) => {
+		const { getFile } = await getHandle(filePath);
+		const file = await (await getFile()).getFile();
+		return file.bytes();
+	};
+	const createReadStream = async (filePath) => {
+		const { getFile } = await getHandle(filePath);
+		const file = await (await getFile()).getFile();
+		return file.stream();
+	};
+	const readdir = async (dirPath) => {
+		const { getDir } = await getHandle(dirPath);
+		const dir = await getDir();
+		return Array.fromAsync(dir.keys());
+	};
+	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 exists = async (path) => {
+		try {
+			await getHandle(path);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const stat = async (path) => {
+		const { getFile, getDir } = await getHandle(path);
+		try {
+			const h$1 = await getFile();
+			const f = await h$1.getFile();
+			return {
+				isFile: true,
+				size: f.size,
+				lastModified: f.lastModified
+			};
+		} catch {
+			await getDir();
+			return { isFile: false };
+		}
+	};
+	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;
+		}
+	};
+	return {
+		writeFile,
+		createWriteStream,
+		readFileText,
+		readFileBinary,
+		createReadStream,
+		readdir,
+		mkdir,
+		exists,
+		stat,
+		rm
+	};
+});
+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 delay = (ms) => new Promise((cb) => setTimeout(cb, ms));
+const raf = () => new Promise((cb) => requestAnimationFrame(cb));
+const $ = document.querySelector.bind(document);
+const $$ = document.querySelectorAll.bind(document);
+async function extractChat(ele = document.body) {
+	const messages = [];
+	const sysCardOpenBtn = ele.querySelector(".flex.w-full.content-start.rounded-lg.hover\\:bg-secondary-subtle button");
+	if (sysCardOpenBtn) {
+		sysCardOpenBtn.click();
+		await raf();
+	}
+	const sysCard = ele.querySelector(".flex.w-full.content-start.rounded-lg.flex-col.bg-secondary-subtle");
+	if (sysCard) {
+		const ta = sysCard.querySelector("textarea");
+		const text = ta?.value.trim();
+		if (text && text !== "Enter system message (Optional)") messages.push({
+			role: "system",
+			text
+		});
+	}
+	ele.querySelectorAll("[class*=\"rounded-lg\"]").forEach((card) => {
+		const roleBtn = card.querySelector("button[class*=\"uppercase\"]");
+		if (!roleBtn) return;
+		const role = roleBtn.textContent?.trim().toLowerCase() ?? "";
+		if (!["user", "assistant"].includes(role)) return;
+		const textarea = card.querySelector("textarea");
+		if (!textarea) return;
+		const text = textarea.value.trim();
+		if (text) messages.push({
+			role,
+			text
+		});
+	});
+	return messages;
+}
+async function keepWeakup() {
+	const workerCode = `
+    setInterval(() => self.postMessage('tick'), 1000);
+  `;
+	const worker = new Worker(URL.createObjectURL(new Blob([workerCode], { type: "application/javascript" })));
+	worker.onmessage = () => {};
+	const ctx = new (window.AudioContext || window.webkitAudioContext)();
+	const length = ctx.sampleRate * .2;
+	const buffer = ctx.createBuffer(1, length, ctx.sampleRate);
+	const data = buffer.getChannelData(0);
+	for (let i = 0; i < length; i++) data[i] = Math.random() * .02 - .01;
+	const source = ctx.createBufferSource();
+	source.buffer = buffer;
+	source.loop = true;
+	source.connect(ctx.destination);
+	source.start();
+	return () => {
+		worker.terminate();
+		try {
+			source.stop();
+		} catch {}
+		try {
+			ctx.close();
+		} catch {}
+	};
+}
+const NEVER = Object.freeze({ status: "aborted" });
+function $constructor(name, initializer$1, params) {
+	function init$1(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$1(inst, def);
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		for (const fn of inst._zod.deferred) fn();
+		return inst;
+	}
+	Object.defineProperty(_, "init", { value: init$1 });
+	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 getEnumValues(entries) {
+	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+	const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+	return values;
+}
+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$1(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+function mergeDefs(...defs) {
+	const mergedDescriptors = {};
+	for (const def of defs) {
+		const descriptors = Object.getOwnPropertyDescriptors(def);
+		Object.assign(mergedDescriptors, descriptors);
+	}
+	return Object.defineProperties({}, mergedDescriptors);
+}
+function esc(str) {
+	return JSON.stringify(str);
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+const allowsEval = cached(() => {
+	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
+	try {
+		const F = Function;
+		new F("");
+		return true;
+	} catch (_) {
+		return false;
+	}
+});
+function isPlainObject$2(o) {
+	if (isObject(o) === false) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (isObject(prot) === false) return false;
+	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
+	return true;
+}
+const propertyKeyTypes = new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+	const cl = new inst._zod.constr(def ?? inst._zod.def);
+	if (!def || params?.parent) cl._zod.parent = inst;
+	return cl;
+}
+function normalizeParams(_params) {
+	const params = _params;
+	if (!params) return {};
+	if (typeof params === "string") return { error: () => params };
+	if (params?.message !== void 0) {
+		if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
+		params.error = params.message;
+	}
+	delete params.message;
+	if (typeof params.error === "string") return {
+		...params,
+		error: () => params.error
+	};
+	return params;
+}
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		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 extend$1(schema, shape) {
+	if (!isPlainObject$2(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	const def = mergeDefs(schema._zod.def, {
+		get shape() {
+			const _shape = {
+				...schema._zod.def.shape,
+				...shape
+			};
+			assignProp$1(this, "shape", _shape);
+			return _shape;
+		},
+		checks: []
+	});
+	return clone(schema, def);
+}
+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, issues) {
+	return issues.map((iss) => {
+		var _a;
+		(_a = iss).path ?? (_a.path = []);
+		iss.path.unshift(path);
+		return iss;
+	});
+}
+function unwrapMessage(message) {
+	return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config$1) {
+	const full = {
+		...iss,
+		path: iss.path ?? []
+	};
+	if (!iss.message) {
+		const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config$1.customError?.(iss)) ?? unwrapMessage(config$1.localeError?.(iss)) ?? "Invalid input";
+		full.message = message;
+	}
+	delete full.inst;
+	delete full.continue;
+	if (!ctx?.reportInput) delete full.input;
+	return full;
+}
+function issue(...args) {
+	const [iss, input, inst] = args;
+	if (typeof iss === "string") return {
+		message: iss,
+		code: "custom",
+		input,
+		inst
+	};
+	return { ...iss };
+}
+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$2 = /* @__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;
+const _null$2 = /null/i;
+const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+	var _a;
+	inst._zod ?? (inst._zod = {});
+	inst._zod.def = def;
+	(_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+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 $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = _null$2;
+	inst._zod.values = new Set([null]);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (input === null) return payload;
+		payload.issues.push({
+			expected: "null",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+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 $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject$2(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		if (def.keyType._zod.values) {
+			const values = def.keyType._zod.values;
+			payload.value = {};
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[key] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!values.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				const keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (keyResult.issues.length) {
+					payload.issues.push({
+						origin: "record",
+						code: "invalid_key",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					payload.value[keyResult.value] = keyResult.value;
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[keyResult.value] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+	$ZodType.init(inst, def);
+	const values = getEnumValues(def.entries);
+	const valuesSet = new Set(values);
+	inst._zod.values = valuesSet;
+	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (valuesSet.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
+	inst._zod.values = new Set(def.values);
+	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (inst._zod.values.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values: def.values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	inst._zod.optout = "optional";
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, void 0]) : void 0;
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? /* @__PURE__ */ new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (def.innerType._zod.optin === "optional") return def.innerType._zod.run(payload, ctx);
+		if (payload.value === void 0) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? /* @__PURE__ */ new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+	});
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === null) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "innerType", () => def.getter());
+	defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
+	defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
+	defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
+	inst._zod.parse = (payload, ctx) => {
+		const inner = inst._zod.innerType;
+		return inner._zod.run(payload, ctx);
+	};
+});
+const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _) => {
+		return payload;
+	};
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const r = def.fn(input);
+		if (r instanceof Promise) return r.then((r$1) => handleRefineResult(r$1, payload, input, inst));
+		handleRefineResult(r, payload, input, inst);
+		return;
+	};
+});
+function handleRefineResult(result, payload, input, inst) {
+	if (!result) {
+		const _iss = {
+			code: "custom",
+			input,
+			inst,
+			path: [...inst._zod.def.path ?? []],
+			continue: !inst._zod.def.abort
+		};
+		if (inst._zod.def.params) _iss.params = inst._zod.def.params;
+		payload.issues.push(issue(_iss));
+	}
+}
+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 _null$1(Class, params) {
+	return new Class({
+		type: "null",
+		...normalizeParams(params)
+	});
+}
+function _any(Class) {
+	return new Class({ type: "any" });
+}
+function _unknown(Class) {
+	return new Class({ type: "unknown" });
+}
+function _custom(Class, fn, _params) {
+	const norm = normalizeParams(_params);
+	norm.abort ?? (norm.abort = true);
+	const schema = new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...norm
+	});
+	return schema;
+}
+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$2(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 ZodMiniNull = /* @__PURE__ */ $constructor("ZodMiniNull", (inst, def) => {
+	$ZodNull.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function _null(params) {
+	return _null$1(ZodMiniNull, params);
+}
+const ZodMiniAny = /* @__PURE__ */ $constructor("ZodMiniAny", (inst, def) => {
+	$ZodAny.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function any() {
+	return _any(ZodMiniAny);
+}
+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$1(this, "shape", { ...shape });
+			return this.shape;
+		},
+		...normalizeParams(params)
+	};
+	return new ZodMiniObject(def);
+}
+function looseObject(shape, params) {
+	return new ZodMiniObject({
+		type: "object",
+		get shape() {
+			assignProp$1(this, "shape", { ...shape });
+			return this.shape;
+		},
+		catchall: unknown(),
+		...normalizeParams(params)
+	});
+}
+function extend(schema, shape) {
+	return extend$1(schema, shape);
+}
+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 ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function record(keyType, valueType, params) {
+	return new ZodMiniRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function _enum(values, params) {
+	const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+	return new ZodMiniEnum({
+		type: "enum",
+		entries,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function literal(value, params) {
+	return new ZodMiniLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
+		...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 ZodMiniNullable = /* @__PURE__ */ $constructor("ZodMiniNullable", (inst, def) => {
+	$ZodNullable.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function nullable(innerType) {
+	return new ZodMiniNullable({
+		type: "nullable",
+		innerType
+	});
+}
+const ZodMiniLazy = /* @__PURE__ */ $constructor("ZodMiniLazy", (inst, def) => {
+	$ZodLazy.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function _lazy(getter) {
+	return new ZodMiniLazy({
+		type: "lazy",
+		getter
+	});
+}
+const ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
+	$ZodCustom.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+function custom(fn, _params) {
+	return _custom(ZodMiniCustom, fn ?? (() => true), _params);
+}
+function _instanceof(cls, params = { error: `Input not instance of ${cls.name}` }) {
+	const inst = custom((data) => data instanceof cls, params);
+	inst._zod.bag.Class = cls;
+	return inst;
+}
+var DuplexClosedError = class extends Error {
+	constructor(reason) {
+		super(`The duplex channel was closed unexpectedly. Reason: ${reason}`);
+		this.name = "DuplexClosedError";
+	}
+};
+var WaitTimeoutError = class extends Error {
+	constructor(timeout) {
+		super(`Waited for next task for ${timeout}ms, but no data was received.`);
+		this.name = "WaitTimeoutError";
+	}
+};
+function waitNextTask(duplex, options = {}) {
+	return new Promise((resolve, reject) => {
+		let timeoutId;
+		const cleanup = () => {
+			if (timeoutId) clearTimeout(timeoutId);
+			offData();
+			offClose();
+		};
+		const offData = duplex.onData.on((data) => {
+			if (!options.filter || options.filter(data)) {
+				cleanup();
+				resolve(data);
+			}
+		});
+		const offClose = duplex.onClose.on((reason) => {
+			cleanup();
+			reject(new DuplexClosedError(reason));
+		});
+		if (options.timeout) timeoutId = setTimeout(() => {
+			cleanup();
+			reject(new WaitTimeoutError(options.timeout));
+		}, options.timeout);
+	});
+}
+const zEvalTask = object({
+	type: literal("eval"),
+	taskId: string(),
+	code: string(),
+	status: _enum([
+		"initial",
+		"pending",
+		"fulfilled",
+		"rejected"
+	]),
+	result: any(),
+	done: boolean()
+});
+async function doEval(duplex, initialTask) {
+	const output = {
+		...initialTask,
+		status: "pending"
+	};
+	try {
+		const result = await (async () => eval(output.code))();
+		output.status = "fulfilled";
+		output.result = result;
+	} catch (e) {
+		output.status = "rejected";
+		output.result = e instanceof Error ? {
+			message: e.message,
+			name: e.name,
+			stack: e.stack
+		} : e;
+	} finally {
+		output.done = true;
+		duplex.sendData(output);
+		duplex.close("done");
+	}
+}
+const createRunCodeInBrowser = (runner) => {
+	return async (dir, code) => {
+		const initialTask = {
+			type: "eval",
+			taskId: crypto.randomUUID(),
+			code,
+			status: "initial",
+			result: null,
+			done: false
+		};
+		const duplex = await runner({
+			dir,
+			initialTask
+		});
+		try {
+			const finalTask = await waitNextTask(duplex, {
+				filter: (task) => task.done,
+				timeout: 3e4
+			});
+			if (finalTask.status === "rejected") throw finalTask.result;
+			else return finalTask.result;
+		} finally {
+			duplex.close();
+		}
+	};
+};
+const zBaseFetchTask = object({
+	type: literal("fetch"),
+	taskId: string()
+});
+const zFetchInitialCommand = extend(zBaseFetchTask, {
+	status: literal("initial"),
+	url: string(),
+	init: optional(any()),
+	done: literal(false)
+});
+const zFetchGetFullBodyCommand = extend(zBaseFetchTask, {
+	sub_command: literal("getFullBody"),
+	format: _enum(["json", "text"])
+});
+const zFetchRequestChunkCommand = extend(zBaseFetchTask, { sub_command: literal("requestChunk") });
+const zFetchRespondedEvent = extend(zBaseFetchTask, {
+	status: literal("responded"),
+	response: object({
+		headers: record(string()),
+		ok: boolean(),
+		status: number(),
+		statusText: string()
+	}),
+	done: literal(false)
+});
+const zFetchFulfilledEvent = extend(zBaseFetchTask, {
+	status: literal("fulfilled"),
+	result: any(),
+	done: literal(true)
+});
+const zFetchChunkEvent = extend(zBaseFetchTask, {
+	status: literal("chunk"),
+	payload: _instanceof(Uint8Array),
+	done: literal(false)
+});
+const zFetchChunkEndEvent = extend(zBaseFetchTask, {
+	status: literal("chunk_end"),
+	done: literal(true)
+});
+const zFetchErrorEvent = extend(zBaseFetchTask, {
+	status: union([literal("rejected"), literal("chunk_error")]),
+	error: any(),
+	done: literal(true)
+});
+const zFetchTask = union([
+	zFetchInitialCommand,
+	zFetchGetFullBodyCommand,
+	zFetchRequestChunkCommand,
+	zFetchRespondedEvent,
+	zFetchFulfilledEvent,
+	zFetchChunkEvent,
+	zFetchChunkEndEvent,
+	zFetchErrorEvent
+]);
+async function doFetch(duplex, initialTask) {
+	let bodyReader;
+	try {
+		const response = await fetch(initialTask.url, initialTask.init);
+		bodyReader = response.body?.getReader();
+		const responseHeaders = {};
+		response.headers.forEach((value, key) => responseHeaders[key] = value);
+		duplex.sendData({
+			type: "fetch",
+			taskId: initialTask.taskId,
+			status: "responded",
+			response: {
+				headers: responseHeaders,
+				ok: response.ok,
+				status: response.status,
+				statusText: response.statusText
+			},
+			done: false
+		});
+		while (duplex.currentState === "open") {
+			const commandTask = await waitNextTask(duplex, { timeout: 6e4 });
+			if ("sub_command" in commandTask) switch (commandTask.sub_command) {
+				case "getFullBody":
+					const body = commandTask.format === "json" ? await response.json() : await response.text();
+					duplex.sendData({
+						type: "fetch",
+						taskId: initialTask.taskId,
+						status: "fulfilled",
+						result: body,
+						done: true
+					});
+					return;
+				case "requestChunk":
+					if (!bodyReader) {
+						duplex.sendData({
+							type: "fetch",
+							taskId: initialTask.taskId,
+							status: "chunk_error",
+							error: "Response body is not readable.",
+							done: true
+						});
+						return;
+					}
+					const { done, value } = await bodyReader.read();
+					if (done) {
+						duplex.sendData({
+							type: "fetch",
+							taskId: initialTask.taskId,
+							status: "chunk_end",
+							done: true
+						});
+						return;
+					}
+					duplex.sendData({
+						type: "fetch",
+						taskId: initialTask.taskId,
+						status: "chunk",
+						payload: value,
+						done: false
+					});
+					break;
+			}
+		}
+	} catch (e) {
+		duplex.sendData({
+			type: "fetch",
+			taskId: initialTask.taskId,
+			status: "rejected",
+			error: e instanceof Error ? {
+				message: e.message,
+				stack: e.stack
+			} : e,
+			done: true
+		});
+	} finally {
+		if (bodyReader) bodyReader.cancel().catch(() => {});
+		duplex.close("done");
+	}
+}
+var require_ms = __commonJSMin((exports, module) => {
+	var s = 1e3;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+	module.exports = function(val, options) {
+		options = options || {};
+		var type = typeof val;
+		if (type === "string" && val.length > 0) return parse$1(val);
+		else if (type === "number" && isFinite(val)) return options.long ? fmtLong(val) : fmtShort(val);
+		throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+	};
+	function parse$1(str) {
+		str = String(str);
+		if (str.length > 100) return;
+		var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+		if (!match) return;
+		var n = parseFloat(match[1]);
+		var type = (match[2] || "ms").toLowerCase();
+		switch (type) {
+			case "years":
+			case "year":
+			case "yrs":
+			case "yr":
+			case "y": return n * y;
+			case "weeks":
+			case "week":
+			case "w": return n * w;
+			case "days":
+			case "day":
+			case "d": return n * d;
+			case "hours":
+			case "hour":
+			case "hrs":
+			case "hr":
+			case "h": return n * h;
+			case "minutes":
+			case "minute":
+			case "mins":
+			case "min":
+			case "m": return n * m;
+			case "seconds":
+			case "second":
+			case "secs":
+			case "sec":
+			case "s": return n * s;
+			case "milliseconds":
+			case "millisecond":
+			case "msecs":
+			case "msec":
+			case "ms": return n;
+			default: return void 0;
+		}
+	}
+	function fmtShort(ms) {
+		var msAbs = Math.abs(ms);
+		if (msAbs >= d) return Math.round(ms / d) + "d";
+		if (msAbs >= h) return Math.round(ms / h) + "h";
+		if (msAbs >= m) return Math.round(ms / m) + "m";
+		if (msAbs >= s) return Math.round(ms / s) + "s";
+		return ms + "ms";
+	}
+	function fmtLong(ms) {
+		var msAbs = Math.abs(ms);
+		if (msAbs >= d) return plural(ms, msAbs, d, "day");
+		if (msAbs >= h) return plural(ms, msAbs, h, "hour");
+		if (msAbs >= m) return plural(ms, msAbs, m, "minute");
+		if (msAbs >= s) return plural(ms, msAbs, s, "second");
+		return ms + " ms";
+	}
+	function plural(ms, msAbs, n, name) {
+		var isPlural = msAbs >= n * 1.5;
+		return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+	}
+});
+var require_common = __commonJSMin((exports, module) => {
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = require_ms();
+		createDebug.destroy = destroy;
+		Object.keys(env).forEach((key) => {
+			createDebug[key] = env[key];
+		});
+		createDebug.names = [];
+		createDebug.skips = [];
+		createDebug.formatters = {};
+		function selectColor(namespace) {
+			let hash = 0;
+			for (let i = 0; i < namespace.length; i++) {
+				hash = (hash << 5) - hash + namespace.charCodeAt(i);
+				hash |= 0;
+			}
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+			function debug(...args) {
+				if (!debug.enabled) return;
+				const self = debug;
+				const curr = Number(/* @__PURE__ */ new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+				args[0] = createDebug.coerce(args[0]);
+				if (typeof args[0] !== "string") args.unshift("%O");
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					if (match === "%%") return "%";
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === "function") {
+						const val = args[index];
+						match = formatter.call(self, val);
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+				createDebug.formatArgs.call(self, args);
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
+			}
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend$2;
+			debug.destroy = createDebug.destroy;
+			Object.defineProperty(debug, "enabled", {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) return enableOverride;
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+					return enabledCache;
+				},
+				set: (v) => {
+					enableOverride = v;
+				}
+			});
+			if (typeof createDebug.init === "function") createDebug.init(debug);
+			return debug;
+		}
+		function extend$2(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+			createDebug.names = [];
+			createDebug.skips = [];
+			const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+			for (const ns of split) if (ns[0] === "-") createDebug.skips.push(ns.slice(1));
+			else createDebug.names.push(ns);
+		}
+		function matchesTemplate(search, template) {
+			let searchIndex = 0;
+			let templateIndex = 0;
+			let starIndex = -1;
+			let matchIndex = 0;
+			while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
+				starIndex = templateIndex;
+				matchIndex = searchIndex;
+				templateIndex++;
+			} else {
+				searchIndex++;
+				templateIndex++;
+			}
+			else if (starIndex !== -1) {
+				templateIndex = starIndex + 1;
+				matchIndex++;
+				searchIndex = matchIndex;
+			} else return false;
+			while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
+			return templateIndex === template.length;
+		}
+		function disable() {
+			const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => "-" + namespace)].join(",");
+			createDebug.enable("");
+			return namespaces;
+		}
+		function enabled(name) {
+			for (const skip of createDebug.skips) if (matchesTemplate(name, skip)) return false;
+			for (const ns of createDebug.names) if (matchesTemplate(name, ns)) return true;
+			return false;
+		}
+		function coerce(val) {
+			if (val instanceof Error) return val.stack || val.message;
+			return val;
+		}
+		function destroy() {
+			console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+		}
+		createDebug.enable(createDebug.load());
+		return createDebug;
+	}
+	module.exports = setup;
+});
+var require_browser = __commonJSMin((exports, module) => {
+	exports.formatArgs = formatArgs$1;
+	exports.save = save$1;
+	exports.load = load$1;
+	exports.useColors = useColors$1;
+	exports.storage = localstorage();
+	exports.destroy = (() => {
+		let warned = false;
+		return () => {
+			if (!warned) {
+				warned = true;
+				console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+			}
+		};
+	})();
+	exports.colors = [
+		"#0000CC",
+		"#0000FF",
+		"#0033CC",
+		"#0033FF",
+		"#0066CC",
+		"#0066FF",
+		"#0099CC",
+		"#0099FF",
+		"#00CC00",
+		"#00CC33",
+		"#00CC66",
+		"#00CC99",
+		"#00CCCC",
+		"#00CCFF",
+		"#3300CC",
+		"#3300FF",
+		"#3333CC",
+		"#3333FF",
+		"#3366CC",
+		"#3366FF",
+		"#3399CC",
+		"#3399FF",
+		"#33CC00",
+		"#33CC33",
+		"#33CC66",
+		"#33CC99",
+		"#33CCCC",
+		"#33CCFF",
+		"#6600CC",
+		"#6600FF",
+		"#6633CC",
+		"#6633FF",
+		"#66CC00",
+		"#66CC33",
+		"#9900CC",
+		"#9900FF",
+		"#9933CC",
+		"#9933FF",
+		"#99CC00",
+		"#99CC33",
+		"#CC0000",
+		"#CC0033",
+		"#CC0066",
+		"#CC0099",
+		"#CC00CC",
+		"#CC00FF",
+		"#CC3300",
+		"#CC3333",
+		"#CC3366",
+		"#CC3399",
+		"#CC33CC",
+		"#CC33FF",
+		"#CC6600",
+		"#CC6633",
+		"#CC9900",
+		"#CC9933",
+		"#CCCC00",
+		"#CCCC33",
+		"#FF0000",
+		"#FF0033",
+		"#FF0066",
+		"#FF0099",
+		"#FF00CC",
+		"#FF00FF",
+		"#FF3300",
+		"#FF3333",
+		"#FF3366",
+		"#FF3399",
+		"#FF33CC",
+		"#FF33FF",
+		"#FF6600",
+		"#FF6633",
+		"#FF9900",
+		"#FF9933",
+		"#FFCC00",
+		"#FFCC33"
+	];
+	function useColors$1() {
+		if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) return true;
+		if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
+		let m$1;
+		return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m$1 = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m$1[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+	}
+	function formatArgs$1(args) {
+		args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+		if (!this.useColors) return;
+		const c = "color: " + this.color;
+		args.splice(1, 0, c, "color: inherit");
+		let index = 0;
+		let lastC = 0;
+		args[0].replace(/%[a-zA-Z%]/g, (match) => {
+			if (match === "%%") return;
+			index++;
+			if (match === "%c") lastC = index;
+		});
+		args.splice(lastC, 0, c);
+	}
+	exports.log = console.debug || console.log || (() => {});
+	function save$1(namespaces) {
+		try {
+			if (namespaces) exports.storage.setItem("debug", namespaces);
+			else exports.storage.removeItem("debug");
+		} catch (error) {}
+	}
+	function load$1() {
+		let r;
+		try {
+			r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+		} catch (error) {}
+		if (!r && typeof process !== "undefined" && "env" in process) r = process.env.DEBUG;
+		return r;
+	}
+	function localstorage() {
+		try {
+			return localStorage;
+		} catch (error) {}
+	}
+	module.exports = require_common()(exports);
+	const { formatters: formatters$1 } = module.exports;
+	formatters$1.j = function(v) {
+		try {
+			return JSON.stringify(v);
+		} catch (error) {
+			return "[UnexpectedJSONParseError]: " + error.message;
+		}
+	};
+});
+var require_node = __commonJSMin((exports, module) => {
+	const tty = __require("tty");
+	const util = __require("util");
+	exports.init = init;
+	exports.log = log;
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.destroy = util.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+	exports.colors = [
+		6,
+		2,
+		3,
+		4,
+		5,
+		1
+	];
+	try {
+		const supportsColor = __require("supports-color");
+		if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) exports.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		];
+	} catch (error) {}
+	exports.inspectOpts = Object.keys(process.env).filter((key) => {
+		return /^debug_/i.test(key);
+	}).reduce((obj, key) => {
+		const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+			return k.toUpperCase();
+		});
+		let val = process.env[key];
+		if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
+		else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
+		else if (val === "null") val = null;
+		else val = Number(val);
+		obj[prop] = val;
+		return obj;
+	}, {});
+	function useColors() {
+		return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+	}
+	function formatArgs(args) {
+		const { namespace: name, useColors: useColors$2 } = this;
+		if (useColors$2) {
+			const c = this.color;
+			const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+			const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+			args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+			args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+		} else args[0] = getDate() + name + " " + args[0];
+	}
+	function getDate() {
+		if (exports.inspectOpts.hideDate) return "";
+		return (/* @__PURE__ */ new Date()).toISOString() + " ";
+	}
+	function log(...args) {
+		return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+	}
+	function save(namespaces) {
+		if (namespaces) process.env.DEBUG = namespaces;
+		else delete process.env.DEBUG;
+	}
+	function load() {
+		return process.env.DEBUG;
+	}
+	function init(debug) {
+		debug.inspectOpts = {};
+		const keys = Object.keys(exports.inspectOpts);
+		for (let i = 0; i < keys.length; i++) debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+	}
+	module.exports = require_common()(exports);
+	const { formatters } = module.exports;
+	formatters.o = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+	};
+	formatters.O = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts);
+	};
+});
+var require_src = __commonJSMin((exports, module) => {
+	if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) module.exports = require_browser();
+	else module.exports = require_node();
+});
+var MessageProcessor = class {
+	party;
+	constructor(party) {
+		this.party = party;
+	}
+	process(message, currentState, currentLocalAck) {
+		const actions = [];
+		let newState = currentState;
+		let newLocalAck = currentLocalAck;
+		if (message.from === this.party || message.seq <= currentLocalAck) return {
+			actions,
+			newState,
+			newLocalAck
+		};
+		newLocalAck = message.seq;
+		actions.push({
+			type: "emit",
+			event: message.type,
+			payload: message.payload
+		});
+		switch (currentState) {
+			case "opening":
+				if (this.party === "handler" && message.type === "init") {
+					newState = "open";
+					const initPayload = message.payload;
+					if (initPayload?.initial_payload !== void 0) actions.push({
+						type: "emit",
+						event: "data",
+						payload: initPayload.initial_payload
+					});
+					actions.push({
+						type: "emit",
+						event: "open"
+					});
+					actions.push({
+						type: "send",
+						messageType: "ack",
+						payload: null
+					});
+				} else if (this.party === "initiator" && message.type === "ack") {
+					newState = "open";
+					actions.push({
+						type: "emit",
+						event: "open"
+					});
+				}
+				break;
+			case "open":
+				if (message.type === "fin") {
+					newState = "closing";
+					actions.push({
+						type: "send",
+						messageType: "fin_ack",
+						payload: null
+					});
+					newState = "closed";
+					actions.push({
+						type: "emit",
+						event: "close"
+					});
+				}
+				break;
+			case "closing":
+				if (message.type === "fin_ack" || message.type === "fin") {
+					newState = "closed";
+					actions.push({
+						type: "emit",
+						event: "close"
+					});
+				}
+				break;
+			case "closed": break;
+		}
+		return {
+			actions,
+			newState,
+			newLocalAck
+		};
+	}
+};
+var import_src$1 = __toESM(require_src(), 1);
+var FsDuplex = class {
+	party;
+	json;
+	readerLog;
+	writerLog;
+	processor;
+	state = "opening";
+	localSeq = 0;
+	localAck = 0;
+	log;
+	onOpen = pureEvent();
+	onClose = pureEvent();
+	onError = pureEvent();
+	onData = pureEvent();
+	get currentState() {
+		return this.state;
+	}
+	constructor(party, json, readerLog, writerLog) {
+		this.party = party;
+		this.json = json;
+		this.readerLog = readerLog;
+		this.writerLog = writerLog;
+		this.processor = new MessageProcessor(party);
+		this.log = (0, import_src$1.default)(`jixo:fs-duplex:${party}`);
+		this.log("Created.");
+	}
+	async handleIncomingData() {
+		const lines = await this.readerLog.readNewLines();
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				if (this.state === "closed") return;
+				const message = this.json.parse(line);
+				this.log("Received message: %o", message);
+				const result = this.processor.process(message, this.state, this.localAck);
+				for (const action of result.actions) this._executeAction(action);
+				if (this.state !== result.newState) {
+					this.log("State change: %s -> %s", this.state, result.newState);
+					this.state = result.newState;
+				}
+				this.localAck = result.newLocalAck;
+			} catch (error) {
+				this.onError.emit(error instanceof Error ? error : new Error(String(error)));
+			}
+		}
+	}
+	sendData(payload) {
+		this._sendMessage("data", payload);
+	}
+	init(initial_payload) {
+		if (this.party !== "initiator") throw new Error("Only the initiator can start the connection with init().");
+		this._sendMessage("init", { initial_payload });
+	}
+	close(reason = "done") {
+		this.log("Close called with reason: %s. Current state: %s", reason, this.state);
+		if (this.state === "closing" || this.state === "closed") return;
+		this.state = "closing";
+		this.log("State change: %s", this.state);
+		this._sendMessage("fin", { reason });
+		if (reason === "timeout" || reason === "error") {
+			this.state = "closed";
+			this.log("State change: %s (immediate due to %s)", this.state, reason);
+			this.onClose.emit(reason);
+		}
+	}
+	_sendMessage(type, payload) {
+		if (this.state === "closed") return;
+		if (this.state === "closing" && type !== "fin" && type !== "fin_ack") return;
+		this.localSeq++;
+		const message = {
+			from: this.party,
+			seq: this.localSeq,
+			ack: this.localAck,
+			type,
+			payload
+		};
+		this.log("Sending message: %o", message);
+		const line = this.json.stringify(message);
+		this.writerLog.append(line).catch((err) => this.onError.emit(err));
+	}
+	_executeAction(action) {
+		this.log("Executing action: %o", action);
+		if (action.type === "emit") switch (action.event) {
+			case "open":
+				this.onOpen.emit();
+				break;
+			case "close":
+				this.state = "closed";
+				this.log("State change: %s", this.state);
+				this.onClose.emit("graceful");
+				break;
+			case "data":
+				this.onData.emit(action.payload);
+				break;
+		}
+		else if (action.type === "send") this._sendMessage(action.messageType, action.payload);
+	}
+};
+var BrowserHeartbeatWriter = class {
+	filename;
+	helper;
+	interval;
+	timer = null;
+	constructor(filename, helper, interval = 2e3) {
+		this.filename = filename;
+		this.helper = helper;
+		this.interval = interval;
+	}
+	start() {
+		if (this.timer) return;
+		this._writeHeartbeat();
+		this.timer = setInterval(() => this._writeHeartbeat(), this.interval);
+	}
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+	async _writeHeartbeat() {
+		try {
+			const handle = await this.helper.getFileHandle(this.filename);
+			const writer = await handle.createWritable();
+			await writer.write(String(Date.now()));
+			await writer.close();
+		} catch (error) {
+			console.error("Failed to write heartbeat:", error);
+		}
+	}
+};
+var import_src = __toESM(require_src(), 1);
+const nodeLog = (0, import_src.default)("jixo:fs-duplex:node-log");
+const browserLog = (0, import_src.default)("jixo:fs-duplex:browser-log");
+var BrowserAppendOnlyLog = class {
+	filename;
+	helper;
+	readOffset = 0;
+	lineBuffer = "";
+	constructor(filename, helper) {
+		this.filename = filename;
+		this.helper = helper;
+		browserLog("Constructed for file: %s", this.filename);
+	}
+	async start() {
+		return Promise.resolve();
+	}
+	async stop() {
+		this.readOffset = 0;
+		this.lineBuffer = "";
+		return Promise.resolve();
+	}
+	async append(line) {
+		const handle = await this.helper.getFileHandle(this.filename);
+		const file = await handle.getFile();
+		const writer = await handle.createWritable({ keepExistingData: true });
+		await writer.seek(file.size);
+		await writer.write(line + "\n");
+		await writer.close();
+	}
+	async readNewLines() {
+		try {
+			const handle = await this.helper.getFileHandle(this.filename);
+			const file = await handle.getFile();
+			const slice = file.slice(this.readOffset);
+			const newContent = await slice.text();
+			if (newContent.length === 0) return [];
+			browserLog("Detected %d new chars in %s", newContent.length, this.filename);
+			this.readOffset += slice.size;
+			this.lineBuffer += newContent;
+			const lines = this.lineBuffer.split("\n");
+			if (this.lineBuffer.at(-1) !== "\n") this.lineBuffer = lines.pop() || "";
+			else {
+				this.lineBuffer = "";
+				lines.pop();
+			}
+			return lines.filter((line) => line);
+		} catch (e) {
+			if (e.name === "NotFoundError") return [];
+			browserLog("Error reading file %s: %O", this.filename, e);
+			throw e;
+		}
+	}
+};
+var BrowserFsDuplex = class extends FsDuplex {
+	heartbeatWriter;
+	pollerId = null;
+	isPolling = false;
+	filepaths;
+	helper;
+	constructor(party, json, filenamePrefix, helper) {
+		const prefixBasename = filenamePrefix.split("/").pop();
+		const readFile = party === "handler" ? `${prefixBasename}.in.jsonl` : `${prefixBasename}.out.jsonl`;
+		const writeFile = party === "handler" ? `${prefixBasename}.out.jsonl` : `${prefixBasename}.in.jsonl`;
+		const heartbeatFile = `${prefixBasename}.heartbeat.json`;
+		const readerLog = new BrowserAppendOnlyLog(readFile, helper);
+		const writerLog = new BrowserAppendOnlyLog(writeFile, helper);
+		super(party, json, readerLog, writerLog);
+		this.helper = helper;
+		this.heartbeatWriter = new BrowserHeartbeatWriter(heartbeatFile, helper);
+		this.filepaths = {
+			read: readFile,
+			write: writeFile,
+			heartbeat: heartbeatFile
+		};
+	}
+	async start() {
+		if (this.pollerId) return;
+		await this.readerLog.start();
+		await this.writerLog.start();
+		this.heartbeatWriter.start();
+		this._poll();
+	}
+	async stop() {
+		if (this.pollerId) {
+			clearTimeout(this.pollerId);
+			this.pollerId = null;
+		}
+		this.heartbeatWriter.stop();
+		await this.readerLog.stop();
+		await this.writerLog.stop();
+	}
+	close(reason = "done") {
+		if (this.currentState === "closing" || this.currentState === "closed") return;
+		this.heartbeatWriter.stop();
+		super.close(reason);
+	}
+	async destroy() {
+		this.log("Destroying...");
+		await this.stop();
+		await Promise.all([
+			this.helper.removeFile(this.filepaths.read).catch(() => {}),
+			this.helper.removeFile(this.filepaths.write).catch(() => {}),
+			this.helper.removeFile(this.filepaths.heartbeat).catch(() => {})
+		]);
+		this.log("Destroyed.");
+	}
+	_poll() {
+		if (this.currentState === "closed") return;
+		this.pollerId = setTimeout(async () => {
+			if (!this.pollerId || this.isPolling) return;
+			this.isPolling = true;
+			try {
+				await this.handleIncomingData();
+			} catch (e) {
+				this.onError.emit(e instanceof Error ? e : new Error(String(e)));
+				this.close("error");
+			} finally {
+				this.isPolling = false;
+				if (this.currentState !== "closed") this._poll();
+			}
+		}, 200);
+	}
+};
+var DoubleIndexedKV = class {
+	constructor() {
+		this.keyToValue = /* @__PURE__ */ new Map();
+		this.valueToKey = /* @__PURE__ */ new Map();
+	}
+	set(key, value) {
+		this.keyToValue.set(key, value);
+		this.valueToKey.set(value, key);
+	}
+	getByKey(key) {
+		return this.keyToValue.get(key);
+	}
+	getByValue(value) {
+		return this.valueToKey.get(value);
+	}
+	clear() {
+		this.keyToValue.clear();
+		this.valueToKey.clear();
+	}
+};
+var Registry = class {
+	constructor(generateIdentifier) {
+		this.generateIdentifier = generateIdentifier;
+		this.kv = new DoubleIndexedKV();
+	}
+	register(value, identifier) {
+		if (this.kv.getByValue(value)) return;
+		if (!identifier) identifier = this.generateIdentifier(value);
+		this.kv.set(identifier, value);
+	}
+	clear() {
+		this.kv.clear();
+	}
+	getIdentifier(value) {
+		return this.kv.getByValue(value);
+	}
+	getValue(identifier) {
+		return this.kv.getByKey(identifier);
+	}
+};
+var ClassRegistry = class extends Registry {
+	constructor() {
+		super((c) => c.name);
+		this.classToAllowedProps = /* @__PURE__ */ new Map();
+	}
+	register(value, options) {
+		if (typeof options === "object") {
+			if (options.allowProps) this.classToAllowedProps.set(value, options.allowProps);
+			super.register(value, options.identifier);
+		} else super.register(value, options);
+	}
+	getAllowedProps(value) {
+		return this.classToAllowedProps.get(value);
+	}
+};
+function valuesOfObj(record$1) {
+	if ("values" in Object) return Object.values(record$1);
+	const values = [];
+	for (const key in record$1) if (record$1.hasOwnProperty(key)) values.push(record$1[key]);
+	return values;
+}
+function find(record$1, predicate) {
+	const values = valuesOfObj(record$1);
+	if ("find" in values) return values.find(predicate);
+	const valuesNotNever = values;
+	for (let i = 0; i < valuesNotNever.length; i++) {
+		const value = valuesNotNever[i];
+		if (predicate(value)) return value;
+	}
+	return void 0;
+}
+function forEach(record$1, run) {
+	Object.entries(record$1).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+	return arr.indexOf(value) !== -1;
+}
+function findArr(record$1, predicate) {
+	for (let i = 0; i < record$1.length; i++) {
+		const value = record$1[i];
+		if (predicate(value)) return value;
+	}
+	return void 0;
+}
+var CustomTransformerRegistry = class {
+	constructor() {
+		this.transfomers = {};
+	}
+	register(transformer) {
+		this.transfomers[transformer.name] = transformer;
+	}
+	findApplicable(v) {
+		return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+	}
+	findByName(name) {
+		return this.transfomers[name];
+	}
+};
+const getType$1 = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+const isUndefined$1 = (payload) => typeof payload === "undefined";
+const isNull$1 = (payload) => payload === null;
+const isPlainObject$1 = (payload) => {
+	if (typeof payload !== "object" || payload === null) return false;
+	if (payload === Object.prototype) return false;
+	if (Object.getPrototypeOf(payload) === null) return true;
+	return Object.getPrototypeOf(payload) === Object.prototype;
+};
+const isEmptyObject = (payload) => isPlainObject$1(payload) && Object.keys(payload).length === 0;
+const isArray$1 = (payload) => Array.isArray(payload);
+const isString = (payload) => typeof payload === "string";
+const isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+const isBoolean = (payload) => typeof payload === "boolean";
+const isRegExp = (payload) => payload instanceof RegExp;
+const isMap = (payload) => payload instanceof Map;
+const isSet = (payload) => payload instanceof Set;
+const isSymbol = (payload) => getType$1(payload) === "Symbol";
+const isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+const isError = (payload) => payload instanceof Error;
+const isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+const isPrimitive = (payload) => isBoolean(payload) || isNull$1(payload) || isUndefined$1(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+const isBigint = (payload) => typeof payload === "bigint";
+const isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+const isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+const isURL = (payload) => payload instanceof URL;
+const escapeKey = (key) => key.replace(/\./g, "\\.");
+const stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+const parsePath = (string$2) => {
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < string$2.length; i++) {
+		let char = string$2.charAt(i);
+		const isEscapedDot = char === "\\" && string$2.charAt(i + 1) === ".";
+		if (isEscapedDot) {
+			segment += ".";
+			i++;
+			continue;
+		}
+		const isEndOfSegment = char === ".";
+		if (isEndOfSegment) {
+			result.push(segment);
+			segment = "";
+			continue;
+		}
+		segment += char;
+	}
+	const lastSegment = segment;
+	result.push(lastSegment);
+	return result;
+};
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+	return {
+		isApplicable,
+		annotation,
+		transform,
+		untransform
+	};
+}
+const simpleRules = [
+	simpleTransformation(isUndefined$1, "undefined", () => null, () => void 0),
+	simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+		if (typeof BigInt !== "undefined") return BigInt(v);
+		console.error("Please add a BigInt polyfill.");
+		return v;
+	}),
+	simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+	simpleTransformation(isError, "Error", (v, superJson) => {
+		const baseError = {
+			name: v.name,
+			message: v.message
+		};
+		superJson.allowedErrorProps.forEach((prop) => {
+			baseError[prop] = v[prop];
+		});
+		return baseError;
+	}, (v, superJson) => {
+		const e = new Error(v.message);
+		e.name = v.name;
+		e.stack = v.stack;
+		superJson.allowedErrorProps.forEach((prop) => {
+			e[prop] = v[prop];
+		});
+		return e;
+	}),
+	simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+		const body = regex.slice(1, regex.lastIndexOf("/"));
+		const flags = regex.slice(regex.lastIndexOf("/") + 1);
+		return new RegExp(body, flags);
+	}),
+	simpleTransformation(isSet, "set", (v) => [...v.values()], (v) => new Set(v)),
+	simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+	simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+		if (isNaNValue(v)) return "NaN";
+		if (v > 0) return "Infinity";
+		else return "-Infinity";
+	}, Number),
+	simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+		return "-0";
+	}, Number),
+	simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+	return {
+		isApplicable,
+		annotation,
+		transform,
+		untransform
+	};
+}
+const symbolRule = compositeTransformation((s$1, superJson) => {
+	if (isSymbol(s$1)) {
+		const isRegistered = !!superJson.symbolRegistry.getIdentifier(s$1);
+		return isRegistered;
+	}
+	return false;
+}, (s$1, superJson) => {
+	const identifier = superJson.symbolRegistry.getIdentifier(s$1);
+	return ["symbol", identifier];
+}, (v) => v.description, (_, a, superJson) => {
+	const value = superJson.symbolRegistry.getValue(a[1]);
+	if (!value) throw new Error("Trying to deserialize unknown symbol");
+	return value;
+});
+const constructorToName = [
+	Int8Array,
+	Uint8Array,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	Uint8ClampedArray
+].reduce((obj, ctor) => {
+	obj[ctor.name] = ctor;
+	return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+	const ctor = constructorToName[a[1]];
+	if (!ctor) throw new Error("Trying to deserialize unknown typed array");
+	return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+	if (potentialClass?.constructor) {
+		const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+		return isRegistered;
+	}
+	return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+	const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+	return ["class", identifier];
+}, (clazz, superJson) => {
+	const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+	if (!allowedProps) return { ...clazz };
+	const result = {};
+	allowedProps.forEach((prop) => {
+		result[prop] = clazz[prop];
+	});
+	return result;
+}, (v, a, superJson) => {
+	const clazz = superJson.classRegistry.getValue(a[1]);
+	if (!clazz) throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+	return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+	return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+	const transformer = superJson.customTransformerRegistry.findApplicable(value);
+	return ["custom", transformer.name];
+}, (value, superJson) => {
+	const transformer = superJson.customTransformerRegistry.findApplicable(value);
+	return transformer.serialize(value);
+}, (v, a, superJson) => {
+	const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+	if (!transformer) throw new Error("Trying to deserialize unknown custom value");
+	return transformer.deserialize(v);
+});
+const compositeRules = [
+	classRule,
+	symbolRule,
+	customRule,
+	typedArrayRule
+];
+const transformValue = (value, superJson) => {
+	const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+	if (applicableCompositeRule) return {
+		value: applicableCompositeRule.transform(value, superJson),
+		type: applicableCompositeRule.annotation(value, superJson)
+	};
+	const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+	if (applicableSimpleRule) return {
+		value: applicableSimpleRule.transform(value, superJson),
+		type: applicableSimpleRule.annotation
+	};
+	return void 0;
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+	simpleRulesByAnnotation[rule.annotation] = rule;
+});
+const untransformValue = (json, type, superJson) => {
+	if (isArray$1(type)) switch (type[0]) {
+		case "symbol": return symbolRule.untransform(json, type, superJson);
+		case "class": return classRule.untransform(json, type, superJson);
+		case "custom": return customRule.untransform(json, type, superJson);
+		case "typed-array": return typedArrayRule.untransform(json, type, superJson);
+		default: throw new Error("Unknown transformation: " + type);
+	}
+	else {
+		const transformation = simpleRulesByAnnotation[type];
+		if (!transformation) throw new Error("Unknown transformation: " + type);
+		return transformation.untransform(json, superJson);
+	}
+};
+const getNthKey = (value, n) => {
+	if (n > value.size) throw new Error("index out of bounds");
+	const keys = value.keys();
+	while (n > 0) {
+		keys.next();
+		n--;
+	}
+	return keys.next().value;
+};
+function validatePath(path) {
+	if (includes(path, "__proto__")) throw new Error("__proto__ is not allowed as a property");
+	if (includes(path, "prototype")) throw new Error("prototype is not allowed as a property");
+	if (includes(path, "constructor")) throw new Error("constructor is not allowed as a property");
+}
+const getDeep = (object$1, path) => {
+	validatePath(path);
+	for (let i = 0; i < path.length; i++) {
+		const key = path[i];
+		if (isSet(object$1)) object$1 = getNthKey(object$1, +key);
+		else if (isMap(object$1)) {
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(object$1, row);
+			switch (type) {
+				case "key":
+					object$1 = keyOfRow;
+					break;
+				case "value":
+					object$1 = object$1.get(keyOfRow);
+					break;
+			}
+		} else object$1 = object$1[key];
+	}
+	return object$1;
+};
+const setDeep = (object$1, path, mapper) => {
+	validatePath(path);
+	if (path.length === 0) return mapper(object$1);
+	let parent = object$1;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		if (isArray$1(parent)) {
+			const index = +key;
+			parent = parent[index];
+		} else if (isPlainObject$1(parent)) parent = parent[key];
+		else if (isSet(parent)) {
+			const row = +key;
+			parent = getNthKey(parent, row);
+		} else if (isMap(parent)) {
+			const isEnd = i === path.length - 2;
+			if (isEnd) break;
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(parent, row);
+			switch (type) {
+				case "key":
+					parent = keyOfRow;
+					break;
+				case "value":
+					parent = parent.get(keyOfRow);
+					break;
+			}
+		}
+	}
+	const lastKey = path[path.length - 1];
+	if (isArray$1(parent)) parent[+lastKey] = mapper(parent[+lastKey]);
+	else if (isPlainObject$1(parent)) parent[lastKey] = mapper(parent[lastKey]);
+	if (isSet(parent)) {
+		const oldValue = getNthKey(parent, +lastKey);
+		const newValue = mapper(oldValue);
+		if (oldValue !== newValue) {
+			parent.delete(oldValue);
+			parent.add(newValue);
+		}
+	}
+	if (isMap(parent)) {
+		const row = +path[path.length - 2];
+		const keyToRow = getNthKey(parent, row);
+		const type = +lastKey === 0 ? "key" : "value";
+		switch (type) {
+			case "key": {
+				const newKey = mapper(keyToRow);
+				parent.set(newKey, parent.get(keyToRow));
+				if (newKey !== keyToRow) parent.delete(keyToRow);
+				break;
+			}
+			case "value": {
+				parent.set(keyToRow, mapper(parent.get(keyToRow)));
+				break;
+			}
+		}
+	}
+	return object$1;
+};
+function traverse(tree, walker$1, origin = []) {
+	if (!tree) return;
+	if (!isArray$1(tree)) {
+		forEach(tree, (subtree, key) => traverse(subtree, walker$1, [...origin, ...parsePath(key)]));
+		return;
+	}
+	const [nodeValue, children] = tree;
+	if (children) forEach(children, (child, key) => {
+		traverse(child, walker$1, [...origin, ...parsePath(key)]);
+	});
+	walker$1(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, superJson) {
+	traverse(annotations, (type, path) => {
+		plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+	});
+	return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations) {
+	function apply(identicalPaths, path) {
+		const object$1 = getDeep(plain, parsePath(path));
+		identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
+			plain = setDeep(plain, identicalObjectPath, () => object$1);
+		});
+	}
+	if (isArray$1(annotations)) {
+		const [root, other] = annotations;
+		root.forEach((identicalPath) => {
+			plain = setDeep(plain, parsePath(identicalPath), () => plain);
+		});
+		if (other) forEach(other, apply);
+	} else forEach(annotations, apply);
+	return plain;
+}
+const isDeep = (object$1, superJson) => isPlainObject$1(object$1) || isArray$1(object$1) || isMap(object$1) || isSet(object$1) || isInstanceOfRegisteredClass(object$1, superJson);
+function addIdentity(object$1, path, identities) {
+	const existingSet = identities.get(object$1);
+	if (existingSet) existingSet.push(path);
+	else identities.set(object$1, [path]);
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+	const result = {};
+	let rootEqualityPaths = void 0;
+	identitites.forEach((paths) => {
+		if (paths.length <= 1) return;
+		if (!dedupe) paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+		const [representativePath, ...identicalPaths] = paths;
+		if (representativePath.length === 0) rootEqualityPaths = identicalPaths.map(stringifyPath);
+		else result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+	});
+	if (rootEqualityPaths) if (isEmptyObject(result)) return [rootEqualityPaths];
+	else return [rootEqualityPaths, result];
+	else return isEmptyObject(result) ? void 0 : result;
+}
+const walker = (object$1, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+	const primitive = isPrimitive(object$1);
+	if (!primitive) {
+		addIdentity(object$1, path, identities);
+		const seen = seenObjects.get(object$1);
+		if (seen) return dedupe ? { transformedValue: null } : seen;
+	}
+	if (!isDeep(object$1, superJson)) {
+		const transformed$1 = transformValue(object$1, superJson);
+		const result$1 = transformed$1 ? {
+			transformedValue: transformed$1.value,
+			annotations: [transformed$1.type]
+		} : { transformedValue: object$1 };
+		if (!primitive) seenObjects.set(object$1, result$1);
+		return result$1;
+	}
+	if (includes(objectsInThisPath, object$1)) return { transformedValue: null };
+	const transformationResult = transformValue(object$1, superJson);
+	const transformed = transformationResult?.value ?? object$1;
+	const transformedValue = isArray$1(transformed) ? [] : {};
+	const innerAnnotations = {};
+	forEach(transformed, (value, index) => {
+		if (index === "__proto__" || index === "constructor" || index === "prototype") throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+		const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object$1], seenObjects);
+		transformedValue[index] = recursiveResult.transformedValue;
+		if (isArray$1(recursiveResult.annotations)) innerAnnotations[index] = recursiveResult.annotations;
+		else if (isPlainObject$1(recursiveResult.annotations)) forEach(recursiveResult.annotations, (tree, key) => {
+			innerAnnotations[escapeKey(index) + "." + key] = tree;
+		});
+	});
+	const result = isEmptyObject(innerAnnotations) ? {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type] : void 0
+	} : {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+	};
+	if (!primitive) seenObjects.set(object$1, result);
+	return result;
+};
+function getType(payload) {
+	return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isArray(payload) {
+	return getType(payload) === "Array";
+}
+function isPlainObject(payload) {
+	if (getType(payload) !== "Object") return false;
+	const prototype = Object.getPrototypeOf(payload);
+	return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+function isNull(payload) {
+	return getType(payload) === "Null";
+}
+function isOneOf(a, b, c, d$1, e) {
+	return (value) => a(value) || b(value) || !!c && c(value) || !!d$1 && d$1(value) || !!e && e(value);
+}
+function isUndefined(payload) {
+	return getType(payload) === "Undefined";
+}
+const isNullOrUndefined = isOneOf(isNull, isUndefined);
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+	const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+	if (propType === "enumerable") carry[key] = newVal;
+	if (includeNonenumerable && propType === "nonenumerable") Object.defineProperty(carry, key, {
+		value: newVal,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+}
+function copy(target, options = {}) {
+	if (isArray(target)) return target.map((item) => copy(item, options));
+	if (!isPlainObject(target)) return target;
+	const props = Object.getOwnPropertyNames(target);
+	const symbols = Object.getOwnPropertySymbols(target);
+	return [...props, ...symbols].reduce((carry, key) => {
+		if (isArray(options.props) && !options.props.includes(key)) return carry;
+		const val = target[key];
+		const newVal = copy(val, options);
+		assignProp(carry, key, newVal, target, options.nonenumerable);
+		return carry;
+	}, {});
+}
+var SuperJSON = class {
+	constructor({ dedupe = false } = {}) {
+		this.classRegistry = new ClassRegistry();
+		this.symbolRegistry = new Registry((s$1) => s$1.description ?? "");
+		this.customTransformerRegistry = new CustomTransformerRegistry();
+		this.allowedErrorProps = [];
+		this.dedupe = dedupe;
+	}
+	serialize(object$1) {
+		const identities = /* @__PURE__ */ new Map();
+		const output = walker(object$1, identities, this, this.dedupe);
+		const res = { json: output.transformedValue };
+		if (output.annotations) res.meta = {
+			...res.meta,
+			values: output.annotations
+		};
+		const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+		if (equalityAnnotations) res.meta = {
+			...res.meta,
+			referentialEqualities: equalityAnnotations
+		};
+		return res;
+	}
+	deserialize(payload) {
+		const { json, meta } = payload;
+		let result = copy(json);
+		if (meta?.values) result = applyValueAnnotations(result, meta.values, this);
+		if (meta?.referentialEqualities) result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+		return result;
+	}
+	stringify(object$1) {
+		return JSON.stringify(this.serialize(object$1));
+	}
+	parse(string$2) {
+		return this.deserialize(JSON.parse(string$2));
+	}
+	registerClass(v, options) {
+		this.classRegistry.register(v, options);
+	}
+	registerSymbol(v, identifier) {
+		this.symbolRegistry.register(v, identifier);
+	}
+	registerCustom(transformer, name) {
+		this.customTransformerRegistry.register({
+			name,
+			...transformer
+		});
+	}
+	allowErrorProps(...props) {
+		this.allowedErrorProps.push(...props);
+	}
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+const serialize = SuperJSON.serialize;
+const deserialize = SuperJSON.deserialize;
+const stringify = SuperJSON.stringify;
+const parse = SuperJSON.parse;
+const registerClass = SuperJSON.registerClass;
+const registerCustom = SuperJSON.registerCustom;
+const registerSymbol = SuperJSON.registerSymbol;
+const allowErrorProps = SuperJSON.allowErrorProps;
+const superjsonInstance = new SuperJSON();
+superjsonInstance.registerCustom({
+	isApplicable: typeof SharedArrayBuffer !== "undefined" ? (v) => v instanceof ArrayBuffer || v instanceof SharedArrayBuffer : (v) => v instanceof ArrayBuffer,
+	serialize: (v) => binary_to_base64_string(new Uint8Array(v)),
+	deserialize: (v) => str_to_base64_binary(v).buffer
+}, "ArrayBuffer");
+superjsonInstance.registerCustom({
+	isApplicable: (v) => v instanceof DataView,
+	serialize: (v) => {
+		return binary_to_base64_string(new Uint8Array(v.buffer, v.byteOffset, v.byteLength));
+	},
+	deserialize: (v) => {
+		const buf = str_to_base64_binary(v);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+	}
+}, "DataView");
+superjsonInstance.registerCustom({
+	isApplicable: (v) => v instanceof Date,
+	serialize: (v) => {
+		const time = +v;
+		return Number.isNaN(time) ? null : time;
+	},
+	deserialize: (v) => /* @__PURE__ */ new Date(v == null ? NaN : +v)
+}, "Date");
+[
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+].forEach((TypedArrayCtorName) => {
+	const TypedArrayCtor = globalThis[TypedArrayCtorName];
+	if (typeof TypedArrayCtor !== "function") return;
+	superjsonInstance.registerCustom({
+		isApplicable: (v) => {
+			return ArrayBuffer.isView(v) && Object.getPrototypeOf(v) === TypedArrayCtor.prototype;
+		},
+		serialize: (v) => {
+			return `${v.byteLength},${binary_to_base64_string(v instanceof Uint8Array ? v : new Uint8Array(v.buffer, v.byteOffset, v.byteLength))}`;
+		},
+		deserialize: (v) => {
+			const splitIndex = v.indexOf(",");
+			const len = +v.slice(splitIndex);
+			const base64 = v.slice(splitIndex + 1);
+			if (TypedArrayCtor === Uint8Array) return str_to_base64_binary(base64);
+			const res = new TypedArrayCtor(len);
+			const u8a = new Uint8Array(res.buffer);
+			u8a.set(str_to_base64_binary(base64));
+			return res;
+		}
+	}, TypedArrayCtorName);
+});
+const superjson = superjsonInstance;
+const zModels = object({
+	object: string(),
+	data: array(object({
+		id: string(),
+		object: string(),
+		created: number(),
+		owned_by: string(),
+		active: boolean(),
+		context_window: number(),
+		public_apps: _null(),
+		max_completion_tokens: number(),
+		features: object({
+			chat: boolean(),
+			tools: boolean(),
+			json_mode: boolean(),
+			max_input_images: number(),
+			transcription: boolean(),
+			audio_translation: boolean(),
+			is_batch_enabled: boolean()
+		}),
+		metadata: looseObject({ display_name: string() }),
+		terms_url: nullable(string()),
+		is_terms_required: boolean(),
+		is_terms_accepted: nullable(boolean())
+	}))
+});
+const zSession = object({
+	time: number(),
+	headers: record(string(), string()),
+	models: zModels.shape.data
+});
+const zTask = union([_lazy(() => zEvalTask), _lazy(() => zFetchTask)]);
+const getWindowId = /* @__PURE__ */ func_remember(() => {
+	for (let i = 0; i < sessionStorage.length; i++) {
+		const key = sessionStorage.key(i);
+		if (key && key.endsWith("_window_id")) try {
+			return JSON.parse(sessionStorage.getItem(key));
+		} catch {}
+	}
+	const windowId = crypto.randomUUID();
+	sessionStorage.setItem(`groq_2_jixo_window_id`, windowId);
+	return windowId;
+});
+let capturedDataPromise;
+async function captureAndHold() {
+	if (capturedDataPromise) return capturedDataPromise;
+	capturedDataPromise = new Promise(async (resolve, reject) => {
+		const originalFetch = window.fetch;
+		const headers = {};
+		let resolved = false;
+		window.fetch = function(...args) {
+			const request = new Request(...args);
+			const auth = request.headers.get("Authorization");
+			const org = request.headers.get("groq-organization");
+			if (auth && org) {
+				Object.assign(headers, {
+					Authorization: auth,
+					"groq-organization": org
+				});
+				resolved = true;
+			}
+			return originalFetch.call(this, request);
+		};
+		const triggerFetch = async () => {
+			while (!resolved) {
+				document.dispatchEvent(new Event("visibilitychange"));
+				await delay(500);
+			}
+		};
+		console.log(`初始化中，通常5秒内能完成...`);
+		await triggerFetch();
+		while (!resolved) await delay(100);
+		try {
+			const modelsResponse = await originalFetch("https://api.groq.com/internal/v1/models", { headers });
+			const modelsJson = await modelsResponse.json();
+			const models = zModels.parse(modelsJson).data;
+			resolve({
+				headers,
+				models
+			});
+		} catch (error) {
+			reject(error);
+		}
+	});
+	return capturedDataPromise;
+}
+const initializeSession = /* @__PURE__ */ func_remember(async () => {
+	try {
+		const { headers, models } = await captureAndHold();
+		const fs = await getEasyFs();
+		const windowId = getWindowId();
+		setInterval(() => {
+			const session = {
+				time: Date.now(),
+				headers,
+				models
+			};
+			fs.writeFile(`${windowId}.groq-session.json`, JSON.stringify(session));
+		}, 1e3);
+		console.log("Session initialized and heartbeat started.");
+	} catch (error) {
+		initializeSession.reset();
+		console.error("Failed to initialize session:", error);
+	}
+});
+const taskHandlers = {
+	eval: doEval,
+	fetch: doFetch
+};
+var FsHelper = class {
+	constructor(fs) {
+		this.fs = fs;
+	}
+	async getFileHandle(filename) {
+		const dirHandle = this.fs._dirHandle;
+		if (!dirHandle) throw new Error("EasyFS is not initialized with a DirectoryHandle.");
+		return dirHandle.getFileHandle(filename, { create: true });
+	}
+	async removeFile(filename) {
+		const dirHandle = this.fs._dirHandle;
+		if (!dirHandle) throw new Error("EasyFS is not initialized with a DirectoryHandle.");
+		await dirHandle.removeEntry(filename);
+	}
+};
+const active_tasks = /* @__PURE__ */ new Set();
+async function handleTask(fs, filenamePrefix, initialContent) {
+	const initialTask = superjson.parse(initialContent);
+	const handler = taskHandlers[initialTask.type];
+	if (!handler) {
+		console.warn(`No handler for task type: ${initialTask.type}`);
+		active_tasks.delete(filenamePrefix);
+		await fs.rm(`${filenamePrefix}.in.jsonl`).catch(() => {});
+		return;
+	}
+	const helper = new FsHelper(fs);
+	const duplex = new BrowserFsDuplex("handler", superjson, filenamePrefix, helper);
+	try {
+		console.log(`Processing task for prefix: ${filenamePrefix}`);
+		duplex.onClose.on((reason) => {
+			console.log(`Connection for ${filenamePrefix} closed. Reason: ${reason}. Cleaning up from active_tasks.`);
+			active_tasks.delete(filenamePrefix);
+		});
+		duplex.onError.on((err) => {
+			console.error(`Error on duplex for ${filenamePrefix}:`, err);
+		});
+		await duplex.start();
+		await handler(duplex, initialTask);
+	} catch (e) {
+		console.error(`Error processing task ${filenamePrefix}:`, e);
+		if (duplex.currentState !== "closed") duplex.close("error");
+	} finally {
+		await duplex.destroy();
+		console.log(`Task ${filenamePrefix} finished and resources destroyed.`);
+	}
+}
+const processTasks = async () => {
+	const fs = await getEasyFs();
+	const windowId = getWindowId();
+	const taskFiles = (await fs.readdir("")).filter((name) => name.startsWith(`${windowId}.`) && name.endsWith(".groq-task.in.jsonl"));
+	for (const filename of taskFiles) {
+		const filenamePrefix = filename.replace(/\.in\.jsonl$/, "");
+		if (active_tasks.has(filenamePrefix)) continue;
+		active_tasks.add(filenamePrefix);
+		const content = await fs.readFileText(filename);
+		const firstLine = content.split("\n")[0];
+		if (firstLine) handleTask(fs, filenamePrefix, firstLine);
+		else {
+			active_tasks.delete(filenamePrefix);
+			fs.rm(filename).catch(() => {});
+		}
+	}
+};
+const sync = async (fps = 1) => {
+	await initializeSession();
+	console.log("%c会话初始化成功！", styles.success);
+	while (true) {
+		await processTasks();
+		await delay(1e3 / fps);
+	}
+};
+(async () => {
+	const aborted$1 = await prepareDirHandle().then(() => false, (e) => {
+		if (e instanceof Error && e.name === "AbortError") return true;
+	});
+	if (aborted$1) {
+		console.warn("用户取消了脚本运行");
+		return;
+	}
+	sync();
+	keepWeakup();
+	Object.assign(window, { extractChat });
+})();