1154 lines
38 KiB
JavaScript
1154 lines
38 KiB
JavaScript
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
|
|
[3462],
|
|
{
|
|
63325: function (e, r, t) {
|
|
"use strict";
|
|
t.d(r, {
|
|
Z: function () {
|
|
return C;
|
|
},
|
|
});
|
|
var n,
|
|
i = t(14224);
|
|
function u() {
|
|
return (u = Object.assign
|
|
? Object.assign.bind()
|
|
: function (e) {
|
|
for (var r = 1; r < arguments.length; r++) {
|
|
var t = arguments[r];
|
|
for (var n in t)
|
|
Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
|
|
}
|
|
return e;
|
|
}).apply(this, arguments);
|
|
}
|
|
function o(e) {
|
|
return (o = Object.setPrototypeOf
|
|
? Object.getPrototypeOf.bind()
|
|
: function (e) {
|
|
return e.__proto__ || Object.getPrototypeOf(e);
|
|
})(e);
|
|
}
|
|
function a(e, r) {
|
|
return (a = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (e, r) {
|
|
return (e.__proto__ = r), e;
|
|
})(e, r);
|
|
}
|
|
function s(e, r, t) {
|
|
return (s = !(function () {
|
|
if (
|
|
"undefined" == typeof Reflect ||
|
|
!Reflect.construct ||
|
|
Reflect.construct.sham
|
|
)
|
|
return !1;
|
|
if ("function" == typeof Proxy) return !0;
|
|
try {
|
|
return (
|
|
Boolean.prototype.valueOf.call(
|
|
Reflect.construct(Boolean, [], function () {})
|
|
),
|
|
!0
|
|
);
|
|
} catch (e) {
|
|
return !1;
|
|
}
|
|
})()
|
|
? function (e, r, t) {
|
|
var n = [null];
|
|
n.push.apply(n, r);
|
|
var i = new (Function.bind.apply(e, n))();
|
|
return t && a(i, t.prototype), i;
|
|
}
|
|
: Reflect.construct.bind()).apply(null, arguments);
|
|
}
|
|
function f(e) {
|
|
var r = "function" == typeof Map ? new Map() : void 0;
|
|
return (f = function (e) {
|
|
var t;
|
|
if (
|
|
null === e ||
|
|
-1 === Function.toString.call(e).indexOf("[native code]")
|
|
)
|
|
return e;
|
|
if ("function" != typeof e)
|
|
throw TypeError(
|
|
"Super expression must either be null or a function"
|
|
);
|
|
if (void 0 !== r) {
|
|
if (r.has(e)) return r.get(e);
|
|
r.set(e, n);
|
|
}
|
|
function n() {
|
|
return s(e, arguments, o(this).constructor);
|
|
}
|
|
return (
|
|
(n.prototype = Object.create(e.prototype, {
|
|
constructor: {
|
|
value: n,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
configurable: !0,
|
|
},
|
|
})),
|
|
a(n, e)
|
|
);
|
|
})(e);
|
|
}
|
|
var l = /%[sdj%]/g,
|
|
c = function () {};
|
|
function p(e) {
|
|
if (!e || !e.length) return null;
|
|
var r = {};
|
|
return (
|
|
e.forEach(function (e) {
|
|
var t = e.field;
|
|
(r[t] = r[t] || []), r[t].push(e);
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
function d(e) {
|
|
for (
|
|
var r = arguments.length, t = Array(r > 1 ? r - 1 : 0), n = 1;
|
|
n < r;
|
|
n++
|
|
)
|
|
t[n - 1] = arguments[n];
|
|
var i = 0,
|
|
u = t.length;
|
|
return "function" == typeof e
|
|
? e.apply(null, t)
|
|
: "string" == typeof e
|
|
? e.replace(l, function (e) {
|
|
if ("%%" === e) return "%";
|
|
if (i >= u) return e;
|
|
switch (e) {
|
|
case "%s":
|
|
return String(t[i++]);
|
|
case "%d":
|
|
return Number(t[i++]);
|
|
case "%j":
|
|
try {
|
|
return JSON.stringify(t[i++]);
|
|
} catch (r) {
|
|
return "[Circular]";
|
|
}
|
|
break;
|
|
default:
|
|
return e;
|
|
}
|
|
})
|
|
: e;
|
|
}
|
|
function y(e, r) {
|
|
var t;
|
|
return (
|
|
!!(null == e || ("array" === r && Array.isArray(e) && !e.length)) ||
|
|
(("string" === r ||
|
|
"url" === r ||
|
|
"hex" === r ||
|
|
"email" === r ||
|
|
"date" === r ||
|
|
"pattern" === r) &&
|
|
"string" == typeof e &&
|
|
!e)
|
|
);
|
|
}
|
|
function h(e, r, t) {
|
|
var n = 0,
|
|
i = e.length;
|
|
!(function u(o) {
|
|
if (o && o.length) {
|
|
t(o);
|
|
return;
|
|
}
|
|
(n += 1) < i ? r(e[n], u) : t([]);
|
|
})([]);
|
|
}
|
|
void 0 !== i && i.env;
|
|
var g = (function (e) {
|
|
var r, t;
|
|
function n(r, t) {
|
|
var n;
|
|
return (
|
|
((n = e.call(this, "Async Validation Error") || this).errors = r),
|
|
(n.fields = t),
|
|
n
|
|
);
|
|
}
|
|
return (
|
|
((r = n).prototype = Object.create(e.prototype)),
|
|
(r.prototype.constructor = r),
|
|
a(r, e),
|
|
n
|
|
);
|
|
})(f(Error));
|
|
function v(e, r) {
|
|
return function (t) {
|
|
var n, i;
|
|
return ((n = e.fullFields
|
|
? (function (e, r) {
|
|
for (var t = e, n = 0; n < r.length && void 0 != t; n++)
|
|
t = t[r[n]];
|
|
return t;
|
|
})(r, e.fullFields)
|
|
: r[t.field || e.fullField]),
|
|
t && void 0 !== t.message)
|
|
? ((t.field = t.field || e.fullField), (t.fieldValue = n), t)
|
|
: {
|
|
message: "function" == typeof t ? t() : t,
|
|
fieldValue: n,
|
|
field: t.field || e.fullField,
|
|
};
|
|
};
|
|
}
|
|
function m(e, r) {
|
|
if (r) {
|
|
for (var t in r)
|
|
if (r.hasOwnProperty(t)) {
|
|
var n = r[t];
|
|
"object" == typeof n && "object" == typeof e[t]
|
|
? (e[t] = u({}, e[t], n))
|
|
: (e[t] = n);
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
var b,
|
|
x,
|
|
q,
|
|
O,
|
|
F,
|
|
w,
|
|
j,
|
|
A,
|
|
_,
|
|
E = function (e, r, t, n, i, u) {
|
|
e.required &&
|
|
(!t.hasOwnProperty(e.field) || y(r, u || e.type)) &&
|
|
n.push(d(i.messages.required, e.fullField));
|
|
},
|
|
P = function () {
|
|
if (n) return n;
|
|
var e = "[a-fA-F\\d:]",
|
|
r = function (r) {
|
|
return r && r.includeBoundaries
|
|
? "(?:(?<=\\s|^)(?=" + e + ")|(?<=" + e + ")(?=\\s|$))"
|
|
: "";
|
|
},
|
|
t =
|
|
"(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}",
|
|
i = "[a-fA-F\\d]{1,4}",
|
|
u = (
|
|
"\n(?:\n(?:" +
|
|
i +
|
|
":){7}(?:" +
|
|
i +
|
|
"|:)| // 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8\n(?:" +
|
|
i +
|
|
":){6}(?:" +
|
|
t +
|
|
"|:" +
|
|
i +
|
|
"|:)| // 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::1.2.3.4\n(?:" +
|
|
i +
|
|
":){5}(?::" +
|
|
t +
|
|
"|(?::" +
|
|
i +
|
|
"){1,2}|:)| // 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::7:1.2.3.4\n(?:" +
|
|
i +
|
|
":){4}(?:(?::" +
|
|
i +
|
|
"){0,1}:" +
|
|
t +
|
|
"|(?::" +
|
|
i +
|
|
"){1,3}|:)| // 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::6:7:1.2.3.4\n(?:" +
|
|
i +
|
|
":){3}(?:(?::" +
|
|
i +
|
|
"){0,2}:" +
|
|
t +
|
|
"|(?::" +
|
|
i +
|
|
"){1,4}|:)| // 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::5:6:7:1.2.3.4\n(?:" +
|
|
i +
|
|
":){2}(?:(?::" +
|
|
i +
|
|
"){0,3}:" +
|
|
t +
|
|
"|(?::" +
|
|
i +
|
|
"){1,5}|:)| // 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::4:5:6:7:1.2.3.4\n(?:" +
|
|
i +
|
|
":){1}(?:(?::" +
|
|
i +
|
|
"){0,4}:" +
|
|
t +
|
|
"|(?::" +
|
|
i +
|
|
"){1,6}|:)| // 1:: 1::3:4:5:6:7:8 1::8 1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" +
|
|
i +
|
|
"){0,5}:" +
|
|
t +
|
|
"|(?::" +
|
|
i +
|
|
"){1,7}|:)) // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})? // %eth0 %1\n"
|
|
)
|
|
.replace(/\s*\/\/.*$/gm, "")
|
|
.replace(/\n/g, "")
|
|
.trim(),
|
|
o = RegExp("(?:^" + t + "$)|(?:^" + u + "$)"),
|
|
a = RegExp("^" + t + "$"),
|
|
s = RegExp("^" + u + "$"),
|
|
f = function (e) {
|
|
return e && e.exact
|
|
? o
|
|
: RegExp(
|
|
"(?:" + r(e) + t + r(e) + ")|(?:" + r(e) + u + r(e) + ")",
|
|
"g"
|
|
);
|
|
};
|
|
(f.v4 = function (e) {
|
|
return e && e.exact ? a : RegExp("" + r(e) + t + r(e), "g");
|
|
}),
|
|
(f.v6 = function (e) {
|
|
return e && e.exact ? s : RegExp("" + r(e) + u + r(e), "g");
|
|
});
|
|
var l,
|
|
c = f.v4().source;
|
|
return (n = RegExp(
|
|
"(?:^" +
|
|
("(?:(?:(?:[a-z]+:)?//)|www\\.)(?:\\S+(?::\\S*)?@)?(?:localhost|" +
|
|
c +
|
|
"|" +
|
|
f.v6().source) +
|
|
'|(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))(?::\\d{2,5})?(?:[/?#][^\\s"]*)?$)',
|
|
"i"
|
|
));
|
|
},
|
|
k = {
|
|
email:
|
|
/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
|
|
hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
|
|
},
|
|
M = {
|
|
integer: function (e) {
|
|
return M.number(e) && parseInt(e, 10) === e;
|
|
},
|
|
float: function (e) {
|
|
return M.number(e) && !M.integer(e);
|
|
},
|
|
array: function (e) {
|
|
return Array.isArray(e);
|
|
},
|
|
regexp: function (e) {
|
|
if (e instanceof RegExp) return !0;
|
|
try {
|
|
return RegExp(e), !0;
|
|
} catch (r) {
|
|
return !1;
|
|
}
|
|
},
|
|
date: function (e) {
|
|
return (
|
|
"function" == typeof e.getTime &&
|
|
"function" == typeof e.getMonth &&
|
|
"function" == typeof e.getYear &&
|
|
!isNaN(e.getTime())
|
|
);
|
|
},
|
|
number: function (e) {
|
|
return !isNaN(e) && "number" == typeof e;
|
|
},
|
|
object: function (e) {
|
|
return "object" == typeof e && !M.array(e);
|
|
},
|
|
method: function (e) {
|
|
return "function" == typeof e;
|
|
},
|
|
email: function (e) {
|
|
return (
|
|
"string" == typeof e && e.length <= 320 && !!e.match(k.email)
|
|
);
|
|
},
|
|
url: function (e) {
|
|
return "string" == typeof e && e.length <= 2048 && !!e.match(P());
|
|
},
|
|
hex: function (e) {
|
|
return "string" == typeof e && !!e.match(k.hex);
|
|
},
|
|
},
|
|
R = function (e, r, t, n, i) {
|
|
if (e.required && void 0 === r) {
|
|
E(e, r, t, n, i);
|
|
return;
|
|
}
|
|
var u = e.type;
|
|
[
|
|
"integer",
|
|
"float",
|
|
"array",
|
|
"regexp",
|
|
"object",
|
|
"method",
|
|
"email",
|
|
"number",
|
|
"date",
|
|
"url",
|
|
"hex",
|
|
].indexOf(u) > -1
|
|
? M[u](r) || n.push(d(i.messages.types[u], e.fullField, e.type))
|
|
: u &&
|
|
typeof r !== e.type &&
|
|
n.push(d(i.messages.types[u], e.fullField, e.type));
|
|
},
|
|
S = "enum",
|
|
Z = {
|
|
required: E,
|
|
whitespace: function (e, r, t, n, i) {
|
|
(/^\s+$/.test(r) || "" === r) &&
|
|
n.push(d(i.messages.whitespace, e.fullField));
|
|
},
|
|
type: R,
|
|
range: function (e, r, t, n, i) {
|
|
var u = "number" == typeof e.len,
|
|
o = "number" == typeof e.min,
|
|
a = "number" == typeof e.max,
|
|
s = r,
|
|
f = null,
|
|
l = "string" == typeof r,
|
|
c = Array.isArray(r);
|
|
if (
|
|
("number" == typeof r
|
|
? (f = "number")
|
|
: l
|
|
? (f = "string")
|
|
: c && (f = "array"),
|
|
!f)
|
|
)
|
|
return !1;
|
|
c && (s = r.length),
|
|
l &&
|
|
(s = r.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "_").length),
|
|
u
|
|
? s !== e.len &&
|
|
n.push(d(i.messages[f].len, e.fullField, e.len))
|
|
: o && !a && s < e.min
|
|
? n.push(d(i.messages[f].min, e.fullField, e.min))
|
|
: a && !o && s > e.max
|
|
? n.push(d(i.messages[f].max, e.fullField, e.max))
|
|
: o &&
|
|
a &&
|
|
(s < e.min || s > e.max) &&
|
|
n.push(d(i.messages[f].range, e.fullField, e.min, e.max));
|
|
},
|
|
enum: function (e, r, t, n, i) {
|
|
(e[S] = Array.isArray(e[S]) ? e[S] : []),
|
|
-1 === e[S].indexOf(r) &&
|
|
n.push(d(i.messages[S], e.fullField, e[S].join(", ")));
|
|
},
|
|
pattern: function (e, r, t, n, i) {
|
|
e.pattern &&
|
|
(e.pattern instanceof RegExp
|
|
? ((e.pattern.lastIndex = 0),
|
|
e.pattern.test(r) ||
|
|
n.push(
|
|
d(i.messages.pattern.mismatch, e.fullField, r, e.pattern)
|
|
))
|
|
: "string" == typeof e.pattern &&
|
|
(RegExp(e.pattern).test(r) ||
|
|
n.push(
|
|
d(i.messages.pattern.mismatch, e.fullField, r, e.pattern)
|
|
)));
|
|
},
|
|
},
|
|
D = function (e, r, t, n, i) {
|
|
var u = e.type,
|
|
o = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r, u) && !e.required) return t();
|
|
Z.required(e, r, n, o, i, u), y(r, u) || Z.type(e, r, n, o, i);
|
|
}
|
|
t(o);
|
|
},
|
|
$ = {
|
|
string: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r, "string") && !e.required) return t();
|
|
Z.required(e, r, n, u, i, "string"),
|
|
y(r, "string") ||
|
|
(Z.type(e, r, n, u, i),
|
|
Z.range(e, r, n, u, i),
|
|
Z.pattern(e, r, n, u, i),
|
|
!0 === e.whitespace && Z.whitespace(e, r, n, u, i));
|
|
}
|
|
t(u);
|
|
},
|
|
method: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i), void 0 !== r && Z.type(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
number: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (("" === r && (r = void 0), y(r) && !e.required)) return t();
|
|
Z.required(e, r, n, u, i),
|
|
void 0 !== r && (Z.type(e, r, n, u, i), Z.range(e, r, n, u, i));
|
|
}
|
|
t(u);
|
|
},
|
|
boolean: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i), void 0 !== r && Z.type(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
regexp: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i), y(r) || Z.type(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
integer: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i),
|
|
void 0 !== r && (Z.type(e, r, n, u, i), Z.range(e, r, n, u, i));
|
|
}
|
|
t(u);
|
|
},
|
|
float: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i),
|
|
void 0 !== r && (Z.type(e, r, n, u, i), Z.range(e, r, n, u, i));
|
|
}
|
|
t(u);
|
|
},
|
|
array: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (null == r && !e.required) return t();
|
|
Z.required(e, r, n, u, i, "array"),
|
|
null != r && (Z.type(e, r, n, u, i), Z.range(e, r, n, u, i));
|
|
}
|
|
t(u);
|
|
},
|
|
object: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i), void 0 !== r && Z.type(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
enum: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i), void 0 !== r && Z.enum(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
pattern: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r, "string") && !e.required) return t();
|
|
Z.required(e, r, n, u, i),
|
|
y(r, "string") || Z.pattern(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
date: function (e, r, t, n, i) {
|
|
var u,
|
|
o = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r, "date") && !e.required) return t();
|
|
Z.required(e, r, n, o, i),
|
|
!y(r, "date") &&
|
|
((u = r instanceof Date ? r : new Date(r)),
|
|
Z.type(e, u, n, o, i),
|
|
u && Z.range(e, u.getTime(), n, o, i));
|
|
}
|
|
t(o);
|
|
},
|
|
url: D,
|
|
hex: D,
|
|
email: D,
|
|
required: function (e, r, t, n, i) {
|
|
var u = [],
|
|
o = Array.isArray(r) ? "array" : typeof r;
|
|
Z.required(e, r, n, u, i, o), t(u);
|
|
},
|
|
any: function (e, r, t, n, i) {
|
|
var u = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (y(r) && !e.required) return t();
|
|
Z.required(e, r, n, u, i);
|
|
}
|
|
t(u);
|
|
},
|
|
};
|
|
function N() {
|
|
return {
|
|
default: "Validation error on field %s",
|
|
required: "%s is required",
|
|
enum: "%s must be one of %s",
|
|
whitespace: "%s cannot be empty",
|
|
date: {
|
|
format: "%s date %s is invalid for format %s",
|
|
parse: "%s date could not be parsed, %s is invalid ",
|
|
invalid: "%s date %s is invalid",
|
|
},
|
|
types: {
|
|
string: "%s is not a %s",
|
|
method: "%s is not a %s (function)",
|
|
array: "%s is not an %s",
|
|
object: "%s is not an %s",
|
|
number: "%s is not a %s",
|
|
date: "%s is not a %s",
|
|
boolean: "%s is not a %s",
|
|
integer: "%s is not an %s",
|
|
float: "%s is not a %s",
|
|
regexp: "%s is not a valid %s",
|
|
email: "%s is not a valid %s",
|
|
url: "%s is not a valid %s",
|
|
hex: "%s is not a valid %s",
|
|
},
|
|
string: {
|
|
len: "%s must be exactly %s characters",
|
|
min: "%s must be at least %s characters",
|
|
max: "%s cannot be longer than %s characters",
|
|
range: "%s must be between %s and %s characters",
|
|
},
|
|
number: {
|
|
len: "%s must equal %s",
|
|
min: "%s cannot be less than %s",
|
|
max: "%s cannot be greater than %s",
|
|
range: "%s must be between %s and %s",
|
|
},
|
|
array: {
|
|
len: "%s must be exactly %s in length",
|
|
min: "%s cannot be less than %s in length",
|
|
max: "%s cannot be greater than %s in length",
|
|
range: "%s must be between %s and %s in length",
|
|
},
|
|
pattern: { mismatch: "%s value %s does not match pattern %s" },
|
|
clone: function () {
|
|
var e = JSON.parse(JSON.stringify(this));
|
|
return (e.clone = this.clone), e;
|
|
},
|
|
};
|
|
}
|
|
var z = N(),
|
|
C = (function () {
|
|
function e(e) {
|
|
(this.rules = null), (this._messages = z), this.define(e);
|
|
}
|
|
var r = e.prototype;
|
|
return (
|
|
(r.define = function (e) {
|
|
var r = this;
|
|
if (!e) throw Error("Cannot configure a schema with no rules");
|
|
if ("object" != typeof e || Array.isArray(e))
|
|
throw Error("Rules must be an object");
|
|
(this.rules = {}),
|
|
Object.keys(e).forEach(function (t) {
|
|
var n = e[t];
|
|
r.rules[t] = Array.isArray(n) ? n : [n];
|
|
});
|
|
}),
|
|
(r.messages = function (e) {
|
|
return e && (this._messages = m(N(), e)), this._messages;
|
|
}),
|
|
(r.validate = function (r, t, n) {
|
|
var i = this;
|
|
void 0 === t && (t = {}), void 0 === n && (n = function () {});
|
|
var o = r,
|
|
a = t,
|
|
s = n;
|
|
if (
|
|
("function" == typeof a && ((s = a), (a = {})),
|
|
!this.rules || 0 === Object.keys(this.rules).length)
|
|
)
|
|
return s && s(null, o), Promise.resolve(o);
|
|
if (a.messages) {
|
|
var f = this.messages();
|
|
f === z && (f = N()), m(f, a.messages), (a.messages = f);
|
|
} else a.messages = this.messages();
|
|
var l = {};
|
|
(a.keys || Object.keys(this.rules)).forEach(function (e) {
|
|
var t = i.rules[e],
|
|
n = o[e];
|
|
t.forEach(function (t) {
|
|
var a = t;
|
|
"function" == typeof a.transform &&
|
|
(o === r && (o = u({}, o)), (n = o[e] = a.transform(n))),
|
|
((a =
|
|
"function" == typeof a
|
|
? { validator: a }
|
|
: u({}, a)).validator = i.getValidationMethod(a)),
|
|
a.validator &&
|
|
((a.field = e),
|
|
(a.fullField = a.fullField || e),
|
|
(a.type = i.getType(a)),
|
|
(l[e] = l[e] || []),
|
|
l[e].push({ rule: a, value: n, source: o, field: e }));
|
|
});
|
|
});
|
|
var c = {};
|
|
return (function (e, r, t, n, i) {
|
|
if (r.first) {
|
|
var u = new Promise(function (r, u) {
|
|
var o,
|
|
a,
|
|
s = function (e) {
|
|
return n(e), e.length ? u(new g(e, p(e))) : r(i);
|
|
},
|
|
f =
|
|
((a = []),
|
|
Object.keys(e).forEach(function (r) {
|
|
a.push.apply(a, e[r] || []);
|
|
}),
|
|
a);
|
|
h(f, t, s);
|
|
});
|
|
return (
|
|
u.catch(function (e) {
|
|
return e;
|
|
}),
|
|
u
|
|
);
|
|
}
|
|
var o =
|
|
!0 === r.firstFields ? Object.keys(e) : r.firstFields || [],
|
|
a = Object.keys(e),
|
|
s = a.length,
|
|
f = 0,
|
|
l = [],
|
|
c = new Promise(function (r, u) {
|
|
var c = function (e) {
|
|
if ((l.push.apply(l, e), ++f === s))
|
|
return n(l), l.length ? u(new g(l, p(l))) : r(i);
|
|
};
|
|
a.length || (n(l), r(i)),
|
|
a.forEach(function (r) {
|
|
var n = e[r];
|
|
-1 !== o.indexOf(r)
|
|
? h(n, t, c)
|
|
: (function (e, r, t) {
|
|
var n = [],
|
|
i = 0,
|
|
u = e.length;
|
|
function o(e) {
|
|
n.push.apply(n, e || []), ++i === u && t(n);
|
|
}
|
|
e.forEach(function (e) {
|
|
r(e, o);
|
|
});
|
|
})(n, t, c);
|
|
});
|
|
});
|
|
return (
|
|
c.catch(function (e) {
|
|
return e;
|
|
}),
|
|
c
|
|
);
|
|
})(
|
|
l,
|
|
a,
|
|
function (r, t) {
|
|
var n,
|
|
i = r.rule,
|
|
s =
|
|
("object" === i.type || "array" === i.type) &&
|
|
("object" == typeof i.fields ||
|
|
"object" == typeof i.defaultField);
|
|
function f(e, r) {
|
|
return u({}, r, {
|
|
fullField: i.fullField + "." + e,
|
|
fullFields: i.fullFields
|
|
? [].concat(i.fullFields, [e])
|
|
: [e],
|
|
});
|
|
}
|
|
function l(n) {
|
|
void 0 === n && (n = []);
|
|
var l = Array.isArray(n) ? n : [n];
|
|
!a.suppressWarning &&
|
|
l.length &&
|
|
e.warning("async-validator:", l),
|
|
l.length &&
|
|
void 0 !== i.message &&
|
|
(l = [].concat(i.message));
|
|
var p = l.map(v(i, o));
|
|
if (a.first && p.length) return (c[i.field] = 1), t(p);
|
|
if (s) {
|
|
if (i.required && !r.value)
|
|
return (
|
|
void 0 !== i.message
|
|
? (p = [].concat(i.message).map(v(i, o)))
|
|
: a.error &&
|
|
(p = [
|
|
a.error(i, d(a.messages.required, i.field)),
|
|
]),
|
|
t(p)
|
|
);
|
|
var y = {};
|
|
i.defaultField &&
|
|
Object.keys(r.value).map(function (e) {
|
|
y[e] = i.defaultField;
|
|
});
|
|
var h = {};
|
|
Object.keys((y = u({}, y, r.rule.fields))).forEach(
|
|
function (e) {
|
|
var r = y[e],
|
|
t = Array.isArray(r) ? r : [r];
|
|
h[e] = t.map(f.bind(null, e));
|
|
}
|
|
);
|
|
var g = new e(h);
|
|
g.messages(a.messages),
|
|
r.rule.options &&
|
|
((r.rule.options.messages = a.messages),
|
|
(r.rule.options.error = a.error)),
|
|
g.validate(r.value, r.rule.options || a, function (e) {
|
|
var r = [];
|
|
p && p.length && r.push.apply(r, p),
|
|
e && e.length && r.push.apply(r, e),
|
|
t(r.length ? r : null);
|
|
});
|
|
} else t(p);
|
|
}
|
|
if (
|
|
((s = s && (i.required || (!i.required && r.value))),
|
|
(i.field = r.field),
|
|
i.asyncValidator)
|
|
)
|
|
n = i.asyncValidator(i, r.value, l, r.source, a);
|
|
else if (i.validator) {
|
|
try {
|
|
n = i.validator(i, r.value, l, r.source, a);
|
|
} catch (p) {
|
|
null == console.error || console.error(p),
|
|
a.suppressValidatorError ||
|
|
setTimeout(function () {
|
|
throw p;
|
|
}, 0),
|
|
l(p.message);
|
|
}
|
|
!0 === n
|
|
? l()
|
|
: !1 === n
|
|
? l(
|
|
"function" == typeof i.message
|
|
? i.message(i.fullField || i.field)
|
|
: i.message || (i.fullField || i.field) + " fails"
|
|
)
|
|
: n instanceof Array
|
|
? l(n)
|
|
: n instanceof Error && l(n.message);
|
|
}
|
|
n &&
|
|
n.then &&
|
|
n.then(
|
|
function () {
|
|
return l();
|
|
},
|
|
function (e) {
|
|
return l(e);
|
|
}
|
|
);
|
|
},
|
|
function (e) {
|
|
!(function (e) {
|
|
var r = [],
|
|
t = {};
|
|
function n(e) {
|
|
if (Array.isArray(e)) {
|
|
var t;
|
|
r = (t = r).concat.apply(t, e);
|
|
} else r.push(e);
|
|
}
|
|
for (var i = 0; i < e.length; i++) n(e[i]);
|
|
r.length ? ((t = p(r)), s(r, t)) : s(null, o);
|
|
})(e);
|
|
},
|
|
o
|
|
);
|
|
}),
|
|
(r.getType = function (e) {
|
|
if (
|
|
(void 0 === e.type &&
|
|
e.pattern instanceof RegExp &&
|
|
(e.type = "pattern"),
|
|
"function" != typeof e.validator &&
|
|
e.type &&
|
|
!$.hasOwnProperty(e.type))
|
|
)
|
|
throw Error(d("Unknown rule type %s", e.type));
|
|
return e.type || "string";
|
|
}),
|
|
(r.getValidationMethod = function (e) {
|
|
if ("function" == typeof e.validator) return e.validator;
|
|
var r = Object.keys(e),
|
|
t = r.indexOf("message");
|
|
return (-1 !== t && r.splice(t, 1),
|
|
1 === r.length && "required" === r[0])
|
|
? $.required
|
|
: $[this.getType(e)] || void 0;
|
|
}),
|
|
e
|
|
);
|
|
})();
|
|
(C.register = function (e, r) {
|
|
if ("function" != typeof r)
|
|
throw Error(
|
|
"Cannot register a validator by type, validator is not a function"
|
|
);
|
|
$[e] = r;
|
|
}),
|
|
(C.warning = c),
|
|
(C.messages = z),
|
|
(C.validators = $);
|
|
},
|
|
49103: function (e, r, t) {
|
|
"use strict";
|
|
function n(e, r) {
|
|
for (var t = e, n = 0; n < r.length; n += 1) {
|
|
if (null == t) return;
|
|
t = t[r[n]];
|
|
}
|
|
return t;
|
|
}
|
|
t.d(r, {
|
|
Z: function () {
|
|
return n;
|
|
},
|
|
});
|
|
},
|
|
72537: function (e, r, t) {
|
|
"use strict";
|
|
t.d(r, {
|
|
Z: function () {
|
|
return a;
|
|
},
|
|
});
|
|
var n = t(75782),
|
|
i = t(49544),
|
|
u = t(9942),
|
|
o = t(49103);
|
|
function a(e, r, t) {
|
|
var a = arguments.length > 3 && void 0 !== arguments[3] && arguments[3];
|
|
return r.length && a && void 0 === t && !(0, o.Z)(e, r.slice(0, -1))
|
|
? e
|
|
: (function e(r, t, o, a) {
|
|
if (!t.length) return o;
|
|
var s,
|
|
f = (0, u.Z)(t),
|
|
l = f[0],
|
|
c = f.slice(1);
|
|
return (
|
|
(s =
|
|
r || "number" != typeof l
|
|
? Array.isArray(r)
|
|
? (0, i.Z)(r)
|
|
: (0, n.Z)({}, r)
|
|
: []),
|
|
a && void 0 === o && 1 === c.length
|
|
? delete s[l][c[0]]
|
|
: (s[l] = e(s[l], c, o, a)),
|
|
s
|
|
);
|
|
})(e, r, t, a);
|
|
}
|
|
},
|
|
25705: function (e) {
|
|
(e.exports = function (e, r) {
|
|
(null == r || r > e.length) && (r = e.length);
|
|
for (var t = 0, n = Array(r); t < r; t++) n[t] = e[t];
|
|
return n;
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
5548: function (e) {
|
|
(e.exports = function (e) {
|
|
if (Array.isArray(e)) return e;
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
66356: function (e, r, t) {
|
|
var n = t(37635).default;
|
|
function i(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = new WeakMap(),
|
|
t = new WeakMap();
|
|
return (i = function (e) {
|
|
return e ? t : r;
|
|
})(e);
|
|
}
|
|
(e.exports = function (e, r) {
|
|
if (!r && e && e.__esModule) return e;
|
|
if (null === e || ("object" !== n(e) && "function" != typeof e))
|
|
return { default: e };
|
|
var t = i(r);
|
|
if (t && t.has(e)) return t.get(e);
|
|
var u = {},
|
|
o = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var a in e)
|
|
if ("default" !== a && Object.prototype.hasOwnProperty.call(e, a)) {
|
|
var s = o ? Object.getOwnPropertyDescriptor(e, a) : null;
|
|
s && (s.get || s.set)
|
|
? Object.defineProperty(u, a, s)
|
|
: (u[a] = e[a]);
|
|
}
|
|
return (u.default = e), t && t.set(e, u), u;
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
40790: function (e) {
|
|
(e.exports = function (e, r) {
|
|
var t =
|
|
null == e
|
|
? null
|
|
: ("undefined" != typeof Symbol && e[Symbol.iterator]) ||
|
|
e["@@iterator"];
|
|
if (null != t) {
|
|
var n,
|
|
i,
|
|
u,
|
|
o,
|
|
a = [],
|
|
s = !0,
|
|
f = !1;
|
|
try {
|
|
if (((u = (t = t.call(e)).next), 0 === r)) {
|
|
if (Object(t) !== t) return;
|
|
s = !1;
|
|
} else
|
|
for (
|
|
;
|
|
!(s = (n = u.call(t)).done) &&
|
|
(a.push(n.value), a.length !== r);
|
|
s = !0
|
|
);
|
|
} catch (l) {
|
|
(f = !0), (i = l);
|
|
} finally {
|
|
try {
|
|
if (!s && null != t.return && ((o = t.return()), Object(o) !== o))
|
|
return;
|
|
} finally {
|
|
if (f) throw i;
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
15324: function (e) {
|
|
(e.exports = function () {
|
|
throw TypeError(
|
|
"Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
|
|
);
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
54306: function (e, r, t) {
|
|
var n = t(5548),
|
|
i = t(40790),
|
|
u = t(41442),
|
|
o = t(15324);
|
|
(e.exports = function (e, r) {
|
|
return n(e) || i(e, r) || u(e, r) || o();
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
37635: function (e) {
|
|
function r(t) {
|
|
return (
|
|
(e.exports = r =
|
|
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
|
|
? function (e) {
|
|
return typeof e;
|
|
}
|
|
: function (e) {
|
|
return e &&
|
|
"function" == typeof Symbol &&
|
|
e.constructor === Symbol &&
|
|
e !== Symbol.prototype
|
|
? "symbol"
|
|
: typeof e;
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports),
|
|
r(t)
|
|
);
|
|
}
|
|
(e.exports = r),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
41442: function (e, r, t) {
|
|
var n = t(25705);
|
|
(e.exports = function (e, r) {
|
|
if (e) {
|
|
if ("string" == typeof e) return n(e, r);
|
|
var t = Object.prototype.toString.call(e).slice(8, -1);
|
|
if (
|
|
("Object" === t && e.constructor && (t = e.constructor.name),
|
|
"Map" === t || "Set" === t)
|
|
)
|
|
return Array.from(e);
|
|
if (
|
|
"Arguments" === t ||
|
|
/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
|
|
)
|
|
return n(e, r);
|
|
}
|
|
}),
|
|
(e.exports.__esModule = !0),
|
|
(e.exports.default = e.exports);
|
|
},
|
|
9942: function (e, r, t) {
|
|
"use strict";
|
|
t.d(r, {
|
|
Z: function () {
|
|
return a;
|
|
},
|
|
});
|
|
var n = t(20533),
|
|
i = t(52987),
|
|
u = t(22266),
|
|
o = t(71885);
|
|
function a(e) {
|
|
return (0, n.Z)(e) || (0, i.Z)(e) || (0, u.Z)(e) || (0, o.Z)();
|
|
}
|
|
},
|
|
},
|
|
]);
|