@reforma/components 0.1.5 → 0.2.0

package/dist/node_modules/zod/v4/core/schemas.js

@@ -0,0 +1,1104 @@
+import { $ZodCheckStringFormat as me, $ZodCheck as $e, $ZodCheckNumberFormat as ze } from "./checks.js";
+import { $constructor as f, globalConfig as T, config as S, $ZodAsyncError as D, $ZodEncodeError as ge } from "./core.js";
+import { Doc as Ze } from "./doc.js";
+import { number as oe, anyString as be, boolean as we, datetime as ke, date as Pe, time as Re, duration as Te, email as ye, guid as Oe, uuid as J, emoji as Ie, nanoid as Se, nanoidOfLength as Ee, cuid as Ue, cuid2 as De, ulid as Ne, xid as je, ksuid as Ae, ipv4 as Le, ipv6 as Ce, cidrv4 as Ke, cidrv6 as Ve, e164 as Be, httpProtocol as Fe } from "./regexes.js";
+import { allowsEval as Me, cached as se, esc as Je, isObject as ie, defineLazyInternal as _, isPlainObject as C, finalizeIssue as E, prefixIssues as R, getEnumValues as W, aborted as k, own as We, hide as Ge, explicitlyAborted as He, attachSchema as K, sizeCaps as G, optionalKeys as Xe, cleanRegex as B, assignProp as Ye, propertyKeyTypes as qe, escapeRegex as Qe, issue as xe } from "./util.js";
+import { clone as zt } from "./util.js";
+import { version as en } from "./versions.js";
+const z = /* @__PURE__ */ f("$ZodType", (e, n) => {
+  var t;
+  e ?? (e = {}), e._zod.def = n, e._zod.bag = e._zod.bag || {}, e._zod.version = en;
+  const r = e._zod.def.checks, o = e._zod.traits.has("$ZodCheck") ? [e, ...r ?? []] : r?.length ? [...r] : [];
+  for (const s of o)
+    for (const c of s._zod.onattach)
+      c(e);
+  if (o.length === 0)
+    (t = e._zod).deferred ?? (t.deferred = []), e._zod.deferred?.push(() => {
+      e._zod.run = e._zod.parse;
+    });
+  else {
+    const s = (a, l, i) => {
+      if (a.memo)
+        return a;
+      let u = k(a), h;
+      for (const v of l) {
+        if (v._zod.def.when) {
+          if (He(a) || !v._zod.def.when(a))
+            continue;
+        } else if (u)
+          continue;
+        const d = a.issues.length, p = v._zod.check(a);
+        if (p instanceof Promise && i?.async === !1)
+          throw new D();
+        if (h || p instanceof Promise)
+          h = (h ?? Promise.resolve()).then(async () => {
+            await p, a.issues.length !== d && (K(a.issues, d, e), u || (u = k(a, d)));
+          });
+        else {
+          if (a.issues.length === d)
+            continue;
+          K(a.issues, d, e), u || (u = k(a, d));
+        }
+      }
+      return h ? h.then(() => a) : a;
+    }, c = (a, l, i) => {
+      if (k(a))
+        return a.aborted = !0, a;
+      const u = s(l, o, i);
+      if (u instanceof Promise) {
+        if (i.async === !1)
+          throw new D();
+        return u.then((h) => e._zod.parse(h, i));
+      }
+      return e._zod.parse(u, i);
+    };
+    e._zod.run = (a, l) => {
+      if (l.skipChecks)
+        return e._zod.parse(a, l);
+      if (l.direction === "backward") {
+        const u = e._zod.parse({ value: a.value, issues: [] }, { ...l, skipChecks: !0 });
+        return u instanceof Promise ? u.then((h) => c(h, a, l)) : c(u, a, l);
+      }
+      const i = e._zod.parse(a, l);
+      if (i instanceof Promise) {
+        if (l.async === !1)
+          throw new D();
+        return i.then((u) => s(u, o, l));
+      }
+      return s(i, o, l);
+    };
+  }
+}, {
+  // Wrappers extend this by installing a richer factory over it; reading it eagerly would defeat the laziness.
+  get "~standard"() {
+    return Ge(this, "~standard", tn(this));
+  },
+  set "~standard"(e) {
+    We(this, "~standard", e);
+  }
+}), ue = (e, n) => e.issues.length ? { issues: e.issues.map((t) => E(t, n, S())) } : { value: e.value };
+async function nn(e, n) {
+  const t = { async: !0 };
+  return ue(await e._zod.run({ value: n, issues: [] }, t), t);
+}
+function tn(e) {
+  return {
+    validate: (n) => {
+      const t = { async: !1 };
+      try {
+        const r = e._zod.run({ value: n, issues: [] }, t);
+        if (!(r instanceof Promise))
+          return ue(r, t);
+      } catch {
+      }
+      return nn(e, n);
+    },
+    vendor: "zod",
+    version: 1
+  };
+}
+const rn = /* @__PURE__ */ f("$ZodString", (e, n) => {
+  z.init(e, n), e._zod.pattern = n.pattern ?? be, e._zod.parse = (t, r) => {
+    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;
+  };
+}), $ = /* @__PURE__ */ f("$ZodStringFormat", (e, n) => {
+  me.init(e, n), rn.init(e, n);
+}), Tn = /* @__PURE__ */ f("$ZodGUID", (e, n) => {
+  n.pattern ?? (n.pattern = Oe), $.init(e, n);
+}), yn = /* @__PURE__ */ f("$ZodUUID", (e, n) => {
+  if (n.version) {
+    const r = {
+      v1: 1,
+      v2: 2,
+      v3: 3,
+      v4: 4,
+      v5: 5,
+      v6: 6,
+      v7: 7,
+      v8: 8
+    }[n.version];
+    if (r === void 0)
+      throw new Error(`Invalid UUID version: "${n.version}"`);
+    n.pattern ?? (n.pattern = J(r));
+  } else
+    n.pattern ?? (n.pattern = J());
+  $.init(e, n);
+}), On = /* @__PURE__ */ f("$ZodEmail", (e, n) => {
+  n.pattern ?? (n.pattern = ye), $.init(e, n);
+}), ce = 1, N = 2;
+function ae(e) {
+  try {
+    return typeof URL < "u" && typeof URL.canParse == "function" ? URL.canParse(e) : (new URL(e), !0);
+  } catch {
+    return !1;
+  }
+}
+function on(e, n) {
+  return !("normalize" in n) && !("hostname" in n) && !("protocol" in n) ? ae(e) || N : sn(e, n);
+}
+function sn(e, n) {
+  if (!n.normalize && n.protocol?.source === Fe.source && !/^https?:\/\//i.test(e))
+    return ce;
+  try {
+    if (typeof URL < "u") {
+      const t = URL;
+      if (typeof t.parse == "function")
+        return t.parse(e) ?? N;
+    }
+    return new URL(e);
+  } catch {
+    return N;
+  }
+}
+const un = /[\t\n\r]/g;
+function H(e) {
+  return e.replace(un, "");
+}
+function cn(e, n) {
+  return n.lastIndex = 0, n.test(e.hostname);
+}
+function an(e, n) {
+  return n.lastIndex = 0, n.test(e.protocol.endsWith(":") ? e.protocol.slice(0, -1) : e.protocol);
+}
+const In = /* @__PURE__ */ f("$ZodURL", (e, n) => {
+  $.init(e, n), e._zod.check = (t) => {
+    try {
+      const r = t.value.trim(), o = on(r, n);
+      if (o === ce) {
+        t.issues.push({
+          code: "invalid_format",
+          format: "url",
+          note: "Invalid URL format",
+          input: t.value,
+          inst: e,
+          continue: !n.abort
+        });
+        return;
+      }
+      if (o === N) {
+        t.issues.push({
+          code: "invalid_format",
+          format: "url",
+          input: t.value,
+          inst: e,
+          continue: !n.abort
+        });
+        return;
+      }
+      if (o === !0) {
+        t.value = H(r);
+        return;
+      }
+      n.hostname && !cn(o, n.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 && !an(o, n.protocol) && t.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid protocol",
+        pattern: n.protocol.source,
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      }), t.value = n.normalize ? o.href : H(r);
+      return;
+    } catch {
+      t.issues.push({
+        code: "invalid_format",
+        format: "url",
+        input: t.value,
+        inst: e,
+        continue: !n.abort
+      });
+    }
+  };
+}), Sn = /* @__PURE__ */ f("$ZodEmoji", (e, n) => {
+  n.pattern ?? (n.pattern = Ie()), $.init(e, n);
+}), En = /* @__PURE__ */ f("$ZodNanoID", (e, n) => {
+  if (n.length !== void 0 && (!Number.isInteger(n.length) || n.length < 1))
+    throw new Error(`Invalid nanoid length: ${n.length}`);
+  n.pattern ?? (n.pattern = n.length === void 0 ? Se : Ee(n.length)), $.init(e, n);
+}), Un = /* @__PURE__ */ f("$ZodCUID", (e, n) => {
+  n.pattern ?? (n.pattern = Ue), $.init(e, n);
+}), Dn = /* @__PURE__ */ f("$ZodCUID2", (e, n) => {
+  n.pattern ?? (n.pattern = De), $.init(e, n);
+}), Nn = /* @__PURE__ */ f("$ZodULID", (e, n) => {
+  n.pattern ?? (n.pattern = Ne), $.init(e, n);
+}), jn = /* @__PURE__ */ f("$ZodXID", (e, n) => {
+  n.pattern ?? (n.pattern = je), $.init(e, n);
+}), An = /* @__PURE__ */ f("$ZodKSUID", (e, n) => {
+  n.pattern ?? (n.pattern = Ae), $.init(e, n);
+}), Ln = /* @__PURE__ */ f("$ZodISODateTime", (e, n) => {
+  n.pattern ?? (n.pattern = ke(n)), $.init(e, n);
+}), Cn = /* @__PURE__ */ f("$ZodISODate", (e, n) => {
+  n.pattern ?? (n.pattern = Pe), $.init(e, n);
+}), Kn = /* @__PURE__ */ f("$ZodISOTime", (e, n) => {
+  n.pattern ?? (n.pattern = Re(n)), $.init(e, n);
+}), Vn = /* @__PURE__ */ f("$ZodISODuration", (e, n) => {
+  n.pattern ?? (n.pattern = Te), $.init(e, n);
+}), Bn = /* @__PURE__ */ f("$ZodIPv4", (e, n) => {
+  n.pattern ?? (n.pattern = Le), $.init(e, n);
+}), ln = /^[0-9a-fA-F:.]+$/;
+function le(e) {
+  return ln.test(e) ? ae(`http://[${e}]`) : !1;
+}
+const Fn = /* @__PURE__ */ f("$ZodIPv6", (e, n) => {
+  n.pattern ?? (n.pattern = Ce), $.init(e, n), e._zod.check = (t) => {
+    le(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: "ipv6",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), Mn = /* @__PURE__ */ f("$ZodCIDRv4", (e, n) => {
+  n.pattern ?? (n.pattern = Ke), $.init(e, n);
+});
+function fn(e) {
+  const n = e.split("/");
+  if (n.length !== 2)
+    return !1;
+  const [t, r] = n;
+  if (!r)
+    return !1;
+  const o = Number(r);
+  return `${o}` !== r || o < 0 || o > 128 ? !1 : le(t);
+}
+const Jn = /* @__PURE__ */ f("$ZodCIDRv6", (e, n) => {
+  n.pattern ?? (n.pattern = Ve), $.init(e, n), e._zod.check = (t) => {
+    fn(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: "cidrv6",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+});
+function fe(e) {
+  if (e === "")
+    return !0;
+  if (/\s/.test(e) || e.length % 4 !== 0)
+    return !1;
+  try {
+    return atob(e), !0;
+  } catch {
+    return !1;
+  }
+}
+const pn = /^[0-9a-zA-Z+/]*={0,2}$/, Wn = /* @__PURE__ */ f("$ZodBase64", (e, n) => {
+  n.pattern ?? (n.pattern = pn), $.init(e, n), e._zod.check = (t) => {
+    fe(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: "base64",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), pe = /^[A-Za-z0-9_-]*$/;
+function dn(e) {
+  if (!pe.test(e))
+    return !1;
+  const n = e.replace(/[-_]/g, (r) => r === "-" ? "+" : "/"), t = n.padEnd(Math.ceil(n.length / 4) * 4, "=");
+  return fe(t);
+}
+const Gn = /* @__PURE__ */ f("$ZodBase64URL", (e, n) => {
+  n.pattern ?? (n.pattern = pe), $.init(e, n), e._zod.check = (t) => {
+    dn(t.value) || t.issues.push({
+      code: "invalid_format",
+      format: "base64url",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), Hn = /* @__PURE__ */ f("$ZodE164", (e, n) => {
+  n.pattern ?? (n.pattern = Be), $.init(e, n);
+});
+function hn(e, n = null) {
+  try {
+    const t = e.split(".");
+    if (t.length !== 3)
+      return !1;
+    const [r] = t;
+    if (!r)
+      return !1;
+    const o = JSON.parse(atob(r));
+    return !("typ" in o && o?.typ !== "JWT" || !o.alg || n && (!("alg" in o) || o.alg !== n));
+  } catch {
+    return !1;
+  }
+}
+const Xn = /* @__PURE__ */ f("$ZodJWT", (e, n) => {
+  $.init(e, n), e._zod.check = (t) => {
+    hn(t.value, n.alg) || t.issues.push({
+      code: "invalid_format",
+      format: "jwt",
+      input: t.value,
+      inst: e,
+      continue: !n.abort
+    });
+  };
+}), vn = /* @__PURE__ */ f("$ZodNumber", (e, n) => {
+  z.init(e, n), e._zod.pattern = oe, e._zod.parse = (t, r) => {
+    if (n.coerce)
+      try {
+        t.value = Number(t.value);
+      } catch {
+      }
+    const o = t.value;
+    if (typeof o == "number" && !Number.isNaN(o) && Number.isFinite(o))
+      return t;
+    const s = typeof o == "number" ? Number.isNaN(o) ? "NaN" : Number.isFinite(o) ? void 0 : String(o) : void 0;
+    return t.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input: o,
+      inst: e,
+      ...s ? { received: s } : {}
+    }), t;
+  };
+}), Yn = /* @__PURE__ */ f("$ZodNumberFormat", (e, n) => {
+  ze.init(e, n), vn.init(e, n);
+}), qn = /* @__PURE__ */ f("$ZodBoolean", (e, n) => {
+  z.init(e, n), e._zod.pattern = we, e._zod.parse = (t, r) => {
+    if (n.coerce)
+      try {
+        t.value = !!t.value;
+      } catch {
+      }
+    const o = t.value;
+    return typeof o == "boolean" || t.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input: o,
+      inst: e
+    }), t;
+  };
+}), Qn = /* @__PURE__ */ f("$ZodAny", (e, n) => {
+  z.init(e, n), e._zod.parse = (t) => t;
+}), xn = /* @__PURE__ */ f("$ZodUnknown", (e, n) => {
+  z.init(e, n), e._zod.parse = (t) => t;
+}), et = /* @__PURE__ */ f("$ZodNever", (e, n) => {
+  z.init(e, n), e._zod.parse = (t, r) => (t.issues.push({
+    expected: "never",
+    code: "invalid_type",
+    input: t.value,
+    inst: e
+  }), t);
+});
+function _n(e, n) {
+  const t = G(e._zod.def.checks);
+  if (!t.length)
+    return;
+  const r = Math.min(...t.map((s) => s[0])), o = e._zod.parse;
+  e._zod.parse = (s, c) => {
+    const a = n(s.value);
+    if (a > r && !c?.skipChecks && c?.direction !== "backward") {
+      for (const [l, i] of G(e._zod.def.checks))
+        if (a > l && i._zod.def.when(s)) {
+          const u = s.issues.length;
+          return i._zod.check(s), s.issues[u].continue = !1, K(s.issues, u, e), s;
+        }
+    }
+    return o(s, c);
+  };
+}
+const mn = (e) => Array.isArray(e) ? e.length : -1;
+function X(e, n, t) {
+  e.issues.length && n.issues.push(...R(t, e.issues)), n.value[t] = e.value;
+}
+const nt = /* @__PURE__ */ f("$ZodArray", (e, n) => {
+  z.init(e, n);
+  const t = T.memoizer;
+  t?.attach(e), e._zod.parse = (r, o) => {
+    const s = r.value;
+    if (!Array.isArray(s))
+      return r.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input: s,
+        inst: e
+      }), r;
+    r.value = t ? t.alloc(e, r, Array(s.length), o) : Array(s.length);
+    const c = [], a = o?.abortEarly;
+    for (let l = 0; l < s.length; l++) {
+      const i = s[l], u = n.element._zod.run({
+        value: i,
+        issues: []
+      }, o);
+      if (u instanceof Promise)
+        c.push(u.then((h) => X(h, r, l)));
+      else if (X(u, r, l), a && u.issues.length !== 0 && k(u))
+        break;
+    }
+    return c.length ? Promise.all(c).then(() => r) : r;
+  }, _n(e, mn);
+});
+function j(e, n, t, r, o, s) {
+  const c = t in r, a = s === "optional";
+  if (!(!c && a && o === "optional")) {
+    if (e.issues.length) {
+      if (o !== void 0 && a && !c)
+        return;
+      n.issues.push(...R(t, e.issues));
+    }
+    if (!c && o === void 0) {
+      e.issues.length || n.issues.push({
+        code: "invalid_type",
+        expected: "nonoptional",
+        input: void 0,
+        path: [t]
+      });
+      return;
+    }
+    e.value === void 0 ? (c || o === "defaulted" && !a) && (n.value[t] = void 0) : n.value[t] = e.value;
+  }
+}
+const $n = [];
+function de(e) {
+  const n = Object.keys(e.shape), t = Object.getOwnPropertySymbols(e.shape), r = t.length ? t : $n, o = r.length ? [...n, ...r] : n;
+  for (const c of o)
+    if (!e.shape?.[c]?._zod?.traits?.has("$ZodType"))
+      throw new Error(`Invalid element at key "${String(c)}": expected a Zod schema`);
+  const s = Xe(e.shape);
+  return {
+    ...e,
+    allKeys: o,
+    symbolKeys: r,
+    // string-only: handleCatchall matches it against `for...in`, which never yields a symbol
+    keySet: new Set(n),
+    numKeys: n.length,
+    optionalKeys: new Set(s)
+  };
+}
+function he(e, n, t, r, o, s, c) {
+  const a = [], l = o.keySet, i = o.catchall._zod, u = i.def.type, h = i.optin, v = i.optout;
+  let d = 0;
+  for (const p in n) {
+    if (c && t.issues.length !== d) {
+      if (k(t, d))
+        break;
+      d = t.issues.length;
+    }
+    if (l.has(p))
+      continue;
+    if (p === "__proto__") {
+      u === "never" && a.push(p);
+      continue;
+    }
+    if (u === "never") {
+      a.push(p);
+      continue;
+    }
+    const b = i.run({ value: n[p], issues: [] }, r);
+    b instanceof Promise ? e.push(b.then((g) => j(g, t, p, n, h, v))) : j(b, t, p, n, h, v);
+  }
+  return a.length && t.issues.push({
+    code: "unrecognized_keys",
+    keys: a,
+    input: n,
+    inst: s,
+    // Describes the shape of the input, not the validity of the parsed value, so it never aborts. The parse still fails; the schema's own checks just get to run first, and an enclosing intersection can reconcile the key against a sibling operand.
+    continue: !0
+  }), e.length ? Promise.all(e).then(() => t) : t;
+}
+const zn = /* @__PURE__ */ f("$ZodObject", (e, n) => {
+  z.init(e, n);
+  const t = Object.getOwnPropertyDescriptor(n, "shape"), r = t?.get ? t.get.raw : n.shape ?? {};
+  if (r) {
+    const i = () => {
+      const u = { ...r };
+      return Object.defineProperty(n, "shape", { value: u }), i.raw = u, u;
+    };
+    i.raw = r, Object.defineProperty(n, "shape", { get: i });
+  }
+  const o = se(() => de(n));
+  _(e, "propValues", (i) => {
+    const u = i.def.shape, h = {};
+    for (const v in u) {
+      const d = u[v]._zod;
+      if (d.values) {
+        Object.prototype.hasOwnProperty.call(h, v) || Ye(h, v, /* @__PURE__ */ new Set());
+        for (const p of d.values)
+          h[v].add(p);
+        d.optin !== void 0 && h[v].add(void 0);
+      }
+    }
+    return h;
+  });
+  const s = ie, c = n.catchall;
+  let a;
+  const l = T.memoizer;
+  l?.attach(e), e._zod.parse = (i, u) => {
+    a ?? (a = o.value);
+    const h = i.value;
+    if (!s(h))
+      return i.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input: h,
+        inst: e
+      }), i;
+    i.value = l ? l.alloc(e, i, {}, u) : {};
+    const v = [], d = a.shape, p = u?.abortEarly;
+    let b = i.issues.length;
+    for (const g of a.allKeys) {
+      if (p && i.issues.length !== b) {
+        if (k(i, b))
+          break;
+        b = i.issues.length;
+      }
+      if (g === "__proto__")
+        continue;
+      const y = d[g], P = y._zod.optin, O = y._zod.optout, I = y._zod.run({ value: h[g], issues: [] }, u);
+      I instanceof Promise ? v.push(I.then((Z) => j(Z, i, g, h, P, O))) : j(I, i, g, h, P, O);
+    }
+    return c ? he(v, h, i, u, o.value, e, p === !0) : v.length ? Promise.all(v).then(() => i) : i;
+  };
+}), tt = /* @__PURE__ */ f("$ZodObjectJIT", (e, n) => {
+  zn.init(e, n);
+  const t = e._zod.parse, r = se(() => de(n)), o = T.memoizer, s = (d) => {
+    const p = r.value, b = p.symbolKeys, g = new Ze(["payload", "ctx"], { shape: d, inst: e, memo: o, syms: b }), y = (Z) => `shape[${Z}]._zod.run({ value: input[${Z}], issues: [] }, ctx)`, P = (Z, m) => `
+          let ${Z}_ab = false;
+          for (let i = 0; i < ${Z}.issues.length; i++) {
+            const iss = ${Z}.issues[i];
+            iss.path = iss.path ? [${m}, ...iss.path] : [${m}];
+            payload.issues.push(iss);
+            if (iss.continue !== true) ${Z}_ab = true;
+          }
+          if (${Z}_ab && ctx && ctx.abortEarly) {
+            payload.value = newResult;
+            return payload;
+          }`;
+    g.write("const input = payload.value;");
+    const O = /* @__PURE__ */ Object.create(null);
+    let I = 0;
+    for (const Z of p.allKeys)
+      O[Z] = `key_${I++}`;
+    g.write(o ? "const newResult = memo.alloc(inst, payload, {}, ctx);" : "const newResult = {};");
+    for (const Z of p.allKeys) {
+      if (Z === "__proto__")
+        continue;
+      const m = O[Z], w = typeof Z == "symbol" ? `syms[${b.indexOf(Z)}]` : Je(Z), A = `${w} in input`, F = d[Z], L = F?._zod?.optin, M = L !== void 0, ve = F?._zod?.optout === "optional";
+      if (g.write(`const ${m} = ${y(w)};`), M && ve) {
+        const _e = L === "optional" ? `${m}_present` : `${m}.value !== undefined || ${m}_present`;
+        g.write(`
+        const ${m}_present = ${A};
+        if (!${m}.issues.length || ${m}_present) {
+          if (${m}.issues.length) {${P(m, w)}
+          }
+
+          if (${_e}) {
+            newResult[${w}] = ${m}.value;
+          }
+        }
+
+      `);
+      } else M ? (g.write(`
+        if (${m}.issues.length) {${P(m, w)}
+        }
+      `), L === "defaulted" ? g.write(`newResult[${w}] = ${m}.value;`) : g.write(`
+        if (${m}.value !== undefined || ${A}) {
+          newResult[${w}] = ${m}.value;
+        }
+      `)) : g.write(`
+        const ${m}_present = ${A};
+        if (${m}.issues.length) {${P(m, w)}
+        }
+        if (!${m}_present && !${m}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${w}]
+          });
+          if (ctx && ctx.abortEarly) {
+            payload.value = newResult;
+            return payload;
+          }
+        }
+
+        if (${m}_present) {
+          newResult[${w}] = ${m}.value;
+        }
+
+      `);
+    }
+    return g.write("payload.value = newResult;"), g.write("return payload;"), g.compile();
+  };
+  let c;
+  const a = ie, l = !T.jitless, u = l && Me.value, h = n.catchall;
+  let v;
+  e._zod.parse = (d, p) => {
+    v ?? (v = r.value);
+    const b = d.value;
+    return a(b) ? l && u && p?.async === !1 && p.jitless !== !0 ? (c || (c = s(n.shape)), d = c(d, p), h ? he([], b, d, p, v, e, p?.abortEarly === !0) : d) : t(d, p) : (d.issues.push({
+      expected: "object",
+      code: "invalid_type",
+      input: b,
+      inst: e
+    }), d);
+  };
+});
+function Y(e, n, t, r) {
+  for (const s of e)
+    if (s.issues.length === 0)
+      return n.value = s.value, n;
+  const o = e.filter((s) => !k(s));
+  return o.length === 1 ? (n.value = o[0].value, o[0]) : (n.issues.push({
+    code: "invalid_union",
+    input: n.value,
+    inst: t,
+    errors: e.map((s) => s.issues.map((c) => E(c, r, S())))
+  }), n);
+}
+const rt = /* @__PURE__ */ f("$ZodUnion", (e, n) => {
+  z.init(e, n), _(e, "optin", (r) => r.def.options.some((o) => o._zod.optin === "defaulted") ? "defaulted" : r.def.options.some((o) => o._zod.optin !== void 0) ? "optional" : void 0), _(e, "optout", (r) => r.def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0), _(e, "values", (r) => {
+    if (r.def.options.every((o) => o._zod.values))
+      return new Set(r.def.options.flatMap((o) => Array.from(o._zod.values)));
+  }), _(e, "pattern", (r) => {
+    if (r.def.options.every((o) => o._zod.pattern)) {
+      const o = r.def.options.map((s) => s._zod.pattern);
+      return new RegExp(`^(${o.map((s) => B(s.source)).join("|")})$`);
+    }
+  });
+  const t = n.options.length === 1 ? n.options[0]._zod.run : null;
+  e._zod.parse = (r, o) => {
+    if (t)
+      return t(r, o);
+    let s = !1;
+    const c = [];
+    for (const a of n.options) {
+      const l = a._zod.run({
+        value: r.value,
+        issues: []
+      }, o);
+      if (l instanceof Promise)
+        c.push(l), s = !0;
+      else {
+        if (l.issues.length === 0)
+          return l;
+        c.push(l);
+      }
+    }
+    return s ? Promise.all(c).then((a) => Y(a, r, e, o)) : Y(c, r, e, o);
+  };
+}), ot = /* @__PURE__ */ f("$ZodIntersection", (e, n) => {
+  z.init(e, n), e._zod.parse = (t, r) => {
+    const o = t.value, s = n.left._zod.run({ value: o, issues: [] }, r), c = n.right._zod.run({ value: o, issues: [] }, r);
+    return s instanceof Promise || c instanceof Promise ? Promise.all([s, c]).then(([l, i]) => q(t, l, i)) : q(t, s, c);
+  };
+});
+function V(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 (C(e) && C(n)) {
+    const t = Object.keys(n), r = Object.keys(e).filter((s) => t.indexOf(s) !== -1), o = { ...e, ...n };
+    Object.prototype.hasOwnProperty.call(o, "__proto__") && delete o.__proto__;
+    for (const s of r) {
+      if (s === "__proto__")
+        continue;
+      const c = V(e[s], n[s]);
+      if (!c.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [s, ...c.mergeErrorPath]
+        };
+      o[s] = c.data;
+    }
+    return { valid: !0, data: o };
+  }
+  if (Array.isArray(e) && Array.isArray(n)) {
+    if (e.length !== n.length)
+      return { valid: !1, mergeErrorPath: [] };
+    const t = [];
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r], s = n[r], c = V(o, s);
+      if (!c.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [r, ...c.mergeErrorPath]
+        };
+      t.push(c.data);
+    }
+    return { valid: !0, data: t };
+  }
+  return { valid: !1, mergeErrorPath: [] };
+}
+function q(e, n, t) {
+  const r = /* @__PURE__ */ new Map();
+  let o;
+  const s = /* @__PURE__ */ new Map(), c = (i, u) => {
+    let h;
+    if (i.code === "unrecognized_keys" && !i.path?.length)
+      o ?? (o = i), h = i.keys;
+    else if (i.code === "invalid_key" && i.origin === "record" && i.path?.length === 1) {
+      const v = String(i.path[0]);
+      s.has(v) || s.set(v, i), h = [v];
+    } else
+      return !1;
+    for (const v of h)
+      r.has(v) || r.set(v, {}), r.get(v)[u] = !0;
+    return !0;
+  };
+  for (const i of n.issues)
+    c(i, "l") || e.issues.push(i);
+  for (const i of t.issues)
+    c(i, "r") || e.issues.push(i);
+  const a = [...r].filter(([, i]) => i.l && i.r).map(([i]) => i);
+  if (a.length) {
+    const i = o ? a.filter((u) => o.keys.includes(u)) : [];
+    i.length && e.issues.push({ ...o, keys: i });
+    for (const u of a)
+      !i.includes(u) && s.has(u) && e.issues.push(s.get(u));
+  }
+  const l = V(n.value, t.value);
+  if (!l.valid) {
+    if (k(e))
+      return e;
+    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(l.mergeErrorPath)}`);
+  }
+  return e.value = l.data, e;
+}
+const st = /* @__PURE__ */ f("$ZodRecord", (e, n) => {
+  z.init(e, n);
+  const t = T.memoizer;
+  t?.attach(e), e._zod.parse = (r, o) => {
+    const s = r.value;
+    if (!C(s))
+      return r.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input: s,
+        inst: e
+      }), r;
+    const c = [], a = n.keyType._zod.values;
+    if (a && !n.partial) {
+      r.value = t ? t.alloc(e, r, {}, o) : {};
+      const l = /* @__PURE__ */ new Set();
+      for (const u of a)
+        if (typeof u == "string" || typeof u == "number" || typeof u == "symbol") {
+          if (l.add(typeof u == "number" ? u.toString() : u), u === "__proto__")
+            continue;
+          const h = n.keyType._zod.run({ value: u, issues: [] }, o);
+          if (h instanceof Promise)
+            throw new Error("Async schemas not supported in object keys currently");
+          if (h.issues.length) {
+            r.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: h.issues.map((p) => E(p, o, S())),
+              input: u,
+              path: [u],
+              inst: e
+            });
+            continue;
+          }
+          const v = h.value;
+          if (v === "__proto__")
+            continue;
+          const d = n.valueType._zod.run({ value: s[u], issues: [] }, o);
+          d instanceof Promise ? c.push(d.then((p) => {
+            p.issues.length && r.issues.push(...R(u, p.issues)), r.value[v] = p.value;
+          })) : (d.issues.length && r.issues.push(...R(u, d.issues)), r.value[v] = d.value);
+        }
+      let i;
+      for (const u in s)
+        if (!l.has(u))
+          if (n.mode === "loose") {
+            if (u === "__proto__")
+              continue;
+            r.value[u] = s[u];
+          } else
+            i = i ?? [], i.push(u);
+      i && i.length > 0 && r.issues.push({
+        code: "unrecognized_keys",
+        input: s,
+        inst: e,
+        keys: i,
+        continue: !0
+      });
+    } else {
+      r.value = t ? t.alloc(e, r, {}, o) : {};
+      let l;
+      for (const i of Reflect.ownKeys(s)) {
+        if (i === "__proto__" || !Object.prototype.propertyIsEnumerable.call(s, i))
+          continue;
+        let u = n.keyType._zod.run({ value: i, issues: [] }, o);
+        if (u instanceof Promise)
+          throw new Error("Async schemas not supported in object keys currently");
+        if (typeof i == "string" && oe.test(i) && u.issues.length) {
+          const p = n.keyType._zod.run({ value: Number(i), issues: [] }, o);
+          if (p instanceof Promise)
+            throw new Error("Async schemas not supported in object keys currently");
+          p.issues.length === 0 && (u = p);
+        }
+        if (u.issues.length) {
+          n.mode === "loose" ? r.value[i] = s[i] : a ? (l = l ?? [], l.push(i)) : r.issues.push({
+            code: "invalid_key",
+            origin: "record",
+            issues: u.issues.map((p) => E(p, o, S())),
+            input: i,
+            path: [i],
+            inst: e
+          });
+          continue;
+        }
+        const v = u.value;
+        if (v === "__proto__")
+          continue;
+        const d = n.valueType._zod.run({ value: s[i], issues: [] }, o);
+        d instanceof Promise ? c.push(d.then((p) => {
+          p.issues.length && r.issues.push(...R(i, p.issues)), r.value[v] = p.value;
+        })) : (d.issues.length && r.issues.push(...R(i, d.issues)), r.value[v] = d.value);
+      }
+      l && l.length > 0 && r.issues.push({
+        code: "unrecognized_keys",
+        input: s,
+        inst: e,
+        keys: l,
+        continue: !0
+      });
+    }
+    return c.length ? Promise.all(c).then(() => r) : r;
+  };
+}), it = /* @__PURE__ */ f("$ZodEnum", (e, n) => {
+  z.init(e, n);
+  const t = W(n.entries), r = new Set(t);
+  e._zod.values = r, _(e, "pattern", (o) => {
+    const s = W(o.def.entries).filter((c) => qe.has(typeof c));
+    return new RegExp(s.length ? `^(${s.map((c) => Qe(c.toString())).join("|")})$` : "^[^\\s\\S]$");
+  }), e._zod.parse = (o, s) => {
+    const c = o.value;
+    return r.has(c) || o.issues.push({
+      code: "invalid_value",
+      values: t,
+      input: c,
+      inst: e
+    }), o;
+  };
+}), ut = /* @__PURE__ */ f("$ZodTransform", (e, n) => {
+  z.init(e, n), e._zod.optin = "optional", T.memoizer?.guard(e), e._zod.parse = (t, r) => {
+    if (r.direction === "backward")
+      throw new ge(e.constructor.name);
+    const o = n.transform(t.value, t);
+    if (r.async)
+      return (o instanceof Promise ? o : Promise.resolve(o)).then((c) => (t.value = c, t));
+    if (o instanceof Promise)
+      throw new D();
+    return t.value = o, t;
+  };
+});
+function Q(e, n) {
+  return e.value = n.issues.length ? void 0 : n.value, e;
+}
+const gn = /* @__PURE__ */ f("$ZodOptional", (e, n) => {
+  z.init(e, n), _(e, "optin", (t) => t.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional"), e._zod.optout = "optional", _(e, "values", (t) => {
+    const r = t.def.innerType._zod.values;
+    return r ? /* @__PURE__ */ new Set([...r, void 0]) : void 0;
+  }), _(e, "pattern", (t) => {
+    const r = t.def.innerType._zod.pattern;
+    return r ? new RegExp(`^(${B(r.source)})?$`) : void 0;
+  }), e._zod.parse = (t, r) => {
+    if (t.value === void 0) {
+      if (n.innerType._zod.optin !== "defaulted")
+        return t;
+      const o = n.innerType._zod.run({ value: t.value, issues: [] }, r);
+      return o instanceof Promise ? o.then((s) => Q(t, s)) : Q(t, o);
+    }
+    return n.innerType._zod.run(t, r);
+  };
+}), ct = /* @__PURE__ */ f("$ZodExactOptional", (e, n) => {
+  gn.init(e, n), _(e, "values", (t) => t.def.innerType._zod.values), _(e, "pattern", (t) => t.def.innerType._zod.pattern), e._zod.parse = (t, r) => n.innerType._zod.run(t, r);
+}), at = /* @__PURE__ */ f("$ZodNullable", (e, n) => {
+  z.init(e, n), _(e, "optin", (t) => t.def.innerType._zod.optin), _(e, "optout", (t) => t.def.innerType._zod.optout), _(e, "pattern", (t) => {
+    const r = t.def.innerType._zod.pattern;
+    return r ? new RegExp(`^(${B(r.source)}|null)$`) : void 0;
+  }), _(e, "values", (t) => t.def.innerType._zod.values ? /* @__PURE__ */ new Set([...t.def.innerType._zod.values, null]) : void 0), e._zod.parse = (t, r) => t.value === null ? t : n.innerType._zod.run(t, r);
+}), lt = /* @__PURE__ */ f("$ZodDefault", (e, n) => {
+  z.init(e, n), e._zod.optin = "defaulted", _(e, "values", (t) => t.def.innerType._zod.values), e._zod.parse = (t, r) => {
+    if (r.direction === "backward")
+      return n.innerType._zod.run(t, r);
+    if (t.value === void 0)
+      return t.value = n.defaultValue, t;
+    const o = n.innerType._zod.run(t, r);
+    return o instanceof Promise ? o.then((s) => x(s, n)) : x(o, n);
+  };
+});
+function x(e, n) {
+  return e.value === void 0 && (e.value = n.defaultValue), e;
+}
+const ft = /* @__PURE__ */ f("$ZodPrefault", (e, n) => {
+  z.init(e, n), e._zod.optin = "defaulted", _(e, "values", (t) => t.def.innerType._zod.values), e._zod.parse = (t, r) => (r.direction === "backward" || t.value === void 0 && (t.value = n.defaultValue), n.innerType._zod.run(t, r));
+}), pt = /* @__PURE__ */ f("$ZodNonOptional", (e, n) => {
+  z.init(e, n), _(e, "values", (t) => {
+    const r = t.def.innerType._zod.values;
+    return r ? new Set([...r].filter((o) => o !== void 0)) : void 0;
+  }), e._zod.parse = (t, r) => {
+    const o = n.innerType._zod.run(t, r);
+    return o instanceof Promise ? o.then((s) => ee(s, e)) : ee(o, e);
+  };
+});
+function ee(e, n) {
+  return !e.issues.length && e.value === void 0 && e.issues.push({
+    code: "invalid_type",
+    expected: "nonoptional",
+    input: e.value,
+    inst: n
+  }), e;
+}
+function ne(e, n, t, r) {
+  return n.issues.length ? (e.value = t.catchValue({
+    ...n,
+    value: e.value,
+    error: {
+      issues: n.issues.map((o) => E(o, r, S()))
+    },
+    input: e.value
+  }), e) : (e.value = n.value, n.memo && (e.memo = !0), e);
+}
+const dt = /* @__PURE__ */ f("$ZodCatch", (e, n) => {
+  z.init(e, n), _(e, "optin", (t) => t.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional"), _(e, "optout", (t) => t.def.innerType._zod.optout), _(e, "values", (t) => t.def.innerType._zod.values), e._zod.parse = (t, r) => {
+    if (r.direction === "backward")
+      return n.innerType._zod.run(t, r);
+    const o = n.innerType._zod.run({ value: t.value, issues: [] }, r);
+    return o instanceof Promise ? o.then((s) => ne(t, s, n, r)) : ne(t, o, n, r);
+  };
+}), ht = /* @__PURE__ */ f("$ZodPipe", (e, n) => {
+  z.init(e, n), _(e, "values", (t) => t.def.in._zod.values), _(e, "optin", (t) => t.def.in._zod.optin), _(e, "optout", (t) => t.def.out._zod.optout), _(e, "propValues", (t) => t.def.in._zod.propValues), e._zod.parse = (t, r) => {
+    if (r.direction === "backward") {
+      const s = n.out._zod.run(t, r);
+      return s instanceof Promise ? s.then((c) => U(c, n.in, r)) : U(s, n.in, r);
+    }
+    const o = n.in._zod.run(t, r);
+    return o instanceof Promise ? o.then((s) => U(s, n.out, r)) : U(o, n.out, r);
+  };
+});
+function U(e, n, t) {
+  return e.issues.some((r) => r.code !== "unrecognized_keys") ? (e.aborted = !0, e) : n._zod.run({ value: e.value, issues: e.issues }, t);
+}
+const vt = /* @__PURE__ */ f("$ZodReadonly", (e, n) => {
+  z.init(e, n), _(e, "propValues", (t) => t.def.innerType._zod.propValues), _(e, "values", (t) => t.def.innerType._zod.values), _(e, "optin", (t) => t.def.innerType?._zod?.optin), _(e, "optout", (t) => t.def.innerType?._zod?.optout), e._zod.parse = (t, r) => {
+    if (r.direction === "backward")
+      return n.innerType._zod.run(t, r);
+    const o = n.innerType._zod.run(t, r);
+    return o instanceof Promise ? o.then(te) : te(o);
+  };
+});
+function te(e) {
+  return e.memo || (e.value = Object.freeze(e.value)), e;
+}
+const _t = /* @__PURE__ */ f("$ZodCustom", (e, n) => {
+  $e.init(e, n), z.init(e, n), e._zod.parse = (t, r) => t, e._zod.check = (t) => {
+    const r = t.value, o = n.fn(r);
+    if (o instanceof Promise)
+      return o.then((s) => re(s, t, r, e));
+    re(o, t, r, e);
+  };
+});
+function re(e, n, t, r) {
+  if (!e) {
+    const o = {
+      code: "custom",
+      input: t,
+      inst: r,
+      // incorporates params.error into issue reporting
+      path: [...r._zod.def.path ?? []],
+      // incorporates params.error into issue reporting
+      continue: !r._zod.def.abort
+      // params: inst._zod.def.params,
+    };
+    r._zod.def.params && (o.params = r._zod.def.params), n.issues.push(xe(o));
+  }
+}
+export {
+  Qn as $ZodAny,
+  nt as $ZodArray,
+  Wn as $ZodBase64,
+  Gn as $ZodBase64URL,
+  qn as $ZodBoolean,
+  Mn as $ZodCIDRv4,
+  Jn as $ZodCIDRv6,
+  Un as $ZodCUID,
+  Dn as $ZodCUID2,
+  dt as $ZodCatch,
+  _t as $ZodCustom,
+  lt as $ZodDefault,
+  Hn as $ZodE164,
+  On as $ZodEmail,
+  Sn as $ZodEmoji,
+  it as $ZodEnum,
+  ct as $ZodExactOptional,
+  Tn as $ZodGUID,
+  Bn as $ZodIPv4,
+  Fn as $ZodIPv6,
+  Cn as $ZodISODate,
+  Ln as $ZodISODateTime,
+  Vn as $ZodISODuration,
+  Kn as $ZodISOTime,
+  ot as $ZodIntersection,
+  Xn as $ZodJWT,
+  An as $ZodKSUID,
+  En as $ZodNanoID,
+  et as $ZodNever,
+  pt as $ZodNonOptional,
+  at as $ZodNullable,
+  vn as $ZodNumber,
+  Yn as $ZodNumberFormat,
+  zn as $ZodObject,
+  tt as $ZodObjectJIT,
+  gn as $ZodOptional,
+  ht as $ZodPipe,
+  ft as $ZodPrefault,
+  vt as $ZodReadonly,
+  st as $ZodRecord,
+  rn as $ZodString,
+  $ as $ZodStringFormat,
+  ut as $ZodTransform,
+  z as $ZodType,
+  Nn as $ZodULID,
+  In as $ZodURL,
+  yn as $ZodUUID,
+  rt as $ZodUnion,
+  xn as $ZodUnknown,
+  jn as $ZodXID,
+  ce as URL_BAD_FORMAT,
+  N as URL_UNPARSEABLE,
+  pn as base64Charset,
+  pe as base64urlCharset,
+  ae as canParseURL,
+  zt as clone,
+  fe as isValidBase64,
+  dn as isValidBase64URL,
+  fn as isValidCIDRv6,
+  le as isValidIPv6,
+  hn as isValidJWT,
+  V as mergeValues,
+  sn as parseURLObject,
+  tn as standardProps,
+  H as stripTabAndNewline,
+  cn as urlHostnameOk,
+  an as urlProtocolOk,
+  on as validateURL
+};
+//# sourceMappingURL=schemas.js.map