@iflyrpa/share 0.0.15-beta.0 → 0.0.15-beta.2

package/dist/index.js

@@ -39,17 +39,25 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    getFilenameFromUrl: ()=>getFilenameFromUrl,
+    CDPSourceScheme: ()=>CDPSourceScheme,
     semver: ()=>semver,
     pathExists: ()=>pathExists,
-    success: ()=>success,
+    CookieSchema: ()=>CookieSchema,
+    CDPCookiePriority: ()=>CDPCookiePriority,
     randomString: ()=>randomString,
     ensureFile: ()=>ensureFile,
+    fetchJSON: ()=>fetchJSON,
+    sleep: ()=>sleep,
+    getFilenameFromUrl: ()=>getFilenameFromUrl,
+    CDPCookieSchema: ()=>CDPCookieSchema,
+    success: ()=>success,
+    TaskState: ()=>types_TaskState,
+    CDPSameSite: ()=>CDPSameSite,
     ensureFileSync: ()=>ensureFileSync,
     isNil: ()=>isNil,
+    CookieBaseSchema: ()=>CookieBaseSchema,
     downloadImage: ()=>downloadImage,
-    fetchJSON: ()=>fetchJSON,
-    sleep: ()=>sleep,
+    response: ()=>utils_response,
     writeFile: ()=>writeFile
 });
 const external_node_fs_namespaceObject = require("node:fs");
@@ -235,17 +243,17 @@ async function downloadImage(url, savePath) {
                 default:
                     break;
             }
-            customMessage.message = "请求图片时" + customMessage.message;
+            customMessage.message = `请求图片时${customMessage.message}`;
             customMessage.extra = {
                 url
             };
             reject(customMessage);
         };
-        const req = external_node_https_default().get(url, handleResponse);
+        const req = external_node_https_default().get(decodeURIComponent(url), handleResponse);
         req.setTimeout(10000, ()=>{
             req.destroy();
             reject({
-                code: 200,
+                code: 500,
                 message: "图片下载超时，请检查网络连接或稍后重试!"
             });
         });
@@ -254,7 +262,9 @@ async function downloadImage(url, savePath) {
 }
 function getFilenameFromUrl(imageUrl) {
     const parsedUrl = new URL(imageUrl);
-    return external_node_path_default().basename(parsedUrl.pathname);
+    const fileName = external_node_path_default().basename(parsedUrl.pathname);
+    const ext = external_node_path_default().extname(fileName);
+    return ext ? fileName : `${fileName}.png`;
 }
 const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
 const success = (data, message)=>({
@@ -262,12 +272,3404 @@ const success = (data, message)=>({
         message: message || "发布成功",
         data
     });
+const utils_response = (code, message, data)=>({
+        code,
+        message: message || "操作成功",
+        data
+    });
 const randomString = (length)=>{
     let T = "";
     const H = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
     for(let de = 0; de < length; de++)T += H.charAt(Math.floor(Math.random() * H.length));
     return T;
 };
+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.");
+    }
+}
+class $ZodEncodeError extends Error {
+    constructor(name){
+        super(`Encountered unidirectional transform during encode: ${name}`);
+        this.name = "ZodEncodeError";
+    }
+}
+const globalConfig = {};
+function core_config(newConfig) {
+    if (newConfig) Object.assign(globalConfig, newConfig);
+    return globalConfig;
+}
+function util_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 joinValues(array, separator = "|") {
+    return array.map((val)=>stringifyPrimitive(val)).join(separator);
+}
+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;
+}
+function shallowClone(o) {
+    if (isPlainObject(o)) return {
+        ...o
+    };
+    if (Array.isArray(o)) return [
+        ...o
+    ];
+    return o;
+}
+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 stringifyPrimitive(value) {
+    if ("bigint" == typeof value) return value.toString() + "n";
+    if ("string" == typeof value) return `"${value}"`;
+    return `${value}`;
+}
+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: [
+        -340282346638528860000000000000000000000,
+        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 checks = schema._zod.def.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+    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 safeExtend(schema, shape) {
+    if (!isPlainObject(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+    const def = {
+        ...schema._zod.def,
+        get shape () {
+            const _shape = {
+                ...schema._zod.def.shape,
+                ...shape
+            };
+            assignProp(this, "shape", _shape);
+            return _shape;
+        },
+        checks: schema._zod.def.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) {
+    if (true === x.aborted) return true;
+    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 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 = (issue)=>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 _encode = (_Err)=>(schema, value, _ctx)=>{
+        const ctx = _ctx ? Object.assign(_ctx, {
+            direction: "backward"
+        }) : {
+            direction: "backward"
+        };
+        return _parse(_Err)(schema, value, ctx);
+    };
+const _decode = (_Err)=>(schema, value, _ctx)=>_parse(_Err)(schema, value, _ctx);
+const _encodeAsync = (_Err)=>async (schema, value, _ctx)=>{
+        const ctx = _ctx ? Object.assign(_ctx, {
+            direction: "backward"
+        }) : {
+            direction: "backward"
+        };
+        return _parseAsync(_Err)(schema, value, ctx);
+    };
+const _decodeAsync = (_Err)=>async (schema, value, _ctx)=>_parseAsync(_Err)(schema, value, _ctx);
+const _safeEncode = (_Err)=>(schema, value, _ctx)=>{
+        const ctx = _ctx ? Object.assign(_ctx, {
+            direction: "backward"
+        }) : {
+            direction: "backward"
+        };
+        return _safeParse(_Err)(schema, value, ctx);
+    };
+const _safeDecode = (_Err)=>(schema, value, _ctx)=>_safeParse(_Err)(schema, value, _ctx);
+const _safeEncodeAsync = (_Err)=>async (schema, value, _ctx)=>{
+        const ctx = _ctx ? Object.assign(_ctx, {
+            direction: "backward"
+        }) : {
+            direction: "backward"
+        };
+        return _safeParseAsync(_Err)(schema, value, ctx);
+    };
+const _safeDecodeAsync = (_Err)=>async (schema, value, _ctx)=>_safeParseAsync(_Err)(schema, value, _ctx);
+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|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+    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}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
+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 regexes_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 regexes_number = /^-?\d+(?:\.\d+)?/;
+const regexes_boolean = /^(?:true|false)$/i;
+const lowercase = /^[^A-Z]*$/;
+const uppercase = /^[^a-z]*$/;
+const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def)=>{
+    var _a;
+    inst._zod ?? (inst._zod = {});
+    inst._zod.def = def;
+    (_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+const 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) ?? Number.POSITIVE_INFINITY;
+        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) ?? Number.NEGATIVE_INFINITY;
+        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)) {
+                payload.issues.push({
+                    expected: origin,
+                    format: def.format,
+                    code: "invalid_type",
+                    continue: false,
+                    input,
+                    inst
+                });
+                return;
+            }
+            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 ?? Number.POSITIVE_INFINITY;
+        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 ?? Number.NEGATIVE_INFINITY;
+        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 versions_version = {
+    major: 4,
+    minor: 1,
+    patch: 12
+};
+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;
+        };
+        const handleCanaryResult = (canary, payload, ctx)=>{
+            if (aborted(canary)) {
+                canary.aborted = true;
+                return canary;
+            }
+            const checkResult = runChecks(payload, checks, ctx);
+            if (checkResult instanceof Promise) {
+                if (false === ctx.async) throw new $ZodAsyncError();
+                return checkResult.then((checkResult)=>inst._zod.parse(checkResult, ctx));
+            }
+            return inst._zod.parse(checkResult, ctx);
+        };
+        inst._zod.run = (payload, ctx)=>{
+            if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
+            if ("backward" === ctx.direction) {
+                const canary = inst._zod.parse({
+                    value: payload.value,
+                    issues: []
+                }, {
+                    ...ctx,
+                    skipChecks: true
+                });
+                if (canary instanceof Promise) return canary.then((canary)=>handleCanaryResult(canary, payload, ctx));
+                return handleCanaryResult(canary, 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 parts = payload.value.split("/");
+        try {
+            if (2 !== parts.length) throw new Error();
+            const [address, prefix] = parts;
+            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 (!regexes_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 = regexes_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 ?? regexes_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 $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;
+}
+function normalizeDef(def) {
+    const keys = Object.keys(def.shape);
+    for (const k of keys)if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+    const okeys = optionalKeys(def.shape);
+    return {
+        ...def,
+        keys,
+        keySet: new Set(keys),
+        numKeys: keys.length,
+        optionalKeys: new Set(okeys)
+    };
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+    const unrecognized = [];
+    const keySet = def.keySet;
+    const _catchall = def.catchall._zod;
+    const t = _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);
+}
+const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def)=>{
+    $ZodType.init(inst, def);
+    const desc = Object.getOwnPropertyDescriptor(def, "shape");
+    if (!desc?.get) {
+        const sh = def.shape;
+        Object.defineProperty(def, "shape", {
+            get: ()=>{
+                const newSh = {
+                    ...sh
+                };
+                Object.defineProperty(def, "shape", {
+                    value: newSh
+                });
+                return newSh;
+            }
+        });
+    }
+    const _normalized = cached(()=>normalizeDef(def));
+    defineLazy(inst._zod, "propValues", ()=>{
+        const shape = def.shape;
+        const propValues = {};
+        for(const key in shape){
+            const field = shape[key]._zod;
+            if (field.values) {
+                propValues[key] ?? (propValues[key] = new Set());
+                for (const v of field.values)propValues[key].add(v);
+            }
+        }
+        return propValues;
+    });
+    const isObject = util_isObject;
+    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;
+        }
+        payload.value = {};
+        const proms = [];
+        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;
+        return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+    };
+});
+const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def)=>{
+    $ZodObject.init(inst, def);
+    const superParse = inst._zod.parse;
+    const _normalized = cached(()=>normalizeDef(def));
+    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;
+        }
+        if (jit && fastEnabled && ctx?.async === false && true !== ctx.jitless) {
+            if (!fastpass) fastpass = generateFastpass(def.shape);
+            payload = fastpass(payload, ctx);
+            if (!catchall) return payload;
+            return handleCatchall([], input, payload, ctx, value, inst);
+        }
+        return superParse(payload, ctx);
+    };
+});
+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 $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 $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def)=>{
+    $ZodType.init(inst, def);
+    const values = util_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 $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def)=>{
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx)=>{
+        if ("backward" === ctx.direction) throw new $ZodEncodeError(inst.constructor.name);
+        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 ("backward" === ctx.direction) return def.innerType._zod.run(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 ("backward" === ctx.direction) return def.innerType._zod.run(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)=>{
+        if ("backward" === ctx.direction) return def.innerType._zod.run(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)=>{
+        if ("backward" === ctx.direction) {
+            const right = def.out._zod.run(payload, ctx);
+            if (right instanceof Promise) return right.then((right)=>handlePipeResult(right, def.in, ctx));
+            return handlePipeResult(right, def.in, ctx);
+        }
+        const left = def.in._zod.run(payload, ctx);
+        if (left instanceof Promise) return left.then((left)=>handlePipeResult(left, def.out, ctx));
+        return handlePipeResult(left, def.out, ctx);
+    };
+});
+function handlePipeResult(left, next, ctx) {
+    if (left.issues.length) {
+        left.aborted = true;
+        return left;
+    }
+    return next._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)=>{
+        if ("backward" === ctx.direction) return def.innerType._zod.run(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));
+    }
+}
+const en_parsedType = (data)=>{
+    const t = typeof data;
+    switch(t){
+        case "number":
+            return Number.isNaN(data) ? "NaN" : "number";
+        case "object":
+            if (Array.isArray(data)) return "array";
+            if (null === data) return "null";
+            if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) return data.constructor.name;
+    }
+    return t;
+};
+const en_error = ()=>{
+    const Sizable = {
+        string: {
+            unit: "characters",
+            verb: "to have"
+        },
+        file: {
+            unit: "bytes",
+            verb: "to have"
+        },
+        array: {
+            unit: "items",
+            verb: "to have"
+        },
+        set: {
+            unit: "items",
+            verb: "to have"
+        }
+    };
+    function getSizing(origin) {
+        return Sizable[origin] ?? null;
+    }
+    const Nouns = {
+        regex: "input",
+        email: "email address",
+        url: "URL",
+        emoji: "emoji",
+        uuid: "UUID",
+        uuidv4: "UUIDv4",
+        uuidv6: "UUIDv6",
+        nanoid: "nanoid",
+        guid: "GUID",
+        cuid: "cuid",
+        cuid2: "cuid2",
+        ulid: "ULID",
+        xid: "XID",
+        ksuid: "KSUID",
+        datetime: "ISO datetime",
+        date: "ISO date",
+        time: "ISO time",
+        duration: "ISO duration",
+        ipv4: "IPv4 address",
+        ipv6: "IPv6 address",
+        cidrv4: "IPv4 range",
+        cidrv6: "IPv6 range",
+        base64: "base64-encoded string",
+        base64url: "base64url-encoded string",
+        json_string: "JSON string",
+        e164: "E.164 number",
+        jwt: "JWT",
+        template_literal: "input"
+    };
+    return (issue)=>{
+        switch(issue.code){
+            case "invalid_type":
+                return `Invalid input: expected ${issue.expected}, received ${en_parsedType(issue.input)}`;
+            case "invalid_value":
+                if (1 === issue.values.length) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
+                return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
+            case "too_big":
+                {
+                    const adj = issue.inclusive ? "<=" : "<";
+                    const sizing = getSizing(issue.origin);
+                    if (sizing) return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
+                    return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
+                }
+            case "too_small":
+                {
+                    const adj = issue.inclusive ? ">=" : ">";
+                    const sizing = getSizing(issue.origin);
+                    if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+                    return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
+                }
+            case "invalid_format":
+                {
+                    const _issue = issue;
+                    if ("starts_with" === _issue.format) return `Invalid string: must start with "${_issue.prefix}"`;
+                    if ("ends_with" === _issue.format) return `Invalid string: must end with "${_issue.suffix}"`;
+                    if ("includes" === _issue.format) return `Invalid string: must include "${_issue.includes}"`;
+                    if ("regex" === _issue.format) return `Invalid string: must match pattern ${_issue.pattern}`;
+                    return `Invalid ${Nouns[_issue.format] ?? issue.format}`;
+                }
+            case "not_multiple_of":
+                return `Invalid number: must be a multiple of ${issue.divisor}`;
+            case "unrecognized_keys":
+                return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
+            case "invalid_key":
+                return `Invalid key in ${issue.origin}`;
+            case "invalid_union":
+                return "Invalid input";
+            case "invalid_element":
+                return `Invalid value in ${issue.origin}`;
+            default:
+                return "Invalid input";
+        }
+    };
+};
+function en() {
+    return {
+        localeError: en_error()
+    };
+}
+Symbol("ZodOutput");
+Symbol("ZodInput");
+class registries_$ZodRegistry {
+    constructor(){
+        this._map = new WeakMap();
+        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 WeakMap();
+        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 registries_$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 _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 classic_parse_parse = /* @__PURE__ */ _parse(ZodRealError);
+const classic_parse_parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const parse_safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+const parse_safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+const parse_encode = /* @__PURE__ */ _encode(ZodRealError);
+const parse_decode = /* @__PURE__ */ _decode(ZodRealError);
+const parse_encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+const parse_decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+const parse_safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+const parse_safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+const parse_safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+const parse_safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def)=>{
+    $ZodType.init(inst, def);
+    inst.def = def;
+    inst.type = def.type;
+    Object.defineProperty(inst, "_def", {
+        value: def
+    });
+    inst.check = (...checks)=>inst.clone(mergeDefs(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)=>classic_parse_parse(inst, data, params, {
+            callee: inst.parse
+        });
+    inst.safeParse = (data, params)=>parse_safeParse(inst, data, params);
+    inst.parseAsync = async (data, params)=>classic_parse_parseAsync(inst, data, params, {
+            callee: inst.parseAsync
+        });
+    inst.safeParseAsync = async (data, params)=>parse_safeParseAsync(inst, data, params);
+    inst.spa = inst.safeParseAsync;
+    inst.encode = (data, params)=>parse_encode(inst, data, params);
+    inst.decode = (data, params)=>parse_decode(inst, data, params);
+    inst.encodeAsync = async (data, params)=>parse_encodeAsync(inst, data, params);
+    inst.decodeAsync = async (data, params)=>parse_decodeAsync(inst, data, params);
+    inst.safeEncode = (data, params)=>parse_safeEncode(inst, data, params);
+    inst.safeDecode = (data, params)=>parse_safeDecode(inst, data, params);
+    inst.safeEncodeAsync = async (data, params)=>parse_safeEncodeAsync(inst, data, params);
+    inst.safeDecodeAsync = async (data, params)=>parse_safeDecodeAsync(inst, data, params);
+    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 ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+    inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? 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 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)=>{
+    $ZodObjectJIT.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.safeExtend = (incoming)=>safeExtend(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",
+        shape: 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 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 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 ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def)=>{
+    $ZodTransform.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.parse = (payload, _ctx)=>{
+        if ("backward" === _ctx.direction) throw new $ZodEncodeError(inst.constructor.name);
+        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() : shallowClone(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() : shallowClone(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);
+}
+var compat_ZodFirstPartyTypeKind;
+compat_ZodFirstPartyTypeKind || (compat_ZodFirstPartyTypeKind = {});
+core_config(en());
+const CookieBaseSchema = schemas_object({
+    domain: schemas_string().optional(),
+    path: schemas_string().optional(),
+    expires: schemas_number().optional(),
+    httpOnly: schemas_boolean().optional(),
+    secure: schemas_boolean().optional(),
+    session: schemas_boolean().optional()
+});
+const CookieSchema = CookieBaseSchema.extend({
+    url: schemas_string(),
+    name: schemas_string().optional(),
+    value: schemas_string().optional(),
+    sameSite: schemas_enum([
+        'unspecified',
+        'no_restriction',
+        'lax',
+        'strict'
+    ]).optional()
+});
+const CDPSameSite = schemas_enum([
+    "Strict",
+    "Lax",
+    "None"
+]);
+const CDPCookiePriority = schemas_enum([
+    "Low",
+    "Medium",
+    "High"
+]);
+const CDPSourceScheme = schemas_enum([
+    "Unset",
+    "NonSecure",
+    "Secure"
+]);
+const CDPCookieSchema = CookieBaseSchema.extend({
+    name: schemas_string(),
+    value: schemas_string(),
+    url: schemas_string().optional(),
+    sameSite: CDPSameSite.optional(),
+    size: schemas_number().optional(),
+    partitionKey: schemas_object({
+        topLevelSite: schemas_string(),
+        hasCrossSiteAncestor: schemas_boolean()
+    }).optional(),
+    priority: CDPCookiePriority.optional(),
+    sameParty: schemas_boolean().optional(),
+    sourceScheme: CDPSourceScheme.optional(),
+    sourcePort: schemas_number().optional()
+});
+var types_TaskState = /*#__PURE__*/ function(TaskState) {
+    TaskState["INIT"] = "INIT";
+    TaskState["ACTION"] = "ACTION";
+    TaskState["WAIT_SCAN"] = "WAIT_SCAN";
+    TaskState["SCANNED"] = "SCANNED";
+    TaskState["CONFIRMED"] = "CONFIRMED";
+    TaskState["SUCCESS"] = "SUCCESS";
+    TaskState["FAILED"] = "FAILED";
+    TaskState["TIMEOUT"] = "TIMEOUT";
+    return TaskState;
+}({});
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
 if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {