modern-ts 0.8.0

package/dist/subpath/Fit.mjs

@@ -0,0 +1,914 @@
+import { O as st, E as ot, i as at } from "../chunks/base-K-RHLZ-S.mjs";
+import { P as rt } from "../chunks/Errors-DwUAvFIF.mjs";
+import { d as x } from "../chunks/helper-BVabbpmX.mjs";
+const F = Symbol("Void");
+var w = /* @__PURE__ */ ((t) => (t[t.that = 0] = "that", t[t.off = 1] = "off", t[t.transform = 2] = "transform", t[t.shape = 3] = "shape", t[t.toArray = 4] = "toArray", t))(w || {});
+class s {
+  ops = new Array();
+  is_optional = !1;
+  get Ops() {
+    return this.ops;
+  }
+  get isOptional() {
+    return this.is_optional;
+  }
+  // -- 内部方法：从现有操作数组创建实例 --
+  static _fromOps(e) {
+    const n = new s();
+    return n.ops = e, n;
+  }
+  that(e, n) {
+    return this.ops.push({
+      type: 0,
+      predicate: e,
+      message: n
+    }), this;
+  }
+  off(e, n) {
+    const r = {
+      type: 1,
+      predicate: e
+    };
+    return arguments.length > 1 && (r.defaultValue = n), this.ops.push(r), this;
+  }
+  // ============================================
+  // transform: 值变换
+  // ============================================
+  /**
+   * Adds a transformation that converts the value to a new type.
+   *
+   * The transform function receives the current value and can return a new value
+   * of any type. Async transforms are supported via MaybePromise.
+   *
+   * @template U - The output type of the transformation
+   * @param fn - A function that transforms the value
+   * @returns A new Fit with type U (Awaited for async transforms)
+   */
+  transform(e) {
+    return this.ops.push({
+      type: 2,
+      fn: e
+    }), this;
+  }
+  // ============================================
+  // toShaped: 对象形状校验
+  // ============================================
+  /**
+   * Adds object shape validation with typed field schemas.
+   *
+   * Each field in the shape is validated by its own Fit schema. The resulting
+   * type is derived from the field schemas, with optional fields marked with `?`
+   * and readonly fields marked with `readonly`.
+   *
+   * Cannot be called on a readonly Fit or after another toShaped call.
+   *
+   * @template F - Record of field name to Fit schema
+   * @param fields - An object mapping field names to their Fit schemas
+   * @returns A new Fit with the derived shape type
+   */
+  toShaped(e) {
+    return this.ops.push({
+      type: 3,
+      fields: e
+    }), this;
+  }
+  // ============================================
+  // toArray: 数组元素校验
+  // ============================================
+  /**
+   * Adds array validation where each element is validated by the given schema.
+   *
+   * Cannot be called on a readonly Fit or after another toArray call.
+   *
+   * @template E - The element type after validation
+   * @template EBail - The element's Bail type
+   * @template EChecked - The element's Checked type
+   * @template EOptional - Whether elements are optional
+   * @template EReadonly - Whether elements are readonly
+   * @template EShape - Whether elements have shape validation
+   * @param elementFit - The Fit schema to validate each array element
+   * @returns A new Fit with array type
+   */
+  toArray(e) {
+    return this.ops.push({
+      type: 4,
+      elementFit: e
+    }), this;
+  }
+  /**
+   * Creates a copy of this Fit instance with its own operation array.
+   *
+   * Useful when you want to branch a validation pipeline without affecting
+   * the original.
+   *
+   * @returns A new Fit instance with copied operations
+   */
+  fork() {
+    const e = s._fromOps([...this.ops]);
+    return e.is_optional = this.is_optional, e;
+  }
+}
+const wt = (t) => t, u = (t) => (t.is_optional = !0, t), Ot = () => new s(), kt = (t) => new s().toShaped(t), vt = (t) => new s().toArray(t), P = (t) => typeof t == "string", W = (t) => typeof t == "number", U = (t) => typeof t == "boolean", Z = (t) => typeof t == "symbol", B = (t) => typeof t == "bigint", K = (t) => typeof t == "function", S = (t) => typeof t == "object" && t !== null, I = (t) => Array.isArray(t), it = (t) => t === void 0, ct = (t) => t === null, L = (t) => t == null, ft = (t) => t == null || typeof t != "object" && typeof t != "function", G = (t) => t instanceof Date, X = (t) => t instanceof RegExp, Y = (t) => t instanceof Error, q = (t) => t instanceof Map, z = (t) => t instanceof Set, C = (t) => t instanceof WeakMap, H = (t) => t instanceof WeakSet, J = (t) => S(t) && !I(t), Q = (t) => S(t) && Symbol.iterator in t, tt = (t) => S(t) && Symbol.asyncIterator in t, jt = (t, e) => (n) => {
+  if (!S(n)) return !1;
+  for (const r in n)
+    if (Object.prototype.hasOwnProperty.call(n, r) && (!t(r) || !e(n[r])))
+      return !1;
+  return !0;
+}, lt = (t) => !!t, ut = (t) => !t, pt = (t) => L(t) ? !0 : P(t) || I(t) ? t.length === 0 : q(t) || z(t) ? t.size === 0 : S(t) ? Object.keys(t).length === 0 : !1, St = (t) => !pt(t), At = (t) => (e) => e === t, Et = (t) => (e) => e !== t, $t = (t) => (e) => e > t, Mt = (t) => (e) => e >= t, It = (t) => (e) => e < t, Nt = (t) => (e) => e <= t, Vt = (t, e) => (n) => n > t && n < e, Rt = (t, e) => (n) => n >= t && n <= e, et = (...t) => (e) => t.includes(e), Wt = (...t) => (e) => !t.includes(e), xt = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ((t) => (e) => e instanceof t)
+), Dt = (t) => (e) => e.length >= t, Ft = (t) => (e) => e.length <= t, Pt = (t, e) => (n) => n.length >= t && n.length <= e, qt = (t) => (e) => t.test(e), zt = (t) => (e) => e.startsWith(t), Tt = (t) => (e) => e.endsWith(t), Ut = (t) => (e) => e.includes(t), Zt = (t) => t === t.trim(), Bt = (t) => t.length > 0, Kt = (t) => /^\d+$/.test(t), Lt = (t) => /^[a-zA-Z]+$/.test(t), Gt = (t) => /^[a-zA-Z0-9]+$/.test(t), Xt = (t) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(t), Yt = (t) => {
+  const e = /^(?!\.)(?!.*?\.\.)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+@((?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,})$/u;
+  return !t || t.length > 254 ? !1 : e.test(t);
+}, Ct = (t) => {
+  try {
+    return new URL(t), !0;
+  } catch {
+    return !1;
+  }
+}, Ht = (t) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(t), Jt = (t) => /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(t), Qt = (t) => (e) => e >= t, te = (t) => (e) => e <= t, ee = (t, e) => (n) => n >= t && n <= e, nt = (t) => Number.isInteger(t), ne = (t) => Number.isSafeInteger(t), se = (t) => t > 0, oe = (t) => t < 0, ae = (t) => t <= 0, re = (t) => t >= 0, ie = (t) => Number.isFinite(t), ce = (t) => Number.isNaN(t), fe = (t) => t % 2 === 0, le = (t) => t % 2 !== 0, ue = (t) => (e) => e % t === 0, pe = (t) => (e) => e.length >= t, de = (t) => (e) => e.length <= t, he = (t, e) => (n) => n.length >= t && n.length <= e, _e = (t) => (e) => e.length === t, ye = (t) => t.length > 0, me = (t) => new Set(t).size === t.length, be = (t) => (e) => {
+  const n = [...e].sort(t);
+  return e.every((r, a) => r === n[a]);
+}, ge = (t) => (e) => e.every(t), we = (t) => (e) => e.some(t), Oe = (t) => (e) => t in e, ke = (t) => (e) => Object.prototype.hasOwnProperty.call(e, t), ve = (...t) => (e) => t.every((n) => n in e), je = (...t) => (e) => {
+  const n = Object.keys(e).sort(), r = [...t].sort();
+  return n.length === r.length && n.every((a, b) => a === r[b]);
+};
+function Se(...t) {
+  return ((e) => t.some((n) => n(e)));
+}
+function Ae(...t) {
+  return ((e) => t.every((n) => n(e)));
+}
+const Ee = (t, e) => (n) => {
+  if (typeof n != "object" || n === null) return !1;
+  const a = n[t], b = e[a];
+  return b?.(n) ?? !1;
+}, $e = (t) => (e) => I(e) && e.every(t), Me = (t) => (e) => {
+  if (!S(e)) return !1;
+  for (const n in t)
+    if (!(n in e) || !t[n](e[n])) return !1;
+  return !0;
+}, Ie = (t, e, n = !1) => (r) => W(r) && r >= t && r <= e && (!n || nt(r)), Ne = (t) => W(t) && nt(t) && t >= 0, p = (t) => t == null || t === F, Ve = () => new s().that(P), Re = () => new s().that(W), We = () => new s().that(U), xe = () => new s().that(Z), De = () => new s().that(B), Fe = () => new s().that(K), Pe = () => new s().that(S), qe = () => new s().that(I), ze = () => new s().that(it), Te = () => new s().that(ct), Ue = () => new s().that(L), Ze = () => new s().that(ft), Be = () => new s().that(G), Ke = () => new s().that(X), Le = () => new s().that(Y), Ge = () => new s().that(q), Xe = () => new s().that(z), Ye = () => new s().that(C), Ce = () => new s().that(H), He = () => new s().that(J), Je = () => new s().that(Q), Qe = () => new s().that(tt), tn = (...t) => new s().that(et(...t)), en = () => new s().that(lt), nn = () => new s().that(ut), sn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(P);
+}, on = (...t) => {
+  const e = new s();
+  return u(e).off(p, void 0).that(
+    et(...t)
+  );
+}, an = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(W);
+}, rn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(U);
+}, cn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(Z);
+}, fn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(B);
+}, ln = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(K);
+}, un = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(S);
+}, pn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(I);
+}, dn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(G);
+}, hn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(X);
+}, _n = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(Y);
+}, yn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(q);
+}, mn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(z);
+}, bn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(C);
+}, gn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(H);
+}, wn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(J);
+}, On = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(Q);
+}, kn = (t = void 0) => {
+  const e = new s();
+  return u(e).off(p, t).that(tt);
+};
+function vn(t, e = void 0) {
+  const r = new s().off(p, e).toShaped(t);
+  return u(r);
+}
+function jn(t, e = void 0) {
+  const r = new s().off(p, e).toArray(t);
+  return u(r);
+}
+const dt = "Validation failed", ht = (t, e) => {
+  switch (t) {
+    case "assertion":
+      return e.extra?.message;
+    case "missing_field":
+      return `Missing required field: ${e.key}`;
+    case "not_object":
+      return `Expected an object, but got ${e.received}`;
+    case "not_array":
+      return `Expected an array, but got ${e.received}`;
+    case "unknown_field":
+      return `Unknown field(s): ${e.extra?.keys}`;
+    case "max_deep":
+      return `Maximum recursion depth ${e.depth} exceeded`;
+    case "too_many_unknown":
+      return `Too many unknown fields (limit: ${e.extra?.limit})`;
+  }
+}, D = (t) => t === null ? "null" : typeof t, A = (t, e, n, r) => (t.validation.push({ path: e.slice(), kind: n, message: r }), t.validation.length), E = (t, e, n, r) => (t.structure.push({ path: e.slice(), kind: n, detail: r }), t.structure.length), _t = (t, e, n) => {
+  const {
+    strict: r = !0,
+    abortEarly: a = !0,
+    maxDeep: b = 10,
+    maxUnknownKeys: N = 30,
+    formatMessage: m = ht
+  } = n ?? {}, V = e.Ops;
+  if (V.length === 0)
+    throw new rt(
+      "validateShape: fit.Ops is empty, did you forget to add operations?"
+    );
+  const _ = { validation: [], structure: [] };
+  let f = 0;
+  const i = [], k = (o, R, O) => {
+    for (let $ = 0; $ < R.length; $++) {
+      const y = R[$];
+      switch (y.type) {
+        // 断言检查：验证值是否满足谓词条件
+        case w.that: {
+          if (!y.predicate(o)) {
+            const d = y.message, h = d ? typeof d == "string" ? d : d(o) : dt;
+            if (A(
+              _,
+              i,
+              "assertion",
+              m("assertion", { extra: { message: h } })
+            ), f++, a) return o;
+          }
+          break;
+        }
+        // 短路处理：满足条件时提前返回默认值或原值
+        case w.off: {
+          if (y.predicate(o))
+            return "defaultValue" in y ? y.defaultValue : o;
+          break;
+        }
+        // 变换操作：对值进行转换处理
+        case w.transform: {
+          o = y.fn(o);
+          break;
+        }
+        // 对象形状校验：递归验证对象字段
+        case w.shape: {
+          if (O >= b) {
+            if (E(
+              _,
+              i,
+              "max_deep",
+              m("max_deep", { depth: b })
+            ), f++, a) return o;
+            break;
+          }
+          if (typeof o != "object" || o === null) {
+            if (A(
+              _,
+              i,
+              "not_object",
+              m("not_object", { received: D(o) })
+            ), f++, a) return o;
+            break;
+          }
+          const d = o, h = y.fields, l = {}, v = /* @__PURE__ */ new Set();
+          let g = [];
+          for (const c in d)
+            if (Object.hasOwn(d, c)) {
+              if (c in h) {
+                v.add(c), i.push(c);
+                const j = h[c], M = k(
+                  d[c],
+                  j.Ops,
+                  O + 1
+                );
+                if (a && f > 0)
+                  return i.pop(), l;
+                l[c] = M, i.pop();
+              } else if (r && (g.push(c), g.length > N && (E(
+                _,
+                i,
+                "too_many_unknown",
+                m("too_many_unknown", {
+                  extra: {
+                    limit: N,
+                    keys: g.join(", ")
+                  }
+                })
+              ), f++, g = [], a)))
+                return l;
+            }
+          if (r && g.length > 0 && f === 0 && (E(
+            _,
+            i,
+            "unknown_field",
+            m("unknown_field", {
+              extra: { keys: g.join(", ") }
+            })
+          ), f++, a))
+            return l;
+          for (const c of Object.keys(h)) {
+            if (v.has(c)) continue;
+            i.push(c);
+            const j = h[c];
+            if (!j.isOptional && (A(
+              _,
+              i,
+              "missing_field",
+              m("missing_field", { key: c })
+            ), f++, a))
+              return i.pop(), l;
+            const M = k(F, j.Ops, O);
+            if (a && f > 0)
+              return i.pop(), l;
+            l[c] = M, i.pop();
+          }
+          o = l;
+          break;
+        }
+        // 数组校验：递归验证数组元素
+        case w.toArray: {
+          if (O >= b) {
+            if (E(
+              _,
+              i,
+              "max_deep",
+              m("max_deep", { depth: b })
+            ), f++, a) return o;
+            break;
+          }
+          if (!Array.isArray(o)) {
+            if (A(
+              _,
+              i,
+              "not_array",
+              m("not_array", { received: D(o) })
+            ), f++, a) return o;
+            break;
+          }
+          const d = y.elementFit, h = [];
+          for (let l = 0; l < o.length; l++) {
+            i.push(`[${l}]`);
+            const v = k(
+              o[l],
+              d.Ops,
+              O + 1
+            );
+            if (a && f > 0)
+              return i.pop(), h;
+            h.push(v), i.pop();
+          }
+          o = h;
+          break;
+        }
+      }
+    }
+    return o;
+  }, T = k(t, V, 0);
+  return f > 0 ? ot(_) : st(T);
+}, yt = async (t, e, n) => {
+  const {
+    strict: r = !0,
+    abortEarly: a = !0,
+    maxDeep: b = 10,
+    maxUnknownKeys: N = 30,
+    formatMessage: m = ht
+  } = n ?? {}, V = e.Ops;
+  if (V.length === 0)
+    throw new rt(
+      "validateAsync: fit.Ops is empty, did you forget to add operations?"
+    );
+  const _ = { validation: [], structure: [] };
+  let f = 0;
+  const i = [], k = async (o, R, O) => {
+    for (let $ = 0; $ < R.length; $++) {
+      const y = R[$];
+      switch (y.type) {
+        // 异步断言检查
+        case w.that: {
+          if (!await x(y.predicate(o))) {
+            const d = y.message, h = d ? typeof d == "string" ? d : await x(d(o)) : dt;
+            if (A(
+              _,
+              i,
+              "assertion",
+              m("assertion", { extra: { message: h } })
+            ), f++, a)
+              return o;
+          }
+          break;
+        }
+        // 异步短路处理
+        case w.off: {
+          if (await x(y.predicate(o)))
+            return "defaultValue" in y ? y.defaultValue : o;
+          break;
+        }
+        // 异步变换操作
+        case w.transform: {
+          o = await x(y.fn(o));
+          break;
+        }
+        // 异步对象形状校验
+        case w.shape: {
+          if (O >= b) {
+            if (E(
+              _,
+              i,
+              "max_deep",
+              m("max_deep", { depth: b })
+            ), f++, a) return o;
+            break;
+          }
+          if (typeof o != "object" || o === null) {
+            if (A(
+              _,
+              i,
+              "not_object",
+              m("not_object", { received: D(o) })
+            ), f++, a) return o;
+            break;
+          }
+          const d = o, h = y.fields, l = {}, v = /* @__PURE__ */ new Set();
+          let g = [];
+          for (const c in d)
+            if (Object.hasOwn(d, c)) {
+              if (c in h) {
+                v.add(c), i.push(c);
+                const j = h[c], M = await k(
+                  d[c],
+                  j.Ops,
+                  O + 1
+                );
+                if (a && f > 0)
+                  return i.pop(), l;
+                l[c] = M, i.pop();
+              } else if (r && (g.push(c), g.length > N && (E(
+                _,
+                i,
+                "too_many_unknown",
+                m("too_many_unknown", {
+                  extra: {
+                    limit: N,
+                    keys: g.join(", ")
+                  }
+                })
+              ), f++, g = [], a)))
+                return l;
+            }
+          if (r && g.length > 0 && f === 0 && (E(
+            _,
+            i,
+            "unknown_field",
+            m("unknown_field", {
+              extra: { keys: g.join(", ") }
+            })
+          ), f++, a))
+            return l;
+          for (const c of Object.keys(h)) {
+            if (v.has(c)) continue;
+            i.push(c);
+            const j = h[c];
+            if (!j.isOptional && (A(
+              _,
+              i,
+              "missing_field",
+              m("missing_field", { key: c })
+            ), f++, a))
+              return i.pop(), l;
+            const M = await k(F, j.Ops, O);
+            if (a && f > 0)
+              return i.pop(), l;
+            l[c] = M, i.pop();
+          }
+          o = l;
+          break;
+        }
+        // 异步数组校验
+        case w.toArray: {
+          if (O >= b) {
+            if (E(
+              _,
+              i,
+              "max_deep",
+              m("max_deep", { depth: b })
+            ), f++, a) return o;
+            break;
+          }
+          if (!Array.isArray(o)) {
+            if (A(
+              _,
+              i,
+              "not_array",
+              m("not_array", { received: D(o) })
+            ), f++, a) return o;
+            break;
+          }
+          const d = y.elementFit, h = [];
+          for (let l = 0; l < o.length; l++) {
+            i.push(`[${l}]`);
+            const v = await k(
+              o[l],
+              d.Ops,
+              O + 1
+            );
+            if (a && f > 0)
+              return i.pop(), h;
+            h.push(v), i.pop();
+          }
+          o = h;
+          break;
+        }
+      }
+    }
+    return o;
+  }, T = await k(t, V, 0);
+  return f > 0 ? ot(_) : st(T);
+}, mt = "fit-schema", Sn = /^\d+$/, bt = (t) => {
+  const e = t.length;
+  if (e === 0) return [];
+  const n = new Array(e);
+  for (let r = 0; r < e; r++) {
+    const a = t[r];
+    if (a[0] === "[" && a[a.length - 1] === "]") {
+      const b = a.slice(1, -1);
+      if (Sn.test(b)) {
+        n[r] = { key: Number(b) };
+        continue;
+      }
+    }
+    n[r] = a;
+  }
+  return n;
+}, An = (t) => {
+  const e = [];
+  for (const n of t)
+    e.push({
+      message: n.message,
+      path: bt(n.path)
+    });
+  return e;
+}, En = (t) => {
+  const e = [];
+  for (const n of t)
+    e.push({
+      message: n.detail,
+      path: bt(n.path)
+    });
+  return e;
+}, gt = (t) => [
+  ...An(t.validation),
+  ...En(t.structure)
+], $n = (t) => ({
+  "~standard": {
+    version: 1,
+    vendor: mt,
+    types: {
+      input: void 0,
+      output: void 0
+    },
+    validate: (n, r) => {
+      const a = _t(n, t);
+      return at(a) ? { issues: gt(a.error) } : { value: a.value };
+    }
+  }
+}), Mn = (t) => ({
+  "~standard": {
+    version: 1,
+    vendor: mt,
+    types: {
+      input: void 0,
+      output: void 0
+    },
+    validate: async (n, r) => {
+      const a = await yt(n, t);
+      return at(a) ? { issues: gt(a.error) } : { value: a.value };
+    }
+  }
+}), Rn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Array: qe,
+  ArrayOpt: pn,
+  AsyncIterable: Qe,
+  AsyncIterableOpt: kn,
+  Bigint: De,
+  BigintOpt: fn,
+  Boolean: We,
+  BooleanOpt: rn,
+  Date: Be,
+  DateOpt: dn,
+  Error: Le,
+  ErrorOpt: _n,
+  Falsy: nn,
+  Fit: s,
+  Function: Fe,
+  FunctionOpt: ln,
+  ItemsOpt: jn,
+  Iterable: Je,
+  IterableOpt: On,
+  Map: Ge,
+  MapOpt: yn,
+  Null: Te,
+  Nullish: Ue,
+  Number: Re,
+  NumberOpt: an,
+  Object: Pe,
+  ObjectOpt: un,
+  OneOf: tn,
+  OneOfOpt: on,
+  PlainObject: He,
+  PlainObjectOpt: wn,
+  Primitive: Ze,
+  RegExp: Ke,
+  RegExpOpt: hn,
+  Set: Xe,
+  SetOpt: mn,
+  ShapeOpt: vn,
+  String: Ve,
+  StringOpt: sn,
+  Symbol: xe,
+  SymbolOpt: cn,
+  Truthy: en,
+  Undefined: ze,
+  Void: F,
+  WeakMap: Ye,
+  WeakMapOpt: bn,
+  WeakSet: Ce,
+  WeakSetOpt: gn,
+  alpha_string: Lt,
+  alphanumeric_string: Gt,
+  and: Ae,
+  arr_len: _e,
+  arr_len_range: he,
+  arr_max_len: de,
+  arr_min_len: pe,
+  array: I,
+  arrayOf: $e,
+  asyncIterable: tt,
+  between: Vt,
+  betweenInclusive: Rt,
+  bigint: B,
+  boolean: U,
+  date: G,
+  discriminatedUnion: Ee,
+  email: Yt,
+  empty: pt,
+  ends_with: Tt,
+  eq: At,
+  error: Y,
+  even: fe,
+  every: ge,
+  exact_keys: je,
+  falsy: ut,
+  finite: ie,
+  fit: Ot,
+  function: K,
+  gt: $t,
+  gte: Mt,
+  has_key: Oe,
+  has_own: ke,
+  hex_color: Jt,
+  includes: Ut,
+  instanceOf: xt,
+  integer: nt,
+  iso_datetime: Xt,
+  items: vt,
+  iterable: Q,
+  keys: ve,
+  len_range: Pt,
+  lt: It,
+  lte: Nt,
+  map: q,
+  matches: qt,
+  max: te,
+  max_len: Ft,
+  min: Qt,
+  min_len: Dt,
+  multiple_of: ue,
+  nan: ce,
+  negative: oe,
+  neq: Et,
+  nonEmpty: St,
+  nonNegativeInt: Ne,
+  non_empty_array: ye,
+  non_empty_string: Bt,
+  non_negative: re,
+  non_positive: ae,
+  notOneOf: Wt,
+  null: ct,
+  nullish: L,
+  numRange: Ie,
+  number: W,
+  numeric_string: Kt,
+  object: S,
+  objectShape: Me,
+  odd: le,
+  oneOf: et,
+  optionality: p,
+  plainObject: J,
+  positive: se,
+  primitive: ft,
+  range: ee,
+  record: jt,
+  regexp: X,
+  safe_integer: ne,
+  set: z,
+  shape: kt,
+  some: we,
+  sorted: be,
+  starts_with: zt,
+  string: P,
+  symbol: Z,
+  toOptional: u,
+  toReadonly: wt,
+  toStandardSchema: $n,
+  toStandardSchemaAsync: Mn,
+  trimmed: Zt,
+  truthy: lt,
+  type: w,
+  undefined: it,
+  union: Se,
+  unique: me,
+  url: Ct,
+  uuid: Ht,
+  validate: _t,
+  validateAsync: yt,
+  weakMap: C,
+  weakSet: H
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  qe as Array,
+  pn as ArrayOpt,
+  Qe as AsyncIterable,
+  kn as AsyncIterableOpt,
+  De as Bigint,
+  fn as BigintOpt,
+  We as Boolean,
+  rn as BooleanOpt,
+  Be as Date,
+  dn as DateOpt,
+  Le as Error,
+  _n as ErrorOpt,
+  nn as Falsy,
+  s as Fit,
+  Fe as Function,
+  ln as FunctionOpt,
+  jn as ItemsOpt,
+  Je as Iterable,
+  On as IterableOpt,
+  Ge as Map,
+  yn as MapOpt,
+  Te as Null,
+  Ue as Nullish,
+  Re as Number,
+  an as NumberOpt,
+  Pe as Object,
+  un as ObjectOpt,
+  tn as OneOf,
+  on as OneOfOpt,
+  He as PlainObject,
+  wn as PlainObjectOpt,
+  Ze as Primitive,
+  Ke as RegExp,
+  hn as RegExpOpt,
+  Xe as Set,
+  mn as SetOpt,
+  vn as ShapeOpt,
+  Ve as String,
+  sn as StringOpt,
+  xe as Symbol,
+  cn as SymbolOpt,
+  en as Truthy,
+  ze as Undefined,
+  F as Void,
+  Ye as WeakMap,
+  bn as WeakMapOpt,
+  Ce as WeakSet,
+  gn as WeakSetOpt,
+  Rn as _,
+  Lt as alpha_string,
+  Gt as alphanumeric_string,
+  Ae as and,
+  _e as arr_len,
+  he as arr_len_range,
+  de as arr_max_len,
+  pe as arr_min_len,
+  I as array,
+  $e as arrayOf,
+  tt as asyncIterable,
+  Vt as between,
+  Rt as betweenInclusive,
+  B as bigint,
+  U as boolean,
+  G as date,
+  Ee as discriminatedUnion,
+  Yt as email,
+  pt as empty,
+  Tt as ends_with,
+  At as eq,
+  Y as error,
+  fe as even,
+  ge as every,
+  je as exact_keys,
+  ut as falsy,
+  ie as finite,
+  Ot as fit,
+  K as function,
+  $t as gt,
+  Mt as gte,
+  Oe as has_key,
+  ke as has_own,
+  Jt as hex_color,
+  Ut as includes,
+  xt as instanceOf,
+  nt as integer,
+  Xt as iso_datetime,
+  vt as items,
+  Q as iterable,
+  ve as keys,
+  Pt as len_range,
+  It as lt,
+  Nt as lte,
+  q as map,
+  qt as matches,
+  te as max,
+  Ft as max_len,
+  Qt as min,
+  Dt as min_len,
+  ue as multiple_of,
+  ce as nan,
+  oe as negative,
+  Et as neq,
+  St as nonEmpty,
+  Ne as nonNegativeInt,
+  ye as non_empty_array,
+  Bt as non_empty_string,
+  re as non_negative,
+  ae as non_positive,
+  Wt as notOneOf,
+  ct as null,
+  L as nullish,
+  Ie as numRange,
+  W as number,
+  Kt as numeric_string,
+  S as object,
+  Me as objectShape,
+  le as odd,
+  et as oneOf,
+  p as optionality,
+  J as plainObject,
+  se as positive,
+  ft as primitive,
+  ee as range,
+  jt as record,
+  X as regexp,
+  ne as safe_integer,
+  z as set,
+  kt as shape,
+  we as some,
+  be as sorted,
+  zt as starts_with,
+  P as string,
+  Z as symbol,
+  u as toOptional,
+  wt as toReadonly,
+  $n as toStandardSchema,
+  Mn as toStandardSchemaAsync,
+  Zt as trimmed,
+  lt as truthy,
+  w as type,
+  it as undefined,
+  Se as union,
+  me as unique,
+  Ct as url,
+  Ht as uuid,
+  _t as validate,
+  yt as validateAsync,
+  C as weakMap,
+  H as weakSet
+};
+//# sourceMappingURL=Fit.mjs.map