@performant-software/geospatial 3.1.25-beta.1 → 3.1.25

package/dist/index.es619.js

@@ -0,0 +1,1103 @@
+import { $ZodCheckStringFormat as ie, $ZodCheckNumberFormat as ue, $ZodCheck as ce } from "./index.es628.js";
+import { $constructor as l, $ZodAsyncError as O, config as P, globalConfig as ae, $ZodEncodeError as le } from "./index.es617.js";
+import { Doc as pe } from "./index.es629.js";
+import { safeParse as ve, safeParseAsync as he } from "./index.es623.js";
+import { number as Y, string as de, boolean as _e, datetime as fe, date as me, time as ze, duration as $e, email as ge, guid as Ze, uuid as L, httpProtocol as be, emoji as we, nanoid as ke, cuid as Pe, cuid2 as Te, ulid as Re, xid as Ie, ksuid as Oe, ipv4 as Ee, ipv6 as De, cidrv4 as Se, cidrv6 as je, base64 as Ne, base64url as ee, e164 as Ue } from "./index.es630.js";
+import { getEnumValues as ye, propertyKeyTypes as Ae, escapeRegex as S, defineLazy as _, aborted as k, explicitlyAborted as Ve, cleanRegex as U, finalizeIssue as T, isPlainObject as j, prefixIssues as b, isObject as y, cached as A, allowsEval as Ce, esc as K, optionalKeys as Le, issue as Ke } from "./index.es618.js";
+import { clone as qt } from "./index.es618.js";
+import { version as Be } from "./index.es631.js";
+const f = /* @__PURE__ */ l("$ZodType", (t, e) => {
+  var n;
+  t ?? (t = {}), t._zod.def = e, t._zod.bag = t._zod.bag || {}, t._zod.version = Be;
+  const o = [...t._zod.def.checks ?? []];
+  t._zod.traits.has("$ZodCheck") && o.unshift(t);
+  for (const r of o)
+    for (const s of r._zod.onattach)
+      s(t);
+  if (o.length === 0)
+    (n = t._zod).deferred ?? (n.deferred = []), t._zod.deferred?.push(() => {
+      t._zod.run = t._zod.parse;
+    });
+  else {
+    const r = (i, u, c) => {
+      let a = k(i), p;
+      for (const d of u) {
+        if (d._zod.def.when) {
+          if (Ve(i) || !d._zod.def.when(i))
+            continue;
+        } else if (a)
+          continue;
+        const v = i.issues.length, h = d._zod.check(i);
+        if (h instanceof Promise && c?.async === !1)
+          throw new O();
+        if (p || h instanceof Promise)
+          p = (p ?? Promise.resolve()).then(async () => {
+            await h, i.issues.length !== v && (a || (a = k(i, v)));
+          });
+        else {
+          if (i.issues.length === v)
+            continue;
+          a || (a = k(i, v));
+        }
+      }
+      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 O();
+        return a.then((p) => t._zod.parse(p, c));
+      }
+      return t._zod.parse(a, c);
+    };
+    t._zod.run = (i, u) => {
+      if (u.skipChecks)
+        return t._zod.parse(i, u);
+      if (u.direction === "backward") {
+        const a = t._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 = t._zod.parse(i, u);
+      if (c instanceof Promise) {
+        if (u.async === !1)
+          throw new O();
+        return c.then((a) => r(a, o, u));
+      }
+      return r(c, o, u);
+    };
+  }
+  _(t, "~standard", () => ({
+    validate: (r) => {
+      try {
+        const s = ve(t, r);
+        return s.success ? { value: s.data } : { issues: s.error?.issues };
+      } catch {
+        return he(t, r).then((i) => i.success ? { value: i.data } : { issues: i.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  }));
+}), Fe = /* @__PURE__ */ l("$ZodString", (t, e) => {
+  f.init(t, e), t._zod.pattern = [...t?._zod.bag?.patterns ?? []].pop() ?? de(t._zod.bag), t._zod.parse = (n, o) => {
+    if (e.coerce)
+      try {
+        n.value = String(n.value);
+      } catch {
+      }
+    return typeof n.value == "string" || n.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: n.value,
+      inst: t
+    }), n;
+  };
+}), m = /* @__PURE__ */ l("$ZodStringFormat", (t, e) => {
+  ie.init(t, e), Fe.init(t, e);
+}), ot = /* @__PURE__ */ l("$ZodGUID", (t, e) => {
+  e.pattern ?? (e.pattern = Ze), m.init(t, e);
+}), rt = /* @__PURE__ */ l("$ZodUUID", (t, e) => {
+  if (e.version) {
+    const o = {
+      v1: 1,
+      v2: 2,
+      v3: 3,
+      v4: 4,
+      v5: 5,
+      v6: 6,
+      v7: 7,
+      v8: 8
+    }[e.version];
+    if (o === void 0)
+      throw new Error(`Invalid UUID version: "${e.version}"`);
+    e.pattern ?? (e.pattern = L(o));
+  } else
+    e.pattern ?? (e.pattern = L());
+  m.init(t, e);
+}), st = /* @__PURE__ */ l("$ZodEmail", (t, e) => {
+  e.pattern ?? (e.pattern = ge), m.init(t, e);
+}), it = /* @__PURE__ */ l("$ZodURL", (t, e) => {
+  m.init(t, e), t._zod.check = (n) => {
+    try {
+      const o = n.value.trim();
+      if (!e.normalize && e.protocol?.source === be.source && !/^https?:\/\//i.test(o)) {
+        n.issues.push({
+          code: "invalid_format",
+          format: "url",
+          note: "Invalid URL format",
+          input: n.value,
+          inst: t,
+          continue: !e.abort
+        });
+        return;
+      }
+      const r = new URL(o);
+      e.hostname && (e.hostname.lastIndex = 0, e.hostname.test(r.hostname) || n.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid hostname",
+        pattern: e.hostname.source,
+        input: n.value,
+        inst: t,
+        continue: !e.abort
+      })), e.protocol && (e.protocol.lastIndex = 0, e.protocol.test(r.protocol.endsWith(":") ? r.protocol.slice(0, -1) : r.protocol) || n.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid protocol",
+        pattern: e.protocol.source,
+        input: n.value,
+        inst: t,
+        continue: !e.abort
+      })), e.normalize ? n.value = r.href : n.value = o;
+      return;
+    } catch {
+      n.issues.push({
+        code: "invalid_format",
+        format: "url",
+        input: n.value,
+        inst: t,
+        continue: !e.abort
+      });
+    }
+  };
+}), ut = /* @__PURE__ */ l("$ZodEmoji", (t, e) => {
+  e.pattern ?? (e.pattern = we()), m.init(t, e);
+}), ct = /* @__PURE__ */ l("$ZodNanoID", (t, e) => {
+  e.pattern ?? (e.pattern = ke), m.init(t, e);
+}), at = /* @__PURE__ */ l("$ZodCUID", (t, e) => {
+  e.pattern ?? (e.pattern = Pe), m.init(t, e);
+}), lt = /* @__PURE__ */ l("$ZodCUID2", (t, e) => {
+  e.pattern ?? (e.pattern = Te), m.init(t, e);
+}), pt = /* @__PURE__ */ l("$ZodULID", (t, e) => {
+  e.pattern ?? (e.pattern = Re), m.init(t, e);
+}), vt = /* @__PURE__ */ l("$ZodXID", (t, e) => {
+  e.pattern ?? (e.pattern = Ie), m.init(t, e);
+}), ht = /* @__PURE__ */ l("$ZodKSUID", (t, e) => {
+  e.pattern ?? (e.pattern = Oe), m.init(t, e);
+}), dt = /* @__PURE__ */ l("$ZodISODateTime", (t, e) => {
+  e.pattern ?? (e.pattern = fe(e)), m.init(t, e);
+}), _t = /* @__PURE__ */ l("$ZodISODate", (t, e) => {
+  e.pattern ?? (e.pattern = me), m.init(t, e);
+}), ft = /* @__PURE__ */ l("$ZodISOTime", (t, e) => {
+  e.pattern ?? (e.pattern = ze(e)), m.init(t, e);
+}), mt = /* @__PURE__ */ l("$ZodISODuration", (t, e) => {
+  e.pattern ?? (e.pattern = $e), m.init(t, e);
+}), zt = /* @__PURE__ */ l("$ZodIPv4", (t, e) => {
+  e.pattern ?? (e.pattern = Ee), m.init(t, e), t._zod.bag.format = "ipv4";
+}), $t = /* @__PURE__ */ l("$ZodIPv6", (t, e) => {
+  e.pattern ?? (e.pattern = De), m.init(t, e), t._zod.bag.format = "ipv6", t._zod.check = (n) => {
+    try {
+      new URL(`http://[${n.value}]`);
+    } catch {
+      n.issues.push({
+        code: "invalid_format",
+        format: "ipv6",
+        input: n.value,
+        inst: t,
+        continue: !e.abort
+      });
+    }
+  };
+}), gt = /* @__PURE__ */ l("$ZodCIDRv4", (t, e) => {
+  e.pattern ?? (e.pattern = Se), m.init(t, e);
+}), Zt = /* @__PURE__ */ l("$ZodCIDRv6", (t, e) => {
+  e.pattern ?? (e.pattern = je), m.init(t, e), t._zod.check = (n) => {
+    const o = n.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 {
+      n.issues.push({
+        code: "invalid_format",
+        format: "cidrv6",
+        input: n.value,
+        inst: t,
+        continue: !e.abort
+      });
+    }
+  };
+});
+function te(t) {
+  if (t === "")
+    return !0;
+  if (/\s/.test(t) || t.length % 4 !== 0)
+    return !1;
+  try {
+    return atob(t), !0;
+  } catch {
+    return !1;
+  }
+}
+const bt = /* @__PURE__ */ l("$ZodBase64", (t, e) => {
+  e.pattern ?? (e.pattern = Ne), m.init(t, e), t._zod.bag.contentEncoding = "base64", t._zod.check = (n) => {
+    te(n.value) || n.issues.push({
+      code: "invalid_format",
+      format: "base64",
+      input: n.value,
+      inst: t,
+      continue: !e.abort
+    });
+  };
+});
+function Je(t) {
+  if (!ee.test(t))
+    return !1;
+  const e = t.replace(/[-_]/g, (o) => o === "-" ? "+" : "/"), n = e.padEnd(Math.ceil(e.length / 4) * 4, "=");
+  return te(n);
+}
+const wt = /* @__PURE__ */ l("$ZodBase64URL", (t, e) => {
+  e.pattern ?? (e.pattern = ee), m.init(t, e), t._zod.bag.contentEncoding = "base64url", t._zod.check = (n) => {
+    Je(n.value) || n.issues.push({
+      code: "invalid_format",
+      format: "base64url",
+      input: n.value,
+      inst: t,
+      continue: !e.abort
+    });
+  };
+}), kt = /* @__PURE__ */ l("$ZodE164", (t, e) => {
+  e.pattern ?? (e.pattern = Ue), m.init(t, e);
+});
+function Me(t, e = null) {
+  try {
+    const n = t.split(".");
+    if (n.length !== 3)
+      return !1;
+    const [o] = n;
+    if (!o)
+      return !1;
+    const r = JSON.parse(atob(o));
+    return !("typ" in r && r?.typ !== "JWT" || !r.alg || e && (!("alg" in r) || r.alg !== e));
+  } catch {
+    return !1;
+  }
+}
+const Pt = /* @__PURE__ */ l("$ZodJWT", (t, e) => {
+  m.init(t, e), t._zod.check = (n) => {
+    Me(n.value, e.alg) || n.issues.push({
+      code: "invalid_format",
+      format: "jwt",
+      input: n.value,
+      inst: t,
+      continue: !e.abort
+    });
+  };
+}), We = /* @__PURE__ */ l("$ZodNumber", (t, e) => {
+  f.init(t, e), t._zod.pattern = t._zod.bag.pattern ?? Y, t._zod.parse = (n, o) => {
+    if (e.coerce)
+      try {
+        n.value = Number(n.value);
+      } catch {
+      }
+    const r = n.value;
+    if (typeof r == "number" && !Number.isNaN(r) && Number.isFinite(r))
+      return n;
+    const s = typeof r == "number" ? Number.isNaN(r) ? "NaN" : Number.isFinite(r) ? void 0 : "Infinity" : void 0;
+    return n.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input: r,
+      inst: t,
+      ...s ? { received: s } : {}
+    }), n;
+  };
+}), Tt = /* @__PURE__ */ l("$ZodNumberFormat", (t, e) => {
+  ue.init(t, e), We.init(t, e);
+}), Rt = /* @__PURE__ */ l("$ZodBoolean", (t, e) => {
+  f.init(t, e), t._zod.pattern = _e, t._zod.parse = (n, o) => {
+    if (e.coerce)
+      try {
+        n.value = !!n.value;
+      } catch {
+      }
+    const r = n.value;
+    return typeof r == "boolean" || n.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input: r,
+      inst: t
+    }), n;
+  };
+}), It = /* @__PURE__ */ l("$ZodUnknown", (t, e) => {
+  f.init(t, e), t._zod.parse = (n) => n;
+}), Ot = /* @__PURE__ */ l("$ZodNever", (t, e) => {
+  f.init(t, e), t._zod.parse = (n, o) => (n.issues.push({
+    expected: "never",
+    code: "invalid_type",
+    input: n.value,
+    inst: t
+  }), n);
+}), Et = /* @__PURE__ */ l("$ZodDate", (t, e) => {
+  f.init(t, e), t._zod.parse = (n, o) => {
+    if (e.coerce)
+      try {
+        n.value = new Date(n.value);
+      } catch {
+      }
+    const r = n.value, s = r instanceof Date;
+    return s && !Number.isNaN(r.getTime()) || n.issues.push({
+      expected: "date",
+      code: "invalid_type",
+      input: r,
+      ...s ? { received: "Invalid Date" } : {},
+      inst: t
+    }), n;
+  };
+});
+function B(t, e, n) {
+  t.issues.length && e.issues.push(...b(n, t.issues)), e.value[n] = t.value;
+}
+const Dt = /* @__PURE__ */ l("$ZodArray", (t, e) => {
+  f.init(t, e), t._zod.parse = (n, o) => {
+    const r = n.value;
+    if (!Array.isArray(r))
+      return n.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input: r,
+        inst: t
+      }), n;
+    n.value = Array(r.length);
+    const s = [];
+    for (let i = 0; i < r.length; i++) {
+      const u = r[i], c = e.element._zod.run({
+        value: u,
+        issues: []
+      }, o);
+      c instanceof Promise ? s.push(c.then((a) => B(a, n, i))) : B(c, n, i);
+    }
+    return s.length ? Promise.all(s).then(() => n) : n;
+  };
+});
+function E(t, e, n, o, r, s) {
+  const i = n in o;
+  if (t.issues.length) {
+    if (r && s && !i)
+      return;
+    e.issues.push(...b(n, t.issues));
+  }
+  if (!i && !r) {
+    t.issues.length || e.issues.push({
+      code: "invalid_type",
+      expected: "nonoptional",
+      input: void 0,
+      path: [n]
+    });
+    return;
+  }
+  t.value === void 0 ? i && (e.value[n] = void 0) : e.value[n] = t.value;
+}
+function ne(t) {
+  const e = Object.keys(t.shape);
+  for (const o of e)
+    if (!t.shape?.[o]?._zod?.traits?.has("$ZodType"))
+      throw new Error(`Invalid element at key "${o}": expected a Zod schema`);
+  const n = Le(t.shape);
+  return {
+    ...t,
+    keys: e,
+    keySet: new Set(e),
+    numKeys: e.length,
+    optionalKeys: new Set(n)
+  };
+}
+function oe(t, e, n, o, r, s) {
+  const i = [], u = r.keySet, c = r.catchall._zod, a = c.def.type, p = c.optin === "optional", d = c.optout === "optional";
+  for (const v in e) {
+    if (v === "__proto__" || u.has(v))
+      continue;
+    if (a === "never") {
+      i.push(v);
+      continue;
+    }
+    const h = c.run({ value: e[v], issues: [] }, o);
+    h instanceof Promise ? t.push(h.then((g) => E(g, n, v, e, p, d))) : E(h, n, v, e, p, d);
+  }
+  return i.length && n.issues.push({
+    code: "unrecognized_keys",
+    keys: i,
+    input: e,
+    inst: s
+  }), t.length ? Promise.all(t).then(() => n) : n;
+}
+const xe = /* @__PURE__ */ l("$ZodObject", (t, e) => {
+  if (f.init(t, e), !Object.getOwnPropertyDescriptor(e, "shape")?.get) {
+    const u = e.shape;
+    Object.defineProperty(e, "shape", {
+      get: () => {
+        const c = { ...u };
+        return Object.defineProperty(e, "shape", {
+          value: c
+        }), c;
+      }
+    });
+  }
+  const o = A(() => ne(e));
+  _(t._zod, "propValues", () => {
+    const u = e.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 = y, s = e.catchall;
+  let i;
+  t._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: t
+      }), u;
+    u.value = {};
+    const p = [], d = i.shape;
+    for (const v of i.keys) {
+      const h = d[v], g = h._zod.optin === "optional", R = h._zod.optout === "optional", w = h._zod.run({ value: a[v], issues: [] }, c);
+      w instanceof Promise ? p.push(w.then((D) => E(D, u, v, a, g, R))) : E(w, u, v, a, g, R);
+    }
+    return s ? oe(p, a, u, c, o.value, t) : p.length ? Promise.all(p).then(() => u) : u;
+  };
+}), St = /* @__PURE__ */ l("$ZodObjectJIT", (t, e) => {
+  xe.init(t, e);
+  const n = t._zod.parse, o = A(() => ne(e)), r = (v) => {
+    const h = new pe(["shape", "payload", "ctx"]), g = o.value, R = (Z) => {
+      const z = K(Z);
+      return `shape[${z}]._zod.run({ value: input[${z}], issues: [] }, ctx)`;
+    };
+    h.write("const input = payload.value;");
+    const w = /* @__PURE__ */ Object.create(null);
+    let D = 0;
+    for (const Z of g.keys)
+      w[Z] = `key_${D++}`;
+    h.write("const newResult = {};");
+    for (const Z of g.keys) {
+      const z = w[Z], $ = K(Z), V = v[Z], C = V?._zod?.optin === "optional", se = V?._zod?.optout === "optional";
+      h.write(`const ${z} = ${R(Z)};`), C && se ? h.write(`
+        if (${z}.issues.length) {
+          if (${$} in input) {
+            payload.issues = payload.issues.concat(${z}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${$}, ...iss.path] : [${$}]
+            })));
+          }
+        }
+        
+        if (${z}.value === undefined) {
+          if (${$} in input) {
+            newResult[${$}] = undefined;
+          }
+        } else {
+          newResult[${$}] = ${z}.value;
+        }
+        
+      `) : C ? h.write(`
+        if (${z}.issues.length) {
+          payload.issues = payload.issues.concat(${z}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${$}, ...iss.path] : [${$}]
+          })));
+        }
+        
+        if (${z}.value === undefined) {
+          if (${$} in input) {
+            newResult[${$}] = undefined;
+          }
+        } else {
+          newResult[${$}] = ${z}.value;
+        }
+        
+      `) : h.write(`
+        const ${z}_present = ${$} in input;
+        if (${z}.issues.length) {
+          payload.issues = payload.issues.concat(${z}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${$}, ...iss.path] : [${$}]
+          })));
+        }
+        if (!${z}_present && !${z}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${$}]
+          });
+        }
+
+        if (${z}_present) {
+          if (${z}.value === undefined) {
+            newResult[${$}] = undefined;
+          } else {
+            newResult[${$}] = ${z}.value;
+          }
+        }
+
+      `);
+    }
+    h.write("payload.value = newResult;"), h.write("return payload;");
+    const re = h.compile();
+    return (Z, z) => re(v, Z, z);
+  };
+  let s;
+  const i = y, u = !ae.jitless, a = u && Ce.value, p = e.catchall;
+  let d;
+  t._zod.parse = (v, h) => {
+    d ?? (d = o.value);
+    const g = v.value;
+    return i(g) ? u && a && h?.async === !1 && h.jitless !== !0 ? (s || (s = r(e.shape)), v = s(v, h), p ? oe([], g, v, h, d, t) : v) : n(v, h) : (v.issues.push({
+      expected: "object",
+      code: "invalid_type",
+      input: g,
+      inst: t
+    }), v);
+  };
+});
+function F(t, e, n, o) {
+  for (const s of t)
+    if (s.issues.length === 0)
+      return e.value = s.value, e;
+  const r = t.filter((s) => !k(s));
+  return r.length === 1 ? (e.value = r[0].value, r[0]) : (e.issues.push({
+    code: "invalid_union",
+    input: e.value,
+    inst: n,
+    errors: t.map((s) => s.issues.map((i) => T(i, o, P())))
+  }), e);
+}
+const Ge = /* @__PURE__ */ l("$ZodUnion", (t, e) => {
+  f.init(t, e), _(t._zod, "optin", () => e.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0), _(t._zod, "optout", () => e.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0), _(t._zod, "values", () => {
+    if (e.options.every((o) => o._zod.values))
+      return new Set(e.options.flatMap((o) => Array.from(o._zod.values)));
+  }), _(t._zod, "pattern", () => {
+    if (e.options.every((o) => o._zod.pattern)) {
+      const o = e.options.map((r) => r._zod.pattern);
+      return new RegExp(`^(${o.map((r) => U(r.source)).join("|")})$`);
+    }
+  });
+  const n = e.options.length === 1 ? e.options[0]._zod.run : null;
+  t._zod.parse = (o, r) => {
+    if (n)
+      return n(o, r);
+    let s = !1;
+    const i = [];
+    for (const u of e.options) {
+      const c = u._zod.run({
+        value: o.value,
+        issues: []
+      }, r);
+      if (c instanceof Promise)
+        i.push(c), s = !0;
+      else {
+        if (c.issues.length === 0)
+          return c;
+        i.push(c);
+      }
+    }
+    return s ? Promise.all(i).then((u) => F(u, o, t, r)) : F(i, o, t, r);
+  };
+}), jt = /* @__PURE__ */ l("$ZodDiscriminatedUnion", (t, e) => {
+  e.inclusive = !1, Ge.init(t, e);
+  const n = t._zod.parse;
+  _(t._zod, "propValues", () => {
+    const r = {};
+    for (const s of e.options) {
+      const i = s._zod.propValues;
+      if (!i || Object.keys(i).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${e.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 = A(() => {
+    const r = e.options, s = /* @__PURE__ */ new Map();
+    for (const i of r) {
+      const u = i._zod.propValues?.[e.discriminator];
+      if (!u || u.size === 0)
+        throw new Error(`Invalid discriminated union option at index "${e.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;
+  });
+  t._zod.parse = (r, s) => {
+    const i = r.value;
+    if (!y(i))
+      return r.issues.push({
+        code: "invalid_type",
+        expected: "object",
+        input: i,
+        inst: t
+      }), r;
+    const u = o.value.get(i?.[e.discriminator]);
+    return u ? u._zod.run(r, s) : e.unionFallback || s.direction === "backward" ? n(r, s) : (r.issues.push({
+      code: "invalid_union",
+      errors: [],
+      note: "No matching discriminator",
+      discriminator: e.discriminator,
+      options: Array.from(o.value.keys()),
+      input: i,
+      path: [e.discriminator],
+      inst: t
+    }), r);
+  };
+}), Nt = /* @__PURE__ */ l("$ZodIntersection", (t, e) => {
+  f.init(t, e), t._zod.parse = (n, o) => {
+    const r = n.value, s = e.left._zod.run({ value: r, issues: [] }, o), i = e.right._zod.run({ value: r, issues: [] }, o);
+    return s instanceof Promise || i instanceof Promise ? Promise.all([s, i]).then(([c, a]) => J(n, c, a)) : J(n, s, i);
+  };
+});
+function N(t, e) {
+  if (t === e)
+    return { valid: !0, data: t };
+  if (t instanceof Date && e instanceof Date && +t == +e)
+    return { valid: !0, data: t };
+  if (j(t) && j(e)) {
+    const n = Object.keys(e), o = Object.keys(t).filter((s) => n.indexOf(s) !== -1), r = { ...t, ...e };
+    for (const s of o) {
+      const i = N(t[s], e[s]);
+      if (!i.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [s, ...i.mergeErrorPath]
+        };
+      r[s] = i.data;
+    }
+    return { valid: !0, data: r };
+  }
+  if (Array.isArray(t) && Array.isArray(e)) {
+    if (t.length !== e.length)
+      return { valid: !1, mergeErrorPath: [] };
+    const n = [];
+    for (let o = 0; o < t.length; o++) {
+      const r = t[o], s = e[o], i = N(r, s);
+      if (!i.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [o, ...i.mergeErrorPath]
+        };
+      n.push(i.data);
+    }
+    return { valid: !0, data: n };
+  }
+  return { valid: !1, mergeErrorPath: [] };
+}
+function J(t, e, n) {
+  const o = /* @__PURE__ */ new Map();
+  let r;
+  for (const u of e.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
+      t.issues.push(u);
+  for (const u of n.issues)
+    if (u.code === "unrecognized_keys")
+      for (const c of u.keys)
+        o.has(c) || o.set(c, {}), o.get(c).r = !0;
+    else
+      t.issues.push(u);
+  const s = [...o].filter(([, u]) => u.l && u.r).map(([u]) => u);
+  if (s.length && r && t.issues.push({ ...r, keys: s }), k(t))
+    return t;
+  const i = N(e.value, n.value);
+  if (!i.valid)
+    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(i.mergeErrorPath)}`);
+  return t.value = i.data, t;
+}
+const Ut = /* @__PURE__ */ l("$ZodTuple", (t, e) => {
+  f.init(t, e);
+  const n = e.items;
+  t._zod.parse = (o, r) => {
+    const s = o.value;
+    if (!Array.isArray(s))
+      return o.issues.push({
+        input: s,
+        inst: t,
+        expected: "tuple",
+        code: "invalid_type"
+      }), o;
+    o.value = [];
+    const i = [], u = M(n, "optin"), c = M(n, "optout");
+    if (!e.rest) {
+      if (s.length < u)
+        return o.issues.push({
+          code: "too_small",
+          minimum: u,
+          inclusive: !0,
+          input: s,
+          inst: t,
+          origin: "array"
+        }), o;
+      s.length > n.length && o.issues.push({
+        code: "too_big",
+        maximum: n.length,
+        inclusive: !0,
+        input: s,
+        inst: t,
+        origin: "array"
+      });
+    }
+    const a = new Array(n.length);
+    for (let p = 0; p < n.length; p++) {
+      const d = n[p]._zod.run({ value: s[p], issues: [] }, r);
+      d instanceof Promise ? i.push(d.then((v) => {
+        a[p] = v;
+      })) : a[p] = d;
+    }
+    if (e.rest) {
+      let p = n.length - 1;
+      const d = s.slice(n.length);
+      for (const v of d) {
+        p++;
+        const h = e.rest._zod.run({ value: v, issues: [] }, r);
+        h instanceof Promise ? i.push(h.then((g) => W(g, o, p))) : W(h, o, p);
+      }
+    }
+    return i.length ? Promise.all(i).then(() => x(a, o, n, s, c)) : x(a, o, n, s, c);
+  };
+});
+function M(t, e) {
+  for (let n = t.length - 1; n >= 0; n--)
+    if (t[n]._zod[e] !== "optional")
+      return n + 1;
+  return 0;
+}
+function W(t, e, n) {
+  t.issues.length && e.issues.push(...b(n, t.issues)), e.value[n] = t.value;
+}
+function x(t, e, n, o, r) {
+  for (let s = 0; s < n.length; s++) {
+    const i = t[s], u = s < o.length;
+    if (i.issues.length) {
+      if (!u && s >= r) {
+        e.value.length = s;
+        break;
+      }
+      e.issues.push(...b(s, i.issues));
+    }
+    e.value[s] = i.value;
+  }
+  for (let s = e.value.length - 1; s >= o.length && (n[s]._zod.optout === "optional" && e.value[s] === void 0); s--)
+    e.value.length = s;
+  return e;
+}
+const yt = /* @__PURE__ */ l("$ZodRecord", (t, e) => {
+  f.init(t, e), t._zod.parse = (n, o) => {
+    const r = n.value;
+    if (!j(r))
+      return n.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input: r,
+        inst: t
+      }), n;
+    const s = [], i = e.keyType._zod.values;
+    if (i) {
+      n.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 = e.keyType._zod.run({ value: a, issues: [] }, o);
+          if (p instanceof Promise)
+            throw new Error("Async schemas not supported in object keys currently");
+          if (p.issues.length) {
+            n.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: p.issues.map((h) => T(h, o, P())),
+              input: a,
+              path: [a],
+              inst: t
+            });
+            continue;
+          }
+          const d = p.value, v = e.valueType._zod.run({ value: r[a], issues: [] }, o);
+          v instanceof Promise ? s.push(v.then((h) => {
+            h.issues.length && n.issues.push(...b(a, h.issues)), n.value[d] = h.value;
+          })) : (v.issues.length && n.issues.push(...b(a, v.issues)), n.value[d] = v.value);
+        }
+      let c;
+      for (const a in r)
+        u.has(a) || (c = c ?? [], c.push(a));
+      c && c.length > 0 && n.issues.push({
+        code: "unrecognized_keys",
+        input: r,
+        inst: t,
+        keys: c
+      });
+    } else {
+      n.value = {};
+      for (const u of Reflect.ownKeys(r)) {
+        if (u === "__proto__" || !Object.prototype.propertyIsEnumerable.call(r, u))
+          continue;
+        let c = e.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" && Y.test(u) && c.issues.length) {
+          const d = e.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) {
+          e.mode === "loose" ? n.value[u] = r[u] : n.issues.push({
+            code: "invalid_key",
+            origin: "record",
+            issues: c.issues.map((d) => T(d, o, P())),
+            input: u,
+            path: [u],
+            inst: t
+          });
+          continue;
+        }
+        const p = e.valueType._zod.run({ value: r[u], issues: [] }, o);
+        p instanceof Promise ? s.push(p.then((d) => {
+          d.issues.length && n.issues.push(...b(u, d.issues)), n.value[c.value] = d.value;
+        })) : (p.issues.length && n.issues.push(...b(u, p.issues)), n.value[c.value] = p.value);
+      }
+    }
+    return s.length ? Promise.all(s).then(() => n) : n;
+  };
+}), At = /* @__PURE__ */ l("$ZodEnum", (t, e) => {
+  f.init(t, e);
+  const n = ye(e.entries), o = new Set(n);
+  t._zod.values = o, t._zod.pattern = new RegExp(`^(${n.filter((r) => Ae.has(typeof r)).map((r) => typeof r == "string" ? S(r) : r.toString()).join("|")})$`), t._zod.parse = (r, s) => {
+    const i = r.value;
+    return o.has(i) || r.issues.push({
+      code: "invalid_value",
+      values: n,
+      input: i,
+      inst: t
+    }), r;
+  };
+}), Vt = /* @__PURE__ */ l("$ZodLiteral", (t, e) => {
+  if (f.init(t, e), e.values.length === 0)
+    throw new Error("Cannot create literal schema with no valid values");
+  const n = new Set(e.values);
+  t._zod.values = n, t._zod.pattern = new RegExp(`^(${e.values.map((o) => typeof o == "string" ? S(o) : o ? S(o.toString()) : String(o)).join("|")})$`), t._zod.parse = (o, r) => {
+    const s = o.value;
+    return n.has(s) || o.issues.push({
+      code: "invalid_value",
+      values: e.values,
+      input: s,
+      inst: t
+    }), o;
+  };
+}), Ct = /* @__PURE__ */ l("$ZodTransform", (t, e) => {
+  f.init(t, e), t._zod.optin = "optional", t._zod.parse = (n, o) => {
+    if (o.direction === "backward")
+      throw new le(t.constructor.name);
+    const r = e.transform(n.value, n);
+    if (o.async)
+      return (r instanceof Promise ? r : Promise.resolve(r)).then((i) => (n.value = i, n.fallback = !0, n));
+    if (r instanceof Promise)
+      throw new O();
+    return n.value = r, n.fallback = !0, n;
+  };
+});
+function G(t, e) {
+  return e === void 0 && (t.issues.length || t.fallback) ? { issues: [], value: void 0 } : t;
+}
+const Xe = /* @__PURE__ */ l("$ZodOptional", (t, e) => {
+  f.init(t, e), t._zod.optin = "optional", t._zod.optout = "optional", _(t._zod, "values", () => e.innerType._zod.values ? /* @__PURE__ */ new Set([...e.innerType._zod.values, void 0]) : void 0), _(t._zod, "pattern", () => {
+    const n = e.innerType._zod.pattern;
+    return n ? new RegExp(`^(${U(n.source)})?$`) : void 0;
+  }), t._zod.parse = (n, o) => {
+    if (e.innerType._zod.optin === "optional") {
+      const r = n.value, s = e.innerType._zod.run(n, o);
+      return s instanceof Promise ? s.then((i) => G(i, r)) : G(s, r);
+    }
+    return n.value === void 0 ? n : e.innerType._zod.run(n, o);
+  };
+}), Lt = /* @__PURE__ */ l("$ZodExactOptional", (t, e) => {
+  Xe.init(t, e), _(t._zod, "values", () => e.innerType._zod.values), _(t._zod, "pattern", () => e.innerType._zod.pattern), t._zod.parse = (n, o) => e.innerType._zod.run(n, o);
+}), Kt = /* @__PURE__ */ l("$ZodNullable", (t, e) => {
+  f.init(t, e), _(t._zod, "optin", () => e.innerType._zod.optin), _(t._zod, "optout", () => e.innerType._zod.optout), _(t._zod, "pattern", () => {
+    const n = e.innerType._zod.pattern;
+    return n ? new RegExp(`^(${U(n.source)}|null)$`) : void 0;
+  }), _(t._zod, "values", () => e.innerType._zod.values ? /* @__PURE__ */ new Set([...e.innerType._zod.values, null]) : void 0), t._zod.parse = (n, o) => n.value === null ? n : e.innerType._zod.run(n, o);
+}), Bt = /* @__PURE__ */ l("$ZodDefault", (t, e) => {
+  f.init(t, e), t._zod.optin = "optional", _(t._zod, "values", () => e.innerType._zod.values), t._zod.parse = (n, o) => {
+    if (o.direction === "backward")
+      return e.innerType._zod.run(n, o);
+    if (n.value === void 0)
+      return n.value = e.defaultValue, n;
+    const r = e.innerType._zod.run(n, o);
+    return r instanceof Promise ? r.then((s) => X(s, e)) : X(r, e);
+  };
+});
+function X(t, e) {
+  return t.value === void 0 && (t.value = e.defaultValue), t;
+}
+const Ft = /* @__PURE__ */ l("$ZodPrefault", (t, e) => {
+  f.init(t, e), t._zod.optin = "optional", _(t._zod, "values", () => e.innerType._zod.values), t._zod.parse = (n, o) => (o.direction === "backward" || n.value === void 0 && (n.value = e.defaultValue), e.innerType._zod.run(n, o));
+}), Jt = /* @__PURE__ */ l("$ZodNonOptional", (t, e) => {
+  f.init(t, e), _(t._zod, "values", () => {
+    const n = e.innerType._zod.values;
+    return n ? new Set([...n].filter((o) => o !== void 0)) : void 0;
+  }), t._zod.parse = (n, o) => {
+    const r = e.innerType._zod.run(n, o);
+    return r instanceof Promise ? r.then((s) => H(s, t)) : H(r, t);
+  };
+});
+function H(t, e) {
+  return !t.issues.length && t.value === void 0 && t.issues.push({
+    code: "invalid_type",
+    expected: "nonoptional",
+    input: t.value,
+    inst: e
+  }), t;
+}
+const Mt = /* @__PURE__ */ l("$ZodCatch", (t, e) => {
+  f.init(t, e), t._zod.optin = "optional", _(t._zod, "optout", () => e.innerType._zod.optout), _(t._zod, "values", () => e.innerType._zod.values), t._zod.parse = (n, o) => {
+    if (o.direction === "backward")
+      return e.innerType._zod.run(n, o);
+    const r = e.innerType._zod.run(n, o);
+    return r instanceof Promise ? r.then((s) => (n.value = s.value, s.issues.length && (n.value = e.catchValue({
+      ...n,
+      error: {
+        issues: s.issues.map((i) => T(i, o, P()))
+      },
+      input: n.value
+    }), n.issues = [], n.fallback = !0), n)) : (n.value = r.value, r.issues.length && (n.value = e.catchValue({
+      ...n,
+      error: {
+        issues: r.issues.map((s) => T(s, o, P()))
+      },
+      input: n.value
+    }), n.issues = [], n.fallback = !0), n);
+  };
+}), Wt = /* @__PURE__ */ l("$ZodPipe", (t, e) => {
+  f.init(t, e), _(t._zod, "values", () => e.in._zod.values), _(t._zod, "optin", () => e.in._zod.optin), _(t._zod, "optout", () => e.out._zod.optout), _(t._zod, "propValues", () => e.in._zod.propValues), t._zod.parse = (n, o) => {
+    if (o.direction === "backward") {
+      const s = e.out._zod.run(n, o);
+      return s instanceof Promise ? s.then((i) => I(i, e.in, o)) : I(s, e.in, o);
+    }
+    const r = e.in._zod.run(n, o);
+    return r instanceof Promise ? r.then((s) => I(s, e.out, o)) : I(r, e.out, o);
+  };
+});
+function I(t, e, n) {
+  return t.issues.length ? (t.aborted = !0, t) : e._zod.run({ value: t.value, issues: t.issues, fallback: t.fallback }, n);
+}
+const xt = /* @__PURE__ */ l("$ZodReadonly", (t, e) => {
+  f.init(t, e), _(t._zod, "propValues", () => e.innerType._zod.propValues), _(t._zod, "values", () => e.innerType._zod.values), _(t._zod, "optin", () => e.innerType?._zod?.optin), _(t._zod, "optout", () => e.innerType?._zod?.optout), t._zod.parse = (n, o) => {
+    if (o.direction === "backward")
+      return e.innerType._zod.run(n, o);
+    const r = e.innerType._zod.run(n, o);
+    return r instanceof Promise ? r.then(q) : q(r);
+  };
+});
+function q(t) {
+  return t.value = Object.freeze(t.value), t;
+}
+const Gt = /* @__PURE__ */ l("$ZodCustom", (t, e) => {
+  ce.init(t, e), f.init(t, e), t._zod.parse = (n, o) => n, t._zod.check = (n) => {
+    const o = n.value, r = e.fn(o);
+    if (r instanceof Promise)
+      return r.then((s) => Q(s, n, o, t));
+    Q(r, n, o, t);
+  };
+});
+function Q(t, e, n, o) {
+  if (!t) {
+    const r = {
+      code: "custom",
+      input: n,
+      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), e.issues.push(Ke(r));
+  }
+}
+export {
+  Dt as $ZodArray,
+  bt as $ZodBase64,
+  wt as $ZodBase64URL,
+  Rt as $ZodBoolean,
+  gt as $ZodCIDRv4,
+  Zt as $ZodCIDRv6,
+  at as $ZodCUID,
+  lt as $ZodCUID2,
+  Mt as $ZodCatch,
+  Gt as $ZodCustom,
+  Et as $ZodDate,
+  Bt as $ZodDefault,
+  jt as $ZodDiscriminatedUnion,
+  kt as $ZodE164,
+  st as $ZodEmail,
+  ut as $ZodEmoji,
+  At as $ZodEnum,
+  Lt as $ZodExactOptional,
+  ot as $ZodGUID,
+  zt as $ZodIPv4,
+  $t as $ZodIPv6,
+  _t as $ZodISODate,
+  dt as $ZodISODateTime,
+  mt as $ZodISODuration,
+  ft as $ZodISOTime,
+  Nt as $ZodIntersection,
+  Pt as $ZodJWT,
+  ht as $ZodKSUID,
+  Vt as $ZodLiteral,
+  ct as $ZodNanoID,
+  Ot as $ZodNever,
+  Jt as $ZodNonOptional,
+  Kt as $ZodNullable,
+  We as $ZodNumber,
+  Tt as $ZodNumberFormat,
+  xe as $ZodObject,
+  St as $ZodObjectJIT,
+  Xe as $ZodOptional,
+  Wt as $ZodPipe,
+  Ft as $ZodPrefault,
+  xt as $ZodReadonly,
+  yt as $ZodRecord,
+  Fe as $ZodString,
+  m as $ZodStringFormat,
+  Ct as $ZodTransform,
+  Ut as $ZodTuple,
+  f as $ZodType,
+  pt as $ZodULID,
+  it as $ZodURL,
+  rt as $ZodUUID,
+  Ge as $ZodUnion,
+  It as $ZodUnknown,
+  vt as $ZodXID,
+  qt as clone,
+  te as isValidBase64,
+  Je as isValidBase64URL,
+  Me as isValidJWT
+};
+//# sourceMappingURL=index.es619.js.map