Size discrepancy in import types
创建于 差异永不过期
var c, h, v, m;
var f;
function g(e) {
function v(e) {
return {
return {
lang: e?.lang ?? c?.lang,
lang: e?.lang ?? f?.lang,
message: e?.message,
message: e?.message,
abortEarly: e?.abortEarly ?? c?.abortEarly,
abortEarly: e?.abortEarly ?? f?.abortEarly,
abortPipeEarly: e?.abortPipeEarly ?? c?.abortPipeEarly,
abortPipeEarly: e?.abortPipeEarly ?? f?.abortPipeEarly,
};
};
}
}
var m;
function k(e) {
function k(e) {
return h?.get(e);
return m?.get(e);
}
}
function b(e) {
var g;
return v?.get(e);
function d(e) {
return g?.get(e);
}
}
function x(e, t) {
var b;
return m?.get(e)?.get(t);
function x(e, n) {
return b?.get(e)?.get(n);
}
}
function E(e) {
function E(e) {
let t = typeof e;
let n = typeof e;
return t === "string"
return n === "string"
? `"${e}"`
? `"${e}"`
: t === "number" || t === "bigint" || t === "boolean"
: n === "number" || n === "bigint" || n === "boolean"
? `${e}`
? `${e}`
: t === "object" || t === "function"
: n === "object" || n === "function"
? (e && Object.getPrototypeOf(e)?.constructor?.name) ?? "null"
? (e && Object.getPrototypeOf(e)?.constructor?.name) ?? "null"
: t;
: n;
}
}
function f(e, t, n, a, s) {
function a(e, n, r, t, i) {
let p = s && "input" in s ? s.input : n.value,
let o = i && "input" in i ? i.input : r.value,
u = s?.expected ?? e.expects ?? null,
l = i?.expected ?? e.expects ?? null,
d = s?.received ?? E(p),
c = i?.received ?? E(o),
r = {
s = {
kind: e.kind,
kind: e.kind,
type: e.type,
type: e.type,
input: p,
input: o,
expected: u,
expected: l,
received: d,
received: c,
message: `Invalid ${t}: ${u ? `Expected ${u} but r` : "R"}eceived ${d}`,
message: `Invalid ${n}: ${l ? `Expected ${l} but r` : "R"}eceived ${c}`,
requirement: e.requirement,
requirement: e.requirement,
path: s?.path,
path: i?.path,
issues: s?.issues,
issues: i?.issues,
lang: a.lang,
lang: t.lang,
abortEarly: a.abortEarly,
abortEarly: t.abortEarly,
abortPipeEarly: a.abortPipeEarly,
abortPipeEarly: t.abortPipeEarly,
},
},
y = e.kind === "schema",
p = e.kind === "schema",
i =
u =
s?.message ??
i?.message ??
e.message ??
e.message ??
x(e.reference, r.lang) ??
x(e.reference, s.lang) ??
(y ? b(r.lang) : null) ??
(p ? d(s.lang) : null) ??
a.message ??
t.message ??
k(r.lang);
k(s.lang);
i !== void 0 && (r.message = typeof i == "function" ? i(r) : i),
u !== void 0 && (s.message = typeof u == "function" ? u(s) : u),
y && (n.typed = !1),
p && (r.typed = !1),
n.issues ? n.issues.push(r) : (n.issues = [r]);
r.issues ? r.issues.push(s) : (r.issues = [s]);
}
}
function _(e) {
function _(e) {
return {
return {
version: 1,
version: 1,
vendor: "valibot",
vendor: "valibot",
validate: (t) => e["~run"]({ value: t }, g()),
validate(n) {
return e["~run"]({ value: n }, v());
},
};
};
}
}
var w = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
var w = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
function o(e) {
function y(e) {
return {
return {
kind: "validation",
kind: "validation",
type: "email",
type: "email",
reference: o,
reference: y,
expects: null,
expects: null,
async: !1,
async: !1,
requirement: w,
requirement: w,
message: e,
message: e,
"~run"(t, n) {
"~run"(n, r) {
return (
return (
t.typed && !this.requirement.test(t.value) && f(this, "email", t, n), t
n.typed && !this.requirement.test(n.value) && a(this, "email", n, r), n
);
);
},
},
};
};
}
}
function l(e) {
function h(e) {
return {
return {
kind: "schema",
kind: "schema",
type: "string",
type: "string",
reference: l,
reference: h,
expects: "string",
expects: "string",
async: !1,
async: !1,
message: e,
message: e,
get "~standard"() {
get "~standard"() {
return _(this);
return _(this);
},
},
"~run"(t, n) {
"~run"(n, r) {
return (
return (
typeof t.value == "string" ? (t.typed = !0) : f(this, "type", t, n), t
typeof n.value == "string" ? (n.typed = !0) : a(this, "type", n, r), n
);
);
},
},
};
};
}
}
var $ = l,
export { y as email, h as string };
A = o;
export { A as email, $ as string };