@btc-vision/transaction 1.7.22 → 1.7.23

package/browser/valibot.js

@@ -0,0 +1,4948 @@
+var t = {}, us;
+function Ys() {
+  if (us) return t;
+  us = 1;
+  let D;
+  function ls(r) {
+    D = {
+      ...D,
+      ...r
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function j(r) {
+    return {
+      lang: r?.lang ?? D?.lang,
+      message: r?.message,
+      abortEarly: r?.abortEarly ?? D?.abortEarly,
+      abortPipeEarly: r?.abortPipeEarly ?? D?.abortPipeEarly
+    };
+  }
+  function os() {
+    D = void 0;
+  }
+  let O;
+  function cs(r, n) {
+    O || (O = /* @__PURE__ */ new Map()), O.set(n, r);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ie(r) {
+    return O?.get(r);
+  }
+  function fs(r) {
+    O?.delete(r);
+  }
+  let G;
+  function ps(r, n) {
+    G || (G = /* @__PURE__ */ new Map()), G.set(n, r);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function se(r) {
+    return G?.get(r);
+  }
+  function as(r) {
+    G?.delete(r);
+  }
+  let w;
+  function ys(r, n, e) {
+    w || (w = /* @__PURE__ */ new Map()), w.get(r) || w.set(r, /* @__PURE__ */ new Map()), w.get(r).set(e, n);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function te(r, n) {
+    return w?.get(r)?.get(n);
+  }
+  function hs(r, n) {
+    w?.get(r)?.delete(n);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function m(r) {
+    const n = typeof r;
+    return n === "string" ? `"${r}"` : n === "number" || n === "bigint" || n === "boolean" ? `${r}` : n === "object" || n === "function" ? (r && Object.getPrototypeOf(r)?.constructor?.name) ?? "null" : n;
+  }
+  function f(r, n, e, i, s) {
+    const u = s && "input" in s ? s.input : e.value, l = s?.expected ?? r.expects ?? null, c = s?.received ?? /* @__PURE__ */ m(u), o = {
+      kind: r.kind,
+      type: r.type,
+      input: u,
+      expected: l,
+      received: c,
+      message: `Invalid ${n}: ${l ? `Expected ${l} but r` : "R"}eceived ${c}`,
+      requirement: r.requirement,
+      path: s?.path,
+      issues: s?.issues,
+      lang: i.lang,
+      abortEarly: i.abortEarly,
+      abortPipeEarly: i.abortPipeEarly
+    }, p = r.kind === "schema", a = s?.message ?? r.message ?? /* @__PURE__ */ te(r.reference, o.lang) ?? (p ? /* @__PURE__ */ se(o.lang) : null) ?? i.message ?? /* @__PURE__ */ ie(o.lang);
+    a !== void 0 && (o.message = typeof a == "function" ? a(o) : a), p && (e.typed = !1), e.issues ? e.issues.push(o) : e.issues = [o];
+  }
+  let z;
+  // @__NO_SIDE_EFFECTS__
+  function R(r) {
+    return z || (z = new TextEncoder()), z.encode(r).length;
+  }
+  let T;
+  // @__NO_SIDE_EFFECTS__
+  function q(r) {
+    T || (T = new Intl.Segmenter());
+    const n = T.segment(r);
+    let e = 0;
+    for (const i of n) e++;
+    return e;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function X(r, n) {
+    if ("pipe" in r) {
+      const e = [];
+      for (let i = r.pipe.length - 1; i >= 0; i--) {
+        const s = r.pipe[i];
+        if (s.kind === "schema" && "pipe" in s) e.push(s);
+        else if (s.kind === "metadata" && s.type === n) return s[n];
+      }
+      for (const i of e) {
+        const s = /* @__PURE__ */ X(i, n);
+        if (s !== void 0) return s;
+      }
+    }
+  }
+  // @__NO_SIDE_EFFECTS__
+  function y(r) {
+    return {
+      version: 1,
+      vendor: "valibot",
+      validate(n) {
+        return r["~run"]({ value: n }, /* @__PURE__ */ j());
+      }
+    };
+  }
+  let M;
+  // @__NO_SIDE_EFFECTS__
+  function S(r, n) {
+    M || (M = /* @__PURE__ */ new Map()), M.get(r) || M.set(r, new Intl.Segmenter(r, { granularity: "word" }));
+    const e = M.get(r).segment(n);
+    let i = 0;
+    for (const s of e) s.isWordLike && i++;
+    return i;
+  }
+  const vs = /\D/gu;
+  // @__NO_SIDE_EFFECTS__
+  function F(r) {
+    const n = r.replace(vs, "");
+    let e = n.length, i = 1, s = 0;
+    for (; e; ) {
+      const u = +n[--e];
+      i ^= 1, s += i ? [
+        0,
+        2,
+        4,
+        6,
+        8,
+        1,
+        3,
+        5,
+        7,
+        9
+      ][u] : u;
+    }
+    return s % 10 === 0;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function I(r, n) {
+    return Object.hasOwn(r, n) && n !== "__proto__" && n !== "prototype" && n !== "constructor";
+  }
+  // @__NO_SIDE_EFFECTS__
+  function E(r, n) {
+    const e = [...new Set(r)];
+    return e.length > 1 ? `(${e.join(` ${n} `)})` : e[0] ?? "never";
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ms(r, n) {
+    const e = {};
+    for (const i of r) e[i] = n;
+    return e;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function gs(r) {
+    const n = {};
+    for (const e of r) Object.assign(n, e.entries);
+    return n;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $(r) {
+    if (r.path) {
+      let n = "";
+      for (const e of r.path) if (typeof e.key == "string" || typeof e.key == "number") n ? n += `.${e.key}` : n += e.key;
+      else return null;
+      return n;
+    }
+    return null;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ds(r, n) {
+    return n.kind === r;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ks(r, n) {
+    return n.type === r;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function bs(r) {
+    return r instanceof x;
+  }
+  var x = class extends Error {
+    /**
+    * Creates a Valibot error with useful information.
+    *
+    * @param issues The error issues.
+    */
+    constructor(r) {
+      super(r[0].message), this.name = "ValiError", this.issues = r;
+    }
+  };
+  // @__NO_SIDE_EFFECTS__
+  function ue(r) {
+    return {
+      kind: "transformation",
+      type: "args",
+      reference: ue,
+      async: !1,
+      schema: r,
+      "~run"(n, e) {
+        const i = n.value;
+        return n.value = (...s) => {
+          const u = this.schema["~run"]({ value: s }, e);
+          if (u.issues) throw new x(u.issues);
+          return i(...u.value);
+        }, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function le(r) {
+    return {
+      kind: "transformation",
+      type: "args",
+      reference: le,
+      async: !1,
+      schema: r,
+      "~run"(n, e) {
+        const i = n.value;
+        return n.value = async (...s) => {
+          const u = await r["~run"]({ value: s }, e);
+          if (u.issues) throw new x(u.issues);
+          return i(...u.value);
+        }, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function oe() {
+    return {
+      kind: "transformation",
+      type: "await",
+      reference: oe,
+      async: !0,
+      async "~run"(r) {
+        return r.value = await r.value, r;
+      }
+    };
+  }
+  const ce = /^(?:[\da-z+/]{4})*(?:[\da-z+/]{2}==|[\da-z+/]{3}=)?$/iu, fe = /^[A-Z]{6}(?!00)[\dA-Z]{2}(?:[\dA-Z]{3})?$/u, pe = /^[a-z][\da-z]*$/u, ae = /^[+-]?(?:\d*\.)?\d+$/u, ye = /^\d+$/u, he = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu, ve = /^(?:[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|(?![\p{Emoji_Modifier_Base}\u{1F1E6}-\u{1F1FF}])\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|(?![\p{Emoji_Modifier_Base}\u{1F1E6}-\u{1F1FF}])\p{Emoji_Presentation}))*)+$/u, me = /^(?:0[hx])?[\da-fA-F]+$/u, ge = /^#(?:[\da-fA-F]{3,4}|[\da-fA-F]{6}|[\da-fA-F]{8})$/u, de = /^\d{15}$|^\d{2}-\d{6}-\d{6}-\d$/u, ke = /^(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])(?:\.(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])){3}$/u, be = /^(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:|(?:[\da-f]{1,4}:){1,6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,5}(?::[\da-f]{1,4}){1,2}|(?:[\da-f]{1,4}:){1,4}(?::[\da-f]{1,4}){1,3}|(?:[\da-f]{1,4}:){1,3}(?::[\da-f]{1,4}){1,4}|(?:[\da-f]{1,4}:){1,2}(?::[\da-f]{1,4}){1,5}|[\da-f]{1,4}:(?::[\da-f]{1,4}){1,6}|:(?:(?::[\da-f]{1,4}){1,7}|:)|fe80:(?::[\da-f]{0,4}){0,4}%[\da-z]+|::(?:f{4}(?::0{1,4})?:)?(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d)|(?:[\da-f]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d))$/iu, Ee = /^(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])(?:\.(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])){3}$|^(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:|(?:[\da-f]{1,4}:){1,6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,5}(?::[\da-f]{1,4}){1,2}|(?:[\da-f]{1,4}:){1,4}(?::[\da-f]{1,4}){1,3}|(?:[\da-f]{1,4}:){1,3}(?::[\da-f]{1,4}){1,4}|(?:[\da-f]{1,4}:){1,2}(?::[\da-f]{1,4}){1,5}|[\da-f]{1,4}:(?::[\da-f]{1,4}){1,6}|:(?:(?::[\da-f]{1,4}){1,7}|:)|fe80:(?::[\da-f]{0,4}){0,4}%[\da-z]+|::(?:f{4}(?::0{1,4})?:)?(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d)|(?:[\da-f]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d))$/iu, xe = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])$/u, _e = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])[T ](?:0\d|1\d|2[0-3]):[0-5]\d$/u, Ae = /^(?:0\d|1\d|2[0-3]):[0-5]\d$/u, we = /^(?:0\d|1\d|2[0-3])(?::[0-5]\d){2}$/u, Ie = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])[T ](?:0\d|1\d|2[0-3])(?::[0-5]\d){2}(?:\.\d{1,9})?(?:Z|[+-](?:0\d|1\d|2[0-3])(?::?[0-5]\d)?)$/u, De = /^\d{4}-W(?:0[1-9]|[1-4]\d|5[0-3])$/u, je = /^(?:[\da-f]{2}:){5}[\da-f]{2}$|^(?:[\da-f]{2}-){5}[\da-f]{2}$|^(?:[\da-f]{4}\.){2}[\da-f]{4}$/iu, Oe = /^(?:[\da-f]{2}:){7}[\da-f]{2}$|^(?:[\da-f]{2}-){7}[\da-f]{2}$|^(?:[\da-f]{4}\.){3}[\da-f]{4}$|^(?:[\da-f]{4}:){3}[\da-f]{4}$/iu, Ge = /^(?:[\da-f]{2}:){5}[\da-f]{2}$|^(?:[\da-f]{2}-){5}[\da-f]{2}$|^(?:[\da-f]{4}\.){2}[\da-f]{4}$|^(?:[\da-f]{2}:){7}[\da-f]{2}$|^(?:[\da-f]{2}-){7}[\da-f]{2}$|^(?:[\da-f]{4}\.){3}[\da-f]{4}$|^(?:[\da-f]{4}:){3}[\da-f]{4}$/iu, Re = /^[\w-]+$/u, qe = /^(?:0o)?[0-7]+$/u, Me = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, Se = /^[\da-z]+(?:[-_][\da-z]+)*$/u, Pe = /^[\da-hjkmnp-tv-zA-HJKMNP-TV-Z]{26}$/u, Xe = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu;
+  // @__NO_SIDE_EFFECTS__
+  function Ne(r) {
+    return {
+      kind: "validation",
+      type: "base64",
+      reference: Ne,
+      async: !1,
+      expects: null,
+      requirement: ce,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "Base64", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ce(r) {
+    return {
+      kind: "validation",
+      type: "bic",
+      reference: Ce,
+      async: !1,
+      expects: null,
+      requirement: fe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "BIC", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ze(r) {
+    return {
+      kind: "transformation",
+      type: "brand",
+      reference: ze,
+      async: !1,
+      name: r,
+      "~run"(n) {
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Te(r, n) {
+    return {
+      kind: "validation",
+      type: "bytes",
+      reference: Te,
+      async: !1,
+      expects: `${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ R(e.value);
+          s !== this.requirement && f(this, "bytes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Fe(r, n) {
+    return {
+      kind: "validation",
+      type: "check",
+      reference: Fe,
+      async: !1,
+      expects: null,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !this.requirement(e.value) && f(this, "input", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $e(r, n) {
+    return {
+      kind: "validation",
+      type: "check",
+      reference: $e,
+      async: !0,
+      expects: null,
+      requirement: r,
+      message: n,
+      async "~run"(e, i) {
+        return e.typed && !await this.requirement(e.value) && f(this, "input", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ve(r, n) {
+    return {
+      kind: "validation",
+      type: "check_items",
+      reference: Ve,
+      async: !1,
+      expects: null,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) for (let s = 0; s < e.value.length; s++) {
+          const u = e.value[s];
+          this.requirement(u, s, e.value) || f(this, "item", e, i, {
+            input: u,
+            path: [{
+              type: "array",
+              origin: "value",
+              input: e.value,
+              key: s,
+              value: u
+            }]
+          });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Le(r, n) {
+    return {
+      kind: "validation",
+      type: "check_items",
+      reference: Le,
+      async: !0,
+      expects: null,
+      requirement: r,
+      message: n,
+      async "~run"(e, i) {
+        if (e.typed) {
+          const s = await Promise.all(e.value.map(this.requirement));
+          for (let u = 0; u < e.value.length; u++) if (!s[u]) {
+            const l = e.value[u];
+            f(this, "item", e, i, {
+              input: l,
+              path: [{
+                type: "array",
+                origin: "value",
+                input: e.value,
+                key: u,
+                value: l
+              }]
+            });
+          }
+        }
+        return e;
+      }
+    };
+  }
+  const Es = /^(?:\d{14,19}|\d{4}(?: \d{3,6}){2,4}|\d{4}(?:-\d{3,6}){2,4})$/u, xs = /[- ]/gu, _s = [
+    /^3[47]\d{13}$/u,
+    /^3(?:0[0-5]|[68]\d)\d{11,13}$/u,
+    /^6(?:011|5\d{2})\d{12,15}$/u,
+    /^(?:2131|1800|35\d{3})\d{11}$/u,
+    /^5[1-5]\d{2}|(?:222\d|22[3-9]\d|2[3-6]\d{2}|27[01]\d|2720)\d{12}$/u,
+    /^(?:6[27]\d{14,17}|81\d{14,17})$/u,
+    /^4\d{12}(?:\d{3,6})?$/u
+  ];
+  // @__NO_SIDE_EFFECTS__
+  function Je(r) {
+    return {
+      kind: "validation",
+      type: "credit_card",
+      reference: Je,
+      async: !1,
+      expects: null,
+      requirement(n) {
+        let e;
+        return Es.test(n) && (e = n.replace(xs, "")) && _s.some((i) => i.test(e)) && /* @__PURE__ */ F(e);
+      },
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement(n.value) && f(this, "credit card", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function We(r) {
+    return {
+      kind: "validation",
+      type: "cuid2",
+      reference: We,
+      async: !1,
+      expects: null,
+      requirement: pe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "Cuid2", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Be(r) {
+    return {
+      kind: "validation",
+      type: "decimal",
+      reference: Be,
+      async: !1,
+      expects: null,
+      requirement: ae,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "decimal", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ue(r) {
+    return {
+      kind: "metadata",
+      type: "description",
+      reference: Ue,
+      description: r
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ze(r) {
+    return {
+      kind: "validation",
+      type: "digits",
+      reference: Ze,
+      async: !1,
+      expects: null,
+      requirement: ye,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "digits", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ke(r) {
+    return {
+      kind: "validation",
+      type: "email",
+      reference: Ke,
+      expects: null,
+      async: !1,
+      requirement: he,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "email", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function He(r) {
+    return {
+      kind: "validation",
+      type: "emoji",
+      reference: He,
+      async: !1,
+      expects: null,
+      requirement: ve,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "emoji", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Qe(r) {
+    return {
+      kind: "validation",
+      type: "empty",
+      reference: Qe,
+      async: !1,
+      expects: "0",
+      message: r,
+      "~run"(n, e) {
+        return n.typed && n.value.length > 0 && f(this, "length", n, e, { received: `${n.value.length}` }), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ye(r, n) {
+    return {
+      kind: "validation",
+      type: "ends_with",
+      reference: Ye,
+      async: !1,
+      expects: `"${r}"`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !e.value.endsWith(this.requirement) && f(this, "end", e, i, { received: `"${e.value.slice(-this.requirement.length)}"` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function en(r, n) {
+    return {
+      kind: "validation",
+      type: "entries",
+      reference: en,
+      async: !1,
+      expects: `${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (!e.typed) return e;
+        const s = Object.keys(e.value).length;
+        return e.typed && s !== this.requirement && f(this, "entries", e, i, { received: `${s}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function nn(r, n) {
+    return {
+      kind: "validation",
+      type: "every_item",
+      reference: nn,
+      async: !1,
+      expects: null,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !e.value.every(this.requirement) && f(this, "item", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function rn(r) {
+    return {
+      kind: "metadata",
+      type: "examples",
+      reference: rn,
+      examples: r
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function sn(r, n) {
+    const e = /* @__PURE__ */ m(r);
+    return {
+      kind: "validation",
+      type: "excludes",
+      reference: sn,
+      async: !1,
+      expects: `!${e}`,
+      requirement: r,
+      message: n,
+      "~run"(i, s) {
+        return i.typed && i.value.includes(this.requirement) && f(this, "content", i, s, { received: e }), i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function tn(r) {
+    return {
+      kind: "transformation",
+      type: "filter_items",
+      reference: tn,
+      async: !1,
+      operation: r,
+      "~run"(n) {
+        return n.value = n.value.filter(this.operation), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function un(r) {
+    return {
+      kind: "transformation",
+      type: "find_item",
+      reference: un,
+      async: !1,
+      operation: r,
+      "~run"(n) {
+        return n.value = n.value.find(this.operation), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ln(r) {
+    return {
+      kind: "validation",
+      type: "finite",
+      reference: ln,
+      async: !1,
+      expects: null,
+      requirement: Number.isFinite,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement(n.value) && f(this, "finite", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function on(r) {
+    return {
+      kind: "transformation",
+      type: "flavor",
+      reference: on,
+      async: !1,
+      name: r,
+      "~run"(n) {
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function cn(r, n) {
+    return {
+      kind: "validation",
+      type: "graphemes",
+      reference: cn,
+      async: !1,
+      expects: `${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ q(e.value);
+          s !== this.requirement && f(this, "graphemes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function fn(r, n) {
+    return {
+      kind: "validation",
+      type: "gt_value",
+      reference: fn,
+      async: !1,
+      expects: `>${r instanceof Date ? r.toJSON() : /* @__PURE__ */ m(r)}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !(e.value > this.requirement) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  const As = {
+    md4: 32,
+    md5: 32,
+    sha1: 40,
+    sha256: 64,
+    sha384: 96,
+    sha512: 128,
+    ripemd128: 32,
+    ripemd160: 40,
+    tiger128: 32,
+    tiger160: 40,
+    tiger192: 48,
+    crc32: 8,
+    crc32b: 8,
+    adler32: 8
+  };
+  // @__NO_SIDE_EFFECTS__
+  function pn(r, n) {
+    return {
+      kind: "validation",
+      type: "hash",
+      reference: pn,
+      expects: null,
+      async: !1,
+      requirement: RegExp(r.map((e) => `^[a-f0-9]{${As[e]}}$`).join("|"), "iu"),
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !this.requirement.test(e.value) && f(this, "hash", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function an(r) {
+    return {
+      kind: "validation",
+      type: "hexadecimal",
+      reference: an,
+      async: !1,
+      expects: null,
+      requirement: me,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "hexadecimal", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function yn(r) {
+    return {
+      kind: "validation",
+      type: "hex_color",
+      reference: yn,
+      async: !1,
+      expects: null,
+      requirement: ge,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "hex color", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function hn(r) {
+    return {
+      kind: "validation",
+      type: "imei",
+      reference: hn,
+      async: !1,
+      expects: null,
+      requirement(n) {
+        return de.test(n) && /* @__PURE__ */ F(n);
+      },
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement(n.value) && f(this, "IMEI", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function vn(r, n) {
+    const e = /* @__PURE__ */ m(r);
+    return {
+      kind: "validation",
+      type: "includes",
+      reference: vn,
+      async: !1,
+      expects: e,
+      requirement: r,
+      message: n,
+      "~run"(i, s) {
+        return i.typed && !i.value.includes(this.requirement) && f(this, "content", i, s, { received: `!${e}` }), i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function mn(r) {
+    return {
+      kind: "validation",
+      type: "integer",
+      reference: mn,
+      async: !1,
+      expects: null,
+      requirement: Number.isInteger,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement(n.value) && f(this, "integer", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function gn(r) {
+    return {
+      kind: "validation",
+      type: "ip",
+      reference: gn,
+      async: !1,
+      expects: null,
+      requirement: Ee,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "IP", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function dn(r) {
+    return {
+      kind: "validation",
+      type: "ipv4",
+      reference: dn,
+      async: !1,
+      expects: null,
+      requirement: ke,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "IPv4", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function kn(r) {
+    return {
+      kind: "validation",
+      type: "ipv6",
+      reference: kn,
+      async: !1,
+      expects: null,
+      requirement: be,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "IPv6", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function bn(r) {
+    return {
+      kind: "validation",
+      type: "iso_date",
+      reference: bn,
+      async: !1,
+      expects: null,
+      requirement: xe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "date", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function En(r) {
+    return {
+      kind: "validation",
+      type: "iso_date_time",
+      reference: En,
+      async: !1,
+      expects: null,
+      requirement: _e,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "date-time", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function xn(r) {
+    return {
+      kind: "validation",
+      type: "iso_time",
+      reference: xn,
+      async: !1,
+      expects: null,
+      requirement: Ae,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "time", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _n(r) {
+    return {
+      kind: "validation",
+      type: "iso_time_second",
+      reference: _n,
+      async: !1,
+      expects: null,
+      requirement: we,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "time-second", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function An(r) {
+    return {
+      kind: "validation",
+      type: "iso_timestamp",
+      reference: An,
+      async: !1,
+      expects: null,
+      requirement: Ie,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "timestamp", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function wn(r) {
+    return {
+      kind: "validation",
+      type: "iso_week",
+      reference: wn,
+      async: !1,
+      expects: null,
+      requirement: De,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "week", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function In(r, n) {
+    return {
+      kind: "validation",
+      type: "length",
+      reference: In,
+      async: !1,
+      expects: `${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.length !== this.requirement && f(this, "length", e, i, { received: `${e.value.length}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Dn(r, n) {
+    return {
+      kind: "validation",
+      type: "lt_value",
+      reference: Dn,
+      async: !1,
+      expects: `<${r instanceof Date ? r.toJSON() : /* @__PURE__ */ m(r)}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !(e.value < this.requirement) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function jn(r) {
+    return {
+      kind: "validation",
+      type: "mac",
+      reference: jn,
+      async: !1,
+      expects: null,
+      requirement: Ge,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "MAC", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function On(r) {
+    return {
+      kind: "validation",
+      type: "mac48",
+      reference: On,
+      async: !1,
+      expects: null,
+      requirement: je,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "48-bit MAC", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Gn(r) {
+    return {
+      kind: "validation",
+      type: "mac64",
+      reference: Gn,
+      async: !1,
+      expects: null,
+      requirement: Oe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "64-bit MAC", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Rn(r) {
+    return {
+      kind: "transformation",
+      type: "map_items",
+      reference: Rn,
+      async: !1,
+      operation: r,
+      "~run"(n) {
+        return n.value = n.value.map(this.operation), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function qn(r, n) {
+    return {
+      kind: "validation",
+      type: "max_bytes",
+      reference: qn,
+      async: !1,
+      expects: `<=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ R(e.value);
+          s > this.requirement && f(this, "bytes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Mn(r, n) {
+    return {
+      kind: "validation",
+      type: "max_entries",
+      reference: Mn,
+      async: !1,
+      expects: `<=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (!e.typed) return e;
+        const s = Object.keys(e.value).length;
+        return e.typed && s > this.requirement && f(this, "entries", e, i, { received: `${s}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Sn(r, n) {
+    return {
+      kind: "validation",
+      type: "max_graphemes",
+      reference: Sn,
+      async: !1,
+      expects: `<=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ q(e.value);
+          s > this.requirement && f(this, "graphemes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Pn(r, n) {
+    return {
+      kind: "validation",
+      type: "max_length",
+      reference: Pn,
+      async: !1,
+      expects: `<=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.length > this.requirement && f(this, "length", e, i, { received: `${e.value.length}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Xn(r, n) {
+    return {
+      kind: "validation",
+      type: "max_size",
+      reference: Xn,
+      async: !1,
+      expects: `<=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.size > this.requirement && f(this, "size", e, i, { received: `${e.value.size}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Nn(r, n) {
+    return {
+      kind: "validation",
+      type: "max_value",
+      reference: Nn,
+      async: !1,
+      expects: `<=${r instanceof Date ? r.toJSON() : /* @__PURE__ */ m(r)}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !(e.value <= this.requirement) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Cn(r, n, e) {
+    return {
+      kind: "validation",
+      type: "max_words",
+      reference: Cn,
+      async: !1,
+      expects: `<=${n}`,
+      locales: r,
+      requirement: n,
+      message: e,
+      "~run"(i, s) {
+        if (i.typed) {
+          const u = /* @__PURE__ */ S(this.locales, i.value);
+          u > this.requirement && f(this, "words", i, s, { received: `${u}` });
+        }
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function zn(r) {
+    return {
+      kind: "metadata",
+      type: "metadata",
+      reference: zn,
+      metadata: r
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Tn(r, n) {
+    return {
+      kind: "validation",
+      type: "mime_type",
+      reference: Tn,
+      async: !1,
+      expects: /* @__PURE__ */ E(r.map((e) => `"${e}"`), "|"),
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !this.requirement.includes(e.value.type) && f(this, "MIME type", e, i, { received: `"${e.value.type}"` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Fn(r, n) {
+    return {
+      kind: "validation",
+      type: "min_bytes",
+      reference: Fn,
+      async: !1,
+      expects: `>=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ R(e.value);
+          s < this.requirement && f(this, "bytes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $n(r, n) {
+    return {
+      kind: "validation",
+      type: "min_entries",
+      reference: $n,
+      async: !1,
+      expects: `>=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (!e.typed) return e;
+        const s = Object.keys(e.value).length;
+        return e.typed && s < this.requirement && f(this, "entries", e, i, { received: `${s}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Vn(r, n) {
+    return {
+      kind: "validation",
+      type: "min_graphemes",
+      reference: Vn,
+      async: !1,
+      expects: `>=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ q(e.value);
+          s < this.requirement && f(this, "graphemes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ln(r, n) {
+    return {
+      kind: "validation",
+      type: "min_length",
+      reference: Ln,
+      async: !1,
+      expects: `>=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.length < this.requirement && f(this, "length", e, i, { received: `${e.value.length}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Jn(r, n) {
+    return {
+      kind: "validation",
+      type: "min_size",
+      reference: Jn,
+      async: !1,
+      expects: `>=${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.size < this.requirement && f(this, "size", e, i, { received: `${e.value.size}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Wn(r, n) {
+    return {
+      kind: "validation",
+      type: "min_value",
+      reference: Wn,
+      async: !1,
+      expects: `>=${r instanceof Date ? r.toJSON() : /* @__PURE__ */ m(r)}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !(e.value >= this.requirement) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Bn(r, n, e) {
+    return {
+      kind: "validation",
+      type: "min_words",
+      reference: Bn,
+      async: !1,
+      expects: `>=${n}`,
+      locales: r,
+      requirement: n,
+      message: e,
+      "~run"(i, s) {
+        if (i.typed) {
+          const u = /* @__PURE__ */ S(this.locales, i.value);
+          u < this.requirement && f(this, "words", i, s, { received: `${u}` });
+        }
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Un(r, n) {
+    return {
+      kind: "validation",
+      type: "multiple_of",
+      reference: Un,
+      async: !1,
+      expects: `%${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value % this.requirement != 0 && f(this, "multiple", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Zn(r) {
+    return {
+      kind: "validation",
+      type: "nanoid",
+      reference: Zn,
+      async: !1,
+      expects: null,
+      requirement: Re,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "Nano ID", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Kn(r) {
+    return {
+      kind: "validation",
+      type: "non_empty",
+      reference: Kn,
+      async: !1,
+      expects: "!0",
+      message: r,
+      "~run"(n, e) {
+        return n.typed && n.value.length === 0 && f(this, "length", n, e, { received: "0" }), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Hn(r) {
+    return {
+      kind: "transformation",
+      type: "normalize",
+      reference: Hn,
+      async: !1,
+      form: r,
+      "~run"(n) {
+        return n.value = n.value.normalize(this.form), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Qn(r, n) {
+    return {
+      kind: "validation",
+      type: "not_bytes",
+      reference: Qn,
+      async: !1,
+      expects: `!${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ R(e.value);
+          s === this.requirement && f(this, "bytes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Yn(r, n) {
+    return {
+      kind: "validation",
+      type: "not_entries",
+      reference: Yn,
+      async: !1,
+      expects: `!${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (!e.typed) return e;
+        const s = Object.keys(e.value).length;
+        return e.typed && s === this.requirement && f(this, "entries", e, i, { received: `${s}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function er(r, n) {
+    return {
+      kind: "validation",
+      type: "not_graphemes",
+      reference: er,
+      async: !1,
+      expects: `!${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        if (e.typed) {
+          const s = /* @__PURE__ */ q(e.value);
+          s === this.requirement && f(this, "graphemes", e, i, { received: `${s}` });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function nr(r, n) {
+    return {
+      kind: "validation",
+      type: "not_length",
+      reference: nr,
+      async: !1,
+      expects: `!${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.length === this.requirement && f(this, "length", e, i, { received: `${e.value.length}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function rr(r, n) {
+    return {
+      kind: "validation",
+      type: "not_size",
+      reference: rr,
+      async: !1,
+      expects: `!${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.size === this.requirement && f(this, "size", e, i, { received: `${e.value.size}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ir(r, n) {
+    return {
+      kind: "validation",
+      type: "not_value",
+      reference: ir,
+      async: !1,
+      expects: r instanceof Date ? `!${r.toJSON()}` : `!${/* @__PURE__ */ m(r)}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && this.requirement <= e.value && this.requirement >= e.value && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function sr(r, n) {
+    return {
+      kind: "validation",
+      type: "not_values",
+      reference: sr,
+      async: !1,
+      expects: `!${/* @__PURE__ */ E(r.map((e) => e instanceof Date ? e.toJSON() : /* @__PURE__ */ m(e)), "|")}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && this.requirement.some((s) => s <= e.value && s >= e.value) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function tr(r, n, e) {
+    return {
+      kind: "validation",
+      type: "not_words",
+      reference: tr,
+      async: !1,
+      expects: `!${n}`,
+      locales: r,
+      requirement: n,
+      message: e,
+      "~run"(i, s) {
+        if (i.typed) {
+          const u = /* @__PURE__ */ S(this.locales, i.value);
+          u === this.requirement && f(this, "words", i, s, { received: `${u}` });
+        }
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ur(r) {
+    return {
+      kind: "validation",
+      type: "octal",
+      reference: ur,
+      async: !1,
+      expects: null,
+      requirement: qe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "octal", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function lr(r, n) {
+    return {
+      kind: "transformation",
+      type: "parse_json",
+      reference: lr,
+      config: r,
+      message: n,
+      async: !1,
+      "~run"(e, i) {
+        try {
+          e.value = JSON.parse(e.value, this.config?.reviver);
+        } catch (s) {
+          if (s instanceof Error)
+            f(this, "JSON", e, i, { received: `"${s.message}"` }), e.typed = !1;
+          else throw s;
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function or(r, n) {
+    if (r.issues) for (const e of n) for (const i of r.issues) {
+      let s = !1;
+      const u = Math.min(e.length, i.path?.length ?? 0);
+      for (let l = 0; l < u; l++) if (e[l] !== i.path[l].key && (e[l] !== "$" || i.path[l].type !== "array")) {
+        s = !0;
+        break;
+      }
+      if (!s) return !1;
+    }
+    return !0;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function cr(r, n, e) {
+    return {
+      kind: "validation",
+      type: "partial_check",
+      reference: cr,
+      async: !1,
+      expects: null,
+      paths: r,
+      requirement: n,
+      message: e,
+      "~run"(i, s) {
+        return (i.typed || /* @__PURE__ */ or(i, r)) && !this.requirement(i.value) && f(this, "input", i, s), i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function fr(r, n, e) {
+    return {
+      kind: "validation",
+      type: "partial_check",
+      reference: fr,
+      async: !0,
+      expects: null,
+      paths: r,
+      requirement: n,
+      message: e,
+      async "~run"(i, s) {
+        return (i.typed || /* @__PURE__ */ or(i, r)) && !await this.requirement(i.value) && f(this, "input", i, s), i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function pr(r) {
+    return {
+      kind: "validation",
+      type: "raw_check",
+      reference: pr,
+      async: !1,
+      expects: null,
+      "~run"(n, e) {
+        return r({
+          dataset: n,
+          config: e,
+          addIssue: (i) => f(this, i?.label ?? "input", n, e, i)
+        }), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ar(r) {
+    return {
+      kind: "validation",
+      type: "raw_check",
+      reference: ar,
+      async: !0,
+      expects: null,
+      async "~run"(n, e) {
+        return await r({
+          dataset: n,
+          config: e,
+          addIssue: (i) => f(this, i?.label ?? "input", n, e, i)
+        }), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function yr(r) {
+    return {
+      kind: "transformation",
+      type: "raw_transform",
+      reference: yr,
+      async: !1,
+      "~run"(n, e) {
+        const i = r({
+          dataset: n,
+          config: e,
+          addIssue: (s) => f(this, s?.label ?? "input", n, e, s),
+          NEVER: null
+        });
+        return n.issues ? n.typed = !1 : n.value = i, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function hr(r) {
+    return {
+      kind: "transformation",
+      type: "raw_transform",
+      reference: hr,
+      async: !0,
+      async "~run"(n, e) {
+        const i = await r({
+          dataset: n,
+          config: e,
+          addIssue: (s) => f(this, s?.label ?? "input", n, e, s),
+          NEVER: null
+        });
+        return n.issues ? n.typed = !1 : n.value = i, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function vr() {
+    return {
+      kind: "transformation",
+      type: "readonly",
+      reference: vr,
+      async: !1,
+      "~run"(r) {
+        return r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function mr(r, n) {
+    return {
+      kind: "transformation",
+      type: "reduce_items",
+      reference: mr,
+      async: !1,
+      operation: r,
+      initial: n,
+      "~run"(e) {
+        return e.value = e.value.reduce(this.operation, this.initial), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function gr(r, n) {
+    return {
+      kind: "validation",
+      type: "regex",
+      reference: gr,
+      async: !1,
+      expects: `${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !this.requirement.test(e.value) && f(this, "format", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function dr(r) {
+    return {
+      kind: "transformation",
+      type: "returns",
+      reference: dr,
+      async: !1,
+      schema: r,
+      "~run"(n, e) {
+        const i = n.value;
+        return n.value = (...s) => {
+          const u = this.schema["~run"]({ value: i(...s) }, e);
+          if (u.issues) throw new x(u.issues);
+          return u.value;
+        }, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function kr(r) {
+    return {
+      kind: "transformation",
+      type: "returns",
+      reference: kr,
+      async: !1,
+      schema: r,
+      "~run"(n, e) {
+        const i = n.value;
+        return n.value = async (...s) => {
+          const u = await this.schema["~run"]({ value: await i(...s) }, e);
+          if (u.issues) throw new x(u.issues);
+          return u.value;
+        }, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function br(r) {
+    return {
+      kind: "validation",
+      type: "rfc_email",
+      reference: br,
+      expects: null,
+      async: !1,
+      requirement: Me,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "email", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Er(r) {
+    return {
+      kind: "validation",
+      type: "safe_integer",
+      reference: Er,
+      async: !1,
+      expects: null,
+      requirement: Number.isSafeInteger,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement(n.value) && f(this, "safe integer", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function xr(r, n) {
+    return {
+      kind: "validation",
+      type: "size",
+      reference: xr,
+      async: !1,
+      expects: `${r}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && e.value.size !== this.requirement && f(this, "size", e, i, { received: `${e.value.size}` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _r(r) {
+    return {
+      kind: "validation",
+      type: "slug",
+      reference: _r,
+      async: !1,
+      expects: null,
+      requirement: Se,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "slug", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ar(r, n) {
+    return {
+      kind: "validation",
+      type: "some_item",
+      reference: Ar,
+      async: !1,
+      expects: null,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !e.value.some(this.requirement) && f(this, "item", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function wr(r) {
+    return {
+      kind: "transformation",
+      type: "sort_items",
+      reference: wr,
+      async: !1,
+      operation: r,
+      "~run"(n) {
+        return n.value = n.value.sort(this.operation), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ir(r, n) {
+    return {
+      kind: "validation",
+      type: "starts_with",
+      reference: Ir,
+      async: !1,
+      expects: `"${r}"`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !e.value.startsWith(this.requirement) && f(this, "start", e, i, { received: `"${e.value.slice(0, this.requirement.length)}"` }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Dr(r, n) {
+    return {
+      kind: "transformation",
+      type: "stringify_json",
+      reference: Dr,
+      message: n,
+      config: r,
+      async: !1,
+      "~run"(e, i) {
+        try {
+          const s = JSON.stringify(e.value, this.config?.replacer, this.config?.space);
+          s === void 0 && (f(this, "JSON", e, i), e.typed = !1), e.value = s;
+        } catch (s) {
+          if (s instanceof Error)
+            f(this, "JSON", e, i, { received: `"${s.message}"` }), e.typed = !1;
+          else throw s;
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function jr(r) {
+    return {
+      kind: "metadata",
+      type: "title",
+      reference: jr,
+      title: r
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Or(r) {
+    return {
+      kind: "transformation",
+      type: "to_bigint",
+      reference: Or,
+      async: !1,
+      message: r,
+      "~run"(n, e) {
+        try {
+          n.value = BigInt(n.value);
+        } catch {
+          f(this, "bigint", n, e), n.typed = !1;
+        }
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Gr() {
+    return {
+      kind: "transformation",
+      type: "to_boolean",
+      reference: Gr,
+      async: !1,
+      "~run"(r) {
+        return r.value = !!r.value, r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Rr(r) {
+    return {
+      kind: "transformation",
+      type: "to_date",
+      reference: Rr,
+      async: !1,
+      message: r,
+      "~run"(n, e) {
+        try {
+          n.value = new Date(n.value), isNaN(n.value) && (f(this, "date", n, e, { received: '"Invalid Date"' }), n.typed = !1);
+        } catch {
+          f(this, "date", n, e), n.typed = !1;
+        }
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function qr() {
+    return {
+      kind: "transformation",
+      type: "to_lower_case",
+      reference: qr,
+      async: !1,
+      "~run"(r) {
+        return r.value = r.value.toLowerCase(), r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Mr(r) {
+    return {
+      kind: "transformation",
+      type: "to_max_value",
+      reference: Mr,
+      async: !1,
+      requirement: r,
+      "~run"(n) {
+        return n.value = n.value > this.requirement ? this.requirement : n.value, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Sr(r) {
+    return {
+      kind: "transformation",
+      type: "to_min_value",
+      reference: Sr,
+      async: !1,
+      requirement: r,
+      "~run"(n) {
+        return n.value = n.value < this.requirement ? this.requirement : n.value, n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Pr(r) {
+    return {
+      kind: "transformation",
+      type: "to_number",
+      reference: Pr,
+      async: !1,
+      message: r,
+      "~run"(n, e) {
+        try {
+          n.value = Number(n.value), isNaN(n.value) && (f(this, "number", n, e), n.typed = !1);
+        } catch {
+          f(this, "number", n, e), n.typed = !1;
+        }
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Xr(r) {
+    return {
+      kind: "transformation",
+      type: "to_string",
+      reference: Xr,
+      async: !1,
+      message: r,
+      "~run"(n, e) {
+        try {
+          n.value = String(n.value);
+        } catch {
+          f(this, "string", n, e), n.typed = !1;
+        }
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Nr() {
+    return {
+      kind: "transformation",
+      type: "to_upper_case",
+      reference: Nr,
+      async: !1,
+      "~run"(r) {
+        return r.value = r.value.toUpperCase(), r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Cr(r) {
+    return {
+      kind: "transformation",
+      type: "transform",
+      reference: Cr,
+      async: !1,
+      operation: r,
+      "~run"(n) {
+        return n.value = this.operation(n.value), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function zr(r) {
+    return {
+      kind: "transformation",
+      type: "transform",
+      reference: zr,
+      async: !0,
+      operation: r,
+      async "~run"(n) {
+        return n.value = await this.operation(n.value), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Tr() {
+    return {
+      kind: "transformation",
+      type: "trim",
+      reference: Tr,
+      async: !1,
+      "~run"(r) {
+        return r.value = r.value.trim(), r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Fr() {
+    return {
+      kind: "transformation",
+      type: "trim_end",
+      reference: Fr,
+      async: !1,
+      "~run"(r) {
+        return r.value = r.value.trimEnd(), r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $r() {
+    return {
+      kind: "transformation",
+      type: "trim_start",
+      reference: $r,
+      async: !1,
+      "~run"(r) {
+        return r.value = r.value.trimStart(), r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Vr(r) {
+    return {
+      kind: "validation",
+      type: "ulid",
+      reference: Vr,
+      async: !1,
+      expects: null,
+      requirement: Pe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "ULID", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Lr(r) {
+    return {
+      kind: "validation",
+      type: "url",
+      reference: Lr,
+      async: !1,
+      expects: null,
+      requirement(n) {
+        try {
+          return new URL(n), !0;
+        } catch {
+          return !1;
+        }
+      },
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement(n.value) && f(this, "URL", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Jr(r) {
+    return {
+      kind: "validation",
+      type: "uuid",
+      reference: Jr,
+      async: !1,
+      expects: null,
+      requirement: Xe,
+      message: r,
+      "~run"(n, e) {
+        return n.typed && !this.requirement.test(n.value) && f(this, "UUID", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Wr(r, n) {
+    return {
+      kind: "validation",
+      type: "value",
+      reference: Wr,
+      async: !1,
+      expects: r instanceof Date ? r.toJSON() : /* @__PURE__ */ m(r),
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !(this.requirement <= e.value && this.requirement >= e.value) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Br(r, n) {
+    return {
+      kind: "validation",
+      type: "values",
+      reference: Br,
+      async: !1,
+      expects: `${/* @__PURE__ */ E(r.map((e) => e instanceof Date ? e.toJSON() : /* @__PURE__ */ m(e)), "|")}`,
+      requirement: r,
+      message: n,
+      "~run"(e, i) {
+        return e.typed && !this.requirement.some((s) => s <= e.value && s >= e.value) && f(this, "value", e, i, { received: e.value instanceof Date ? e.value.toJSON() : /* @__PURE__ */ m(e.value) }), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ur(r, n, e) {
+    return {
+      kind: "validation",
+      type: "words",
+      reference: Ur,
+      async: !1,
+      expects: `${n}`,
+      locales: r,
+      requirement: n,
+      message: e,
+      "~run"(i, s) {
+        if (i.typed) {
+          const u = /* @__PURE__ */ S(this.locales, i.value);
+          u !== this.requirement && f(this, "words", i, s, { received: `${u}` });
+        }
+        return i;
+      }
+    };
+  }
+  function ws(r, n) {
+    const e = r["~run"]({ value: n }, { abortEarly: !0 }).issues;
+    if (e) throw new x(e);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Is(r, n) {
+    return {
+      ...r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return r["~run"](e, {
+          ...i,
+          ...n
+        });
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function b(r, n, e) {
+    return typeof r.fallback == "function" ? r.fallback(n, e) : r.fallback;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ds(r, n) {
+    return {
+      ...r,
+      fallback: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = r["~run"](e, i);
+        return s.issues ? {
+          typed: !0,
+          value: /* @__PURE__ */ b(this, s, i)
+        } : s;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function js(r, n) {
+    return {
+      ...r,
+      fallback: n,
+      async: !0,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = await r["~run"](e, i);
+        return s.issues ? {
+          typed: !0,
+          value: await /* @__PURE__ */ b(this, s, i)
+        } : s;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Os(r) {
+    const n = {};
+    for (const e of r) if (e.path) {
+      const i = /* @__PURE__ */ $(e);
+      i ? (n.nested || (n.nested = {}), n.nested[i] ? n.nested[i].push(e.message) : n.nested[i] = [e.message]) : n.other ? n.other.push(e.message) : n.other = [e.message];
+    } else n.root ? n.root.push(e.message) : n.root = [e.message];
+    return n;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Gs(r, n) {
+    return {
+      ...r,
+      "~run"(e, i) {
+        const s = e.issues && [...e.issues];
+        if (e = r["~run"](e, i), e.issues) {
+          for (const u of e.issues) if (!s?.includes(u)) {
+            let l = e.value;
+            for (const c of n) {
+              const o = l[c], p = {
+                type: "unknown",
+                origin: "value",
+                input: l,
+                key: c,
+                value: o
+              };
+              if (u.path ? u.path.push(p) : u.path = [p], !o) break;
+              l = o;
+            }
+          }
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Rs(r, n) {
+    return {
+      ...r,
+      async: !0,
+      async "~run"(e, i) {
+        const s = e.issues && [...e.issues];
+        if (e = await r["~run"](e, i), e.issues) {
+          for (const u of e.issues) if (!s?.includes(u)) {
+            let l = e.value;
+            for (const c of n) {
+              const o = l[c], p = {
+                type: "unknown",
+                origin: "value",
+                input: l,
+                key: c,
+                value: o
+              };
+              if (u.path ? u.path.push(p) : u.path = [p], !o) break;
+              l = o;
+            }
+          }
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function d(r, n, e) {
+    return typeof r.default == "function" ? r.default(n, e) : r.default;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function V(r) {
+    if ("entries" in r) {
+      const n = {};
+      for (const e in r.entries) n[e] = /* @__PURE__ */ V(r.entries[e]);
+      return n;
+    }
+    return "items" in r ? r.items.map(V) : /* @__PURE__ */ d(r);
+  }
+  // @__NO_SIDE_EFFECTS__
+  async function L(r) {
+    return "entries" in r ? Object.fromEntries(await Promise.all(Object.entries(r.entries).map(async ([n, e]) => [n, await /* @__PURE__ */ L(e)]))) : "items" in r ? Promise.all(r.items.map(L)) : /* @__PURE__ */ d(r);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function qs(r) {
+    return /* @__PURE__ */ X(r, "description");
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ms(r) {
+    const n = [];
+    function e(i) {
+      if ("pipe" in i)
+        for (const s of i.pipe) s.kind === "schema" && "pipe" in s ? e(s) : s.kind === "metadata" && s.type === "examples" && n.push(...s.examples);
+    }
+    return e(r), n;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function J(r) {
+    if ("entries" in r) {
+      const n = {};
+      for (const e in r.entries) n[e] = /* @__PURE__ */ J(r.entries[e]);
+      return n;
+    }
+    return "items" in r ? r.items.map(J) : /* @__PURE__ */ b(r);
+  }
+  // @__NO_SIDE_EFFECTS__
+  async function W(r) {
+    return "entries" in r ? Object.fromEntries(await Promise.all(Object.entries(r.entries).map(async ([n, e]) => [n, await /* @__PURE__ */ W(e)]))) : "items" in r ? Promise.all(r.items.map(W)) : /* @__PURE__ */ b(r);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ss(r) {
+    const n = {};
+    function e(i) {
+      if ("pipe" in i)
+        for (const s of i.pipe) s.kind === "schema" && "pipe" in s ? e(s) : s.kind === "metadata" && s.type === "metadata" && Object.assign(n, s.metadata);
+    }
+    return e(r), n;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ps(r) {
+    return /* @__PURE__ */ X(r, "title");
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Xs(r, n) {
+    return !r["~run"]({ value: n }, { abortEarly: !0 }).issues;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Zr() {
+    return {
+      kind: "schema",
+      type: "any",
+      reference: Zr,
+      expects: "any",
+      async: !1,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(r) {
+        return r.typed = !0, r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Kr(r, n) {
+    return {
+      kind: "schema",
+      type: "array",
+      reference: Kr,
+      expects: "Array",
+      async: !1,
+      item: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          for (let u = 0; u < s.length; u++) {
+            const l = s[u], c = this.item["~run"]({ value: l }, i);
+            if (c.issues) {
+              const o = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: u,
+                value: l
+              };
+              for (const p of c.issues)
+                p.path ? p.path.unshift(o) : p.path = [o], e.issues?.push(p);
+              if (e.issues || (e.issues = c.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            c.typed || (e.typed = !1), e.value.push(c.value);
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Hr(r, n) {
+    return {
+      kind: "schema",
+      type: "array",
+      reference: Hr,
+      expects: "Array",
+      async: !0,
+      item: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          const u = await Promise.all(s.map((l) => this.item["~run"]({ value: l }, i)));
+          for (let l = 0; l < u.length; l++) {
+            const c = u[l];
+            if (c.issues) {
+              const o = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: l,
+                value: s[l]
+              };
+              for (const p of c.issues)
+                p.path ? p.path.unshift(o) : p.path = [o], e.issues?.push(p);
+              if (e.issues || (e.issues = c.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            c.typed || (e.typed = !1), e.value.push(c.value);
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Qr(r) {
+    return {
+      kind: "schema",
+      type: "bigint",
+      reference: Qr,
+      expects: "bigint",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return typeof n.value == "bigint" ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Yr(r) {
+    return {
+      kind: "schema",
+      type: "blob",
+      reference: Yr,
+      expects: "Blob",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value instanceof Blob ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ei(r) {
+    return {
+      kind: "schema",
+      type: "boolean",
+      reference: ei,
+      expects: "boolean",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return typeof n.value == "boolean" ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ni(r, n) {
+    return {
+      kind: "schema",
+      type: "custom",
+      reference: ni,
+      expects: "unknown",
+      async: !1,
+      check: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return this.check(e.value) ? e.typed = !0 : f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ri(r, n) {
+    return {
+      kind: "schema",
+      type: "custom",
+      reference: ri,
+      expects: "unknown",
+      async: !0,
+      check: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return await this.check(e.value) ? e.typed = !0 : f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ii(r) {
+    return {
+      kind: "schema",
+      type: "date",
+      reference: ii,
+      expects: "Date",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value instanceof Date ? isNaN(n.value) ? f(this, "type", n, e, { received: '"Invalid Date"' }) : n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function B(r, n) {
+    const e = [];
+    for (const i in r) (`${+i}` !== i || typeof r[i] != "string" || !Object.is(r[r[i]], +i)) && e.push(r[i]);
+    return {
+      kind: "schema",
+      type: "enum",
+      reference: B,
+      expects: /* @__PURE__ */ E(e.map(m), "|"),
+      async: !1,
+      enum: r,
+      options: e,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(i, s) {
+        return this.options.includes(i.value) ? i.typed = !0 : f(this, "type", i, s), i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function si(r, n) {
+    return {
+      kind: "schema",
+      type: "exact_optional",
+      reference: si,
+      expects: r.expects,
+      async: !1,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ti(r, n) {
+    return {
+      kind: "schema",
+      type: "exact_optional",
+      reference: ti,
+      expects: r.expects,
+      async: !0,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ui(r) {
+    return {
+      kind: "schema",
+      type: "file",
+      reference: ui,
+      expects: "File",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value instanceof File ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function U(r) {
+    return {
+      kind: "schema",
+      type: "function",
+      reference: U,
+      expects: "Function",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return typeof n.value == "function" ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function li(r, n) {
+    return {
+      kind: "schema",
+      type: "instance",
+      reference: li,
+      expects: r.name,
+      async: !1,
+      class: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value instanceof this.class ? e.typed = !0 : f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function N(r, n) {
+    if (typeof r == typeof n) {
+      if (r === n || r instanceof Date && n instanceof Date && +r == +n) return { value: r };
+      if (r && n && r.constructor === Object && n.constructor === Object) {
+        for (const e in n) if (e in r) {
+          const i = /* @__PURE__ */ N(r[e], n[e]);
+          if (i.issue) return i;
+          r[e] = i.value;
+        } else r[e] = n[e];
+        return { value: r };
+      }
+      if (Array.isArray(r) && Array.isArray(n) && r.length === n.length) {
+        for (let e = 0; e < r.length; e++) {
+          const i = /* @__PURE__ */ N(r[e], n[e]);
+          if (i.issue) return i;
+          r[e] = i.value;
+        }
+        return { value: r };
+      }
+    }
+    return { issue: !0 };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function oi(r, n) {
+    return {
+      kind: "schema",
+      type: "intersect",
+      reference: oi,
+      expects: /* @__PURE__ */ E(r.map((e) => e.expects), "&"),
+      async: !1,
+      options: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        if (this.options.length) {
+          const s = e.value;
+          let u;
+          e.typed = !0;
+          for (const l of this.options) {
+            const c = l["~run"]({ value: s }, i);
+            if (c.issues && (e.issues ? e.issues.push(...c.issues) : e.issues = c.issues, i.abortEarly)) {
+              e.typed = !1;
+              break;
+            }
+            c.typed || (e.typed = !1), e.typed && (u ? u.push(c.value) : u = [c.value]);
+          }
+          if (e.typed) {
+            e.value = u[0];
+            for (let l = 1; l < u.length; l++) {
+              const c = /* @__PURE__ */ N(e.value, u[l]);
+              if (c.issue) {
+                f(this, "type", e, i, { received: "unknown" });
+                break;
+              }
+              e.value = c.value;
+            }
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ci(r, n) {
+    return {
+      kind: "schema",
+      type: "intersect",
+      reference: ci,
+      expects: /* @__PURE__ */ E(r.map((e) => e.expects), "&"),
+      async: !0,
+      options: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        if (this.options.length) {
+          const s = e.value;
+          let u;
+          e.typed = !0;
+          const l = await Promise.all(this.options.map((c) => c["~run"]({ value: s }, i)));
+          for (const c of l) {
+            if (c.issues && (e.issues ? e.issues.push(...c.issues) : e.issues = c.issues, i.abortEarly)) {
+              e.typed = !1;
+              break;
+            }
+            c.typed || (e.typed = !1), e.typed && (u ? u.push(c.value) : u = [c.value]);
+          }
+          if (e.typed) {
+            e.value = u[0];
+            for (let c = 1; c < u.length; c++) {
+              const o = /* @__PURE__ */ N(e.value, u[c]);
+              if (o.issue) {
+                f(this, "type", e, i, { received: "unknown" });
+                break;
+              }
+              e.value = o.value;
+            }
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function fi(r) {
+    return {
+      kind: "schema",
+      type: "lazy",
+      reference: fi,
+      expects: "unknown",
+      async: !1,
+      getter: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return this.getter(n.value)["~run"](n, e);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function pi(r) {
+    return {
+      kind: "schema",
+      type: "lazy",
+      reference: pi,
+      expects: "unknown",
+      async: !0,
+      getter: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(n, e) {
+        return (await this.getter(n.value))["~run"](n, e);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ai(r, n) {
+    return {
+      kind: "schema",
+      type: "literal",
+      reference: ai,
+      expects: /* @__PURE__ */ m(r),
+      async: !1,
+      literal: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value === this.literal ? e.typed = !0 : f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function yi(r, n) {
+    return {
+      kind: "schema",
+      type: "loose_object",
+      reference: yi,
+      expects: "Object",
+      async: !1,
+      entries: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (s && typeof s == "object") {
+          e.typed = !0, e.value = {};
+          for (const u in this.entries) {
+            const l = this.entries[u];
+            if (u in s || (l.type === "exact_optional" || l.type === "optional" || l.type === "nullish") && l.default !== void 0) {
+              const c = u in s ? s[u] : /* @__PURE__ */ d(l), o = l["~run"]({ value: c }, i);
+              if (o.issues) {
+                const p = {
+                  type: "object",
+                  origin: "value",
+                  input: s,
+                  key: u,
+                  value: c
+                };
+                for (const a of o.issues)
+                  a.path ? a.path.unshift(p) : a.path = [p], e.issues?.push(a);
+                if (e.issues || (e.issues = o.issues), i.abortEarly) {
+                  e.typed = !1;
+                  break;
+                }
+              }
+              o.typed || (e.typed = !1), e.value[u] = o.value;
+            } else if (l.fallback !== void 0) e.value[u] = /* @__PURE__ */ b(l);
+            else if (l.type !== "exact_optional" && l.type !== "optional" && l.type !== "nullish" && (f(this, "key", e, i, {
+              input: void 0,
+              expected: `"${u}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input: s,
+                key: u,
+                value: s[u]
+              }]
+            }), i.abortEarly))
+              break;
+          }
+          if (!e.issues || !i.abortEarly)
+            for (const u in s) /* @__PURE__ */ I(s, u) && !(u in this.entries) && (e.value[u] = s[u]);
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function hi(r, n) {
+    return {
+      kind: "schema",
+      type: "loose_object",
+      reference: hi,
+      expects: "Object",
+      async: !0,
+      entries: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (s && typeof s == "object") {
+          e.typed = !0, e.value = {};
+          const u = await Promise.all(Object.entries(this.entries).map(async ([l, c]) => {
+            if (l in s || (c.type === "exact_optional" || c.type === "optional" || c.type === "nullish") && c.default !== void 0) {
+              const o = l in s ? s[l] : await /* @__PURE__ */ d(c);
+              return [
+                l,
+                o,
+                c,
+                await c["~run"]({ value: o }, i)
+              ];
+            }
+            return [
+              l,
+              s[l],
+              c,
+              null
+            ];
+          }));
+          for (const [l, c, o, p] of u) if (p) {
+            if (p.issues) {
+              const a = {
+                type: "object",
+                origin: "value",
+                input: s,
+                key: l,
+                value: c
+              };
+              for (const h of p.issues)
+                h.path ? h.path.unshift(a) : h.path = [a], e.issues?.push(h);
+              if (e.issues || (e.issues = p.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            p.typed || (e.typed = !1), e.value[l] = p.value;
+          } else if (o.fallback !== void 0) e.value[l] = await /* @__PURE__ */ b(o);
+          else if (o.type !== "exact_optional" && o.type !== "optional" && o.type !== "nullish" && (f(this, "key", e, i, {
+            input: void 0,
+            expected: `"${l}"`,
+            path: [{
+              type: "object",
+              origin: "key",
+              input: s,
+              key: l,
+              value: c
+            }]
+          }), i.abortEarly))
+            break;
+          if (!e.issues || !i.abortEarly)
+            for (const l in s) /* @__PURE__ */ I(s, l) && !(l in this.entries) && (e.value[l] = s[l]);
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function vi(r, n) {
+    return {
+      kind: "schema",
+      type: "loose_tuple",
+      reference: vi,
+      expects: "Array",
+      async: !1,
+      items: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          for (let u = 0; u < this.items.length; u++) {
+            const l = s[u], c = this.items[u]["~run"]({ value: l }, i);
+            if (c.issues) {
+              const o = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: u,
+                value: l
+              };
+              for (const p of c.issues)
+                p.path ? p.path.unshift(o) : p.path = [o], e.issues?.push(p);
+              if (e.issues || (e.issues = c.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            c.typed || (e.typed = !1), e.value.push(c.value);
+          }
+          if (!e.issues || !i.abortEarly) for (let u = this.items.length; u < s.length; u++) e.value.push(s[u]);
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function mi(r, n) {
+    return {
+      kind: "schema",
+      type: "loose_tuple",
+      reference: mi,
+      expects: "Array",
+      async: !0,
+      items: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          const u = await Promise.all(this.items.map(async (l, c) => {
+            const o = s[c];
+            return [
+              c,
+              o,
+              await l["~run"]({ value: o }, i)
+            ];
+          }));
+          for (const [l, c, o] of u) {
+            if (o.issues) {
+              const p = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: l,
+                value: c
+              };
+              for (const a of o.issues)
+                a.path ? a.path.unshift(p) : a.path = [p], e.issues?.push(a);
+              if (e.issues || (e.issues = o.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            o.typed || (e.typed = !1), e.value.push(o.value);
+          }
+          if (!e.issues || !i.abortEarly) for (let l = this.items.length; l < s.length; l++) e.value.push(s[l]);
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function gi(r, n, e) {
+    return {
+      kind: "schema",
+      type: "map",
+      reference: gi,
+      expects: "Map",
+      async: !1,
+      key: r,
+      value: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(i, s) {
+        const u = i.value;
+        if (u instanceof Map) {
+          i.typed = !0, i.value = /* @__PURE__ */ new Map();
+          for (const [l, c] of u) {
+            const o = this.key["~run"]({ value: l }, s);
+            if (o.issues) {
+              const a = {
+                type: "map",
+                origin: "key",
+                input: u,
+                key: l,
+                value: c
+              };
+              for (const h of o.issues)
+                h.path ? h.path.unshift(a) : h.path = [a], i.issues?.push(h);
+              if (i.issues || (i.issues = o.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            const p = this.value["~run"]({ value: c }, s);
+            if (p.issues) {
+              const a = {
+                type: "map",
+                origin: "value",
+                input: u,
+                key: l,
+                value: c
+              };
+              for (const h of p.issues)
+                h.path ? h.path.unshift(a) : h.path = [a], i.issues?.push(h);
+              if (i.issues || (i.issues = p.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            (!o.typed || !p.typed) && (i.typed = !1), i.value.set(o.value, p.value);
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function di(r, n, e) {
+    return {
+      kind: "schema",
+      type: "map",
+      reference: di,
+      expects: "Map",
+      async: !0,
+      key: r,
+      value: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(i, s) {
+        const u = i.value;
+        if (u instanceof Map) {
+          i.typed = !0, i.value = /* @__PURE__ */ new Map();
+          const l = await Promise.all([...u].map(([c, o]) => Promise.all([
+            c,
+            o,
+            this.key["~run"]({ value: c }, s),
+            this.value["~run"]({ value: o }, s)
+          ])));
+          for (const [c, o, p, a] of l) {
+            if (p.issues) {
+              const h = {
+                type: "map",
+                origin: "key",
+                input: u,
+                key: c,
+                value: o
+              };
+              for (const v of p.issues)
+                v.path ? v.path.unshift(h) : v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = p.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            if (a.issues) {
+              const h = {
+                type: "map",
+                origin: "value",
+                input: u,
+                key: c,
+                value: o
+              };
+              for (const v of a.issues)
+                v.path ? v.path.unshift(h) : v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = a.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            (!p.typed || !a.typed) && (i.typed = !1), i.value.set(p.value, a.value);
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ki(r) {
+    return {
+      kind: "schema",
+      type: "nan",
+      reference: ki,
+      expects: "NaN",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return Number.isNaN(n.value) ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function bi(r) {
+    return {
+      kind: "schema",
+      type: "never",
+      reference: bi,
+      expects: "never",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ei(r, n) {
+    return {
+      kind: "schema",
+      type: "non_nullable",
+      reference: Ei,
+      expects: "!null",
+      async: !1,
+      wrapped: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value !== null && (e = this.wrapped["~run"](e, i)), e.value === null && f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function xi(r, n) {
+    return {
+      kind: "schema",
+      type: "non_nullable",
+      reference: xi,
+      expects: "!null",
+      async: !0,
+      wrapped: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return e.value !== null && (e = await this.wrapped["~run"](e, i)), e.value === null && f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _i(r, n) {
+    return {
+      kind: "schema",
+      type: "non_nullish",
+      reference: _i,
+      expects: "(!null & !undefined)",
+      async: !1,
+      wrapped: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value === null || e.value === void 0 || (e = this.wrapped["~run"](e, i)), (e.value === null || e.value === void 0) && f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ai(r, n) {
+    return {
+      kind: "schema",
+      type: "non_nullish",
+      reference: Ai,
+      expects: "(!null & !undefined)",
+      async: !0,
+      wrapped: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return e.value === null || e.value === void 0 || (e = await this.wrapped["~run"](e, i)), (e.value === null || e.value === void 0) && f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Z(r, n) {
+    return {
+      kind: "schema",
+      type: "non_optional",
+      reference: Z,
+      expects: "!undefined",
+      async: !1,
+      wrapped: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value !== void 0 && (e = this.wrapped["~run"](e, i)), e.value === void 0 && f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function K(r, n) {
+    return {
+      kind: "schema",
+      type: "non_optional",
+      reference: K,
+      expects: "!undefined",
+      async: !0,
+      wrapped: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return e.value !== void 0 && (e = await this.wrapped["~run"](e, i)), e.value === void 0 && f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function H(r) {
+    return {
+      kind: "schema",
+      type: "null",
+      reference: H,
+      expects: "null",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value === null ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function wi(r, n) {
+    return {
+      kind: "schema",
+      type: "nullable",
+      reference: wi,
+      expects: `(${r.expects} | null)`,
+      async: !1,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value === null && (this.default !== void 0 && (e.value = /* @__PURE__ */ d(this, e, i)), e.value === null) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ii(r, n) {
+    return {
+      kind: "schema",
+      type: "nullable",
+      reference: Ii,
+      expects: `(${r.expects} | null)`,
+      async: !0,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return e.value === null && (this.default !== void 0 && (e.value = await /* @__PURE__ */ d(this, e, i)), e.value === null) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Di(r, n) {
+    return {
+      kind: "schema",
+      type: "nullish",
+      reference: Di,
+      expects: `(${r.expects} | null | undefined)`,
+      async: !1,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return (e.value === null || e.value === void 0) && (this.default !== void 0 && (e.value = /* @__PURE__ */ d(this, e, i)), e.value === null || e.value === void 0) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ji(r, n) {
+    return {
+      kind: "schema",
+      type: "nullish",
+      reference: ji,
+      expects: `(${r.expects} | null | undefined)`,
+      async: !0,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return (e.value === null || e.value === void 0) && (this.default !== void 0 && (e.value = await /* @__PURE__ */ d(this, e, i)), e.value === null || e.value === void 0) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Oi(r) {
+    return {
+      kind: "schema",
+      type: "number",
+      reference: Oi,
+      expects: "number",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return typeof n.value == "number" && !isNaN(n.value) ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Gi(r, n) {
+    return {
+      kind: "schema",
+      type: "object",
+      reference: Gi,
+      expects: "Object",
+      async: !1,
+      entries: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (s && typeof s == "object") {
+          e.typed = !0, e.value = {};
+          for (const u in this.entries) {
+            const l = this.entries[u];
+            if (u in s || (l.type === "exact_optional" || l.type === "optional" || l.type === "nullish") && l.default !== void 0) {
+              const c = u in s ? s[u] : /* @__PURE__ */ d(l), o = l["~run"]({ value: c }, i);
+              if (o.issues) {
+                const p = {
+                  type: "object",
+                  origin: "value",
+                  input: s,
+                  key: u,
+                  value: c
+                };
+                for (const a of o.issues)
+                  a.path ? a.path.unshift(p) : a.path = [p], e.issues?.push(a);
+                if (e.issues || (e.issues = o.issues), i.abortEarly) {
+                  e.typed = !1;
+                  break;
+                }
+              }
+              o.typed || (e.typed = !1), e.value[u] = o.value;
+            } else if (l.fallback !== void 0) e.value[u] = /* @__PURE__ */ b(l);
+            else if (l.type !== "exact_optional" && l.type !== "optional" && l.type !== "nullish" && (f(this, "key", e, i, {
+              input: void 0,
+              expected: `"${u}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input: s,
+                key: u,
+                value: s[u]
+              }]
+            }), i.abortEarly))
+              break;
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ri(r, n) {
+    return {
+      kind: "schema",
+      type: "object",
+      reference: Ri,
+      expects: "Object",
+      async: !0,
+      entries: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (s && typeof s == "object") {
+          e.typed = !0, e.value = {};
+          const u = await Promise.all(Object.entries(this.entries).map(async ([l, c]) => {
+            if (l in s || (c.type === "exact_optional" || c.type === "optional" || c.type === "nullish") && c.default !== void 0) {
+              const o = l in s ? s[l] : await /* @__PURE__ */ d(c);
+              return [
+                l,
+                o,
+                c,
+                await c["~run"]({ value: o }, i)
+              ];
+            }
+            return [
+              l,
+              s[l],
+              c,
+              null
+            ];
+          }));
+          for (const [l, c, o, p] of u) if (p) {
+            if (p.issues) {
+              const a = {
+                type: "object",
+                origin: "value",
+                input: s,
+                key: l,
+                value: c
+              };
+              for (const h of p.issues)
+                h.path ? h.path.unshift(a) : h.path = [a], e.issues?.push(h);
+              if (e.issues || (e.issues = p.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            p.typed || (e.typed = !1), e.value[l] = p.value;
+          } else if (o.fallback !== void 0) e.value[l] = await /* @__PURE__ */ b(o);
+          else if (o.type !== "exact_optional" && o.type !== "optional" && o.type !== "nullish" && (f(this, "key", e, i, {
+            input: void 0,
+            expected: `"${l}"`,
+            path: [{
+              type: "object",
+              origin: "key",
+              input: s,
+              key: l,
+              value: c
+            }]
+          }), i.abortEarly))
+            break;
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function qi(r, n, e) {
+    return {
+      kind: "schema",
+      type: "object_with_rest",
+      reference: qi,
+      expects: "Object",
+      async: !1,
+      entries: r,
+      rest: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(i, s) {
+        const u = i.value;
+        if (u && typeof u == "object") {
+          i.typed = !0, i.value = {};
+          for (const l in this.entries) {
+            const c = this.entries[l];
+            if (l in u || (c.type === "exact_optional" || c.type === "optional" || c.type === "nullish") && c.default !== void 0) {
+              const o = l in u ? u[l] : /* @__PURE__ */ d(c), p = c["~run"]({ value: o }, s);
+              if (p.issues) {
+                const a = {
+                  type: "object",
+                  origin: "value",
+                  input: u,
+                  key: l,
+                  value: o
+                };
+                for (const h of p.issues)
+                  h.path ? h.path.unshift(a) : h.path = [a], i.issues?.push(h);
+                if (i.issues || (i.issues = p.issues), s.abortEarly) {
+                  i.typed = !1;
+                  break;
+                }
+              }
+              p.typed || (i.typed = !1), i.value[l] = p.value;
+            } else if (c.fallback !== void 0) i.value[l] = /* @__PURE__ */ b(c);
+            else if (c.type !== "exact_optional" && c.type !== "optional" && c.type !== "nullish" && (f(this, "key", i, s, {
+              input: void 0,
+              expected: `"${l}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input: u,
+                key: l,
+                value: u[l]
+              }]
+            }), s.abortEarly))
+              break;
+          }
+          if (!i.issues || !s.abortEarly) {
+            for (const l in u) if (/* @__PURE__ */ I(u, l) && !(l in this.entries)) {
+              const c = this.rest["~run"]({ value: u[l] }, s);
+              if (c.issues) {
+                const o = {
+                  type: "object",
+                  origin: "value",
+                  input: u,
+                  key: l,
+                  value: u[l]
+                };
+                for (const p of c.issues)
+                  p.path ? p.path.unshift(o) : p.path = [o], i.issues?.push(p);
+                if (i.issues || (i.issues = c.issues), s.abortEarly) {
+                  i.typed = !1;
+                  break;
+                }
+              }
+              c.typed || (i.typed = !1), i.value[l] = c.value;
+            }
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Mi(r, n, e) {
+    return {
+      kind: "schema",
+      type: "object_with_rest",
+      reference: Mi,
+      expects: "Object",
+      async: !0,
+      entries: r,
+      rest: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(i, s) {
+        const u = i.value;
+        if (u && typeof u == "object") {
+          i.typed = !0, i.value = {};
+          const [l, c] = await Promise.all([Promise.all(Object.entries(this.entries).map(async ([o, p]) => {
+            if (o in u || (p.type === "exact_optional" || p.type === "optional" || p.type === "nullish") && p.default !== void 0) {
+              const a = o in u ? u[o] : await /* @__PURE__ */ d(p);
+              return [
+                o,
+                a,
+                p,
+                await p["~run"]({ value: a }, s)
+              ];
+            }
+            return [
+              o,
+              u[o],
+              p,
+              null
+            ];
+          })), Promise.all(Object.entries(u).filter(([o]) => /* @__PURE__ */ I(u, o) && !(o in this.entries)).map(async ([o, p]) => [
+            o,
+            p,
+            await this.rest["~run"]({ value: p }, s)
+          ]))]);
+          for (const [o, p, a, h] of l) if (h) {
+            if (h.issues) {
+              const v = {
+                type: "object",
+                origin: "value",
+                input: u,
+                key: o,
+                value: p
+              };
+              for (const k of h.issues)
+                k.path ? k.path.unshift(v) : k.path = [v], i.issues?.push(k);
+              if (i.issues || (i.issues = h.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            h.typed || (i.typed = !1), i.value[o] = h.value;
+          } else if (a.fallback !== void 0) i.value[o] = await /* @__PURE__ */ b(a);
+          else if (a.type !== "exact_optional" && a.type !== "optional" && a.type !== "nullish" && (f(this, "key", i, s, {
+            input: void 0,
+            expected: `"${o}"`,
+            path: [{
+              type: "object",
+              origin: "key",
+              input: u,
+              key: o,
+              value: p
+            }]
+          }), s.abortEarly))
+            break;
+          if (!i.issues || !s.abortEarly) for (const [o, p, a] of c) {
+            if (a.issues) {
+              const h = {
+                type: "object",
+                origin: "value",
+                input: u,
+                key: o,
+                value: p
+              };
+              for (const v of a.issues)
+                v.path ? v.path.unshift(h) : v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = a.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            a.typed || (i.typed = !1), i.value[o] = a.value;
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Q(r, n) {
+    return {
+      kind: "schema",
+      type: "optional",
+      reference: Q,
+      expects: `(${r.expects} | undefined)`,
+      async: !1,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value === void 0 && (this.default !== void 0 && (e.value = /* @__PURE__ */ d(this, e, i)), e.value === void 0) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Y(r, n) {
+    return {
+      kind: "schema",
+      type: "optional",
+      reference: Y,
+      expects: `(${r.expects} | undefined)`,
+      async: !0,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return e.value === void 0 && (this.default !== void 0 && (e.value = await /* @__PURE__ */ d(this, e, i)), e.value === void 0) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ee(r, n) {
+    return {
+      kind: "schema",
+      type: "picklist",
+      reference: ee,
+      expects: /* @__PURE__ */ E(r.map(m), "|"),
+      async: !1,
+      options: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return this.options.includes(e.value) ? e.typed = !0 : f(this, "type", e, i), e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Si(r) {
+    return {
+      kind: "schema",
+      type: "promise",
+      reference: Si,
+      expects: "Promise",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value instanceof Promise ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Pi(r, n, e) {
+    return {
+      kind: "schema",
+      type: "record",
+      reference: Pi,
+      expects: "Object",
+      async: !1,
+      key: r,
+      value: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(i, s) {
+        const u = i.value;
+        if (u && typeof u == "object") {
+          i.typed = !0, i.value = {};
+          for (const l in u) if (/* @__PURE__ */ I(u, l)) {
+            const c = u[l], o = this.key["~run"]({ value: l }, s);
+            if (o.issues) {
+              const a = {
+                type: "object",
+                origin: "key",
+                input: u,
+                key: l,
+                value: c
+              };
+              for (const h of o.issues)
+                h.path = [a], i.issues?.push(h);
+              if (i.issues || (i.issues = o.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            const p = this.value["~run"]({ value: c }, s);
+            if (p.issues) {
+              const a = {
+                type: "object",
+                origin: "value",
+                input: u,
+                key: l,
+                value: c
+              };
+              for (const h of p.issues)
+                h.path ? h.path.unshift(a) : h.path = [a], i.issues?.push(h);
+              if (i.issues || (i.issues = p.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            (!o.typed || !p.typed) && (i.typed = !1), o.typed && (i.value[o.value] = p.value);
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Xi(r, n, e) {
+    return {
+      kind: "schema",
+      type: "record",
+      reference: Xi,
+      expects: "Object",
+      async: !0,
+      key: r,
+      value: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(i, s) {
+        const u = i.value;
+        if (u && typeof u == "object") {
+          i.typed = !0, i.value = {};
+          const l = await Promise.all(Object.entries(u).filter(([c]) => /* @__PURE__ */ I(u, c)).map(([c, o]) => Promise.all([
+            c,
+            o,
+            this.key["~run"]({ value: c }, s),
+            this.value["~run"]({ value: o }, s)
+          ])));
+          for (const [c, o, p, a] of l) {
+            if (p.issues) {
+              const h = {
+                type: "object",
+                origin: "key",
+                input: u,
+                key: c,
+                value: o
+              };
+              for (const v of p.issues)
+                v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = p.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            if (a.issues) {
+              const h = {
+                type: "object",
+                origin: "value",
+                input: u,
+                key: c,
+                value: o
+              };
+              for (const v of a.issues)
+                v.path ? v.path.unshift(h) : v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = a.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            (!p.typed || !a.typed) && (i.typed = !1), p.typed && (i.value[p.value] = a.value);
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ni(r, n) {
+    return {
+      kind: "schema",
+      type: "set",
+      reference: Ni,
+      expects: "Set",
+      async: !1,
+      value: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (s instanceof Set) {
+          e.typed = !0, e.value = /* @__PURE__ */ new Set();
+          for (const u of s) {
+            const l = this.value["~run"]({ value: u }, i);
+            if (l.issues) {
+              const c = {
+                type: "set",
+                origin: "value",
+                input: s,
+                key: null,
+                value: u
+              };
+              for (const o of l.issues)
+                o.path ? o.path.unshift(c) : o.path = [c], e.issues?.push(o);
+              if (e.issues || (e.issues = l.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            l.typed || (e.typed = !1), e.value.add(l.value);
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ci(r, n) {
+    return {
+      kind: "schema",
+      type: "set",
+      reference: Ci,
+      expects: "Set",
+      async: !0,
+      value: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (s instanceof Set) {
+          e.typed = !0, e.value = /* @__PURE__ */ new Set();
+          const u = await Promise.all([...s].map(async (l) => [l, await this.value["~run"]({ value: l }, i)]));
+          for (const [l, c] of u) {
+            if (c.issues) {
+              const o = {
+                type: "set",
+                origin: "value",
+                input: s,
+                key: null,
+                value: l
+              };
+              for (const p of c.issues)
+                p.path ? p.path.unshift(o) : p.path = [o], e.issues?.push(p);
+              if (e.issues || (e.issues = c.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            c.typed || (e.typed = !1), e.value.add(c.value);
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function zi(r, n) {
+    return {
+      kind: "schema",
+      type: "strict_object",
+      reference: zi,
+      expects: "Object",
+      async: !1,
+      entries: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (s && typeof s == "object") {
+          e.typed = !0, e.value = {};
+          for (const u in this.entries) {
+            const l = this.entries[u];
+            if (u in s || (l.type === "exact_optional" || l.type === "optional" || l.type === "nullish") && l.default !== void 0) {
+              const c = u in s ? s[u] : /* @__PURE__ */ d(l), o = l["~run"]({ value: c }, i);
+              if (o.issues) {
+                const p = {
+                  type: "object",
+                  origin: "value",
+                  input: s,
+                  key: u,
+                  value: c
+                };
+                for (const a of o.issues)
+                  a.path ? a.path.unshift(p) : a.path = [p], e.issues?.push(a);
+                if (e.issues || (e.issues = o.issues), i.abortEarly) {
+                  e.typed = !1;
+                  break;
+                }
+              }
+              o.typed || (e.typed = !1), e.value[u] = o.value;
+            } else if (l.fallback !== void 0) e.value[u] = /* @__PURE__ */ b(l);
+            else if (l.type !== "exact_optional" && l.type !== "optional" && l.type !== "nullish" && (f(this, "key", e, i, {
+              input: void 0,
+              expected: `"${u}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input: s,
+                key: u,
+                value: s[u]
+              }]
+            }), i.abortEarly))
+              break;
+          }
+          if (!e.issues || !i.abortEarly) {
+            for (const u in s) if (!(u in this.entries)) {
+              f(this, "key", e, i, {
+                input: u,
+                expected: "never",
+                path: [{
+                  type: "object",
+                  origin: "key",
+                  input: s,
+                  key: u,
+                  value: s[u]
+                }]
+              });
+              break;
+            }
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ti(r, n) {
+    return {
+      kind: "schema",
+      type: "strict_object",
+      reference: Ti,
+      expects: "Object",
+      async: !0,
+      entries: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (s && typeof s == "object") {
+          e.typed = !0, e.value = {};
+          const u = await Promise.all(Object.entries(this.entries).map(async ([l, c]) => {
+            if (l in s || (c.type === "exact_optional" || c.type === "optional" || c.type === "nullish") && c.default !== void 0) {
+              const o = l in s ? s[l] : await /* @__PURE__ */ d(c);
+              return [
+                l,
+                o,
+                c,
+                await c["~run"]({ value: o }, i)
+              ];
+            }
+            return [
+              l,
+              s[l],
+              c,
+              null
+            ];
+          }));
+          for (const [l, c, o, p] of u) if (p) {
+            if (p.issues) {
+              const a = {
+                type: "object",
+                origin: "value",
+                input: s,
+                key: l,
+                value: c
+              };
+              for (const h of p.issues)
+                h.path ? h.path.unshift(a) : h.path = [a], e.issues?.push(h);
+              if (e.issues || (e.issues = p.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            p.typed || (e.typed = !1), e.value[l] = p.value;
+          } else if (o.fallback !== void 0) e.value[l] = await /* @__PURE__ */ b(o);
+          else if (o.type !== "exact_optional" && o.type !== "optional" && o.type !== "nullish" && (f(this, "key", e, i, {
+            input: void 0,
+            expected: `"${l}"`,
+            path: [{
+              type: "object",
+              origin: "key",
+              input: s,
+              key: l,
+              value: c
+            }]
+          }), i.abortEarly))
+            break;
+          if (!e.issues || !i.abortEarly) {
+            for (const l in s) if (!(l in this.entries)) {
+              f(this, "key", e, i, {
+                input: l,
+                expected: "never",
+                path: [{
+                  type: "object",
+                  origin: "key",
+                  input: s,
+                  key: l,
+                  value: s[l]
+                }]
+              });
+              break;
+            }
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Fi(r, n) {
+    return {
+      kind: "schema",
+      type: "strict_tuple",
+      reference: Fi,
+      expects: "Array",
+      async: !1,
+      items: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          for (let u = 0; u < this.items.length; u++) {
+            const l = s[u], c = this.items[u]["~run"]({ value: l }, i);
+            if (c.issues) {
+              const o = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: u,
+                value: l
+              };
+              for (const p of c.issues)
+                p.path ? p.path.unshift(o) : p.path = [o], e.issues?.push(p);
+              if (e.issues || (e.issues = c.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            c.typed || (e.typed = !1), e.value.push(c.value);
+          }
+          !(e.issues && i.abortEarly) && this.items.length < s.length && f(this, "type", e, i, {
+            input: s[this.items.length],
+            expected: "never",
+            path: [{
+              type: "array",
+              origin: "value",
+              input: s,
+              key: this.items.length,
+              value: s[this.items.length]
+            }]
+          });
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $i(r, n) {
+    return {
+      kind: "schema",
+      type: "strict_tuple",
+      reference: $i,
+      expects: "Array",
+      async: !0,
+      items: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          const u = await Promise.all(this.items.map(async (l, c) => {
+            const o = s[c];
+            return [
+              c,
+              o,
+              await l["~run"]({ value: o }, i)
+            ];
+          }));
+          for (const [l, c, o] of u) {
+            if (o.issues) {
+              const p = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: l,
+                value: c
+              };
+              for (const a of o.issues)
+                a.path ? a.path.unshift(p) : a.path = [p], e.issues?.push(a);
+              if (e.issues || (e.issues = o.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            o.typed || (e.typed = !1), e.value.push(o.value);
+          }
+          !(e.issues && i.abortEarly) && this.items.length < s.length && f(this, "type", e, i, {
+            input: s[this.items.length],
+            expected: "never",
+            path: [{
+              type: "array",
+              origin: "value",
+              input: s,
+              key: this.items.length,
+              value: s[this.items.length]
+            }]
+          });
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Vi(r) {
+    return {
+      kind: "schema",
+      type: "string",
+      reference: Vi,
+      expects: "string",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return typeof n.value == "string" ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Li(r) {
+    return {
+      kind: "schema",
+      type: "symbol",
+      reference: Li,
+      expects: "symbol",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return typeof n.value == "symbol" ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ji(r, n) {
+    return {
+      kind: "schema",
+      type: "tuple",
+      reference: Ji,
+      expects: "Array",
+      async: !1,
+      items: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          for (let u = 0; u < this.items.length; u++) {
+            const l = s[u], c = this.items[u]["~run"]({ value: l }, i);
+            if (c.issues) {
+              const o = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: u,
+                value: l
+              };
+              for (const p of c.issues)
+                p.path ? p.path.unshift(o) : p.path = [o], e.issues?.push(p);
+              if (e.issues || (e.issues = c.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            c.typed || (e.typed = !1), e.value.push(c.value);
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Wi(r, n) {
+    return {
+      kind: "schema",
+      type: "tuple",
+      reference: Wi,
+      expects: "Array",
+      async: !0,
+      items: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        const s = e.value;
+        if (Array.isArray(s)) {
+          e.typed = !0, e.value = [];
+          const u = await Promise.all(this.items.map(async (l, c) => {
+            const o = s[c];
+            return [
+              c,
+              o,
+              await l["~run"]({ value: o }, i)
+            ];
+          }));
+          for (const [l, c, o] of u) {
+            if (o.issues) {
+              const p = {
+                type: "array",
+                origin: "value",
+                input: s,
+                key: l,
+                value: c
+              };
+              for (const a of o.issues)
+                a.path ? a.path.unshift(p) : a.path = [p], e.issues?.push(a);
+              if (e.issues || (e.issues = o.issues), i.abortEarly) {
+                e.typed = !1;
+                break;
+              }
+            }
+            o.typed || (e.typed = !1), e.value.push(o.value);
+          }
+        } else f(this, "type", e, i);
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Bi(r, n, e) {
+    return {
+      kind: "schema",
+      type: "tuple_with_rest",
+      reference: Bi,
+      expects: "Array",
+      async: !1,
+      items: r,
+      rest: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(i, s) {
+        const u = i.value;
+        if (Array.isArray(u)) {
+          i.typed = !0, i.value = [];
+          for (let l = 0; l < this.items.length; l++) {
+            const c = u[l], o = this.items[l]["~run"]({ value: c }, s);
+            if (o.issues) {
+              const p = {
+                type: "array",
+                origin: "value",
+                input: u,
+                key: l,
+                value: c
+              };
+              for (const a of o.issues)
+                a.path ? a.path.unshift(p) : a.path = [p], i.issues?.push(a);
+              if (i.issues || (i.issues = o.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            o.typed || (i.typed = !1), i.value.push(o.value);
+          }
+          if (!i.issues || !s.abortEarly) for (let l = this.items.length; l < u.length; l++) {
+            const c = u[l], o = this.rest["~run"]({ value: c }, s);
+            if (o.issues) {
+              const p = {
+                type: "array",
+                origin: "value",
+                input: u,
+                key: l,
+                value: c
+              };
+              for (const a of o.issues)
+                a.path ? a.path.unshift(p) : a.path = [p], i.issues?.push(a);
+              if (i.issues || (i.issues = o.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            o.typed || (i.typed = !1), i.value.push(o.value);
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ui(r, n, e) {
+    return {
+      kind: "schema",
+      type: "tuple_with_rest",
+      reference: Ui,
+      expects: "Array",
+      async: !0,
+      items: r,
+      rest: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(i, s) {
+        const u = i.value;
+        if (Array.isArray(u)) {
+          i.typed = !0, i.value = [];
+          const [l, c] = await Promise.all([Promise.all(this.items.map(async (o, p) => {
+            const a = u[p];
+            return [
+              p,
+              a,
+              await o["~run"]({ value: a }, s)
+            ];
+          })), Promise.all(u.slice(this.items.length).map(async (o, p) => [
+            p + this.items.length,
+            o,
+            await this.rest["~run"]({ value: o }, s)
+          ]))]);
+          for (const [o, p, a] of l) {
+            if (a.issues) {
+              const h = {
+                type: "array",
+                origin: "value",
+                input: u,
+                key: o,
+                value: p
+              };
+              for (const v of a.issues)
+                v.path ? v.path.unshift(h) : v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = a.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            a.typed || (i.typed = !1), i.value.push(a.value);
+          }
+          if (!i.issues || !s.abortEarly) for (const [o, p, a] of c) {
+            if (a.issues) {
+              const h = {
+                type: "array",
+                origin: "value",
+                input: u,
+                key: o,
+                value: p
+              };
+              for (const v of a.issues)
+                v.path ? v.path.unshift(h) : v.path = [h], i.issues?.push(v);
+              if (i.issues || (i.issues = a.issues), s.abortEarly) {
+                i.typed = !1;
+                break;
+              }
+            }
+            a.typed || (i.typed = !1), i.value.push(a.value);
+          }
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ne(r) {
+    return {
+      kind: "schema",
+      type: "undefined",
+      reference: ne,
+      expects: "undefined",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value === void 0 ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Zi(r, n) {
+    return {
+      kind: "schema",
+      type: "undefinedable",
+      reference: Zi,
+      expects: `(${r.expects} | undefined)`,
+      async: !1,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return e.value === void 0 && (this.default !== void 0 && (e.value = /* @__PURE__ */ d(this, e, i)), e.value === void 0) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ki(r, n) {
+    return {
+      kind: "schema",
+      type: "undefinedable",
+      reference: Ki,
+      expects: `(${r.expects} | undefined)`,
+      async: !0,
+      wrapped: r,
+      default: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        return e.value === void 0 && (this.default !== void 0 && (e.value = await /* @__PURE__ */ d(this, e, i)), e.value === void 0) ? (e.typed = !0, e) : this.wrapped["~run"](e, i);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function C(r) {
+    let n;
+    if (r) for (const e of r) n ? n.push(...e.issues) : n = e.issues;
+    return n;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Hi(r, n) {
+    return {
+      kind: "schema",
+      type: "union",
+      reference: Hi,
+      expects: /* @__PURE__ */ E(r.map((e) => e.expects), "|"),
+      async: !1,
+      options: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        let s, u, l;
+        for (const c of this.options) {
+          const o = c["~run"]({ value: e.value }, i);
+          if (o.typed) if (o.issues) u ? u.push(o) : u = [o];
+          else {
+            s = o;
+            break;
+          }
+          else l ? l.push(o) : l = [o];
+        }
+        if (s) return s;
+        if (u) {
+          if (u.length === 1) return u[0];
+          f(this, "type", e, i, { issues: /* @__PURE__ */ C(u) }), e.typed = !0;
+        } else {
+          if (l?.length === 1) return l[0];
+          f(this, "type", e, i, { issues: /* @__PURE__ */ C(l) });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Qi(r, n) {
+    return {
+      kind: "schema",
+      type: "union",
+      reference: Qi,
+      expects: /* @__PURE__ */ E(r.map((e) => e.expects), "|"),
+      async: !0,
+      options: r,
+      message: n,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(e, i) {
+        let s, u, l;
+        for (const c of this.options) {
+          const o = await c["~run"]({ value: e.value }, i);
+          if (o.typed) if (o.issues) u ? u.push(o) : u = [o];
+          else {
+            s = o;
+            break;
+          }
+          else l ? l.push(o) : l = [o];
+        }
+        if (s) return s;
+        if (u) {
+          if (u.length === 1) return u[0];
+          f(this, "type", e, i, { issues: /* @__PURE__ */ C(u) }), e.typed = !0;
+        } else {
+          if (l?.length === 1) return l[0];
+          f(this, "type", e, i, { issues: /* @__PURE__ */ C(l) });
+        }
+        return e;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Yi() {
+    return {
+      kind: "schema",
+      type: "unknown",
+      reference: Yi,
+      expects: "unknown",
+      async: !1,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(r) {
+        return r.typed = !0, r;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function es(r, n, e) {
+    return {
+      kind: "schema",
+      type: "variant",
+      reference: es,
+      expects: "Object",
+      async: !1,
+      key: r,
+      options: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(i, s) {
+        const u = i.value;
+        if (u && typeof u == "object") {
+          let l, c = 0, o = this.key, p = [];
+          const a = (h, v) => {
+            for (const k of h.options) {
+              if (k.type === "variant") a(k, new Set(v).add(k.key));
+              else {
+                let P = !0, _ = 0;
+                for (const g of v) {
+                  const A = k.entries[g];
+                  if (g in u ? A["~run"]({
+                    typed: !1,
+                    value: u[g]
+                  }, { abortEarly: !0 }).issues : A.type !== "exact_optional" && A.type !== "optional" && A.type !== "nullish") {
+                    P = !1, o !== g && (c < _ || c === _ && g in u && !(o in u)) && (c = _, o = g, p = []), o === g && p.push(k.entries[g].expects);
+                    break;
+                  }
+                  _++;
+                }
+                if (P) {
+                  const g = k["~run"]({ value: u }, s);
+                  (!l || !l.typed && g.typed) && (l = g);
+                }
+              }
+              if (l && !l.issues) break;
+            }
+          };
+          if (a(this, /* @__PURE__ */ new Set([this.key])), l) return l;
+          f(this, "type", i, s, {
+            input: u[o],
+            expected: /* @__PURE__ */ E(p, "|"),
+            path: [{
+              type: "object",
+              origin: "value",
+              input: u,
+              key: o,
+              value: u[o]
+            }]
+          });
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ns(r, n, e) {
+    return {
+      kind: "schema",
+      type: "variant",
+      reference: ns,
+      expects: "Object",
+      async: !0,
+      key: r,
+      options: n,
+      message: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(i, s) {
+        const u = i.value;
+        if (u && typeof u == "object") {
+          let l, c = 0, o = this.key, p = [];
+          const a = async (h, v) => {
+            for (const k of h.options) {
+              if (k.type === "variant") await a(k, new Set(v).add(k.key));
+              else {
+                let P = !0, _ = 0;
+                for (const g of v) {
+                  const A = k.entries[g];
+                  if (g in u ? (await A["~run"]({
+                    typed: !1,
+                    value: u[g]
+                  }, { abortEarly: !0 })).issues : A.type !== "exact_optional" && A.type !== "optional" && A.type !== "nullish") {
+                    P = !1, o !== g && (c < _ || c === _ && g in u && !(o in u)) && (c = _, o = g, p = []), o === g && p.push(k.entries[g].expects);
+                    break;
+                  }
+                  _++;
+                }
+                if (P) {
+                  const g = await k["~run"]({ value: u }, s);
+                  (!l || !l.typed && g.typed) && (l = g);
+                }
+              }
+              if (l && !l.issues) break;
+            }
+          };
+          if (await a(this, /* @__PURE__ */ new Set([this.key])), l) return l;
+          f(this, "type", i, s, {
+            input: u[o],
+            expected: /* @__PURE__ */ E(p, "|"),
+            path: [{
+              type: "object",
+              origin: "value",
+              input: u,
+              key: o,
+              value: u[o]
+            }]
+          });
+        } else f(this, "type", i, s);
+        return i;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function re(r) {
+    return {
+      kind: "schema",
+      type: "void",
+      reference: re,
+      expects: "void",
+      async: !1,
+      message: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        return n.value === void 0 ? n.typed = !0 : f(this, "type", n, e), n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ns(r, n) {
+    return /* @__PURE__ */ ee(Object.keys(r.entries), n);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Cs(r, n) {
+    return {
+      ...r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(e, i) {
+        return r["~run"](e, {
+          ...i,
+          message: n
+        });
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function zs(r, n) {
+    const e = { ...r.entries };
+    for (const i of n) delete e[i];
+    return {
+      ...r,
+      entries: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      }
+    };
+  }
+  function rs(r, n, e) {
+    const i = r["~run"]({ value: n }, /* @__PURE__ */ j(e));
+    if (i.issues) throw new x(i.issues);
+    return i.value;
+  }
+  async function is(r, n, e) {
+    const i = await r["~run"]({ value: n }, /* @__PURE__ */ j(e));
+    if (i.issues) throw new x(i.issues);
+    return i.value;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ts(r, n) {
+    const e = (i) => rs(r, i, n);
+    return e.schema = r, e.config = n, e;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Fs(r, n) {
+    const e = (i) => is(r, i, n);
+    return e.schema = r, e.config = n, e;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $s(r, n) {
+    const e = {};
+    for (const i in r.entries) e[i] = !n || n.includes(i) ? /* @__PURE__ */ Q(r.entries[i]) : r.entries[i];
+    return {
+      ...r,
+      entries: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Vs(r, n) {
+    const e = {};
+    for (const i in r.entries) e[i] = !n || n.includes(i) ? /* @__PURE__ */ Y(r.entries[i]) : r.entries[i];
+    return {
+      ...r,
+      entries: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ls(r, n) {
+    const e = {};
+    for (const i of n) e[i] = r.entries[i];
+    return {
+      ...r,
+      entries: e,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Js(...r) {
+    return {
+      ...r[0],
+      pipe: r,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      "~run"(n, e) {
+        for (const i of r) if (i.kind !== "metadata") {
+          if (n.issues && (i.kind === "schema" || i.kind === "transformation")) {
+            n.typed = !1;
+            break;
+          }
+          (!n.issues || !e.abortEarly && !e.abortPipeEarly) && (n = i["~run"](n, e));
+        }
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ws(...r) {
+    return {
+      ...r[0],
+      pipe: r,
+      async: !0,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      },
+      async "~run"(n, e) {
+        for (const i of r) if (i.kind !== "metadata") {
+          if (n.issues && (i.kind === "schema" || i.kind === "transformation")) {
+            n.typed = !1;
+            break;
+          }
+          (!n.issues || !e.abortEarly && !e.abortPipeEarly) && (n = await i["~run"](n, e));
+        }
+        return n;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Bs(r, n, e) {
+    const i = Array.isArray(n) ? n : void 0, s = Array.isArray(n) ? e : n, u = {};
+    for (const l in r.entries) u[l] = !i || i.includes(l) ? /* @__PURE__ */ Z(r.entries[l], s) : r.entries[l];
+    return {
+      ...r,
+      entries: u,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Us(r, n, e) {
+    const i = Array.isArray(n) ? n : void 0, s = Array.isArray(n) ? e : n, u = {};
+    for (const l in r.entries) u[l] = !i || i.includes(l) ? /* @__PURE__ */ K(r.entries[l], s) : r.entries[l];
+    return {
+      ...r,
+      entries: u,
+      get "~standard"() {
+        return /* @__PURE__ */ y(this);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function ss(r, n, e) {
+    const i = r["~run"]({ value: n }, /* @__PURE__ */ j(e));
+    return {
+      typed: i.typed,
+      success: !i.issues,
+      output: i.value,
+      issues: i.issues
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  async function ts(r, n, e) {
+    const i = await r["~run"]({ value: n }, /* @__PURE__ */ j(e));
+    return {
+      typed: i.typed,
+      success: !i.issues,
+      output: i.value,
+      issues: i.issues
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Zs(r, n) {
+    const e = (i) => /* @__PURE__ */ ss(r, i, n);
+    return e.schema = r, e.config = n, e;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Ks(r, n) {
+    const e = (i) => /* @__PURE__ */ ts(r, i, n);
+    return e.schema = r, e.config = n, e;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Hs(r) {
+    let n = "";
+    for (const e of r) {
+      n && (n += `
+`), n += `× ${e.message}`;
+      const i = /* @__PURE__ */ $(e);
+      i && (n += `
+  → at ${i}`);
+    }
+    return n;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function Qs(r) {
+    return r.wrapped;
+  }
+  return t.BASE64_REGEX = ce, t.BIC_REGEX = fe, t.CUID2_REGEX = pe, t.DECIMAL_REGEX = ae, t.DIGITS_REGEX = ye, t.EMAIL_REGEX = he, t.EMOJI_REGEX = ve, t.HEXADECIMAL_REGEX = me, t.HEX_COLOR_REGEX = ge, t.IMEI_REGEX = de, t.IPV4_REGEX = ke, t.IPV6_REGEX = be, t.IP_REGEX = Ee, t.ISO_DATE_REGEX = xe, t.ISO_DATE_TIME_REGEX = _e, t.ISO_TIMESTAMP_REGEX = Ie, t.ISO_TIME_REGEX = Ae, t.ISO_TIME_SECOND_REGEX = we, t.ISO_WEEK_REGEX = De, t.MAC48_REGEX = je, t.MAC64_REGEX = Oe, t.MAC_REGEX = Ge, t.NANO_ID_REGEX = Re, t.OCTAL_REGEX = qe, t.RFC_EMAIL_REGEX = Me, t.SLUG_REGEX = Se, t.ULID_REGEX = Pe, t.UUID_REGEX = Xe, t.ValiError = x, t._addIssue = f, t._getByteCount = R, t._getGraphemeCount = q, t._getLastMetadata = X, t._getStandardProps = y, t._getWordCount = S, t._isLuhnAlgo = F, t._isValidObjectKey = I, t._joinExpects = E, t._stringify = m, t.any = Zr, t.args = ue, t.argsAsync = le, t.array = Kr, t.arrayAsync = Hr, t.assert = ws, t.awaitAsync = oe, t.base64 = Ne, t.bic = Ce, t.bigint = Qr, t.blob = Yr, t.boolean = ei, t.brand = ze, t.bytes = Te, t.check = Fe, t.checkAsync = $e, t.checkItems = Ve, t.checkItemsAsync = Le, t.config = Is, t.creditCard = Je, t.cuid2 = We, t.custom = ni, t.customAsync = ri, t.date = ii, t.decimal = Be, t.deleteGlobalConfig = os, t.deleteGlobalMessage = fs, t.deleteSchemaMessage = as, t.deleteSpecificMessage = hs, t.description = Ue, t.digits = Ze, t.email = Ke, t.emoji = He, t.empty = Qe, t.endsWith = Ye, t.entries = en, t.entriesFromList = ms, t.entriesFromObjects = gs, t.enum = B, t.enum_ = B, t.everyItem = nn, t.exactOptional = si, t.exactOptionalAsync = ti, t.examples = rn, t.excludes = sn, t.fallback = Ds, t.fallbackAsync = js, t.file = ui, t.filterItems = tn, t.findItem = un, t.finite = ln, t.flatten = Os, t.flavor = on, t.forward = Gs, t.forwardAsync = Rs, t.function = U, t.function_ = U, t.getDefault = d, t.getDefaults = V, t.getDefaultsAsync = L, t.getDescription = qs, t.getDotPath = $, t.getExamples = Ms, t.getFallback = b, t.getFallbacks = J, t.getFallbacksAsync = W, t.getGlobalConfig = j, t.getGlobalMessage = ie, t.getMetadata = Ss, t.getSchemaMessage = se, t.getSpecificMessage = te, t.getTitle = Ps, t.graphemes = cn, t.gtValue = fn, t.hash = pn, t.hexColor = yn, t.hexadecimal = an, t.imei = hn, t.includes = vn, t.instance = li, t.integer = mn, t.intersect = oi, t.intersectAsync = ci, t.ip = gn, t.ipv4 = dn, t.ipv6 = kn, t.is = Xs, t.isOfKind = ds, t.isOfType = ks, t.isValiError = bs, t.isoDate = bn, t.isoDateTime = En, t.isoTime = xn, t.isoTimeSecond = _n, t.isoTimestamp = An, t.isoWeek = wn, t.keyof = Ns, t.lazy = fi, t.lazyAsync = pi, t.length = In, t.literal = ai, t.looseObject = yi, t.looseObjectAsync = hi, t.looseTuple = vi, t.looseTupleAsync = mi, t.ltValue = Dn, t.mac = jn, t.mac48 = On, t.mac64 = Gn, t.map = gi, t.mapAsync = di, t.mapItems = Rn, t.maxBytes = qn, t.maxEntries = Mn, t.maxGraphemes = Sn, t.maxLength = Pn, t.maxSize = Xn, t.maxValue = Nn, t.maxWords = Cn, t.message = Cs, t.metadata = zn, t.mimeType = Tn, t.minBytes = Fn, t.minEntries = $n, t.minGraphemes = Vn, t.minLength = Ln, t.minSize = Jn, t.minValue = Wn, t.minWords = Bn, t.multipleOf = Un, t.nan = ki, t.nanoid = Zn, t.never = bi, t.nonEmpty = Kn, t.nonNullable = Ei, t.nonNullableAsync = xi, t.nonNullish = _i, t.nonNullishAsync = Ai, t.nonOptional = Z, t.nonOptionalAsync = K, t.normalize = Hn, t.notBytes = Qn, t.notEntries = Yn, t.notGraphemes = er, t.notLength = nr, t.notSize = rr, t.notValue = ir, t.notValues = sr, t.notWords = tr, t.null = H, t.null_ = H, t.nullable = wi, t.nullableAsync = Ii, t.nullish = Di, t.nullishAsync = ji, t.number = Oi, t.object = Gi, t.objectAsync = Ri, t.objectWithRest = qi, t.objectWithRestAsync = Mi, t.octal = ur, t.omit = zs, t.optional = Q, t.optionalAsync = Y, t.parse = rs, t.parseAsync = is, t.parseJson = lr, t.parser = Ts, t.parserAsync = Fs, t.partial = $s, t.partialAsync = Vs, t.partialCheck = cr, t.partialCheckAsync = fr, t.pick = Ls, t.picklist = ee, t.pipe = Js, t.pipeAsync = Ws, t.promise = Si, t.rawCheck = pr, t.rawCheckAsync = ar, t.rawTransform = yr, t.rawTransformAsync = hr, t.readonly = vr, t.record = Pi, t.recordAsync = Xi, t.reduceItems = mr, t.regex = gr, t.required = Bs, t.requiredAsync = Us, t.returns = dr, t.returnsAsync = kr, t.rfcEmail = br, t.safeInteger = Er, t.safeParse = ss, t.safeParseAsync = ts, t.safeParser = Zs, t.safeParserAsync = Ks, t.set = Ni, t.setAsync = Ci, t.setGlobalConfig = ls, t.setGlobalMessage = cs, t.setSchemaMessage = ps, t.setSpecificMessage = ys, t.size = xr, t.slug = _r, t.someItem = Ar, t.sortItems = wr, t.startsWith = Ir, t.strictObject = zi, t.strictObjectAsync = Ti, t.strictTuple = Fi, t.strictTupleAsync = $i, t.string = Vi, t.stringifyJson = Dr, t.summarize = Hs, t.symbol = Li, t.title = jr, t.toBigint = Or, t.toBoolean = Gr, t.toDate = Rr, t.toLowerCase = qr, t.toMaxValue = Mr, t.toMinValue = Sr, t.toNumber = Pr, t.toString = Xr, t.toUpperCase = Nr, t.transform = Cr, t.transformAsync = zr, t.trim = Tr, t.trimEnd = Fr, t.trimStart = $r, t.tuple = Ji, t.tupleAsync = Wi, t.tupleWithRest = Bi, t.tupleWithRestAsync = Ui, t.ulid = Vr, t.undefined = ne, t.undefined_ = ne, t.undefinedable = Zi, t.undefinedableAsync = Ki, t.union = Hi, t.unionAsync = Qi, t.unknown = Yi, t.unwrap = Qs, t.url = Lr, t.uuid = Jr, t.value = Wr, t.values = Br, t.variant = es, t.variantAsync = ns, t.void = re, t.void_ = re, t.words = Ur, t;
+}
+export {
+  Ys as r
+};