@scalar/agent-chat 0.2.0 → 0.2.2

package/dist/node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/schemas.js

@@ -0,0 +1,1318 @@
+import { $ZodCheck as de, $ZodCheckStringFormat as he, $ZodCheckNumberFormat as ve, $ZodCheckBigIntFormat as _e } from "./checks.js";
+import { $constructor as l, $ZodEncodeError as te, $ZodAsyncError as D, config as b, globalConfig as fe } from "./core.js";
+import { Doc as me } from "./doc.js";
+import { safeParse as ze, safeParseAsync as $e, parse as B, parseAsync as K } from "./parse.js";
+import { number as re, string as ge, email as Ze, boolean as we, null as be, guid as Pe, uuid as x, emoji as ke, nanoid as Te, cuid as Ie, cuid2 as Se, ulid as Ee, xid as Re, ksuid as Oe, datetime as De, date as Ne, time as je, duration as Ue, ipv4 as Ae, ipv6 as Ce, mac as Ve, cidrv4 as Fe, cidrv6 as Le, base64 as Be, base64url as oe, e164 as Ke, bigint as xe, undefined as Me } from "./regexes.js";
+import { defineLazy as v, aborted as k, cleanRegex as V, finalizeIssue as P, isPlainObject as U, allowsEval as Je, cached as F, isObject as L, esc as M, prefixIssues as w, getEnumValues as We, propertyKeyTypes as A, escapeRegex as N, optionalKeys as ye, issue as Xe, primitiveTypes as Ge } from "./util.js";
+import { clone as Tt } from "./util.js";
+import { version as He } from "./versions.js";
+const h = /* @__PURE__ */ l("$ZodType", (e, n) => {
+  var t;
+  e ?? (e = {}), e._zod.def = n, e._zod.bag = e._zod.bag || {}, e._zod.version = He;
+  const o = [...e._zod.def.checks ?? []];
+  e._zod.traits.has("$ZodCheck") && o.unshift(e);
+  for (const r of o)
+    for (const s of r._zod.onattach)
+      s(e);
+  if (o.length === 0)
+    (t = e._zod).deferred ?? (t.deferred = []), e._zod.deferred?.push(() => {
+      e._zod.run = e._zod.parse;
+    });
+  else {
+    const r = (i, u, c) => {
+      let a = k(i), p;
+      for (const d of u) {
+        if (d._zod.def.when) {
+          if (!d._zod.def.when(i))
+            continue;
+        } else if (a)
+          continue;
+        const _ = i.issues.length, f = d._zod.check(i);
+        if (f instanceof Promise && c?.async === !1)
+          throw new D();
+        if (p || f instanceof Promise)
+          p = (p ?? Promise.resolve()).then(async () => {
+            await f, i.issues.length !== _ && (a || (a = k(i, _)));
+          });
+        else {
+          if (i.issues.length === _)
+            continue;
+          a || (a = k(i, _));
+        }
+      }
+      return p ? p.then(() => i) : i;
+    }, s = (i, u, c) => {
+      if (k(i))
+        return i.aborted = !0, i;
+      const a = r(u, o, c);
+      if (a instanceof Promise) {
+        if (c.async === !1)
+          throw new D();
+        return a.then((p) => e._zod.parse(p, c));
+      }
+      return e._zod.parse(a, c);
+    };
+    e._zod.run = (i, u) => {
+      if (u.skipChecks)
+        return e._zod.parse(i, u);
+      if (u.direction === "backward") {
+        const a = e._zod.parse({ value: i.value, issues: [] }, { ...u, skipChecks: !0 });
+        return a instanceof Promise ? a.then((p) => s(p, i, u)) : s(a, i, u);
+      }
+      const c = e._zod.parse(i, u);
+      if (c instanceof Promise) {
+        if (u.async === !1)
+          throw new D();
+        return c.then((a) => r(a, o, u));
+      }
+      return r(c, o, u);
+    };
+  }
+  v(e, "~standard", () => ({
+    validate: (r) => {
+      try {
+        const s = ze(e, r);
+        return s.success ? { value: s.data } : { issues: s.error?.issues };
+      } catch {
+        return $e(e, r).then((i) => i.success ? { value: i.data } : { issues: i.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  }));
+}), qe = /* @__PURE__ */ l("$ZodString", (e, n) => {
+  h.init(e, n), e._zod.pattern = [...e?._zod.bag?.patterns ?? []].pop() ?? ge(e._zod.bag), e._zod.parse = (t, o) => {
+    if (n.coerce)
+      try {
+        t.value = String(t.value);
+      } catch {
+      }
+    return typeof t.value == "string" || t.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: t.value,
+      inst: e
+    }), t;
+  };
+}), m = /* @__PURE__ */ l("$ZodStringFormat", (e, n) => {
+  he.init(e, n), qe.init(e, n);
+}), vn = /* @__PURE__ */ l("$ZodGUID", (e, n) => {
+  n.pattern ?? (n.pattern = Pe), m.init(e, n);
+}), _n = /* @__PURE__ */ l("$ZodUUID", (e, n) => {
+  if (n.version) {
+    const o = {
+      v1: 1,
+      v2: 2,
+      v3: 3,
+      v4: 4,
+      v5: 5,
+      v6: 6,
+      v7: 7,
+      v8: 8
+    }[n.version];
+    if (o === void 0)
+      throw new Error(`Invalid UUID version: "${n.version}"`);
+    n.pattern ?? (n.pattern = x(o));
+  } else
+    n.pattern ?? (n.pattern = x());
+  m.init(e, n);
+}), fn = /* @__PURE__ */ l("$ZodEmail", (e, n) => {
+  n.pattern ?? (n.pattern = Ze), m.init(e, n);
+}), mn = /* @__PURE__ */ l("$ZodURL", (e, n) => {
+  m.init(e, n), e._zod.check = (t) => {
+    try {
+      const o = t.value.trim(), r = new URL(o);
+      n.hostname && (n.hostname.lastIndex = 0, n.hostname.test(r.hostname) || t.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid hostname",
+        pattern: n.hostname.source,
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      })), n.protocol && (n.protocol.lastIndex = 0, n.protocol.test(r.protocol.endsWith(":") ? r.protocol.slice(0, -1) : r.protocol) || t.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid protocol",
+        pattern: n.protocol.source,
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      })), n.normalize ? t.value = r.href : t.value = o;
+      return;
+    } catch {
+      t.issues.push({
+        code: "invalid_format",
+        format: "url",
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      });
+    }
+  };
+}), zn = /* @__PURE__ */ l("$ZodEmoji", (e, n) => {
+  n.pattern ?? (n.pattern = ke()), m.init(e, n);
+}), $n = /* @__PURE__ */ l("$ZodNanoID", (e, n) => {
+  n.pattern ?? (n.pattern = Te), m.init(e, n);
+}), gn = /* @__PURE__ */ l("$ZodCUID", (e, n) => {
+  n.pattern ?? (n.pattern = Ie), m.init(e, n);
+}), Zn = /* @__PURE__ */ l("$ZodCUID2", (e, n) => {
+  n.pattern ?? (n.pattern = Se), m.init(e, n);
+}), wn = /* @__PURE__ */ l("$ZodULID", (e, n) => {
+  n.pattern ?? (n.pattern = Ee), m.init(e, n);
+}), bn = /* @__PURE__ */ l("$ZodXID", (e, n) => {
+  n.pattern ?? (n.pattern = Re), m.init(e, n);
+}), Pn = /* @__PURE__ */ l("$ZodKSUID", (e, n) => {
+  n.pattern ?? (n.pattern = Oe), m.init(e, n);
+}), kn = /* @__PURE__ */ l("$ZodISODateTime", (e, n) => {
+  n.pattern ?? (n.pattern = De(n)), m.init(e, n);
+}), Tn = /* @__PURE__ */ l("$ZodISODate", (e, n) => {
+  n.pattern ?? (n.pattern = Ne), m.init(e, n);
+}), In = /* @__PURE__ */ l("$ZodISOTime", (e, n) => {
+  n.pattern ?? (n.pattern = je(n)), m.init(e, n);
+}), Sn = /* @__PURE__ */ l("$ZodISODuration", (e, n) => {
+  n.pattern ?? (n.pattern = Ue), m.init(e, n);
+}), En = /* @__PURE__ */ l("$ZodIPv4", (e, n) => {
+  n.pattern ?? (n.pattern = Ae), m.init(e, n), e._zod.bag.format = "ipv4";
+}), Rn = /* @__PURE__ */ l("$ZodIPv6", (e, n) => {
+  n.pattern ?? (n.pattern = Ce), m.init(e, n), e._zod.bag.format = "ipv6", e._zod.check = (t) => {
+    try {
+      new URL(`http://[${t.value}]`);
+    } catch {
+      t.issues.push({
+        code: "invalid_format",
+        format: "ipv6",
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      });
+    }
+  };
+}), On = /* @__PURE__ */ l("$ZodMAC", (e, n) => {
+  n.pattern ?? (n.pattern = Ve(n.delimiter)), m.init(e, n), e._zod.bag.format = "mac";
+}), Dn = /* @__PURE__ */ l("$ZodCIDRv4", (e, n) => {
+  n.pattern ?? (n.pattern = Fe), m.init(e, n);
+}), Nn = /* @__PURE__ */ l("$ZodCIDRv6", (e, n) => {
+  n.pattern ?? (n.pattern = Le), m.init(e, n), e._zod.check = (t) => {
+    const o = t.value.split("/");
+    try {
+      if (o.length !== 2)
+        throw new Error();
+      const [r, s] = o;
+      if (!s)
+        throw new Error();
+      const i = Number(s);
+      if (`${i}` !== s)
+        throw new Error();
+      if (i < 0 || i > 128)
+        throw new Error();
+      new URL(`http://[${r}]`);
+    } catch {
+      t.issues.push({
+        code: "invalid_format",
+        format: "cidrv6",
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      });
+    }
+  };
+});
+function se(e) {
+  if (e === "")
+    return !0;
+  if (e.length % 4 !== 0)
+    return !1;
+  try {
+    return atob(e), !0;
+  } catch {
+    return !1;
+  }
+}
+const jn = /* @__PURE__ */ l("$ZodBase64", (e, n) => {
+  n.pattern ?? (n.pattern = Be), m.init(e, n), e._zod.bag.contentEncoding = "base64", e._zod.check = (t) => {
+    se(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: "base64",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+});
+function Qe(e) {
+  if (!oe.test(e))
+    return !1;
+  const n = e.replace(/[-_]/g, (o) => o === "-" ? "+" : "/"), t = n.padEnd(Math.ceil(n.length / 4) * 4, "=");
+  return se(t);
+}
+const Un = /* @__PURE__ */ l("$ZodBase64URL", (e, n) => {
+  n.pattern ?? (n.pattern = oe), m.init(e, n), e._zod.bag.contentEncoding = "base64url", e._zod.check = (t) => {
+    Qe(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: "base64url",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), An = /* @__PURE__ */ l("$ZodE164", (e, n) => {
+  n.pattern ?? (n.pattern = Ke), m.init(e, n);
+});
+function Ye(e, n = null) {
+  try {
+    const t = e.split(".");
+    if (t.length !== 3)
+      return !1;
+    const [o] = t;
+    if (!o)
+      return !1;
+    const r = JSON.parse(atob(o));
+    return !("typ" in r && r?.typ !== "JWT" || !r.alg || n && (!("alg" in r) || r.alg !== n));
+  } catch {
+    return !1;
+  }
+}
+const Cn = /* @__PURE__ */ l("$ZodJWT", (e, n) => {
+  m.init(e, n), e._zod.check = (t) => {
+    Ye(t.value, n.alg) || t.issues.push({
+      code: "invalid_format",
+      format: "jwt",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), Vn = /* @__PURE__ */ l("$ZodCustomStringFormat", (e, n) => {
+  m.init(e, n), e._zod.check = (t) => {
+    n.fn(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: n.format,
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), en = /* @__PURE__ */ l("$ZodNumber", (e, n) => {
+  h.init(e, n), e._zod.pattern = e._zod.bag.pattern ?? re, e._zod.parse = (t, o) => {
+    if (n.coerce)
+      try {
+        t.value = Number(t.value);
+      } catch {
+      }
+    const r = t.value;
+    if (typeof r == "number" && !Number.isNaN(r) && Number.isFinite(r))
+      return t;
+    const s = typeof r == "number" ? Number.isNaN(r) ? "NaN" : Number.isFinite(r) ? void 0 : "Infinity" : void 0;
+    return t.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input: r,
+      inst: e,
+      ...s ? { received: s } : {}
+    }), t;
+  };
+}), Fn = /* @__PURE__ */ l("$ZodNumberFormat", (e, n) => {
+  ve.init(e, n), en.init(e, n);
+}), Ln = /* @__PURE__ */ l("$ZodBoolean", (e, n) => {
+  h.init(e, n), e._zod.pattern = we, e._zod.parse = (t, o) => {
+    if (n.coerce)
+      try {
+        t.value = !!t.value;
+      } catch {
+      }
+    const r = t.value;
+    return typeof r == "boolean" || t.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input: r,
+      inst: e
+    }), t;
+  };
+}), nn = /* @__PURE__ */ l("$ZodBigInt", (e, n) => {
+  h.init(e, n), e._zod.pattern = xe, e._zod.parse = (t, o) => {
+    if (n.coerce)
+      try {
+        t.value = BigInt(t.value);
+      } catch {
+      }
+    return typeof t.value == "bigint" || t.issues.push({
+      expected: "bigint",
+      code: "invalid_type",
+      input: t.value,
+      inst: e
+    }), t;
+  };
+}), Bn = /* @__PURE__ */ l("$ZodBigIntFormat", (e, n) => {
+  _e.init(e, n), nn.init(e, n);
+}), Kn = /* @__PURE__ */ l("$ZodSymbol", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    return typeof r == "symbol" || t.issues.push({
+      expected: "symbol",
+      code: "invalid_type",
+      input: r,
+      inst: e
+    }), t;
+  };
+}), xn = /* @__PURE__ */ l("$ZodUndefined", (e, n) => {
+  h.init(e, n), e._zod.pattern = Me, e._zod.values = /* @__PURE__ */ new Set([void 0]), e._zod.optin = "optional", e._zod.optout = "optional", e._zod.parse = (t, o) => {
+    const r = t.value;
+    return typeof r > "u" || t.issues.push({
+      expected: "undefined",
+      code: "invalid_type",
+      input: r,
+      inst: e
+    }), t;
+  };
+}), Mn = /* @__PURE__ */ l("$ZodNull", (e, n) => {
+  h.init(e, n), e._zod.pattern = be, e._zod.values = /* @__PURE__ */ new Set([null]), e._zod.parse = (t, o) => {
+    const r = t.value;
+    return r === null || t.issues.push({
+      expected: "null",
+      code: "invalid_type",
+      input: r,
+      inst: e
+    }), t;
+  };
+}), Jn = /* @__PURE__ */ l("$ZodAny", (e, n) => {
+  h.init(e, n), e._zod.parse = (t) => t;
+}), Wn = /* @__PURE__ */ l("$ZodUnknown", (e, n) => {
+  h.init(e, n), e._zod.parse = (t) => t;
+}), yn = /* @__PURE__ */ l("$ZodNever", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => (t.issues.push({
+    expected: "never",
+    code: "invalid_type",
+    input: t.value,
+    inst: e
+  }), t);
+}), Xn = /* @__PURE__ */ l("$ZodVoid", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    return typeof r > "u" || t.issues.push({
+      expected: "void",
+      code: "invalid_type",
+      input: r,
+      inst: e
+    }), t;
+  };
+}), Gn = /* @__PURE__ */ l("$ZodDate", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    if (n.coerce)
+      try {
+        t.value = new Date(t.value);
+      } catch {
+      }
+    const r = t.value, s = r instanceof Date;
+    return s && !Number.isNaN(r.getTime()) || t.issues.push({
+      expected: "date",
+      code: "invalid_type",
+      input: r,
+      ...s ? { received: "Invalid Date" } : {},
+      inst: e
+    }), t;
+  };
+});
+function J(e, n, t) {
+  e.issues.length && n.issues.push(...w(t, e.issues)), n.value[t] = e.value;
+}
+const Hn = /* @__PURE__ */ l("$ZodArray", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    if (!Array.isArray(r))
+      return t.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input: r,
+        inst: e
+      }), t;
+    t.value = Array(r.length);
+    const s = [];
+    for (let i = 0; i < r.length; i++) {
+      const u = r[i], c = n.element._zod.run({
+        value: u,
+        issues: []
+      }, o);
+      c instanceof Promise ? s.push(c.then((a) => J(a, t, i))) : J(c, t, i);
+    }
+    return s.length ? Promise.all(s).then(() => t) : t;
+  };
+});
+function j(e, n, t, o, r) {
+  if (e.issues.length) {
+    if (r && !(t in o))
+      return;
+    n.issues.push(...w(t, e.issues));
+  }
+  e.value === void 0 ? t in o && (n.value[t] = void 0) : n.value[t] = e.value;
+}
+function ie(e) {
+  const n = Object.keys(e.shape);
+  for (const o of n)
+    if (!e.shape?.[o]?._zod?.traits?.has("$ZodType"))
+      throw new Error(`Invalid element at key "${o}": expected a Zod schema`);
+  const t = ye(e.shape);
+  return {
+    ...e,
+    keys: n,
+    keySet: new Set(n),
+    numKeys: n.length,
+    optionalKeys: new Set(t)
+  };
+}
+function ue(e, n, t, o, r, s) {
+  const i = [], u = r.keySet, c = r.catchall._zod, a = c.def.type, p = c.optout === "optional";
+  for (const d in n) {
+    if (u.has(d))
+      continue;
+    if (a === "never") {
+      i.push(d);
+      continue;
+    }
+    const _ = c.run({ value: n[d], issues: [] }, o);
+    _ instanceof Promise ? e.push(_.then((f) => j(f, t, d, n, p))) : j(_, t, d, n, p);
+  }
+  return i.length && t.issues.push({
+    code: "unrecognized_keys",
+    keys: i,
+    input: n,
+    inst: s
+  }), e.length ? Promise.all(e).then(() => t) : t;
+}
+const tn = /* @__PURE__ */ l("$ZodObject", (e, n) => {
+  if (h.init(e, n), !Object.getOwnPropertyDescriptor(n, "shape")?.get) {
+    const u = n.shape;
+    Object.defineProperty(n, "shape", {
+      get: () => {
+        const c = { ...u };
+        return Object.defineProperty(n, "shape", {
+          value: c
+        }), c;
+      }
+    });
+  }
+  const o = F(() => ie(n));
+  v(e._zod, "propValues", () => {
+    const u = n.shape, c = {};
+    for (const a in u) {
+      const p = u[a]._zod;
+      if (p.values) {
+        c[a] ?? (c[a] = /* @__PURE__ */ new Set());
+        for (const d of p.values)
+          c[a].add(d);
+      }
+    }
+    return c;
+  });
+  const r = L, s = n.catchall;
+  let i;
+  e._zod.parse = (u, c) => {
+    i ?? (i = o.value);
+    const a = u.value;
+    if (!r(a))
+      return u.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input: a,
+        inst: e
+      }), u;
+    u.value = {};
+    const p = [], d = i.shape;
+    for (const _ of i.keys) {
+      const f = d[_], $ = f._zod.optout === "optional", T = f._zod.run({ value: a[_], issues: [] }, c);
+      T instanceof Promise ? p.push(T.then((I) => j(I, u, _, a, $))) : j(T, u, _, a, $);
+    }
+    return s ? ue(p, a, u, c, o.value, e) : p.length ? Promise.all(p).then(() => u) : u;
+  };
+}), qn = /* @__PURE__ */ l("$ZodObjectJIT", (e, n) => {
+  tn.init(e, n);
+  const t = e._zod.parse, o = F(() => ie(n)), r = (_) => {
+    const f = new me(["shape", "payload", "ctx"]), $ = o.value, T = (Z) => {
+      const z = M(Z);
+      return `shape[${z}]._zod.run({ value: input[${z}], issues: [] }, ctx)`;
+    };
+    f.write("const input = payload.value;");
+    const I = /* @__PURE__ */ Object.create(null);
+    let ae = 0;
+    for (const Z of $.keys)
+      I[Z] = `key_${ae++}`;
+    f.write("const newResult = {};");
+    for (const Z of $.keys) {
+      const z = I[Z], g = M(Z), pe = _[Z]?._zod?.optout === "optional";
+      f.write(`const ${z} = ${T(Z)};`), pe ? f.write(`
+        if (${z}.issues.length) {
+          if (${g} in input) {
+            payload.issues = payload.issues.concat(${z}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${g}, ...iss.path] : [${g}]
+            })));
+          }
+        }
+        
+        if (${z}.value === undefined) {
+          if (${g} in input) {
+            newResult[${g}] = undefined;
+          }
+        } else {
+          newResult[${g}] = ${z}.value;
+        }
+        
+      `) : f.write(`
+        if (${z}.issues.length) {
+          payload.issues = payload.issues.concat(${z}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${g}, ...iss.path] : [${g}]
+          })));
+        }
+        
+        if (${z}.value === undefined) {
+          if (${g} in input) {
+            newResult[${g}] = undefined;
+          }
+        } else {
+          newResult[${g}] = ${z}.value;
+        }
+        
+      `);
+    }
+    f.write("payload.value = newResult;"), f.write("return payload;");
+    const le = f.compile();
+    return (Z, z) => le(_, Z, z);
+  };
+  let s;
+  const i = L, u = !fe.jitless, a = u && Je.value, p = n.catchall;
+  let d;
+  e._zod.parse = (_, f) => {
+    d ?? (d = o.value);
+    const $ = _.value;
+    return i($) ? u && a && f?.async === !1 && f.jitless !== !0 ? (s || (s = r(n.shape)), _ = s(_, f), p ? ue([], $, _, f, d, e) : _) : t(_, f) : (_.issues.push({
+      expected: "object",
+      code: "invalid_type",
+      input: $,
+      inst: e
+    }), _);
+  };
+});
+function W(e, n, t, o) {
+  for (const s of e)
+    if (s.issues.length === 0)
+      return n.value = s.value, n;
+  const r = e.filter((s) => !k(s));
+  return r.length === 1 ? (n.value = r[0].value, r[0]) : (n.issues.push({
+    code: "invalid_union",
+    input: n.value,
+    inst: t,
+    errors: e.map((s) => s.issues.map((i) => P(i, o, b())))
+  }), n);
+}
+const ce = /* @__PURE__ */ l("$ZodUnion", (e, n) => {
+  h.init(e, n), v(e._zod, "optin", () => n.options.some((r) => r._zod.optin === "optional") ? "optional" : void 0), v(e._zod, "optout", () => n.options.some((r) => r._zod.optout === "optional") ? "optional" : void 0), v(e._zod, "values", () => {
+    if (n.options.every((r) => r._zod.values))
+      return new Set(n.options.flatMap((r) => Array.from(r._zod.values)));
+  }), v(e._zod, "pattern", () => {
+    if (n.options.every((r) => r._zod.pattern)) {
+      const r = n.options.map((s) => s._zod.pattern);
+      return new RegExp(`^(${r.map((s) => V(s.source)).join("|")})$`);
+    }
+  });
+  const t = n.options.length === 1, o = n.options[0]._zod.run;
+  e._zod.parse = (r, s) => {
+    if (t)
+      return o(r, s);
+    let i = !1;
+    const u = [];
+    for (const c of n.options) {
+      const a = c._zod.run({
+        value: r.value,
+        issues: []
+      }, s);
+      if (a instanceof Promise)
+        u.push(a), i = !0;
+      else {
+        if (a.issues.length === 0)
+          return a;
+        u.push(a);
+      }
+    }
+    return i ? Promise.all(u).then((c) => W(c, r, e, s)) : W(u, r, e, s);
+  };
+});
+function y(e, n, t, o) {
+  const r = e.filter((s) => s.issues.length === 0);
+  return r.length === 1 ? (n.value = r[0].value, n) : (r.length === 0 ? n.issues.push({
+    code: "invalid_union",
+    input: n.value,
+    inst: t,
+    errors: e.map((s) => s.issues.map((i) => P(i, o, b())))
+  }) : n.issues.push({
+    code: "invalid_union",
+    input: n.value,
+    inst: t,
+    errors: [],
+    inclusive: !1
+  }), n);
+}
+const Qn = /* @__PURE__ */ l("$ZodXor", (e, n) => {
+  ce.init(e, n), n.inclusive = !1;
+  const t = n.options.length === 1, o = n.options[0]._zod.run;
+  e._zod.parse = (r, s) => {
+    if (t)
+      return o(r, s);
+    let i = !1;
+    const u = [];
+    for (const c of n.options) {
+      const a = c._zod.run({
+        value: r.value,
+        issues: []
+      }, s);
+      a instanceof Promise ? (u.push(a), i = !0) : u.push(a);
+    }
+    return i ? Promise.all(u).then((c) => y(c, r, e, s)) : y(u, r, e, s);
+  };
+}), Yn = /* @__PURE__ */ l("$ZodDiscriminatedUnion", (e, n) => {
+  n.inclusive = !1, ce.init(e, n);
+  const t = e._zod.parse;
+  v(e._zod, "propValues", () => {
+    const r = {};
+    for (const s of n.options) {
+      const i = s._zod.propValues;
+      if (!i || Object.keys(i).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${n.options.indexOf(s)}"`);
+      for (const [u, c] of Object.entries(i)) {
+        r[u] || (r[u] = /* @__PURE__ */ new Set());
+        for (const a of c)
+          r[u].add(a);
+      }
+    }
+    return r;
+  });
+  const o = F(() => {
+    const r = n.options, s = /* @__PURE__ */ new Map();
+    for (const i of r) {
+      const u = i._zod.propValues?.[n.discriminator];
+      if (!u || u.size === 0)
+        throw new Error(`Invalid discriminated union option at index "${n.options.indexOf(i)}"`);
+      for (const c of u) {
+        if (s.has(c))
+          throw new Error(`Duplicate discriminator value "${String(c)}"`);
+        s.set(c, i);
+      }
+    }
+    return s;
+  });
+  e._zod.parse = (r, s) => {
+    const i = r.value;
+    if (!L(i))
+      return r.issues.push({
+        code: "invalid_type",
+        expected: "object",
+        input: i,
+        inst: e
+      }), r;
+    const u = o.value.get(i?.[n.discriminator]);
+    return u ? u._zod.run(r, s) : n.unionFallback ? t(r, s) : (r.issues.push({
+      code: "invalid_union",
+      errors: [],
+      note: "No matching discriminator",
+      discriminator: n.discriminator,
+      input: i,
+      path: [n.discriminator],
+      inst: e
+    }), r);
+  };
+}), et = /* @__PURE__ */ l("$ZodIntersection", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value, s = n.left._zod.run({ value: r, issues: [] }, o), i = n.right._zod.run({ value: r, issues: [] }, o);
+    return s instanceof Promise || i instanceof Promise ? Promise.all([s, i]).then(([c, a]) => X(t, c, a)) : X(t, s, i);
+  };
+});
+function C(e, n) {
+  if (e === n)
+    return { valid: !0, data: e };
+  if (e instanceof Date && n instanceof Date && +e == +n)
+    return { valid: !0, data: e };
+  if (U(e) && U(n)) {
+    const t = Object.keys(n), o = Object.keys(e).filter((s) => t.indexOf(s) !== -1), r = { ...e, ...n };
+    for (const s of o) {
+      const i = C(e[s], n[s]);
+      if (!i.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [s, ...i.mergeErrorPath]
+        };
+      r[s] = i.data;
+    }
+    return { valid: !0, data: r };
+  }
+  if (Array.isArray(e) && Array.isArray(n)) {
+    if (e.length !== n.length)
+      return { valid: !1, mergeErrorPath: [] };
+    const t = [];
+    for (let o = 0; o < e.length; o++) {
+      const r = e[o], s = n[o], i = C(r, s);
+      if (!i.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [o, ...i.mergeErrorPath]
+        };
+      t.push(i.data);
+    }
+    return { valid: !0, data: t };
+  }
+  return { valid: !1, mergeErrorPath: [] };
+}
+function X(e, n, t) {
+  const o = /* @__PURE__ */ new Map();
+  let r;
+  for (const u of n.issues)
+    if (u.code === "unrecognized_keys") {
+      r ?? (r = u);
+      for (const c of u.keys)
+        o.has(c) || o.set(c, {}), o.get(c).l = !0;
+    } else
+      e.issues.push(u);
+  for (const u of t.issues)
+    if (u.code === "unrecognized_keys")
+      for (const c of u.keys)
+        o.has(c) || o.set(c, {}), o.get(c).r = !0;
+    else
+      e.issues.push(u);
+  const s = [...o].filter(([, u]) => u.l && u.r).map(([u]) => u);
+  if (s.length && r && e.issues.push({ ...r, keys: s }), k(e))
+    return e;
+  const i = C(n.value, t.value);
+  if (!i.valid)
+    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(i.mergeErrorPath)}`);
+  return e.value = i.data, e;
+}
+const rn = /* @__PURE__ */ l("$ZodTuple", (e, n) => {
+  h.init(e, n);
+  const t = n.items;
+  e._zod.parse = (o, r) => {
+    const s = o.value;
+    if (!Array.isArray(s))
+      return o.issues.push({
+        input: s,
+        inst: e,
+        expected: "tuple",
+        code: "invalid_type"
+      }), o;
+    o.value = [];
+    const i = [], u = [...t].reverse().findIndex((p) => p._zod.optin !== "optional"), c = u === -1 ? 0 : t.length - u;
+    if (!n.rest) {
+      const p = s.length > t.length, d = s.length < c - 1;
+      if (p || d)
+        return o.issues.push({
+          ...p ? { code: "too_big", maximum: t.length, inclusive: !0 } : { code: "too_small", minimum: t.length },
+          input: s,
+          inst: e,
+          origin: "array"
+        }), o;
+    }
+    let a = -1;
+    for (const p of t) {
+      if (a++, a >= s.length && a >= c)
+        continue;
+      const d = p._zod.run({
+        value: s[a],
+        issues: []
+      }, r);
+      d instanceof Promise ? i.push(d.then((_) => S(_, o, a))) : S(d, o, a);
+    }
+    if (n.rest) {
+      const p = s.slice(t.length);
+      for (const d of p) {
+        a++;
+        const _ = n.rest._zod.run({
+          value: d,
+          issues: []
+        }, r);
+        _ instanceof Promise ? i.push(_.then((f) => S(f, o, a))) : S(_, o, a);
+      }
+    }
+    return i.length ? Promise.all(i).then(() => o) : o;
+  };
+});
+function S(e, n, t) {
+  e.issues.length && n.issues.push(...w(t, e.issues)), n.value[t] = e.value;
+}
+const nt = /* @__PURE__ */ l("$ZodRecord", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    if (!U(r))
+      return t.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input: r,
+        inst: e
+      }), t;
+    const s = [], i = n.keyType._zod.values;
+    if (i) {
+      t.value = {};
+      const u = /* @__PURE__ */ new Set();
+      for (const a of i)
+        if (typeof a == "string" || typeof a == "number" || typeof a == "symbol") {
+          u.add(typeof a == "number" ? a.toString() : a);
+          const p = n.valueType._zod.run({ value: r[a], issues: [] }, o);
+          p instanceof Promise ? s.push(p.then((d) => {
+            d.issues.length && t.issues.push(...w(a, d.issues)), t.value[a] = d.value;
+          })) : (p.issues.length && t.issues.push(...w(a, p.issues)), t.value[a] = p.value);
+        }
+      let c;
+      for (const a in r)
+        u.has(a) || (c = c ?? [], c.push(a));
+      c && c.length > 0 && t.issues.push({
+        code: "unrecognized_keys",
+        input: r,
+        inst: e,
+        keys: c
+      });
+    } else {
+      t.value = {};
+      for (const u of Reflect.ownKeys(r)) {
+        if (u === "__proto__")
+          continue;
+        let c = n.keyType._zod.run({ value: u, issues: [] }, o);
+        if (c instanceof Promise)
+          throw new Error("Async schemas not supported in object keys currently");
+        if (typeof u == "string" && re.test(u) && c.issues.length && c.issues.some((d) => d.code === "invalid_type" && d.expected === "number")) {
+          const d = n.keyType._zod.run({ value: Number(u), issues: [] }, o);
+          if (d instanceof Promise)
+            throw new Error("Async schemas not supported in object keys currently");
+          d.issues.length === 0 && (c = d);
+        }
+        if (c.issues.length) {
+          n.mode === "loose" ? t.value[u] = r[u] : t.issues.push({
+            code: "invalid_key",
+            origin: "record",
+            issues: c.issues.map((d) => P(d, o, b())),
+            input: u,
+            path: [u],
+            inst: e
+          });
+          continue;
+        }
+        const p = n.valueType._zod.run({ value: r[u], issues: [] }, o);
+        p instanceof Promise ? s.push(p.then((d) => {
+          d.issues.length && t.issues.push(...w(u, d.issues)), t.value[c.value] = d.value;
+        })) : (p.issues.length && t.issues.push(...w(u, p.issues)), t.value[c.value] = p.value);
+      }
+    }
+    return s.length ? Promise.all(s).then(() => t) : t;
+  };
+}), tt = /* @__PURE__ */ l("$ZodMap", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    if (!(r instanceof Map))
+      return t.issues.push({
+        expected: "map",
+        code: "invalid_type",
+        input: r,
+        inst: e
+      }), t;
+    const s = [];
+    t.value = /* @__PURE__ */ new Map();
+    for (const [i, u] of r) {
+      const c = n.keyType._zod.run({ value: i, issues: [] }, o), a = n.valueType._zod.run({ value: u, issues: [] }, o);
+      c instanceof Promise || a instanceof Promise ? s.push(Promise.all([c, a]).then(([p, d]) => {
+        G(p, d, t, i, r, e, o);
+      })) : G(c, a, t, i, r, e, o);
+    }
+    return s.length ? Promise.all(s).then(() => t) : t;
+  };
+});
+function G(e, n, t, o, r, s, i) {
+  e.issues.length && (A.has(typeof o) ? t.issues.push(...w(o, e.issues)) : t.issues.push({
+    code: "invalid_key",
+    origin: "map",
+    input: r,
+    inst: s,
+    issues: e.issues.map((u) => P(u, i, b()))
+  })), n.issues.length && (A.has(typeof o) ? t.issues.push(...w(o, n.issues)) : t.issues.push({
+    origin: "map",
+    code: "invalid_element",
+    input: r,
+    inst: s,
+    key: o,
+    issues: n.issues.map((u) => P(u, i, b()))
+  })), t.value.set(e.value, n.value);
+}
+const rt = /* @__PURE__ */ l("$ZodSet", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    if (!(r instanceof Set))
+      return t.issues.push({
+        input: r,
+        inst: e,
+        expected: "set",
+        code: "invalid_type"
+      }), t;
+    const s = [];
+    t.value = /* @__PURE__ */ new Set();
+    for (const i of r) {
+      const u = n.valueType._zod.run({ value: i, issues: [] }, o);
+      u instanceof Promise ? s.push(u.then((c) => H(c, t))) : H(u, t);
+    }
+    return s.length ? Promise.all(s).then(() => t) : t;
+  };
+});
+function H(e, n) {
+  e.issues.length && n.issues.push(...e.issues), n.value.add(e.value);
+}
+const ot = /* @__PURE__ */ l("$ZodEnum", (e, n) => {
+  h.init(e, n);
+  const t = We(n.entries), o = new Set(t);
+  e._zod.values = o, e._zod.pattern = new RegExp(`^(${t.filter((r) => A.has(typeof r)).map((r) => typeof r == "string" ? N(r) : r.toString()).join("|")})$`), e._zod.parse = (r, s) => {
+    const i = r.value;
+    return o.has(i) || r.issues.push({
+      code: "invalid_value",
+      values: t,
+      input: i,
+      inst: e
+    }), r;
+  };
+}), st = /* @__PURE__ */ l("$ZodLiteral", (e, n) => {
+  if (h.init(e, n), n.values.length === 0)
+    throw new Error("Cannot create literal schema with no valid values");
+  const t = new Set(n.values);
+  e._zod.values = t, e._zod.pattern = new RegExp(`^(${n.values.map((o) => typeof o == "string" ? N(o) : o ? N(o.toString()) : String(o)).join("|")})$`), e._zod.parse = (o, r) => {
+    const s = o.value;
+    return t.has(s) || o.issues.push({
+      code: "invalid_value",
+      values: n.values,
+      input: s,
+      inst: e
+    }), o;
+  };
+}), it = /* @__PURE__ */ l("$ZodFile", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    const r = t.value;
+    return r instanceof File || t.issues.push({
+      expected: "file",
+      code: "invalid_type",
+      input: r,
+      inst: e
+    }), t;
+  };
+}), ut = /* @__PURE__ */ l("$ZodTransform", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    if (o.direction === "backward")
+      throw new te(e.constructor.name);
+    const r = n.transform(t.value, t);
+    if (o.async)
+      return (r instanceof Promise ? r : Promise.resolve(r)).then((i) => (t.value = i, t));
+    if (r instanceof Promise)
+      throw new D();
+    return t.value = r, t;
+  };
+});
+function q(e, n) {
+  return e.issues.length && n === void 0 ? { issues: [], value: void 0 } : e;
+}
+const on = /* @__PURE__ */ l("$ZodOptional", (e, n) => {
+  h.init(e, n), e._zod.optin = "optional", e._zod.optout = "optional", v(e._zod, "values", () => n.innerType._zod.values ? /* @__PURE__ */ new Set([...n.innerType._zod.values, void 0]) : void 0), v(e._zod, "pattern", () => {
+    const t = n.innerType._zod.pattern;
+    return t ? new RegExp(`^(${V(t.source)})?$`) : void 0;
+  }), e._zod.parse = (t, o) => {
+    if (n.innerType._zod.optin === "optional") {
+      const r = n.innerType._zod.run(t, o);
+      return r instanceof Promise ? r.then((s) => q(s, t.value)) : q(r, t.value);
+    }
+    return t.value === void 0 ? t : n.innerType._zod.run(t, o);
+  };
+}), ct = /* @__PURE__ */ l("$ZodExactOptional", (e, n) => {
+  on.init(e, n), v(e._zod, "values", () => n.innerType._zod.values), v(e._zod, "pattern", () => n.innerType._zod.pattern), e._zod.parse = (t, o) => n.innerType._zod.run(t, o);
+}), at = /* @__PURE__ */ l("$ZodNullable", (e, n) => {
+  h.init(e, n), v(e._zod, "optin", () => n.innerType._zod.optin), v(e._zod, "optout", () => n.innerType._zod.optout), v(e._zod, "pattern", () => {
+    const t = n.innerType._zod.pattern;
+    return t ? new RegExp(`^(${V(t.source)}|null)$`) : void 0;
+  }), v(e._zod, "values", () => n.innerType._zod.values ? /* @__PURE__ */ new Set([...n.innerType._zod.values, null]) : void 0), e._zod.parse = (t, o) => t.value === null ? t : n.innerType._zod.run(t, o);
+}), lt = /* @__PURE__ */ l("$ZodDefault", (e, n) => {
+  h.init(e, n), e._zod.optin = "optional", v(e._zod, "values", () => n.innerType._zod.values), e._zod.parse = (t, o) => {
+    if (o.direction === "backward")
+      return n.innerType._zod.run(t, o);
+    if (t.value === void 0)
+      return t.value = n.defaultValue, t;
+    const r = n.innerType._zod.run(t, o);
+    return r instanceof Promise ? r.then((s) => Q(s, n)) : Q(r, n);
+  };
+});
+function Q(e, n) {
+  return e.value === void 0 && (e.value = n.defaultValue), e;
+}
+const pt = /* @__PURE__ */ l("$ZodPrefault", (e, n) => {
+  h.init(e, n), e._zod.optin = "optional", v(e._zod, "values", () => n.innerType._zod.values), e._zod.parse = (t, o) => (o.direction === "backward" || t.value === void 0 && (t.value = n.defaultValue), n.innerType._zod.run(t, o));
+}), dt = /* @__PURE__ */ l("$ZodNonOptional", (e, n) => {
+  h.init(e, n), v(e._zod, "values", () => {
+    const t = n.innerType._zod.values;
+    return t ? new Set([...t].filter((o) => o !== void 0)) : void 0;
+  }), e._zod.parse = (t, o) => {
+    const r = n.innerType._zod.run(t, o);
+    return r instanceof Promise ? r.then((s) => Y(s, e)) : Y(r, e);
+  };
+});
+function Y(e, n) {
+  return !e.issues.length && e.value === void 0 && e.issues.push({
+    code: "invalid_type",
+    expected: "nonoptional",
+    input: e.value,
+    inst: n
+  }), e;
+}
+const ht = /* @__PURE__ */ l("$ZodSuccess", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => {
+    if (o.direction === "backward")
+      throw new te("ZodSuccess");
+    const r = n.innerType._zod.run(t, o);
+    return r instanceof Promise ? r.then((s) => (t.value = s.issues.length === 0, t)) : (t.value = r.issues.length === 0, t);
+  };
+}), vt = /* @__PURE__ */ l("$ZodCatch", (e, n) => {
+  h.init(e, n), v(e._zod, "optin", () => n.innerType._zod.optin), v(e._zod, "optout", () => n.innerType._zod.optout), v(e._zod, "values", () => n.innerType._zod.values), e._zod.parse = (t, o) => {
+    if (o.direction === "backward")
+      return n.innerType._zod.run(t, o);
+    const r = n.innerType._zod.run(t, o);
+    return r instanceof Promise ? r.then((s) => (t.value = s.value, s.issues.length && (t.value = n.catchValue({
+      ...t,
+      error: {
+        issues: s.issues.map((i) => P(i, o, b()))
+      },
+      input: t.value
+    }), t.issues = []), t)) : (t.value = r.value, r.issues.length && (t.value = n.catchValue({
+      ...t,
+      error: {
+        issues: r.issues.map((s) => P(s, o, b()))
+      },
+      input: t.value
+    }), t.issues = []), t);
+  };
+}), _t = /* @__PURE__ */ l("$ZodNaN", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => ((typeof t.value != "number" || !Number.isNaN(t.value)) && t.issues.push({
+    input: t.value,
+    inst: e,
+    expected: "nan",
+    code: "invalid_type"
+  }), t);
+}), ft = /* @__PURE__ */ l("$ZodPipe", (e, n) => {
+  h.init(e, n), v(e._zod, "values", () => n.in._zod.values), v(e._zod, "optin", () => n.in._zod.optin), v(e._zod, "optout", () => n.out._zod.optout), v(e._zod, "propValues", () => n.in._zod.propValues), e._zod.parse = (t, o) => {
+    if (o.direction === "backward") {
+      const s = n.out._zod.run(t, o);
+      return s instanceof Promise ? s.then((i) => E(i, n.in, o)) : E(s, n.in, o);
+    }
+    const r = n.in._zod.run(t, o);
+    return r instanceof Promise ? r.then((s) => E(s, n.out, o)) : E(r, n.out, o);
+  };
+});
+function E(e, n, t) {
+  return e.issues.length ? (e.aborted = !0, e) : n._zod.run({ value: e.value, issues: e.issues }, t);
+}
+const mt = /* @__PURE__ */ l("$ZodCodec", (e, n) => {
+  h.init(e, n), v(e._zod, "values", () => n.in._zod.values), v(e._zod, "optin", () => n.in._zod.optin), v(e._zod, "optout", () => n.out._zod.optout), v(e._zod, "propValues", () => n.in._zod.propValues), e._zod.parse = (t, o) => {
+    if ((o.direction || "forward") === "forward") {
+      const s = n.in._zod.run(t, o);
+      return s instanceof Promise ? s.then((i) => R(i, n, o)) : R(s, n, o);
+    } else {
+      const s = n.out._zod.run(t, o);
+      return s instanceof Promise ? s.then((i) => R(i, n, o)) : R(s, n, o);
+    }
+  };
+});
+function R(e, n, t) {
+  if (e.issues.length)
+    return e.aborted = !0, e;
+  if ((t.direction || "forward") === "forward") {
+    const r = n.transform(e.value, e);
+    return r instanceof Promise ? r.then((s) => O(e, s, n.out, t)) : O(e, r, n.out, t);
+  } else {
+    const r = n.reverseTransform(e.value, e);
+    return r instanceof Promise ? r.then((s) => O(e, s, n.in, t)) : O(e, r, n.in, t);
+  }
+}
+function O(e, n, t, o) {
+  return e.issues.length ? (e.aborted = !0, e) : t._zod.run({ value: n, issues: e.issues }, o);
+}
+const zt = /* @__PURE__ */ l("$ZodReadonly", (e, n) => {
+  h.init(e, n), v(e._zod, "propValues", () => n.innerType._zod.propValues), v(e._zod, "values", () => n.innerType._zod.values), v(e._zod, "optin", () => n.innerType?._zod?.optin), v(e._zod, "optout", () => n.innerType?._zod?.optout), e._zod.parse = (t, o) => {
+    if (o.direction === "backward")
+      return n.innerType._zod.run(t, o);
+    const r = n.innerType._zod.run(t, o);
+    return r instanceof Promise ? r.then(ee) : ee(r);
+  };
+});
+function ee(e) {
+  return e.value = Object.freeze(e.value), e;
+}
+const $t = /* @__PURE__ */ l("$ZodTemplateLiteral", (e, n) => {
+  h.init(e, n);
+  const t = [];
+  for (const o of n.parts)
+    if (typeof o == "object" && o !== null) {
+      if (!o._zod.pattern)
+        throw new Error(`Invalid template literal part, no pattern found: ${[...o._zod.traits].shift()}`);
+      const r = o._zod.pattern instanceof RegExp ? o._zod.pattern.source : o._zod.pattern;
+      if (!r)
+        throw new Error(`Invalid template literal part: ${o._zod.traits}`);
+      const s = r.startsWith("^") ? 1 : 0, i = r.endsWith("$") ? r.length - 1 : r.length;
+      t.push(r.slice(s, i));
+    } else if (o === null || Ge.has(typeof o))
+      t.push(N(`${o}`));
+    else
+      throw new Error(`Invalid template literal part: ${o}`);
+  e._zod.pattern = new RegExp(`^${t.join("")}$`), e._zod.parse = (o, r) => typeof o.value != "string" ? (o.issues.push({
+    input: o.value,
+    inst: e,
+    expected: "string",
+    code: "invalid_type"
+  }), o) : (e._zod.pattern.lastIndex = 0, e._zod.pattern.test(o.value) || o.issues.push({
+    input: o.value,
+    inst: e,
+    code: "invalid_format",
+    format: n.format ?? "template_literal",
+    pattern: e._zod.pattern.source
+  }), o);
+}), gt = /* @__PURE__ */ l("$ZodFunction", (e, n) => (h.init(e, n), e._def = n, e._zod.def = n, e.implement = (t) => {
+  if (typeof t != "function")
+    throw new Error("implement() must be called with a function");
+  return function(...o) {
+    const r = e._def.input ? B(e._def.input, o) : o, s = Reflect.apply(t, this, r);
+    return e._def.output ? B(e._def.output, s) : s;
+  };
+}, e.implementAsync = (t) => {
+  if (typeof t != "function")
+    throw new Error("implementAsync() must be called with a function");
+  return async function(...o) {
+    const r = e._def.input ? await K(e._def.input, o) : o, s = await Reflect.apply(t, this, r);
+    return e._def.output ? await K(e._def.output, s) : s;
+  };
+}, e._zod.parse = (t, o) => typeof t.value != "function" ? (t.issues.push({
+  code: "invalid_type",
+  expected: "function",
+  input: t.value,
+  inst: e
+}), t) : (e._def.output && e._def.output._zod.def.type === "promise" ? t.value = e.implementAsync(t.value) : t.value = e.implement(t.value), t), e.input = (...t) => {
+  const o = e.constructor;
+  return Array.isArray(t[0]) ? new o({
+    type: "function",
+    input: new rn({
+      type: "tuple",
+      items: t[0],
+      rest: t[1]
+    }),
+    output: e._def.output
+  }) : new o({
+    type: "function",
+    input: t[0],
+    output: e._def.output
+  });
+}, e.output = (t) => {
+  const o = e.constructor;
+  return new o({
+    type: "function",
+    input: e._def.input,
+    output: t
+  });
+}, e)), Zt = /* @__PURE__ */ l("$ZodPromise", (e, n) => {
+  h.init(e, n), e._zod.parse = (t, o) => Promise.resolve(t.value).then((r) => n.innerType._zod.run({ value: r, issues: [] }, o));
+}), wt = /* @__PURE__ */ l("$ZodLazy", (e, n) => {
+  h.init(e, n), v(e._zod, "innerType", () => n.getter()), v(e._zod, "pattern", () => e._zod.innerType?._zod?.pattern), v(e._zod, "propValues", () => e._zod.innerType?._zod?.propValues), v(e._zod, "optin", () => e._zod.innerType?._zod?.optin ?? void 0), v(e._zod, "optout", () => e._zod.innerType?._zod?.optout ?? void 0), e._zod.parse = (t, o) => e._zod.innerType._zod.run(t, o);
+}), bt = /* @__PURE__ */ l("$ZodCustom", (e, n) => {
+  de.init(e, n), h.init(e, n), e._zod.parse = (t, o) => t, e._zod.check = (t) => {
+    const o = t.value, r = n.fn(o);
+    if (r instanceof Promise)
+      return r.then((s) => ne(s, t, o, e));
+    ne(r, t, o, e);
+  };
+});
+function ne(e, n, t, o) {
+  if (!e) {
+    const r = {
+      code: "custom",
+      input: t,
+      inst: o,
+      // incorporates params.error into issue reporting
+      path: [...o._zod.def.path ?? []],
+      // incorporates params.error into issue reporting
+      continue: !o._zod.def.abort
+      // params: inst._zod.def.params,
+    };
+    o._zod.def.params && (r.params = o._zod.def.params), n.issues.push(Xe(r));
+  }
+}
+export {
+  Jn as $ZodAny,
+  Hn as $ZodArray,
+  jn as $ZodBase64,
+  Un as $ZodBase64URL,
+  nn as $ZodBigInt,
+  Bn as $ZodBigIntFormat,
+  Ln as $ZodBoolean,
+  Dn as $ZodCIDRv4,
+  Nn as $ZodCIDRv6,
+  gn as $ZodCUID,
+  Zn as $ZodCUID2,
+  vt as $ZodCatch,
+  mt as $ZodCodec,
+  bt as $ZodCustom,
+  Vn as $ZodCustomStringFormat,
+  Gn as $ZodDate,
+  lt as $ZodDefault,
+  Yn as $ZodDiscriminatedUnion,
+  An as $ZodE164,
+  fn as $ZodEmail,
+  zn as $ZodEmoji,
+  ot as $ZodEnum,
+  ct as $ZodExactOptional,
+  it as $ZodFile,
+  gt as $ZodFunction,
+  vn as $ZodGUID,
+  En as $ZodIPv4,
+  Rn as $ZodIPv6,
+  Tn as $ZodISODate,
+  kn as $ZodISODateTime,
+  Sn as $ZodISODuration,
+  In as $ZodISOTime,
+  et as $ZodIntersection,
+  Cn as $ZodJWT,
+  Pn as $ZodKSUID,
+  wt as $ZodLazy,
+  st as $ZodLiteral,
+  On as $ZodMAC,
+  tt as $ZodMap,
+  _t as $ZodNaN,
+  $n as $ZodNanoID,
+  yn as $ZodNever,
+  dt as $ZodNonOptional,
+  Mn as $ZodNull,
+  at as $ZodNullable,
+  en as $ZodNumber,
+  Fn as $ZodNumberFormat,
+  tn as $ZodObject,
+  qn as $ZodObjectJIT,
+  on as $ZodOptional,
+  ft as $ZodPipe,
+  pt as $ZodPrefault,
+  Zt as $ZodPromise,
+  zt as $ZodReadonly,
+  nt as $ZodRecord,
+  rt as $ZodSet,
+  qe as $ZodString,
+  m as $ZodStringFormat,
+  ht as $ZodSuccess,
+  Kn as $ZodSymbol,
+  $t as $ZodTemplateLiteral,
+  ut as $ZodTransform,
+  rn as $ZodTuple,
+  h as $ZodType,
+  wn as $ZodULID,
+  mn as $ZodURL,
+  _n as $ZodUUID,
+  xn as $ZodUndefined,
+  ce as $ZodUnion,
+  Wn as $ZodUnknown,
+  Xn as $ZodVoid,
+  bn as $ZodXID,
+  Qn as $ZodXor,
+  Tt as clone,
+  se as isValidBase64,
+  Qe as isValidBase64URL,
+  Ye as isValidJWT
+};