@visactor/vseed 0.0.17 → 0.0.18

package/dist/umd/999.js

@@ -0,0 +1,3574 @@
+"use strict";
+(globalThis["webpackChunkVSeed"] = globalThis["webpackChunkVSeed"] || []).push([
+    [
+        "999"
+    ],
+    {
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-2T7K3PFL.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>i
+            });
+            var _chunk_WIMGWYZL_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-WIMGWYZL.js");
+            function i(...e) {
+                return (0, _chunk_WIMGWYZL_js__WEBPACK_IMPORTED_MODULE_0__.a)(o, e);
+            }
+            function o(e, s) {
+                let r = {};
+                for (let n of s)n in e && (r[n] = e[n]);
+                return r;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-6GTAPB47.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>e
+            });
+            function e(r) {
+                return "number" == typeof r && !Number.isNaN(r);
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-BCBB46UE.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>d
+            });
+            var _chunk_WIMGWYZL_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-WIMGWYZL.js");
+            function d(...n) {
+                return (0, _chunk_WIMGWYZL_js__WEBPACK_IMPORTED_MODULE_0__.a)(u, n);
+            }
+            function u(n, o = [], t = []) {
+                if ("function" == typeof n) return n;
+                if ("object" != typeof n || null === n) return structuredClone(n);
+                let r = Object.getPrototypeOf(n);
+                if (!Array.isArray(n) && null !== r && r !== Object.prototype) return structuredClone(n);
+                let e = o.indexOf(n);
+                return -1 !== e ? t[e] : (o.push(n), Array.isArray(n) ? p(n, o, t) : i(n, o, t));
+            }
+            function i(n, o, t) {
+                let r = {};
+                t.push(r);
+                for (let [e, c] of Object.entries(n))r[e] = u(c, o, t);
+                return r;
+            }
+            function p(n, o, t) {
+                let r = [];
+                t.push(r);
+                for (let [e, c] of n.entries())r[e] = u(c, o, t);
+                return r;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-BO3LQZNF.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>o
+            });
+            function o(r) {
+                return Array.isArray(r);
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-HVPVHFDT.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>i
+            });
+            var _chunk_WIMGWYZL_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-WIMGWYZL.js");
+            function i(...e) {
+                return (0, _chunk_WIMGWYZL_js__WEBPACK_IMPORTED_MODULE_0__.a)(p, e);
+            }
+            var p = (e, d)=>{
+                let r = Object.create(null);
+                for(let n = 0; n < e.length; n++){
+                    let t = e[n], y = d(t, n, e);
+                    if (void 0 !== y) {
+                        let o = r[y];
+                        void 0 === o ? r[y] = [
+                            t
+                        ] : o.push(t);
+                    }
+                }
+                return Object.setPrototypeOf(r, Object.prototype), r;
+            };
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-JK3VNB42.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>n
+            });
+            function n(e) {
+                return null == e;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-KI5X74E2.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>y
+            });
+            var chunk_WIMGWYZL = __webpack_require__("../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-WIMGWYZL.js");
+            function i(...e) {
+                return (0, chunk_WIMGWYZL.a)(n, e);
+            }
+            var n = (e, r)=>e.length >= r;
+            function y(...t) {
+                return (0, chunk_WIMGWYZL.a)(f, t);
+            }
+            function f(t, e) {
+                if (!i(e, 1)) return {
+                    ...t
+                };
+                if (!i(e, 2)) {
+                    let { [e[0]]: r, ...m } = t;
+                    return m;
+                }
+                let o = {
+                    ...t
+                };
+                for (let r of e)delete o[r];
+                return o;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-PDQFB3TV.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>D
+            });
+            function chunk_BZNENX2T_r(o) {
+                if ("object" != typeof o || null === o) return !1;
+                let e = Object.getPrototypeOf(o);
+                return null === e || e === Object.prototype;
+            }
+            var chunk_WIMGWYZL = __webpack_require__("../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-WIMGWYZL.js");
+            function D(...e) {
+                return (0, chunk_WIMGWYZL.a)(s, e);
+            }
+            function s(e, t) {
+                let r = {
+                    ...e,
+                    ...t
+                };
+                for(let n in t){
+                    if (!(n in e)) continue;
+                    let { [n]: i } = e;
+                    if (!chunk_BZNENX2T_r(i)) continue;
+                    let { [n]: c } = t;
+                    chunk_BZNENX2T_r(c) && (r[n] = s(i, c));
+                }
+                return r;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-QJLMYOTX.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>chunk_QJLMYOTX_i
+            });
+            var chunk_ANXBDSUI_s = {
+                done: !1,
+                hasNext: !1
+            };
+            function C(t, ...o) {
+                let n = t, u = o.map((e)=>"lazy" in e ? y(e) : void 0), p = 0;
+                for(; p < o.length;){
+                    if (void 0 === u[p] || !B(n)) {
+                        let i = o[p];
+                        n = i(n), p += 1;
+                        continue;
+                    }
+                    let r = [];
+                    for(let i = p; i < o.length; i++){
+                        let l = u[i];
+                        if (void 0 === l || (r.push(l), l.isSingle)) break;
+                    }
+                    let a = [];
+                    for (let i of n)if (f(i, a, r)) break;
+                    let { isSingle: s } = r.at(-1);
+                    n = s ? a[0] : a, p += r.length;
+                }
+                return n;
+            }
+            function f(t, o, n) {
+                if (0 === n.length) return o.push(t), !1;
+                let u = t, p = chunk_ANXBDSUI_s, e = !1;
+                for (let [r, a] of n.entries()){
+                    let { index: s, items: i } = a;
+                    if (i.push(u), p = a(u, s, i), a.index += 1, p.hasNext) {
+                        if (p.hasMany ?? !1) {
+                            for (let l of p.next)if (f(l, o, n.slice(r + 1))) return !0;
+                            return e;
+                        }
+                        u = p.next;
+                    }
+                    if (!p.hasNext) break;
+                    p.done && (e = !0);
+                }
+                return p.hasNext && o.push(u), e;
+            }
+            function y(t) {
+                let { lazy: o, lazyArgs: n } = t, u = o(...n);
+                return Object.assign(u, {
+                    isSingle: o.single ?? !1,
+                    index: 0,
+                    items: []
+                });
+            }
+            function B(t) {
+                return "string" == typeof t || "object" == typeof t && null !== t && Symbol.iterator in t;
+            }
+            function chunk_LFJW7BOT_y(t, i) {
+                let a = i.length - t.length;
+                if (1 === a) {
+                    let [n, ...r] = i;
+                    return C(n, {
+                        lazy: t,
+                        lazyArgs: r
+                    });
+                }
+                if (0 === a) {
+                    let n = {
+                        lazy: t,
+                        lazyArgs: i
+                    };
+                    return Object.assign((e)=>C(e, n), n);
+                }
+                throw new Error("Wrong number of arguments");
+            }
+            function chunk_QJLMYOTX_i(...e) {
+                return chunk_LFJW7BOT_y(chunk_QJLMYOTX_a, e);
+            }
+            function chunk_QJLMYOTX_a() {
+                let e = new Set;
+                return (t)=>e.has(t) ? chunk_ANXBDSUI_s : (e.add(t), {
+                        done: !1,
+                        hasNext: !0,
+                        next: t
+                    });
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-SFZGYJFI.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>t
+            });
+            function t(r) {
+                return "string" == typeof r;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-VCYTMP4D.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>n
+            });
+            function n(e) {
+                return void 0 === e ? !0 : "string" == typeof e || Array.isArray(e) ? 0 === e.length : 0 === Object.keys(e).length;
+            }
+        },
+        "../../node_modules/.pnpm/remeda@2.28.0/node_modules/remeda/dist/chunk-WIMGWYZL.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                a: ()=>chunk_WIMGWYZL_u
+            });
+            function u(o, n, a) {
+                let t = (r)=>o(r, ...n);
+                return void 0 === a ? t : Object.assign(t, {
+                    lazy: a,
+                    lazyArgs: n
+                });
+            }
+            function chunk_WIMGWYZL_u(r, n, o) {
+                let a = r.length - n.length;
+                if (0 === a) return r(...n);
+                if (1 === a) return u(r, n, o);
+                throw new Error("Wrong number of arguments");
+            }
+        },
+        "../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/classic/schemas.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.d(__webpack_exports__, {
+                EB: ()=>ZodStringFormat,
+                k5: ()=>schemas_enum,
+                gM: ()=>discriminatedUnion,
+                bz: ()=>any,
+                g1: ()=>record,
+                zM: ()=>schemas_boolean,
+                ai: ()=>schemas_number,
+                Vx: ()=>schemas_undefined,
+                Ik: ()=>schemas_object,
+                YO: ()=>schemas_array,
+                Yj: ()=>schemas_string,
+                eu: ()=>literal,
+                KC: ()=>union
+            });
+            Object.freeze({
+                status: "aborted"
+            });
+            function $constructor(name, initializer, params) {
+                function init(inst, def) {
+                    var _a;
+                    Object.defineProperty(inst, "_zod", {
+                        value: inst._zod ?? {},
+                        enumerable: false
+                    });
+                    (_a = inst._zod).traits ?? (_a.traits = new Set());
+                    inst._zod.traits.add(name);
+                    initializer(inst, def);
+                    for(const k in _.prototype)if (!(k in inst)) Object.defineProperty(inst, k, {
+                        value: _.prototype[k].bind(inst)
+                    });
+                    inst._zod.constr = _;
+                    inst._zod.def = def;
+                }
+                const Parent = params?.Parent ?? Object;
+                class Definition extends Parent {
+                }
+                Object.defineProperty(Definition, "name", {
+                    value: name
+                });
+                function _(def) {
+                    var _a;
+                    const inst = params?.Parent ? new Definition() : this;
+                    init(inst, def);
+                    (_a = inst._zod).deferred ?? (_a.deferred = []);
+                    for (const fn of inst._zod.deferred)fn();
+                    return inst;
+                }
+                Object.defineProperty(_, "init", {
+                    value: init
+                });
+                Object.defineProperty(_, Symbol.hasInstance, {
+                    value: (inst)=>{
+                        if (params?.Parent && inst instanceof params.Parent) return true;
+                        return inst?._zod?.traits?.has(name);
+                    }
+                });
+                Object.defineProperty(_, "name", {
+                    value: name
+                });
+                return _;
+            }
+            Symbol("zod_brand");
+            class $ZodAsyncError extends Error {
+                constructor(){
+                    super("Encountered Promise during synchronous parse. Use .parseAsync() instead.");
+                }
+            }
+            const globalConfig = {};
+            function core_config(newConfig) {
+                if (newConfig) Object.assign(globalConfig, newConfig);
+                return globalConfig;
+            }
+            const cuid = /^[cC][^\s-]{8,}$/;
+            const cuid2 = /^[0-9a-z]+$/;
+            const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
+            const xid = /^[0-9a-vA-V]{20}$/;
+            const ksuid = /^[A-Za-z0-9]{27}$/;
+            const nanoid = /^[a-zA-Z0-9_-]{21}$/;
+            const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+            const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+            const uuid = (version)=>{
+                if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+                return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+            };
+            const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+            const _emoji = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+            function emoji() {
+                return new RegExp(_emoji, "u");
+            }
+            const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+            const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
+            const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+            const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+            const regexes_base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+            const base64url = /^[A-Za-z0-9_-]*$/;
+            const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+            const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+            const dateSource = "(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))";
+            const date = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
+            function timeSource(args) {
+                const hhmm = "(?:[01]\\d|2[0-3]):[0-5]\\d";
+                const regex = "number" == typeof args.precision ? -1 === args.precision ? `${hhmm}` : 0 === args.precision ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+                return regex;
+            }
+            function regexes_time(args) {
+                return new RegExp(`^${timeSource(args)}$`);
+            }
+            function datetime(args) {
+                const time = timeSource({
+                    precision: args.precision
+                });
+                const opts = [
+                    "Z"
+                ];
+                if (args.local) opts.push("");
+                if (args.offset) opts.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");
+                const timeRegex = `${time}(?:${opts.join("|")})`;
+                return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+            }
+            const string = (params)=>{
+                const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : "[\\s\\S]*";
+                return new RegExp(`^${regex}$`);
+            };
+            const integer = /^\d+$/;
+            const number = /^-?\d+(?:\.\d+)?/i;
+            const regexes_boolean = /true|false/i;
+            const _undefined = /undefined/i;
+            const lowercase = /^[^A-Z]*$/;
+            const uppercase = /^[^a-z]*$/;
+            function getEnumValues(entries) {
+                const numericValues = Object.values(entries).filter((v)=>"number" == typeof v);
+                const values = Object.entries(entries).filter(([k, _])=>-1 === numericValues.indexOf(+k)).map(([_, v])=>v);
+                return values;
+            }
+            function jsonStringifyReplacer(_, value) {
+                if ("bigint" == typeof value) return value.toString();
+                return value;
+            }
+            function cached(getter) {
+                const set = false;
+                return {
+                    get value () {
+                        if (!set) {
+                            const value = getter();
+                            Object.defineProperty(this, "value", {
+                                value
+                            });
+                            return value;
+                        }
+                        throw new Error("cached value already set");
+                    }
+                };
+            }
+            function nullish(input) {
+                return null == input;
+            }
+            function cleanRegex(source) {
+                const start = source.startsWith("^") ? 1 : 0;
+                const end = source.endsWith("$") ? source.length - 1 : source.length;
+                return source.slice(start, end);
+            }
+            function floatSafeRemainder(val, step) {
+                const valDecCount = (val.toString().split(".")[1] || "").length;
+                const stepString = step.toString();
+                let stepDecCount = (stepString.split(".")[1] || "").length;
+                if (0 === stepDecCount && /\d?e-\d?/.test(stepString)) {
+                    const match = stepString.match(/\d?e-(\d?)/);
+                    if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
+                }
+                const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+                const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+                const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+                return valInt % stepInt / 10 ** decCount;
+            }
+            const EVALUATING = Symbol("evaluating");
+            function defineLazy(object, key, getter) {
+                let value;
+                Object.defineProperty(object, key, {
+                    get () {
+                        if (value === EVALUATING) return;
+                        if (void 0 === value) {
+                            value = EVALUATING;
+                            value = getter();
+                        }
+                        return value;
+                    },
+                    set (v) {
+                        Object.defineProperty(object, key, {
+                            value: v
+                        });
+                    },
+                    configurable: true
+                });
+            }
+            function assignProp(target, prop, value) {
+                Object.defineProperty(target, prop, {
+                    value,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+            function mergeDefs(...defs) {
+                const mergedDescriptors = {};
+                for (const def of defs){
+                    const descriptors = Object.getOwnPropertyDescriptors(def);
+                    Object.assign(mergedDescriptors, descriptors);
+                }
+                return Object.defineProperties({}, mergedDescriptors);
+            }
+            function esc(str) {
+                return JSON.stringify(str);
+            }
+            const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args)=>{};
+            function util_isObject(data) {
+                return "object" == typeof data && null !== data && !Array.isArray(data);
+            }
+            const util_allowsEval = cached(()=>{
+                if ("undefined" != typeof navigator && navigator?.userAgent?.includes("Cloudflare")) return false;
+                try {
+                    const F = Function;
+                    new F("");
+                    return true;
+                } catch (_) {
+                    return false;
+                }
+            });
+            function isPlainObject(o) {
+                if (false === util_isObject(o)) return false;
+                const ctor = o.constructor;
+                if (void 0 === ctor) return true;
+                const prot = ctor.prototype;
+                if (false === util_isObject(prot)) return false;
+                if (false === Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf")) return false;
+                return true;
+            }
+            const propertyKeyTypes = new Set([
+                "string",
+                "number",
+                "symbol"
+            ]);
+            new Set([
+                "string",
+                "number",
+                "bigint",
+                "boolean",
+                "symbol",
+                "undefined"
+            ]);
+            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 ("string" == typeof params) 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 ("string" == typeof params.error) return {
+                    ...params,
+                    error: ()=>params.error
+                };
+                return params;
+            }
+            function optionalKeys(shape) {
+                return Object.keys(shape).filter((k)=>"optional" === shape[k]._zod.optin && "optional" === shape[k]._zod.optout);
+            }
+            const NUMBER_FORMAT_RANGES = {
+                safeint: [
+                    Number.MIN_SAFE_INTEGER,
+                    Number.MAX_SAFE_INTEGER
+                ],
+                int32: [
+                    -2147483648,
+                    2147483647
+                ],
+                uint32: [
+                    0,
+                    4294967295
+                ],
+                float32: [
+                    -3.4028234663852886e+38,
+                    3.4028234663852886e38
+                ],
+                float64: [
+                    -Number.MAX_VALUE,
+                    Number.MAX_VALUE
+                ]
+            };
+            function pick(schema, mask) {
+                const currDef = schema._zod.def;
+                const def = mergeDefs(schema._zod.def, {
+                    get shape () {
+                        const newShape = {};
+                        for(const key in mask){
+                            if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+                            if (mask[key]) newShape[key] = currDef.shape[key];
+                        }
+                        assignProp(this, "shape", newShape);
+                        return newShape;
+                    },
+                    checks: []
+                });
+                return clone(schema, def);
+            }
+            function omit(schema, mask) {
+                const currDef = schema._zod.def;
+                const def = mergeDefs(schema._zod.def, {
+                    get shape () {
+                        const newShape = {
+                            ...schema._zod.def.shape
+                        };
+                        for(const key in mask){
+                            if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+                            if (mask[key]) delete newShape[key];
+                        }
+                        assignProp(this, "shape", newShape);
+                        return newShape;
+                    },
+                    checks: []
+                });
+                return clone(schema, def);
+            }
+            function extend(schema, shape) {
+                if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
+                const def = mergeDefs(schema._zod.def, {
+                    get shape () {
+                        const _shape = {
+                            ...schema._zod.def.shape,
+                            ...shape
+                        };
+                        assignProp(this, "shape", _shape);
+                        return _shape;
+                    },
+                    checks: []
+                });
+                return clone(schema, def);
+            }
+            function merge(a, b) {
+                const def = mergeDefs(a._zod.def, {
+                    get shape () {
+                        const _shape = {
+                            ...a._zod.def.shape,
+                            ...b._zod.def.shape
+                        };
+                        assignProp(this, "shape", _shape);
+                        return _shape;
+                    },
+                    get catchall () {
+                        return b._zod.def.catchall;
+                    },
+                    checks: []
+                });
+                return clone(a, def);
+            }
+            function partial(Class, schema, mask) {
+                const def = mergeDefs(schema._zod.def, {
+                    get shape () {
+                        const oldShape = schema._zod.def.shape;
+                        const shape = {
+                            ...oldShape
+                        };
+                        if (mask) for(const key in mask){
+                            if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
+                            if (mask[key]) shape[key] = Class ? new Class({
+                                type: "optional",
+                                innerType: oldShape[key]
+                            }) : oldShape[key];
+                        }
+                        else for(const key in oldShape)shape[key] = Class ? new Class({
+                            type: "optional",
+                            innerType: oldShape[key]
+                        }) : oldShape[key];
+                        assignProp(this, "shape", shape);
+                        return shape;
+                    },
+                    checks: []
+                });
+                return clone(schema, def);
+            }
+            function required(Class, schema, mask) {
+                const def = mergeDefs(schema._zod.def, {
+                    get shape () {
+                        const oldShape = schema._zod.def.shape;
+                        const shape = {
+                            ...oldShape
+                        };
+                        if (mask) for(const key in mask){
+                            if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
+                            if (mask[key]) shape[key] = new Class({
+                                type: "nonoptional",
+                                innerType: oldShape[key]
+                            });
+                        }
+                        else for(const key in oldShape)shape[key] = new Class({
+                            type: "nonoptional",
+                            innerType: oldShape[key]
+                        });
+                        assignProp(this, "shape", shape);
+                        return shape;
+                    },
+                    checks: []
+                });
+                return clone(schema, def);
+            }
+            function aborted(x, 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 "string" == typeof message ? message : message?.message;
+            }
+            function finalizeIssue(iss, ctx, config) {
+                const full = {
+                    ...iss,
+                    path: iss.path ?? []
+                };
+                if (!iss.message) {
+                    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+                    full.message = message;
+                }
+                delete full.inst;
+                delete full.continue;
+                if (!ctx?.reportInput) delete full.input;
+                return full;
+            }
+            function getLengthableOrigin(input) {
+                if (Array.isArray(input)) return "array";
+                if ("string" == typeof input) return "string";
+                return "unknown";
+            }
+            function util_issue(...args) {
+                const [iss, input, inst] = args;
+                if ("string" == typeof iss) return {
+                    message: iss,
+                    code: "custom",
+                    input,
+                    inst
+                };
+                return {
+                    ...iss
+                };
+            }
+            const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def)=>{
+                var _a;
+                inst._zod ?? (inst._zod = {});
+                inst._zod.def = def;
+                (_a = inst._zod).onattach ?? (_a.onattach = []);
+            });
+            const numericOriginMap = {
+                number: "number",
+                bigint: "bigint",
+                object: "date"
+            };
+            const $ZodCheckLessThan = /*@__PURE__*/ $constructor("$ZodCheckLessThan", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                const origin = numericOriginMap[typeof def.value];
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? 1 / 0;
+                    if (def.value < curr) if (def.inclusive) bag.maximum = def.value;
+                    else bag.exclusiveMaximum = def.value;
+                });
+                inst._zod.check = (payload)=>{
+                    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
+                    payload.issues.push({
+                        origin,
+                        code: "too_big",
+                        maximum: def.value,
+                        input: payload.value,
+                        inclusive: def.inclusive,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckGreaterThan = /*@__PURE__*/ $constructor("$ZodCheckGreaterThan", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                const origin = numericOriginMap[typeof def.value];
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? -1 / 0;
+                    if (def.value > curr) if (def.inclusive) bag.minimum = def.value;
+                    else bag.exclusiveMinimum = def.value;
+                });
+                inst._zod.check = (payload)=>{
+                    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
+                    payload.issues.push({
+                        origin,
+                        code: "too_small",
+                        minimum: def.value,
+                        input: payload.value,
+                        inclusive: def.inclusive,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckMultipleOf = /*@__PURE__*/ $constructor("$ZodCheckMultipleOf", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                inst._zod.onattach.push((inst)=>{
+                    var _a;
+                    (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
+                });
+                inst._zod.check = (payload)=>{
+                    if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
+                    const isMultiple = "bigint" == typeof payload.value ? payload.value % def.value === BigInt(0) : 0 === floatSafeRemainder(payload.value, def.value);
+                    if (isMultiple) return;
+                    payload.issues.push({
+                        origin: typeof payload.value,
+                        code: "not_multiple_of",
+                        divisor: def.value,
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                def.format = def.format || "float64";
+                const isInt = def.format?.includes("int");
+                const origin = isInt ? "int" : "number";
+                const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.format = def.format;
+                    bag.minimum = minimum;
+                    bag.maximum = maximum;
+                    if (isInt) bag.pattern = integer;
+                });
+                inst._zod.check = (payload)=>{
+                    const input = payload.value;
+                    if (isInt) {
+                        if (!Number.isInteger(input)) return void payload.issues.push({
+                            expected: origin,
+                            format: def.format,
+                            code: "invalid_type",
+                            continue: false,
+                            input,
+                            inst
+                        });
+                        if (!Number.isSafeInteger(input)) {
+                            if (input > 0) payload.issues.push({
+                                input,
+                                code: "too_big",
+                                maximum: Number.MAX_SAFE_INTEGER,
+                                note: "Integers must be within the safe integer range.",
+                                inst,
+                                origin,
+                                continue: !def.abort
+                            });
+                            else payload.issues.push({
+                                input,
+                                code: "too_small",
+                                minimum: Number.MIN_SAFE_INTEGER,
+                                note: "Integers must be within the safe integer range.",
+                                inst,
+                                origin,
+                                continue: !def.abort
+                            });
+                            return;
+                        }
+                    }
+                    if (input < minimum) payload.issues.push({
+                        origin: "number",
+                        input,
+                        code: "too_small",
+                        minimum,
+                        inclusive: true,
+                        inst,
+                        continue: !def.abort
+                    });
+                    if (input > maximum) payload.issues.push({
+                        origin: "number",
+                        input,
+                        code: "too_big",
+                        maximum,
+                        inst
+                    });
+                };
+            });
+            const $ZodCheckMaxLength = /*@__PURE__*/ $constructor("$ZodCheckMaxLength", (inst, def)=>{
+                var _a;
+                $ZodCheck.init(inst, def);
+                (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
+                    const val = payload.value;
+                    return !nullish(val) && void 0 !== val.length;
+                });
+                inst._zod.onattach.push((inst)=>{
+                    const curr = inst._zod.bag.maximum ?? 1 / 0;
+                    if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
+                });
+                inst._zod.check = (payload)=>{
+                    const input = payload.value;
+                    const length = input.length;
+                    if (length <= def.maximum) return;
+                    const origin = getLengthableOrigin(input);
+                    payload.issues.push({
+                        origin,
+                        code: "too_big",
+                        maximum: def.maximum,
+                        inclusive: true,
+                        input,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckMinLength = /*@__PURE__*/ $constructor("$ZodCheckMinLength", (inst, def)=>{
+                var _a;
+                $ZodCheck.init(inst, def);
+                (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
+                    const val = payload.value;
+                    return !nullish(val) && void 0 !== val.length;
+                });
+                inst._zod.onattach.push((inst)=>{
+                    const curr = inst._zod.bag.minimum ?? -1 / 0;
+                    if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
+                });
+                inst._zod.check = (payload)=>{
+                    const input = payload.value;
+                    const length = input.length;
+                    if (length >= def.minimum) return;
+                    const origin = getLengthableOrigin(input);
+                    payload.issues.push({
+                        origin,
+                        code: "too_small",
+                        minimum: def.minimum,
+                        inclusive: true,
+                        input,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckLengthEquals = /*@__PURE__*/ $constructor("$ZodCheckLengthEquals", (inst, def)=>{
+                var _a;
+                $ZodCheck.init(inst, def);
+                (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
+                    const val = payload.value;
+                    return !nullish(val) && void 0 !== val.length;
+                });
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.minimum = def.length;
+                    bag.maximum = def.length;
+                    bag.length = def.length;
+                });
+                inst._zod.check = (payload)=>{
+                    const input = payload.value;
+                    const length = input.length;
+                    if (length === def.length) return;
+                    const origin = getLengthableOrigin(input);
+                    const tooBig = length > def.length;
+                    payload.issues.push({
+                        origin,
+                        ...tooBig ? {
+                            code: "too_big",
+                            maximum: def.length
+                        } : {
+                            code: "too_small",
+                            minimum: def.length
+                        },
+                        inclusive: true,
+                        exact: true,
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckStringFormat = /*@__PURE__*/ $constructor("$ZodCheckStringFormat", (inst, def)=>{
+                var _a, _b;
+                $ZodCheck.init(inst, def);
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.format = def.format;
+                    if (def.pattern) {
+                        bag.patterns ?? (bag.patterns = new Set());
+                        bag.patterns.add(def.pattern);
+                    }
+                });
+                if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload)=>{
+                    def.pattern.lastIndex = 0;
+                    if (def.pattern.test(payload.value)) return;
+                    payload.issues.push({
+                        origin: "string",
+                        code: "invalid_format",
+                        format: def.format,
+                        input: payload.value,
+                        ...def.pattern ? {
+                            pattern: def.pattern.toString()
+                        } : {},
+                        inst,
+                        continue: !def.abort
+                    });
+                });
+                else (_b = inst._zod).check ?? (_b.check = ()=>{});
+            });
+            const $ZodCheckRegex = /*@__PURE__*/ $constructor("$ZodCheckRegex", (inst, def)=>{
+                $ZodCheckStringFormat.init(inst, def);
+                inst._zod.check = (payload)=>{
+                    def.pattern.lastIndex = 0;
+                    if (def.pattern.test(payload.value)) return;
+                    payload.issues.push({
+                        origin: "string",
+                        code: "invalid_format",
+                        format: "regex",
+                        input: payload.value,
+                        pattern: def.pattern.toString(),
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckLowerCase = /*@__PURE__*/ $constructor("$ZodCheckLowerCase", (inst, def)=>{
+                def.pattern ?? (def.pattern = lowercase);
+                $ZodCheckStringFormat.init(inst, def);
+            });
+            const $ZodCheckUpperCase = /*@__PURE__*/ $constructor("$ZodCheckUpperCase", (inst, def)=>{
+                def.pattern ?? (def.pattern = uppercase);
+                $ZodCheckStringFormat.init(inst, def);
+            });
+            const $ZodCheckIncludes = /*@__PURE__*/ $constructor("$ZodCheckIncludes", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                const escapedRegex = escapeRegex(def.includes);
+                const pattern = new RegExp("number" == typeof def.position ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
+                def.pattern = pattern;
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.patterns ?? (bag.patterns = new Set());
+                    bag.patterns.add(pattern);
+                });
+                inst._zod.check = (payload)=>{
+                    if (payload.value.includes(def.includes, def.position)) return;
+                    payload.issues.push({
+                        origin: "string",
+                        code: "invalid_format",
+                        format: "includes",
+                        includes: def.includes,
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckStartsWith = /*@__PURE__*/ $constructor("$ZodCheckStartsWith", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
+                def.pattern ?? (def.pattern = pattern);
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.patterns ?? (bag.patterns = new Set());
+                    bag.patterns.add(pattern);
+                });
+                inst._zod.check = (payload)=>{
+                    if (payload.value.startsWith(def.prefix)) return;
+                    payload.issues.push({
+                        origin: "string",
+                        code: "invalid_format",
+                        format: "starts_with",
+                        prefix: def.prefix,
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckEndsWith = /*@__PURE__*/ $constructor("$ZodCheckEndsWith", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
+                def.pattern ?? (def.pattern = pattern);
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.patterns ?? (bag.patterns = new Set());
+                    bag.patterns.add(pattern);
+                });
+                inst._zod.check = (payload)=>{
+                    if (payload.value.endsWith(def.suffix)) return;
+                    payload.issues.push({
+                        origin: "string",
+                        code: "invalid_format",
+                        format: "ends_with",
+                        suffix: def.suffix,
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodCheckOverwrite = /*@__PURE__*/ $constructor("$ZodCheckOverwrite", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                inst._zod.check = (payload)=>{
+                    payload.value = def.tx(payload.value);
+                };
+            });
+            class Doc {
+                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 ("function" == typeof arg) {
+                        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(2 * this.indent) + 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 errors_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", errors_initializer);
+            const $ZodRealError = $constructor("$ZodError", errors_initializer, {
+                Parent: Error
+            });
+            function flattenError(error, mapper = (issue)=>issue.message) {
+                const fieldErrors = {};
+                const formErrors = [];
+                for (const sub of error.issues)if (sub.path.length > 0) {
+                    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                    fieldErrors[sub.path[0]].push(mapper(sub));
+                } else formErrors.push(mapper(sub));
+                return {
+                    formErrors,
+                    fieldErrors
+                };
+            }
+            function formatError(error, _mapper) {
+                const mapper = _mapper || function(issue) {
+                    return issue.message;
+                };
+                const fieldErrors = {
+                    _errors: []
+                };
+                const processError = (error)=>{
+                    for (const issue of error.issues)if ("invalid_union" === issue.code && issue.errors.length) issue.errors.map((issues)=>processError({
+                            issues
+                        }));
+                    else if ("invalid_key" === issue.code) processError({
+                        issues: issue.issues
+                    });
+                    else if ("invalid_element" === issue.code) processError({
+                        issues: issue.issues
+                    });
+                    else if (0 === issue.path.length) fieldErrors._errors.push(mapper(issue));
+                    else {
+                        let curr = fieldErrors;
+                        let i = 0;
+                        while(i < issue.path.length){
+                            const el = issue.path[i];
+                            const terminal = i === issue.path.length - 1;
+                            if (terminal) {
+                                curr[el] = curr[el] || {
+                                    _errors: []
+                                };
+                                curr[el]._errors.push(mapper(issue));
+                            } else curr[el] = curr[el] || {
+                                _errors: []
+                            };
+                            curr = curr[el];
+                            i++;
+                        }
+                    }
+                };
+                processError(error);
+                return fieldErrors;
+            }
+            const _parse = (_Err)=>(schema, value, _ctx, _params)=>{
+                    const ctx = _ctx ? Object.assign(_ctx, {
+                        async: false
+                    }) : {
+                        async: false
+                    };
+                    const result = schema._zod.run({
+                        value,
+                        issues: []
+                    }, ctx);
+                    if (result instanceof Promise) throw new $ZodAsyncError();
+                    if (result.issues.length) {
+                        const e = new (_params?.Err ?? _Err)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())));
+                        captureStackTrace(e, _params?.callee);
+                        throw e;
+                    }
+                    return result.value;
+                };
+            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, core_config())));
+                        captureStackTrace(e, params?.callee);
+                        throw e;
+                    }
+                    return result.value;
+                };
+            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, core_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, core_config())))
+                    } : {
+                        success: true,
+                        data: result.value
+                    };
+                };
+            const safeParseAsync = /* @__PURE__*/ _safeParseAsync($ZodRealError);
+            const versions_version = {
+                major: 4,
+                minor: 0,
+                patch: 14
+            };
+            const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def)=>{
+                var _a;
+                inst ?? (inst = {});
+                inst._zod.def = def;
+                inst._zod.bag = inst._zod.bag || {};
+                inst._zod.version = versions_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 (0 === checks.length) {
+                    (_a = inst._zod).deferred ?? (_a.deferred = []);
+                    inst._zod.deferred?.push(()=>{
+                        inst._zod.run = inst._zod.parse;
+                    });
+                } else {
+                    const runChecks = (payload, checks, ctx)=>{
+                        let isAborted = aborted(payload);
+                        let asyncResult;
+                        for (const ch of checks){
+                            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(()=>payload);
+                        return payload;
+                    };
+                    inst._zod.run = (payload, ctx)=>{
+                        const result = inst._zod.parse(payload, ctx);
+                        if (result instanceof Promise) {
+                            if (false === ctx.async) throw new $ZodAsyncError();
+                            return result.then((result)=>runChecks(result, 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(inst._zod.bag);
+                inst._zod.parse = (payload, _)=>{
+                    if (def.coerce) try {
+                        payload.value = String(payload.value);
+                    } catch (_) {}
+                    if ("string" == typeof payload.value) return payload;
+                    payload.issues.push({
+                        expected: "string",
+                        code: "invalid_type",
+                        input: payload.value,
+                        inst
+                    });
+                    return payload;
+                };
+            });
+            const $ZodStringFormat = /*@__PURE__*/ $constructor("$ZodStringFormat", (inst, def)=>{
+                $ZodCheckStringFormat.init(inst, def);
+                $ZodString.init(inst, def);
+            });
+            const $ZodGUID = /*@__PURE__*/ $constructor("$ZodGUID", (inst, def)=>{
+                def.pattern ?? (def.pattern = guid);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodUUID = /*@__PURE__*/ $constructor("$ZodUUID", (inst, def)=>{
+                if (def.version) {
+                    const versionMap = {
+                        v1: 1,
+                        v2: 2,
+                        v3: 3,
+                        v4: 4,
+                        v5: 5,
+                        v6: 6,
+                        v7: 7,
+                        v8: 8
+                    };
+                    const v = versionMap[def.version];
+                    if (void 0 === v) throw new Error(`Invalid UUID version: "${def.version}"`);
+                    def.pattern ?? (def.pattern = uuid(v));
+                } else def.pattern ?? (def.pattern = uuid());
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodEmail = /*@__PURE__*/ $constructor("$ZodEmail", (inst, def)=>{
+                def.pattern ?? (def.pattern = email);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodURL = /*@__PURE__*/ $constructor("$ZodURL", (inst, def)=>{
+                $ZodStringFormat.init(inst, def);
+                inst._zod.check = (payload)=>{
+                    try {
+                        const trimmed = payload.value.trim();
+                        const url = new URL(trimmed);
+                        if (def.hostname) {
+                            def.hostname.lastIndex = 0;
+                            if (!def.hostname.test(url.hostname)) payload.issues.push({
+                                code: "invalid_format",
+                                format: "url",
+                                note: "Invalid hostname",
+                                pattern: hostname.source,
+                                input: payload.value,
+                                inst,
+                                continue: !def.abort
+                            });
+                        }
+                        if (def.protocol) {
+                            def.protocol.lastIndex = 0;
+                            if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) payload.issues.push({
+                                code: "invalid_format",
+                                format: "url",
+                                note: "Invalid protocol",
+                                pattern: def.protocol.source,
+                                input: payload.value,
+                                inst,
+                                continue: !def.abort
+                            });
+                        }
+                        if (def.normalize) payload.value = url.href;
+                        else payload.value = trimmed;
+                        return;
+                    } catch (_) {
+                        payload.issues.push({
+                            code: "invalid_format",
+                            format: "url",
+                            input: payload.value,
+                            inst,
+                            continue: !def.abort
+                        });
+                    }
+                };
+            });
+            const $ZodEmoji = /*@__PURE__*/ $constructor("$ZodEmoji", (inst, def)=>{
+                def.pattern ?? (def.pattern = emoji());
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodNanoID = /*@__PURE__*/ $constructor("$ZodNanoID", (inst, def)=>{
+                def.pattern ?? (def.pattern = nanoid);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodCUID = /*@__PURE__*/ $constructor("$ZodCUID", (inst, def)=>{
+                def.pattern ?? (def.pattern = cuid);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodCUID2 = /*@__PURE__*/ $constructor("$ZodCUID2", (inst, def)=>{
+                def.pattern ?? (def.pattern = cuid2);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodULID = /*@__PURE__*/ $constructor("$ZodULID", (inst, def)=>{
+                def.pattern ?? (def.pattern = ulid);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodXID = /*@__PURE__*/ $constructor("$ZodXID", (inst, def)=>{
+                def.pattern ?? (def.pattern = xid);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodKSUID = /*@__PURE__*/ $constructor("$ZodKSUID", (inst, def)=>{
+                def.pattern ?? (def.pattern = ksuid);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def)=>{
+                def.pattern ?? (def.pattern = datetime(def));
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def)=>{
+                def.pattern ?? (def.pattern = date);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodISOTime = /*@__PURE__*/ $constructor("$ZodISOTime", (inst, def)=>{
+                def.pattern ?? (def.pattern = regexes_time(def));
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodISODuration = /*@__PURE__*/ $constructor("$ZodISODuration", (inst, def)=>{
+                def.pattern ?? (def.pattern = duration);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodIPv4 = /*@__PURE__*/ $constructor("$ZodIPv4", (inst, def)=>{
+                def.pattern ?? (def.pattern = ipv4);
+                $ZodStringFormat.init(inst, def);
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.format = "ipv4";
+                });
+            });
+            const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def)=>{
+                def.pattern ?? (def.pattern = ipv6);
+                $ZodStringFormat.init(inst, def);
+                inst._zod.onattach.push((inst)=>{
+                    const bag = inst._zod.bag;
+                    bag.format = "ipv6";
+                });
+                inst._zod.check = (payload)=>{
+                    try {
+                        new URL(`http://[${payload.value}]`);
+                    } catch  {
+                        payload.issues.push({
+                            code: "invalid_format",
+                            format: "ipv6",
+                            input: payload.value,
+                            inst,
+                            continue: !def.abort
+                        });
+                    }
+                };
+            });
+            const $ZodCIDRv4 = /*@__PURE__*/ $constructor("$ZodCIDRv4", (inst, def)=>{
+                def.pattern ?? (def.pattern = cidrv4);
+                $ZodStringFormat.init(inst, def);
+            });
+            const $ZodCIDRv6 = /*@__PURE__*/ $constructor("$ZodCIDRv6", (inst, def)=>{
+                def.pattern ?? (def.pattern = cidrv6);
+                $ZodStringFormat.init(inst, def);
+                inst._zod.check = (payload)=>{
+                    const [address, prefix] = payload.value.split("/");
+                    try {
+                        if (!prefix) throw new Error();
+                        const prefixNum = Number(prefix);
+                        if (`${prefixNum}` !== prefix) throw new Error();
+                        if (prefixNum < 0 || prefixNum > 128) throw new Error();
+                        new URL(`http://[${address}]`);
+                    } catch  {
+                        payload.issues.push({
+                            code: "invalid_format",
+                            format: "cidrv6",
+                            input: payload.value,
+                            inst,
+                            continue: !def.abort
+                        });
+                    }
+                };
+            });
+            function isValidBase64(data) {
+                if ("" === data) return true;
+                if (data.length % 4 !== 0) return false;
+                try {
+                    atob(data);
+                    return true;
+                } catch  {
+                    return false;
+                }
+            }
+            const $ZodBase64 = /*@__PURE__*/ $constructor("$ZodBase64", (inst, def)=>{
+                def.pattern ?? (def.pattern = regexes_base64);
+                $ZodStringFormat.init(inst, def);
+                inst._zod.onattach.push((inst)=>{
+                    inst._zod.bag.contentEncoding = "base64";
+                });
+                inst._zod.check = (payload)=>{
+                    if (isValidBase64(payload.value)) return;
+                    payload.issues.push({
+                        code: "invalid_format",
+                        format: "base64",
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            function isValidBase64URL(data) {
+                if (!base64url.test(data)) return false;
+                const base64 = data.replace(/[-_]/g, (c)=>"-" === c ? "+" : "/");
+                const padded = base64.padEnd(4 * Math.ceil(base64.length / 4), "=");
+                return isValidBase64(padded);
+            }
+            const $ZodBase64URL = /*@__PURE__*/ $constructor("$ZodBase64URL", (inst, def)=>{
+                def.pattern ?? (def.pattern = base64url);
+                $ZodStringFormat.init(inst, def);
+                inst._zod.onattach.push((inst)=>{
+                    inst._zod.bag.contentEncoding = "base64url";
+                });
+                inst._zod.check = (payload)=>{
+                    if (isValidBase64URL(payload.value)) return;
+                    payload.issues.push({
+                        code: "invalid_format",
+                        format: "base64url",
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodE164 = /*@__PURE__*/ $constructor("$ZodE164", (inst, def)=>{
+                def.pattern ?? (def.pattern = e164);
+                $ZodStringFormat.init(inst, def);
+            });
+            function isValidJWT(token, algorithm = null) {
+                try {
+                    const tokensParts = token.split(".");
+                    if (3 !== tokensParts.length) return false;
+                    const [header] = tokensParts;
+                    if (!header) return false;
+                    const parsedHeader = JSON.parse(atob(header));
+                    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
+                    if (!parsedHeader.alg) return false;
+                    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
+                    return true;
+                } catch  {
+                    return false;
+                }
+            }
+            const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def)=>{
+                $ZodStringFormat.init(inst, def);
+                inst._zod.check = (payload)=>{
+                    if (isValidJWT(payload.value, def.alg)) return;
+                    payload.issues.push({
+                        code: "invalid_format",
+                        format: "jwt",
+                        input: payload.value,
+                        inst,
+                        continue: !def.abort
+                    });
+                };
+            });
+            const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.pattern = inst._zod.bag.pattern ?? number;
+                inst._zod.parse = (payload, _ctx)=>{
+                    if (def.coerce) try {
+                        payload.value = Number(payload.value);
+                    } catch (_) {}
+                    const input = payload.value;
+                    if ("number" == typeof input && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+                    const received = "number" == typeof input ? Number.isNaN(input) ? "NaN" : Number.isFinite(input) ? void 0 : "Infinity" : void 0;
+                    payload.issues.push({
+                        expected: "number",
+                        code: "invalid_type",
+                        input,
+                        inst,
+                        ...received ? {
+                            received
+                        } : {}
+                    });
+                    return payload;
+                };
+            });
+            const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def)=>{
+                $ZodCheckNumberFormat.init(inst, def);
+                $ZodNumber.init(inst, def);
+            });
+            const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.pattern = regexes_boolean;
+                inst._zod.parse = (payload, _ctx)=>{
+                    if (def.coerce) try {
+                        payload.value = Boolean(payload.value);
+                    } catch (_) {}
+                    const input = payload.value;
+                    if ("boolean" == typeof input) return payload;
+                    payload.issues.push({
+                        expected: "boolean",
+                        code: "invalid_type",
+                        input,
+                        inst
+                    });
+                    return payload;
+                };
+            });
+            const $ZodUndefined = /*@__PURE__*/ $constructor("$ZodUndefined", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.pattern = _undefined;
+                inst._zod.values = new Set([
+                    void 0
+                ]);
+                inst._zod.optin = "optional";
+                inst._zod.optout = "optional";
+                inst._zod.parse = (payload, _ctx)=>{
+                    const input = payload.value;
+                    if (void 0 === input) return payload;
+                    payload.issues.push({
+                        expected: "undefined",
+                        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;
+            });
+            const $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.parse = (payload, _ctx)=>{
+                    payload.issues.push({
+                        expected: "never",
+                        code: "invalid_type",
+                        input: payload.value,
+                        inst
+                    });
+                    return payload;
+                };
+            });
+            function handleArrayResult(result, final, index) {
+                if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+                final.value[index] = result.value;
+            }
+            const $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.parse = (payload, ctx)=>{
+                    const input = payload.value;
+                    if (!Array.isArray(input)) {
+                        payload.issues.push({
+                            expected: "array",
+                            code: "invalid_type",
+                            input,
+                            inst
+                        });
+                        return payload;
+                    }
+                    payload.value = Array(input.length);
+                    const proms = [];
+                    for(let i = 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)=>handleArrayResult(result, 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 (void 0 === result.value) {
+                    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] = 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 = util_isObject;
+                const jit = !globalConfig.jitless;
+                const allowsEval = util_allowsEval;
+                const fastEnabled = jit && allowsEval.value;
+                const catchall = def.catchall;
+                let value;
+                inst._zod.parse = (payload, ctx)=>{
+                    value ?? (value = _normalized.value);
+                    const input = payload.value;
+                    if (!isObject(input)) {
+                        payload.issues.push({
+                            expected: "object",
+                            code: "invalid_type",
+                            input,
+                            inst
+                        });
+                        return payload;
+                    }
+                    const proms = [];
+                    if (jit && fastEnabled && ctx?.async === false && true !== ctx.jitless) {
+                        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)=>handlePropertyResult(r, 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 ("never" === t) {
+                            unrecognized.push(key);
+                            continue;
+                        }
+                        const r = _catchall.run({
+                            value: input[key],
+                            issues: []
+                        }, ctx);
+                        if (r instanceof Promise) proms.push(r.then((r)=>handlePropertyResult(r, 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(()=>payload);
+                };
+            });
+            function handleUnionResults(results, final, inst, ctx) {
+                for (const result of results)if (0 === result.issues.length) {
+                    final.value = result.value;
+                    return final;
+                }
+                const nonaborted = results.filter((r)=>!aborted(r));
+                if (1 === nonaborted.length) {
+                    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, core_config())))
+                });
+                return final;
+            }
+            const $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def)=>{
+                $ZodType.init(inst, def);
+                defineLazy(inst._zod, "optin", ()=>def.options.some((o)=>"optional" === o._zod.optin) ? "optional" : void 0);
+                defineLazy(inst._zod, "optout", ()=>def.options.some((o)=>"optional" === o._zod.optout) ? "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)));
+                });
+                defineLazy(inst._zod, "pattern", ()=>{
+                    if (def.options.every((o)=>o._zod.pattern)) {
+                        const patterns = def.options.map((o)=>o._zod.pattern);
+                        return new RegExp(`^(${patterns.map((p)=>cleanRegex(p.source)).join("|")})$`);
+                    }
+                });
+                const single = 1 === def.options.length;
+                const first = def.options[0]._zod.run;
+                inst._zod.parse = (payload, ctx)=>{
+                    if (single) return first(payload, ctx);
+                    let async = false;
+                    const results = [];
+                    for (const option of def.options){
+                        const result = option._zod.run({
+                            value: payload.value,
+                            issues: []
+                        }, ctx);
+                        if (result instanceof Promise) {
+                            results.push(result);
+                            async = true;
+                        } else {
+                            if (0 === result.issues.length) return result;
+                            results.push(result);
+                        }
+                    }
+                    if (!async) return handleUnionResults(results, payload, inst, ctx);
+                    return Promise.all(results).then((results)=>handleUnionResults(results, payload, inst, ctx));
+                };
+            });
+            const $ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("$ZodDiscriminatedUnion", (inst, def)=>{
+                $ZodUnion.init(inst, def);
+                const _super = inst._zod.parse;
+                defineLazy(inst._zod, "propValues", ()=>{
+                    const propValues = {};
+                    for (const option of def.options){
+                        const pv = option._zod.propValues;
+                        if (!pv || 0 === Object.keys(pv).length) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+                        for (const [k, v] of Object.entries(pv)){
+                            if (!propValues[k]) propValues[k] = new Set();
+                            for (const val of v)propValues[k].add(val);
+                        }
+                    }
+                    return propValues;
+                });
+                const disc = cached(()=>{
+                    const opts = def.options;
+                    const map = new Map();
+                    for (const o of opts){
+                        const values = o._zod.propValues?.[def.discriminator];
+                        if (!values || 0 === values.size) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+                        for (const v of values){
+                            if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
+                            map.set(v, o);
+                        }
+                    }
+                    return map;
+                });
+                inst._zod.parse = (payload, ctx)=>{
+                    const input = payload.value;
+                    if (!util_isObject(input)) {
+                        payload.issues.push({
+                            code: "invalid_type",
+                            expected: "object",
+                            input,
+                            inst
+                        });
+                        return payload;
+                    }
+                    const opt = disc.value.get(input?.[def.discriminator]);
+                    if (opt) return opt._zod.run(payload, ctx);
+                    if (def.unionFallback) return _super(payload, ctx);
+                    payload.issues.push({
+                        code: "invalid_union",
+                        errors: [],
+                        note: "No matching discriminator",
+                        discriminator: def.discriminator,
+                        input,
+                        path: [
+                            def.discriminator
+                        ],
+                        inst
+                    });
+                    return payload;
+                };
+            });
+            const $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.parse = (payload, ctx)=>{
+                    const input = payload.value;
+                    const left = def.left._zod.run({
+                        value: input,
+                        issues: []
+                    }, ctx);
+                    const right = def.right._zod.run({
+                        value: input,
+                        issues: []
+                    }, ctx);
+                    const async = left instanceof Promise || right instanceof Promise;
+                    if (async) return Promise.all([
+                        left,
+                        right
+                    ]).then(([left, right])=>handleIntersectionResults(payload, left, right));
+                    return handleIntersectionResults(payload, left, right);
+                };
+            });
+            function mergeValues(a, b) {
+                if (a === b) return {
+                    valid: true,
+                    data: a
+                };
+                if (a instanceof Date && b instanceof Date && +a === +b) return {
+                    valid: true,
+                    data: a
+                };
+                if (isPlainObject(a) && isPlainObject(b)) {
+                    const bKeys = Object.keys(b);
+                    const sharedKeys = Object.keys(a).filter((key)=>-1 !== bKeys.indexOf(key));
+                    const newObj = {
+                        ...a,
+                        ...b
+                    };
+                    for (const key of sharedKeys){
+                        const sharedValue = mergeValues(a[key], b[key]);
+                        if (!sharedValue.valid) return {
+                            valid: false,
+                            mergeErrorPath: [
+                                key,
+                                ...sharedValue.mergeErrorPath
+                            ]
+                        };
+                        newObj[key] = sharedValue.data;
+                    }
+                    return {
+                        valid: true,
+                        data: newObj
+                    };
+                }
+                if (Array.isArray(a) && Array.isArray(b)) {
+                    if (a.length !== b.length) return {
+                        valid: false,
+                        mergeErrorPath: []
+                    };
+                    const newArray = [];
+                    for(let index = 0; index < a.length; index++){
+                        const itemA = a[index];
+                        const itemB = b[index];
+                        const sharedValue = mergeValues(itemA, itemB);
+                        if (!sharedValue.valid) return {
+                            valid: false,
+                            mergeErrorPath: [
+                                index,
+                                ...sharedValue.mergeErrorPath
+                            ]
+                        };
+                        newArray.push(sharedValue.data);
+                    }
+                    return {
+                        valid: true,
+                        data: newArray
+                    };
+                }
+                return {
+                    valid: false,
+                    mergeErrorPath: []
+                };
+            }
+            function handleIntersectionResults(result, left, right) {
+                if (left.issues.length) result.issues.push(...left.issues);
+                if (right.issues.length) result.issues.push(...right.issues);
+                if (aborted(result)) return result;
+                const merged = mergeValues(left.value, right.value);
+                if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
+                result.value = merged.data;
+                return result;
+            }
+            const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.parse = (payload, ctx)=>{
+                    const input = payload.value;
+                    if (!isPlainObject(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 ("string" == typeof key || "number" == typeof key || "symbol" == typeof key) {
+                            const result = def.valueType._zod.run({
+                                value: input[key],
+                                issues: []
+                            }, ctx);
+                            if (result instanceof Promise) proms.push(result.then((result)=>{
+                                if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+                                payload.value[key] = result.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 ("__proto__" === key) 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({
+                                    code: "invalid_key",
+                                    origin: "record",
+                                    issues: keyResult.issues.map((iss)=>finalizeIssue(iss, ctx, core_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)=>{
+                                if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+                                payload.value[keyResult.value] = result.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 = new RegExp(`^(${values.filter((k)=>propertyKeyTypes.has(typeof k)).map((o)=>"string" == typeof o ? 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 (0 === def.values.length) throw new Error("Cannot create literal schema with no valid values");
+                inst._zod.values = new Set(def.values);
+                inst._zod.pattern = new RegExp(`^(${def.values.map((o)=>"string" == typeof o ? 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 $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.parse = (payload, _ctx)=>{
+                    const _out = def.transform(payload.value, payload);
+                    if (_ctx.async) {
+                        const output = _out instanceof Promise ? _out : Promise.resolve(_out);
+                        return output.then((output)=>{
+                            payload.value = output;
+                            return payload;
+                        });
+                    }
+                    if (_out instanceof Promise) throw new $ZodAsyncError();
+                    payload.value = _out;
+                    return payload;
+                };
+            });
+            function handleOptionalResult(result, input) {
+                if (result.issues.length && void 0 === input) return {
+                    issues: [],
+                    value: void 0
+                };
+                return result;
+            }
+            const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.optin = "optional";
+                inst._zod.optout = "optional";
+                defineLazy(inst._zod, "values", ()=>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 ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+                });
+                inst._zod.parse = (payload, ctx)=>{
+                    if ("optional" === def.innerType._zod.optin) {
+                        const result = def.innerType._zod.run(payload, ctx);
+                        if (result instanceof Promise) return result.then((r)=>handleOptionalResult(r, payload.value));
+                        return handleOptionalResult(result, payload.value);
+                    }
+                    if (void 0 === payload.value) 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 ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+                });
+                defineLazy(inst._zod, "values", ()=>def.innerType._zod.values ? new Set([
+                        ...def.innerType._zod.values,
+                        null
+                    ]) : void 0);
+                inst._zod.parse = (payload, ctx)=>{
+                    if (null === payload.value) return payload;
+                    return def.innerType._zod.run(payload, ctx);
+                };
+            });
+            const $ZodDefault = /*@__PURE__*/ $constructor("$ZodDefault", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.optin = "optional";
+                defineLazy(inst._zod, "values", ()=>def.innerType._zod.values);
+                inst._zod.parse = (payload, ctx)=>{
+                    if (void 0 === payload.value) {
+                        payload.value = def.defaultValue;
+                        return payload;
+                    }
+                    const result = def.innerType._zod.run(payload, ctx);
+                    if (result instanceof Promise) return result.then((result)=>handleDefaultResult(result, def));
+                    return handleDefaultResult(result, def);
+                };
+            });
+            function handleDefaultResult(payload, def) {
+                if (void 0 === payload.value) payload.value = def.defaultValue;
+                return payload;
+            }
+            const $ZodPrefault = /*@__PURE__*/ $constructor("$ZodPrefault", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst._zod.optin = "optional";
+                defineLazy(inst._zod, "values", ()=>def.innerType._zod.values);
+                inst._zod.parse = (payload, ctx)=>{
+                    if (void 0 === payload.value) payload.value = def.defaultValue;
+                    return def.innerType._zod.run(payload, ctx);
+                };
+            });
+            const $ZodNonOptional = /*@__PURE__*/ $constructor("$ZodNonOptional", (inst, def)=>{
+                $ZodType.init(inst, def);
+                defineLazy(inst._zod, "values", ()=>{
+                    const v = def.innerType._zod.values;
+                    return v ? new Set([
+                        ...v
+                    ].filter((x)=>void 0 !== x)) : void 0;
+                });
+                inst._zod.parse = (payload, ctx)=>{
+                    const result = def.innerType._zod.run(payload, ctx);
+                    if (result instanceof Promise) return result.then((result)=>handleNonOptionalResult(result, inst));
+                    return handleNonOptionalResult(result, inst);
+                };
+            });
+            function handleNonOptionalResult(payload, inst) {
+                if (!payload.issues.length && void 0 === payload.value) payload.issues.push({
+                    code: "invalid_type",
+                    expected: "nonoptional",
+                    input: payload.value,
+                    inst
+                });
+                return payload;
+            }
+            const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def)=>{
+                $ZodType.init(inst, def);
+                defineLazy(inst._zod, "optin", ()=>def.innerType._zod.optin);
+                defineLazy(inst._zod, "optout", ()=>def.innerType._zod.optout);
+                defineLazy(inst._zod, "values", ()=>def.innerType._zod.values);
+                inst._zod.parse = (payload, ctx)=>{
+                    const result = def.innerType._zod.run(payload, ctx);
+                    if (result instanceof Promise) return result.then((result)=>{
+                        payload.value = result.value;
+                        if (result.issues.length) {
+                            payload.value = def.catchValue({
+                                ...payload,
+                                error: {
+                                    issues: result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config()))
+                                },
+                                input: payload.value
+                            });
+                            payload.issues = [];
+                        }
+                        return payload;
+                    });
+                    payload.value = result.value;
+                    if (result.issues.length) {
+                        payload.value = def.catchValue({
+                            ...payload,
+                            error: {
+                                issues: result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config()))
+                            },
+                            input: payload.value
+                        });
+                        payload.issues = [];
+                    }
+                    return payload;
+                };
+            });
+            const $ZodPipe = /*@__PURE__*/ $constructor("$ZodPipe", (inst, def)=>{
+                $ZodType.init(inst, def);
+                defineLazy(inst._zod, "values", ()=>def.in._zod.values);
+                defineLazy(inst._zod, "optin", ()=>def.in._zod.optin);
+                defineLazy(inst._zod, "optout", ()=>def.out._zod.optout);
+                defineLazy(inst._zod, "propValues", ()=>def.in._zod.propValues);
+                inst._zod.parse = (payload, ctx)=>{
+                    const left = def.in._zod.run(payload, ctx);
+                    if (left instanceof Promise) return left.then((left)=>handlePipeResult(left, def, ctx));
+                    return handlePipeResult(left, def, ctx);
+                };
+            });
+            function handlePipeResult(left, def, ctx) {
+                if (left.issues.length) return left;
+                return def.out._zod.run({
+                    value: left.value,
+                    issues: left.issues
+                }, ctx);
+            }
+            const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def)=>{
+                $ZodType.init(inst, def);
+                defineLazy(inst._zod, "propValues", ()=>def.innerType._zod.propValues);
+                defineLazy(inst._zod, "values", ()=>def.innerType._zod.values);
+                defineLazy(inst._zod, "optin", ()=>def.innerType._zod.optin);
+                defineLazy(inst._zod, "optout", ()=>def.innerType._zod.optout);
+                inst._zod.parse = (payload, ctx)=>{
+                    const result = def.innerType._zod.run(payload, ctx);
+                    if (result instanceof Promise) return result.then(handleReadonlyResult);
+                    return handleReadonlyResult(result);
+                };
+            });
+            function handleReadonlyResult(payload) {
+                payload.value = Object.freeze(payload.value);
+                return payload;
+            }
+            const $ZodCustom = /*@__PURE__*/ $constructor("$ZodCustom", (inst, def)=>{
+                $ZodCheck.init(inst, def);
+                $ZodType.init(inst, def);
+                inst._zod.parse = (payload, _)=>payload;
+                inst._zod.check = (payload)=>{
+                    const input = payload.value;
+                    const r = def.fn(input);
+                    if (r instanceof Promise) return r.then((r)=>handleRefineResult(r, payload, input, inst));
+                    handleRefineResult(r, payload, input, inst);
+                };
+            });
+            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(util_issue(_iss));
+                }
+            }
+            Symbol("ZodOutput");
+            Symbol("ZodInput");
+            class $ZodRegistry {
+                constructor(){
+                    this._map = new Map();
+                    this._idmap = new Map();
+                }
+                add(schema, ..._meta) {
+                    const meta = _meta[0];
+                    this._map.set(schema, meta);
+                    if (meta && "object" == typeof meta && "id" in meta) {
+                        if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
+                        this._idmap.set(meta.id, schema);
+                    }
+                    return this;
+                }
+                clear() {
+                    this._map = new Map();
+                    this._idmap = new Map();
+                    return this;
+                }
+                remove(schema) {
+                    const meta = this._map.get(schema);
+                    if (meta && "object" == typeof meta && "id" in meta) this._idmap.delete(meta.id);
+                    this._map.delete(schema);
+                    return this;
+                }
+                get(schema) {
+                    const p = schema._zod.parent;
+                    if (p) {
+                        const pm = {
+                            ...this.get(p) ?? {}
+                        };
+                        delete pm.id;
+                        const f = {
+                            ...pm,
+                            ...this._map.get(schema)
+                        };
+                        return Object.keys(f).length ? f : void 0;
+                    }
+                    return this._map.get(schema);
+                }
+                has(schema) {
+                    return this._map.has(schema);
+                }
+            }
+            function registry() {
+                return new $ZodRegistry();
+            }
+            const globalRegistry = /*@__PURE__*/ registry();
+            function _string(Class, params) {
+                return new Class({
+                    type: "string",
+                    ...normalizeParams(params)
+                });
+            }
+            function _email(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "email",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _guid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "guid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _uuid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "uuid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _uuidv4(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "uuid",
+                    check: "string_format",
+                    abort: false,
+                    version: "v4",
+                    ...normalizeParams(params)
+                });
+            }
+            function _uuidv6(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "uuid",
+                    check: "string_format",
+                    abort: false,
+                    version: "v6",
+                    ...normalizeParams(params)
+                });
+            }
+            function _uuidv7(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "uuid",
+                    check: "string_format",
+                    abort: false,
+                    version: "v7",
+                    ...normalizeParams(params)
+                });
+            }
+            function _url(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "url",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function api_emoji(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "emoji",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _nanoid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "nanoid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _cuid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "cuid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _cuid2(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "cuid2",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _ulid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "ulid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _xid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "xid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _ksuid(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "ksuid",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _ipv4(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "ipv4",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _ipv6(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "ipv6",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _cidrv4(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "cidrv4",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _cidrv6(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "cidrv6",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _base64(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "base64",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _base64url(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "base64url",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _e164(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "e164",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _jwt(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "jwt",
+                    check: "string_format",
+                    abort: false,
+                    ...normalizeParams(params)
+                });
+            }
+            function _isoDateTime(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "datetime",
+                    check: "string_format",
+                    offset: false,
+                    local: false,
+                    precision: null,
+                    ...normalizeParams(params)
+                });
+            }
+            function _isoDate(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "date",
+                    check: "string_format",
+                    ...normalizeParams(params)
+                });
+            }
+            function _isoTime(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "time",
+                    check: "string_format",
+                    precision: null,
+                    ...normalizeParams(params)
+                });
+            }
+            function _isoDuration(Class, params) {
+                return new Class({
+                    type: "string",
+                    format: "duration",
+                    check: "string_format",
+                    ...normalizeParams(params)
+                });
+            }
+            function _number(Class, params) {
+                return new Class({
+                    type: "number",
+                    checks: [],
+                    ...normalizeParams(params)
+                });
+            }
+            function _int(Class, params) {
+                return new Class({
+                    type: "number",
+                    check: "number_format",
+                    abort: false,
+                    format: "safeint",
+                    ...normalizeParams(params)
+                });
+            }
+            function _boolean(Class, params) {
+                return new Class({
+                    type: "boolean",
+                    ...normalizeParams(params)
+                });
+            }
+            function api_undefined(Class, params) {
+                return new Class({
+                    type: "undefined",
+                    ...normalizeParams(params)
+                });
+            }
+            function _any(Class) {
+                return new Class({
+                    type: "any"
+                });
+            }
+            function _unknown(Class) {
+                return new Class({
+                    type: "unknown"
+                });
+            }
+            function _never(Class, params) {
+                return new Class({
+                    type: "never",
+                    ...normalizeParams(params)
+                });
+            }
+            function _lt(value, params) {
+                return new $ZodCheckLessThan({
+                    check: "less_than",
+                    ...normalizeParams(params),
+                    value,
+                    inclusive: false
+                });
+            }
+            function _lte(value, params) {
+                return new $ZodCheckLessThan({
+                    check: "less_than",
+                    ...normalizeParams(params),
+                    value,
+                    inclusive: true
+                });
+            }
+            function _gt(value, params) {
+                return new $ZodCheckGreaterThan({
+                    check: "greater_than",
+                    ...normalizeParams(params),
+                    value,
+                    inclusive: false
+                });
+            }
+            function _gte(value, params) {
+                return new $ZodCheckGreaterThan({
+                    check: "greater_than",
+                    ...normalizeParams(params),
+                    value,
+                    inclusive: true
+                });
+            }
+            function _multipleOf(value, params) {
+                return new $ZodCheckMultipleOf({
+                    check: "multiple_of",
+                    ...normalizeParams(params),
+                    value
+                });
+            }
+            function _maxLength(maximum, params) {
+                const ch = new $ZodCheckMaxLength({
+                    check: "max_length",
+                    ...normalizeParams(params),
+                    maximum
+                });
+                return ch;
+            }
+            function _minLength(minimum, params) {
+                return new $ZodCheckMinLength({
+                    check: "min_length",
+                    ...normalizeParams(params),
+                    minimum
+                });
+            }
+            function _length(length, params) {
+                return new $ZodCheckLengthEquals({
+                    check: "length_equals",
+                    ...normalizeParams(params),
+                    length
+                });
+            }
+            function _regex(pattern, params) {
+                return new $ZodCheckRegex({
+                    check: "string_format",
+                    format: "regex",
+                    ...normalizeParams(params),
+                    pattern
+                });
+            }
+            function _lowercase(params) {
+                return new $ZodCheckLowerCase({
+                    check: "string_format",
+                    format: "lowercase",
+                    ...normalizeParams(params)
+                });
+            }
+            function _uppercase(params) {
+                return new $ZodCheckUpperCase({
+                    check: "string_format",
+                    format: "uppercase",
+                    ...normalizeParams(params)
+                });
+            }
+            function _includes(includes, params) {
+                return new $ZodCheckIncludes({
+                    check: "string_format",
+                    format: "includes",
+                    ...normalizeParams(params),
+                    includes
+                });
+            }
+            function _startsWith(prefix, params) {
+                return new $ZodCheckStartsWith({
+                    check: "string_format",
+                    format: "starts_with",
+                    ...normalizeParams(params),
+                    prefix
+                });
+            }
+            function _endsWith(suffix, params) {
+                return new $ZodCheckEndsWith({
+                    check: "string_format",
+                    format: "ends_with",
+                    ...normalizeParams(params),
+                    suffix
+                });
+            }
+            function _overwrite(tx) {
+                return new $ZodCheckOverwrite({
+                    check: "overwrite",
+                    tx
+                });
+            }
+            function _normalize(form) {
+                return _overwrite((input)=>input.normalize(form));
+            }
+            function _trim() {
+                return _overwrite((input)=>input.trim());
+            }
+            function _toLowerCase() {
+                return _overwrite((input)=>input.toLowerCase());
+            }
+            function _toUpperCase() {
+                return _overwrite((input)=>input.toUpperCase());
+            }
+            function _array(Class, element, params) {
+                return new Class({
+                    type: "array",
+                    element,
+                    ...normalizeParams(params)
+                });
+            }
+            function _refine(Class, fn, _params) {
+                const schema = new Class({
+                    type: "custom",
+                    check: "custom",
+                    fn: fn,
+                    ...normalizeParams(_params)
+                });
+                return schema;
+            }
+            function _superRefine(fn) {
+                const ch = _check((payload)=>{
+                    payload.addIssue = (issue)=>{
+                        if ("string" == typeof issue) payload.issues.push(util_issue(issue, payload.value, ch._zod.def));
+                        else {
+                            const _issue = issue;
+                            if (_issue.fatal) _issue.continue = false;
+                            _issue.code ?? (_issue.code = "custom");
+                            _issue.input ?? (_issue.input = payload.value);
+                            _issue.inst ?? (_issue.inst = ch);
+                            _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+                            payload.issues.push(util_issue(_issue));
+                        }
+                    };
+                    return fn(payload.value, payload);
+                });
+                return ch;
+            }
+            function _check(fn, params) {
+                const ch = new $ZodCheck({
+                    check: "custom",
+                    ...normalizeParams(params)
+                });
+                ch._zod.check = fn;
+                return ch;
+            }
+            const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def)=>{
+                $ZodISODateTime.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            function iso_datetime(params) {
+                return _isoDateTime(ZodISODateTime, params);
+            }
+            const ZodISODate = /*@__PURE__*/ $constructor("ZodISODate", (inst, def)=>{
+                $ZodISODate.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            function iso_date(params) {
+                return _isoDate(ZodISODate, params);
+            }
+            const ZodISOTime = /*@__PURE__*/ $constructor("ZodISOTime", (inst, def)=>{
+                $ZodISOTime.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            function iso_time(params) {
+                return _isoTime(ZodISOTime, params);
+            }
+            const ZodISODuration = /*@__PURE__*/ $constructor("ZodISODuration", (inst, def)=>{
+                $ZodISODuration.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            function iso_duration(params) {
+                return _isoDuration(ZodISODuration, params);
+            }
+            const classic_errors_initializer = (inst, issues)=>{
+                $ZodError.init(inst, issues);
+                inst.name = "ZodError";
+                Object.defineProperties(inst, {
+                    format: {
+                        value: (mapper)=>formatError(inst, mapper)
+                    },
+                    flatten: {
+                        value: (mapper)=>flattenError(inst, mapper)
+                    },
+                    addIssue: {
+                        value: (issue)=>{
+                            inst.issues.push(issue);
+                            inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+                        }
+                    },
+                    addIssues: {
+                        value: (issues)=>{
+                            inst.issues.push(...issues);
+                            inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+                        }
+                    },
+                    isEmpty: {
+                        get () {
+                            return 0 === inst.issues.length;
+                        }
+                    }
+                });
+            };
+            $constructor("ZodError", classic_errors_initializer);
+            const ZodRealError = $constructor("ZodError", classic_errors_initializer, {
+                Parent: Error
+            });
+            const parse_parse = /* @__PURE__ */ _parse(ZodRealError);
+            const parse_parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+            const parse_safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+            const parse_safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+            const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def)=>{
+                $ZodType.init(inst, def);
+                inst.def = def;
+                Object.defineProperty(inst, "_def", {
+                    value: def
+                });
+                inst.check = (...checks)=>inst.clone({
+                        ...def,
+                        checks: [
+                            ...def.checks ?? [],
+                            ...checks.map((ch)=>"function" == typeof ch ? {
+                                    _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;
+                };
+                inst.parse = (data, params)=>parse_parse(inst, data, params, {
+                        callee: inst.parse
+                    });
+                inst.safeParse = (data, params)=>parse_safeParse(inst, data, params);
+                inst.parseAsync = async (data, params)=>parse_parseAsync(inst, data, params, {
+                        callee: inst.parseAsync
+                    });
+                inst.safeParseAsync = async (data, params)=>parse_safeParseAsync(inst, data, params);
+                inst.spa = inst.safeParseAsync;
+                inst.refine = (check, params)=>inst.check(refine(check, params));
+                inst.superRefine = (refinement)=>inst.check(superRefine(refinement));
+                inst.overwrite = (fn)=>inst.check(_overwrite(fn));
+                inst.optional = ()=>optional(inst);
+                inst.nullable = ()=>nullable(inst);
+                inst.nullish = ()=>optional(nullable(inst));
+                inst.nonoptional = (params)=>nonoptional(inst, params);
+                inst.array = ()=>schemas_array(inst);
+                inst.or = (arg)=>union([
+                        inst,
+                        arg
+                    ]);
+                inst.and = (arg)=>intersection(inst, arg);
+                inst.transform = (tx)=>pipe(inst, transform(tx));
+                inst.default = (def)=>schemas_default(inst, def);
+                inst.prefault = (def)=>prefault(inst, def);
+                inst.catch = (params)=>schemas_catch(inst, params);
+                inst.pipe = (target)=>pipe(inst, target);
+                inst.readonly = ()=>readonly(inst);
+                inst.describe = (description)=>{
+                    const cl = inst.clone();
+                    globalRegistry.add(cl, {
+                        description
+                    });
+                    return cl;
+                };
+                Object.defineProperty(inst, "description", {
+                    get () {
+                        return globalRegistry.get(inst)?.description;
+                    },
+                    configurable: true
+                });
+                inst.meta = (...args)=>{
+                    if (0 === args.length) return globalRegistry.get(inst);
+                    const cl = inst.clone();
+                    globalRegistry.add(cl, args[0]);
+                    return cl;
+                };
+                inst.isOptional = ()=>inst.safeParse(void 0).success;
+                inst.isNullable = ()=>inst.safeParse(null).success;
+                return inst;
+            });
+            const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def)=>{
+                $ZodString.init(inst, def);
+                ZodType.init(inst, def);
+                const bag = inst._zod.bag;
+                inst.format = bag.format ?? null;
+                inst.minLength = bag.minimum ?? null;
+                inst.maxLength = bag.maximum ?? null;
+                inst.regex = (...args)=>inst.check(_regex(...args));
+                inst.includes = (...args)=>inst.check(_includes(...args));
+                inst.startsWith = (...args)=>inst.check(_startsWith(...args));
+                inst.endsWith = (...args)=>inst.check(_endsWith(...args));
+                inst.min = (...args)=>inst.check(_minLength(...args));
+                inst.max = (...args)=>inst.check(_maxLength(...args));
+                inst.length = (...args)=>inst.check(_length(...args));
+                inst.nonempty = (...args)=>inst.check(_minLength(1, ...args));
+                inst.lowercase = (params)=>inst.check(_lowercase(params));
+                inst.uppercase = (params)=>inst.check(_uppercase(params));
+                inst.trim = ()=>inst.check(_trim());
+                inst.normalize = (...args)=>inst.check(_normalize(...args));
+                inst.toLowerCase = ()=>inst.check(_toLowerCase());
+                inst.toUpperCase = ()=>inst.check(_toUpperCase());
+            });
+            const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def)=>{
+                $ZodString.init(inst, def);
+                _ZodString.init(inst, def);
+                inst.email = (params)=>inst.check(_email(ZodEmail, params));
+                inst.url = (params)=>inst.check(_url(ZodURL, params));
+                inst.jwt = (params)=>inst.check(_jwt(ZodJWT, params));
+                inst.emoji = (params)=>inst.check(api_emoji(ZodEmoji, params));
+                inst.guid = (params)=>inst.check(_guid(ZodGUID, params));
+                inst.uuid = (params)=>inst.check(_uuid(ZodUUID, params));
+                inst.uuidv4 = (params)=>inst.check(_uuidv4(ZodUUID, params));
+                inst.uuidv6 = (params)=>inst.check(_uuidv6(ZodUUID, params));
+                inst.uuidv7 = (params)=>inst.check(_uuidv7(ZodUUID, params));
+                inst.nanoid = (params)=>inst.check(_nanoid(ZodNanoID, params));
+                inst.guid = (params)=>inst.check(_guid(ZodGUID, params));
+                inst.cuid = (params)=>inst.check(_cuid(ZodCUID, params));
+                inst.cuid2 = (params)=>inst.check(_cuid2(ZodCUID2, params));
+                inst.ulid = (params)=>inst.check(_ulid(ZodULID, params));
+                inst.base64 = (params)=>inst.check(_base64(ZodBase64, params));
+                inst.base64url = (params)=>inst.check(_base64url(ZodBase64URL, params));
+                inst.xid = (params)=>inst.check(_xid(ZodXID, params));
+                inst.ksuid = (params)=>inst.check(_ksuid(ZodKSUID, params));
+                inst.ipv4 = (params)=>inst.check(_ipv4(ZodIPv4, params));
+                inst.ipv6 = (params)=>inst.check(_ipv6(ZodIPv6, params));
+                inst.cidrv4 = (params)=>inst.check(_cidrv4(ZodCIDRv4, params));
+                inst.cidrv6 = (params)=>inst.check(_cidrv6(ZodCIDRv6, params));
+                inst.e164 = (params)=>inst.check(_e164(ZodE164, params));
+                inst.datetime = (params)=>inst.check(iso_datetime(params));
+                inst.date = (params)=>inst.check(iso_date(params));
+                inst.time = (params)=>inst.check(iso_time(params));
+                inst.duration = (params)=>inst.check(iso_duration(params));
+            });
+            function schemas_string(params) {
+                return _string(ZodString, params);
+            }
+            const ZodStringFormat = /*@__PURE__*/ $constructor("ZodStringFormat", (inst, def)=>{
+                $ZodStringFormat.init(inst, def);
+                _ZodString.init(inst, def);
+            });
+            const ZodEmail = /*@__PURE__*/ $constructor("ZodEmail", (inst, def)=>{
+                $ZodEmail.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodGUID = /*@__PURE__*/ $constructor("ZodGUID", (inst, def)=>{
+                $ZodGUID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodUUID = /*@__PURE__*/ $constructor("ZodUUID", (inst, def)=>{
+                $ZodUUID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodURL = /*@__PURE__*/ $constructor("ZodURL", (inst, def)=>{
+                $ZodURL.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodEmoji = /*@__PURE__*/ $constructor("ZodEmoji", (inst, def)=>{
+                $ZodEmoji.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodNanoID = /*@__PURE__*/ $constructor("ZodNanoID", (inst, def)=>{
+                $ZodNanoID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodCUID = /*@__PURE__*/ $constructor("ZodCUID", (inst, def)=>{
+                $ZodCUID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodCUID2 = /*@__PURE__*/ $constructor("ZodCUID2", (inst, def)=>{
+                $ZodCUID2.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodULID = /*@__PURE__*/ $constructor("ZodULID", (inst, def)=>{
+                $ZodULID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodXID = /*@__PURE__*/ $constructor("ZodXID", (inst, def)=>{
+                $ZodXID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodKSUID = /*@__PURE__*/ $constructor("ZodKSUID", (inst, def)=>{
+                $ZodKSUID.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodIPv4 = /*@__PURE__*/ $constructor("ZodIPv4", (inst, def)=>{
+                $ZodIPv4.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodIPv6 = /*@__PURE__*/ $constructor("ZodIPv6", (inst, def)=>{
+                $ZodIPv6.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodCIDRv4 = /*@__PURE__*/ $constructor("ZodCIDRv4", (inst, def)=>{
+                $ZodCIDRv4.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodCIDRv6 = /*@__PURE__*/ $constructor("ZodCIDRv6", (inst, def)=>{
+                $ZodCIDRv6.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodBase64 = /*@__PURE__*/ $constructor("ZodBase64", (inst, def)=>{
+                $ZodBase64.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodBase64URL = /*@__PURE__*/ $constructor("ZodBase64URL", (inst, def)=>{
+                $ZodBase64URL.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodE164 = /*@__PURE__*/ $constructor("ZodE164", (inst, def)=>{
+                $ZodE164.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodJWT = /*@__PURE__*/ $constructor("ZodJWT", (inst, def)=>{
+                $ZodJWT.init(inst, def);
+                ZodStringFormat.init(inst, def);
+            });
+            const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def)=>{
+                $ZodNumber.init(inst, def);
+                ZodType.init(inst, def);
+                inst.gt = (value, params)=>inst.check(_gt(value, params));
+                inst.gte = (value, params)=>inst.check(_gte(value, params));
+                inst.min = (value, params)=>inst.check(_gte(value, params));
+                inst.lt = (value, params)=>inst.check(_lt(value, params));
+                inst.lte = (value, params)=>inst.check(_lte(value, params));
+                inst.max = (value, params)=>inst.check(_lte(value, params));
+                inst.int = (params)=>inst.check(schemas_int(params));
+                inst.safe = (params)=>inst.check(schemas_int(params));
+                inst.positive = (params)=>inst.check(_gt(0, params));
+                inst.nonnegative = (params)=>inst.check(_gte(0, params));
+                inst.negative = (params)=>inst.check(_lt(0, params));
+                inst.nonpositive = (params)=>inst.check(_lte(0, params));
+                inst.multipleOf = (value, params)=>inst.check(_multipleOf(value, params));
+                inst.step = (value, params)=>inst.check(_multipleOf(value, params));
+                inst.finite = ()=>inst;
+                const bag = inst._zod.bag;
+                inst.minValue = Math.max(bag.minimum ?? -1 / 0, bag.exclusiveMinimum ?? -1 / 0) ?? null;
+                inst.maxValue = Math.min(bag.maximum ?? 1 / 0, bag.exclusiveMaximum ?? 1 / 0) ?? null;
+                inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
+                inst.isFinite = true;
+                inst.format = bag.format ?? null;
+            });
+            function schemas_number(params) {
+                return _number(ZodNumber, params);
+            }
+            const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def)=>{
+                $ZodNumberFormat.init(inst, def);
+                ZodNumber.init(inst, def);
+            });
+            function schemas_int(params) {
+                return _int(ZodNumberFormat, params);
+            }
+            const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def)=>{
+                $ZodBoolean.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function schemas_boolean(params) {
+                return _boolean(ZodBoolean, params);
+            }
+            const ZodUndefined = /*@__PURE__*/ $constructor("ZodUndefined", (inst, def)=>{
+                $ZodUndefined.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function schemas_undefined(params) {
+                return api_undefined(ZodUndefined, params);
+            }
+            const ZodAny = /*@__PURE__*/ $constructor("ZodAny", (inst, def)=>{
+                $ZodAny.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function any() {
+                return _any(ZodAny);
+            }
+            const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def)=>{
+                $ZodUnknown.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function unknown() {
+                return _unknown(ZodUnknown);
+            }
+            const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def)=>{
+                $ZodNever.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function never(params) {
+                return _never(ZodNever, params);
+            }
+            const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def)=>{
+                $ZodArray.init(inst, def);
+                ZodType.init(inst, def);
+                inst.element = def.element;
+                inst.min = (minLength, params)=>inst.check(_minLength(minLength, params));
+                inst.nonempty = (params)=>inst.check(_minLength(1, params));
+                inst.max = (maxLength, params)=>inst.check(_maxLength(maxLength, params));
+                inst.length = (len, params)=>inst.check(_length(len, params));
+                inst.unwrap = ()=>inst.element;
+            });
+            function schemas_array(element, params) {
+                return _array(ZodArray, element, params);
+            }
+            const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def)=>{
+                $ZodObject.init(inst, def);
+                ZodType.init(inst, def);
+                defineLazy(inst, "shape", ()=>def.shape);
+                inst.keyof = ()=>schemas_enum(Object.keys(inst._zod.def.shape));
+                inst.catchall = (catchall)=>inst.clone({
+                        ...inst._zod.def,
+                        catchall: catchall
+                    });
+                inst.passthrough = ()=>inst.clone({
+                        ...inst._zod.def,
+                        catchall: unknown()
+                    });
+                inst.loose = ()=>inst.clone({
+                        ...inst._zod.def,
+                        catchall: unknown()
+                    });
+                inst.strict = ()=>inst.clone({
+                        ...inst._zod.def,
+                        catchall: never()
+                    });
+                inst.strip = ()=>inst.clone({
+                        ...inst._zod.def,
+                        catchall: void 0
+                    });
+                inst.extend = (incoming)=>extend(inst, incoming);
+                inst.merge = (other)=>merge(inst, other);
+                inst.pick = (mask)=>pick(inst, mask);
+                inst.omit = (mask)=>omit(inst, mask);
+                inst.partial = (...args)=>partial(ZodOptional, inst, args[0]);
+                inst.required = (...args)=>required(ZodNonOptional, inst, args[0]);
+            });
+            function schemas_object(shape, params) {
+                const def = {
+                    type: "object",
+                    get shape () {
+                        assignProp(this, "shape", {
+                            ...shape
+                        });
+                        return this.shape;
+                    },
+                    ...normalizeParams(params)
+                };
+                return new ZodObject(def);
+            }
+            const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def)=>{
+                $ZodUnion.init(inst, def);
+                ZodType.init(inst, def);
+                inst.options = def.options;
+            });
+            function union(options, params) {
+                return new ZodUnion({
+                    type: "union",
+                    options: options,
+                    ...normalizeParams(params)
+                });
+            }
+            const ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def)=>{
+                ZodUnion.init(inst, def);
+                $ZodDiscriminatedUnion.init(inst, def);
+            });
+            function discriminatedUnion(discriminator, options, params) {
+                return new ZodDiscriminatedUnion({
+                    type: "union",
+                    options,
+                    discriminator,
+                    ...normalizeParams(params)
+                });
+            }
+            const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def)=>{
+                $ZodIntersection.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function intersection(left, right) {
+                return new ZodIntersection({
+                    type: "intersection",
+                    left: left,
+                    right: right
+                });
+            }
+            const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def)=>{
+                $ZodRecord.init(inst, def);
+                ZodType.init(inst, def);
+                inst.keyType = def.keyType;
+                inst.valueType = def.valueType;
+            });
+            function record(keyType, valueType, params) {
+                return new ZodRecord({
+                    type: "record",
+                    keyType,
+                    valueType: valueType,
+                    ...normalizeParams(params)
+                });
+            }
+            const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def)=>{
+                $ZodEnum.init(inst, def);
+                ZodType.init(inst, def);
+                inst.enum = def.entries;
+                inst.options = Object.values(def.entries);
+                const keys = new Set(Object.keys(def.entries));
+                inst.extract = (values, params)=>{
+                    const newEntries = {};
+                    for (const value of values)if (keys.has(value)) newEntries[value] = def.entries[value];
+                    else throw new Error(`Key ${value} not found in enum`);
+                    return new ZodEnum({
+                        ...def,
+                        checks: [],
+                        ...normalizeParams(params),
+                        entries: newEntries
+                    });
+                };
+                inst.exclude = (values, params)=>{
+                    const newEntries = {
+                        ...def.entries
+                    };
+                    for (const value of values)if (keys.has(value)) delete newEntries[value];
+                    else throw new Error(`Key ${value} not found in enum`);
+                    return new ZodEnum({
+                        ...def,
+                        checks: [],
+                        ...normalizeParams(params),
+                        entries: newEntries
+                    });
+                };
+            });
+            function schemas_enum(values, params) {
+                const entries = Array.isArray(values) ? Object.fromEntries(values.map((v)=>[
+                        v,
+                        v
+                    ])) : values;
+                return new ZodEnum({
+                    type: "enum",
+                    entries,
+                    ...normalizeParams(params)
+                });
+            }
+            const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def)=>{
+                $ZodLiteral.init(inst, def);
+                ZodType.init(inst, def);
+                inst.values = new Set(def.values);
+                Object.defineProperty(inst, "value", {
+                    get () {
+                        if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+                        return def.values[0];
+                    }
+                });
+            });
+            function literal(value, params) {
+                return new ZodLiteral({
+                    type: "literal",
+                    values: Array.isArray(value) ? value : [
+                        value
+                    ],
+                    ...normalizeParams(params)
+                });
+            }
+            const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def)=>{
+                $ZodTransform.init(inst, def);
+                ZodType.init(inst, def);
+                inst._zod.parse = (payload, _ctx)=>{
+                    payload.addIssue = (issue)=>{
+                        if ("string" == typeof issue) payload.issues.push(util_issue(issue, payload.value, def));
+                        else {
+                            const _issue = issue;
+                            if (_issue.fatal) _issue.continue = false;
+                            _issue.code ?? (_issue.code = "custom");
+                            _issue.input ?? (_issue.input = payload.value);
+                            _issue.inst ?? (_issue.inst = inst);
+                            payload.issues.push(util_issue(_issue));
+                        }
+                    };
+                    const output = def.transform(payload.value, payload);
+                    if (output instanceof Promise) return output.then((output)=>{
+                        payload.value = output;
+                        return payload;
+                    });
+                    payload.value = output;
+                    return payload;
+                };
+            });
+            function transform(fn) {
+                return new ZodTransform({
+                    type: "transform",
+                    transform: fn
+                });
+            }
+            const ZodOptional = /*@__PURE__*/ $constructor("ZodOptional", (inst, def)=>{
+                $ZodOptional.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+            });
+            function optional(innerType) {
+                return new ZodOptional({
+                    type: "optional",
+                    innerType: innerType
+                });
+            }
+            const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def)=>{
+                $ZodNullable.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+            });
+            function nullable(innerType) {
+                return new ZodNullable({
+                    type: "nullable",
+                    innerType: innerType
+                });
+            }
+            const ZodDefault = /*@__PURE__*/ $constructor("ZodDefault", (inst, def)=>{
+                $ZodDefault.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+                inst.removeDefault = inst.unwrap;
+            });
+            function schemas_default(innerType, defaultValue) {
+                return new ZodDefault({
+                    type: "default",
+                    innerType: innerType,
+                    get defaultValue () {
+                        return "function" == typeof defaultValue ? defaultValue() : defaultValue;
+                    }
+                });
+            }
+            const ZodPrefault = /*@__PURE__*/ $constructor("ZodPrefault", (inst, def)=>{
+                $ZodPrefault.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+            });
+            function prefault(innerType, defaultValue) {
+                return new ZodPrefault({
+                    type: "prefault",
+                    innerType: innerType,
+                    get defaultValue () {
+                        return "function" == typeof defaultValue ? defaultValue() : defaultValue;
+                    }
+                });
+            }
+            const ZodNonOptional = /*@__PURE__*/ $constructor("ZodNonOptional", (inst, def)=>{
+                $ZodNonOptional.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+            });
+            function nonoptional(innerType, params) {
+                return new ZodNonOptional({
+                    type: "nonoptional",
+                    innerType: innerType,
+                    ...normalizeParams(params)
+                });
+            }
+            const ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def)=>{
+                $ZodCatch.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+                inst.removeCatch = inst.unwrap;
+            });
+            function schemas_catch(innerType, catchValue) {
+                return new ZodCatch({
+                    type: "catch",
+                    innerType: innerType,
+                    catchValue: "function" == typeof catchValue ? catchValue : ()=>catchValue
+                });
+            }
+            const ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def)=>{
+                $ZodPipe.init(inst, def);
+                ZodType.init(inst, def);
+                inst.in = def.in;
+                inst.out = def.out;
+            });
+            function pipe(in_, out) {
+                return new ZodPipe({
+                    type: "pipe",
+                    in: in_,
+                    out: out
+                });
+            }
+            const ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def)=>{
+                $ZodReadonly.init(inst, def);
+                ZodType.init(inst, def);
+                inst.unwrap = ()=>inst._zod.def.innerType;
+            });
+            function readonly(innerType) {
+                return new ZodReadonly({
+                    type: "readonly",
+                    innerType: innerType
+                });
+            }
+            const ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def)=>{
+                $ZodCustom.init(inst, def);
+                ZodType.init(inst, def);
+            });
+            function refine(fn, _params = {}) {
+                return _refine(ZodCustom, fn, _params);
+            }
+            function superRefine(fn) {
+                return _superRefine(fn);
+            }
+        }
+    }
+]);
+
+//# sourceMappingURL=999.js.map