8109 lines
240 KiB
JavaScript
8109 lines
240 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 5d5b47876e53e564.da1ba52a93.js
|
|
* Module id: 897151
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
let t, r, n, o, a, i, l, s, c;
|
|
var u,
|
|
d,
|
|
f,
|
|
m = e.i(358379),
|
|
p = e.i(549116);
|
|
e.i(977955);
|
|
var h = e.i(820186);
|
|
e.i(606823);
|
|
var g = e.i(687517),
|
|
b = e.i(626673);
|
|
e.i(370357);
|
|
var v = e.i(436178),
|
|
_ = e.i(185264),
|
|
y = e.i(373518);
|
|
e.i(23741);
|
|
var x = e.i(935492),
|
|
C = e.i(315394);
|
|
let E = "__rc_react_root__",
|
|
S = m.default.createContext({});
|
|
var w = e.i(944356);
|
|
function k() {
|
|
return !!(
|
|
"u" > typeof window &&
|
|
window.document &&
|
|
window.document.createElement
|
|
);
|
|
}
|
|
let j = "data-rc-order",
|
|
P = "data-rc-priority",
|
|
R = new Map();
|
|
function N({ mark: e } = {}) {
|
|
return e ? (e.startsWith("data-") ? e : `data-${e}`) : "rc-util-key";
|
|
}
|
|
function $(e) {
|
|
return e.attachTo
|
|
? e.attachTo
|
|
: document.querySelector("head") || document.body;
|
|
}
|
|
function O(e) {
|
|
return Array.from((R.get(e) || e).children).filter(
|
|
(e) => "STYLE" === e.tagName,
|
|
);
|
|
}
|
|
function T(e, t = {}) {
|
|
if (!k()) return null;
|
|
let { csp: r, prepend: n, priority: o = 0 } = t,
|
|
a = "queue" === n ? "prependQueue" : n ? "prepend" : "append",
|
|
i = "prependQueue" === a,
|
|
l = document.createElement("style");
|
|
l.setAttribute(j, a),
|
|
i && o && l.setAttribute(P, `${o}`),
|
|
r?.nonce && (l.nonce = r?.nonce),
|
|
(l.innerHTML = e);
|
|
let s = $(t),
|
|
{ firstChild: c } = s;
|
|
if (n) {
|
|
if (i) {
|
|
let e = (t.styles || O(s)).filter(
|
|
(e) =>
|
|
!!["prepend", "prependQueue"].includes(e.getAttribute(j)) &&
|
|
o >= Number(e.getAttribute(P) || 0),
|
|
);
|
|
if (e.length)
|
|
return s.insertBefore(l, e[e.length - 1].nextSibling), l;
|
|
}
|
|
s.insertBefore(l, c);
|
|
} else s.appendChild(l);
|
|
return l;
|
|
}
|
|
function M(e, t = {}) {
|
|
let { styles: r } = t;
|
|
return (r ||= O($(t))).find((r) => r.getAttribute(N(t)) === e);
|
|
}
|
|
function I(e, t = {}) {
|
|
let r = M(e, t);
|
|
r && $(t).removeChild(r);
|
|
}
|
|
function A(e, t, r = {}) {
|
|
let n = $(r),
|
|
o = O(n),
|
|
a = { ...r, styles: o };
|
|
!(function (e, t) {
|
|
let r = R.get(e);
|
|
if (
|
|
!r ||
|
|
!(function (e, t) {
|
|
if (!e) return !1;
|
|
if (e.contains) return e.contains(t);
|
|
let r = t;
|
|
for (; r; ) {
|
|
if (r === e) return !0;
|
|
r = r.parentNode;
|
|
}
|
|
return !1;
|
|
})(document, r)
|
|
) {
|
|
let r = T("", t),
|
|
{ parentNode: n } = r;
|
|
R.set(e, n), e.removeChild(r);
|
|
}
|
|
})(n, a);
|
|
let i = M(t, a);
|
|
if (i)
|
|
return (
|
|
a.csp?.nonce && i.nonce !== a.csp?.nonce && (i.nonce = a.csp?.nonce),
|
|
i.innerHTML !== e && (i.innerHTML = e),
|
|
i
|
|
);
|
|
let l = T(e, a);
|
|
return l.setAttribute(N(a), t), l;
|
|
}
|
|
function L(e, t, r) {
|
|
let n = m.useRef({});
|
|
return (
|
|
(!("value" in n.current) || r(n.current.condition, t)) &&
|
|
((n.current.value = e()), (n.current.condition = t)),
|
|
n.current.value
|
|
);
|
|
}
|
|
let B = {},
|
|
D = [];
|
|
function H(e, t) {}
|
|
function z(e, t) {}
|
|
function W(e, t, r) {
|
|
t || B[r] || (e(!1, r), (B[r] = !0));
|
|
}
|
|
function F(e, t) {
|
|
W(H, e, t);
|
|
}
|
|
(F.preMessage = (e) => {
|
|
D.push(e);
|
|
}),
|
|
(F.resetWarned = function () {
|
|
B = {};
|
|
}),
|
|
(F.noteOnce = function (e, t) {
|
|
W(z, e, t);
|
|
});
|
|
let U = function (e, t, r = !1) {
|
|
let n = new Set();
|
|
return (function e(t, o, a = 1) {
|
|
let i = n.has(t);
|
|
if ((F(!i, "Warning: There may be circular references"), i)) return !1;
|
|
if (t === o) return !0;
|
|
if (r && a > 1) return !1;
|
|
n.add(t);
|
|
let l = a + 1;
|
|
if (Array.isArray(t)) {
|
|
if (!Array.isArray(o) || t.length !== o.length) return !1;
|
|
for (let r = 0; r < t.length; r++) if (!e(t[r], o[r], l)) return !1;
|
|
return !0;
|
|
}
|
|
if (t && o && "object" == typeof t && "object" == typeof o) {
|
|
let r = Object.keys(t);
|
|
return (
|
|
r.length === Object.keys(o).length &&
|
|
r.every((r) => e(t[r], o[r], l))
|
|
);
|
|
}
|
|
return !1;
|
|
})(e, t);
|
|
};
|
|
function G(e) {
|
|
return e.join("%");
|
|
}
|
|
let q = 0;
|
|
class X {
|
|
instanceId;
|
|
constructor(e) {
|
|
this.instanceId = e;
|
|
}
|
|
cache = new Map();
|
|
updateTimes = new Map();
|
|
extracted = new Set();
|
|
get(e) {
|
|
return this.opGet(G(e));
|
|
}
|
|
opGet(e) {
|
|
return this.cache.get(e) || null;
|
|
}
|
|
update(e, t) {
|
|
return this.opUpdate(G(e), t);
|
|
}
|
|
opUpdate(e, t) {
|
|
let r = t(this.cache.get(e));
|
|
null === r
|
|
? (this.cache.delete(e), this.updateTimes.delete(e))
|
|
: (this.cache.set(e, r), this.updateTimes.set(e, q), (q += 1));
|
|
}
|
|
}
|
|
let K = "data-token-hash",
|
|
V = "data-css-hash",
|
|
Y = "__cssinjs_instance__",
|
|
Q = m.createContext({
|
|
hashPriority: "low",
|
|
cache: (function () {
|
|
let e = Math.random().toString(12).slice(2);
|
|
if ("u" > typeof document && document.head && document.body) {
|
|
let t = document.body.querySelectorAll(`style[${V}]`) || [],
|
|
{ firstChild: r } = document.head;
|
|
Array.from(t).forEach((t) => {
|
|
(t[Y] ||= e), t[Y] === e && document.head.insertBefore(t, r);
|
|
});
|
|
let n = {};
|
|
Array.from(document.querySelectorAll(`style[${V}]`)).forEach(
|
|
(t) => {
|
|
let r = t.getAttribute(V);
|
|
n[r] ? t[Y] === e && t.parentNode?.removeChild(t) : (n[r] = !0);
|
|
},
|
|
);
|
|
}
|
|
return new X(e);
|
|
})(),
|
|
defaultCache: !0,
|
|
autoPrefix: !1,
|
|
});
|
|
class Z {
|
|
static MAX_CACHE_SIZE = 20;
|
|
static MAX_CACHE_OFFSET = 5;
|
|
cache;
|
|
keys;
|
|
cacheCallTimes;
|
|
constructor() {
|
|
(this.cache = new Map()), (this.keys = []), (this.cacheCallTimes = 0);
|
|
}
|
|
size() {
|
|
return this.keys.length;
|
|
}
|
|
internalGet(e, t = !1) {
|
|
let r = { map: this.cache };
|
|
return (
|
|
e.forEach((e) => {
|
|
r = r ? r?.map?.get(e) : void 0;
|
|
}),
|
|
r?.value && t && (r.value[1] = this.cacheCallTimes++),
|
|
r?.value
|
|
);
|
|
}
|
|
get(e) {
|
|
return this.internalGet(e, !0)?.[0];
|
|
}
|
|
has(e) {
|
|
return !!this.internalGet(e);
|
|
}
|
|
set(e, t) {
|
|
if (!this.has(e)) {
|
|
if (this.size() + 1 > Z.MAX_CACHE_SIZE + Z.MAX_CACHE_OFFSET) {
|
|
let [e] = this.keys.reduce(
|
|
(e, t) => {
|
|
let [, r] = e;
|
|
return this.internalGet(t)[1] < r
|
|
? [t, this.internalGet(t)[1]]
|
|
: e;
|
|
},
|
|
[this.keys[0], this.cacheCallTimes],
|
|
);
|
|
this.delete(e);
|
|
}
|
|
this.keys.push(e);
|
|
}
|
|
let r = this.cache;
|
|
e.forEach((n, o) => {
|
|
if (o === e.length - 1)
|
|
r.set(n, { value: [t, this.cacheCallTimes++] });
|
|
else {
|
|
let e = r.get(n);
|
|
e ? e.map || (e.map = new Map()) : r.set(n, { map: new Map() }),
|
|
(r = r.get(n).map);
|
|
}
|
|
});
|
|
}
|
|
deleteByPath(e, t) {
|
|
let r = e.get(t[0]);
|
|
if (1 === t.length)
|
|
return (
|
|
r.map ? e.set(t[0], { map: r.map }) : e.delete(t[0]), r.value?.[0]
|
|
);
|
|
let n = this.deleteByPath(r.map, t.slice(1));
|
|
return (r.map && 0 !== r.map.size) || r.value || e.delete(t[0]), n;
|
|
}
|
|
delete(e) {
|
|
if (this.has(e))
|
|
return (
|
|
(this.keys = this.keys.filter(
|
|
(t) =>
|
|
!(function (e, t) {
|
|
if (e.length !== t.length) return !1;
|
|
for (let r = 0; r < e.length; r++)
|
|
if (e[r] !== t[r]) return !1;
|
|
return !0;
|
|
})(t, e),
|
|
)),
|
|
this.deleteByPath(this.cache, e)
|
|
);
|
|
}
|
|
}
|
|
let J = 0;
|
|
class ee {
|
|
derivatives;
|
|
id;
|
|
constructor(e) {
|
|
(this.derivatives = Array.isArray(e) ? e : [e]),
|
|
(this.id = J),
|
|
0 === e.length &&
|
|
H(
|
|
e.length > 0,
|
|
"[Ant Design CSS-in-JS] Theme should have at least one derivative function.",
|
|
),
|
|
(J += 1);
|
|
}
|
|
getDerivativeToken(e) {
|
|
return this.derivatives.reduce((t, r) => r(e, t), void 0);
|
|
}
|
|
}
|
|
let et = new Z();
|
|
function er(e) {
|
|
let t = Array.isArray(e) ? e : [e];
|
|
return et.has(t) || et.set(t, new ee(t)), et.get(t);
|
|
}
|
|
let en = new WeakMap(),
|
|
eo = {},
|
|
ea = new WeakMap();
|
|
function ei(e) {
|
|
let t = ea.get(e) || "";
|
|
return (
|
|
t ||
|
|
(Object.keys(e).forEach((r) => {
|
|
let n = e[r];
|
|
(t += r),
|
|
n instanceof ee
|
|
? (t += n.id)
|
|
: n && "object" == typeof n
|
|
? (t += ei(n))
|
|
: (t += n);
|
|
}),
|
|
(t = (0, w.default)(t)),
|
|
ea.set(e, t)),
|
|
t
|
|
);
|
|
}
|
|
`random-${Date.now()}-${Math.random()}`.replace(/\./g, "");
|
|
let el = k();
|
|
function es(e) {
|
|
return "number" == typeof e ? `${e}px` : e;
|
|
}
|
|
function ec(e) {
|
|
let { hashCls: t, hashPriority: r = "low" } = e || {};
|
|
if (!t) return "";
|
|
let n = `.${t}`;
|
|
return "low" === r ? `:where(${n})` : n;
|
|
}
|
|
let eu = (e, t = "") =>
|
|
`--${t ? `${t}-` : ""}${e}`
|
|
.replace(/([a-z0-9])([A-Z])/g, "$1-$2")
|
|
.replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1-$2")
|
|
.replace(/([a-z])([A-Z0-9])/g, "$1-$2")
|
|
.toLowerCase(),
|
|
ed = (e, t, r) => {
|
|
let {
|
|
hashCls: n,
|
|
hashPriority: o = "low",
|
|
prefix: a,
|
|
unitless: i,
|
|
ignore: l,
|
|
preserve: s,
|
|
} = r || {},
|
|
c = {},
|
|
u = {};
|
|
return (
|
|
Object.entries(e).forEach(([e, t]) => {
|
|
if (s?.[e]) u[e] = t;
|
|
else if (
|
|
("string" == typeof t || "number" == typeof t) &&
|
|
!l?.[e]
|
|
) {
|
|
let r = eu(e, a);
|
|
(c[r] = "number" != typeof t || i?.[e] ? String(t) : `${t}px`),
|
|
(u[e] = `var(${r})`);
|
|
}
|
|
}),
|
|
[
|
|
u,
|
|
((e, t, r) => {
|
|
let { hashCls: n, hashPriority: o = "low" } = r || {};
|
|
return Object.keys(e).length
|
|
? `${ec({ hashCls: n, hashPriority: o })}.${t}${r?.scope ? `.${r.scope}` : ""}{${Object.entries(
|
|
e,
|
|
)
|
|
.map(([e, t]) => `${e}:${t};`)
|
|
.join("")}}`
|
|
: "";
|
|
})(c, t, { scope: r?.scope, hashCls: n, hashPriority: o }),
|
|
]
|
|
);
|
|
},
|
|
ef = new Map();
|
|
function em(e, t, r, n, o) {
|
|
let { cache: a } = m.useContext(Q),
|
|
i = G([e, ...t]),
|
|
l = (e) => {
|
|
a.opUpdate(i, (t) => {
|
|
let [n = 0, o] = t || [void 0, void 0],
|
|
a = [n, o || r()];
|
|
return e ? e(a) : a;
|
|
});
|
|
};
|
|
m.useMemo(() => {
|
|
l();
|
|
}, [i]);
|
|
let s = a.opGet(i)[1];
|
|
return (
|
|
(0, m.useInsertionEffect)(
|
|
() => (
|
|
l(([e, t]) => [e + 1, t]),
|
|
ef.has(i) ||
|
|
(o?.(s),
|
|
ef.set(i, !0),
|
|
Promise.resolve().then(() => {
|
|
ef.delete(i);
|
|
})),
|
|
() => {
|
|
a.opUpdate(i, (e) => {
|
|
let [t = 0, r] = e || [];
|
|
return 0 == t - 1
|
|
? (n?.(r, !1), ef.delete(i), null)
|
|
: [t - 1, r];
|
|
});
|
|
}
|
|
),
|
|
[i],
|
|
),
|
|
s
|
|
);
|
|
}
|
|
let ep = {},
|
|
eh = new Map();
|
|
var eg = e.i(315946),
|
|
eb = e.i(357957),
|
|
ev = e.i(830476),
|
|
e_ = e.i(731042),
|
|
ey = e.i(921976),
|
|
ex = e.i(368185);
|
|
function eC(e, t, r, n) {
|
|
if (e.length > -1 && !e.return)
|
|
switch (e.type) {
|
|
case ev.DECLARATION:
|
|
e.return = (function e(t, r, n) {
|
|
switch ((0, e_.hash)(t, r)) {
|
|
case 5103:
|
|
return ev.WEBKIT + "print-" + t + t;
|
|
case 5737:
|
|
case 4201:
|
|
case 3177:
|
|
case 3433:
|
|
case 1641:
|
|
case 4457:
|
|
case 2921:
|
|
case 5572:
|
|
case 6356:
|
|
case 5844:
|
|
case 3191:
|
|
case 6645:
|
|
case 3005:
|
|
case 4215:
|
|
case 6389:
|
|
case 5109:
|
|
case 5365:
|
|
case 5621:
|
|
case 3829:
|
|
case 6391:
|
|
case 5879:
|
|
case 5623:
|
|
case 6135:
|
|
case 4599:
|
|
return ev.WEBKIT + t + t;
|
|
case 4855:
|
|
return (
|
|
ev.WEBKIT +
|
|
t
|
|
.replace("add", "source-over")
|
|
.replace("substract", "source-out")
|
|
.replace("intersect", "source-in")
|
|
.replace("exclude", "xor") +
|
|
t
|
|
);
|
|
case 4789:
|
|
return ev.MOZ + t + t;
|
|
case 5349:
|
|
case 4246:
|
|
case 4810:
|
|
case 6968:
|
|
case 2756:
|
|
return ev.WEBKIT + t + ev.MOZ + t + ev.MS + t + t;
|
|
case 5936:
|
|
switch ((0, e_.charat)(t, r + 11)) {
|
|
case 114:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
(0, e_.replace)(t, /[svh]\w+-[tblr]{2}/, "tb") +
|
|
t
|
|
);
|
|
case 108:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
(0, e_.replace)(t, /[svh]\w+-[tblr]{2}/, "tb-rl") +
|
|
t
|
|
);
|
|
case 45:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
(0, e_.replace)(t, /[svh]\w+-[tblr]{2}/, "lr") +
|
|
t
|
|
);
|
|
}
|
|
case 6828:
|
|
case 4268:
|
|
case 2903:
|
|
return ev.WEBKIT + t + ev.MS + t + t;
|
|
case 6165:
|
|
return ev.WEBKIT + t + ev.MS + "flex-" + t + t;
|
|
case 5187:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
(0, e_.replace)(
|
|
t,
|
|
/(\w+).+(:[^]+)/,
|
|
ev.WEBKIT + "box-$1$2" + ev.MS + "flex-$1$2",
|
|
) +
|
|
t
|
|
);
|
|
case 5443:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
"flex-item-" +
|
|
(0, e_.replace)(t, /flex-|-self/g, "") +
|
|
((0, e_.match)(t, /flex-|baseline/)
|
|
? ""
|
|
: ev.MS +
|
|
"grid-row-" +
|
|
(0, e_.replace)(t, /flex-|-self/g, "")) +
|
|
t
|
|
);
|
|
case 4675:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
"flex-line-pack" +
|
|
(0, e_.replace)(t, /align-content|flex-|-self/g, "") +
|
|
t
|
|
);
|
|
case 5548:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
(0, e_.replace)(t, "shrink", "negative") +
|
|
t
|
|
);
|
|
case 5292:
|
|
return (
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
(0, e_.replace)(t, "basis", "preferred-size") +
|
|
t
|
|
);
|
|
case 6060:
|
|
return (
|
|
ev.WEBKIT +
|
|
"box-" +
|
|
(0, e_.replace)(t, "-grow", "") +
|
|
ev.WEBKIT +
|
|
t +
|
|
ev.MS +
|
|
(0, e_.replace)(t, "grow", "positive") +
|
|
t
|
|
);
|
|
case 4554:
|
|
return (
|
|
ev.WEBKIT +
|
|
(0, e_.replace)(
|
|
t,
|
|
/([^-])(transform)/g,
|
|
"$1" + ev.WEBKIT + "$2",
|
|
) +
|
|
t
|
|
);
|
|
case 6187:
|
|
return (
|
|
(0, e_.replace)(
|
|
(0, e_.replace)(
|
|
(0, e_.replace)(t, /(zoom-|grab)/, ev.WEBKIT + "$1"),
|
|
/(image-set)/,
|
|
ev.WEBKIT + "$1",
|
|
),
|
|
t,
|
|
"",
|
|
) + t
|
|
);
|
|
case 5495:
|
|
case 3959:
|
|
return (0, e_.replace)(
|
|
t,
|
|
/(image-set\([^]*)/,
|
|
ev.WEBKIT + "$1$`$1",
|
|
);
|
|
case 4968:
|
|
return (
|
|
(0, e_.replace)(
|
|
(0, e_.replace)(
|
|
t,
|
|
/(.+:)(flex-)?(.*)/,
|
|
ev.WEBKIT + "box-pack:$3" + ev.MS + "flex-pack:$3",
|
|
),
|
|
/space-between/,
|
|
"justify",
|
|
) +
|
|
ev.WEBKIT +
|
|
t +
|
|
t
|
|
);
|
|
case 4200:
|
|
if (!(0, e_.match)(t, /flex-|baseline/))
|
|
return (
|
|
ev.MS + "grid-column-align" + (0, e_.substr)(t, r) + t
|
|
);
|
|
break;
|
|
case 2592:
|
|
case 3360:
|
|
return ev.MS + (0, e_.replace)(t, "template-", "") + t;
|
|
case 4384:
|
|
case 3616:
|
|
if (
|
|
n &&
|
|
n.some(function (e, t) {
|
|
return (r = t), (0, e_.match)(e.props, /grid-\w+-end/);
|
|
})
|
|
)
|
|
return ~(0, e_.indexof)(t + (n = n[r].value), "span", 0)
|
|
? t
|
|
: ev.MS +
|
|
(0, e_.replace)(t, "-start", "") +
|
|
t +
|
|
ev.MS +
|
|
"grid-row-span:" +
|
|
(~(0, e_.indexof)(n, "span", 0)
|
|
? (0, e_.match)(n, /\d+/)
|
|
: (0, e_.match)(n, /\d+/) -
|
|
(0, e_.match)(t, /\d+/)) +
|
|
";";
|
|
return ev.MS + (0, e_.replace)(t, "-start", "") + t;
|
|
case 4896:
|
|
case 4128:
|
|
return n &&
|
|
n.some(function (e) {
|
|
return (0, e_.match)(e.props, /grid-\w+-start/);
|
|
})
|
|
? t
|
|
: ev.MS +
|
|
(0, e_.replace)(
|
|
(0, e_.replace)(t, "-end", "-span"),
|
|
"span ",
|
|
"",
|
|
) +
|
|
t;
|
|
case 4095:
|
|
case 3583:
|
|
case 4068:
|
|
case 2532:
|
|
return (
|
|
(0, e_.replace)(t, /(.+)-inline(.+)/, ev.WEBKIT + "$1$2") +
|
|
t
|
|
);
|
|
case 8116:
|
|
case 7059:
|
|
case 5753:
|
|
case 5535:
|
|
case 5445:
|
|
case 5701:
|
|
case 4933:
|
|
case 4677:
|
|
case 5533:
|
|
case 5789:
|
|
case 5021:
|
|
case 4765:
|
|
if ((0, e_.strlen)(t) - 1 - r > 6)
|
|
switch ((0, e_.charat)(t, r + 1)) {
|
|
case 109:
|
|
if (45 !== (0, e_.charat)(t, r + 4)) break;
|
|
case 102:
|
|
return (
|
|
(0, e_.replace)(
|
|
t,
|
|
/(.+:)(.+)-([^]+)/,
|
|
"$1" +
|
|
ev.WEBKIT +
|
|
"$2-$3$1" +
|
|
ev.MOZ +
|
|
(108 == (0, e_.charat)(t, r + 3)
|
|
? "$3"
|
|
: "$2-$3"),
|
|
) + t
|
|
);
|
|
case 115:
|
|
return ~(0, e_.indexof)(t, "stretch", 0)
|
|
? e(
|
|
(0, e_.replace)(t, "stretch", "fill-available"),
|
|
r,
|
|
n,
|
|
) + t
|
|
: t;
|
|
}
|
|
break;
|
|
case 5152:
|
|
case 5920:
|
|
return (0, e_.replace)(
|
|
t,
|
|
/(.+?):(\d+)(\s*\/\s*(span)?\s*(\d+))?(.*)/,
|
|
function (e, r, n, o, a, i, l) {
|
|
return (
|
|
ev.MS +
|
|
r +
|
|
":" +
|
|
n +
|
|
l +
|
|
(o ? ev.MS + r + "-span:" + (a ? i : i - n) + l : "") +
|
|
t
|
|
);
|
|
},
|
|
);
|
|
case 4949:
|
|
if (121 === (0, e_.charat)(t, r + 6))
|
|
return (0, e_.replace)(t, ":", ":" + ev.WEBKIT) + t;
|
|
break;
|
|
case 6444:
|
|
switch (
|
|
(0, e_.charat)(t, 45 === (0, e_.charat)(t, 14) ? 18 : 11)
|
|
) {
|
|
case 120:
|
|
return (
|
|
(0, e_.replace)(
|
|
t,
|
|
/(.+:)([^;\s!]+)(;|(\s+)?!.+)?/,
|
|
"$1" +
|
|
ev.WEBKIT +
|
|
(45 === (0, e_.charat)(t, 14) ? "inline-" : "") +
|
|
"box$3$1" +
|
|
ev.WEBKIT +
|
|
"$2$3$1" +
|
|
ev.MS +
|
|
"$2box$3",
|
|
) + t
|
|
);
|
|
case 100:
|
|
return (0, e_.replace)(t, ":", ":" + ev.MS) + t;
|
|
}
|
|
break;
|
|
case 5719:
|
|
case 2647:
|
|
case 2135:
|
|
case 3927:
|
|
case 2391:
|
|
return (0, e_.replace)(t, "scroll-", "scroll-snap-") + t;
|
|
}
|
|
return t;
|
|
})(e.value, e.length, r);
|
|
return;
|
|
case ev.KEYFRAMES:
|
|
return (0, ex.serialize)(
|
|
[
|
|
(0, ey.copy)(e, {
|
|
value: (0, e_.replace)(e.value, "@", "@" + ev.WEBKIT),
|
|
}),
|
|
],
|
|
n,
|
|
);
|
|
case ev.RULESET:
|
|
if (e.length)
|
|
return (0, e_.combine)((r = e.props), function (t) {
|
|
switch ((0, e_.match)(t, (n = /(::plac\w+|:read-\w+)/))) {
|
|
case ":read-only":
|
|
case ":read-write":
|
|
(0, ey.lift)(
|
|
(0, ey.copy)(e, {
|
|
props: [
|
|
(0, e_.replace)(
|
|
t,
|
|
/:(read-\w+)/,
|
|
":" + ev.MOZ + "$1",
|
|
),
|
|
],
|
|
}),
|
|
),
|
|
(0, ey.lift)((0, ey.copy)(e, { props: [t] })),
|
|
(0, e_.assign)(e, { props: (0, e_.filter)(r, n) });
|
|
break;
|
|
case "::placeholder":
|
|
(0, ey.lift)(
|
|
(0, ey.copy)(e, {
|
|
props: [
|
|
(0, e_.replace)(
|
|
t,
|
|
/:(plac\w+)/,
|
|
":" + ev.WEBKIT + "input-$1",
|
|
),
|
|
],
|
|
}),
|
|
),
|
|
(0, ey.lift)(
|
|
(0, ey.copy)(e, {
|
|
props: [
|
|
(0, e_.replace)(
|
|
t,
|
|
/:(plac\w+)/,
|
|
":" + ev.MOZ + "$1",
|
|
),
|
|
],
|
|
}),
|
|
),
|
|
(0, ey.lift)(
|
|
(0, ey.copy)(e, {
|
|
props: [
|
|
(0, e_.replace)(
|
|
t,
|
|
/:(plac\w+)/,
|
|
ev.MS + "input-$1",
|
|
),
|
|
],
|
|
}),
|
|
),
|
|
(0, ey.lift)((0, ey.copy)(e, { props: [t] })),
|
|
(0, e_.assign)(e, { props: (0, e_.filter)(r, n) });
|
|
}
|
|
return "";
|
|
});
|
|
}
|
|
}
|
|
let eE = "data-ant-cssinjs-cache-path",
|
|
eS = "_FILE_STYLE__",
|
|
ew = !0,
|
|
ek = "_multi_value_";
|
|
function ej(e, t) {
|
|
var r, n;
|
|
return (
|
|
t
|
|
? (0, ex.serialize)(
|
|
(0, eb.compile)(e),
|
|
((r = [eC, ex.stringify]),
|
|
(n = (0, e_.sizeof)(r)),
|
|
function (e, t, o, a) {
|
|
for (var i = "", l = 0; l < n; l++) i += r[l](e, t, o, a) || "";
|
|
return i;
|
|
}),
|
|
)
|
|
: (0, ex.serialize)((0, eb.compile)(e), ex.stringify)
|
|
).replace(/\{%%%\:[^;];}/g, ";");
|
|
}
|
|
function eP(e, t, r = "high") {
|
|
if (!t) return e;
|
|
let n = ec({ hashCls: t, hashPriority: r });
|
|
return e
|
|
.split(",")
|
|
.map((e) => {
|
|
let t = e.trim().split(/\s+/),
|
|
r = t[0] || "",
|
|
o = r.match(/^\w+/)?.[0] || "";
|
|
return [(r = `${o}${n}${r.slice(o.length)}`), ...t.slice(1)].join(
|
|
" ",
|
|
);
|
|
})
|
|
.join(",");
|
|
}
|
|
let eR = (
|
|
e,
|
|
t = {},
|
|
{ root: r, injectHash: n, parentSelectors: o } = {
|
|
root: !0,
|
|
parentSelectors: [],
|
|
},
|
|
) => {
|
|
let {
|
|
hashId: a,
|
|
layer: i,
|
|
path: l,
|
|
hashPriority: s,
|
|
transformers: c = [],
|
|
linters: u = [],
|
|
} = t,
|
|
d = "",
|
|
f = {};
|
|
function m(e) {
|
|
let r = e.getName(a);
|
|
if (!f[r]) {
|
|
let [n] = eR(e.style, t, { root: !1, parentSelectors: o });
|
|
f[r] = `@keyframes ${e.getName(a)}${n}`;
|
|
}
|
|
}
|
|
return (
|
|
(function e(t, r = []) {
|
|
return (
|
|
t.forEach((t) => {
|
|
Array.isArray(t) ? e(t, r) : t && r.push(t);
|
|
}),
|
|
r
|
|
);
|
|
})(Array.isArray(e) ? e : [e]).forEach((e) => {
|
|
let i = "string" != typeof e || r ? e : {};
|
|
if ("string" == typeof i)
|
|
d += `${i}
|
|
`;
|
|
else if (i._keyframe) m(i);
|
|
else {
|
|
let e = c.reduce((e, t) => t?.visit?.(e) || e, i);
|
|
Object.keys(e).forEach((i) => {
|
|
let l = e[i];
|
|
if (
|
|
"object" != typeof l ||
|
|
!l ||
|
|
("animationName" === i && l._keyframe) ||
|
|
("object" == typeof l && l && ("_skip_check_" in l || ek in l))
|
|
) {
|
|
function c(e, t) {
|
|
let r = e.replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`),
|
|
n = t;
|
|
eg.default[e] ||
|
|
"number" != typeof n ||
|
|
0 === n ||
|
|
(n = `${n}px`),
|
|
"animationName" === e &&
|
|
t?._keyframe &&
|
|
(m(t), (n = t.getName(a))),
|
|
(d += `${r}:${n};`);
|
|
}
|
|
let e = l?.value ?? l;
|
|
if ("object" == typeof l && l?.[ek] && Array.isArray(e))
|
|
e.forEach((e) => {
|
|
c(i, e);
|
|
});
|
|
else null != e && c(i, e);
|
|
} else {
|
|
let e = !1,
|
|
c = i.trim(),
|
|
u = !1;
|
|
(r || n) && a
|
|
? c.startsWith("@")
|
|
? (e = !0)
|
|
: (c = "&" === c ? eP("", a, s) : eP(i, a, s))
|
|
: r && !a && ("&" === c || "" === c) && ((c = ""), (u = !0));
|
|
let [m, p] = eR(l, t, {
|
|
root: u,
|
|
injectHash: e,
|
|
parentSelectors: [...o, c],
|
|
});
|
|
(f = { ...f, ...p }), (d += `${c}${m}`);
|
|
}
|
|
});
|
|
}
|
|
}),
|
|
r
|
|
? i &&
|
|
(d && (d = `@layer ${i.name} {${d}}`),
|
|
i.dependencies &&
|
|
(f[`@layer ${i.name}`] = i.dependencies
|
|
.map((e) => `@layer ${e}, ${i.name};`)
|
|
.join("\n")))
|
|
: (d = `{${d}}`),
|
|
[d, f]
|
|
);
|
|
};
|
|
function eN(e, t) {
|
|
return (0, w.default)(`${e.join("%")}${t}`);
|
|
}
|
|
function e$(e, r) {
|
|
let {
|
|
path: n,
|
|
hashId: o,
|
|
layer: a,
|
|
nonce: i,
|
|
clientOnly: l,
|
|
order: s = 0,
|
|
} = e,
|
|
{
|
|
mock: c,
|
|
hashPriority: u,
|
|
container: d,
|
|
transformers: f,
|
|
linters: p,
|
|
cache: h,
|
|
layer: g,
|
|
autoPrefix: b,
|
|
} = m.useContext(Q),
|
|
v = [o || ""];
|
|
g && v.push("layer"), v.push(...n);
|
|
em(
|
|
"style",
|
|
v,
|
|
() => {
|
|
let e = v.join("|");
|
|
if (
|
|
(function (e) {
|
|
if (!t && ((t = {}), k())) {
|
|
let e = document.createElement("div");
|
|
(e.className = eE),
|
|
(e.style.position = "fixed"),
|
|
(e.style.visibility = "hidden"),
|
|
(e.style.top = "-9999px"),
|
|
document.body.appendChild(e);
|
|
let r = getComputedStyle(e).content || "";
|
|
(r = r.replace(/^"/, "").replace(/"$/, ""))
|
|
.split(";")
|
|
.forEach((e) => {
|
|
let [r, n] = e.split(":");
|
|
t[r] = n;
|
|
});
|
|
let n = document.querySelector(`style[${eE}]`);
|
|
n && ((ew = !1), n.parentNode?.removeChild(n)),
|
|
document.body.removeChild(e);
|
|
}
|
|
return !!t[e];
|
|
})(e)
|
|
) {
|
|
let [r, n] = (function (e) {
|
|
let r = t[e],
|
|
n = null;
|
|
if (r && k())
|
|
if (ew) n = eS;
|
|
else {
|
|
let r = document.querySelector(`style[${V}="${t[e]}"]`);
|
|
r ? (n = r.innerHTML) : delete t[e];
|
|
}
|
|
return [n, r];
|
|
})(e);
|
|
if (r) return [r, n, {}, l, s];
|
|
}
|
|
let [i, c] = eR(r(), {
|
|
hashId: o,
|
|
hashPriority: u,
|
|
layer: g ? a : void 0,
|
|
path: n.join("-"),
|
|
transformers: f,
|
|
linters: p,
|
|
}),
|
|
d = ej(i, b || !1),
|
|
m = eN(v, d);
|
|
return [d, m, c, l, s];
|
|
},
|
|
(e, t) => {
|
|
let [, r] = e;
|
|
t && el && I(r, { mark: V, attachTo: d });
|
|
},
|
|
(e) => {
|
|
let [t, r, n, , o] = e;
|
|
if (el && t !== eS) {
|
|
let e = {
|
|
mark: V,
|
|
prepend: !g && "queue",
|
|
attachTo: d,
|
|
priority: o,
|
|
},
|
|
a = "function" == typeof i ? i() : i;
|
|
a && (e.csp = { nonce: a });
|
|
let l = [],
|
|
s = [];
|
|
Object.keys(n).forEach((e) => {
|
|
e.startsWith("@layer") ? l.push(e) : s.push(e);
|
|
}),
|
|
l.forEach((t) => {
|
|
A(ej(n[t], b || !1), `_layer-${t}`, { ...e, prepend: !0 });
|
|
}),
|
|
(A(t, r, e)[Y] = h.instanceId),
|
|
s.forEach((t) => {
|
|
A(ej(n[t], b || !1), `_effect-${t}`, e);
|
|
});
|
|
}
|
|
},
|
|
);
|
|
}
|
|
let eO = class {
|
|
name;
|
|
style;
|
|
constructor(e, t) {
|
|
(this.name = e), (this.style = t);
|
|
}
|
|
getName(e = "") {
|
|
return e ? `${e}-${this.name}` : this.name;
|
|
}
|
|
_keyframe = !0;
|
|
};
|
|
function eT(e) {
|
|
return (e.notSplit = !0), e;
|
|
}
|
|
eT(["borderTop", "borderBottom"]),
|
|
eT(["borderTop"]),
|
|
eT(["borderBottom"]),
|
|
eT(["borderLeft", "borderRight"]),
|
|
eT(["borderLeft"]),
|
|
eT(["borderRight"]);
|
|
let eM = (0, m.createContext)({}),
|
|
eI = function (e) {
|
|
let t = m.useRef(e);
|
|
return (t.current = e), m.useCallback((...e) => t.current?.(...e), []);
|
|
},
|
|
eA = k() ? m.useLayoutEffect : m.useEffect,
|
|
eL = (e, t) => {
|
|
let r = m.useRef(!0);
|
|
eA(() => e(r.current), t),
|
|
eA(
|
|
() => (
|
|
(r.current = !1),
|
|
() => {
|
|
r.current = !0;
|
|
}
|
|
),
|
|
[],
|
|
);
|
|
},
|
|
eB = (e) => {
|
|
let t = m.useRef(!1),
|
|
[r, n] = m.useState(e);
|
|
return (
|
|
m.useEffect(
|
|
() => (
|
|
(t.current = !1),
|
|
() => {
|
|
t.current = !0;
|
|
}
|
|
),
|
|
[],
|
|
),
|
|
[
|
|
r,
|
|
function (e, r) {
|
|
(r && t.current) || n(e);
|
|
},
|
|
]
|
|
);
|
|
};
|
|
var eD = e.i(87683);
|
|
let eH = Symbol.for("react.element"),
|
|
ez = Symbol.for("react.transitional.element"),
|
|
eW = Symbol.for("react.fragment");
|
|
function eF(e) {
|
|
return (
|
|
e &&
|
|
"object" == typeof e &&
|
|
(e.$$typeof === eH || e.$$typeof === ez) &&
|
|
e.type === eW
|
|
);
|
|
}
|
|
let eU = Number(m.version.split(".")[0]),
|
|
eG = (...e) => {
|
|
let t = e.filter(Boolean);
|
|
return t.length <= 1
|
|
? t[0]
|
|
: (t) => {
|
|
e.forEach((e) => {
|
|
"function" == typeof e
|
|
? e(t)
|
|
: "object" == typeof e &&
|
|
e &&
|
|
"current" in e &&
|
|
(e.current = t);
|
|
});
|
|
};
|
|
},
|
|
eq = (...e) =>
|
|
L(
|
|
() => eG(...e),
|
|
e,
|
|
(e, t) => e.length !== t.length || e.every((e, r) => e !== t[r]),
|
|
),
|
|
eX = (e) => {
|
|
if (!e) return !1;
|
|
if (eK(e) && eU >= 19) return !0;
|
|
let t = (0, eD.isMemo)(e) ? e.type.type : e.type;
|
|
return (
|
|
("function" != typeof t ||
|
|
!!t.prototype?.render ||
|
|
t.$$typeof === eD.ForwardRef) &&
|
|
("function" != typeof e ||
|
|
!!e.prototype?.render ||
|
|
e.$$typeof === eD.ForwardRef)
|
|
);
|
|
};
|
|
function eK(e) {
|
|
return (0, m.isValidElement)(e) && !eF(e);
|
|
}
|
|
let eV = (e) =>
|
|
e && eK(e)
|
|
? e.props.propertyIsEnumerable("ref")
|
|
? e.props.ref
|
|
: e.ref
|
|
: null;
|
|
function eY(e, t) {
|
|
let r = e;
|
|
for (let e = 0; e < t.length; e += 1) {
|
|
if (null == r) return;
|
|
r = r[t[e]];
|
|
}
|
|
return r;
|
|
}
|
|
function eQ(e, t, r, n = !1) {
|
|
return t.length && n && void 0 === r && !eY(e, t.slice(0, -1))
|
|
? e
|
|
: (function e(t, r, n, o) {
|
|
let a;
|
|
if (!r.length) return n;
|
|
let [i, ...l] = r;
|
|
return (
|
|
(a =
|
|
t || "number" != typeof i
|
|
? Array.isArray(t)
|
|
? [...t]
|
|
: { ...t }
|
|
: []),
|
|
o && void 0 === n && 1 === l.length
|
|
? delete a[i][l[0]]
|
|
: (a[i] = e(a[i], l, n, o)),
|
|
a
|
|
);
|
|
})(e, t, r, n);
|
|
}
|
|
function eZ(e) {
|
|
return Array.isArray(e) ? [] : {};
|
|
}
|
|
let eJ = "u" < typeof Reflect ? Object.keys : Reflect.ownKeys;
|
|
function e0() {}
|
|
let { resetWarned: e1 } = F,
|
|
e2 = m.createContext({}),
|
|
e4 = () => {
|
|
let e = () => {};
|
|
return (e.deprecated = e0), e;
|
|
},
|
|
e6 = (0, m.createContext)(void 0);
|
|
function e3(e) {
|
|
return (e3 =
|
|
"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);
|
|
}
|
|
function e5(e, t) {
|
|
var r = Object.keys(e);
|
|
if (Object.getOwnPropertySymbols) {
|
|
var n = Object.getOwnPropertySymbols(e);
|
|
t &&
|
|
(n = n.filter(function (t) {
|
|
return Object.getOwnPropertyDescriptor(e, t).enumerable;
|
|
})),
|
|
r.push.apply(r, n);
|
|
}
|
|
return r;
|
|
}
|
|
function e8(e) {
|
|
for (var t = 1; t < arguments.length; t++) {
|
|
var r = null != arguments[t] ? arguments[t] : {};
|
|
t % 2
|
|
? e5(Object(r), !0).forEach(function (t) {
|
|
var n, o, a;
|
|
(n = e),
|
|
(o = t),
|
|
(a = r[t]),
|
|
(o = (function (e) {
|
|
var t = (function (e, t) {
|
|
if ("object" != e3(e) || !e) return e;
|
|
var r = e[Symbol.toPrimitive];
|
|
if (void 0 !== r) {
|
|
var n = r.call(e, t || "default");
|
|
if ("object" != e3(n)) return n;
|
|
throw TypeError(
|
|
"@@toPrimitive must return a primitive value.",
|
|
);
|
|
}
|
|
return ("string" === t ? String : Number)(e);
|
|
})(e, "string");
|
|
return "symbol" == e3(t) ? t : String(t);
|
|
})(o)) in n
|
|
? Object.defineProperty(n, o, {
|
|
value: a,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
writable: !0,
|
|
})
|
|
: (n[o] = a);
|
|
})
|
|
: Object.getOwnPropertyDescriptors
|
|
? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r))
|
|
: e5(Object(r)).forEach(function (t) {
|
|
Object.defineProperty(
|
|
e,
|
|
t,
|
|
Object.getOwnPropertyDescriptor(r, t),
|
|
);
|
|
});
|
|
}
|
|
return e;
|
|
}
|
|
e8(
|
|
e8(
|
|
{},
|
|
{
|
|
yearFormat: "YYYY",
|
|
dayFormat: "D",
|
|
cellMeridiemFormat: "A",
|
|
monthBeforeYear: !0,
|
|
},
|
|
),
|
|
{},
|
|
{
|
|
locale: "en_US",
|
|
today: "Today",
|
|
now: "Now",
|
|
backToToday: "Back to today",
|
|
ok: "OK",
|
|
clear: "Clear",
|
|
week: "Week",
|
|
month: "Month",
|
|
year: "Year",
|
|
timeSelect: "select time",
|
|
dateSelect: "select date",
|
|
weekSelect: "Choose a week",
|
|
monthSelect: "Choose a month",
|
|
yearSelect: "Choose a year",
|
|
decadeSelect: "Choose a decade",
|
|
previousMonth: "Previous month (PageUp)",
|
|
nextMonth: "Next month (PageDown)",
|
|
previousYear: "Last year (Control + left)",
|
|
nextYear: "Next year (Control + right)",
|
|
previousDecade: "Last decade",
|
|
nextDecade: "Next decade",
|
|
previousCentury: "Last century",
|
|
nextCentury: "Next century",
|
|
},
|
|
);
|
|
let e7 = "${label} is not a valid ${type}",
|
|
e9 = { okText: "OK", cancelText: "Cancel", justOkText: "OK" },
|
|
te = {
|
|
default: "Field validation error for ${label}",
|
|
required: "Please enter ${label}",
|
|
enum: "${label} must be one of [${enum}]",
|
|
whitespace: "${label} cannot be a blank character",
|
|
date: {
|
|
format: "${label} date format is invalid",
|
|
parse: "${label} cannot be converted to a date",
|
|
invalid: "${label} is an invalid date",
|
|
},
|
|
types: {
|
|
string: e7,
|
|
method: e7,
|
|
array: e7,
|
|
object: e7,
|
|
number: e7,
|
|
date: e7,
|
|
boolean: e7,
|
|
integer: e7,
|
|
float: e7,
|
|
regexp: e7,
|
|
email: e7,
|
|
url: e7,
|
|
hex: e7,
|
|
},
|
|
string: {
|
|
len: "${label} must be ${len} characters",
|
|
min: "${label} must be at least ${min} characters",
|
|
max: "${label} must be up to ${max} characters",
|
|
range: "${label} must be between ${min}-${max} characters",
|
|
},
|
|
number: {
|
|
len: "${label} must be equal to ${len}",
|
|
min: "${label} must be minimum ${min}",
|
|
max: "${label} must be maximum ${max}",
|
|
range: "${label} must be between ${min}-${max}",
|
|
},
|
|
array: {
|
|
len: "Must be ${len} ${label}",
|
|
min: "At least ${min} ${label}",
|
|
max: "At most ${max} ${label}",
|
|
range: "The amount of ${label} must be between ${min}-${max}",
|
|
},
|
|
pattern: { mismatch: "${label} does not match the pattern ${pattern}" },
|
|
},
|
|
tt = [],
|
|
tr = () => tt.reduce((e, t) => ({ ...e, ...t }), e9),
|
|
tn = (0, m.createContext)(void 0),
|
|
to = (e) => {
|
|
let { locale: t = {}, children: r, _ANT_MARK__: n } = e;
|
|
m.useEffect(
|
|
() =>
|
|
(function (e) {
|
|
if (e) {
|
|
let t = { ...e };
|
|
return (
|
|
tt.push(t),
|
|
tr(),
|
|
() => {
|
|
(tt = tt.filter((e) => e !== t)), tr();
|
|
}
|
|
);
|
|
}
|
|
({ ...e9 });
|
|
})(t?.Modal),
|
|
[t],
|
|
);
|
|
let o = m.useMemo(() => ({ ...t, exist: !0 }), [t]);
|
|
return m.createElement(tn.Provider, { value: o }, r);
|
|
},
|
|
ta = {
|
|
aliceblue: "9ehhb",
|
|
antiquewhite: "9sgk7",
|
|
aqua: "1ekf",
|
|
aquamarine: "4zsno",
|
|
azure: "9eiv3",
|
|
beige: "9lhp8",
|
|
bisque: "9zg04",
|
|
black: "0",
|
|
blanchedalmond: "9zhe5",
|
|
blue: "73",
|
|
blueviolet: "5e31e",
|
|
brown: "6g016",
|
|
burlywood: "8ouiv",
|
|
cadetblue: "3qba8",
|
|
chartreuse: "4zshs",
|
|
chocolate: "87k0u",
|
|
coral: "9yvyo",
|
|
cornflowerblue: "3xael",
|
|
cornsilk: "9zjz0",
|
|
crimson: "8l4xo",
|
|
cyan: "1ekf",
|
|
darkblue: "3v",
|
|
darkcyan: "rkb",
|
|
darkgoldenrod: "776yz",
|
|
darkgray: "6mbhl",
|
|
darkgreen: "jr4",
|
|
darkgrey: "6mbhl",
|
|
darkkhaki: "7ehkb",
|
|
darkmagenta: "5f91n",
|
|
darkolivegreen: "3bzfz",
|
|
darkorange: "9yygw",
|
|
darkorchid: "5z6x8",
|
|
darkred: "5f8xs",
|
|
darksalmon: "9441m",
|
|
darkseagreen: "5lwgf",
|
|
darkslateblue: "2th1n",
|
|
darkslategray: "1ugcv",
|
|
darkslategrey: "1ugcv",
|
|
darkturquoise: "14up",
|
|
darkviolet: "5rw7n",
|
|
deeppink: "9yavn",
|
|
deepskyblue: "11xb",
|
|
dimgray: "442g9",
|
|
dimgrey: "442g9",
|
|
dodgerblue: "16xof",
|
|
firebrick: "6y7tu",
|
|
floralwhite: "9zkds",
|
|
forestgreen: "1cisi",
|
|
fuchsia: "9y70f",
|
|
gainsboro: "8m8kc",
|
|
ghostwhite: "9pq0v",
|
|
goldenrod: "8j4f4",
|
|
gold: "9zda8",
|
|
gray: "50i2o",
|
|
green: "pa8",
|
|
greenyellow: "6senj",
|
|
grey: "50i2o",
|
|
honeydew: "9eiuo",
|
|
hotpink: "9yrp0",
|
|
indianred: "80gnw",
|
|
indigo: "2xcoy",
|
|
ivory: "9zldc",
|
|
khaki: "9edu4",
|
|
lavenderblush: "9ziet",
|
|
lavender: "90c8q",
|
|
lawngreen: "4vk74",
|
|
lemonchiffon: "9zkct",
|
|
lightblue: "6s73a",
|
|
lightcoral: "9dtog",
|
|
lightcyan: "8s1rz",
|
|
lightgoldenrodyellow: "9sjiq",
|
|
lightgray: "89jo3",
|
|
lightgreen: "5nkwg",
|
|
lightgrey: "89jo3",
|
|
lightpink: "9z6wx",
|
|
lightsalmon: "9z2ii",
|
|
lightseagreen: "19xgq",
|
|
lightskyblue: "5arju",
|
|
lightslategray: "4nwk9",
|
|
lightslategrey: "4nwk9",
|
|
lightsteelblue: "6wau6",
|
|
lightyellow: "9zlcw",
|
|
lime: "1edc",
|
|
limegreen: "1zcxe",
|
|
linen: "9shk6",
|
|
magenta: "9y70f",
|
|
maroon: "4zsow",
|
|
mediumaquamarine: "40eju",
|
|
mediumblue: "5p",
|
|
mediumorchid: "79qkz",
|
|
mediumpurple: "5r3rv",
|
|
mediumseagreen: "2d9ip",
|
|
mediumslateblue: "4tcku",
|
|
mediumspringgreen: "1di2",
|
|
mediumturquoise: "2uabw",
|
|
mediumvioletred: "7rn9h",
|
|
midnightblue: "z980",
|
|
mintcream: "9ljp6",
|
|
mistyrose: "9zg0x",
|
|
moccasin: "9zfzp",
|
|
navajowhite: "9zest",
|
|
navy: "3k",
|
|
oldlace: "9wq92",
|
|
olive: "50hz4",
|
|
olivedrab: "472ub",
|
|
orange: "9z3eo",
|
|
orangered: "9ykg0",
|
|
orchid: "8iu3a",
|
|
palegoldenrod: "9bl4a",
|
|
palegreen: "5yw0o",
|
|
paleturquoise: "6v4ku",
|
|
palevioletred: "8k8lv",
|
|
papayawhip: "9zi6t",
|
|
peachpuff: "9ze0p",
|
|
peru: "80oqn",
|
|
pink: "9z8wb",
|
|
plum: "8nba5",
|
|
powderblue: "6wgdi",
|
|
purple: "4zssg",
|
|
rebeccapurple: "3zk49",
|
|
red: "9y6tc",
|
|
rosybrown: "7cv4f",
|
|
royalblue: "2jvtt",
|
|
saddlebrown: "5fmkz",
|
|
salmon: "9rvci",
|
|
sandybrown: "9jn1c",
|
|
seagreen: "1tdnb",
|
|
seashell: "9zje6",
|
|
sienna: "6973h",
|
|
silver: "7ir40",
|
|
skyblue: "5arjf",
|
|
slateblue: "45e4t",
|
|
slategray: "4e100",
|
|
slategrey: "4e100",
|
|
snow: "9zke2",
|
|
springgreen: "1egv",
|
|
steelblue: "2r1kk",
|
|
tan: "87yx8",
|
|
teal: "pds",
|
|
thistle: "8ggk8",
|
|
tomato: "9yqfb",
|
|
turquoise: "2j4r4",
|
|
violet: "9b10u",
|
|
wheat: "9ld4j",
|
|
white: "9zldr",
|
|
whitesmoke: "9lhpx",
|
|
yellow: "9zl6o",
|
|
yellowgreen: "61fzm",
|
|
},
|
|
ti = Math.round;
|
|
function tl(e, t) {
|
|
let r =
|
|
e
|
|
.replace(/^[^(]*\((.*)/, "$1")
|
|
.replace(/\).*/, "")
|
|
.match(/\d*\.?\d+%?/g) || [],
|
|
n = r.map((e) => parseFloat(e));
|
|
for (let e = 0; e < 3; e += 1) n[e] = t(n[e] || 0, r[e] || "", e);
|
|
return (
|
|
r[3] ? (n[3] = r[3].includes("%") ? n[3] / 100 : n[3]) : (n[3] = 1), n
|
|
);
|
|
}
|
|
let ts = (e, t, r) => (0 === r ? e : e / 100);
|
|
function tc(e, t) {
|
|
let r = t || 255;
|
|
return e > r ? r : e < 0 ? 0 : e;
|
|
}
|
|
class tu {
|
|
isValid = !0;
|
|
r = 0;
|
|
g = 0;
|
|
b = 0;
|
|
a = 1;
|
|
_h;
|
|
_hsl_s;
|
|
_hsv_s;
|
|
_l;
|
|
_v;
|
|
_max;
|
|
_min;
|
|
_brightness;
|
|
constructor(e) {
|
|
function t(t) {
|
|
return t[0] in e && t[1] in e && t[2] in e;
|
|
}
|
|
if (e)
|
|
if ("string" == typeof e) {
|
|
const t = e.trim();
|
|
function r(e) {
|
|
return t.startsWith(e);
|
|
}
|
|
if (/^#?[A-F\d]{3,8}$/i.test(t)) this.fromHexString(t);
|
|
else if (r("rgb")) this.fromRgbString(t);
|
|
else if (r("hsl")) this.fromHslString(t);
|
|
else if (r("hsv") || r("hsb")) this.fromHsvString(t);
|
|
else {
|
|
const e = ta[t.toLowerCase()];
|
|
e &&
|
|
this.fromHexString(
|
|
parseInt(e, 36).toString(16).padStart(6, "0"),
|
|
);
|
|
}
|
|
} else if (e instanceof tu)
|
|
(this.r = e.r),
|
|
(this.g = e.g),
|
|
(this.b = e.b),
|
|
(this.a = e.a),
|
|
(this._h = e._h),
|
|
(this._hsl_s = e._hsl_s),
|
|
(this._hsv_s = e._hsv_s),
|
|
(this._l = e._l),
|
|
(this._v = e._v);
|
|
else if (t("rgb"))
|
|
(this.r = tc(e.r)),
|
|
(this.g = tc(e.g)),
|
|
(this.b = tc(e.b)),
|
|
(this.a = "number" == typeof e.a ? tc(e.a, 1) : 1);
|
|
else if (t("hsl")) this.fromHsl(e);
|
|
else if (t("hsv")) this.fromHsv(e);
|
|
else
|
|
throw Error(
|
|
"@ant-design/fast-color: unsupported input " + JSON.stringify(e),
|
|
);
|
|
}
|
|
setR(e) {
|
|
return this._sc("r", e);
|
|
}
|
|
setG(e) {
|
|
return this._sc("g", e);
|
|
}
|
|
setB(e) {
|
|
return this._sc("b", e);
|
|
}
|
|
setA(e) {
|
|
return this._sc("a", e, 1);
|
|
}
|
|
setHue(e) {
|
|
let t = this.toHsv();
|
|
return (t.h = e), this._c(t);
|
|
}
|
|
getLuminance() {
|
|
function e(e) {
|
|
let t = e / 255;
|
|
return t <= 0.03928 ? t / 12.92 : Math.pow((t + 0.055) / 1.055, 2.4);
|
|
}
|
|
return 0.2126 * e(this.r) + 0.7152 * e(this.g) + 0.0722 * e(this.b);
|
|
}
|
|
getHue() {
|
|
if (void 0 === this._h) {
|
|
let e = this.getMax() - this.getMin();
|
|
0 === e
|
|
? (this._h = 0)
|
|
: (this._h = ti(
|
|
60 *
|
|
(this.r === this.getMax()
|
|
? (this.g - this.b) / e + 6 * (this.g < this.b)
|
|
: this.g === this.getMax()
|
|
? (this.b - this.r) / e + 2
|
|
: (this.r - this.g) / e + 4),
|
|
));
|
|
}
|
|
return this._h;
|
|
}
|
|
getSaturation() {
|
|
return this.getHSVSaturation();
|
|
}
|
|
getHSVSaturation() {
|
|
if (void 0 === this._hsv_s) {
|
|
let e = this.getMax() - this.getMin();
|
|
0 === e ? (this._hsv_s = 0) : (this._hsv_s = e / this.getMax());
|
|
}
|
|
return this._hsv_s;
|
|
}
|
|
getHSLSaturation() {
|
|
if (void 0 === this._hsl_s) {
|
|
let e = this.getMax() - this.getMin();
|
|
if (0 === e) this._hsl_s = 0;
|
|
else {
|
|
let t = this.getLightness();
|
|
this._hsl_s = e / 255 / (1 - Math.abs(2 * t - 1));
|
|
}
|
|
}
|
|
return this._hsl_s;
|
|
}
|
|
getLightness() {
|
|
return (
|
|
void 0 === this._l &&
|
|
(this._l = (this.getMax() + this.getMin()) / 510),
|
|
this._l
|
|
);
|
|
}
|
|
getValue() {
|
|
return void 0 === this._v && (this._v = this.getMax() / 255), this._v;
|
|
}
|
|
getBrightness() {
|
|
return (
|
|
void 0 === this._brightness &&
|
|
(this._brightness =
|
|
(299 * this.r + 587 * this.g + 114 * this.b) / 1e3),
|
|
this._brightness
|
|
);
|
|
}
|
|
darken(e = 10) {
|
|
let t = this.getHue(),
|
|
r = this.getSaturation(),
|
|
n = this.getLightness() - e / 100;
|
|
return n < 0 && (n = 0), this._c({ h: t, s: r, l: n, a: this.a });
|
|
}
|
|
lighten(e = 10) {
|
|
let t = this.getHue(),
|
|
r = this.getSaturation(),
|
|
n = this.getLightness() + e / 100;
|
|
return n > 1 && (n = 1), this._c({ h: t, s: r, l: n, a: this.a });
|
|
}
|
|
mix(e, t = 50) {
|
|
let r = this._c(e),
|
|
n = t / 100,
|
|
o = (e) => (r[e] - this[e]) * n + this[e],
|
|
a = {
|
|
r: ti(o("r")),
|
|
g: ti(o("g")),
|
|
b: ti(o("b")),
|
|
a: ti(100 * o("a")) / 100,
|
|
};
|
|
return this._c(a);
|
|
}
|
|
tint(e = 10) {
|
|
return this.mix({ r: 255, g: 255, b: 255, a: 1 }, e);
|
|
}
|
|
shade(e = 10) {
|
|
return this.mix({ r: 0, g: 0, b: 0, a: 1 }, e);
|
|
}
|
|
onBackground(e) {
|
|
let t = this._c(e),
|
|
r = this.a + t.a * (1 - this.a),
|
|
n = (e) => ti((this[e] * this.a + t[e] * t.a * (1 - this.a)) / r);
|
|
return this._c({ r: n("r"), g: n("g"), b: n("b"), a: r });
|
|
}
|
|
isDark() {
|
|
return 128 > this.getBrightness();
|
|
}
|
|
isLight() {
|
|
return this.getBrightness() >= 128;
|
|
}
|
|
equals(e) {
|
|
return (
|
|
this.r === e.r && this.g === e.g && this.b === e.b && this.a === e.a
|
|
);
|
|
}
|
|
clone() {
|
|
return this._c(this);
|
|
}
|
|
toHexString() {
|
|
let e = "#",
|
|
t = (this.r || 0).toString(16);
|
|
e += 2 === t.length ? t : "0" + t;
|
|
let r = (this.g || 0).toString(16);
|
|
e += 2 === r.length ? r : "0" + r;
|
|
let n = (this.b || 0).toString(16);
|
|
if (
|
|
((e += 2 === n.length ? n : "0" + n),
|
|
"number" == typeof this.a && this.a >= 0 && this.a < 1)
|
|
) {
|
|
let t = ti(255 * this.a).toString(16);
|
|
e += 2 === t.length ? t : "0" + t;
|
|
}
|
|
return e;
|
|
}
|
|
toHsl() {
|
|
return {
|
|
h: this.getHue(),
|
|
s: this.getHSLSaturation(),
|
|
l: this.getLightness(),
|
|
a: this.a,
|
|
};
|
|
}
|
|
toHslString() {
|
|
let e = this.getHue(),
|
|
t = ti(100 * this.getHSLSaturation()),
|
|
r = ti(100 * this.getLightness());
|
|
return 1 !== this.a
|
|
? `hsla(${e},${t}%,${r}%,${this.a})`
|
|
: `hsl(${e},${t}%,${r}%)`;
|
|
}
|
|
toHsv() {
|
|
return {
|
|
h: this.getHue(),
|
|
s: this.getHSVSaturation(),
|
|
v: this.getValue(),
|
|
a: this.a,
|
|
};
|
|
}
|
|
toRgb() {
|
|
return { r: this.r, g: this.g, b: this.b, a: this.a };
|
|
}
|
|
toRgbString() {
|
|
return 1 !== this.a
|
|
? `rgba(${this.r},${this.g},${this.b},${this.a})`
|
|
: `rgb(${this.r},${this.g},${this.b})`;
|
|
}
|
|
toString() {
|
|
return this.toRgbString();
|
|
}
|
|
_sc(e, t, r) {
|
|
let n = this.clone();
|
|
return (n[e] = tc(t, r)), n;
|
|
}
|
|
_c(e) {
|
|
return new this.constructor(e);
|
|
}
|
|
getMax() {
|
|
return (
|
|
void 0 === this._max &&
|
|
(this._max = Math.max(this.r, this.g, this.b)),
|
|
this._max
|
|
);
|
|
}
|
|
getMin() {
|
|
return (
|
|
void 0 === this._min &&
|
|
(this._min = Math.min(this.r, this.g, this.b)),
|
|
this._min
|
|
);
|
|
}
|
|
fromHexString(e) {
|
|
let t = e.replace("#", "");
|
|
function r(e, r) {
|
|
return parseInt(t[e] + t[r || e], 16);
|
|
}
|
|
t.length < 6
|
|
? ((this.r = r(0)),
|
|
(this.g = r(1)),
|
|
(this.b = r(2)),
|
|
(this.a = t[3] ? r(3) / 255 : 1))
|
|
: ((this.r = r(0, 1)),
|
|
(this.g = r(2, 3)),
|
|
(this.b = r(4, 5)),
|
|
(this.a = t[6] ? r(6, 7) / 255 : 1));
|
|
}
|
|
fromHsl({ h: e, s: t, l: r, a: n }) {
|
|
let o = ((e % 360) + 360) % 360;
|
|
if (
|
|
((this._h = o),
|
|
(this._hsl_s = t),
|
|
(this._l = r),
|
|
(this.a = "number" == typeof n ? n : 1),
|
|
t <= 0)
|
|
) {
|
|
let e = ti(255 * r);
|
|
(this.r = e), (this.g = e), (this.b = e);
|
|
return;
|
|
}
|
|
let a = 0,
|
|
i = 0,
|
|
l = 0,
|
|
s = o / 60,
|
|
c = (1 - Math.abs(2 * r - 1)) * t,
|
|
u = c * (1 - Math.abs((s % 2) - 1));
|
|
s >= 0 && s < 1
|
|
? ((a = c), (i = u))
|
|
: s >= 1 && s < 2
|
|
? ((a = u), (i = c))
|
|
: s >= 2 && s < 3
|
|
? ((i = c), (l = u))
|
|
: s >= 3 && s < 4
|
|
? ((i = u), (l = c))
|
|
: s >= 4 && s < 5
|
|
? ((a = u), (l = c))
|
|
: s >= 5 && s < 6 && ((a = c), (l = u));
|
|
let d = r - c / 2;
|
|
(this.r = ti((a + d) * 255)),
|
|
(this.g = ti((i + d) * 255)),
|
|
(this.b = ti((l + d) * 255));
|
|
}
|
|
fromHsv({ h: e, s: t, v: r, a: n }) {
|
|
let o = ((e % 360) + 360) % 360;
|
|
(this._h = o),
|
|
(this._hsv_s = t),
|
|
(this._v = r),
|
|
(this.a = "number" == typeof n ? n : 1);
|
|
let a = ti(255 * r);
|
|
if (((this.r = a), (this.g = a), (this.b = a), t <= 0)) return;
|
|
let i = o / 60,
|
|
l = Math.floor(i),
|
|
s = i - l,
|
|
c = ti(r * (1 - t) * 255),
|
|
u = ti(r * (1 - t * s) * 255),
|
|
d = ti(r * (1 - t * (1 - s)) * 255);
|
|
switch (l) {
|
|
case 0:
|
|
(this.g = d), (this.b = c);
|
|
break;
|
|
case 1:
|
|
(this.r = u), (this.b = c);
|
|
break;
|
|
case 2:
|
|
(this.r = c), (this.b = d);
|
|
break;
|
|
case 3:
|
|
(this.r = c), (this.g = u);
|
|
break;
|
|
case 4:
|
|
(this.r = d), (this.g = c);
|
|
break;
|
|
default:
|
|
(this.g = c), (this.b = u);
|
|
}
|
|
}
|
|
fromHsvString(e) {
|
|
let t = tl(e, ts);
|
|
this.fromHsv({ h: t[0], s: t[1], v: t[2], a: t[3] });
|
|
}
|
|
fromHslString(e) {
|
|
let t = tl(e, ts);
|
|
this.fromHsl({ h: t[0], s: t[1], l: t[2], a: t[3] });
|
|
}
|
|
fromRgbString(e) {
|
|
let t = tl(e, (e, t) => (t.includes("%") ? ti((e / 100) * 255) : e));
|
|
(this.r = t[0]), (this.g = t[1]), (this.b = t[2]), (this.a = t[3]);
|
|
}
|
|
}
|
|
let td = [
|
|
{ index: 7, amount: 15 },
|
|
{ index: 6, amount: 25 },
|
|
{ index: 5, amount: 30 },
|
|
{ index: 5, amount: 45 },
|
|
{ index: 5, amount: 65 },
|
|
{ index: 5, amount: 85 },
|
|
{ index: 4, amount: 90 },
|
|
{ index: 3, amount: 95 },
|
|
{ index: 2, amount: 97 },
|
|
{ index: 1, amount: 98 },
|
|
];
|
|
function tf(e, t, r) {
|
|
let n;
|
|
return (
|
|
(n =
|
|
Math.round(e.h) >= 60 && 240 >= Math.round(e.h)
|
|
? r
|
|
? Math.round(e.h) - 2 * t
|
|
: Math.round(e.h) + 2 * t
|
|
: r
|
|
? Math.round(e.h) + 2 * t
|
|
: Math.round(e.h) - 2 * t) < 0
|
|
? (n += 360)
|
|
: n >= 360 && (n -= 360),
|
|
n
|
|
);
|
|
}
|
|
function tm(e, t, r) {
|
|
let n;
|
|
return 0 === e.h && 0 === e.s
|
|
? e.s
|
|
: ((n = r ? e.s - 0.16 * t : 4 === t ? e.s + 0.16 : e.s + 0.05 * t) >
|
|
1 && (n = 1),
|
|
r && 5 === t && n > 0.1 && (n = 0.1),
|
|
n < 0.06 && (n = 0.06),
|
|
Math.round(100 * n) / 100);
|
|
}
|
|
function tp(e, t, r) {
|
|
return (
|
|
Math.round(
|
|
100 * Math.max(0, Math.min(1, r ? e.v + 0.05 * t : e.v - 0.15 * t)),
|
|
) / 100
|
|
);
|
|
}
|
|
function th(e, t = {}) {
|
|
let r = [],
|
|
n = new tu(e),
|
|
o = n.toHsv();
|
|
for (let e = 5; e > 0; e -= 1) {
|
|
let t = new tu({ h: tf(o, e, !0), s: tm(o, e, !0), v: tp(o, e, !0) });
|
|
r.push(t);
|
|
}
|
|
r.push(n);
|
|
for (let e = 1; e <= 4; e += 1) {
|
|
let t = new tu({ h: tf(o, e), s: tm(o, e), v: tp(o, e) });
|
|
r.push(t);
|
|
}
|
|
return "dark" === t.theme
|
|
? td.map(({ index: e, amount: n }) =>
|
|
new tu(t.backgroundColor || "#141414").mix(r[e], n).toHexString(),
|
|
)
|
|
: r.map((e) => e.toHexString());
|
|
}
|
|
let tg = {
|
|
red: "#F5222D",
|
|
volcano: "#FA541C",
|
|
orange: "#FA8C16",
|
|
gold: "#FAAD14",
|
|
yellow: "#FADB14",
|
|
lime: "#A0D911",
|
|
green: "#52C41A",
|
|
cyan: "#13C2C2",
|
|
blue: "#1677FF",
|
|
geekblue: "#2F54EB",
|
|
purple: "#722ED1",
|
|
magenta: "#EB2F96",
|
|
grey: "#666666",
|
|
},
|
|
tb = [
|
|
"#fff1f0",
|
|
"#ffccc7",
|
|
"#ffa39e",
|
|
"#ff7875",
|
|
"#ff4d4f",
|
|
"#f5222d",
|
|
"#cf1322",
|
|
"#a8071a",
|
|
"#820014",
|
|
"#5c0011",
|
|
];
|
|
tb.primary = tb[5];
|
|
let tv = [
|
|
"#fff2e8",
|
|
"#ffd8bf",
|
|
"#ffbb96",
|
|
"#ff9c6e",
|
|
"#ff7a45",
|
|
"#fa541c",
|
|
"#d4380d",
|
|
"#ad2102",
|
|
"#871400",
|
|
"#610b00",
|
|
];
|
|
tv.primary = tv[5];
|
|
let t_ = [
|
|
"#fff7e6",
|
|
"#ffe7ba",
|
|
"#ffd591",
|
|
"#ffc069",
|
|
"#ffa940",
|
|
"#fa8c16",
|
|
"#d46b08",
|
|
"#ad4e00",
|
|
"#873800",
|
|
"#612500",
|
|
];
|
|
t_.primary = t_[5];
|
|
let ty = [
|
|
"#fffbe6",
|
|
"#fff1b8",
|
|
"#ffe58f",
|
|
"#ffd666",
|
|
"#ffc53d",
|
|
"#faad14",
|
|
"#d48806",
|
|
"#ad6800",
|
|
"#874d00",
|
|
"#613400",
|
|
];
|
|
ty.primary = ty[5];
|
|
let tx = [
|
|
"#feffe6",
|
|
"#ffffb8",
|
|
"#fffb8f",
|
|
"#fff566",
|
|
"#ffec3d",
|
|
"#fadb14",
|
|
"#d4b106",
|
|
"#ad8b00",
|
|
"#876800",
|
|
"#614700",
|
|
];
|
|
tx.primary = tx[5];
|
|
let tC = [
|
|
"#fcffe6",
|
|
"#f4ffb8",
|
|
"#eaff8f",
|
|
"#d3f261",
|
|
"#bae637",
|
|
"#a0d911",
|
|
"#7cb305",
|
|
"#5b8c00",
|
|
"#3f6600",
|
|
"#254000",
|
|
];
|
|
tC.primary = tC[5];
|
|
let tE = [
|
|
"#f6ffed",
|
|
"#d9f7be",
|
|
"#b7eb8f",
|
|
"#95de64",
|
|
"#73d13d",
|
|
"#52c41a",
|
|
"#389e0d",
|
|
"#237804",
|
|
"#135200",
|
|
"#092b00",
|
|
];
|
|
tE.primary = tE[5];
|
|
let tS = [
|
|
"#e6fffb",
|
|
"#b5f5ec",
|
|
"#87e8de",
|
|
"#5cdbd3",
|
|
"#36cfc9",
|
|
"#13c2c2",
|
|
"#08979c",
|
|
"#006d75",
|
|
"#00474f",
|
|
"#002329",
|
|
];
|
|
tS.primary = tS[5];
|
|
let tw = [
|
|
"#e6f4ff",
|
|
"#bae0ff",
|
|
"#91caff",
|
|
"#69b1ff",
|
|
"#4096ff",
|
|
"#1677ff",
|
|
"#0958d9",
|
|
"#003eb3",
|
|
"#002c8c",
|
|
"#001d66",
|
|
];
|
|
tw.primary = tw[5];
|
|
let tk = [
|
|
"#f0f5ff",
|
|
"#d6e4ff",
|
|
"#adc6ff",
|
|
"#85a5ff",
|
|
"#597ef7",
|
|
"#2f54eb",
|
|
"#1d39c4",
|
|
"#10239e",
|
|
"#061178",
|
|
"#030852",
|
|
];
|
|
tk.primary = tk[5];
|
|
let tj = [
|
|
"#f9f0ff",
|
|
"#efdbff",
|
|
"#d3adf7",
|
|
"#b37feb",
|
|
"#9254de",
|
|
"#722ed1",
|
|
"#531dab",
|
|
"#391085",
|
|
"#22075e",
|
|
"#120338",
|
|
];
|
|
tj.primary = tj[5];
|
|
let tP = [
|
|
"#fff0f6",
|
|
"#ffd6e7",
|
|
"#ffadd2",
|
|
"#ff85c0",
|
|
"#f759ab",
|
|
"#eb2f96",
|
|
"#c41d7f",
|
|
"#9e1068",
|
|
"#780650",
|
|
"#520339",
|
|
];
|
|
tP.primary = tP[5];
|
|
let tR = [
|
|
"#a6a6a6",
|
|
"#999999",
|
|
"#8c8c8c",
|
|
"#808080",
|
|
"#737373",
|
|
"#666666",
|
|
"#404040",
|
|
"#1a1a1a",
|
|
"#000000",
|
|
"#000000",
|
|
];
|
|
tR.primary = tR[5];
|
|
let tN = {
|
|
red: tb,
|
|
volcano: tv,
|
|
orange: t_,
|
|
gold: ty,
|
|
yellow: tx,
|
|
lime: tC,
|
|
green: tE,
|
|
cyan: tS,
|
|
blue: tw,
|
|
geekblue: tk,
|
|
purple: tj,
|
|
magenta: tP,
|
|
grey: tR,
|
|
},
|
|
t$ = [
|
|
"#2a1215",
|
|
"#431418",
|
|
"#58181c",
|
|
"#791a1f",
|
|
"#a61d24",
|
|
"#d32029",
|
|
"#e84749",
|
|
"#f37370",
|
|
"#f89f9a",
|
|
"#fac8c3",
|
|
];
|
|
t$.primary = t$[5];
|
|
let tO = [
|
|
"#2b1611",
|
|
"#441d12",
|
|
"#592716",
|
|
"#7c3118",
|
|
"#aa3e19",
|
|
"#d84a1b",
|
|
"#e87040",
|
|
"#f3956a",
|
|
"#f8b692",
|
|
"#fad4bc",
|
|
];
|
|
tO.primary = tO[5];
|
|
let tT = [
|
|
"#2b1d11",
|
|
"#442a11",
|
|
"#593815",
|
|
"#7c4a15",
|
|
"#aa6215",
|
|
"#d87a16",
|
|
"#e89a3c",
|
|
"#f3b765",
|
|
"#f8cf8d",
|
|
"#fae3b7",
|
|
];
|
|
tT.primary = tT[5];
|
|
let tM = [
|
|
"#2b2111",
|
|
"#443111",
|
|
"#594214",
|
|
"#7c5914",
|
|
"#aa7714",
|
|
"#d89614",
|
|
"#e8b339",
|
|
"#f3cc62",
|
|
"#f8df8b",
|
|
"#faedb5",
|
|
];
|
|
tM.primary = tM[5];
|
|
let tI = [
|
|
"#2b2611",
|
|
"#443b11",
|
|
"#595014",
|
|
"#7c6e14",
|
|
"#aa9514",
|
|
"#d8bd14",
|
|
"#e8d639",
|
|
"#f3ea62",
|
|
"#f8f48b",
|
|
"#fafab5",
|
|
];
|
|
tI.primary = tI[5];
|
|
let tA = [
|
|
"#1f2611",
|
|
"#2e3c10",
|
|
"#3e4f13",
|
|
"#536d13",
|
|
"#6f9412",
|
|
"#8bbb11",
|
|
"#a9d134",
|
|
"#c9e75d",
|
|
"#e4f88b",
|
|
"#f0fab5",
|
|
];
|
|
tA.primary = tA[5];
|
|
let tL = [
|
|
"#162312",
|
|
"#1d3712",
|
|
"#274916",
|
|
"#306317",
|
|
"#3c8618",
|
|
"#49aa19",
|
|
"#6abe39",
|
|
"#8fd460",
|
|
"#b2e58b",
|
|
"#d5f2bb",
|
|
];
|
|
tL.primary = tL[5];
|
|
let tB = [
|
|
"#112123",
|
|
"#113536",
|
|
"#144848",
|
|
"#146262",
|
|
"#138585",
|
|
"#13a8a8",
|
|
"#33bcb7",
|
|
"#58d1c9",
|
|
"#84e2d8",
|
|
"#b2f1e8",
|
|
];
|
|
tB.primary = tB[5];
|
|
let tD = [
|
|
"#111a2c",
|
|
"#112545",
|
|
"#15325b",
|
|
"#15417e",
|
|
"#1554ad",
|
|
"#1668dc",
|
|
"#3c89e8",
|
|
"#65a9f3",
|
|
"#8dc5f8",
|
|
"#b7dcfa",
|
|
];
|
|
tD.primary = tD[5];
|
|
let tH = [
|
|
"#131629",
|
|
"#161d40",
|
|
"#1c2755",
|
|
"#203175",
|
|
"#263ea0",
|
|
"#2b4acb",
|
|
"#5273e0",
|
|
"#7f9ef3",
|
|
"#a8c1f8",
|
|
"#d2e0fa",
|
|
];
|
|
tH.primary = tH[5];
|
|
let tz = [
|
|
"#1a1325",
|
|
"#24163a",
|
|
"#301c4d",
|
|
"#3e2069",
|
|
"#51258f",
|
|
"#642ab5",
|
|
"#854eca",
|
|
"#ab7ae0",
|
|
"#cda8f0",
|
|
"#ebd7fa",
|
|
];
|
|
tz.primary = tz[5];
|
|
let tW = [
|
|
"#291321",
|
|
"#40162f",
|
|
"#551c3b",
|
|
"#75204f",
|
|
"#a02669",
|
|
"#cb2b83",
|
|
"#e0529c",
|
|
"#f37fb7",
|
|
"#f8a8cc",
|
|
"#fad2e3",
|
|
];
|
|
tW.primary = tW[5];
|
|
let tF = [
|
|
"#151515",
|
|
"#1f1f1f",
|
|
"#2d2d2d",
|
|
"#393939",
|
|
"#494949",
|
|
"#5a5a5a",
|
|
"#6a6a6a",
|
|
"#7b7b7b",
|
|
"#888888",
|
|
"#969696",
|
|
];
|
|
tF.primary = tF[5];
|
|
let tU = {
|
|
blue: "#1677FF",
|
|
purple: "#722ED1",
|
|
cyan: "#13C2C2",
|
|
green: "#52C41A",
|
|
magenta: "#EB2F96",
|
|
pink: "#EB2F96",
|
|
red: "#F5222D",
|
|
orange: "#FA8C16",
|
|
yellow: "#FADB14",
|
|
volcano: "#FA541C",
|
|
geekblue: "#2F54EB",
|
|
gold: "#FAAD14",
|
|
lime: "#A0D911",
|
|
},
|
|
tG = {
|
|
...tU,
|
|
colorPrimary: "#1677ff",
|
|
colorSuccess: "#52c41a",
|
|
colorWarning: "#faad14",
|
|
colorError: "#ff4d4f",
|
|
colorInfo: "#1677ff",
|
|
colorLink: "",
|
|
colorTextBase: "",
|
|
colorBgBase: "",
|
|
fontFamily: `-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
|
|
'Noto Sans', sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol',
|
|
'Noto Color Emoji'`,
|
|
fontFamilyCode:
|
|
"'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier, monospace",
|
|
fontSize: 14,
|
|
lineWidth: 1,
|
|
lineType: "solid",
|
|
motionUnit: 0.1,
|
|
motionBase: 0,
|
|
motionEaseOutCirc: "cubic-bezier(0.08, 0.82, 0.17, 1)",
|
|
motionEaseInOutCirc: "cubic-bezier(0.78, 0.14, 0.15, 0.86)",
|
|
motionEaseOut: "cubic-bezier(0.215, 0.61, 0.355, 1)",
|
|
motionEaseInOut: "cubic-bezier(0.645, 0.045, 0.355, 1)",
|
|
motionEaseOutBack: "cubic-bezier(0.12, 0.4, 0.29, 1.46)",
|
|
motionEaseInBack: "cubic-bezier(0.71, -0.46, 0.88, 0.6)",
|
|
motionEaseInQuint: "cubic-bezier(0.755, 0.05, 0.855, 0.06)",
|
|
motionEaseOutQuint: "cubic-bezier(0.23, 1, 0.32, 1)",
|
|
borderRadius: 6,
|
|
sizeUnit: 4,
|
|
sizeStep: 4,
|
|
sizePopupArrow: 16,
|
|
controlHeight: 32,
|
|
zIndexBase: 0,
|
|
zIndexPopupBase: 1e3,
|
|
opacityImage: 1,
|
|
wireframe: !1,
|
|
motion: !0,
|
|
},
|
|
tq = (e, t) => new tu(e).setA(t).toRgbString(),
|
|
tX = (e, t) => new tu(e).darken(t).toHexString(),
|
|
tK = (e) => {
|
|
let t = th(e);
|
|
return {
|
|
1: t[0],
|
|
2: t[1],
|
|
3: t[2],
|
|
4: t[3],
|
|
5: t[4],
|
|
6: t[5],
|
|
7: t[6],
|
|
8: t[4],
|
|
9: t[5],
|
|
10: t[6],
|
|
};
|
|
},
|
|
tV = (e, t) => {
|
|
let r = e || "#fff",
|
|
n = t || "#000";
|
|
return {
|
|
colorBgBase: r,
|
|
colorTextBase: n,
|
|
colorText: tq(n, 0.88),
|
|
colorTextSecondary: tq(n, 0.65),
|
|
colorTextTertiary: tq(n, 0.45),
|
|
colorTextQuaternary: tq(n, 0.25),
|
|
colorFill: tq(n, 0.15),
|
|
colorFillSecondary: tq(n, 0.06),
|
|
colorFillTertiary: tq(n, 0.04),
|
|
colorFillQuaternary: tq(n, 0.02),
|
|
colorBgSolid: tq(n, 1),
|
|
colorBgSolidHover: tq(n, 0.75),
|
|
colorBgSolidActive: tq(n, 0.95),
|
|
colorBgLayout: tX(r, 4),
|
|
colorBgContainer: tX(r, 0),
|
|
colorBgElevated: tX(r, 0),
|
|
colorBgSpotlight: tq(n, 0.85),
|
|
colorBgBlur: "transparent",
|
|
colorBorder: tX(r, 15),
|
|
colorBorderDisabled: tX(r, 15),
|
|
colorBorderSecondary: tX(r, 6),
|
|
};
|
|
},
|
|
tY = er(function (e) {
|
|
var t;
|
|
let r, n, o, a, i, l, s, c, u, d;
|
|
(tg.pink = tg.magenta), (tN.pink = tN.magenta);
|
|
let f = Object.keys(tU)
|
|
.map((t) => {
|
|
let r = e[t] === tg[t] ? tN[t] : th(e[t]);
|
|
return Array.from({ length: 10 }, () => 1).reduce(
|
|
(e, n, o) => (
|
|
(e[`${t}-${o + 1}`] = r[o]), (e[`${t}${o + 1}`] = r[o]), e
|
|
),
|
|
{},
|
|
);
|
|
})
|
|
.reduce((e, t) => (e = { ...e, ...t }), {});
|
|
return {
|
|
...e,
|
|
...f,
|
|
...(function (
|
|
e,
|
|
{ generateColorPalettes: t, generateNeutralColorPalettes: r },
|
|
) {
|
|
let {
|
|
colorSuccess: n,
|
|
colorWarning: o,
|
|
colorError: a,
|
|
colorInfo: i,
|
|
colorPrimary: l,
|
|
colorBgBase: s,
|
|
colorTextBase: c,
|
|
} = e,
|
|
u = t(l),
|
|
d = t(n),
|
|
f = t(o),
|
|
m = t(a),
|
|
p = t(i),
|
|
h = r(s, c),
|
|
g = t(e.colorLink || e.colorInfo),
|
|
b = new tu(m[1]).mix(new tu(m[3]), 50).toHexString();
|
|
return {
|
|
...h,
|
|
colorPrimaryBg: u[1],
|
|
colorPrimaryBgHover: u[2],
|
|
colorPrimaryBorder: u[3],
|
|
colorPrimaryBorderHover: u[4],
|
|
colorPrimaryHover: u[5],
|
|
colorPrimary: u[6],
|
|
colorPrimaryActive: u[7],
|
|
colorPrimaryTextHover: u[8],
|
|
colorPrimaryText: u[9],
|
|
colorPrimaryTextActive: u[10],
|
|
colorSuccessBg: d[1],
|
|
colorSuccessBgHover: d[2],
|
|
colorSuccessBorder: d[3],
|
|
colorSuccessBorderHover: d[4],
|
|
colorSuccessHover: d[4],
|
|
colorSuccess: d[6],
|
|
colorSuccessActive: d[7],
|
|
colorSuccessTextHover: d[8],
|
|
colorSuccessText: d[9],
|
|
colorSuccessTextActive: d[10],
|
|
colorErrorBg: m[1],
|
|
colorErrorBgHover: m[2],
|
|
colorErrorBgFilledHover: b,
|
|
colorErrorBgActive: m[3],
|
|
colorErrorBorder: m[3],
|
|
colorErrorBorderHover: m[4],
|
|
colorErrorHover: m[5],
|
|
colorError: m[6],
|
|
colorErrorActive: m[7],
|
|
colorErrorTextHover: m[8],
|
|
colorErrorText: m[9],
|
|
colorErrorTextActive: m[10],
|
|
colorWarningBg: f[1],
|
|
colorWarningBgHover: f[2],
|
|
colorWarningBorder: f[3],
|
|
colorWarningBorderHover: f[4],
|
|
colorWarningHover: f[4],
|
|
colorWarning: f[6],
|
|
colorWarningActive: f[7],
|
|
colorWarningTextHover: f[8],
|
|
colorWarningText: f[9],
|
|
colorWarningTextActive: f[10],
|
|
colorInfoBg: p[1],
|
|
colorInfoBgHover: p[2],
|
|
colorInfoBorder: p[3],
|
|
colorInfoBorderHover: p[4],
|
|
colorInfoHover: p[4],
|
|
colorInfo: p[6],
|
|
colorInfoActive: p[7],
|
|
colorInfoTextHover: p[8],
|
|
colorInfoText: p[9],
|
|
colorInfoTextActive: p[10],
|
|
colorLinkHover: g[4],
|
|
colorLink: g[6],
|
|
colorLinkActive: g[7],
|
|
colorBgMask: new tu("#000").setA(0.45).toRgbString(),
|
|
colorWhite: "#fff",
|
|
};
|
|
})(e, {
|
|
generateColorPalettes: tK,
|
|
generateNeutralColorPalettes: tV,
|
|
}),
|
|
...((t = e.fontSize),
|
|
((r = Array.from({ length: 10 }).map((e, r) => {
|
|
let n = t * Math.E ** ((r - 1) / 5);
|
|
return 2 * Math.floor((r > 1 ? Math.floor(n) : Math.ceil(n)) / 2);
|
|
}))[1] = t),
|
|
(o = (n = r.map((e) => ({ size: e, lineHeight: (e + 8) / e }))).map(
|
|
(e) => e.size,
|
|
)),
|
|
(a = n.map((e) => e.lineHeight)),
|
|
(i = o[1]),
|
|
(l = o[0]),
|
|
(s = o[2]),
|
|
(c = a[1]),
|
|
(u = a[0]),
|
|
(d = a[2]),
|
|
{
|
|
fontSizeSM: l,
|
|
fontSize: i,
|
|
fontSizeLG: s,
|
|
fontSizeXL: o[3],
|
|
fontSizeHeading1: o[6],
|
|
fontSizeHeading2: o[5],
|
|
fontSizeHeading3: o[4],
|
|
fontSizeHeading4: o[3],
|
|
fontSizeHeading5: o[2],
|
|
lineHeight: c,
|
|
lineHeightLG: d,
|
|
lineHeightSM: u,
|
|
fontHeight: Math.round(c * i),
|
|
fontHeightLG: Math.round(d * s),
|
|
fontHeightSM: Math.round(u * l),
|
|
lineHeightHeading1: a[6],
|
|
lineHeightHeading2: a[5],
|
|
lineHeightHeading3: a[4],
|
|
lineHeightHeading4: a[3],
|
|
lineHeightHeading5: a[2],
|
|
}),
|
|
...(function (e) {
|
|
let { sizeUnit: t, sizeStep: r } = e;
|
|
return {
|
|
sizeXXL: t * (r + 8),
|
|
sizeXL: t * (r + 4),
|
|
sizeLG: t * (r + 2),
|
|
sizeMD: t * (r + 1),
|
|
sizeMS: t * r,
|
|
size: t * r,
|
|
sizeSM: t * (r - 1),
|
|
sizeXS: t * (r - 2),
|
|
sizeXXS: t * (r - 3),
|
|
};
|
|
})(e),
|
|
...((e) => {
|
|
let { controlHeight: t } = e;
|
|
return {
|
|
controlHeightSM: 0.75 * t,
|
|
controlHeightXS: 0.5 * t,
|
|
controlHeightLG: 1.25 * t,
|
|
};
|
|
})(e),
|
|
...(function (e) {
|
|
let t,
|
|
r,
|
|
n,
|
|
o,
|
|
{
|
|
motionUnit: a,
|
|
motionBase: i,
|
|
borderRadius: l,
|
|
lineWidth: s,
|
|
} = e;
|
|
return {
|
|
motionDurationFast: `${(i + a).toFixed(1)}s`,
|
|
motionDurationMid: `${(i + 2 * a).toFixed(1)}s`,
|
|
motionDurationSlow: `${(i + 3 * a).toFixed(1)}s`,
|
|
lineWidthBold: s + 1,
|
|
...((t = l),
|
|
(r = l),
|
|
(n = l),
|
|
(o = l),
|
|
l < 6 && l >= 5
|
|
? (t = l + 1)
|
|
: l < 16 && l >= 6
|
|
? (t = l + 2)
|
|
: l >= 16 && (t = 16),
|
|
l < 7 && l >= 5
|
|
? (r = 4)
|
|
: l < 8 && l >= 7
|
|
? (r = 5)
|
|
: l < 14 && l >= 8
|
|
? (r = 6)
|
|
: l < 16 && l >= 14
|
|
? (r = 7)
|
|
: l >= 16 && (r = 8),
|
|
l < 6 && l >= 2 ? (n = 1) : l >= 6 && (n = 2),
|
|
l > 4 && l < 8 ? (o = 4) : l >= 8 && (o = 6),
|
|
{
|
|
borderRadius: l,
|
|
borderRadiusXS: n,
|
|
borderRadiusSM: r,
|
|
borderRadiusLG: t,
|
|
borderRadiusOuter: o,
|
|
}),
|
|
};
|
|
})(e),
|
|
};
|
|
}),
|
|
tQ = { token: tG, override: { override: tG }, hashed: !0 },
|
|
tZ = m.default.createContext(tQ);
|
|
var tJ = e.i(111558);
|
|
let t0 = m.createContext(null),
|
|
t1 = [],
|
|
t2 = `rc-util-locker-${Date.now()}`,
|
|
t4 = 0,
|
|
t6 = 0,
|
|
t3 = { ...m }.useId,
|
|
t5 = t3
|
|
? function (e) {
|
|
let t = t3();
|
|
return e || t;
|
|
}
|
|
: function (e) {
|
|
let [t, r] = m.useState("ssr-id");
|
|
return (m.useEffect(() => {
|
|
let e = t6;
|
|
(t6 += 1), r(`rc_unique_${e}`);
|
|
}, []),
|
|
e)
|
|
? e
|
|
: t;
|
|
},
|
|
t8 = [],
|
|
t7 = 0,
|
|
t9 = (e) => {
|
|
if ("Escape" === e.key && !e.isComposing) {
|
|
if (Date.now() - t7 < 200) return;
|
|
let t = t8.length;
|
|
for (let r = t - 1; r >= 0; r -= 1)
|
|
t8[r].onEsc({ top: r === t - 1, event: e });
|
|
}
|
|
},
|
|
re = () => {
|
|
t7 = Date.now();
|
|
},
|
|
rt = (e) =>
|
|
!1 !== e &&
|
|
(k() && e
|
|
? "string" == typeof e
|
|
? document.querySelector(e)
|
|
: "function" == typeof e
|
|
? e()
|
|
: e
|
|
: null),
|
|
rr = m.forwardRef((e, t) => {
|
|
let r,
|
|
n,
|
|
o,
|
|
a,
|
|
{
|
|
open: i,
|
|
autoLock: l,
|
|
getContainer: s,
|
|
debug: c,
|
|
autoDestroy: u = !0,
|
|
children: d,
|
|
onEsc: f,
|
|
} = e,
|
|
[p, h] = m.useState(i),
|
|
g = p || i;
|
|
m.useEffect(() => {
|
|
(u || i) && h(i);
|
|
}, [i, u]);
|
|
let [b, v] = m.useState(() => rt(s));
|
|
m.useEffect(() => {
|
|
let e = rt(s);
|
|
v(() => e ?? null);
|
|
});
|
|
let [_, y] = (function (e, t) {
|
|
let [r] = m.useState(() =>
|
|
k() ? document.createElement("div") : null,
|
|
),
|
|
n = m.useRef(!1),
|
|
o = m.useContext(t0),
|
|
[a, i] = m.useState(t1),
|
|
l =
|
|
o ||
|
|
(n.current
|
|
? void 0
|
|
: (e) => {
|
|
i((t) => [e, ...t]);
|
|
});
|
|
function s() {
|
|
r.parentElement || document.body.appendChild(r), (n.current = !0);
|
|
}
|
|
function c() {
|
|
r.parentElement?.removeChild(r), (n.current = !1);
|
|
}
|
|
return (
|
|
eL(() => (e ? (o ? o(s) : s()) : c(), c), [e]),
|
|
eL(() => {
|
|
a.length && (a.forEach((e) => e()), i(t1));
|
|
}, [a]),
|
|
[r, l]
|
|
);
|
|
})(g && !b, 0),
|
|
x = b ?? _;
|
|
!(function (e) {
|
|
let t = !!e,
|
|
[r] = m.useState(() => ((t4 += 1), `${t2}_${t4}`));
|
|
eL(() => {
|
|
if (t) {
|
|
var e;
|
|
let t = ((e = document.body),
|
|
"u" < typeof document || !e || !(e instanceof Element)
|
|
? { width: 0, height: 0 }
|
|
: (function (e) {
|
|
let t,
|
|
r,
|
|
n = `rc-scrollbar-measure-${Math.random().toString(36).substring(7)}`,
|
|
o = document.createElement("div");
|
|
o.id = n;
|
|
let a = o.style;
|
|
if (
|
|
((a.position = "absolute"),
|
|
(a.left = "0"),
|
|
(a.top = "0"),
|
|
(a.width = "100px"),
|
|
(a.height = "100px"),
|
|
(a.overflow = "scroll"),
|
|
e)
|
|
) {
|
|
let o = getComputedStyle(e);
|
|
(a.scrollbarColor = o.scrollbarColor),
|
|
(a.scrollbarWidth = o.scrollbarWidth);
|
|
let i = getComputedStyle(e, "::-webkit-scrollbar"),
|
|
l = parseInt(i.width, 10),
|
|
s = parseInt(i.height, 10);
|
|
try {
|
|
let e = l ? `width: ${i.width};` : "",
|
|
t = s ? `height: ${i.height};` : "";
|
|
A(
|
|
`
|
|
#${n}::-webkit-scrollbar {
|
|
${e}
|
|
${t}
|
|
}`,
|
|
n,
|
|
);
|
|
} catch (e) {
|
|
console.error(e), (t = l), (r = s);
|
|
}
|
|
}
|
|
document.body.appendChild(o);
|
|
let i =
|
|
e && t && !isNaN(t)
|
|
? t
|
|
: o.offsetWidth - o.clientWidth,
|
|
l =
|
|
e && r && !isNaN(r)
|
|
? r
|
|
: o.offsetHeight - o.clientHeight;
|
|
return (
|
|
document.body.removeChild(o),
|
|
I(n),
|
|
{ width: i, height: l }
|
|
);
|
|
})(e)).width,
|
|
n =
|
|
document.body.scrollHeight >
|
|
(window.innerHeight ||
|
|
document.documentElement.clientHeight) &&
|
|
window.innerWidth > document.body.offsetWidth;
|
|
A(
|
|
`
|
|
html body {
|
|
overflow-y: hidden;
|
|
${n ? `width: calc(100% - ${t}px);` : ""}
|
|
}`,
|
|
r,
|
|
);
|
|
} else I(r);
|
|
return () => {
|
|
I(r);
|
|
};
|
|
}, [t, r]);
|
|
})(l && i && k() && (x === _ || x === document.body)),
|
|
(r = t5()),
|
|
(n = eI(f)),
|
|
(o = () => {
|
|
t8.find((e) => e.id === r) || t8.push({ id: r, onEsc: n });
|
|
}),
|
|
(a = () => {
|
|
t8 = t8.filter((e) => e.id !== r);
|
|
}),
|
|
(0, m.useMemo)(() => {
|
|
i ? o() : i || a();
|
|
}, [i]),
|
|
(0, m.useEffect)(() => {
|
|
if (i)
|
|
return (
|
|
o(),
|
|
window.addEventListener("keydown", t9),
|
|
window.addEventListener("compositionend", re),
|
|
() => {
|
|
a(),
|
|
0 === t8.length &&
|
|
(window.removeEventListener("keydown", t9),
|
|
window.removeEventListener("compositionend", re));
|
|
}
|
|
);
|
|
}, [i]);
|
|
let C = null;
|
|
d && eX(d) && t && (C = eV(d));
|
|
let E = eq(C, t);
|
|
if (!g || !k() || void 0 === b) return null;
|
|
let S = !1 === x,
|
|
w = d;
|
|
return (
|
|
t && (w = m.cloneElement(d, { ref: E })),
|
|
m.createElement(
|
|
t0.Provider,
|
|
{ value: y },
|
|
S ? w : (0, tJ.createPortal)(w, x),
|
|
)
|
|
);
|
|
});
|
|
var rn = e.i(7284);
|
|
function ro(e) {
|
|
return e instanceof HTMLElement || e instanceof SVGElement;
|
|
}
|
|
function ra(e) {
|
|
return e && "object" == typeof e && ro(e.nativeElement)
|
|
? e.nativeElement
|
|
: ro(e)
|
|
? e
|
|
: null;
|
|
}
|
|
let ri = m.createContext(null),
|
|
rl = new Map();
|
|
function rs(e) {
|
|
e.forEach((e) => {
|
|
let { target: t } = e;
|
|
rl.get(t)?.forEach((e) => e(t));
|
|
});
|
|
}
|
|
function rc() {
|
|
return r || (r = new ResizeObserver(rs)), r;
|
|
}
|
|
function ru(e, t, r, n) {
|
|
let o = m.useRef({
|
|
width: -1,
|
|
height: -1,
|
|
offsetWidth: -1,
|
|
offsetHeight: -1,
|
|
}),
|
|
a = eI((e) => {
|
|
let { width: t, height: a } = e.getBoundingClientRect(),
|
|
{ offsetWidth: i, offsetHeight: l } = e,
|
|
s = Math.floor(t),
|
|
c = Math.floor(a);
|
|
if (
|
|
o.current.width !== s ||
|
|
o.current.height !== c ||
|
|
o.current.offsetWidth !== i ||
|
|
o.current.offsetHeight !== l
|
|
) {
|
|
let u = { width: s, height: c, offsetWidth: i, offsetHeight: l };
|
|
o.current = u;
|
|
let d = i === Math.round(t) ? t : i,
|
|
f = l === Math.round(a) ? a : l,
|
|
m = { ...u, offsetWidth: d, offsetHeight: f };
|
|
n?.(m, e),
|
|
Promise.resolve().then(() => {
|
|
r?.(m, e);
|
|
});
|
|
}
|
|
}),
|
|
i = "function" == typeof t;
|
|
m.useEffect(() => {
|
|
let r = i ? t() : t;
|
|
return (
|
|
r &&
|
|
e &&
|
|
(rl.has(r) || (rl.set(r, new Set()), rc().observe(r)),
|
|
rl.get(r).add(a)),
|
|
() => {
|
|
r &&
|
|
rl.has(r) &&
|
|
(rl.get(r).delete(a),
|
|
rl.get(r).size || (rc().unobserve(r), rl.delete(r)));
|
|
}
|
|
);
|
|
}, [e, i ? 0 : t]);
|
|
}
|
|
let rd = m.forwardRef(function (e, t) {
|
|
let { children: r, disabled: n, onResize: o, data: a } = e,
|
|
i = m.useRef(null),
|
|
l = m.useContext(ri),
|
|
s = "function" == typeof r,
|
|
c = s ? r(i) : r,
|
|
u = !s && m.isValidElement(c) && eX(c),
|
|
d = eq(u ? eV(c) : null, i),
|
|
f = () => ra(i.current);
|
|
return (
|
|
m.useImperativeHandle(t, () => f()),
|
|
ru(!n, f, o, (e, t) => {
|
|
l?.(e, t, a);
|
|
}),
|
|
u ? m.cloneElement(c, { ref: d }) : c
|
|
);
|
|
});
|
|
function rf() {
|
|
return (rf = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let rm = m.forwardRef(function (e, t) {
|
|
let { children: r } = e;
|
|
return (
|
|
"function" == typeof r
|
|
? [r]
|
|
: (function e(t, r = {}) {
|
|
let n = [];
|
|
return (
|
|
m.default.Children.forEach(t, (t) => {
|
|
(null != t || r.keepEmpty) &&
|
|
(Array.isArray(t)
|
|
? (n = n.concat(e(t)))
|
|
: eF(t) && t.props
|
|
? (n = n.concat(e(t.props.children, r)))
|
|
: n.push(t));
|
|
}),
|
|
n
|
|
);
|
|
})(r)
|
|
).map((r, n) => {
|
|
let o = r?.key || `rc-observer-key-${n}`;
|
|
return m.createElement(
|
|
rd,
|
|
rf({}, e, { key: o, ref: 0 === n ? t : void 0 }),
|
|
r,
|
|
);
|
|
});
|
|
});
|
|
function rp(e) {
|
|
return e?.getRootNode?.();
|
|
}
|
|
function rh(e) {
|
|
return rp(e) instanceof ShadowRoot ? rp(e) : null;
|
|
}
|
|
rm.Collection = function ({ children: e, onBatchResize: t }) {
|
|
let r = m.useRef(0),
|
|
n = m.useRef([]),
|
|
o = m.useContext(ri),
|
|
a = m.useCallback(
|
|
(e, a, i) => {
|
|
r.current += 1;
|
|
let l = r.current;
|
|
n.current.push({ size: e, element: a, data: i }),
|
|
Promise.resolve().then(() => {
|
|
l === r.current && (t?.(n.current), (n.current = []));
|
|
}),
|
|
o?.(e, a, i);
|
|
},
|
|
[t, o],
|
|
);
|
|
return m.createElement(ri.Provider, { value: a }, e);
|
|
};
|
|
let rg = m.createContext({});
|
|
function rb({ children: e, ...t }) {
|
|
return m.createElement(rg.Provider, { value: t }, e);
|
|
}
|
|
let rv = function (e) {
|
|
let [, t] = m.useReducer((e) => e + 1, 0),
|
|
r = m.useRef(e);
|
|
return [
|
|
eI(() => r.current),
|
|
eI((e) => {
|
|
(r.current = "function" == typeof e ? e(r.current) : e), t();
|
|
}),
|
|
];
|
|
},
|
|
r_ = "none",
|
|
ry = "appear",
|
|
rx = "enter",
|
|
rC = "leave",
|
|
rE = "none",
|
|
rS = "prepare",
|
|
rw = "start",
|
|
rk = "active",
|
|
rj = "prepared";
|
|
function rP(e, t) {
|
|
let r = {};
|
|
return (
|
|
(r[e.toLowerCase()] = t.toLowerCase()),
|
|
(r[`Webkit${e}`] = `webkit${t}`),
|
|
(r[`Moz${e}`] = `moz${t}`),
|
|
(r[`ms${e}`] = `MS${t}`),
|
|
(r[`O${e}`] = `o${t.toLowerCase()}`),
|
|
r
|
|
);
|
|
}
|
|
let rR =
|
|
((u = k()),
|
|
(d = "u" > typeof window ? window : {}),
|
|
(l = {
|
|
animationend: rP("Animation", "AnimationEnd"),
|
|
transitionend: rP("Transition", "TransitionEnd"),
|
|
}),
|
|
u &&
|
|
("AnimationEvent" in d || delete l.animationend.animation,
|
|
"TransitionEvent" in d || delete l.transitionend.transition),
|
|
l),
|
|
rN = {};
|
|
k() && ({ style: rN } = document.createElement("div"));
|
|
let r$ = {};
|
|
function rO(e) {
|
|
if (r$[e]) return r$[e];
|
|
let t = rR[e];
|
|
if (t) {
|
|
let r = Object.keys(t),
|
|
n = r.length;
|
|
for (let o = 0; o < n; o += 1) {
|
|
let n = r[o];
|
|
if (Object.prototype.hasOwnProperty.call(t, n) && n in rN)
|
|
return (r$[e] = t[n]), r$[e];
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
let rT = rO("animationend"),
|
|
rM = rO("transitionend"),
|
|
rI = rT || "animationend",
|
|
rA = rM || "transitionend";
|
|
function rL(e, t) {
|
|
return e
|
|
? "object" == typeof e
|
|
? e[t.replace(/-\w/g, (e) => e[1].toUpperCase())]
|
|
: `${e}-${t}`
|
|
: null;
|
|
}
|
|
let rB = k() ? m.useLayoutEffect : m.useEffect,
|
|
rD = (e) => +setTimeout(e, 16),
|
|
rH = (e) => clearTimeout(e);
|
|
"u" > typeof window &&
|
|
"requestAnimationFrame" in window &&
|
|
((rD = (e) => window.requestAnimationFrame(e)),
|
|
(rH = (e) => window.cancelAnimationFrame(e)));
|
|
let rz = 0,
|
|
rW = new Map(),
|
|
rF = (e, t = 1) => {
|
|
let r = (rz += 1);
|
|
return (
|
|
!(function t(n) {
|
|
if (0 === n) rW.delete(r), e();
|
|
else {
|
|
let e = rD(() => {
|
|
t(n - 1);
|
|
});
|
|
rW.set(r, e);
|
|
}
|
|
})(t),
|
|
r
|
|
);
|
|
};
|
|
rF.cancel = (e) => {
|
|
let t = rW.get(e);
|
|
return rW.delete(e), rH(t);
|
|
};
|
|
let rU = [rS, rw, rk, "end"],
|
|
rG = [rS, rj];
|
|
function rq(e) {
|
|
return e === rk || "end" === e;
|
|
}
|
|
let rX =
|
|
((s = f = !!(rT && rM)),
|
|
"object" == typeof f && ({ transitionSupport: s } = f),
|
|
((c = m.forwardRef((e, t) => {
|
|
let r,
|
|
{
|
|
visible: n = !0,
|
|
removeOnLeave: o = !0,
|
|
forceRender: a,
|
|
children: i,
|
|
motionName: l,
|
|
leavedClassName: c,
|
|
eventProps: u,
|
|
} = e,
|
|
{ motion: d } = m.useContext(rg),
|
|
f = !!(e.motionName && s && !1 !== d),
|
|
p = (0, m.useRef)();
|
|
function h() {
|
|
return ra(p.current);
|
|
}
|
|
let [g, b, v, _] = (function (
|
|
e,
|
|
t,
|
|
r,
|
|
{
|
|
motionEnter: n = !0,
|
|
motionAppear: o = !0,
|
|
motionLeave: a = !0,
|
|
motionDeadline: i,
|
|
motionLeaveImmediately: l,
|
|
onAppearPrepare: s,
|
|
onEnterPrepare: c,
|
|
onLeavePrepare: u,
|
|
onAppearStart: d,
|
|
onEnterStart: f,
|
|
onLeaveStart: p,
|
|
onAppearActive: h,
|
|
onEnterActive: g,
|
|
onLeaveActive: b,
|
|
onAppearEnd: v,
|
|
onEnterEnd: _,
|
|
onLeaveEnd: y,
|
|
onVisibleChanged: x,
|
|
},
|
|
) {
|
|
let [C, E] = eB(),
|
|
[S, w] = rv(r_),
|
|
[k, j] = eB(null),
|
|
P = S(),
|
|
R = (0, m.useRef)(!1),
|
|
N = (0, m.useRef)(null),
|
|
$ = (0, m.useRef)(!1);
|
|
function O() {
|
|
w(r_), j(null, !0);
|
|
}
|
|
let T = eI((e) => {
|
|
let t,
|
|
n = S();
|
|
if (n === r_) return;
|
|
let o = r();
|
|
if (e && !e.deadline && e.target !== o) return;
|
|
let a = $.current;
|
|
n === ry && a
|
|
? (t = v?.(o, e))
|
|
: n === rx && a
|
|
? (t = _?.(o, e))
|
|
: n === rC && a && (t = y?.(o, e)),
|
|
a && !1 !== t && O();
|
|
}),
|
|
[M] = ((e) => {
|
|
let t = (0, m.useRef)();
|
|
function r(t) {
|
|
t &&
|
|
(t.removeEventListener(rA, e),
|
|
t.removeEventListener(rI, e));
|
|
}
|
|
return (
|
|
m.useEffect(
|
|
() => () => {
|
|
r(t.current), (t.current = null);
|
|
},
|
|
[],
|
|
),
|
|
[
|
|
function (n) {
|
|
t.current && t.current !== n && r(t.current),
|
|
n &&
|
|
n !== t.current &&
|
|
(n.addEventListener(rA, e),
|
|
n.addEventListener(rI, e),
|
|
(t.current = n));
|
|
},
|
|
r,
|
|
]
|
|
);
|
|
})(T),
|
|
I = (e) => {
|
|
switch (e) {
|
|
case ry:
|
|
return { [rS]: s, [rw]: d, [rk]: h };
|
|
case rx:
|
|
return { [rS]: c, [rw]: f, [rk]: g };
|
|
case rC:
|
|
return { [rS]: u, [rw]: p, [rk]: b };
|
|
default:
|
|
return {};
|
|
}
|
|
},
|
|
A = m.useMemo(() => I(P), [P]),
|
|
[L, B] = ((e, t, r) => {
|
|
let [n, o] = eB(rE),
|
|
[a, i] = (() => {
|
|
let e = m.useRef(null);
|
|
function t() {
|
|
rF.cancel(e.current);
|
|
}
|
|
return (
|
|
m.useEffect(
|
|
() => () => {
|
|
t();
|
|
},
|
|
[],
|
|
),
|
|
[
|
|
function r(n, o = 2) {
|
|
t();
|
|
let a = rF(() => {
|
|
o <= 1
|
|
? n({ isCanceled: () => a !== e.current })
|
|
: r(n, o - 1);
|
|
});
|
|
e.current = a;
|
|
},
|
|
t,
|
|
]
|
|
);
|
|
})(),
|
|
l = t ? rG : rU;
|
|
return (
|
|
rB(() => {
|
|
if (n !== rE && "end" !== n) {
|
|
let e = l.indexOf(n),
|
|
t = l[e + 1],
|
|
i = r(n);
|
|
!1 === i
|
|
? o(t, !0)
|
|
: t &&
|
|
a((e) => {
|
|
function r() {
|
|
e.isCanceled() || o(t, !0);
|
|
}
|
|
!0 === i ? r() : Promise.resolve(i).then(r);
|
|
});
|
|
}
|
|
}, [e, n]),
|
|
m.useEffect(
|
|
() => () => {
|
|
i();
|
|
},
|
|
[],
|
|
),
|
|
[
|
|
function () {
|
|
o(rS, !0);
|
|
},
|
|
n,
|
|
]
|
|
);
|
|
})(P, !e, (e) => {
|
|
if (e === rS) {
|
|
let e = A[rS];
|
|
return !!e && e(r());
|
|
}
|
|
return (
|
|
B in A && j(A[B]?.(r(), null) || null),
|
|
B === rk &&
|
|
P !== r_ &&
|
|
(M(r()),
|
|
i > 0 &&
|
|
(clearTimeout(N.current),
|
|
(N.current = setTimeout(() => {
|
|
T({ deadline: !0 });
|
|
}, i)))),
|
|
B === rj && O(),
|
|
!0
|
|
);
|
|
});
|
|
$.current = rq(B);
|
|
let D = (0, m.useRef)(null);
|
|
rB(() => {
|
|
let r;
|
|
if (R.current && D.current === t) return;
|
|
E(t);
|
|
let i = R.current;
|
|
(R.current = !0),
|
|
!i && t && o && (r = ry),
|
|
i && t && n && (r = rx),
|
|
((i && !t && a) || (!i && l && !t && a)) && (r = rC);
|
|
let s = I(r);
|
|
r && (e || s[rS]) ? (w(r), L()) : w(r_), (D.current = t);
|
|
}, [t]),
|
|
(0, m.useEffect)(() => {
|
|
((P !== ry || o) && (P !== rx || n) && (P !== rC || a)) ||
|
|
w(r_);
|
|
}, [o, n, a]),
|
|
(0, m.useEffect)(
|
|
() => () => {
|
|
(R.current = !1), clearTimeout(N.current);
|
|
},
|
|
[],
|
|
);
|
|
let H = m.useRef(!1);
|
|
(0, m.useEffect)(() => {
|
|
C && (H.current = !0),
|
|
void 0 !== C &&
|
|
P === r_ &&
|
|
((H.current || C) && x?.(C), (H.current = !0));
|
|
}, [C, P]);
|
|
let z = k;
|
|
return (
|
|
A[rS] && B === rw && (z = { transition: "none", ...z }),
|
|
[S, B, z, C ?? t]
|
|
);
|
|
})(f, n, h, e),
|
|
y = g(),
|
|
x = m.useRef(_);
|
|
_ && (x.current = !0);
|
|
let C = m.useMemo(() => {
|
|
let e = {};
|
|
return (
|
|
Object.defineProperties(e, {
|
|
nativeElement: { enumerable: !0, get: h },
|
|
inMotion: { enumerable: !0, get: () => () => g() !== r_ },
|
|
enableMotion: { enumerable: !0, get: () => () => f },
|
|
}),
|
|
e
|
|
);
|
|
}, []);
|
|
m.useImperativeHandle(t, () => C, []);
|
|
let E = { ...u, visible: n };
|
|
if (i)
|
|
if (y === r_)
|
|
r = _
|
|
? i({ ...E }, p)
|
|
: !o && x.current && c
|
|
? i({ ...E, className: c }, p)
|
|
: !a && (o || c)
|
|
? null
|
|
: i({ ...E, style: { display: "none" } }, p);
|
|
else {
|
|
let e;
|
|
b === rS
|
|
? (e = "prepare")
|
|
: rq(b)
|
|
? (e = "active")
|
|
: b === rw && (e = "start");
|
|
let t = rL(l, `${y}-${e}`);
|
|
r = i(
|
|
{
|
|
...E,
|
|
className: (0, rn.clsx)(rL(l, y), {
|
|
[t]: t && e,
|
|
[l]: "string" == typeof l,
|
|
}),
|
|
style: v,
|
|
},
|
|
p,
|
|
);
|
|
}
|
|
else r = null;
|
|
return (
|
|
m.isValidElement(r) &&
|
|
eX(r) &&
|
|
(eV(r) || (r = m.cloneElement(r, { ref: p }))),
|
|
r
|
|
);
|
|
})).displayName = "CSSMotion"),
|
|
c);
|
|
var rK = m;
|
|
let rV = "keep",
|
|
rY = "remove",
|
|
rQ = "removed";
|
|
function rZ(e) {
|
|
let t;
|
|
return {
|
|
...(t = e && "object" == typeof e && "key" in e ? e : { key: e }),
|
|
key: String(t.key),
|
|
};
|
|
}
|
|
function rJ(e = []) {
|
|
return e.map(rZ);
|
|
}
|
|
function r0() {
|
|
return (r0 = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let r1 = [
|
|
"eventProps",
|
|
"visible",
|
|
"children",
|
|
"motionName",
|
|
"motionAppear",
|
|
"motionEnter",
|
|
"motionLeave",
|
|
"motionLeaveImmediately",
|
|
"motionDeadline",
|
|
"removeOnLeave",
|
|
"leavedClassName",
|
|
"onAppearPrepare",
|
|
"onAppearStart",
|
|
"onAppearActive",
|
|
"onAppearEnd",
|
|
"onEnterStart",
|
|
"onEnterActive",
|
|
"onEnterEnd",
|
|
"onLeaveStart",
|
|
"onLeaveActive",
|
|
"onLeaveEnd",
|
|
],
|
|
r2 = (function (e, t = rX) {
|
|
class r extends rK.Component {
|
|
static defaultProps = { component: "div" };
|
|
state = { keyEntities: [] };
|
|
static getDerivedStateFromProps({ keys: e }, { keyEntities: t }) {
|
|
return {
|
|
keyEntities: (function (e = [], t = []) {
|
|
let r = [],
|
|
n = 0,
|
|
o = t.length,
|
|
a = rJ(e),
|
|
i = rJ(t);
|
|
a.forEach((e) => {
|
|
let t = !1;
|
|
for (let a = n; a < o; a += 1) {
|
|
let o = i[a];
|
|
if (o.key === e.key) {
|
|
n < a &&
|
|
((r = r.concat(
|
|
i.slice(n, a).map((e) => ({ ...e, status: "add" })),
|
|
)),
|
|
(n = a)),
|
|
r.push({ ...o, status: rV }),
|
|
(n += 1),
|
|
(t = !0);
|
|
break;
|
|
}
|
|
}
|
|
t || r.push({ ...e, status: rY });
|
|
}),
|
|
n < o &&
|
|
(r = r.concat(
|
|
i.slice(n).map((e) => ({ ...e, status: "add" })),
|
|
));
|
|
let l = {};
|
|
return (
|
|
r.forEach(({ key: e }) => {
|
|
l[e] = (l[e] || 0) + 1;
|
|
}),
|
|
Object.keys(l)
|
|
.filter((e) => l[e] > 1)
|
|
.forEach((e) => {
|
|
(r = r.filter(
|
|
({ key: t, status: r }) => t !== e || r !== rY,
|
|
)).forEach((t) => {
|
|
t.key === e && (t.status = rV);
|
|
});
|
|
}),
|
|
r
|
|
);
|
|
})(t, rJ(e)).filter((e) => {
|
|
let r = t.find(({ key: t }) => e.key === t);
|
|
return !r || r.status !== rQ || e.status !== rY;
|
|
}),
|
|
};
|
|
}
|
|
removeKey = (e) => {
|
|
this.setState(
|
|
(t) => ({
|
|
keyEntities: t.keyEntities.map((t) =>
|
|
t.key !== e ? t : { ...t, status: rQ },
|
|
),
|
|
}),
|
|
() => {
|
|
let { keyEntities: e } = this.state;
|
|
0 === e.filter(({ status: e }) => e !== rQ).length &&
|
|
this.props.onAllRemoved &&
|
|
this.props.onAllRemoved();
|
|
},
|
|
);
|
|
};
|
|
render() {
|
|
let { keyEntities: e } = this.state,
|
|
{
|
|
component: r,
|
|
children: n,
|
|
onVisibleChanged: o,
|
|
onAllRemoved: a,
|
|
...i
|
|
} = this.props,
|
|
l = r || rK.Fragment,
|
|
s = {};
|
|
return (
|
|
r1.forEach((e) => {
|
|
(s[e] = i[e]), delete i[e];
|
|
}),
|
|
delete i.keys,
|
|
rK.createElement(
|
|
l,
|
|
i,
|
|
e.map(({ status: e, ...r }, a) =>
|
|
rK.createElement(
|
|
t,
|
|
r0({}, s, {
|
|
key: r.key,
|
|
visible: "add" === e || e === rV,
|
|
eventProps: r,
|
|
onVisibleChanged: (e) => {
|
|
o?.(e, { key: r.key }), e || this.removeKey(r.key);
|
|
},
|
|
}),
|
|
(e, t) => n({ ...e, index: a }, t),
|
|
),
|
|
),
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return r;
|
|
})(0);
|
|
function r4(e) {
|
|
let { prefixCls: t, align: r, arrow: n, arrowPos: o } = e,
|
|
{ className: a, content: i, style: l } = n || {},
|
|
{ x: s = 0, y: c = 0 } = o,
|
|
u = m.useRef(null);
|
|
if (!r || !r.points) return null;
|
|
let d = { position: "absolute" };
|
|
if (!1 !== r.autoArrow) {
|
|
let e = r.points[0],
|
|
t = r.points[1],
|
|
n = e[0],
|
|
o = e[1],
|
|
a = t[0],
|
|
i = t[1];
|
|
n !== a && ["t", "b"].includes(n)
|
|
? "t" === n
|
|
? (d.top = 0)
|
|
: (d.bottom = 0)
|
|
: (d.top = c),
|
|
o !== i && ["l", "r"].includes(o)
|
|
? "l" === o
|
|
? (d.left = 0)
|
|
: (d.right = 0)
|
|
: (d.left = s);
|
|
}
|
|
return m.createElement(
|
|
"div",
|
|
{
|
|
ref: u,
|
|
className: (0, rn.clsx)(`${t}-arrow`, a),
|
|
style: { ...d, ...l },
|
|
},
|
|
i,
|
|
);
|
|
}
|
|
function r6() {
|
|
return (r6 = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
function r3(e) {
|
|
let {
|
|
prefixCls: t,
|
|
open: r,
|
|
zIndex: n,
|
|
mask: o,
|
|
motion: a,
|
|
mobile: i,
|
|
} = e;
|
|
return o
|
|
? m.createElement(
|
|
rX,
|
|
r6({}, a, { motionAppear: !0, visible: r, removeOnLeave: !0 }),
|
|
({ className: e }) =>
|
|
m.createElement("div", {
|
|
style: { zIndex: n },
|
|
className: (0, rn.clsx)(
|
|
`${t}-mask`,
|
|
i && `${t}-mobile-mask`,
|
|
e,
|
|
),
|
|
}),
|
|
)
|
|
: null;
|
|
}
|
|
let r5 = m.memo(
|
|
({ children: e }) => e,
|
|
(e, t) => t.cache,
|
|
);
|
|
function r8(e, t, r, n, o, a, i, l) {
|
|
let s = "auto",
|
|
c = e ? {} : { left: "-1000vw", top: "-1000vh", right: s, bottom: s };
|
|
if (!e && (t || !r)) {
|
|
let { points: e } = n,
|
|
t = n.dynamicInset || n._experimental?.dynamicInset,
|
|
r = t && "r" === e[0][1],
|
|
u = t && "b" === e[0][0];
|
|
r ? ((c.right = o), (c.left = s)) : ((c.left = i), (c.right = s)),
|
|
u ? ((c.bottom = a), (c.top = s)) : ((c.top = l), (c.bottom = s));
|
|
}
|
|
return c;
|
|
}
|
|
function r7() {
|
|
return (r7 = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let r9 = m.forwardRef((e, t) => {
|
|
let {
|
|
onEsc: r,
|
|
popup: n,
|
|
className: o,
|
|
prefixCls: a,
|
|
style: i,
|
|
target: l,
|
|
onVisibleChanged: s,
|
|
open: c,
|
|
keepDom: u,
|
|
fresh: d,
|
|
onClick: f,
|
|
mask: p,
|
|
arrow: h,
|
|
arrowPos: g,
|
|
align: b,
|
|
motion: v,
|
|
maskMotion: _,
|
|
mobile: y,
|
|
forceRender: x,
|
|
getPopupContainer: C,
|
|
autoDestroy: E,
|
|
portal: S,
|
|
children: w,
|
|
zIndex: k,
|
|
onMouseEnter: j,
|
|
onMouseLeave: P,
|
|
onPointerEnter: R,
|
|
onPointerDownCapture: N,
|
|
ready: $,
|
|
offsetX: O,
|
|
offsetY: T,
|
|
offsetR: M,
|
|
offsetB: I,
|
|
onAlign: A,
|
|
onPrepare: L,
|
|
onResize: B,
|
|
stretch: D,
|
|
targetWidth: H,
|
|
targetHeight: z,
|
|
} = e,
|
|
W = "function" == typeof n ? n() : n,
|
|
F = c || u,
|
|
U = !!y,
|
|
[G, q, X] = m.useMemo(
|
|
() => (y ? [y.mask, y.maskMotion, y.motion] : [p, _, v]),
|
|
[y, p, _, v],
|
|
),
|
|
K = C?.length > 0,
|
|
[V, Y] = m.useState(!C || !K);
|
|
eL(() => {
|
|
!V && K && l && Y(!0);
|
|
}, [V, K, l]);
|
|
let Q = eI((e, t) => {
|
|
B?.(e, t), A();
|
|
}),
|
|
Z = r8(U, $, c, b, M, I, O, T);
|
|
if (!V) return null;
|
|
let J = {};
|
|
return (
|
|
D &&
|
|
(D.includes("height") && z
|
|
? (J.height = z)
|
|
: D.includes("minHeight") && z && (J.minHeight = z),
|
|
D.includes("width") && H
|
|
? (J.width = H)
|
|
: D.includes("minWidth") && H && (J.minWidth = H)),
|
|
c || (J.pointerEvents = "none"),
|
|
m.createElement(
|
|
S,
|
|
{
|
|
open: x || F,
|
|
getContainer: C && (() => C(l)),
|
|
autoDestroy: E,
|
|
onEsc: r,
|
|
},
|
|
m.createElement(r3, {
|
|
prefixCls: a,
|
|
open: c,
|
|
zIndex: k,
|
|
mask: G,
|
|
motion: q,
|
|
mobile: U,
|
|
}),
|
|
m.createElement(rm, { onResize: Q, disabled: !c }, (e) =>
|
|
m.createElement(
|
|
rX,
|
|
r7(
|
|
{
|
|
motionAppear: !0,
|
|
motionEnter: !0,
|
|
motionLeave: !0,
|
|
removeOnLeave: !1,
|
|
forceRender: x,
|
|
leavedClassName: `${a}-hidden`,
|
|
},
|
|
X,
|
|
{
|
|
onAppearPrepare: L,
|
|
onEnterPrepare: L,
|
|
visible: c,
|
|
onVisibleChanged: (e) => {
|
|
v?.onVisibleChanged?.(e), s(e);
|
|
},
|
|
},
|
|
),
|
|
({ className: r, style: n }, l) => {
|
|
let s = (0, rn.clsx)(a, r, o, { [`${a}-mobile`]: U });
|
|
return m.createElement(
|
|
"div",
|
|
{
|
|
ref: eG(e, t, l),
|
|
className: s,
|
|
style: {
|
|
"--arrow-x": `${g.x || 0}px`,
|
|
"--arrow-y": `${g.y || 0}px`,
|
|
...Z,
|
|
...J,
|
|
...n,
|
|
boxSizing: "border-box",
|
|
zIndex: k,
|
|
...i,
|
|
},
|
|
onMouseEnter: j,
|
|
onMouseLeave: P,
|
|
onPointerEnter: R,
|
|
onClick: f,
|
|
onPointerDownCapture: N,
|
|
},
|
|
h &&
|
|
m.createElement(r4, {
|
|
prefixCls: a,
|
|
arrow: h,
|
|
arrowPos: g,
|
|
align: b,
|
|
}),
|
|
m.createElement(r5, { cache: !c && !d }, W),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
w,
|
|
)
|
|
);
|
|
}),
|
|
ne = m.createContext(null),
|
|
nt = m.createContext(null);
|
|
function nr(e) {
|
|
return e ? (Array.isArray(e) ? e : [e]) : [];
|
|
}
|
|
function nn(e, t, r, n) {
|
|
let { points: o } = r,
|
|
a = Object.keys(e);
|
|
for (let r = 0; r < a.length; r += 1) {
|
|
let i = a[r];
|
|
if (
|
|
(function (e = [], t = [], r) {
|
|
let n = (e, t) => e[t] || "";
|
|
return r
|
|
? n(e, 0) === n(t, 0)
|
|
: n(e, 0) === n(t, 0) && n(e, 1) === n(t, 1);
|
|
})(e[i]?.points, o, n)
|
|
)
|
|
return `${t}-placement-${i}`;
|
|
}
|
|
return "";
|
|
}
|
|
function no(e) {
|
|
return e.ownerDocument.defaultView;
|
|
}
|
|
function na(e) {
|
|
let t = [],
|
|
r = e?.parentElement,
|
|
n = ["hidden", "scroll", "clip", "auto"];
|
|
for (; r; ) {
|
|
let {
|
|
overflowX: e,
|
|
overflowY: o,
|
|
overflow: a,
|
|
} = no(r).getComputedStyle(r);
|
|
[e, o, a].some((e) => n.includes(e)) && t.push(r),
|
|
(r = r.parentElement);
|
|
}
|
|
return t;
|
|
}
|
|
function ni(e, t = 1) {
|
|
return Number.isNaN(e) ? t : e;
|
|
}
|
|
function nl(e) {
|
|
return ni(parseFloat(e), 0);
|
|
}
|
|
function ns(e, t) {
|
|
let r = { ...e };
|
|
return (
|
|
(t || []).forEach((e) => {
|
|
if (e instanceof HTMLBodyElement || e instanceof HTMLHtmlElement)
|
|
return;
|
|
let {
|
|
overflow: t,
|
|
overflowClipMargin: n,
|
|
borderTopWidth: o,
|
|
borderBottomWidth: a,
|
|
borderLeftWidth: i,
|
|
borderRightWidth: l,
|
|
} = no(e).getComputedStyle(e),
|
|
s = e.getBoundingClientRect(),
|
|
{
|
|
offsetHeight: c,
|
|
clientHeight: u,
|
|
offsetWidth: d,
|
|
clientWidth: f,
|
|
} = e,
|
|
m = nl(o),
|
|
p = nl(a),
|
|
h = nl(i),
|
|
g = nl(l),
|
|
b = ni(Math.round((s.width / d) * 1e3) / 1e3),
|
|
v = ni(Math.round((s.height / c) * 1e3) / 1e3),
|
|
_ = m * v,
|
|
y = h * b,
|
|
x = 0,
|
|
C = 0;
|
|
if ("clip" === t) {
|
|
let e = nl(n);
|
|
(x = e * b), (C = e * v);
|
|
}
|
|
let E = s.x + y - x,
|
|
S = s.y + _ - C,
|
|
w = E + s.width + 2 * x - y - g * b - (d - f - h - g) * b,
|
|
k = S + s.height + 2 * C - _ - p * v - (c - u - m - p) * v;
|
|
(r.left = Math.max(r.left, E)),
|
|
(r.top = Math.max(r.top, S)),
|
|
(r.right = Math.min(r.right, w)),
|
|
(r.bottom = Math.min(r.bottom, k));
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
function nc(e, t = 0) {
|
|
let r = `${t}`,
|
|
n = r.match(/^(.*)\%$/);
|
|
return n ? e * (parseFloat(n[1]) / 100) : parseFloat(r);
|
|
}
|
|
function nu(e, t) {
|
|
let [r, n] = t || [];
|
|
return [nc(e.width, r), nc(e.height, n)];
|
|
}
|
|
function nd(e = "") {
|
|
return [e[0], e[1]];
|
|
}
|
|
function nf(e, t) {
|
|
let r,
|
|
n = t[0],
|
|
o = t[1];
|
|
return (
|
|
(r = "t" === n ? e.y : "b" === n ? e.y + e.height : e.y + e.height / 2),
|
|
{
|
|
x: "l" === o ? e.x : "r" === o ? e.x + e.width : e.x + e.width / 2,
|
|
y: r,
|
|
}
|
|
);
|
|
}
|
|
function nm(e, t) {
|
|
let r = [...e];
|
|
return (r[t] = { t: "b", b: "t", l: "r", r: "l" }[e[t]] || "c"), r;
|
|
}
|
|
function np(e, t, r, n, o, a, i, l) {
|
|
let [s, c] = m.useState({
|
|
ready: !1,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
offsetR: 0,
|
|
offsetB: 0,
|
|
arrowX: 0,
|
|
arrowY: 0,
|
|
scaleX: 1,
|
|
scaleY: 1,
|
|
align: o[n] || {},
|
|
}),
|
|
u = m.useRef(0),
|
|
d = m.useMemo(() => (!t || l ? [] : na(t)), [t]),
|
|
f = m.useRef({});
|
|
e || (f.current = {});
|
|
let p = eI(() => {
|
|
if (t && r && e && !l) {
|
|
let e,
|
|
l,
|
|
m,
|
|
p,
|
|
h,
|
|
g = t.ownerDocument,
|
|
b = no(t),
|
|
{ position: v } = b.getComputedStyle(t),
|
|
_ = t.style.left,
|
|
y = t.style.top,
|
|
x = t.style.right,
|
|
C = t.style.bottom,
|
|
E = t.style.overflow,
|
|
S = { ...o[n], ...a },
|
|
w = g.createElement("div");
|
|
if (
|
|
(t.parentElement?.appendChild(w),
|
|
(w.style.left = `${t.offsetLeft}px`),
|
|
(w.style.top = `${t.offsetTop}px`),
|
|
(w.style.position = v),
|
|
(w.style.height = `${t.offsetHeight}px`),
|
|
(w.style.width = `${t.offsetWidth}px`),
|
|
(t.style.left = "0"),
|
|
(t.style.top = "0"),
|
|
(t.style.right = "auto"),
|
|
(t.style.bottom = "auto"),
|
|
(t.style.overflow = "hidden"),
|
|
Array.isArray(r))
|
|
)
|
|
e = { x: r[0], y: r[1], width: 0, height: 0 };
|
|
else {
|
|
let t = r.getBoundingClientRect();
|
|
(t.x = t.x ?? t.left),
|
|
(t.y = t.y ?? t.top),
|
|
(e = { x: t.x, y: t.y, width: t.width, height: t.height });
|
|
}
|
|
let k = t.getBoundingClientRect(),
|
|
{ height: j, width: P } = b.getComputedStyle(t);
|
|
(k.x = k.x ?? k.left), (k.y = k.y ?? k.top);
|
|
let {
|
|
clientWidth: R,
|
|
clientHeight: N,
|
|
scrollWidth: $,
|
|
scrollHeight: O,
|
|
scrollTop: T,
|
|
scrollLeft: M,
|
|
} = g.documentElement,
|
|
I = k.height,
|
|
A = k.width,
|
|
L = e.height,
|
|
B = e.width,
|
|
{ htmlRegion: D } = S,
|
|
H = "visible",
|
|
z = "visibleFirst";
|
|
"scroll" !== D && D !== z && (D = H);
|
|
let W = D === z,
|
|
F = ns({ left: -M, top: -T, right: $ - M, bottom: O - T }, d),
|
|
U = ns({ left: 0, top: 0, right: R, bottom: N }, d),
|
|
G = D === H ? U : F,
|
|
q = W ? U : G;
|
|
(t.style.left = "auto"),
|
|
(t.style.top = "auto"),
|
|
(t.style.right = "0"),
|
|
(t.style.bottom = "0");
|
|
let X = t.getBoundingClientRect();
|
|
(t.style.left = _),
|
|
(t.style.top = y),
|
|
(t.style.right = x),
|
|
(t.style.bottom = C),
|
|
(t.style.overflow = E),
|
|
t.parentElement?.removeChild(w);
|
|
let K = ni(Math.round((A / parseFloat(P)) * 1e3) / 1e3),
|
|
V = ni(Math.round((I / parseFloat(j)) * 1e3) / 1e3);
|
|
if (
|
|
0 === K ||
|
|
0 === V ||
|
|
(ro(r) &&
|
|
!((e) => {
|
|
if (!e) return !1;
|
|
if (e instanceof Element) {
|
|
if (e.offsetParent) return !0;
|
|
if (e.getBBox) {
|
|
let { width: t, height: r } = e.getBBox();
|
|
if (t || r) return !0;
|
|
}
|
|
if (e.getBoundingClientRect) {
|
|
let { width: t, height: r } = e.getBoundingClientRect();
|
|
if (t || r) return !0;
|
|
}
|
|
}
|
|
return !1;
|
|
})(r))
|
|
)
|
|
return;
|
|
let { offset: Y, targetOffset: Q } = S,
|
|
[Z, J] = nu(k, Y),
|
|
[ee, et] = nu(e, Q);
|
|
(e.x -= ee), (e.y -= et);
|
|
let [er, en] = S.points || [],
|
|
eo = nd(en),
|
|
ea = nd(er),
|
|
ei = nf(e, eo),
|
|
el = nf(k, ea),
|
|
es = { ...S },
|
|
ec = [ea, eo],
|
|
eu = ei.x - el.x + Z,
|
|
ed = ei.y - el.y + J;
|
|
function s(e, t, r = G) {
|
|
let n = k.x + e,
|
|
o = k.y + t,
|
|
a = Math.max(n, r.left),
|
|
i = Math.max(o, r.top);
|
|
return Math.max(
|
|
0,
|
|
(Math.min(n + A, r.right) - a) *
|
|
(Math.min(o + I, r.bottom) - i),
|
|
);
|
|
}
|
|
let ef = s(eu, ed),
|
|
em = s(eu, ed, U),
|
|
ep = nf(e, ["t", "l"]),
|
|
eh = nf(k, ["t", "l"]),
|
|
eg = nf(e, ["b", "r"]),
|
|
eb = nf(k, ["b", "r"]),
|
|
{
|
|
adjustX: ev,
|
|
adjustY: e_,
|
|
shiftX: ey,
|
|
shiftY: ex,
|
|
} = S.overflow || {},
|
|
eC = (e) => ("boolean" == typeof e ? e : e >= 0);
|
|
function u() {
|
|
(m = (l = k.y + ed) + I), (h = (p = k.x + eu) + A);
|
|
}
|
|
u();
|
|
let eE = eC(e_),
|
|
eS = ea[0] === eo[0];
|
|
if (eE && "t" === ea[0] && (m > q.bottom || f.current.bt)) {
|
|
let e = ed;
|
|
eS ? (e -= I - L) : (e = ep.y - eb.y - J);
|
|
let t = s(eu, e),
|
|
r = s(eu, e, U);
|
|
t > ef || (t === ef && (!W || r >= em))
|
|
? ((f.current.bt = !0),
|
|
(ed = e),
|
|
(J = -J),
|
|
(ec = [nm(ec[0], 0), nm(ec[1], 0)]))
|
|
: (f.current.bt = !1);
|
|
}
|
|
if (eE && "b" === ea[0] && (l < q.top || f.current.tb)) {
|
|
let e = ed;
|
|
eS ? (e += I - L) : (e = eg.y - eh.y - J);
|
|
let t = s(eu, e),
|
|
r = s(eu, e, U);
|
|
t > ef || (t === ef && (!W || r >= em))
|
|
? ((f.current.tb = !0),
|
|
(ed = e),
|
|
(J = -J),
|
|
(ec = [nm(ec[0], 0), nm(ec[1], 0)]))
|
|
: (f.current.tb = !1);
|
|
}
|
|
let ew = eC(ev),
|
|
ek = ea[1] === eo[1];
|
|
if (ew && "l" === ea[1] && (h > q.right || f.current.rl)) {
|
|
let e = eu;
|
|
ek ? (e -= A - B) : (e = ep.x - eb.x - Z);
|
|
let t = s(e, ed),
|
|
r = s(e, ed, U);
|
|
t > ef || (t === ef && (!W || r >= em))
|
|
? ((f.current.rl = !0),
|
|
(eu = e),
|
|
(Z = -Z),
|
|
(ec = [nm(ec[0], 1), nm(ec[1], 1)]))
|
|
: (f.current.rl = !1);
|
|
}
|
|
if (ew && "r" === ea[1] && (p < q.left || f.current.lr)) {
|
|
let e = eu;
|
|
ek ? (e += A - B) : (e = eg.x - eh.x - Z);
|
|
let t = s(e, ed),
|
|
r = s(e, ed, U);
|
|
t > ef || (t === ef && (!W || r >= em))
|
|
? ((f.current.lr = !0),
|
|
(eu = e),
|
|
(Z = -Z),
|
|
(ec = [nm(ec[0], 1), nm(ec[1], 1)]))
|
|
: (f.current.lr = !1);
|
|
}
|
|
(es.points = [ec[0].join(""), ec[1].join("")]), u();
|
|
let ej = !0 === ey ? 0 : ey;
|
|
"number" == typeof ej &&
|
|
(p < U.left &&
|
|
((eu -= p - U.left - Z),
|
|
e.x + B < U.left + ej && (eu += e.x - U.left + B - ej)),
|
|
h > U.right &&
|
|
((eu -= h - U.right - Z),
|
|
e.x > U.right - ej && (eu += e.x - U.right + ej)));
|
|
let eP = !0 === ex ? 0 : ex;
|
|
"number" == typeof eP &&
|
|
(l < U.top &&
|
|
((ed -= l - U.top - J),
|
|
e.y + L < U.top + eP && (ed += e.y - U.top + L - eP)),
|
|
m > U.bottom &&
|
|
((ed -= m - U.bottom - J),
|
|
e.y > U.bottom - eP && (ed += e.y - U.bottom + eP)));
|
|
let eR = k.x + eu,
|
|
eN = k.y + ed,
|
|
e$ = e.x,
|
|
eO = e.y,
|
|
eT = Math.max(eR, e$),
|
|
eM = Math.min(eR + A, e$ + B),
|
|
eI = Math.max(eN, eO),
|
|
eA = Math.min(eN + I, eO + L);
|
|
i?.(t, es);
|
|
let eL = X.right - k.x - (eu + k.width),
|
|
eB = X.bottom - k.y - (ed + k.height);
|
|
1 === K && ((eu = Math.floor(eu)), (eL = Math.floor(eL))),
|
|
1 === V && ((ed = Math.floor(ed)), (eB = Math.floor(eB))),
|
|
c({
|
|
ready: !0,
|
|
offsetX: eu / K,
|
|
offsetY: ed / V,
|
|
offsetR: eL / K,
|
|
offsetB: eB / V,
|
|
arrowX: ((eT + eM) / 2 - eR) / K,
|
|
arrowY: ((eI + eA) / 2 - eN) / V,
|
|
scaleX: K,
|
|
scaleY: V,
|
|
align: es,
|
|
});
|
|
}
|
|
}),
|
|
h = () => {
|
|
c((e) => ({ ...e, ready: !1 }));
|
|
};
|
|
return (
|
|
eL(h, [n]),
|
|
eL(() => {
|
|
e || h();
|
|
}, [e]),
|
|
[
|
|
s.ready,
|
|
s.offsetX,
|
|
s.offsetY,
|
|
s.offsetR,
|
|
s.offsetB,
|
|
s.arrowX,
|
|
s.arrowY,
|
|
s.scaleX,
|
|
s.scaleY,
|
|
s.align,
|
|
() => {
|
|
u.current += 1;
|
|
let e = u.current;
|
|
Promise.resolve().then(() => {
|
|
u.current === e && p();
|
|
});
|
|
},
|
|
]
|
|
);
|
|
}
|
|
function nh() {
|
|
let e = m.useRef(null),
|
|
t = () => {
|
|
e.current && (clearTimeout(e.current), (e.current = null));
|
|
};
|
|
return (
|
|
m.useEffect(
|
|
() => () => {
|
|
t();
|
|
},
|
|
[],
|
|
),
|
|
(r, n) => {
|
|
t(),
|
|
0 === n
|
|
? r()
|
|
: (e.current = setTimeout(() => {
|
|
r();
|
|
}, 1e3 * n));
|
|
}
|
|
);
|
|
}
|
|
function ng() {
|
|
return (ng = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let nb = (e) => {
|
|
let {
|
|
prefixCls: t,
|
|
isMobile: r,
|
|
ready: n,
|
|
open: o,
|
|
align: a,
|
|
offsetR: i,
|
|
offsetB: l,
|
|
offsetX: s,
|
|
offsetY: c,
|
|
arrowPos: u,
|
|
popupSize: d,
|
|
motion: f,
|
|
uniqueContainerClassName: p,
|
|
uniqueContainerStyle: h,
|
|
} = e,
|
|
g = `${t}-unique-container`,
|
|
[b, v] = m.default.useState(!1),
|
|
_ = r8(r, n, o, a, i, l, s, c),
|
|
y = m.default.useRef(_);
|
|
n && (y.current = _);
|
|
let x = {};
|
|
return (
|
|
d && ((x.width = d.width), (x.height = d.height)),
|
|
m.default.createElement(
|
|
rX,
|
|
ng(
|
|
{
|
|
motionAppear: !0,
|
|
motionEnter: !0,
|
|
motionLeave: !0,
|
|
removeOnLeave: !1,
|
|
leavedClassName: `${g}-hidden`,
|
|
},
|
|
f,
|
|
{
|
|
visible: o,
|
|
onVisibleChanged: (e) => {
|
|
v(e);
|
|
},
|
|
},
|
|
),
|
|
({ className: e, style: t }) => {
|
|
let r = (0, rn.clsx)(g, e, p, { [`${g}-visible`]: b });
|
|
return m.default.createElement("div", {
|
|
className: r,
|
|
style: {
|
|
"--arrow-x": `${u?.x || 0}px`,
|
|
"--arrow-y": `${u?.y || 0}px`,
|
|
...y.current,
|
|
...x,
|
|
...t,
|
|
...h,
|
|
},
|
|
});
|
|
},
|
|
)
|
|
);
|
|
},
|
|
nv = ({ children: e, postTriggerProps: t }) => {
|
|
let [r, n, o, a] = (function () {
|
|
let [e, t] = m.default.useState(null),
|
|
[r, n] = m.default.useState(!1),
|
|
[o, a] = m.default.useState(!1),
|
|
i = m.default.useRef(null);
|
|
return [
|
|
eI((e) => {
|
|
!1 === e
|
|
? ((i.current = null), n(!1))
|
|
: o && r
|
|
? (i.current = e)
|
|
: (n(!0), t(e), (i.current = null), r || a(!0));
|
|
}),
|
|
r,
|
|
e,
|
|
eI((e) => {
|
|
e
|
|
? (a(!1), i.current && (t(i.current), (i.current = null)))
|
|
: (a(!1), (i.current = null));
|
|
}),
|
|
];
|
|
})(),
|
|
i = m.useMemo(() => (o && t ? t(o) : o), [o, t]),
|
|
[l, s] = m.useState(null),
|
|
[c, u] = m.useState(null),
|
|
d = m.useRef(null),
|
|
f = eI((e) => {
|
|
(d.current = e), ro(e) && l !== e && s(e);
|
|
}),
|
|
p = m.useRef(null),
|
|
h = nh(),
|
|
g = eI((e, t) => {
|
|
(p.current = t),
|
|
h(() => {
|
|
r(e);
|
|
}, e.delay);
|
|
}),
|
|
b = (e) => {
|
|
h(() => {
|
|
p.current?.() || r(!1);
|
|
}, e);
|
|
},
|
|
v = eI((e) => {
|
|
a(e);
|
|
}),
|
|
[_, y, x, C, E, S, w, , , k, j] = np(
|
|
n,
|
|
l,
|
|
i?.target,
|
|
i?.popupPlacement,
|
|
i?.builtinPlacements || {},
|
|
i?.popupAlign,
|
|
void 0,
|
|
!1,
|
|
),
|
|
P = m.useMemo(() => {
|
|
if (!i) return "";
|
|
let e = nn(i.builtinPlacements || {}, i.prefixCls || "", k, !1);
|
|
return (0, rn.clsx)(e, i.getPopupClassNameFromAlign?.(k));
|
|
}, [
|
|
k,
|
|
i?.getPopupClassNameFromAlign,
|
|
i?.builtinPlacements,
|
|
i?.prefixCls,
|
|
]),
|
|
R = m.useMemo(() => ({ show: g, hide: b }), []);
|
|
m.useEffect(() => {
|
|
j();
|
|
}, [i?.target]);
|
|
let N = eI(() => (j(), Promise.resolve())),
|
|
$ = m.useRef({}),
|
|
O = m.useContext(ne),
|
|
T = m.useMemo(
|
|
() => ({
|
|
registerSubPopup: (e, t) => {
|
|
($.current[e] = t), O?.registerSubPopup(e, t);
|
|
},
|
|
}),
|
|
[O],
|
|
),
|
|
M = i?.prefixCls;
|
|
return m.createElement(
|
|
nt.Provider,
|
|
{ value: R },
|
|
e,
|
|
i &&
|
|
m.createElement(
|
|
ne.Provider,
|
|
{ value: T },
|
|
m.createElement(
|
|
r9,
|
|
{
|
|
ref: f,
|
|
portal: rr,
|
|
onEsc: i.onEsc,
|
|
prefixCls: M,
|
|
popup: i.popup,
|
|
className: (0, rn.clsx)(
|
|
i.popupClassName,
|
|
P,
|
|
`${M}-unique-controlled`,
|
|
),
|
|
style: i.popupStyle,
|
|
target: i.target,
|
|
open: n,
|
|
keepDom: !0,
|
|
fresh: !0,
|
|
autoDestroy: !1,
|
|
onVisibleChanged: v,
|
|
ready: _,
|
|
offsetX: y,
|
|
offsetY: x,
|
|
offsetR: C,
|
|
offsetB: E,
|
|
onAlign: j,
|
|
onPrepare: N,
|
|
onResize: (e) =>
|
|
u({ width: e.offsetWidth, height: e.offsetHeight }),
|
|
arrowPos: { x: S, y: w },
|
|
align: k,
|
|
zIndex: i.zIndex,
|
|
mask: i.mask,
|
|
arrow: i.arrow,
|
|
motion: i.popupMotion,
|
|
maskMotion: i.maskMotion,
|
|
getPopupContainer: i.getPopupContainer,
|
|
},
|
|
m.createElement(nb, {
|
|
prefixCls: M,
|
|
isMobile: !1,
|
|
ready: _,
|
|
open: n,
|
|
align: k,
|
|
offsetR: C,
|
|
offsetB: E,
|
|
offsetX: y,
|
|
offsetY: x,
|
|
arrowPos: { x: S, y: w },
|
|
popupSize: c,
|
|
motion: i.popupMotion,
|
|
uniqueContainerClassName: (0, rn.clsx)(
|
|
i.uniqueContainerClassName,
|
|
P,
|
|
),
|
|
uniqueContainerStyle: i.uniqueContainerStyle,
|
|
}),
|
|
),
|
|
),
|
|
);
|
|
};
|
|
function n_(e, t) {
|
|
return m.default.isValidElement(e)
|
|
? m.default.cloneElement(
|
|
e,
|
|
"function" == typeof t ? t(e.props || {}) : t,
|
|
)
|
|
: e;
|
|
}
|
|
!(function (e = rr) {
|
|
(t, r) => {
|
|
var n;
|
|
let o,
|
|
a,
|
|
i,
|
|
l,
|
|
{
|
|
prefixCls: s = "rc-trigger-popup",
|
|
children: c,
|
|
action: u = "hover",
|
|
showAction: d,
|
|
hideAction: f,
|
|
popupVisible: p,
|
|
defaultPopupVisible: h,
|
|
onOpenChange: g,
|
|
afterOpenChange: b,
|
|
onPopupVisibleChange: v,
|
|
afterPopupVisibleChange: _,
|
|
mouseEnterDelay: y,
|
|
mouseLeaveDelay: x = 0.1,
|
|
focusDelay: C,
|
|
blurDelay: E,
|
|
mask: S,
|
|
maskClosable: w = !0,
|
|
getPopupContainer: k,
|
|
forceRender: j,
|
|
autoDestroy: P,
|
|
popup: R,
|
|
popupClassName: N,
|
|
uniqueContainerClassName: $,
|
|
uniqueContainerStyle: O,
|
|
popupStyle: T,
|
|
popupPlacement: M,
|
|
builtinPlacements: I = {},
|
|
popupAlign: A,
|
|
zIndex: L,
|
|
stretch: B,
|
|
getPopupClassNameFromAlign: D,
|
|
fresh: H,
|
|
unique: z,
|
|
alignPoint: W,
|
|
onPopupClick: F,
|
|
onPopupAlign: U,
|
|
arrow: G,
|
|
popupMotion: q,
|
|
maskMotion: X,
|
|
mobile: K,
|
|
...V
|
|
} = t,
|
|
Y = void 0 === p,
|
|
Q = !!K,
|
|
Z = m.useRef({}),
|
|
J = m.useContext(ne),
|
|
ee = m.useMemo(
|
|
() => ({
|
|
registerSubPopup: (e, t) => {
|
|
(Z.current[e] = t), J?.registerSubPopup(e, t);
|
|
},
|
|
}),
|
|
[J],
|
|
),
|
|
et = m.useContext(nt),
|
|
er = t5(),
|
|
[en, eo] = m.useState(null),
|
|
ea = m.useRef(null),
|
|
ei = eI((e) => {
|
|
(ea.current = e),
|
|
ro(e) && en !== e && eo(e),
|
|
J?.registerSubPopup(er, e);
|
|
}),
|
|
[el, es] = m.useState(null),
|
|
ec = m.useRef(null),
|
|
eu = eI((e) => {
|
|
let t = ra(e);
|
|
ro(t) && el !== t && (es(t), (ec.current = t));
|
|
}),
|
|
ed = {},
|
|
ef = eI(
|
|
(e) =>
|
|
el?.contains(e) ||
|
|
rh(el)?.host === e ||
|
|
e === el ||
|
|
en?.contains(e) ||
|
|
rh(en)?.host === e ||
|
|
e === en ||
|
|
Object.values(Z.current).some((t) => t?.contains(e) || e === t),
|
|
),
|
|
em = G ? { ...(!0 !== G ? G : {}) } : null,
|
|
[ep, eh] = (function (e, t) {
|
|
let [r, n] = (0, m.useState)(e),
|
|
o = void 0 !== t ? t : r;
|
|
return (
|
|
eL(
|
|
(e) => {
|
|
e || n(t);
|
|
},
|
|
[t],
|
|
),
|
|
[o, n]
|
|
);
|
|
})(h || !1, p),
|
|
eg = ep || !1,
|
|
eb = m.useMemo(() => {
|
|
let e = "function" == typeof c ? c({ open: eg }) : c;
|
|
return m.Children.only(e);
|
|
}, [c, eg]),
|
|
ev = eb?.props || {},
|
|
e_ = eI(() => eg),
|
|
ey = eI((e = 0) => ({
|
|
popup: R,
|
|
target: el,
|
|
delay: e,
|
|
prefixCls: s,
|
|
popupClassName: N,
|
|
uniqueContainerClassName: $,
|
|
uniqueContainerStyle: O,
|
|
popupStyle: T,
|
|
popupPlacement: M,
|
|
builtinPlacements: I,
|
|
popupAlign: A,
|
|
zIndex: L,
|
|
mask: S,
|
|
maskClosable: w,
|
|
popupMotion: q,
|
|
maskMotion: X,
|
|
arrow: em,
|
|
getPopupContainer: k,
|
|
getPopupClassNameFromAlign: D,
|
|
id: er,
|
|
onEsc: ew,
|
|
}));
|
|
eL(() => {
|
|
et && z && el && !Y && !J && (eg ? et.show(ey(y), e_) : et.hide(x));
|
|
}, [eg, el]);
|
|
let ex = m.useRef(eg);
|
|
ex.current = eg;
|
|
let eC = eI((e) => {
|
|
(0, tJ.flushSync)(() => {
|
|
eg !== e && (eh(e), g?.(e), v?.(e));
|
|
});
|
|
}),
|
|
eE = nh(),
|
|
eS = (e, t = 0) => {
|
|
void 0 !== p
|
|
? eE(() => {
|
|
eC(e);
|
|
}, t)
|
|
: et && z && Y && !J
|
|
? e
|
|
? et.show(ey(t), e_)
|
|
: et.hide(t)
|
|
: eE(() => {
|
|
eC(e);
|
|
}, t);
|
|
};
|
|
function ew({ top: e }) {
|
|
e && eS(!1);
|
|
}
|
|
let [ek, ej] = m.useState(!1);
|
|
eL(
|
|
(e) => {
|
|
(!e || eg) && ej(!0);
|
|
},
|
|
[eg],
|
|
);
|
|
let [eP, eR] = m.useState(null),
|
|
[eN, e$] = m.useState(null),
|
|
eO = (e) => {
|
|
e$([e.clientX, e.clientY]);
|
|
},
|
|
[eT, eM, eA, eB, eD, eH, ez, eW, eF, eU, eG] = np(
|
|
eg,
|
|
en,
|
|
W && null !== eN ? eN : el,
|
|
M,
|
|
I,
|
|
A,
|
|
U,
|
|
Q,
|
|
),
|
|
[eX, eK] = m.useMemo(() => {
|
|
let e = nr(d ?? u),
|
|
t = nr(f ?? u),
|
|
r = new Set(e),
|
|
n = new Set(t);
|
|
return (
|
|
r.has("hover") && !r.has("click") && r.add("touch"),
|
|
n.has("hover") && !n.has("click") && n.add("touch"),
|
|
[r, n]
|
|
);
|
|
}, [u, d, f]),
|
|
eY = eX.has("click"),
|
|
eQ = eK.has("click") || eK.has("contextMenu"),
|
|
eZ = eI(() => {
|
|
ek || eG();
|
|
});
|
|
eL(() => {
|
|
if (eg && el && en) {
|
|
let t = na(el),
|
|
r = na(en),
|
|
n = no(en),
|
|
o = new Set([n, ...t, ...r]);
|
|
function e() {
|
|
eZ(), ex.current && W && eQ && eS(!1);
|
|
}
|
|
return (
|
|
o.forEach((t) => {
|
|
t.addEventListener("scroll", e, { passive: !0 });
|
|
}),
|
|
n.addEventListener("resize", e, { passive: !0 }),
|
|
eZ(),
|
|
() => {
|
|
o.forEach((t) => {
|
|
t.removeEventListener("scroll", e),
|
|
n.removeEventListener("resize", e);
|
|
});
|
|
}
|
|
);
|
|
}
|
|
}, [eg, el, en]),
|
|
eL(() => {
|
|
eZ();
|
|
}, [eN, M]),
|
|
eL(() => {
|
|
eg && !I?.[M] && eZ();
|
|
}, [JSON.stringify(A)]);
|
|
let eJ = m.useMemo(() => {
|
|
let e = nn(I, s, eU, W);
|
|
return (0, rn.clsx)(e, D?.(eU));
|
|
}, [eU, D, I, s, W]);
|
|
m.useImperativeHandle(r, () => ({
|
|
nativeElement: ec.current,
|
|
popupElement: ea.current,
|
|
forceAlign: eZ,
|
|
}));
|
|
let [e0, e1] = m.useState(0),
|
|
[e2, e4] = m.useState(0),
|
|
e6 = () => {
|
|
if (B && el) {
|
|
let e = el.getBoundingClientRect();
|
|
e1(e.width), e4(e.height);
|
|
}
|
|
};
|
|
function e3(e, t, r, n, o) {
|
|
ed[e] = (a, ...i) => {
|
|
(o && o()) || (n?.(a), eS(t, r)), ev[e]?.(a, ...i);
|
|
};
|
|
}
|
|
eL(() => {
|
|
eP && (eG(), eP(), eR(null));
|
|
}, [eP]);
|
|
let e5 = eX.has("touch"),
|
|
e8 = eK.has("touch"),
|
|
e7 = m.useRef(!1);
|
|
(e5 || e8) &&
|
|
(ed.onTouchStart = (...e) => {
|
|
(e7.current = !0),
|
|
ex.current && e8 ? eS(!1) : !ex.current && e5 && eS(!0),
|
|
ev.onTouchStart?.(...e);
|
|
}),
|
|
(eY || eQ) &&
|
|
(ed.onClick = (e, ...t) => {
|
|
ex.current && eQ ? eS(!1) : !ex.current && eY && (eO(e), eS(!0)),
|
|
ev.onClick?.(e, ...t),
|
|
(e7.current = !1);
|
|
});
|
|
let e9 =
|
|
((n = eQ || e8),
|
|
((i = m.useRef(eg)).current = eg),
|
|
(l = m.useRef(!1)),
|
|
m.useEffect(() => {
|
|
if (n && en && (!S || w)) {
|
|
let e = () => {
|
|
l.current = !1;
|
|
},
|
|
t = (e) => {
|
|
!i.current ||
|
|
ef(e.composedPath?.()?.[0] || e.target) ||
|
|
l.current ||
|
|
eS(!1);
|
|
},
|
|
r = no(en);
|
|
r.addEventListener("pointerdown", e, !0),
|
|
r.addEventListener("mousedown", t, !0),
|
|
r.addEventListener("contextmenu", t, !0);
|
|
let n = rh(el);
|
|
return (
|
|
n &&
|
|
(n.addEventListener("mousedown", t, !0),
|
|
n.addEventListener("contextmenu", t, !0)),
|
|
() => {
|
|
r.removeEventListener("pointerdown", e, !0),
|
|
r.removeEventListener("mousedown", t, !0),
|
|
r.removeEventListener("contextmenu", t, !0),
|
|
n &&
|
|
(n.removeEventListener("mousedown", t, !0),
|
|
n.removeEventListener("contextmenu", t, !0));
|
|
}
|
|
);
|
|
}
|
|
}, [n, el, en, S, w]),
|
|
function () {
|
|
l.current = !0;
|
|
}),
|
|
te = eX.has("hover"),
|
|
tt = eK.has("hover"),
|
|
tr = () => e7.current;
|
|
if (te) {
|
|
let e = (e) => {
|
|
eO(e);
|
|
};
|
|
e3("onMouseEnter", !0, y, e, tr),
|
|
e3("onPointerEnter", !0, y, e, tr),
|
|
(o = (e) => {
|
|
(eg || ek) && en?.contains(e.target) && eS(!0, y);
|
|
}),
|
|
W &&
|
|
(ed.onMouseMove = (e) => {
|
|
ev.onMouseMove?.(e);
|
|
});
|
|
}
|
|
tt &&
|
|
(e3("onMouseLeave", !1, x, void 0, tr),
|
|
e3("onPointerLeave", !1, x, void 0, tr),
|
|
(a = () => {
|
|
eS(!1, x);
|
|
})),
|
|
eX.has("focus") && e3("onFocus", !0, C),
|
|
eK.has("focus") && e3("onBlur", !1, E),
|
|
eX.has("contextMenu") &&
|
|
(ed.onContextMenu = (e, ...t) => {
|
|
ex.current && eK.has("contextMenu") ? eS(!1) : (eO(e), eS(!0)),
|
|
e.preventDefault(),
|
|
ev.onContextMenu?.(e, ...t);
|
|
});
|
|
let tn = m.useRef(!1);
|
|
tn.current ||= j || eg || ek;
|
|
let to = { ...ev, ...ed },
|
|
ta = {};
|
|
[
|
|
"onContextMenu",
|
|
"onClick",
|
|
"onMouseDown",
|
|
"onTouchStart",
|
|
"onMouseEnter",
|
|
"onMouseLeave",
|
|
"onFocus",
|
|
"onBlur",
|
|
].forEach((e) => {
|
|
V[e] &&
|
|
(ta[e] = (...t) => {
|
|
to[e]?.(...t), V[e](...t);
|
|
});
|
|
}),
|
|
ru(eg, el, () => {
|
|
e6(), eZ();
|
|
});
|
|
let ti = eq(eu, eV(eb)),
|
|
tl = m.cloneElement(eb, { ...to, ...ta, ref: ti });
|
|
return m.createElement(
|
|
m.Fragment,
|
|
null,
|
|
tl,
|
|
tn.current &&
|
|
(!et || !z) &&
|
|
m.createElement(
|
|
ne.Provider,
|
|
{ value: ee },
|
|
m.createElement(r9, {
|
|
portal: e,
|
|
ref: ei,
|
|
prefixCls: s,
|
|
popup: R,
|
|
className: (0, rn.clsx)(N, !Q && eJ),
|
|
style: T,
|
|
target: el,
|
|
onMouseEnter: o,
|
|
onMouseLeave: a,
|
|
onPointerEnter: o,
|
|
zIndex: L,
|
|
open: eg,
|
|
keepDom: ek,
|
|
fresh: H,
|
|
onClick: F,
|
|
onPointerDownCapture: e9,
|
|
mask: S,
|
|
motion: q,
|
|
maskMotion: X,
|
|
onVisibleChanged: (e) => {
|
|
ej(!1), eG(), b?.(e), _?.(e);
|
|
},
|
|
onPrepare: () =>
|
|
new Promise((e) => {
|
|
e6(), eR(() => e);
|
|
}),
|
|
forceRender: j,
|
|
autoDestroy: P || !1,
|
|
getPopupContainer: k,
|
|
onEsc: ew,
|
|
align: eU,
|
|
arrow: em,
|
|
arrowPos: { x: eH, y: ez },
|
|
ready: eT,
|
|
offsetX: eM,
|
|
offsetY: eA,
|
|
offsetR: eB,
|
|
offsetB: eD,
|
|
onAlign: eZ,
|
|
stretch: B,
|
|
targetWidth: e0 / eW,
|
|
targetHeight: e2 / eF,
|
|
mobile: K,
|
|
}),
|
|
),
|
|
);
|
|
};
|
|
})(rr);
|
|
let ny = "anticon",
|
|
nx = m.createContext({
|
|
getPrefixCls: (e, t) => t || (e ? `ant-${e}` : "ant"),
|
|
iconPrefixCls: ny,
|
|
}),
|
|
{ Consumer: nC } = nx,
|
|
nE = {};
|
|
function nS(e) {
|
|
let t = m.useContext(nx),
|
|
{
|
|
getPrefixCls: r,
|
|
direction: n,
|
|
getPopupContainer: o,
|
|
renderEmpty: a,
|
|
} = t;
|
|
return {
|
|
classNames: nE,
|
|
styles: nE,
|
|
...t[e],
|
|
getPrefixCls: r,
|
|
direction: n,
|
|
getPopupContainer: o,
|
|
renderEmpty: a,
|
|
};
|
|
}
|
|
let nw = ({ children: e }) => {
|
|
let { getPrefixCls: t } = m.default.useContext(nx),
|
|
r = t();
|
|
return m.default.isValidElement(e)
|
|
? m.default.createElement(
|
|
rX,
|
|
{
|
|
visible: !0,
|
|
motionName: `${r}-fade`,
|
|
motionAppear: !0,
|
|
motionEnter: !0,
|
|
motionLeave: !1,
|
|
removeOnLeave: !1,
|
|
},
|
|
({ style: t, className: r }) =>
|
|
n_(e, (e) => ({
|
|
className: (0, rn.clsx)(e.className, r),
|
|
style: { ...e.style, ...t },
|
|
})),
|
|
)
|
|
: e;
|
|
},
|
|
nk = [null, null],
|
|
nj = ({ children: e }) =>
|
|
m.default.createElement(
|
|
nv,
|
|
{
|
|
postTriggerProps: (e) => {
|
|
let { id: t, builtinPlacements: r, popup: n } = e,
|
|
o = "function" == typeof n ? n() : n,
|
|
a = (function (e) {
|
|
if (nk[0] !== e) {
|
|
let t = {};
|
|
Object.keys(e).forEach((r) => {
|
|
t[r] = { ...e[r], dynamicInset: !1 };
|
|
}),
|
|
(nk[0] = e),
|
|
(nk[1] = t);
|
|
}
|
|
return nk[1];
|
|
})(r);
|
|
return {
|
|
...e,
|
|
getPopupContainer: null,
|
|
arrow: !1,
|
|
popup: m.default.createElement(nw, { key: t }, o),
|
|
builtinPlacements: a,
|
|
};
|
|
},
|
|
},
|
|
e,
|
|
),
|
|
nP = m.createContext(!1),
|
|
nR = ({ children: e, disabled: t }) => {
|
|
let r = m.useContext(nP);
|
|
return m.createElement(nP.Provider, { value: t ?? r }, e);
|
|
},
|
|
nN = m.createContext(void 0),
|
|
n$ = ({ children: e, size: t }) => {
|
|
let r = m.useContext(nN);
|
|
return m.createElement(nN.Provider, { value: t || r }, e);
|
|
};
|
|
function nO(e) {
|
|
return e >= 0 && e <= 255;
|
|
}
|
|
let nT = function (e, t) {
|
|
let { r: r, g: n, b: o, a: a } = new tu(e).toRgb();
|
|
if (a < 1) return e;
|
|
let { r: i, g: l, b: s } = new tu(t).toRgb();
|
|
for (let e = 0.01; e <= 1; e += 0.01) {
|
|
let t = Math.round((r - i * (1 - e)) / e),
|
|
a = Math.round((n - l * (1 - e)) / e),
|
|
c = Math.round((o - s * (1 - e)) / e);
|
|
if (nO(t) && nO(a) && nO(c))
|
|
return new tu({
|
|
r: t,
|
|
g: a,
|
|
b: c,
|
|
a: Math.round(100 * e) / 100,
|
|
}).toRgbString();
|
|
}
|
|
return new tu({ r: r, g: n, b: o, a: 1 }).toRgbString();
|
|
},
|
|
nM = {
|
|
lineHeight: !0,
|
|
lineHeightSM: !0,
|
|
lineHeightLG: !0,
|
|
lineHeightHeading1: !0,
|
|
lineHeightHeading2: !0,
|
|
lineHeightHeading3: !0,
|
|
lineHeightHeading4: !0,
|
|
lineHeightHeading5: !0,
|
|
opacityLoading: !0,
|
|
fontWeightStrong: !0,
|
|
zIndexPopupBase: !0,
|
|
zIndexBase: !0,
|
|
opacityImage: !0,
|
|
},
|
|
nI = { motionBase: !0, motionUnit: !0 },
|
|
nA = {
|
|
screenXS: !0,
|
|
screenXSMin: !0,
|
|
screenXSMax: !0,
|
|
screenSM: !0,
|
|
screenSMMin: !0,
|
|
screenSMMax: !0,
|
|
screenMD: !0,
|
|
screenMDMin: !0,
|
|
screenMDMax: !0,
|
|
screenLG: !0,
|
|
screenLGMin: !0,
|
|
screenLGMax: !0,
|
|
screenXL: !0,
|
|
screenXLMin: !0,
|
|
screenXLMax: !0,
|
|
screenXXL: !0,
|
|
screenXXLMin: !0,
|
|
},
|
|
nL = (e, t, r) => {
|
|
let n = r.getDerivativeToken(e),
|
|
{ override: o, ...a } = t,
|
|
i = { ...n, override: o };
|
|
return (
|
|
(i = (function (e) {
|
|
let { override: t, ...r } = e,
|
|
n = { ...t };
|
|
Object.keys(tG).forEach((e) => {
|
|
delete n[e];
|
|
});
|
|
let o = { ...r, ...n };
|
|
return (
|
|
!1 === o.motion &&
|
|
((o.motionDurationFast = "0s"),
|
|
(o.motionDurationMid = "0s"),
|
|
(o.motionDurationSlow = "0s")),
|
|
{
|
|
...o,
|
|
colorFillContent: o.colorFillSecondary,
|
|
colorFillContentHover: o.colorFill,
|
|
colorFillAlter: o.colorFillQuaternary,
|
|
colorBgContainerDisabled: o.colorFillTertiary,
|
|
colorBorderBg: o.colorBgContainer,
|
|
colorSplit: nT(o.colorBorderSecondary, o.colorBgContainer),
|
|
colorTextPlaceholder: o.colorTextQuaternary,
|
|
colorTextDisabled: o.colorTextQuaternary,
|
|
colorTextHeading: o.colorText,
|
|
colorTextLabel: o.colorTextSecondary,
|
|
colorTextDescription: o.colorTextTertiary,
|
|
colorTextLightSolid: o.colorWhite,
|
|
colorHighlight: o.colorError,
|
|
colorBgTextHover: o.colorFillSecondary,
|
|
colorBgTextActive: o.colorFill,
|
|
colorIcon: o.colorTextTertiary,
|
|
colorIconHover: o.colorText,
|
|
colorErrorOutline: nT(o.colorErrorBg, o.colorBgContainer),
|
|
colorWarningOutline: nT(o.colorWarningBg, o.colorBgContainer),
|
|
fontSizeIcon: o.fontSizeSM,
|
|
lineWidthFocus: 3 * o.lineWidth,
|
|
lineWidth: o.lineWidth,
|
|
controlOutlineWidth: 2 * o.lineWidth,
|
|
controlInteractiveSize: o.controlHeight / 2,
|
|
controlItemBgHover: o.colorFillTertiary,
|
|
controlItemBgActive: o.colorPrimaryBg,
|
|
controlItemBgActiveHover: o.colorPrimaryBgHover,
|
|
controlItemBgActiveDisabled: o.colorFill,
|
|
controlTmpOutline: o.colorFillQuaternary,
|
|
controlOutline: nT(o.colorPrimaryBg, o.colorBgContainer),
|
|
lineType: o.lineType,
|
|
borderRadius: o.borderRadius,
|
|
borderRadiusXS: o.borderRadiusXS,
|
|
borderRadiusSM: o.borderRadiusSM,
|
|
borderRadiusLG: o.borderRadiusLG,
|
|
fontWeightStrong: 600,
|
|
opacityLoading: 0.65,
|
|
linkDecoration: "none",
|
|
linkHoverDecoration: "none",
|
|
linkFocusDecoration: "none",
|
|
controlPaddingHorizontal: 12,
|
|
controlPaddingHorizontalSM: 8,
|
|
paddingXXS: o.sizeXXS,
|
|
paddingXS: o.sizeXS,
|
|
paddingSM: o.sizeSM,
|
|
padding: o.size,
|
|
paddingMD: o.sizeMD,
|
|
paddingLG: o.sizeLG,
|
|
paddingXL: o.sizeXL,
|
|
paddingContentHorizontalLG: o.sizeLG,
|
|
paddingContentVerticalLG: o.sizeMS,
|
|
paddingContentHorizontal: o.sizeMS,
|
|
paddingContentVertical: o.sizeSM,
|
|
paddingContentHorizontalSM: o.size,
|
|
paddingContentVerticalSM: o.sizeXS,
|
|
marginXXS: o.sizeXXS,
|
|
marginXS: o.sizeXS,
|
|
marginSM: o.sizeSM,
|
|
margin: o.size,
|
|
marginMD: o.sizeMD,
|
|
marginLG: o.sizeLG,
|
|
marginXL: o.sizeXL,
|
|
marginXXL: o.sizeXXL,
|
|
boxShadow: `
|
|
0 6px 16px 0 rgba(0, 0, 0, 0.08),
|
|
0 3px 6px -4px rgba(0, 0, 0, 0.12),
|
|
0 9px 28px 8px rgba(0, 0, 0, 0.05)
|
|
`,
|
|
boxShadowSecondary: `
|
|
0 6px 16px 0 rgba(0, 0, 0, 0.08),
|
|
0 3px 6px -4px rgba(0, 0, 0, 0.12),
|
|
0 9px 28px 8px rgba(0, 0, 0, 0.05)
|
|
`,
|
|
boxShadowTertiary: `
|
|
0 1px 2px 0 rgba(0, 0, 0, 0.03),
|
|
0 1px 6px -1px rgba(0, 0, 0, 0.02),
|
|
0 2px 4px 0 rgba(0, 0, 0, 0.02)
|
|
`,
|
|
screenXS: 480,
|
|
screenXSMin: 480,
|
|
screenXSMax: 575,
|
|
screenSM: 576,
|
|
screenSMMin: 576,
|
|
screenSMMax: 767,
|
|
screenMD: 768,
|
|
screenMDMin: 768,
|
|
screenMDMax: 991,
|
|
screenLG: 992,
|
|
screenLGMin: 992,
|
|
screenLGMax: 1199,
|
|
screenXL: 1200,
|
|
screenXLMin: 1200,
|
|
screenXLMax: 1599,
|
|
screenXXL: 1600,
|
|
screenXXLMin: 1600,
|
|
boxShadowPopoverArrow: "2px 2px 5px rgba(0, 0, 0, 0.05)",
|
|
boxShadowCard: `
|
|
0 1px 2px -2px ${new tu("rgba(0, 0, 0, 0.16)").toRgbString()},
|
|
0 3px 6px 0 ${new tu("rgba(0, 0, 0, 0.12)").toRgbString()},
|
|
0 5px 12px 4px ${new tu("rgba(0, 0, 0, 0.09)").toRgbString()}
|
|
`,
|
|
boxShadowDrawerRight: `
|
|
-6px 0 16px 0 rgba(0, 0, 0, 0.08),
|
|
-3px 0 6px -4px rgba(0, 0, 0, 0.12),
|
|
-9px 0 28px 8px rgba(0, 0, 0, 0.05)
|
|
`,
|
|
boxShadowDrawerLeft: `
|
|
6px 0 16px 0 rgba(0, 0, 0, 0.08),
|
|
3px 0 6px -4px rgba(0, 0, 0, 0.12),
|
|
9px 0 28px 8px rgba(0, 0, 0, 0.05)
|
|
`,
|
|
boxShadowDrawerUp: `
|
|
0 6px 16px 0 rgba(0, 0, 0, 0.08),
|
|
0 3px 6px -4px rgba(0, 0, 0, 0.12),
|
|
0 9px 28px 8px rgba(0, 0, 0, 0.05)
|
|
`,
|
|
boxShadowDrawerDown: `
|
|
0 -6px 16px 0 rgba(0, 0, 0, 0.08),
|
|
0 -3px 6px -4px rgba(0, 0, 0, 0.12),
|
|
0 -9px 28px 8px rgba(0, 0, 0, 0.05)
|
|
`,
|
|
boxShadowTabsOverflowLeft:
|
|
"inset 10px 0 8px -8px rgba(0, 0, 0, 0.08)",
|
|
boxShadowTabsOverflowRight:
|
|
"inset -10px 0 8px -8px rgba(0, 0, 0, 0.08)",
|
|
boxShadowTabsOverflowTop:
|
|
"inset 0 10px 8px -8px rgba(0, 0, 0, 0.08)",
|
|
boxShadowTabsOverflowBottom:
|
|
"inset 0 -10px 8px -8px rgba(0, 0, 0, 0.08)",
|
|
...n,
|
|
}
|
|
);
|
|
})(i)),
|
|
a &&
|
|
Object.entries(a).forEach(([e, t]) => {
|
|
let { theme: r, ...n } = t,
|
|
o = n;
|
|
r && (o = nL({ ...i, ...n }, { override: n }, r)), (i[e] = o);
|
|
}),
|
|
i
|
|
);
|
|
};
|
|
function nB() {
|
|
let {
|
|
token: e,
|
|
hashed: t,
|
|
theme: r,
|
|
override: n,
|
|
cssVar: o,
|
|
zeroRuntime: a,
|
|
} = m.default.useContext(tZ),
|
|
i = { prefix: o?.prefix ?? "ant", key: o?.key ?? "css-var-root" },
|
|
l = r || tY,
|
|
[s, c, u] = (function (e, t, r) {
|
|
let {
|
|
cache: { instanceId: n },
|
|
container: o,
|
|
hashPriority: a,
|
|
} = (0, m.useContext)(Q),
|
|
{
|
|
salt: i = "",
|
|
override: l = ep,
|
|
formatToken: s,
|
|
getComputedToken: c,
|
|
cssVar: u,
|
|
} = r,
|
|
d = (function (e, t) {
|
|
let r = en;
|
|
for (let e = 0; e < t.length; e += 1) {
|
|
let n = t[e];
|
|
r.has(n) || r.set(n, new WeakMap()), (r = r.get(n));
|
|
}
|
|
return r.has(eo) || r.set(eo, e()), r.get(eo);
|
|
})(() => Object.assign({}, ...t), t),
|
|
f = ei(d),
|
|
p = ei(l),
|
|
h = ei(u);
|
|
return em(
|
|
"token",
|
|
[i, e.id, f, p, h],
|
|
() => {
|
|
var t;
|
|
let r,
|
|
n = c
|
|
? c(d, l, e)
|
|
: ((r = { ...e.getDerivativeToken(d), ...l }),
|
|
s && (r = s(r)),
|
|
r),
|
|
o = { ...n },
|
|
f = `${i}_${u.prefix}`,
|
|
m = (0, w.default)(f),
|
|
p = `css-${m}`;
|
|
o._tokenKey = (0, w.default)(`${f}_${ei(o)}`);
|
|
let [h, g] = ed(n, u.key, {
|
|
prefix: u.prefix,
|
|
ignore: u.ignore,
|
|
unitless: u.unitless,
|
|
preserve: u.preserve,
|
|
hashPriority: a,
|
|
hashCls: u.hashed ? p : void 0,
|
|
});
|
|
return (
|
|
(h._hashId = m),
|
|
(t = u.key),
|
|
eh.set(t, (eh.get(t) || 0) + 1),
|
|
[h, p, o, g, u.key]
|
|
);
|
|
},
|
|
([, , , , e]) => {
|
|
let t;
|
|
eh.set(e, (eh.get(e) || 0) - 1),
|
|
(t = new Set()),
|
|
eh.forEach((e, r) => {
|
|
e <= 0 && t.add(r);
|
|
}),
|
|
eh.size - t.size > -1 &&
|
|
t.forEach((e) => {
|
|
"u" > typeof document &&
|
|
document
|
|
.querySelectorAll(`style[${K}="${e}"]`)
|
|
.forEach((e) => {
|
|
e[Y] === n && e.parentNode?.removeChild(e);
|
|
}),
|
|
eh.delete(e);
|
|
});
|
|
},
|
|
([, , , e, t]) => {
|
|
if (!e) return;
|
|
let r = A(e, (0, w.default)(`css-var-${t}`), {
|
|
mark: V,
|
|
prepend: "queue",
|
|
attachTo: o,
|
|
priority: -999,
|
|
});
|
|
(r[Y] = n), r.setAttribute(K, t);
|
|
},
|
|
);
|
|
})(l, [tG, e], {
|
|
salt: `6.2.3-${t || ""}`,
|
|
override: n,
|
|
getComputedToken: nL,
|
|
cssVar: { ...i, unitless: nM, ignore: nI, preserve: nA },
|
|
});
|
|
return [l, u, t ? c : "", s, i, !!a];
|
|
}
|
|
let nD = m.createContext(!0);
|
|
function nH(e) {
|
|
let t = m.useContext(nD),
|
|
{ children: r } = e,
|
|
[, n] = nB(),
|
|
{ motion: o } = n,
|
|
a = m.useRef(!1);
|
|
return (a.current || (a.current = t !== o), a.current)
|
|
? m.createElement(
|
|
nD.Provider,
|
|
{ value: o },
|
|
m.createElement(rb, { motion: o }, r),
|
|
)
|
|
: r;
|
|
}
|
|
let nz = () => null,
|
|
nW = (e) => ({
|
|
[`.${e}`]: {
|
|
...{
|
|
display: "inline-flex",
|
|
alignItems: "center",
|
|
color: "inherit",
|
|
fontStyle: "normal",
|
|
lineHeight: 0,
|
|
textAlign: "center",
|
|
textTransform: "none",
|
|
verticalAlign: "-0.125em",
|
|
textRendering: "optimizeLegibility",
|
|
"-webkit-font-smoothing": "antialiased",
|
|
"-moz-osx-font-smoothing": "grayscale",
|
|
"> *": { lineHeight: 1 },
|
|
svg: { display: "inline-block" },
|
|
},
|
|
[`.${e} .${e}-icon`]: { display: "block" },
|
|
},
|
|
}),
|
|
nF = ({ iconPrefixCls: e, csp: t }) => (
|
|
((e, t) => {
|
|
let [r, n] = nB();
|
|
return e$(
|
|
{
|
|
theme: r,
|
|
token: n,
|
|
hashId: "",
|
|
path: ["ant-design-icons", e],
|
|
nonce: () => t?.nonce,
|
|
layer: { name: "antd" },
|
|
},
|
|
() => nW(e),
|
|
);
|
|
})(e, t),
|
|
null
|
|
),
|
|
nU = [
|
|
"getTargetContainer",
|
|
"getPopupContainer",
|
|
"renderEmpty",
|
|
"input",
|
|
"pagination",
|
|
"form",
|
|
"select",
|
|
"button",
|
|
];
|
|
function nG() {
|
|
return n || "ant";
|
|
}
|
|
function nq() {
|
|
return o || ny;
|
|
}
|
|
let nX = () => ({
|
|
getPrefixCls: (e, t) => t || (e ? `${nG()}-${e}` : nG()),
|
|
getIconPrefixCls: nq,
|
|
getRootPrefixCls: () => n || nG(),
|
|
getTheme: () => a,
|
|
holderRender: i,
|
|
}),
|
|
nK = (e) => {
|
|
var t, r;
|
|
let n,
|
|
o,
|
|
a,
|
|
{
|
|
children: i,
|
|
csp: l,
|
|
autoInsertSpaceInButton: s,
|
|
alert: c,
|
|
affix: u,
|
|
anchor: d,
|
|
form: f,
|
|
locale: p,
|
|
componentSize: h,
|
|
direction: g,
|
|
space: b,
|
|
splitter: v,
|
|
virtual: _,
|
|
dropdownMatchSelectWidth: y,
|
|
popupMatchSelectWidth: x,
|
|
popupOverflow: C,
|
|
legacyLocale: E,
|
|
parentContext: S,
|
|
iconPrefixCls: w,
|
|
theme: k,
|
|
componentDisabled: j,
|
|
segmented: P,
|
|
statistic: R,
|
|
spin: N,
|
|
calendar: $,
|
|
carousel: O,
|
|
cascader: T,
|
|
collapse: M,
|
|
typography: I,
|
|
checkbox: A,
|
|
descriptions: B,
|
|
divider: D,
|
|
drawer: H,
|
|
skeleton: z,
|
|
steps: W,
|
|
image: F,
|
|
layout: G,
|
|
list: q,
|
|
mentions: X,
|
|
modal: K,
|
|
progress: V,
|
|
result: Y,
|
|
slider: Z,
|
|
breadcrumb: J,
|
|
masonry: ee,
|
|
menu: et,
|
|
pagination: en,
|
|
input: eo,
|
|
textArea: ea,
|
|
otp: ei,
|
|
empty: el,
|
|
badge: es,
|
|
radio: ec,
|
|
rate: eu,
|
|
ribbon: ed,
|
|
switch: ef,
|
|
transfer: em,
|
|
avatar: ep,
|
|
message: eh,
|
|
tag: eg,
|
|
table: eb,
|
|
card: ev,
|
|
cardMeta: e_,
|
|
tabs: ey,
|
|
timeline: ex,
|
|
timePicker: eC,
|
|
upload: eE,
|
|
notification: eS,
|
|
tree: ew,
|
|
colorPicker: ek,
|
|
datePicker: ej,
|
|
rangePicker: eP,
|
|
flex: eR,
|
|
wave: eN,
|
|
dropdown: e$,
|
|
warning: eO,
|
|
tour: eT,
|
|
tooltip: eI,
|
|
popover: eA,
|
|
popconfirm: eL,
|
|
qrcode: eB,
|
|
floatButton: eD,
|
|
floatButtonGroup: eH,
|
|
variant: ez,
|
|
inputNumber: eW,
|
|
treeSelect: eF,
|
|
watermark: eU,
|
|
} = e,
|
|
eG = m.useCallback(
|
|
(t, r) => {
|
|
let { prefixCls: n } = e;
|
|
if (r) return r;
|
|
let o = n || S.getPrefixCls("");
|
|
return t ? `${o}-${t}` : o;
|
|
},
|
|
[S.getPrefixCls, e.prefixCls],
|
|
),
|
|
eq = w || S.iconPrefixCls || ny,
|
|
eX = l || S.csp,
|
|
eK =
|
|
((t = S.theme),
|
|
(r = { prefixCls: eG("") }),
|
|
e4("ConfigProvider"),
|
|
(o =
|
|
!1 !== (n = k || {}).inherit && t
|
|
? t
|
|
: { ...tQ, hashed: t?.hashed ?? tQ.hashed, cssVar: t?.cssVar }),
|
|
(a = (0, m.useId)()),
|
|
L(
|
|
() => {
|
|
if (!k) return t;
|
|
let e = { ...o.components };
|
|
Object.keys(k.components || {}).forEach((t) => {
|
|
e[t] = { ...e[t], ...k.components[t] };
|
|
});
|
|
let i = `css-var-${a.replace(/:/g, "")}`,
|
|
l = {
|
|
prefix: r?.prefixCls,
|
|
...o.cssVar,
|
|
...n.cssVar,
|
|
key: n.cssVar?.key || i,
|
|
};
|
|
return {
|
|
...o,
|
|
...n,
|
|
token: { ...o.token, ...n.token },
|
|
components: e,
|
|
cssVar: l,
|
|
};
|
|
},
|
|
[n, o],
|
|
(e, t) => e.some((e, r) => !U(e, t[r], !0)),
|
|
)),
|
|
eV = {
|
|
csp: eX,
|
|
autoInsertSpaceInButton: s,
|
|
alert: c,
|
|
affix: u,
|
|
anchor: d,
|
|
locale: p || E,
|
|
direction: g,
|
|
space: b,
|
|
splitter: v,
|
|
virtual: _,
|
|
popupMatchSelectWidth: x ?? y,
|
|
popupOverflow: C,
|
|
getPrefixCls: eG,
|
|
iconPrefixCls: eq,
|
|
theme: eK,
|
|
segmented: P,
|
|
statistic: R,
|
|
spin: N,
|
|
calendar: $,
|
|
carousel: O,
|
|
cascader: T,
|
|
collapse: M,
|
|
typography: I,
|
|
checkbox: A,
|
|
descriptions: B,
|
|
divider: D,
|
|
drawer: H,
|
|
skeleton: z,
|
|
steps: W,
|
|
image: F,
|
|
input: eo,
|
|
textArea: ea,
|
|
otp: ei,
|
|
layout: G,
|
|
list: q,
|
|
mentions: X,
|
|
modal: K,
|
|
progress: V,
|
|
result: Y,
|
|
slider: Z,
|
|
breadcrumb: J,
|
|
masonry: ee,
|
|
menu: et,
|
|
pagination: en,
|
|
empty: el,
|
|
badge: es,
|
|
radio: ec,
|
|
rate: eu,
|
|
ribbon: ed,
|
|
switch: ef,
|
|
transfer: em,
|
|
avatar: ep,
|
|
message: eh,
|
|
tag: eg,
|
|
table: eb,
|
|
card: ev,
|
|
cardMeta: e_,
|
|
tabs: ey,
|
|
timeline: ex,
|
|
timePicker: eC,
|
|
upload: eE,
|
|
notification: eS,
|
|
tree: ew,
|
|
colorPicker: ek,
|
|
datePicker: ej,
|
|
rangePicker: eP,
|
|
flex: eR,
|
|
wave: eN,
|
|
dropdown: e$,
|
|
warning: eO,
|
|
tour: eT,
|
|
tooltip: eI,
|
|
popover: eA,
|
|
popconfirm: eL,
|
|
qrcode: eB,
|
|
floatButton: eD,
|
|
floatButtonGroup: eH,
|
|
variant: ez,
|
|
inputNumber: eW,
|
|
treeSelect: eF,
|
|
watermark: eU,
|
|
},
|
|
e0 = { ...S };
|
|
Object.keys(eV).forEach((e) => {
|
|
void 0 !== eV[e] && (e0[e] = eV[e]);
|
|
}),
|
|
nU.forEach((t) => {
|
|
let r = e[t];
|
|
r && (e0[t] = r);
|
|
}),
|
|
void 0 !== s && (e0.button = { autoInsertSpace: s, ...e0.button });
|
|
let e1 = L(
|
|
() => e0,
|
|
e0,
|
|
(e, t) => {
|
|
let r = Object.keys(e),
|
|
n = Object.keys(t);
|
|
return r.length !== n.length || r.some((r) => e[r] !== t[r]);
|
|
},
|
|
),
|
|
{ layer: e3 } = m.useContext(Q),
|
|
e5 = m.useMemo(
|
|
() => ({ prefixCls: eq, csp: eX, layer: e3 ? "antd" : void 0 }),
|
|
[eq, eX, e3],
|
|
),
|
|
e8 = m.createElement(
|
|
m.Fragment,
|
|
null,
|
|
m.createElement(nF, { iconPrefixCls: eq, csp: eX }),
|
|
m.createElement(nz, { dropdownMatchSelectWidth: y }),
|
|
i,
|
|
),
|
|
e7 = m.useMemo(
|
|
() =>
|
|
(function (...e) {
|
|
return (function (e, t = {}) {
|
|
let { prepareArray: r } = t,
|
|
n = r || (() => []),
|
|
o = eZ(e[0]);
|
|
return (
|
|
e.forEach((e) => {
|
|
!(function t(r, a) {
|
|
let i = new Set(a),
|
|
l = eY(e, r),
|
|
s = Array.isArray(l);
|
|
if (
|
|
s ||
|
|
("object" == typeof l &&
|
|
null !== l &&
|
|
Object.getPrototypeOf(l) === Object.prototype)
|
|
) {
|
|
if (!i.has(l)) {
|
|
i.add(l);
|
|
let e = eY(o, r);
|
|
s
|
|
? (o = eQ(o, r, n(e, l)))
|
|
: (e && "object" == typeof e) ||
|
|
(o = eQ(o, r, eZ(l))),
|
|
eJ(l).forEach((e) => {
|
|
Object.getOwnPropertyDescriptor(l, e)
|
|
.enumerable && t([...r, e], i);
|
|
});
|
|
}
|
|
} else o = eQ(o, r, l);
|
|
})([]);
|
|
}),
|
|
o
|
|
);
|
|
})(e);
|
|
})(
|
|
te || {},
|
|
e1.locale?.Form?.defaultValidateMessages || {},
|
|
e1.form?.validateMessages || {},
|
|
f?.validateMessages || {},
|
|
),
|
|
[e1, f?.validateMessages],
|
|
);
|
|
Object.keys(e7).length > 0 &&
|
|
(e8 = m.createElement(e6.Provider, { value: e7 }, e8)),
|
|
p &&
|
|
(e8 = m.createElement(
|
|
to,
|
|
{ locale: p, _ANT_MARK__: "internalMark" },
|
|
e8,
|
|
)),
|
|
(eq || eX) && (e8 = m.createElement(eM.Provider, { value: e5 }, e8)),
|
|
h && (e8 = m.createElement(n$, { size: h }, e8)),
|
|
(e8 = m.createElement(nH, null, e8)),
|
|
eI?.unique && (e8 = m.createElement(nj, null, e8));
|
|
let e9 = m.useMemo(() => {
|
|
let {
|
|
algorithm: e,
|
|
token: t,
|
|
components: r,
|
|
cssVar: n,
|
|
...o
|
|
} = eK || {},
|
|
a = e && (!Array.isArray(e) || e.length > 0) ? er(e) : tY,
|
|
i = {};
|
|
Object.entries(r || {}).forEach(([e, t]) => {
|
|
let r = { ...t };
|
|
"algorithm" in r &&
|
|
(!0 === r.algorithm
|
|
? (r.theme = a)
|
|
: (Array.isArray(r.algorithm) ||
|
|
"function" == typeof r.algorithm) &&
|
|
(r.theme = er(r.algorithm)),
|
|
delete r.algorithm),
|
|
(i[e] = r);
|
|
});
|
|
let l = { ...tG, ...t };
|
|
return {
|
|
...o,
|
|
theme: a,
|
|
token: l,
|
|
components: i,
|
|
override: { override: l, ...i },
|
|
cssVar: n,
|
|
};
|
|
}, [eK]);
|
|
return (
|
|
k && (e8 = m.createElement(tZ.Provider, { value: e9 }, e8)),
|
|
e1.warning &&
|
|
(e8 = m.createElement(e2.Provider, { value: e1.warning }, e8)),
|
|
void 0 !== j && (e8 = m.createElement(nR, { disabled: j }, e8)),
|
|
m.createElement(nx.Provider, { value: e1 }, e8)
|
|
);
|
|
},
|
|
nV = (e) => {
|
|
let t = m.useContext(nx),
|
|
r = m.useContext(tn);
|
|
return m.createElement(nK, { parentContext: t, legacyLocale: r, ...e });
|
|
};
|
|
(nV.ConfigContext = nx),
|
|
(nV.SizeContext = nN),
|
|
(nV.config = (e) => {
|
|
let { prefixCls: t, iconPrefixCls: r, theme: l, holderRender: s } = e;
|
|
void 0 !== t && (n = t),
|
|
void 0 !== r && (o = r),
|
|
"holderRender" in e && (i = s),
|
|
l && (a = l);
|
|
}),
|
|
(nV.useConfig = function () {
|
|
return {
|
|
componentDisabled: (0, m.useContext)(nP),
|
|
componentSize: (0, m.useContext)(nN),
|
|
};
|
|
}),
|
|
Object.defineProperty(nV, "SizeContext", { get: () => nN });
|
|
var nY = e.i(826579);
|
|
function nQ(e) {
|
|
return (
|
|
"object" == typeof e &&
|
|
"string" == typeof e.name &&
|
|
"string" == typeof e.theme &&
|
|
("object" == typeof e.icon || "function" == typeof e.icon)
|
|
);
|
|
}
|
|
function nZ(e = {}) {
|
|
return Object.keys(e).reduce((t, r) => {
|
|
let n = e[r];
|
|
return (
|
|
"class" === r
|
|
? ((t.className = n), delete t.class)
|
|
: (delete t[r],
|
|
(t[r.replace(/-(.)/g, (e, t) => t.toUpperCase())] = n)),
|
|
t
|
|
);
|
|
}, {});
|
|
}
|
|
function nJ(e) {
|
|
return e ? (Array.isArray(e) ? e : [e]) : [];
|
|
}
|
|
let n0 = `
|
|
.anticon {
|
|
display: inline-flex;
|
|
align-items: center;
|
|
color: inherit;
|
|
font-style: normal;
|
|
line-height: 0;
|
|
text-align: center;
|
|
text-transform: none;
|
|
vertical-align: -0.125em;
|
|
text-rendering: optimizeLegibility;
|
|
-webkit-font-smoothing: antialiased;
|
|
-moz-osx-font-smoothing: grayscale;
|
|
}
|
|
|
|
.anticon > * {
|
|
line-height: 1;
|
|
}
|
|
|
|
.anticon svg {
|
|
display: inline-block;
|
|
vertical-align: inherit;
|
|
}
|
|
|
|
.anticon::before {
|
|
display: none;
|
|
}
|
|
|
|
.anticon .anticon-icon {
|
|
display: block;
|
|
}
|
|
|
|
.anticon[tabindex] {
|
|
cursor: pointer;
|
|
}
|
|
|
|
.anticon-spin::before,
|
|
.anticon-spin {
|
|
display: inline-block;
|
|
-webkit-animation: loadingCircle 1s infinite linear;
|
|
animation: loadingCircle 1s infinite linear;
|
|
}
|
|
|
|
@-webkit-keyframes loadingCircle {
|
|
100% {
|
|
-webkit-transform: rotate(360deg);
|
|
transform: rotate(360deg);
|
|
}
|
|
}
|
|
|
|
@keyframes loadingCircle {
|
|
100% {
|
|
-webkit-transform: rotate(360deg);
|
|
transform: rotate(360deg);
|
|
}
|
|
}
|
|
`,
|
|
n1 = { primaryColor: "#333", secondaryColor: "#E6E6E6", calculated: !1 },
|
|
n2 = (e) => {
|
|
var t, r;
|
|
let {
|
|
icon: n,
|
|
className: o,
|
|
onClick: a,
|
|
style: i,
|
|
primaryColor: l,
|
|
secondaryColor: s,
|
|
...c
|
|
} = e,
|
|
u = m.useRef(null),
|
|
d = n1;
|
|
if (
|
|
(l && (d = { primaryColor: l, secondaryColor: s || th(l)[0] }),
|
|
((e) => {
|
|
let { csp: t, prefixCls: r, layer: n } = (0, m.useContext)(eM),
|
|
o = n0;
|
|
r && (o = o.replace(/anticon/g, r)),
|
|
n &&
|
|
(o = `@layer ${n} {
|
|
${o}
|
|
}`),
|
|
(0, m.useEffect)(() => {
|
|
let r = rh(e.current);
|
|
A(o, "@ant-design-icons", { prepend: !n, csp: t, attachTo: r });
|
|
}, []);
|
|
})(u),
|
|
(t = nQ(n)),
|
|
(r = `icon should be icon definiton, but got ${n}`),
|
|
F(t, `[@ant-design/icons] ${r}`),
|
|
!nQ(n))
|
|
)
|
|
return null;
|
|
let f = n;
|
|
return (
|
|
f &&
|
|
"function" == typeof f.icon &&
|
|
(f = { ...f, icon: f.icon(d.primaryColor, d.secondaryColor) }),
|
|
(function e(t, r, n) {
|
|
return n
|
|
? m.default.createElement(
|
|
t.tag,
|
|
{ key: r, ...nZ(t.attrs), ...n },
|
|
(t.children || []).map((n, o) => e(n, `${r}-${t.tag}-${o}`)),
|
|
)
|
|
: m.default.createElement(
|
|
t.tag,
|
|
{ key: r, ...nZ(t.attrs) },
|
|
(t.children || []).map((n, o) => e(n, `${r}-${t.tag}-${o}`)),
|
|
);
|
|
})(f.icon, `svg-${f.name}`, {
|
|
className: o,
|
|
onClick: a,
|
|
style: i,
|
|
"data-icon": f.name,
|
|
width: "1em",
|
|
height: "1em",
|
|
fill: "currentColor",
|
|
"aria-hidden": "true",
|
|
...c,
|
|
ref: u,
|
|
})
|
|
);
|
|
};
|
|
function n4(e) {
|
|
let [t, r] = nJ(e);
|
|
return n2.setTwoToneColors({ primaryColor: t, secondaryColor: r });
|
|
}
|
|
function n6() {
|
|
return (n6 = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
(n2.displayName = "IconReact"),
|
|
(n2.getTwoToneColors = function () {
|
|
return { ...n1 };
|
|
}),
|
|
(n2.setTwoToneColors = function ({ primaryColor: e, secondaryColor: t }) {
|
|
(n1.primaryColor = e),
|
|
(n1.secondaryColor = t || th(e)[0]),
|
|
(n1.calculated = !!t);
|
|
}),
|
|
n4(tw.primary);
|
|
let n3 = m.forwardRef((e, t) => {
|
|
let {
|
|
className: r,
|
|
icon: n,
|
|
spin: o,
|
|
rotate: a,
|
|
tabIndex: i,
|
|
onClick: l,
|
|
twoToneColor: s,
|
|
...c
|
|
} = e,
|
|
{ prefixCls: u = "anticon", rootClassName: d } = m.useContext(eM),
|
|
f = (0, rn.clsx)(
|
|
d,
|
|
u,
|
|
{
|
|
[`${u}-${n.name}`]: !!n.name,
|
|
[`${u}-spin`]: !!o || "loading" === n.name,
|
|
},
|
|
r,
|
|
),
|
|
p = i;
|
|
void 0 === p && l && (p = -1);
|
|
let h = a
|
|
? { msTransform: `rotate(${a}deg)`, transform: `rotate(${a}deg)` }
|
|
: void 0,
|
|
[g, b] = nJ(s);
|
|
return m.createElement(
|
|
"span",
|
|
n6({ role: "img", "aria-label": n.name }, c, {
|
|
ref: t,
|
|
tabIndex: p,
|
|
onClick: l,
|
|
className: f,
|
|
}),
|
|
m.createElement(n2, {
|
|
icon: n,
|
|
primaryColor: g,
|
|
secondaryColor: b,
|
|
style: h,
|
|
}),
|
|
);
|
|
});
|
|
function n5() {
|
|
return (n5 = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
(n3.getTwoToneColor = function () {
|
|
let e = n2.getTwoToneColors();
|
|
return e.calculated ? [e.primaryColor, e.secondaryColor] : e.primaryColor;
|
|
}),
|
|
(n3.setTwoToneColor = n4);
|
|
let n8 = m.forwardRef((e, t) =>
|
|
m.createElement(n3, n5({}, e, { ref: t, icon: nY.default })),
|
|
);
|
|
var n7 = e.i(346188);
|
|
function n9() {
|
|
return (n9 = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let oe = m.forwardRef((e, t) =>
|
|
m.createElement(n3, n9({}, e, { ref: t, icon: n7.default })),
|
|
);
|
|
var ot = e.i(95002);
|
|
function or() {
|
|
return (or = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let on = m.forwardRef((e, t) =>
|
|
m.createElement(n3, or({}, e, { ref: t, icon: ot.default })),
|
|
);
|
|
var oo = e.i(752060);
|
|
function oa() {
|
|
return (oa = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let oi = m.forwardRef((e, t) =>
|
|
m.createElement(n3, oa({}, e, { ref: t, icon: oo.default })),
|
|
);
|
|
var ol = e.i(174477);
|
|
function os() {
|
|
return (os = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let oc = m.forwardRef((e, t) =>
|
|
m.createElement(n3, os({}, e, { ref: t, icon: ol.default })),
|
|
),
|
|
ou = {
|
|
MAC_ENTER: 3,
|
|
BACKSPACE: 8,
|
|
TAB: 9,
|
|
NUM_CENTER: 12,
|
|
ENTER: 13,
|
|
SHIFT: 16,
|
|
CTRL: 17,
|
|
ALT: 18,
|
|
PAUSE: 19,
|
|
CAPS_LOCK: 20,
|
|
ESC: 27,
|
|
SPACE: 32,
|
|
PAGE_UP: 33,
|
|
PAGE_DOWN: 34,
|
|
END: 35,
|
|
HOME: 36,
|
|
LEFT: 37,
|
|
UP: 38,
|
|
RIGHT: 39,
|
|
DOWN: 40,
|
|
PRINT_SCREEN: 44,
|
|
INSERT: 45,
|
|
DELETE: 46,
|
|
ZERO: 48,
|
|
ONE: 49,
|
|
TWO: 50,
|
|
THREE: 51,
|
|
FOUR: 52,
|
|
FIVE: 53,
|
|
SIX: 54,
|
|
SEVEN: 55,
|
|
EIGHT: 56,
|
|
NINE: 57,
|
|
QUESTION_MARK: 63,
|
|
A: 65,
|
|
B: 66,
|
|
C: 67,
|
|
D: 68,
|
|
E: 69,
|
|
F: 70,
|
|
G: 71,
|
|
H: 72,
|
|
I: 73,
|
|
J: 74,
|
|
K: 75,
|
|
L: 76,
|
|
M: 77,
|
|
N: 78,
|
|
O: 79,
|
|
P: 80,
|
|
Q: 81,
|
|
R: 82,
|
|
S: 83,
|
|
T: 84,
|
|
U: 85,
|
|
V: 86,
|
|
W: 87,
|
|
X: 88,
|
|
Y: 89,
|
|
Z: 90,
|
|
META: 91,
|
|
WIN_KEY_RIGHT: 92,
|
|
CONTEXT_MENU: 93,
|
|
NUM_ZERO: 96,
|
|
NUM_ONE: 97,
|
|
NUM_TWO: 98,
|
|
NUM_THREE: 99,
|
|
NUM_FOUR: 100,
|
|
NUM_FIVE: 101,
|
|
NUM_SIX: 102,
|
|
NUM_SEVEN: 103,
|
|
NUM_EIGHT: 104,
|
|
NUM_NINE: 105,
|
|
NUM_MULTIPLY: 106,
|
|
NUM_PLUS: 107,
|
|
NUM_MINUS: 109,
|
|
NUM_PERIOD: 110,
|
|
NUM_DIVISION: 111,
|
|
F1: 112,
|
|
F2: 113,
|
|
F3: 114,
|
|
F4: 115,
|
|
F5: 116,
|
|
F6: 117,
|
|
F7: 118,
|
|
F8: 119,
|
|
F9: 120,
|
|
F10: 121,
|
|
F11: 122,
|
|
F12: 123,
|
|
NUMLOCK: 144,
|
|
SEMICOLON: 186,
|
|
DASH: 189,
|
|
EQUALS: 187,
|
|
COMMA: 188,
|
|
PERIOD: 190,
|
|
SLASH: 191,
|
|
APOSTROPHE: 192,
|
|
SINGLE_QUOTE: 222,
|
|
OPEN_SQUARE_BRACKET: 219,
|
|
BACKSLASH: 220,
|
|
CLOSE_SQUARE_BRACKET: 221,
|
|
WIN_KEY: 224,
|
|
MAC_FF_META: 224,
|
|
WIN_IME: 229,
|
|
isTextModifyingKeyEvent: function (e) {
|
|
let { keyCode: t } = e;
|
|
if (
|
|
(e.altKey && !e.ctrlKey) ||
|
|
e.metaKey ||
|
|
(t >= ou.F1 && t <= ou.F12)
|
|
)
|
|
return !1;
|
|
switch (t) {
|
|
case ou.ALT:
|
|
case ou.CAPS_LOCK:
|
|
case ou.CONTEXT_MENU:
|
|
case ou.CTRL:
|
|
case ou.DOWN:
|
|
case ou.END:
|
|
case ou.ESC:
|
|
case ou.HOME:
|
|
case ou.INSERT:
|
|
case ou.LEFT:
|
|
case ou.MAC_FF_META:
|
|
case ou.META:
|
|
case ou.NUMLOCK:
|
|
case ou.NUM_CENTER:
|
|
case ou.PAGE_DOWN:
|
|
case ou.PAGE_UP:
|
|
case ou.PAUSE:
|
|
case ou.PRINT_SCREEN:
|
|
case ou.RIGHT:
|
|
case ou.SHIFT:
|
|
case ou.UP:
|
|
case ou.WIN_KEY:
|
|
case ou.WIN_KEY_RIGHT:
|
|
return !1;
|
|
default:
|
|
return !0;
|
|
}
|
|
},
|
|
isCharacterKey: function (e) {
|
|
if (
|
|
(e >= ou.ZERO && e <= ou.NINE) ||
|
|
(e >= ou.NUM_ZERO && e <= ou.NUM_MULTIPLY) ||
|
|
(e >= ou.A && e <= ou.Z) ||
|
|
(-1 !== window.navigator.userAgent.indexOf("WebKit") && 0 === e)
|
|
)
|
|
return !0;
|
|
switch (e) {
|
|
case ou.SPACE:
|
|
case ou.QUESTION_MARK:
|
|
case ou.NUM_PLUS:
|
|
case ou.NUM_MINUS:
|
|
case ou.NUM_PERIOD:
|
|
case ou.NUM_DIVISION:
|
|
case ou.SEMICOLON:
|
|
case ou.DASH:
|
|
case ou.EQUALS:
|
|
case ou.COMMA:
|
|
case ou.PERIOD:
|
|
case ou.SLASH:
|
|
case ou.APOSTROPHE:
|
|
case ou.SINGLE_QUOTE:
|
|
case ou.OPEN_SQUARE_BRACKET:
|
|
case ou.BACKSLASH:
|
|
case ou.CLOSE_SQUARE_BRACKET:
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
},
|
|
isEditableTarget: function (e) {
|
|
let t = e.target;
|
|
if (!(t instanceof HTMLElement)) return !1;
|
|
let r = t.tagName;
|
|
return (
|
|
"INPUT" === r ||
|
|
"TEXTAREA" === r ||
|
|
"SELECT" === r ||
|
|
!!t.isContentEditable
|
|
);
|
|
},
|
|
},
|
|
od = `accept acceptCharset accessKey action allowFullScreen allowTransparency
|
|
alt async autoComplete autoFocus autoPlay capture cellPadding cellSpacing challenge
|
|
charSet checked classID className colSpan cols content contentEditable contextMenu
|
|
controls coords crossOrigin data dateTime default defer dir disabled download draggable
|
|
encType form formAction formEncType formMethod formNoValidate formTarget frameBorder
|
|
headers height hidden high href hrefLang htmlFor httpEquiv icon id inputMode integrity
|
|
is keyParams keyType kind label lang list loop low manifest marginHeight marginWidth max maxLength media
|
|
mediaGroup method min minLength multiple muted name noValidate nonce open
|
|
optimum pattern placeholder poster preload radioGroup readOnly rel required
|
|
reversed role rowSpan rows sandbox scope scoped scrolling seamless selected
|
|
shape size sizes span spellCheck src srcDoc srcLang srcSet start step style
|
|
summary tabIndex target title type useMap value width wmode wrap`,
|
|
of = `onCopy onCut onPaste onCompositionEnd onCompositionStart onCompositionUpdate onKeyDown
|
|
onKeyPress onKeyUp onFocus onBlur onChange onInput onSubmit onClick onContextMenu onDoubleClick
|
|
onDrag onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop onMouseDown
|
|
onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver onMouseUp onSelect onTouchCancel
|
|
onTouchEnd onTouchMove onTouchStart onScroll onWheel onAbort onCanPlay onCanPlayThrough
|
|
onDurationChange onEmptied onEncrypted onEnded onError onLoadedData onLoadedMetadata
|
|
onLoadStart onPause onPlay onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend onTimeUpdate onVolumeChange onWaiting onLoad onError`,
|
|
om = `${od} ${of}`.split(/[\s\n]+/);
|
|
function op(e, t) {
|
|
return 0 === e.indexOf(t);
|
|
}
|
|
function oh() {
|
|
return (oh = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let og = m.forwardRef((e, t) => {
|
|
let {
|
|
prefixCls: r,
|
|
style: n,
|
|
className: o,
|
|
duration: a = 4.5,
|
|
showProgress: i,
|
|
pauseOnHover: l = !0,
|
|
eventKey: s,
|
|
content: c,
|
|
closable: u,
|
|
props: d,
|
|
onClick: f,
|
|
onNoticeClose: p,
|
|
times: h,
|
|
hovering: g,
|
|
} = e,
|
|
[b, v] = m.useState(!1),
|
|
[_, y] = m.useState(0),
|
|
[x, C] = m.useState(0),
|
|
E = g || b,
|
|
S = "number" == typeof a ? a : 0,
|
|
w = S > 0 && i,
|
|
k = () => {
|
|
p(s);
|
|
};
|
|
m.useEffect(() => {
|
|
if (!E && S > 0) {
|
|
let e = Date.now() - x,
|
|
t = setTimeout(
|
|
() => {
|
|
k();
|
|
},
|
|
1e3 * S - x,
|
|
);
|
|
return () => {
|
|
l && clearTimeout(t), C(Date.now() - e);
|
|
};
|
|
}
|
|
}, [S, E, h]),
|
|
m.useEffect(() => {
|
|
if (!E && w && (l || 0 === x)) {
|
|
let e,
|
|
t = performance.now(),
|
|
r = () => {
|
|
cancelAnimationFrame(e),
|
|
(e = requestAnimationFrame((e) => {
|
|
let n = Math.min((e + x - t) / (1e3 * S), 1);
|
|
y(100 * n), n < 1 && r();
|
|
}));
|
|
};
|
|
return (
|
|
r(),
|
|
() => {
|
|
l && cancelAnimationFrame(e);
|
|
}
|
|
);
|
|
}
|
|
}, [S, x, E, w, h]);
|
|
let j = m.useMemo(
|
|
() => ("object" == typeof u && null !== u ? u : {}),
|
|
[u],
|
|
),
|
|
P = (function (e, t = !1) {
|
|
let r;
|
|
r =
|
|
!1 === t
|
|
? { aria: !0, data: !0, attr: !0 }
|
|
: !0 === t
|
|
? { aria: !0 }
|
|
: { ...t };
|
|
let n = {};
|
|
return (
|
|
Object.keys(e).forEach((t) => {
|
|
((r.aria && ("role" === t || op(t, "aria-"))) ||
|
|
(r.data && op(t, "data-")) ||
|
|
(r.attr && om.includes(t))) &&
|
|
(n[t] = e[t]);
|
|
}),
|
|
n
|
|
);
|
|
})(j, !0),
|
|
R = 100 - (!_ || _ < 0 ? 0 : _ > 100 ? 100 : _),
|
|
N = `${r}-notice`;
|
|
return m.createElement(
|
|
"div",
|
|
oh({}, d, {
|
|
ref: t,
|
|
className: (0, rn.clsx)(N, o, { [`${N}-closable`]: u }),
|
|
style: n,
|
|
onMouseEnter: (e) => {
|
|
v(!0), d?.onMouseEnter?.(e);
|
|
},
|
|
onMouseLeave: (e) => {
|
|
v(!1), d?.onMouseLeave?.(e);
|
|
},
|
|
onClick: f,
|
|
}),
|
|
m.createElement("div", { className: `${N}-content` }, c),
|
|
u &&
|
|
m.createElement(
|
|
"button",
|
|
oh(
|
|
{
|
|
className: `${N}-close`,
|
|
onKeyDown: (e) => {
|
|
("Enter" === e.key ||
|
|
"Enter" === e.code ||
|
|
e.keyCode === ou.ENTER) &&
|
|
k();
|
|
},
|
|
"aria-label": "Close",
|
|
},
|
|
P,
|
|
{
|
|
onClick: (e) => {
|
|
e.preventDefault(), e.stopPropagation(), k();
|
|
},
|
|
},
|
|
),
|
|
j.closeIcon ?? "x",
|
|
),
|
|
w &&
|
|
m.createElement(
|
|
"progress",
|
|
{ className: `${N}-progress`, max: "100", value: R },
|
|
R + "%",
|
|
),
|
|
);
|
|
}),
|
|
ob = m.default.createContext({}),
|
|
ov = ({ children: e, classNames: t }) =>
|
|
m.default.createElement(ob.Provider, { value: { classNames: t } }, e);
|
|
function o_() {
|
|
return (o_ = Object.assign.bind()).apply(this, arguments);
|
|
}
|
|
let oy = (e) => {
|
|
let t,
|
|
{
|
|
configList: r,
|
|
placement: n,
|
|
prefixCls: o,
|
|
className: a,
|
|
style: i,
|
|
motion: l,
|
|
onAllNoticeRemoved: s,
|
|
onNoticeClose: c,
|
|
stack: u,
|
|
} = e,
|
|
{ classNames: d } = (0, m.useContext)(ob),
|
|
f = (0, m.useRef)({}),
|
|
[p, h] = (0, m.useState)(null),
|
|
[g, b] = (0, m.useState)([]),
|
|
v = r.map((e) => ({ config: e, key: String(e.key) })),
|
|
[_, { offset: y, threshold: x, gap: C }] =
|
|
((t = { offset: 8, threshold: 3, gap: 16 }),
|
|
u &&
|
|
"object" == typeof u &&
|
|
((t.offset = u.offset ?? 8),
|
|
(t.threshold = u.threshold ?? 3),
|
|
(t.gap = u.gap ?? 16)),
|
|
[!!u, t]),
|
|
E = _ && (g.length > 0 || v.length <= x),
|
|
S = "function" == typeof l ? l(n) : l;
|
|
return (
|
|
(0, m.useEffect)(() => {
|
|
_ &&
|
|
g.length > 1 &&
|
|
b((e) => e.filter((e) => v.some(({ key: t }) => e === t)));
|
|
}, [g, v, _]),
|
|
(0, m.useEffect)(() => {
|
|
_ &&
|
|
f.current[v[v.length - 1]?.key] &&
|
|
h(f.current[v[v.length - 1]?.key]);
|
|
}, [v, _]),
|
|
m.default.createElement(
|
|
r2,
|
|
o_(
|
|
{
|
|
key: n,
|
|
className: (0, rn.clsx)(o, `${o}-${n}`, d?.list, a, {
|
|
[`${o}-stack`]: !!_,
|
|
[`${o}-stack-expanded`]: E,
|
|
}),
|
|
style: i,
|
|
keys: v,
|
|
motionAppear: !0,
|
|
},
|
|
S,
|
|
{
|
|
onAllRemoved: () => {
|
|
s(n);
|
|
},
|
|
},
|
|
),
|
|
({ config: e, className: t, style: r, index: a }, i) => {
|
|
let { key: l, times: s } = e,
|
|
u = String(l),
|
|
{ className: h, style: x, classNames: S, styles: w, ...k } = e,
|
|
j = v.findIndex((e) => e.key === u),
|
|
P = {};
|
|
if (_) {
|
|
let e = v.length - 1 - (j > -1 ? j : a - 1),
|
|
t = "top" === n || "bottom" === n ? "-50%" : "0";
|
|
if (e > 0) {
|
|
P.height = E ? f.current[u]?.offsetHeight : p?.offsetHeight;
|
|
let r = 0;
|
|
for (let t = 0; t < e; t++)
|
|
r += f.current[v[v.length - 1 - t].key]?.offsetHeight + C;
|
|
let o = (E ? r : e * y) * (n.startsWith("top") ? 1 : -1),
|
|
a =
|
|
!E && p?.offsetWidth && f.current[u]?.offsetWidth
|
|
? (p?.offsetWidth - 2 * y * (e < 3 ? e : 3)) /
|
|
f.current[u]?.offsetWidth
|
|
: 1;
|
|
P.transform = `translate3d(${t}, ${o}px, 0) scaleX(${a})`;
|
|
} else P.transform = `translate3d(${t}, 0, 0)`;
|
|
}
|
|
return m.default.createElement(
|
|
"div",
|
|
{
|
|
ref: i,
|
|
className: (0, rn.clsx)(`${o}-notice-wrapper`, t, S?.wrapper),
|
|
style: { ...r, ...P, ...w?.wrapper },
|
|
onMouseEnter: () => b((e) => (e.includes(u) ? e : [...e, u])),
|
|
onMouseLeave: () => b((e) => e.filter((e) => e !== u)),
|
|
},
|
|
m.default.createElement(
|
|
og,
|
|
o_({}, k, {
|
|
ref: (e) => {
|
|
j > -1 ? (f.current[u] = e) : delete f.current[u];
|
|
},
|
|
prefixCls: o,
|
|
classNames: S,
|
|
styles: w,
|
|
className: (0, rn.clsx)(h, d?.notice),
|
|
style: x,
|
|
times: s,
|
|
key: l,
|
|
eventKey: l,
|
|
onNoticeClose: c,
|
|
hovering: _ && g.length > 0,
|
|
}),
|
|
),
|
|
);
|
|
},
|
|
)
|
|
);
|
|
},
|
|
ox = m.forwardRef((e, t) => {
|
|
let {
|
|
prefixCls: r = "rc-notification",
|
|
container: n,
|
|
motion: o,
|
|
maxCount: a,
|
|
className: i,
|
|
style: l,
|
|
onAllRemoved: s,
|
|
stack: c,
|
|
renderNotifications: u,
|
|
} = e,
|
|
[d, f] = m.useState([]),
|
|
p = (e) => {
|
|
let t = d.find((t) => t.key === e),
|
|
r = t?.closable,
|
|
{ onClose: n } = r && "object" == typeof r ? r : {};
|
|
n?.(), t?.onClose?.(), f((t) => t.filter((t) => t.key !== e));
|
|
};
|
|
m.useImperativeHandle(t, () => ({
|
|
open: (e) => {
|
|
f((t) => {
|
|
let r = [...t],
|
|
n = r.findIndex((t) => t.key === e.key),
|
|
o = { ...e };
|
|
return (
|
|
n >= 0
|
|
? ((o.times = (t[n]?.times || 0) + 1), (r[n] = o))
|
|
: ((o.times = 0), r.push(o)),
|
|
a > 0 && r.length > a && (r = r.slice(-a)),
|
|
r
|
|
);
|
|
});
|
|
},
|
|
close: (e) => {
|
|
p(e);
|
|
},
|
|
destroy: () => {
|
|
f([]);
|
|
},
|
|
}));
|
|
let [h, g] = m.useState({});
|
|
m.useEffect(() => {
|
|
let e = {};
|
|
d.forEach((t) => {
|
|
let { placement: r = "topRight" } = t;
|
|
r && ((e[r] = e[r] || []), e[r].push(t));
|
|
}),
|
|
Object.keys(h).forEach((t) => {
|
|
e[t] = e[t] || [];
|
|
}),
|
|
g(e);
|
|
}, [d]);
|
|
let b = (e) => {
|
|
g((t) => {
|
|
let r = { ...t };
|
|
return (r[e] || []).length || delete r[e], r;
|
|
});
|
|
},
|
|
v = m.useRef(!1);
|
|
if (
|
|
(m.useEffect(() => {
|
|
Object.keys(h).length > 0
|
|
? (v.current = !0)
|
|
: v.current && (s?.(), (v.current = !1));
|
|
}, [h]),
|
|
!n)
|
|
)
|
|
return null;
|
|
let _ = Object.keys(h);
|
|
return (0, tJ.createPortal)(
|
|
m.createElement(
|
|
m.Fragment,
|
|
null,
|
|
_.map((e) => {
|
|
let t = h[e],
|
|
n = m.createElement(oy, {
|
|
key: e,
|
|
configList: t,
|
|
placement: e,
|
|
prefixCls: r,
|
|
className: i?.(e),
|
|
style: l?.(e),
|
|
motion: o,
|
|
onNoticeClose: p,
|
|
onAllNoticeRemoved: b,
|
|
stack: c,
|
|
});
|
|
return u ? u(n, { prefixCls: r, key: e }) : n;
|
|
}),
|
|
),
|
|
n,
|
|
);
|
|
}),
|
|
oC = () => document.body,
|
|
oE = 0,
|
|
oS = (e, ...t) => {
|
|
let r = e || {};
|
|
return t.filter(Boolean).reduce(
|
|
(e, t) => (
|
|
Object.keys(t || {}).forEach((n) => {
|
|
let o = r[n],
|
|
a = t[n];
|
|
if (o && "object" == typeof o)
|
|
if (a && "object" == typeof a) e[n] = oS(o, e[n], a);
|
|
else {
|
|
let { _default: t } = o;
|
|
t &&
|
|
((e[n] = e[n] || {}), (e[n][t] = (0, rn.clsx)(e[n][t], a)));
|
|
}
|
|
else e[n] = (0, rn.clsx)(e[n], a);
|
|
}),
|
|
e
|
|
),
|
|
{},
|
|
);
|
|
},
|
|
ow = (e, ...t) =>
|
|
m.useMemo(() => oS.apply(void 0, [e].concat(t)), [e].concat(t)),
|
|
ok = (...e) =>
|
|
e.filter(Boolean).reduce(
|
|
(e, t = {}) => (
|
|
Object.keys(t).forEach((r) => {
|
|
e[r] = { ...e[r], ...t[r] };
|
|
}),
|
|
e
|
|
),
|
|
{},
|
|
),
|
|
oj = (...e) => m.useMemo(() => ok.apply(void 0, e), [].concat(e)),
|
|
oP = (e, t) => {
|
|
let r = { ...e };
|
|
return (
|
|
Object.keys(t).forEach((e) => {
|
|
if ("_default" !== e) {
|
|
let n = t[e],
|
|
o = r[e] || {};
|
|
r[e] = n ? oP(o, n) : o;
|
|
}
|
|
}),
|
|
r
|
|
);
|
|
},
|
|
oR = (e, t) => ("function" == typeof e ? e(t) : e),
|
|
oN = (e, t, r, n) => {
|
|
let o = e.map((e) => (e ? oR(e, r) : void 0)),
|
|
a = t.map((e) => (e ? oR(e, r) : void 0)),
|
|
i = ow.apply(void 0, [n].concat((0, x.default)(o))),
|
|
l = oj.apply(void 0, (0, x.default)(a));
|
|
return m.useMemo(() => (n ? [oP(i, n), oP(l, n)] : [i, l]), [i, l, n]);
|
|
},
|
|
o$ = (e) => `${e}-css-var`;
|
|
var oO = e.i(624977),
|
|
oT = e.i(552659),
|
|
oM = e.i(640404),
|
|
oI = e.i(54168),
|
|
oA = e.i(634885),
|
|
oL = e.i(914528),
|
|
oB = e.i(892388),
|
|
oD = e.i(504997),
|
|
oH = e.i(483926),
|
|
oz = (0, oL.default)(function e() {
|
|
(0, oA.default)(this, e);
|
|
}),
|
|
oW = "CALC_UNIT",
|
|
oF = RegExp(oW, "g");
|
|
function oU(e) {
|
|
return "number" == typeof e ? "".concat(e).concat(oW) : e;
|
|
}
|
|
var oG = (function (e) {
|
|
(0, oD.default)(r, e);
|
|
var t = (0, oH.default)(r);
|
|
function r(e, n) {
|
|
(0, oA.default)(this, r),
|
|
(o = t.call(this)),
|
|
(0, oM.default)((0, oB.default)(o), "result", ""),
|
|
(0, oM.default)((0, oB.default)(o), "unitlessCssVar", void 0),
|
|
(0, oM.default)((0, oB.default)(o), "lowPriority", void 0);
|
|
var o,
|
|
a = (0, oO.default)(e);
|
|
return (
|
|
(o.unitlessCssVar = n),
|
|
e instanceof r
|
|
? (o.result = "(".concat(e.result, ")"))
|
|
: "number" === a
|
|
? (o.result = oU(e))
|
|
: "string" === a && (o.result = e),
|
|
o
|
|
);
|
|
}
|
|
return (
|
|
(0, oL.default)(r, [
|
|
{
|
|
key: "add",
|
|
value: function (e) {
|
|
return (
|
|
e instanceof r
|
|
? (this.result = ""
|
|
.concat(this.result, " + ")
|
|
.concat(e.getResult()))
|
|
: ("number" == typeof e || "string" == typeof e) &&
|
|
(this.result = ""
|
|
.concat(this.result, " + ")
|
|
.concat(oU(e))),
|
|
(this.lowPriority = !0),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "sub",
|
|
value: function (e) {
|
|
return (
|
|
e instanceof r
|
|
? (this.result = ""
|
|
.concat(this.result, " - ")
|
|
.concat(e.getResult()))
|
|
: ("number" == typeof e || "string" == typeof e) &&
|
|
(this.result = ""
|
|
.concat(this.result, " - ")
|
|
.concat(oU(e))),
|
|
(this.lowPriority = !0),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "mul",
|
|
value: function (e) {
|
|
return (
|
|
this.lowPriority &&
|
|
(this.result = "(".concat(this.result, ")")),
|
|
e instanceof r
|
|
? (this.result = ""
|
|
.concat(this.result, " * ")
|
|
.concat(e.getResult(!0)))
|
|
: ("number" == typeof e || "string" == typeof e) &&
|
|
(this.result = "".concat(this.result, " * ").concat(e)),
|
|
(this.lowPriority = !1),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "div",
|
|
value: function (e) {
|
|
return (
|
|
this.lowPriority &&
|
|
(this.result = "(".concat(this.result, ")")),
|
|
e instanceof r
|
|
? (this.result = ""
|
|
.concat(this.result, " / ")
|
|
.concat(e.getResult(!0)))
|
|
: ("number" == typeof e || "string" == typeof e) &&
|
|
(this.result = "".concat(this.result, " / ").concat(e)),
|
|
(this.lowPriority = !1),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "getResult",
|
|
value: function (e) {
|
|
return this.lowPriority || e
|
|
? "(".concat(this.result, ")")
|
|
: this.result;
|
|
},
|
|
},
|
|
{
|
|
key: "equal",
|
|
value: function (e) {
|
|
var t = this,
|
|
r = (e || {}).unit,
|
|
n = !0;
|
|
return ("boolean" == typeof r
|
|
? (n = r)
|
|
: Array.from(this.unitlessCssVar).some(function (e) {
|
|
return t.result.includes(e);
|
|
}) && (n = !1),
|
|
(this.result = this.result.replace(oF, n ? "px" : "")),
|
|
void 0 !== this.lowPriority)
|
|
? "calc(".concat(this.result, ")")
|
|
: this.result;
|
|
},
|
|
},
|
|
]),
|
|
r
|
|
);
|
|
})(oz),
|
|
oq = (function (e) {
|
|
(0, oD.default)(r, e);
|
|
var t = (0, oH.default)(r);
|
|
function r(e) {
|
|
var n;
|
|
return (
|
|
(0, oA.default)(this, r),
|
|
(n = t.call(this)),
|
|
(0, oM.default)((0, oB.default)(n), "result", 0),
|
|
e instanceof r
|
|
? (n.result = e.result)
|
|
: "number" == typeof e && (n.result = e),
|
|
n
|
|
);
|
|
}
|
|
return (
|
|
(0, oL.default)(r, [
|
|
{
|
|
key: "add",
|
|
value: function (e) {
|
|
return (
|
|
e instanceof r
|
|
? (this.result += e.result)
|
|
: "number" == typeof e && (this.result += e),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "sub",
|
|
value: function (e) {
|
|
return (
|
|
e instanceof r
|
|
? (this.result -= e.result)
|
|
: "number" == typeof e && (this.result -= e),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "mul",
|
|
value: function (e) {
|
|
return (
|
|
e instanceof r
|
|
? (this.result *= e.result)
|
|
: "number" == typeof e && (this.result *= e),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "div",
|
|
value: function (e) {
|
|
return (
|
|
e instanceof r
|
|
? (this.result /= e.result)
|
|
: "number" == typeof e && (this.result /= e),
|
|
this
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "equal",
|
|
value: function () {
|
|
return this.result;
|
|
},
|
|
},
|
|
]),
|
|
r
|
|
);
|
|
})(oz);
|
|
let oX = function (e, t) {
|
|
var r = "css" === e ? oG : oq;
|
|
return function (e) {
|
|
return new r(e, t);
|
|
};
|
|
},
|
|
oK = function (e, t) {
|
|
return "".concat(
|
|
[
|
|
t,
|
|
e
|
|
.replace(/([A-Z]+)([A-Z][a-z]+)/g, "$1-$2")
|
|
.replace(/([a-z])([A-Z])/g, "$1-$2"),
|
|
]
|
|
.filter(Boolean)
|
|
.join("-"),
|
|
);
|
|
},
|
|
oV = function (e, t, r, n) {
|
|
var o = (0, oI.default)({}, t[e]);
|
|
null != n &&
|
|
n.deprecatedTokens &&
|
|
n.deprecatedTokens.forEach(function (e) {
|
|
var t = (0, oT.default)(e, 2),
|
|
r = t[0],
|
|
n = t[1];
|
|
((null != o && o[r]) || (null != o && o[n])) &&
|
|
(null != o[n] || (o[n] = null == o ? void 0 : o[r]));
|
|
});
|
|
var a = (0, oI.default)((0, oI.default)({}, r), o);
|
|
return (
|
|
Object.keys(a).forEach(function (e) {
|
|
a[e] === t[e] && delete a[e];
|
|
}),
|
|
a
|
|
);
|
|
};
|
|
var oY = "u" > typeof CSSINJS_STATISTIC,
|
|
oQ = !0;
|
|
function oZ() {
|
|
for (var e = arguments.length, t = Array(e), r = 0; r < e; r++)
|
|
t[r] = arguments[r];
|
|
if (!oY) return Object.assign.apply(Object, [{}].concat(t));
|
|
oQ = !1;
|
|
var n = {};
|
|
return (
|
|
t.forEach(function (e) {
|
|
"object" === (0, oO.default)(e) &&
|
|
Object.keys(e).forEach(function (t) {
|
|
Object.defineProperty(n, t, {
|
|
configurable: !0,
|
|
enumerable: !0,
|
|
get: function () {
|
|
return e[t];
|
|
},
|
|
});
|
|
});
|
|
}),
|
|
(oQ = !0),
|
|
n
|
|
);
|
|
}
|
|
var oJ = {};
|
|
function o0() {}
|
|
let o1 = function (e) {
|
|
var t,
|
|
r = e,
|
|
n = o0;
|
|
return (
|
|
oY &&
|
|
"u" > typeof Proxy &&
|
|
((t = new Set()),
|
|
(r = new Proxy(e, {
|
|
get: function (e, r) {
|
|
if (oQ) {
|
|
var n;
|
|
null == (n = t) || n.add(r);
|
|
}
|
|
return e[r];
|
|
},
|
|
})),
|
|
(n = function (e, r) {
|
|
var n;
|
|
oJ[e] = {
|
|
global: Array.from(t),
|
|
component: (0, oI.default)(
|
|
(0, oI.default)(
|
|
{},
|
|
null == (n = oJ[e]) ? void 0 : n.component,
|
|
),
|
|
r,
|
|
),
|
|
};
|
|
})),
|
|
{ token: r, keys: t, flush: n }
|
|
);
|
|
},
|
|
o2 = function (e, t, r) {
|
|
if ("function" == typeof r) {
|
|
var n;
|
|
return r(oZ(t, null != (n = t[e]) ? n : {}));
|
|
}
|
|
return null != r ? r : {};
|
|
};
|
|
var o4 = new ((function () {
|
|
function e() {
|
|
(0, oA.default)(this, e),
|
|
(0, oM.default)(this, "map", new Map()),
|
|
(0, oM.default)(this, "objectIDMap", new WeakMap()),
|
|
(0, oM.default)(this, "nextID", 0),
|
|
(0, oM.default)(this, "lastAccessBeat", new Map()),
|
|
(0, oM.default)(this, "accessBeat", 0);
|
|
}
|
|
return (
|
|
(0, oL.default)(e, [
|
|
{
|
|
key: "set",
|
|
value: function (e, t) {
|
|
this.clear();
|
|
var r = this.getCompositeKey(e);
|
|
this.map.set(r, t), this.lastAccessBeat.set(r, Date.now());
|
|
},
|
|
},
|
|
{
|
|
key: "get",
|
|
value: function (e) {
|
|
var t = this.getCompositeKey(e),
|
|
r = this.map.get(t);
|
|
return (
|
|
this.lastAccessBeat.set(t, Date.now()),
|
|
(this.accessBeat += 1),
|
|
r
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "getCompositeKey",
|
|
value: function (e) {
|
|
var t = this;
|
|
return e
|
|
.map(function (e) {
|
|
return e && "object" === (0, oO.default)(e)
|
|
? "obj_".concat(t.getObjectID(e))
|
|
: "".concat((0, oO.default)(e), "_").concat(e);
|
|
})
|
|
.join("|");
|
|
},
|
|
},
|
|
{
|
|
key: "getObjectID",
|
|
value: function (e) {
|
|
if (this.objectIDMap.has(e)) return this.objectIDMap.get(e);
|
|
var t = this.nextID;
|
|
return this.objectIDMap.set(e, t), (this.nextID += 1), t;
|
|
},
|
|
},
|
|
{
|
|
key: "clear",
|
|
value: function () {
|
|
var e = this;
|
|
if (this.accessBeat > 1e4) {
|
|
var t = Date.now();
|
|
this.lastAccessBeat.forEach(function (r, n) {
|
|
t - r > 6e5 && (e.map.delete(n), e.lastAccessBeat.delete(n));
|
|
}),
|
|
(this.accessBeat = 0);
|
|
}
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})())();
|
|
let o6 = function () {
|
|
return {};
|
|
},
|
|
{
|
|
genStyleHooks: o3,
|
|
genComponentStyleHook: o5,
|
|
genSubStyleComponent: o8,
|
|
} = (function (e) {
|
|
var t = e.useCSP,
|
|
r = void 0 === t ? o6 : t,
|
|
n = e.useToken,
|
|
o = e.usePrefix,
|
|
a = e.getResetStyles,
|
|
i = e.getCommonStyle,
|
|
l = e.getCompUnitless;
|
|
function s(t, l, s) {
|
|
var c =
|
|
arguments.length > 3 && void 0 !== arguments[3]
|
|
? arguments[3]
|
|
: {},
|
|
u = Array.isArray(t) ? t : [t, t],
|
|
d = (0, oT.default)(u, 1)[0],
|
|
f = u.join("-"),
|
|
p = e.layer || { name: "antd" };
|
|
return function (e) {
|
|
var t,
|
|
u,
|
|
h =
|
|
arguments.length > 1 && void 0 !== arguments[1]
|
|
? arguments[1]
|
|
: e,
|
|
g = n(),
|
|
b = g.theme,
|
|
v = g.realToken,
|
|
_ = g.hashId,
|
|
y = g.token,
|
|
x = g.cssVar,
|
|
C = g.zeroRuntime;
|
|
if (
|
|
(0, m.useMemo)(function () {
|
|
return C;
|
|
}, [])
|
|
)
|
|
return _;
|
|
var E = o(),
|
|
S = E.rootPrefixCls,
|
|
w = E.iconPrefixCls,
|
|
k = r(),
|
|
j =
|
|
((t = function () {
|
|
var e = new Set();
|
|
return (
|
|
Object.keys(c.unitless || {}).forEach(function (t) {
|
|
e.add(eu(t, x.prefix)), e.add(eu(t, oK(d, x.prefix)));
|
|
}),
|
|
oX("css", e)
|
|
);
|
|
}),
|
|
(u = ["css", d, null == x ? void 0 : x.prefix]),
|
|
m.default.useMemo(function () {
|
|
var e = o4.get(u);
|
|
if (e) return e;
|
|
var r = t();
|
|
return o4.set(u, r), r;
|
|
}, u)),
|
|
P = function () {
|
|
for (var e = arguments.length, t = Array(e), r = 0; r < e; r++)
|
|
t[r] = arguments[r];
|
|
return "max(".concat(
|
|
t
|
|
.map(function (e) {
|
|
return es(e);
|
|
})
|
|
.join(","),
|
|
")",
|
|
);
|
|
},
|
|
R = function () {
|
|
for (var e = arguments.length, t = Array(e), r = 0; r < e; r++)
|
|
t[r] = arguments[r];
|
|
return "min(".concat(
|
|
t
|
|
.map(function (e) {
|
|
return es(e);
|
|
})
|
|
.join(","),
|
|
")",
|
|
);
|
|
},
|
|
N = {
|
|
theme: b,
|
|
token: y,
|
|
hashId: _,
|
|
nonce: function () {
|
|
return k.nonce;
|
|
},
|
|
clientOnly: c.clientOnly,
|
|
layer: p,
|
|
order: c.order || -999,
|
|
};
|
|
return (
|
|
"function" == typeof a &&
|
|
e$(
|
|
(0, oI.default)(
|
|
(0, oI.default)({}, N),
|
|
{},
|
|
{ clientOnly: !1, path: ["Shared", S] },
|
|
),
|
|
function () {
|
|
return a(y, {
|
|
prefix: { rootPrefixCls: S, iconPrefixCls: w },
|
|
csp: k,
|
|
});
|
|
},
|
|
),
|
|
e$(
|
|
(0, oI.default)(
|
|
(0, oI.default)({}, N),
|
|
{},
|
|
{ path: [f, e, w] },
|
|
),
|
|
function () {
|
|
if (!1 === c.injectStyle) return [];
|
|
var t = o1(y),
|
|
r = t.token,
|
|
n = t.flush,
|
|
o = o2(d, v, s),
|
|
a = ".".concat(e),
|
|
u = oV(d, v, o, { deprecatedTokens: c.deprecatedTokens });
|
|
o &&
|
|
"object" === (0, oO.default)(o) &&
|
|
Object.keys(o).forEach(function (e) {
|
|
o[e] = "var(".concat(eu(e, oK(d, x.prefix)), ")");
|
|
});
|
|
var f = oZ(
|
|
r,
|
|
{
|
|
componentCls: a,
|
|
prefixCls: e,
|
|
iconCls: ".".concat(w),
|
|
antCls: ".".concat(S),
|
|
calc: j,
|
|
max: P,
|
|
min: R,
|
|
},
|
|
o,
|
|
),
|
|
m = l(f, {
|
|
hashId: _,
|
|
prefixCls: e,
|
|
rootPrefixCls: S,
|
|
iconPrefixCls: w,
|
|
});
|
|
n(d, u);
|
|
var p =
|
|
"function" == typeof i ? i(f, e, h, c.resetFont) : null;
|
|
return [!1 === c.resetStyle ? null : p, m];
|
|
},
|
|
),
|
|
_
|
|
);
|
|
};
|
|
}
|
|
return {
|
|
genStyleHooks: function (e, t, r, o) {
|
|
var a,
|
|
i,
|
|
c,
|
|
u,
|
|
d,
|
|
f,
|
|
p = Array.isArray(e) ? e[0] : e;
|
|
function h(e) {
|
|
return ""
|
|
.concat(String(p))
|
|
.concat(e.slice(0, 1).toUpperCase())
|
|
.concat(e.slice(1));
|
|
}
|
|
var g = (null == o ? void 0 : o.unitless) || {},
|
|
b = "function" == typeof l ? l(e) : {},
|
|
v = (0, oI.default)(
|
|
(0, oI.default)({}, b),
|
|
{},
|
|
(0, oM.default)({}, h("zIndexPopup"), !0),
|
|
);
|
|
Object.keys(g).forEach(function (e) {
|
|
v[h(e)] = g[e];
|
|
});
|
|
var _ = (0, oI.default)(
|
|
(0, oI.default)({}, o),
|
|
{},
|
|
{ unitless: v, prefixToken: h },
|
|
),
|
|
y = s(e, t, r, _),
|
|
x =
|
|
((a = p),
|
|
(i = r),
|
|
(u = (c = _).unitless),
|
|
(d = c.prefixToken),
|
|
(f = c.ignore),
|
|
function (e) {
|
|
var t = n(),
|
|
r = t.cssVar,
|
|
o = t.realToken;
|
|
return (
|
|
((e, t) => {
|
|
let {
|
|
key: r,
|
|
prefix: n,
|
|
unitless: o,
|
|
ignore: a,
|
|
token: i,
|
|
hashId: l,
|
|
scope: s = "",
|
|
} = e,
|
|
{
|
|
cache: { instanceId: c },
|
|
container: u,
|
|
hashPriority: d,
|
|
} = (0, m.useContext)(Q),
|
|
{ _tokenKey: f } = i,
|
|
p = [...e.path, r, s, f];
|
|
return em(
|
|
"cssVar",
|
|
p,
|
|
() => {
|
|
let [e, i] = ed(t(), r, {
|
|
prefix: n,
|
|
unitless: o,
|
|
ignore: a,
|
|
scope: s,
|
|
hashPriority: d,
|
|
hashCls: l,
|
|
}),
|
|
c = eN(p, i);
|
|
return [e, i, c, r];
|
|
},
|
|
([, , e]) => {
|
|
el && I(e, { mark: V, attachTo: u });
|
|
},
|
|
([, e, t]) => {
|
|
if (!e) return;
|
|
let n = A(e, t, {
|
|
mark: V,
|
|
prepend: "queue",
|
|
attachTo: u,
|
|
priority: -999,
|
|
});
|
|
(n[Y] = c), n.setAttribute(K, r);
|
|
},
|
|
);
|
|
})(
|
|
{
|
|
path: [a],
|
|
prefix: r.prefix,
|
|
key: r.key,
|
|
unitless: u,
|
|
ignore: f,
|
|
token: o,
|
|
scope: e,
|
|
},
|
|
function () {
|
|
var e = o2(a, o, i),
|
|
t = oV(a, o, e, {
|
|
deprecatedTokens:
|
|
null == c ? void 0 : c.deprecatedTokens,
|
|
});
|
|
return (
|
|
e &&
|
|
Object.keys(e).forEach(function (e) {
|
|
(t[d(e)] = t[e]), delete t[e];
|
|
}),
|
|
t
|
|
);
|
|
},
|
|
),
|
|
null == r ? void 0 : r.key
|
|
);
|
|
});
|
|
return function (e) {
|
|
var t =
|
|
arguments.length > 1 && void 0 !== arguments[1]
|
|
? arguments[1]
|
|
: e;
|
|
return [y(e, t), x(t)];
|
|
};
|
|
},
|
|
genSubStyleComponent: function (e, t, r) {
|
|
var n =
|
|
arguments.length > 3 && void 0 !== arguments[3]
|
|
? arguments[3]
|
|
: {},
|
|
o = s(
|
|
e,
|
|
t,
|
|
r,
|
|
(0, oI.default)({ resetStyle: !1, order: -998 }, n),
|
|
);
|
|
return function (e) {
|
|
var t = e.prefixCls,
|
|
r = e.rootCls,
|
|
n = void 0 === r ? t : r;
|
|
return o(t, n), null;
|
|
};
|
|
},
|
|
genComponentStyleHook: s,
|
|
};
|
|
})({
|
|
usePrefix: () => {
|
|
let { getPrefixCls: e, iconPrefixCls: t } = (0, m.useContext)(nx);
|
|
return { rootPrefixCls: e(), iconPrefixCls: t };
|
|
},
|
|
useToken: () => {
|
|
let [e, t, r, n, o, a] = nB();
|
|
return {
|
|
theme: e,
|
|
realToken: t,
|
|
hashId: r,
|
|
token: n,
|
|
cssVar: o,
|
|
zeroRuntime: a,
|
|
};
|
|
},
|
|
useCSP: () => {
|
|
let { csp: e } = (0, m.useContext)(nx);
|
|
return e ?? {};
|
|
},
|
|
getResetStyles: (e, t) => {
|
|
let r = {
|
|
a: {
|
|
color: e.colorLink,
|
|
textDecoration: e.linkDecoration,
|
|
backgroundColor: "transparent",
|
|
outline: "none",
|
|
cursor: "pointer",
|
|
transition: `color ${e.motionDurationSlow}`,
|
|
"-webkit-text-decoration-skip": "objects",
|
|
"&:hover": { color: e.colorLinkHover },
|
|
"&:active": { color: e.colorLinkActive },
|
|
"&:active, &:hover": {
|
|
textDecoration: e.linkHoverDecoration,
|
|
outline: 0,
|
|
},
|
|
"&:focus": { textDecoration: e.linkFocusDecoration, outline: 0 },
|
|
"&[disabled]": {
|
|
color: e.colorTextDisabled,
|
|
cursor: "not-allowed",
|
|
},
|
|
},
|
|
};
|
|
return [r, { "&": r }, nW(t?.prefix.iconPrefixCls ?? ny)];
|
|
},
|
|
getCommonStyle: (e, t, r, n) => {
|
|
let o = `[class^="${t}"], [class*=" ${t}"]`,
|
|
a = r ? `.${r}` : o,
|
|
i = {
|
|
boxSizing: "border-box",
|
|
"&::before, &::after": { boxSizing: "border-box" },
|
|
},
|
|
l = {};
|
|
return (
|
|
!1 !== n &&
|
|
(l = { fontFamily: e.fontFamily, fontSize: e.fontSize }),
|
|
{ [a]: { ...l, ...i, [o]: i } }
|
|
);
|
|
},
|
|
getCompUnitless: () => nM,
|
|
}),
|
|
o7 = o3(
|
|
"Message",
|
|
(e) =>
|
|
((e) => {
|
|
let {
|
|
componentCls: t,
|
|
iconCls: r,
|
|
boxShadow: n,
|
|
colorText: o,
|
|
colorSuccess: a,
|
|
colorError: i,
|
|
colorWarning: l,
|
|
colorInfo: s,
|
|
fontSizeLG: c,
|
|
motionEaseInOutCirc: u,
|
|
motionDurationSlow: d,
|
|
marginXS: f,
|
|
paddingXS: m,
|
|
borderRadiusLG: p,
|
|
zIndexPopup: h,
|
|
contentPadding: g,
|
|
contentBg: b,
|
|
} = e,
|
|
v = `${t}-notice`,
|
|
_ = new eO("MessageMoveIn", {
|
|
"0%": {
|
|
padding: 0,
|
|
transform: "translateY(-100%)",
|
|
opacity: 0,
|
|
},
|
|
"100%": { padding: m, transform: "translateY(0)", opacity: 1 },
|
|
}),
|
|
y = new eO("MessageMoveOut", {
|
|
"0%": { maxHeight: e.height, padding: m, opacity: 1 },
|
|
"100%": { maxHeight: 0, padding: 0, opacity: 0 },
|
|
}),
|
|
x = {
|
|
padding: m,
|
|
textAlign: "center",
|
|
[`${t}-custom-content`]: {
|
|
display: "flex",
|
|
alignItems: "center",
|
|
},
|
|
[`${t}-custom-content > ${r}`]: {
|
|
marginInlineEnd: f,
|
|
fontSize: c,
|
|
},
|
|
[`${v}-content`]: {
|
|
display: "inline-block",
|
|
padding: g,
|
|
background: b,
|
|
borderRadius: p,
|
|
boxShadow: n,
|
|
pointerEvents: "all",
|
|
},
|
|
[`${t}-success > ${r}`]: { color: a },
|
|
[`${t}-error > ${r}`]: { color: i },
|
|
[`${t}-warning > ${r}`]: { color: l },
|
|
[`${t}-info > ${r},
|
|
${t}-loading > ${r}`]: { color: s },
|
|
};
|
|
return [
|
|
{
|
|
[t]: {
|
|
...((e, t = !1) => ({
|
|
boxSizing: "border-box",
|
|
margin: 0,
|
|
padding: 0,
|
|
color: e.colorText,
|
|
fontSize: e.fontSize,
|
|
lineHeight: e.lineHeight,
|
|
listStyle: "none",
|
|
fontFamily: t ? "inherit" : e.fontFamily,
|
|
}))(e),
|
|
color: o,
|
|
position: "fixed",
|
|
top: f,
|
|
width: "100%",
|
|
pointerEvents: "none",
|
|
zIndex: h,
|
|
[`${t}-move-up`]: { animationFillMode: "forwards" },
|
|
[`
|
|
${t}-move-up-appear,
|
|
${t}-move-up-enter
|
|
`]: {
|
|
animationName: _,
|
|
animationDuration: d,
|
|
animationPlayState: "paused",
|
|
animationTimingFunction: u,
|
|
},
|
|
[`
|
|
${t}-move-up-appear${t}-move-up-appear-active,
|
|
${t}-move-up-enter${t}-move-up-enter-active
|
|
`]: { animationPlayState: "running" },
|
|
[`${t}-move-up-leave`]: {
|
|
animationName: y,
|
|
animationDuration: d,
|
|
animationPlayState: "paused",
|
|
animationTimingFunction: u,
|
|
},
|
|
[`${t}-move-up-leave${t}-move-up-leave-active`]: {
|
|
animationPlayState: "running",
|
|
},
|
|
"&-rtl": { direction: "rtl", span: { direction: "rtl" } },
|
|
},
|
|
},
|
|
{ [t]: { [`${v}-wrapper`]: { ...x } } },
|
|
{
|
|
[`${t}-notice-pure-panel`]: {
|
|
...x,
|
|
padding: 0,
|
|
textAlign: "start",
|
|
},
|
|
},
|
|
];
|
|
})(oZ(e, { height: 150 })),
|
|
(e) => ({
|
|
zIndexPopup: e.zIndexPopupBase + 1e3 + 10,
|
|
contentBg: e.colorBgElevated,
|
|
contentPadding: `${(e.controlHeightLG - e.fontSize * e.lineHeight) / 2}px ${e.paddingSM}px`,
|
|
}),
|
|
),
|
|
o9 = {
|
|
info: m.createElement(oi, null),
|
|
success: m.createElement(n8, null),
|
|
error: m.createElement(oe, null),
|
|
warning: m.createElement(on, null),
|
|
loading: m.createElement(oc, null),
|
|
},
|
|
ae = (e) => {
|
|
let {
|
|
prefixCls: t,
|
|
type: r,
|
|
icon: n,
|
|
children: o,
|
|
classNames: a,
|
|
styles: i,
|
|
} = e,
|
|
l = n_(n || (r && o9[r]), (e) => {
|
|
let t = { ...e?.style, ...i?.icon };
|
|
return { className: (0, rn.clsx)(e.className, a?.icon), style: t };
|
|
});
|
|
return m.createElement(
|
|
"div",
|
|
{ className: (0, rn.clsx)(`${t}-custom-content`, `${t}-${r}`) },
|
|
l,
|
|
m.createElement(
|
|
"span",
|
|
{ className: a?.content, style: i?.content },
|
|
o,
|
|
),
|
|
);
|
|
};
|
|
function at(e) {
|
|
let t,
|
|
r = new Promise((r) => {
|
|
t = e(() => {
|
|
r(!0);
|
|
});
|
|
}),
|
|
n = () => {
|
|
t?.();
|
|
};
|
|
return (n.then = (e, t) => r.then(e, t)), (n.promise = r), n;
|
|
}
|
|
let ar = ({ children: e, prefixCls: t }) => {
|
|
let r = o$(t),
|
|
[n, o] = o7(t, r);
|
|
return m.createElement(
|
|
ov,
|
|
{ classNames: { list: (0, rn.clsx)(n, o, r) } },
|
|
e,
|
|
);
|
|
},
|
|
an = (e, { prefixCls: t, key: r }) =>
|
|
m.createElement(ar, { prefixCls: t, key: r }, e),
|
|
ao = m.forwardRef((e, t) => {
|
|
let {
|
|
top: r,
|
|
prefixCls: n,
|
|
getContainer: o,
|
|
maxCount: a,
|
|
duration: i = 3,
|
|
rtl: l,
|
|
transitionName: s,
|
|
onAllRemoved: c,
|
|
pauseOnHover: u = !0,
|
|
} = e,
|
|
{
|
|
getPrefixCls: d,
|
|
direction: f,
|
|
getPopupContainer: p,
|
|
} = nS("message"),
|
|
{ message: h } = m.useContext(nx),
|
|
g = n || d("message"),
|
|
[b, v] = oN([e?.classNames, h?.classNames], [e?.styles, h?.styles], {
|
|
props: e,
|
|
}),
|
|
[_, y] = (function (e = {}) {
|
|
let {
|
|
getContainer: t = oC,
|
|
motion: r,
|
|
prefixCls: n,
|
|
maxCount: o,
|
|
className: a,
|
|
style: i,
|
|
onAllRemoved: l,
|
|
stack: s,
|
|
renderNotifications: c,
|
|
...u
|
|
} = e,
|
|
[d, f] = m.useState(),
|
|
p = m.useRef(),
|
|
h = m.createElement(ox, {
|
|
container: d,
|
|
ref: p,
|
|
prefixCls: n,
|
|
motion: r,
|
|
maxCount: o,
|
|
className: a,
|
|
style: i,
|
|
onAllRemoved: l,
|
|
stack: s,
|
|
renderNotifications: c,
|
|
}),
|
|
[g, b] = m.useState([]),
|
|
v = eI((e) => {
|
|
let t = (function (...e) {
|
|
let t = {};
|
|
return (
|
|
e.forEach((e) => {
|
|
e &&
|
|
Object.keys(e).forEach((r) => {
|
|
let n = e[r];
|
|
void 0 !== n && (t[r] = n);
|
|
});
|
|
}),
|
|
t
|
|
);
|
|
})(u, e);
|
|
(null === t.key || void 0 === t.key) &&
|
|
((t.key = `rc-notification-${oE}`), (oE += 1)),
|
|
b((e) => [...e, { type: "open", config: t }]);
|
|
}),
|
|
_ = m.useMemo(
|
|
() => ({
|
|
open: v,
|
|
close: (e) => {
|
|
b((t) => [...t, { type: "close", key: e }]);
|
|
},
|
|
destroy: () => {
|
|
b((e) => [...e, { type: "destroy" }]);
|
|
},
|
|
}),
|
|
[],
|
|
);
|
|
return (
|
|
m.useEffect(() => {
|
|
f(t());
|
|
}),
|
|
m.useEffect(() => {
|
|
if (p.current && g.length) {
|
|
let e, t;
|
|
g.forEach((e) => {
|
|
switch (e.type) {
|
|
case "open":
|
|
p.current.open(e.config);
|
|
break;
|
|
case "close":
|
|
p.current.close(e.key);
|
|
break;
|
|
case "destroy":
|
|
p.current.destroy();
|
|
}
|
|
}),
|
|
b(
|
|
(r) => (
|
|
(e === r && t) ||
|
|
((e = r), (t = r.filter((e) => !g.includes(e)))),
|
|
t
|
|
),
|
|
);
|
|
}
|
|
}, [g]),
|
|
[_, h]
|
|
);
|
|
})({
|
|
prefixCls: g,
|
|
style: () => ({
|
|
left: "50%",
|
|
transform: "translateX(-50%)",
|
|
top: r ?? 8,
|
|
}),
|
|
className: () => (0, rn.clsx)({ [`${g}-rtl`]: l ?? "rtl" === f }),
|
|
motion: () => ({ motionName: s ?? `${g}-move-up` }),
|
|
closable: !1,
|
|
duration: i,
|
|
getContainer: () => o?.() || p?.() || document.body,
|
|
maxCount: a,
|
|
onAllRemoved: c,
|
|
renderNotifications: an,
|
|
pauseOnHover: u,
|
|
});
|
|
return (
|
|
m.useImperativeHandle(t, () => ({
|
|
..._,
|
|
prefixCls: g,
|
|
message: h,
|
|
classNames: b,
|
|
styles: v,
|
|
})),
|
|
y
|
|
);
|
|
}),
|
|
aa = 0;
|
|
function ai(e) {
|
|
let t = m.useRef(null);
|
|
return (
|
|
e4("Message"),
|
|
[
|
|
m.useMemo(() => {
|
|
let r = (e) => {
|
|
t.current?.close(e);
|
|
},
|
|
n = (n) => {
|
|
if (!t.current) {
|
|
let e = () => {};
|
|
return (e.then = () => {}), e;
|
|
}
|
|
let {
|
|
open: o,
|
|
prefixCls: a,
|
|
message: i,
|
|
classNames: l,
|
|
styles: s,
|
|
} = t.current,
|
|
c = i?.className || {},
|
|
u = i?.style || {},
|
|
d = i?.classNames || {},
|
|
f = i?.styles || {},
|
|
p = `${a}-notice`,
|
|
{
|
|
content: h,
|
|
icon: g,
|
|
type: b,
|
|
key: v,
|
|
className: _,
|
|
style: y,
|
|
onClose: x,
|
|
classNames: C = {},
|
|
styles: E = {},
|
|
...S
|
|
} = n,
|
|
w = v;
|
|
null == w && ((aa += 1), (w = `antd-message-${aa}`));
|
|
let k = { ...e, ...n },
|
|
j = oR(d, { props: k }),
|
|
P = oR(C, { props: k }),
|
|
R = oR(f, { props: k }),
|
|
N = oR(E, { props: k }),
|
|
$ = oS(void 0, j, P, l),
|
|
O = ok(R, N, s);
|
|
return at(
|
|
(e) => (
|
|
o({
|
|
...S,
|
|
key: w,
|
|
content: m.createElement(
|
|
ae,
|
|
{
|
|
prefixCls: a,
|
|
type: b,
|
|
icon: g,
|
|
classNames: $,
|
|
styles: O,
|
|
},
|
|
h,
|
|
),
|
|
placement: "top",
|
|
className: (0, rn.clsx)(
|
|
{ [`${p}-${b}`]: b },
|
|
_,
|
|
c,
|
|
$.root,
|
|
),
|
|
style: { ...O.root, ...u, ...y },
|
|
onClose: () => {
|
|
x?.(), e();
|
|
},
|
|
}),
|
|
() => {
|
|
r(w);
|
|
}
|
|
),
|
|
);
|
|
},
|
|
o = {
|
|
open: n,
|
|
destroy: (e) => {
|
|
void 0 !== e ? r(e) : t.current?.destroy();
|
|
},
|
|
};
|
|
return (
|
|
["info", "success", "warning", "error", "loading"].forEach(
|
|
(e) => {
|
|
o[e] = (t, r, o) => {
|
|
let a, i, l;
|
|
return (
|
|
(a =
|
|
t && "object" == typeof t && "content" in t
|
|
? t
|
|
: { content: t }),
|
|
"function" == typeof r ? (l = r) : ((i = r), (l = o)),
|
|
n({ onClose: l, duration: i, ...a, type: e })
|
|
);
|
|
};
|
|
},
|
|
),
|
|
o
|
|
);
|
|
}, []),
|
|
m.createElement(ao, { key: "message-holder", ...e, ref: t }),
|
|
]
|
|
);
|
|
}
|
|
let al = null,
|
|
as = [],
|
|
ac = {};
|
|
function au() {
|
|
let { getContainer: e, duration: t, rtl: r, maxCount: n, top: o } = ac,
|
|
a = e?.() || document.body;
|
|
return {
|
|
getContainer: () => a,
|
|
duration: t,
|
|
rtl: r,
|
|
maxCount: n,
|
|
top: o,
|
|
};
|
|
}
|
|
let ad = m.default.forwardRef((e, t) => {
|
|
let { messageConfig: r, sync: n } = e,
|
|
{ getPrefixCls: o } = (0, m.useContext)(nx),
|
|
a = ac.prefixCls || o("message"),
|
|
i = (0, m.useContext)(S),
|
|
[l, s] = ai({ ...r, prefixCls: a, ...i.message });
|
|
return (
|
|
m.default.useImperativeHandle(t, () => {
|
|
let e = { ...l };
|
|
return (
|
|
Object.keys(e).forEach((t) => {
|
|
e[t] = (...e) => (n(), l[t].apply(l, e));
|
|
}),
|
|
{ instance: e, sync: n }
|
|
);
|
|
}),
|
|
s
|
|
);
|
|
}),
|
|
af = m.default.forwardRef((e, t) => {
|
|
let [r, n] = m.default.useState(au),
|
|
o = () => {
|
|
n(au);
|
|
};
|
|
m.default.useEffect(o, []);
|
|
let a = nX(),
|
|
i = a.getRootPrefixCls(),
|
|
l = a.getIconPrefixCls(),
|
|
s = a.getTheme(),
|
|
c = m.default.createElement(ad, {
|
|
ref: t,
|
|
sync: o,
|
|
messageConfig: r,
|
|
});
|
|
return m.default.createElement(
|
|
nV,
|
|
{ prefixCls: i, iconPrefixCls: l, theme: s },
|
|
a.holderRender ? a.holderRender(c) : c,
|
|
);
|
|
}),
|
|
am = () => {
|
|
if (!al) {
|
|
let e = document.createDocumentFragment(),
|
|
t = { fragment: e };
|
|
(al = t),
|
|
(() => {
|
|
var r;
|
|
let n;
|
|
(r = m.default.createElement(af, {
|
|
ref: (e) => {
|
|
let { instance: r, sync: n } = e || {};
|
|
Promise.resolve().then(() => {
|
|
!t.instance && r && ((t.instance = r), (t.sync = n), am());
|
|
});
|
|
},
|
|
})),
|
|
(n = e[E] || (0, C.createRoot)(e)).render(r),
|
|
(e[E] = n);
|
|
})();
|
|
return;
|
|
}
|
|
al.instance &&
|
|
(as.forEach((e) => {
|
|
let { type: t, skipped: r } = e;
|
|
if (!r)
|
|
switch (t) {
|
|
case "open":
|
|
{
|
|
let t = al.instance.open({ ...ac, ...e.config });
|
|
t?.then(e.resolve), e.setCloseFn(t);
|
|
}
|
|
break;
|
|
case "destroy":
|
|
al?.instance.destroy(e.key);
|
|
break;
|
|
default: {
|
|
var n;
|
|
let r = (n = al.instance)[t].apply(n, (0, x.default)(e.args));
|
|
r?.then(e.resolve), e.setCloseFn(r);
|
|
}
|
|
}
|
|
}),
|
|
(as = []));
|
|
},
|
|
ap = {
|
|
open: function (e) {
|
|
let t = at((t) => {
|
|
let r,
|
|
n = {
|
|
type: "open",
|
|
config: e,
|
|
resolve: t,
|
|
setCloseFn: (e) => {
|
|
r = e;
|
|
},
|
|
};
|
|
return (
|
|
as.push(n),
|
|
() => {
|
|
r
|
|
? (() => {
|
|
r();
|
|
})()
|
|
: (n.skipped = !0);
|
|
}
|
|
);
|
|
});
|
|
return am(), t;
|
|
},
|
|
destroy: (e) => {
|
|
as.push({ type: "destroy", key: e }), am();
|
|
},
|
|
config: function (e) {
|
|
(ac = { ...ac, ...e }),
|
|
(() => {
|
|
al?.sync?.();
|
|
})();
|
|
},
|
|
useMessage: function (e) {
|
|
return ai(e);
|
|
},
|
|
_InternalPanelDoNotUseOrYouWillBeFired: (e) => {
|
|
let {
|
|
prefixCls: t,
|
|
className: r,
|
|
style: n,
|
|
type: o,
|
|
icon: a,
|
|
content: i,
|
|
classNames: l,
|
|
styles: s,
|
|
...c
|
|
} = e,
|
|
{
|
|
getPrefixCls: u,
|
|
className: d,
|
|
style: f,
|
|
classNames: p,
|
|
styles: h,
|
|
} = nS("message"),
|
|
g = t || u("message"),
|
|
b = o$(g),
|
|
[v, _] = o7(g, b),
|
|
[y, x] = oN([p, l], [h, s], { props: e });
|
|
return m.createElement(og, {
|
|
...c,
|
|
prefixCls: g,
|
|
className: (0, rn.clsx)(
|
|
d,
|
|
y.root,
|
|
r,
|
|
v,
|
|
`${g}-notice-pure-panel`,
|
|
_,
|
|
b,
|
|
),
|
|
style: { ...x.root, ...f, ...n },
|
|
eventKey: "pure",
|
|
duration: null,
|
|
content: m.createElement(
|
|
ae,
|
|
{ prefixCls: g, type: o, icon: a, classNames: y, styles: x },
|
|
i,
|
|
),
|
|
});
|
|
},
|
|
};
|
|
["success", "info", "warning", "error", "loading"].forEach((e) => {
|
|
ap[e] = (...t) => {
|
|
let r;
|
|
return (
|
|
nX(),
|
|
(r = at((r) => {
|
|
let n,
|
|
o = {
|
|
type: e,
|
|
args: t,
|
|
resolve: r,
|
|
setCloseFn: (e) => {
|
|
n = e;
|
|
},
|
|
};
|
|
return (
|
|
as.push(o),
|
|
() => {
|
|
n
|
|
? (() => {
|
|
n();
|
|
})()
|
|
: (o.skipped = !0);
|
|
}
|
|
);
|
|
})),
|
|
am(),
|
|
r
|
|
);
|
|
};
|
|
});
|
|
e.s(
|
|
[
|
|
"useCombineOrderHooks",
|
|
0,
|
|
(e) => {
|
|
let {
|
|
orderVipSku: t,
|
|
inviteCode: r,
|
|
inviterAvatar: n,
|
|
inviterNickname: o,
|
|
} = e,
|
|
a = (0, b.useReportLog)(),
|
|
i = (0, v.commercialStore)((e) => e.currentPurchaseSku),
|
|
l = (0, v.commercialStore)((e) => e.setCurrentPurchaseSku),
|
|
{ isLogin: s } = (0, g.useLoginHook)(),
|
|
{ vipInfo: c } = (0, _.useUserVipInfo)();
|
|
return {
|
|
handleOpenQRCodeModal: (e, r) => {
|
|
s &&
|
|
(a({
|
|
t: 2,
|
|
e: "training.billing.vip.click",
|
|
page: 9,
|
|
var: {
|
|
train_vip_level: c?.effective
|
|
? c?.accountLevel
|
|
: c?.tradeId
|
|
? 4
|
|
: 5,
|
|
train_billing_referer: 1,
|
|
train_billing_vip_level: e.packageLevel,
|
|
train_billing_price: (e?.price || 0) / 100,
|
|
},
|
|
}),
|
|
l(e),
|
|
"TEAM" === e.packageType
|
|
? "立即续购" === r
|
|
? (0, p.showRenewalTeamVip)()
|
|
: "开通团队会员" === r
|
|
? (0, p.showInitPurchaseTeamVip)()
|
|
: "升级购买" === r && (0, p.showUpgradeTeamVip)()
|
|
: t?.(e),
|
|
a({
|
|
t: 1,
|
|
e: "vip.center.vip.button.show.click",
|
|
page: 12,
|
|
var: {},
|
|
}));
|
|
},
|
|
currentPurchaseSku: i,
|
|
};
|
|
},
|
|
"usePurchaseGoodsHooks",
|
|
0,
|
|
(e) => {
|
|
let { onPaySuccess: t, onExpired: r } = e,
|
|
[n, o] = (0, m.useState)(),
|
|
[a, i] = (0, m.useState)(!1),
|
|
l = (0, m.useCallback)(async (e, t, r) => {
|
|
if (e?.id)
|
|
try {
|
|
i(!0);
|
|
let n = await (0, y.getMemberPurchaseInfo)({
|
|
memPkgId: e?.id,
|
|
packageShopType: e.packageShopType,
|
|
referralCode: t,
|
|
activityUuid: r,
|
|
var: {
|
|
pageUrl: location.href,
|
|
referer: window?.__NEXT_DATA__?.props?.referer,
|
|
},
|
|
isApp: (0, h.isNative)(),
|
|
isiOS: (0, h.isIOS)(),
|
|
}),
|
|
a = n.data;
|
|
return (
|
|
a ? o(a) : (o(void 0), ap.warning(`下单失败，${n.msg}`)), a
|
|
);
|
|
} catch (e) {
|
|
ap.warning(`下单失败，${e?.msg || "请稍后重试"}`), o(void 0);
|
|
} finally {
|
|
i(!1);
|
|
}
|
|
else ap.warning("商品缺少参数");
|
|
}, []),
|
|
s = (0, m.useCallback)(async () => {
|
|
try {
|
|
if (n) {
|
|
let e = await (0, y.payResultInfo)(n.tradeId),
|
|
r = e?.data;
|
|
(2 === r.payStatus || 6 === r.payStatus) && t();
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}, [n, t]);
|
|
return (
|
|
(0, m.useEffect)(() => {
|
|
if (n) {
|
|
let e = setInterval(s, 5e3),
|
|
t = setTimeout(
|
|
() => {
|
|
console.info(`支付信息已过期，已停止轮询`, n),
|
|
r(),
|
|
clearInterval(e);
|
|
},
|
|
1e3 * (n.expireSeconds || 300),
|
|
);
|
|
return () => {
|
|
console.info(`定时任务已清空`),
|
|
clearInterval(e),
|
|
clearTimeout(t);
|
|
};
|
|
}
|
|
}, [n, r]),
|
|
{
|
|
handleOpenQRCodeModal: l,
|
|
clearPurchaseMemberDetail: (0, m.useCallback)(
|
|
() => o(void 0),
|
|
[],
|
|
),
|
|
purchaseMemberDetail: n,
|
|
isOrdering: a,
|
|
}
|
|
);
|
|
},
|
|
],
|
|
897151,
|
|
);
|
|
};
|
|
|
|
export default moduleFactory;
|