10167 lines
339 KiB
JavaScript
10167 lines
339 KiB
JavaScript
/*! For license information please see main.608a23ae.js.LICENSE.txt */
|
|
(() => {
|
|
'use strict';
|
|
var e = {
|
|
463: (e, t, n) => {
|
|
var r = n(791),
|
|
l = n(296);
|
|
function a(e) {
|
|
for (
|
|
var t =
|
|
'https://reactjs.org/docs/error-decoder.html?invariant=' + e,
|
|
n = 1;
|
|
n < arguments.length;
|
|
n++
|
|
)
|
|
t += '&args[]=' + encodeURIComponent(arguments[n]);
|
|
return (
|
|
'Minified React error #' +
|
|
e +
|
|
'; visit ' +
|
|
t +
|
|
' for the full message or use the non-minified dev environment for full errors and additional helpful warnings.'
|
|
);
|
|
}
|
|
var o = new Set(),
|
|
i = {};
|
|
function u(e, t) {
|
|
(s(e, t), s(e + 'Capture', t));
|
|
}
|
|
function s(e, t) {
|
|
for (i[e] = t, e = 0; e < t.length; e++) o.add(t[e]);
|
|
}
|
|
var c = !(
|
|
'undefined' === typeof window ||
|
|
'undefined' === typeof window.document ||
|
|
'undefined' === typeof window.document.createElement
|
|
),
|
|
f = Object.prototype.hasOwnProperty,
|
|
d =
|
|
/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,
|
|
p = {},
|
|
h = {};
|
|
function m(e, t, n, r, l, a, o) {
|
|
((this.acceptsBooleans = 2 === t || 3 === t || 4 === t),
|
|
(this.attributeName = r),
|
|
(this.attributeNamespace = l),
|
|
(this.mustUseProperty = n),
|
|
(this.propertyName = e),
|
|
(this.type = t),
|
|
(this.sanitizeURL = a),
|
|
(this.removeEmptyString = o));
|
|
}
|
|
var v = {};
|
|
('children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style'
|
|
.split(' ')
|
|
.forEach(function (e) {
|
|
v[e] = new m(e, 0, !1, e, null, !1, !1);
|
|
}),
|
|
[
|
|
['acceptCharset', 'accept-charset'],
|
|
['className', 'class'],
|
|
['htmlFor', 'for'],
|
|
['httpEquiv', 'http-equiv'],
|
|
].forEach(function (e) {
|
|
var t = e[0];
|
|
v[t] = new m(t, 1, !1, e[1], null, !1, !1);
|
|
}),
|
|
['contentEditable', 'draggable', 'spellCheck', 'value'].forEach(
|
|
function (e) {
|
|
v[e] = new m(e, 2, !1, e.toLowerCase(), null, !1, !1);
|
|
}
|
|
),
|
|
[
|
|
'autoReverse',
|
|
'externalResourcesRequired',
|
|
'focusable',
|
|
'preserveAlpha',
|
|
].forEach(function (e) {
|
|
v[e] = new m(e, 2, !1, e, null, !1, !1);
|
|
}),
|
|
'allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope'
|
|
.split(' ')
|
|
.forEach(function (e) {
|
|
v[e] = new m(e, 3, !1, e.toLowerCase(), null, !1, !1);
|
|
}),
|
|
['checked', 'multiple', 'muted', 'selected'].forEach(function (e) {
|
|
v[e] = new m(e, 3, !0, e, null, !1, !1);
|
|
}),
|
|
['capture', 'download'].forEach(function (e) {
|
|
v[e] = new m(e, 4, !1, e, null, !1, !1);
|
|
}),
|
|
['cols', 'rows', 'size', 'span'].forEach(function (e) {
|
|
v[e] = new m(e, 6, !1, e, null, !1, !1);
|
|
}),
|
|
['rowSpan', 'start'].forEach(function (e) {
|
|
v[e] = new m(e, 5, !1, e.toLowerCase(), null, !1, !1);
|
|
}));
|
|
var g = /[\-:]([a-z])/g;
|
|
function y(e) {
|
|
return e[1].toUpperCase();
|
|
}
|
|
function b(e, t, n, r) {
|
|
var l = v.hasOwnProperty(t) ? v[t] : null;
|
|
(null !== l
|
|
? 0 !== l.type
|
|
: r ||
|
|
!(2 < t.length) ||
|
|
('o' !== t[0] && 'O' !== t[0]) ||
|
|
('n' !== t[1] && 'N' !== t[1])) &&
|
|
((function (e, t, n, r) {
|
|
if (
|
|
null === t ||
|
|
'undefined' === typeof t ||
|
|
(function (e, t, n, r) {
|
|
if (null !== n && 0 === n.type) return !1;
|
|
switch (typeof t) {
|
|
case 'function':
|
|
case 'symbol':
|
|
return !0;
|
|
case 'boolean':
|
|
return (
|
|
!r &&
|
|
(null !== n
|
|
? !n.acceptsBooleans
|
|
: 'data-' !== (e = e.toLowerCase().slice(0, 5)) &&
|
|
'aria-' !== e)
|
|
);
|
|
default:
|
|
return !1;
|
|
}
|
|
})(e, t, n, r)
|
|
)
|
|
return !0;
|
|
if (r) return !1;
|
|
if (null !== n)
|
|
switch (n.type) {
|
|
case 3:
|
|
return !t;
|
|
case 4:
|
|
return !1 === t;
|
|
case 5:
|
|
return isNaN(t);
|
|
case 6:
|
|
return isNaN(t) || 1 > t;
|
|
}
|
|
return !1;
|
|
})(t, n, l, r) && (n = null),
|
|
r || null === l
|
|
? (function (e) {
|
|
return (
|
|
!!f.call(h, e) ||
|
|
(!f.call(p, e) &&
|
|
(d.test(e) ? (h[e] = !0) : ((p[e] = !0), !1)))
|
|
);
|
|
})(t) &&
|
|
(null === n ? e.removeAttribute(t) : e.setAttribute(t, '' + n))
|
|
: l.mustUseProperty
|
|
? (e[l.propertyName] = null === n ? 3 !== l.type && '' : n)
|
|
: ((t = l.attributeName),
|
|
(r = l.attributeNamespace),
|
|
null === n
|
|
? e.removeAttribute(t)
|
|
: ((n =
|
|
3 === (l = l.type) || (4 === l && !0 === n)
|
|
? ''
|
|
: '' + n),
|
|
r ? e.setAttributeNS(r, t, n) : e.setAttribute(t, n))));
|
|
}
|
|
('accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height'
|
|
.split(' ')
|
|
.forEach(function (e) {
|
|
var t = e.replace(g, y);
|
|
v[t] = new m(t, 1, !1, e, null, !1, !1);
|
|
}),
|
|
'xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type'
|
|
.split(' ')
|
|
.forEach(function (e) {
|
|
var t = e.replace(g, y);
|
|
v[t] = new m(t, 1, !1, e, 'http://www.w3.org/1999/xlink', !1, !1);
|
|
}),
|
|
['xml:base', 'xml:lang', 'xml:space'].forEach(function (e) {
|
|
var t = e.replace(g, y);
|
|
v[t] = new m(
|
|
t,
|
|
1,
|
|
!1,
|
|
e,
|
|
'http://www.w3.org/XML/1998/namespace',
|
|
!1,
|
|
!1
|
|
);
|
|
}),
|
|
['tabIndex', 'crossOrigin'].forEach(function (e) {
|
|
v[e] = new m(e, 1, !1, e.toLowerCase(), null, !1, !1);
|
|
}),
|
|
(v.xlinkHref = new m(
|
|
'xlinkHref',
|
|
1,
|
|
!1,
|
|
'xlink:href',
|
|
'http://www.w3.org/1999/xlink',
|
|
!0,
|
|
!1
|
|
)),
|
|
['src', 'href', 'action', 'formAction'].forEach(function (e) {
|
|
v[e] = new m(e, 1, !1, e.toLowerCase(), null, !0, !0);
|
|
}));
|
|
var k = r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
|
|
w = Symbol.for('react.element'),
|
|
S = Symbol.for('react.portal'),
|
|
x = Symbol.for('react.fragment'),
|
|
E = Symbol.for('react.strict_mode'),
|
|
C = Symbol.for('react.profiler'),
|
|
_ = Symbol.for('react.provider'),
|
|
P = Symbol.for('react.context'),
|
|
N = Symbol.for('react.forward_ref'),
|
|
z = Symbol.for('react.suspense'),
|
|
T = Symbol.for('react.suspense_list'),
|
|
M = Symbol.for('react.memo'),
|
|
L = Symbol.for('react.lazy');
|
|
(Symbol.for('react.scope'), Symbol.for('react.debug_trace_mode'));
|
|
var D = Symbol.for('react.offscreen');
|
|
(Symbol.for('react.legacy_hidden'),
|
|
Symbol.for('react.cache'),
|
|
Symbol.for('react.tracing_marker'));
|
|
var R = Symbol.iterator;
|
|
function O(e) {
|
|
return null === e || 'object' !== typeof e
|
|
? null
|
|
: 'function' === typeof (e = (R && e[R]) || e['@@iterator'])
|
|
? e
|
|
: null;
|
|
}
|
|
var F,
|
|
I = Object.assign;
|
|
function U(e) {
|
|
if (void 0 === F)
|
|
try {
|
|
throw Error();
|
|
} catch (n) {
|
|
var t = n.stack.trim().match(/\n( *(at )?)/);
|
|
F = (t && t[1]) || '';
|
|
}
|
|
return '\n' + F + e;
|
|
}
|
|
var j = !1;
|
|
function A(e, t) {
|
|
if (!e || j) return '';
|
|
j = !0;
|
|
var n = Error.prepareStackTrace;
|
|
Error.prepareStackTrace = void 0;
|
|
try {
|
|
if (t)
|
|
if (
|
|
((t = function () {
|
|
throw Error();
|
|
}),
|
|
Object.defineProperty(t.prototype, 'props', {
|
|
set: function () {
|
|
throw Error();
|
|
},
|
|
}),
|
|
'object' === typeof Reflect && Reflect.construct)
|
|
) {
|
|
try {
|
|
Reflect.construct(t, []);
|
|
} catch (s) {
|
|
var r = s;
|
|
}
|
|
Reflect.construct(e, [], t);
|
|
} else {
|
|
try {
|
|
t.call();
|
|
} catch (s) {
|
|
r = s;
|
|
}
|
|
e.call(t.prototype);
|
|
}
|
|
else {
|
|
try {
|
|
throw Error();
|
|
} catch (s) {
|
|
r = s;
|
|
}
|
|
e();
|
|
}
|
|
} catch (s) {
|
|
if (s && r && 'string' === typeof s.stack) {
|
|
for (
|
|
var l = s.stack.split('\n'),
|
|
a = r.stack.split('\n'),
|
|
o = l.length - 1,
|
|
i = a.length - 1;
|
|
1 <= o && 0 <= i && l[o] !== a[i];
|
|
)
|
|
i--;
|
|
for (; 1 <= o && 0 <= i; o--, i--)
|
|
if (l[o] !== a[i]) {
|
|
if (1 !== o || 1 !== i)
|
|
do {
|
|
if ((o--, 0 > --i || l[o] !== a[i])) {
|
|
var u = '\n' + l[o].replace(' at new ', ' at ');
|
|
return (
|
|
e.displayName &&
|
|
u.includes('<anonymous>') &&
|
|
(u = u.replace('<anonymous>', e.displayName)),
|
|
u
|
|
);
|
|
}
|
|
} while (1 <= o && 0 <= i);
|
|
break;
|
|
}
|
|
}
|
|
} finally {
|
|
((j = !1), (Error.prepareStackTrace = n));
|
|
}
|
|
return (e = e ? e.displayName || e.name : '') ? U(e) : '';
|
|
}
|
|
function B(e) {
|
|
switch (e.tag) {
|
|
case 5:
|
|
return U(e.type);
|
|
case 16:
|
|
return U('Lazy');
|
|
case 13:
|
|
return U('Suspense');
|
|
case 19:
|
|
return U('SuspenseList');
|
|
case 0:
|
|
case 2:
|
|
case 15:
|
|
return (e = A(e.type, !1));
|
|
case 11:
|
|
return (e = A(e.type.render, !1));
|
|
case 1:
|
|
return (e = A(e.type, !0));
|
|
default:
|
|
return '';
|
|
}
|
|
}
|
|
function V(e) {
|
|
if (null == e) return null;
|
|
if ('function' === typeof e) return e.displayName || e.name || null;
|
|
if ('string' === typeof e) return e;
|
|
switch (e) {
|
|
case x:
|
|
return 'Fragment';
|
|
case S:
|
|
return 'Portal';
|
|
case C:
|
|
return 'Profiler';
|
|
case E:
|
|
return 'StrictMode';
|
|
case z:
|
|
return 'Suspense';
|
|
case T:
|
|
return 'SuspenseList';
|
|
}
|
|
if ('object' === typeof e)
|
|
switch (e.$$typeof) {
|
|
case P:
|
|
return (e.displayName || 'Context') + '.Consumer';
|
|
case _:
|
|
return (e._context.displayName || 'Context') + '.Provider';
|
|
case N:
|
|
var t = e.render;
|
|
return (
|
|
(e = e.displayName) ||
|
|
(e =
|
|
'' !== (e = t.displayName || t.name || '')
|
|
? 'ForwardRef(' + e + ')'
|
|
: 'ForwardRef'),
|
|
e
|
|
);
|
|
case M:
|
|
return null !== (t = e.displayName || null)
|
|
? t
|
|
: V(e.type) || 'Memo';
|
|
case L:
|
|
((t = e._payload), (e = e._init));
|
|
try {
|
|
return V(e(t));
|
|
} catch (n) {}
|
|
}
|
|
return null;
|
|
}
|
|
function $(e) {
|
|
var t = e.type;
|
|
switch (e.tag) {
|
|
case 24:
|
|
return 'Cache';
|
|
case 9:
|
|
return (t.displayName || 'Context') + '.Consumer';
|
|
case 10:
|
|
return (t._context.displayName || 'Context') + '.Provider';
|
|
case 18:
|
|
return 'DehydratedFragment';
|
|
case 11:
|
|
return (
|
|
(e = (e = t.render).displayName || e.name || ''),
|
|
t.displayName ||
|
|
('' !== e ? 'ForwardRef(' + e + ')' : 'ForwardRef')
|
|
);
|
|
case 7:
|
|
return 'Fragment';
|
|
case 5:
|
|
return t;
|
|
case 4:
|
|
return 'Portal';
|
|
case 3:
|
|
return 'Root';
|
|
case 6:
|
|
return 'Text';
|
|
case 16:
|
|
return V(t);
|
|
case 8:
|
|
return t === E ? 'StrictMode' : 'Mode';
|
|
case 22:
|
|
return 'Offscreen';
|
|
case 12:
|
|
return 'Profiler';
|
|
case 21:
|
|
return 'Scope';
|
|
case 13:
|
|
return 'Suspense';
|
|
case 19:
|
|
return 'SuspenseList';
|
|
case 25:
|
|
return 'TracingMarker';
|
|
case 1:
|
|
case 0:
|
|
case 17:
|
|
case 2:
|
|
case 14:
|
|
case 15:
|
|
if ('function' === typeof t)
|
|
return t.displayName || t.name || null;
|
|
if ('string' === typeof t) return t;
|
|
}
|
|
return null;
|
|
}
|
|
function H(e) {
|
|
switch (typeof e) {
|
|
case 'boolean':
|
|
case 'number':
|
|
case 'string':
|
|
case 'undefined':
|
|
case 'object':
|
|
return e;
|
|
default:
|
|
return '';
|
|
}
|
|
}
|
|
function W(e) {
|
|
var t = e.type;
|
|
return (
|
|
(e = e.nodeName) &&
|
|
'input' === e.toLowerCase() &&
|
|
('checkbox' === t || 'radio' === t)
|
|
);
|
|
}
|
|
function K(e) {
|
|
e._valueTracker ||
|
|
(e._valueTracker = (function (e) {
|
|
var t = W(e) ? 'checked' : 'value',
|
|
n = Object.getOwnPropertyDescriptor(e.constructor.prototype, t),
|
|
r = '' + e[t];
|
|
if (
|
|
!e.hasOwnProperty(t) &&
|
|
'undefined' !== typeof n &&
|
|
'function' === typeof n.get &&
|
|
'function' === typeof n.set
|
|
) {
|
|
var l = n.get,
|
|
a = n.set;
|
|
return (
|
|
Object.defineProperty(e, t, {
|
|
configurable: !0,
|
|
get: function () {
|
|
return l.call(this);
|
|
},
|
|
set: function (e) {
|
|
((r = '' + e), a.call(this, e));
|
|
},
|
|
}),
|
|
Object.defineProperty(e, t, { enumerable: n.enumerable }),
|
|
{
|
|
getValue: function () {
|
|
return r;
|
|
},
|
|
setValue: function (e) {
|
|
r = '' + e;
|
|
},
|
|
stopTracking: function () {
|
|
((e._valueTracker = null), delete e[t]);
|
|
},
|
|
}
|
|
);
|
|
}
|
|
})(e));
|
|
}
|
|
function Q(e) {
|
|
if (!e) return !1;
|
|
var t = e._valueTracker;
|
|
if (!t) return !0;
|
|
var n = t.getValue(),
|
|
r = '';
|
|
return (
|
|
e && (r = W(e) ? (e.checked ? 'true' : 'false') : e.value),
|
|
(e = r) !== n && (t.setValue(e), !0)
|
|
);
|
|
}
|
|
function q(e) {
|
|
if (
|
|
'undefined' ===
|
|
typeof (e =
|
|
e || ('undefined' !== typeof document ? document : void 0))
|
|
)
|
|
return null;
|
|
try {
|
|
return e.activeElement || e.body;
|
|
} catch (t) {
|
|
return e.body;
|
|
}
|
|
}
|
|
function Y(e, t) {
|
|
var n = t.checked;
|
|
return I({}, t, {
|
|
defaultChecked: void 0,
|
|
defaultValue: void 0,
|
|
value: void 0,
|
|
checked: null != n ? n : e._wrapperState.initialChecked,
|
|
});
|
|
}
|
|
function X(e, t) {
|
|
var n = null == t.defaultValue ? '' : t.defaultValue,
|
|
r = null != t.checked ? t.checked : t.defaultChecked;
|
|
((n = H(null != t.value ? t.value : n)),
|
|
(e._wrapperState = {
|
|
initialChecked: r,
|
|
initialValue: n,
|
|
controlled:
|
|
'checkbox' === t.type || 'radio' === t.type
|
|
? null != t.checked
|
|
: null != t.value,
|
|
}));
|
|
}
|
|
function G(e, t) {
|
|
null != (t = t.checked) && b(e, 'checked', t, !1);
|
|
}
|
|
function Z(e, t) {
|
|
G(e, t);
|
|
var n = H(t.value),
|
|
r = t.type;
|
|
if (null != n)
|
|
'number' === r
|
|
? ((0 === n && '' === e.value) || e.value != n) &&
|
|
(e.value = '' + n)
|
|
: e.value !== '' + n && (e.value = '' + n);
|
|
else if ('submit' === r || 'reset' === r)
|
|
return void e.removeAttribute('value');
|
|
(t.hasOwnProperty('value')
|
|
? ee(e, t.type, n)
|
|
: t.hasOwnProperty('defaultValue') &&
|
|
ee(e, t.type, H(t.defaultValue)),
|
|
null == t.checked &&
|
|
null != t.defaultChecked &&
|
|
(e.defaultChecked = !!t.defaultChecked));
|
|
}
|
|
function J(e, t, n) {
|
|
if (t.hasOwnProperty('value') || t.hasOwnProperty('defaultValue')) {
|
|
var r = t.type;
|
|
if (
|
|
!(
|
|
('submit' !== r && 'reset' !== r) ||
|
|
(void 0 !== t.value && null !== t.value)
|
|
)
|
|
)
|
|
return;
|
|
((t = '' + e._wrapperState.initialValue),
|
|
n || t === e.value || (e.value = t),
|
|
(e.defaultValue = t));
|
|
}
|
|
('' !== (n = e.name) && (e.name = ''),
|
|
(e.defaultChecked = !!e._wrapperState.initialChecked),
|
|
'' !== n && (e.name = n));
|
|
}
|
|
function ee(e, t, n) {
|
|
('number' === t && q(e.ownerDocument) === e) ||
|
|
(null == n
|
|
? (e.defaultValue = '' + e._wrapperState.initialValue)
|
|
: e.defaultValue !== '' + n && (e.defaultValue = '' + n));
|
|
}
|
|
var te = Array.isArray;
|
|
function ne(e, t, n, r) {
|
|
if (((e = e.options), t)) {
|
|
t = {};
|
|
for (var l = 0; l < n.length; l++) t['$' + n[l]] = !0;
|
|
for (n = 0; n < e.length; n++)
|
|
((l = t.hasOwnProperty('$' + e[n].value)),
|
|
e[n].selected !== l && (e[n].selected = l),
|
|
l && r && (e[n].defaultSelected = !0));
|
|
} else {
|
|
for (n = '' + H(n), t = null, l = 0; l < e.length; l++) {
|
|
if (e[l].value === n)
|
|
return (
|
|
(e[l].selected = !0),
|
|
void (r && (e[l].defaultSelected = !0))
|
|
);
|
|
null !== t || e[l].disabled || (t = e[l]);
|
|
}
|
|
null !== t && (t.selected = !0);
|
|
}
|
|
}
|
|
function re(e, t) {
|
|
if (null != t.dangerouslySetInnerHTML) throw Error(a(91));
|
|
return I({}, t, {
|
|
value: void 0,
|
|
defaultValue: void 0,
|
|
children: '' + e._wrapperState.initialValue,
|
|
});
|
|
}
|
|
function le(e, t) {
|
|
var n = t.value;
|
|
if (null == n) {
|
|
if (((n = t.children), (t = t.defaultValue), null != n)) {
|
|
if (null != t) throw Error(a(92));
|
|
if (te(n)) {
|
|
if (1 < n.length) throw Error(a(93));
|
|
n = n[0];
|
|
}
|
|
t = n;
|
|
}
|
|
(null == t && (t = ''), (n = t));
|
|
}
|
|
e._wrapperState = { initialValue: H(n) };
|
|
}
|
|
function ae(e, t) {
|
|
var n = H(t.value),
|
|
r = H(t.defaultValue);
|
|
(null != n &&
|
|
((n = '' + n) !== e.value && (e.value = n),
|
|
null == t.defaultValue &&
|
|
e.defaultValue !== n &&
|
|
(e.defaultValue = n)),
|
|
null != r && (e.defaultValue = '' + r));
|
|
}
|
|
function oe(e) {
|
|
var t = e.textContent;
|
|
t === e._wrapperState.initialValue &&
|
|
'' !== t &&
|
|
null !== t &&
|
|
(e.value = t);
|
|
}
|
|
function ie(e) {
|
|
switch (e) {
|
|
case 'svg':
|
|
return 'http://www.w3.org/2000/svg';
|
|
case 'math':
|
|
return 'http://www.w3.org/1998/Math/MathML';
|
|
default:
|
|
return 'http://www.w3.org/1999/xhtml';
|
|
}
|
|
}
|
|
function ue(e, t) {
|
|
return null == e || 'http://www.w3.org/1999/xhtml' === e
|
|
? ie(t)
|
|
: 'http://www.w3.org/2000/svg' === e && 'foreignObject' === t
|
|
? 'http://www.w3.org/1999/xhtml'
|
|
: e;
|
|
}
|
|
var se,
|
|
ce,
|
|
fe =
|
|
((ce = function (e, t) {
|
|
if (
|
|
'http://www.w3.org/2000/svg' !== e.namespaceURI ||
|
|
'innerHTML' in e
|
|
)
|
|
e.innerHTML = t;
|
|
else {
|
|
for (
|
|
(se = se || document.createElement('div')).innerHTML =
|
|
'<svg>' + t.valueOf().toString() + '</svg>',
|
|
t = se.firstChild;
|
|
e.firstChild;
|
|
)
|
|
e.removeChild(e.firstChild);
|
|
for (; t.firstChild; ) e.appendChild(t.firstChild);
|
|
}
|
|
}),
|
|
'undefined' !== typeof MSApp && MSApp.execUnsafeLocalFunction
|
|
? function (e, t, n, r) {
|
|
MSApp.execUnsafeLocalFunction(function () {
|
|
return ce(e, t);
|
|
});
|
|
}
|
|
: ce);
|
|
function de(e, t) {
|
|
if (t) {
|
|
var n = e.firstChild;
|
|
if (n && n === e.lastChild && 3 === n.nodeType)
|
|
return void (n.nodeValue = t);
|
|
}
|
|
e.textContent = t;
|
|
}
|
|
var pe = {
|
|
animationIterationCount: !0,
|
|
aspectRatio: !0,
|
|
borderImageOutset: !0,
|
|
borderImageSlice: !0,
|
|
borderImageWidth: !0,
|
|
boxFlex: !0,
|
|
boxFlexGroup: !0,
|
|
boxOrdinalGroup: !0,
|
|
columnCount: !0,
|
|
columns: !0,
|
|
flex: !0,
|
|
flexGrow: !0,
|
|
flexPositive: !0,
|
|
flexShrink: !0,
|
|
flexNegative: !0,
|
|
flexOrder: !0,
|
|
gridArea: !0,
|
|
gridRow: !0,
|
|
gridRowEnd: !0,
|
|
gridRowSpan: !0,
|
|
gridRowStart: !0,
|
|
gridColumn: !0,
|
|
gridColumnEnd: !0,
|
|
gridColumnSpan: !0,
|
|
gridColumnStart: !0,
|
|
fontWeight: !0,
|
|
lineClamp: !0,
|
|
lineHeight: !0,
|
|
opacity: !0,
|
|
order: !0,
|
|
orphans: !0,
|
|
tabSize: !0,
|
|
widows: !0,
|
|
zIndex: !0,
|
|
zoom: !0,
|
|
fillOpacity: !0,
|
|
floodOpacity: !0,
|
|
stopOpacity: !0,
|
|
strokeDasharray: !0,
|
|
strokeDashoffset: !0,
|
|
strokeMiterlimit: !0,
|
|
strokeOpacity: !0,
|
|
strokeWidth: !0,
|
|
},
|
|
he = ['Webkit', 'ms', 'Moz', 'O'];
|
|
function me(e, t, n) {
|
|
return null == t || 'boolean' === typeof t || '' === t
|
|
? ''
|
|
: n ||
|
|
'number' !== typeof t ||
|
|
0 === t ||
|
|
(pe.hasOwnProperty(e) && pe[e])
|
|
? ('' + t).trim()
|
|
: t + 'px';
|
|
}
|
|
function ve(e, t) {
|
|
for (var n in ((e = e.style), t))
|
|
if (t.hasOwnProperty(n)) {
|
|
var r = 0 === n.indexOf('--'),
|
|
l = me(n, t[n], r);
|
|
('float' === n && (n = 'cssFloat'),
|
|
r ? e.setProperty(n, l) : (e[n] = l));
|
|
}
|
|
}
|
|
Object.keys(pe).forEach(function (e) {
|
|
he.forEach(function (t) {
|
|
((t = t + e.charAt(0).toUpperCase() + e.substring(1)),
|
|
(pe[t] = pe[e]));
|
|
});
|
|
});
|
|
var ge = I(
|
|
{ menuitem: !0 },
|
|
{
|
|
area: !0,
|
|
base: !0,
|
|
br: !0,
|
|
col: !0,
|
|
embed: !0,
|
|
hr: !0,
|
|
img: !0,
|
|
input: !0,
|
|
keygen: !0,
|
|
link: !0,
|
|
meta: !0,
|
|
param: !0,
|
|
source: !0,
|
|
track: !0,
|
|
wbr: !0,
|
|
}
|
|
);
|
|
function ye(e, t) {
|
|
if (t) {
|
|
if (
|
|
ge[e] &&
|
|
(null != t.children || null != t.dangerouslySetInnerHTML)
|
|
)
|
|
throw Error(a(137, e));
|
|
if (null != t.dangerouslySetInnerHTML) {
|
|
if (null != t.children) throw Error(a(60));
|
|
if (
|
|
'object' !== typeof t.dangerouslySetInnerHTML ||
|
|
!('__html' in t.dangerouslySetInnerHTML)
|
|
)
|
|
throw Error(a(61));
|
|
}
|
|
if (null != t.style && 'object' !== typeof t.style)
|
|
throw Error(a(62));
|
|
}
|
|
}
|
|
function be(e, t) {
|
|
if (-1 === e.indexOf('-')) return 'string' === typeof t.is;
|
|
switch (e) {
|
|
case 'annotation-xml':
|
|
case 'color-profile':
|
|
case 'font-face':
|
|
case 'font-face-src':
|
|
case 'font-face-uri':
|
|
case 'font-face-format':
|
|
case 'font-face-name':
|
|
case 'missing-glyph':
|
|
return !1;
|
|
default:
|
|
return !0;
|
|
}
|
|
}
|
|
var ke = null;
|
|
function we(e) {
|
|
return (
|
|
(e = e.target || e.srcElement || window).correspondingUseElement &&
|
|
(e = e.correspondingUseElement),
|
|
3 === e.nodeType ? e.parentNode : e
|
|
);
|
|
}
|
|
var Se = null,
|
|
xe = null,
|
|
Ee = null;
|
|
function Ce(e) {
|
|
if ((e = bl(e))) {
|
|
if ('function' !== typeof Se) throw Error(a(280));
|
|
var t = e.stateNode;
|
|
t && ((t = wl(t)), Se(e.stateNode, e.type, t));
|
|
}
|
|
}
|
|
function _e(e) {
|
|
xe ? (Ee ? Ee.push(e) : (Ee = [e])) : (xe = e);
|
|
}
|
|
function Pe() {
|
|
if (xe) {
|
|
var e = xe,
|
|
t = Ee;
|
|
if (((Ee = xe = null), Ce(e), t))
|
|
for (e = 0; e < t.length; e++) Ce(t[e]);
|
|
}
|
|
}
|
|
function Ne(e, t) {
|
|
return e(t);
|
|
}
|
|
function ze() {}
|
|
var Te = !1;
|
|
function Me(e, t, n) {
|
|
if (Te) return e(t, n);
|
|
Te = !0;
|
|
try {
|
|
return Ne(e, t, n);
|
|
} finally {
|
|
((Te = !1), (null !== xe || null !== Ee) && (ze(), Pe()));
|
|
}
|
|
}
|
|
function Le(e, t) {
|
|
var n = e.stateNode;
|
|
if (null === n) return null;
|
|
var r = wl(n);
|
|
if (null === r) return null;
|
|
n = r[t];
|
|
e: switch (t) {
|
|
case 'onClick':
|
|
case 'onClickCapture':
|
|
case 'onDoubleClick':
|
|
case 'onDoubleClickCapture':
|
|
case 'onMouseDown':
|
|
case 'onMouseDownCapture':
|
|
case 'onMouseMove':
|
|
case 'onMouseMoveCapture':
|
|
case 'onMouseUp':
|
|
case 'onMouseUpCapture':
|
|
case 'onMouseEnter':
|
|
((r = !r.disabled) ||
|
|
(r = !(
|
|
'button' === (e = e.type) ||
|
|
'input' === e ||
|
|
'select' === e ||
|
|
'textarea' === e
|
|
)),
|
|
(e = !r));
|
|
break e;
|
|
default:
|
|
e = !1;
|
|
}
|
|
if (e) return null;
|
|
if (n && 'function' !== typeof n) throw Error(a(231, t, typeof n));
|
|
return n;
|
|
}
|
|
var De = !1;
|
|
if (c)
|
|
try {
|
|
var Re = {};
|
|
(Object.defineProperty(Re, 'passive', {
|
|
get: function () {
|
|
De = !0;
|
|
},
|
|
}),
|
|
window.addEventListener('test', Re, Re),
|
|
window.removeEventListener('test', Re, Re));
|
|
} catch (ce) {
|
|
De = !1;
|
|
}
|
|
function Oe(e, t, n, r, l, a, o, i, u) {
|
|
var s = Array.prototype.slice.call(arguments, 3);
|
|
try {
|
|
t.apply(n, s);
|
|
} catch (c) {
|
|
this.onError(c);
|
|
}
|
|
}
|
|
var Fe = !1,
|
|
Ie = null,
|
|
Ue = !1,
|
|
je = null,
|
|
Ae = {
|
|
onError: function (e) {
|
|
((Fe = !0), (Ie = e));
|
|
},
|
|
};
|
|
function Be(e, t, n, r, l, a, o, i, u) {
|
|
((Fe = !1), (Ie = null), Oe.apply(Ae, arguments));
|
|
}
|
|
function Ve(e) {
|
|
var t = e,
|
|
n = e;
|
|
if (e.alternate) for (; t.return; ) t = t.return;
|
|
else {
|
|
e = t;
|
|
do {
|
|
(0 !== (4098 & (t = e).flags) && (n = t.return), (e = t.return));
|
|
} while (e);
|
|
}
|
|
return 3 === t.tag ? n : null;
|
|
}
|
|
function $e(e) {
|
|
if (13 === e.tag) {
|
|
var t = e.memoizedState;
|
|
if (
|
|
(null === t &&
|
|
null !== (e = e.alternate) &&
|
|
(t = e.memoizedState),
|
|
null !== t)
|
|
)
|
|
return t.dehydrated;
|
|
}
|
|
return null;
|
|
}
|
|
function He(e) {
|
|
if (Ve(e) !== e) throw Error(a(188));
|
|
}
|
|
function We(e) {
|
|
return null !==
|
|
(e = (function (e) {
|
|
var t = e.alternate;
|
|
if (!t) {
|
|
if (null === (t = Ve(e))) throw Error(a(188));
|
|
return t !== e ? null : e;
|
|
}
|
|
for (var n = e, r = t; ; ) {
|
|
var l = n.return;
|
|
if (null === l) break;
|
|
var o = l.alternate;
|
|
if (null === o) {
|
|
if (null !== (r = l.return)) {
|
|
n = r;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (l.child === o.child) {
|
|
for (o = l.child; o; ) {
|
|
if (o === n) return (He(l), e);
|
|
if (o === r) return (He(l), t);
|
|
o = o.sibling;
|
|
}
|
|
throw Error(a(188));
|
|
}
|
|
if (n.return !== r.return) ((n = l), (r = o));
|
|
else {
|
|
for (var i = !1, u = l.child; u; ) {
|
|
if (u === n) {
|
|
((i = !0), (n = l), (r = o));
|
|
break;
|
|
}
|
|
if (u === r) {
|
|
((i = !0), (r = l), (n = o));
|
|
break;
|
|
}
|
|
u = u.sibling;
|
|
}
|
|
if (!i) {
|
|
for (u = o.child; u; ) {
|
|
if (u === n) {
|
|
((i = !0), (n = o), (r = l));
|
|
break;
|
|
}
|
|
if (u === r) {
|
|
((i = !0), (r = o), (n = l));
|
|
break;
|
|
}
|
|
u = u.sibling;
|
|
}
|
|
if (!i) throw Error(a(189));
|
|
}
|
|
}
|
|
if (n.alternate !== r) throw Error(a(190));
|
|
}
|
|
if (3 !== n.tag) throw Error(a(188));
|
|
return n.stateNode.current === n ? e : t;
|
|
})(e))
|
|
? Ke(e)
|
|
: null;
|
|
}
|
|
function Ke(e) {
|
|
if (5 === e.tag || 6 === e.tag) return e;
|
|
for (e = e.child; null !== e; ) {
|
|
var t = Ke(e);
|
|
if (null !== t) return t;
|
|
e = e.sibling;
|
|
}
|
|
return null;
|
|
}
|
|
var Qe = l.unstable_scheduleCallback,
|
|
qe = l.unstable_cancelCallback,
|
|
Ye = l.unstable_shouldYield,
|
|
Xe = l.unstable_requestPaint,
|
|
Ge = l.unstable_now,
|
|
Ze = l.unstable_getCurrentPriorityLevel,
|
|
Je = l.unstable_ImmediatePriority,
|
|
et = l.unstable_UserBlockingPriority,
|
|
tt = l.unstable_NormalPriority,
|
|
nt = l.unstable_LowPriority,
|
|
rt = l.unstable_IdlePriority,
|
|
lt = null,
|
|
at = null;
|
|
var ot = Math.clz32
|
|
? Math.clz32
|
|
: function (e) {
|
|
return (
|
|
(e >>>= 0),
|
|
0 === e ? 32 : (31 - ((it(e) / ut) | 0)) | 0
|
|
);
|
|
},
|
|
it = Math.log,
|
|
ut = Math.LN2;
|
|
var st = 64,
|
|
ct = 4194304;
|
|
function ft(e) {
|
|
switch (e & -e) {
|
|
case 1:
|
|
return 1;
|
|
case 2:
|
|
return 2;
|
|
case 4:
|
|
return 4;
|
|
case 8:
|
|
return 8;
|
|
case 16:
|
|
return 16;
|
|
case 32:
|
|
return 32;
|
|
case 64:
|
|
case 128:
|
|
case 256:
|
|
case 512:
|
|
case 1024:
|
|
case 2048:
|
|
case 4096:
|
|
case 8192:
|
|
case 16384:
|
|
case 32768:
|
|
case 65536:
|
|
case 131072:
|
|
case 262144:
|
|
case 524288:
|
|
case 1048576:
|
|
case 2097152:
|
|
return 4194240 & e;
|
|
case 4194304:
|
|
case 8388608:
|
|
case 16777216:
|
|
case 33554432:
|
|
case 67108864:
|
|
return 130023424 & e;
|
|
case 134217728:
|
|
return 134217728;
|
|
case 268435456:
|
|
return 268435456;
|
|
case 536870912:
|
|
return 536870912;
|
|
case 1073741824:
|
|
return 1073741824;
|
|
default:
|
|
return e;
|
|
}
|
|
}
|
|
function dt(e, t) {
|
|
var n = e.pendingLanes;
|
|
if (0 === n) return 0;
|
|
var r = 0,
|
|
l = e.suspendedLanes,
|
|
a = e.pingedLanes,
|
|
o = 268435455 & n;
|
|
if (0 !== o) {
|
|
var i = o & ~l;
|
|
0 !== i ? (r = ft(i)) : 0 !== (a &= o) && (r = ft(a));
|
|
} else 0 !== (o = n & ~l) ? (r = ft(o)) : 0 !== a && (r = ft(a));
|
|
if (0 === r) return 0;
|
|
if (
|
|
0 !== t &&
|
|
t !== r &&
|
|
0 === (t & l) &&
|
|
((l = r & -r) >= (a = t & -t) || (16 === l && 0 !== (4194240 & a)))
|
|
)
|
|
return t;
|
|
if ((0 !== (4 & r) && (r |= 16 & n), 0 !== (t = e.entangledLanes)))
|
|
for (e = e.entanglements, t &= r; 0 < t; )
|
|
((l = 1 << (n = 31 - ot(t))), (r |= e[n]), (t &= ~l));
|
|
return r;
|
|
}
|
|
function pt(e, t) {
|
|
switch (e) {
|
|
case 1:
|
|
case 2:
|
|
case 4:
|
|
return t + 250;
|
|
case 8:
|
|
case 16:
|
|
case 32:
|
|
case 64:
|
|
case 128:
|
|
case 256:
|
|
case 512:
|
|
case 1024:
|
|
case 2048:
|
|
case 4096:
|
|
case 8192:
|
|
case 16384:
|
|
case 32768:
|
|
case 65536:
|
|
case 131072:
|
|
case 262144:
|
|
case 524288:
|
|
case 1048576:
|
|
case 2097152:
|
|
return t + 5e3;
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
function ht(e) {
|
|
return 0 !== (e = -1073741825 & e.pendingLanes)
|
|
? e
|
|
: 1073741824 & e
|
|
? 1073741824
|
|
: 0;
|
|
}
|
|
function mt() {
|
|
var e = st;
|
|
return (0 === (4194240 & (st <<= 1)) && (st = 64), e);
|
|
}
|
|
function vt(e) {
|
|
for (var t = [], n = 0; 31 > n; n++) t.push(e);
|
|
return t;
|
|
}
|
|
function gt(e, t, n) {
|
|
((e.pendingLanes |= t),
|
|
536870912 !== t && ((e.suspendedLanes = 0), (e.pingedLanes = 0)),
|
|
((e = e.eventTimes)[(t = 31 - ot(t))] = n));
|
|
}
|
|
function yt(e, t) {
|
|
var n = (e.entangledLanes |= t);
|
|
for (e = e.entanglements; n; ) {
|
|
var r = 31 - ot(n),
|
|
l = 1 << r;
|
|
((l & t) | (e[r] & t) && (e[r] |= t), (n &= ~l));
|
|
}
|
|
}
|
|
var bt = 0;
|
|
function kt(e) {
|
|
return 1 < (e &= -e)
|
|
? 4 < e
|
|
? 0 !== (268435455 & e)
|
|
? 16
|
|
: 536870912
|
|
: 4
|
|
: 1;
|
|
}
|
|
var wt,
|
|
St,
|
|
xt,
|
|
Et,
|
|
Ct,
|
|
_t = !1,
|
|
Pt = [],
|
|
Nt = null,
|
|
zt = null,
|
|
Tt = null,
|
|
Mt = new Map(),
|
|
Lt = new Map(),
|
|
Dt = [],
|
|
Rt =
|
|
'mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit'.split(
|
|
' '
|
|
);
|
|
function Ot(e, t) {
|
|
switch (e) {
|
|
case 'focusin':
|
|
case 'focusout':
|
|
Nt = null;
|
|
break;
|
|
case 'dragenter':
|
|
case 'dragleave':
|
|
zt = null;
|
|
break;
|
|
case 'mouseover':
|
|
case 'mouseout':
|
|
Tt = null;
|
|
break;
|
|
case 'pointerover':
|
|
case 'pointerout':
|
|
Mt.delete(t.pointerId);
|
|
break;
|
|
case 'gotpointercapture':
|
|
case 'lostpointercapture':
|
|
Lt.delete(t.pointerId);
|
|
}
|
|
}
|
|
function Ft(e, t, n, r, l, a) {
|
|
return null === e || e.nativeEvent !== a
|
|
? ((e = {
|
|
blockedOn: t,
|
|
domEventName: n,
|
|
eventSystemFlags: r,
|
|
nativeEvent: a,
|
|
targetContainers: [l],
|
|
}),
|
|
null !== t && null !== (t = bl(t)) && St(t),
|
|
e)
|
|
: ((e.eventSystemFlags |= r),
|
|
(t = e.targetContainers),
|
|
null !== l && -1 === t.indexOf(l) && t.push(l),
|
|
e);
|
|
}
|
|
function It(e) {
|
|
var t = yl(e.target);
|
|
if (null !== t) {
|
|
var n = Ve(t);
|
|
if (null !== n)
|
|
if (13 === (t = n.tag)) {
|
|
if (null !== (t = $e(n)))
|
|
return (
|
|
(e.blockedOn = t),
|
|
void Ct(e.priority, function () {
|
|
xt(n);
|
|
})
|
|
);
|
|
} else if (
|
|
3 === t &&
|
|
n.stateNode.current.memoizedState.isDehydrated
|
|
)
|
|
return void (e.blockedOn =
|
|
3 === n.tag ? n.stateNode.containerInfo : null);
|
|
}
|
|
e.blockedOn = null;
|
|
}
|
|
function Ut(e) {
|
|
if (null !== e.blockedOn) return !1;
|
|
for (var t = e.targetContainers; 0 < t.length; ) {
|
|
var n = Yt(e.domEventName, e.eventSystemFlags, t[0], e.nativeEvent);
|
|
if (null !== n)
|
|
return (null !== (t = bl(n)) && St(t), (e.blockedOn = n), !1);
|
|
var r = new (n = e.nativeEvent).constructor(n.type, n);
|
|
((ke = r), n.target.dispatchEvent(r), (ke = null), t.shift());
|
|
}
|
|
return !0;
|
|
}
|
|
function jt(e, t, n) {
|
|
Ut(e) && n.delete(t);
|
|
}
|
|
function At() {
|
|
((_t = !1),
|
|
null !== Nt && Ut(Nt) && (Nt = null),
|
|
null !== zt && Ut(zt) && (zt = null),
|
|
null !== Tt && Ut(Tt) && (Tt = null),
|
|
Mt.forEach(jt),
|
|
Lt.forEach(jt));
|
|
}
|
|
function Bt(e, t) {
|
|
e.blockedOn === t &&
|
|
((e.blockedOn = null),
|
|
_t ||
|
|
((_t = !0),
|
|
l.unstable_scheduleCallback(l.unstable_NormalPriority, At)));
|
|
}
|
|
function Vt(e) {
|
|
function t(t) {
|
|
return Bt(t, e);
|
|
}
|
|
if (0 < Pt.length) {
|
|
Bt(Pt[0], e);
|
|
for (var n = 1; n < Pt.length; n++) {
|
|
var r = Pt[n];
|
|
r.blockedOn === e && (r.blockedOn = null);
|
|
}
|
|
}
|
|
for (
|
|
null !== Nt && Bt(Nt, e),
|
|
null !== zt && Bt(zt, e),
|
|
null !== Tt && Bt(Tt, e),
|
|
Mt.forEach(t),
|
|
Lt.forEach(t),
|
|
n = 0;
|
|
n < Dt.length;
|
|
n++
|
|
)
|
|
(r = Dt[n]).blockedOn === e && (r.blockedOn = null);
|
|
for (; 0 < Dt.length && null === (n = Dt[0]).blockedOn; )
|
|
(It(n), null === n.blockedOn && Dt.shift());
|
|
}
|
|
var $t = k.ReactCurrentBatchConfig,
|
|
Ht = !0;
|
|
function Wt(e, t, n, r) {
|
|
var l = bt,
|
|
a = $t.transition;
|
|
$t.transition = null;
|
|
try {
|
|
((bt = 1), Qt(e, t, n, r));
|
|
} finally {
|
|
((bt = l), ($t.transition = a));
|
|
}
|
|
}
|
|
function Kt(e, t, n, r) {
|
|
var l = bt,
|
|
a = $t.transition;
|
|
$t.transition = null;
|
|
try {
|
|
((bt = 4), Qt(e, t, n, r));
|
|
} finally {
|
|
((bt = l), ($t.transition = a));
|
|
}
|
|
}
|
|
function Qt(e, t, n, r) {
|
|
if (Ht) {
|
|
var l = Yt(e, t, n, r);
|
|
if (null === l) (Hr(e, t, r, qt, n), Ot(e, r));
|
|
else if (
|
|
(function (e, t, n, r, l) {
|
|
switch (t) {
|
|
case 'focusin':
|
|
return ((Nt = Ft(Nt, e, t, n, r, l)), !0);
|
|
case 'dragenter':
|
|
return ((zt = Ft(zt, e, t, n, r, l)), !0);
|
|
case 'mouseover':
|
|
return ((Tt = Ft(Tt, e, t, n, r, l)), !0);
|
|
case 'pointerover':
|
|
var a = l.pointerId;
|
|
return (
|
|
Mt.set(a, Ft(Mt.get(a) || null, e, t, n, r, l)),
|
|
!0
|
|
);
|
|
case 'gotpointercapture':
|
|
return (
|
|
(a = l.pointerId),
|
|
Lt.set(a, Ft(Lt.get(a) || null, e, t, n, r, l)),
|
|
!0
|
|
);
|
|
}
|
|
return !1;
|
|
})(l, e, t, n, r)
|
|
)
|
|
r.stopPropagation();
|
|
else if ((Ot(e, r), 4 & t && -1 < Rt.indexOf(e))) {
|
|
for (; null !== l; ) {
|
|
var a = bl(l);
|
|
if (
|
|
(null !== a && wt(a),
|
|
null === (a = Yt(e, t, n, r)) && Hr(e, t, r, qt, n),
|
|
a === l)
|
|
)
|
|
break;
|
|
l = a;
|
|
}
|
|
null !== l && r.stopPropagation();
|
|
} else Hr(e, t, r, null, n);
|
|
}
|
|
}
|
|
var qt = null;
|
|
function Yt(e, t, n, r) {
|
|
if (((qt = null), null !== (e = yl((e = we(r))))))
|
|
if (null === (t = Ve(e))) e = null;
|
|
else if (13 === (n = t.tag)) {
|
|
if (null !== (e = $e(t))) return e;
|
|
e = null;
|
|
} else if (3 === n) {
|
|
if (t.stateNode.current.memoizedState.isDehydrated)
|
|
return 3 === t.tag ? t.stateNode.containerInfo : null;
|
|
e = null;
|
|
} else t !== e && (e = null);
|
|
return ((qt = e), null);
|
|
}
|
|
function Xt(e) {
|
|
switch (e) {
|
|
case 'cancel':
|
|
case 'click':
|
|
case 'close':
|
|
case 'contextmenu':
|
|
case 'copy':
|
|
case 'cut':
|
|
case 'auxclick':
|
|
case 'dblclick':
|
|
case 'dragend':
|
|
case 'dragstart':
|
|
case 'drop':
|
|
case 'focusin':
|
|
case 'focusout':
|
|
case 'input':
|
|
case 'invalid':
|
|
case 'keydown':
|
|
case 'keypress':
|
|
case 'keyup':
|
|
case 'mousedown':
|
|
case 'mouseup':
|
|
case 'paste':
|
|
case 'pause':
|
|
case 'play':
|
|
case 'pointercancel':
|
|
case 'pointerdown':
|
|
case 'pointerup':
|
|
case 'ratechange':
|
|
case 'reset':
|
|
case 'resize':
|
|
case 'seeked':
|
|
case 'submit':
|
|
case 'touchcancel':
|
|
case 'touchend':
|
|
case 'touchstart':
|
|
case 'volumechange':
|
|
case 'change':
|
|
case 'selectionchange':
|
|
case 'textInput':
|
|
case 'compositionstart':
|
|
case 'compositionend':
|
|
case 'compositionupdate':
|
|
case 'beforeblur':
|
|
case 'afterblur':
|
|
case 'beforeinput':
|
|
case 'blur':
|
|
case 'fullscreenchange':
|
|
case 'focus':
|
|
case 'hashchange':
|
|
case 'popstate':
|
|
case 'select':
|
|
case 'selectstart':
|
|
return 1;
|
|
case 'drag':
|
|
case 'dragenter':
|
|
case 'dragexit':
|
|
case 'dragleave':
|
|
case 'dragover':
|
|
case 'mousemove':
|
|
case 'mouseout':
|
|
case 'mouseover':
|
|
case 'pointermove':
|
|
case 'pointerout':
|
|
case 'pointerover':
|
|
case 'scroll':
|
|
case 'toggle':
|
|
case 'touchmove':
|
|
case 'wheel':
|
|
case 'mouseenter':
|
|
case 'mouseleave':
|
|
case 'pointerenter':
|
|
case 'pointerleave':
|
|
return 4;
|
|
case 'message':
|
|
switch (Ze()) {
|
|
case Je:
|
|
return 1;
|
|
case et:
|
|
return 4;
|
|
case tt:
|
|
case nt:
|
|
return 16;
|
|
case rt:
|
|
return 536870912;
|
|
default:
|
|
return 16;
|
|
}
|
|
default:
|
|
return 16;
|
|
}
|
|
}
|
|
var Gt = null,
|
|
Zt = null,
|
|
Jt = null;
|
|
function en() {
|
|
if (Jt) return Jt;
|
|
var e,
|
|
t,
|
|
n = Zt,
|
|
r = n.length,
|
|
l = 'value' in Gt ? Gt.value : Gt.textContent,
|
|
a = l.length;
|
|
for (e = 0; e < r && n[e] === l[e]; e++);
|
|
var o = r - e;
|
|
for (t = 1; t <= o && n[r - t] === l[a - t]; t++);
|
|
return (Jt = l.slice(e, 1 < t ? 1 - t : void 0));
|
|
}
|
|
function tn(e) {
|
|
var t = e.keyCode;
|
|
return (
|
|
'charCode' in e
|
|
? 0 === (e = e.charCode) && 13 === t && (e = 13)
|
|
: (e = t),
|
|
10 === e && (e = 13),
|
|
32 <= e || 13 === e ? e : 0
|
|
);
|
|
}
|
|
function nn() {
|
|
return !0;
|
|
}
|
|
function rn() {
|
|
return !1;
|
|
}
|
|
function ln(e) {
|
|
function t(t, n, r, l, a) {
|
|
for (var o in ((this._reactName = t),
|
|
(this._targetInst = r),
|
|
(this.type = n),
|
|
(this.nativeEvent = l),
|
|
(this.target = a),
|
|
(this.currentTarget = null),
|
|
e))
|
|
e.hasOwnProperty(o) && ((t = e[o]), (this[o] = t ? t(l) : l[o]));
|
|
return (
|
|
(this.isDefaultPrevented = (
|
|
null != l.defaultPrevented
|
|
? l.defaultPrevented
|
|
: !1 === l.returnValue
|
|
)
|
|
? nn
|
|
: rn),
|
|
(this.isPropagationStopped = rn),
|
|
this
|
|
);
|
|
}
|
|
return (
|
|
I(t.prototype, {
|
|
preventDefault: function () {
|
|
this.defaultPrevented = !0;
|
|
var e = this.nativeEvent;
|
|
e &&
|
|
(e.preventDefault
|
|
? e.preventDefault()
|
|
: 'unknown' !== typeof e.returnValue &&
|
|
(e.returnValue = !1),
|
|
(this.isDefaultPrevented = nn));
|
|
},
|
|
stopPropagation: function () {
|
|
var e = this.nativeEvent;
|
|
e &&
|
|
(e.stopPropagation
|
|
? e.stopPropagation()
|
|
: 'unknown' !== typeof e.cancelBubble &&
|
|
(e.cancelBubble = !0),
|
|
(this.isPropagationStopped = nn));
|
|
},
|
|
persist: function () {},
|
|
isPersistent: nn,
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
var an,
|
|
on,
|
|
un,
|
|
sn = {
|
|
eventPhase: 0,
|
|
bubbles: 0,
|
|
cancelable: 0,
|
|
timeStamp: function (e) {
|
|
return e.timeStamp || Date.now();
|
|
},
|
|
defaultPrevented: 0,
|
|
isTrusted: 0,
|
|
},
|
|
cn = ln(sn),
|
|
fn = I({}, sn, { view: 0, detail: 0 }),
|
|
dn = ln(fn),
|
|
pn = I({}, fn, {
|
|
screenX: 0,
|
|
screenY: 0,
|
|
clientX: 0,
|
|
clientY: 0,
|
|
pageX: 0,
|
|
pageY: 0,
|
|
ctrlKey: 0,
|
|
shiftKey: 0,
|
|
altKey: 0,
|
|
metaKey: 0,
|
|
getModifierState: Cn,
|
|
button: 0,
|
|
buttons: 0,
|
|
relatedTarget: function (e) {
|
|
return void 0 === e.relatedTarget
|
|
? e.fromElement === e.srcElement
|
|
? e.toElement
|
|
: e.fromElement
|
|
: e.relatedTarget;
|
|
},
|
|
movementX: function (e) {
|
|
return 'movementX' in e
|
|
? e.movementX
|
|
: (e !== un &&
|
|
(un && 'mousemove' === e.type
|
|
? ((an = e.screenX - un.screenX),
|
|
(on = e.screenY - un.screenY))
|
|
: (on = an = 0),
|
|
(un = e)),
|
|
an);
|
|
},
|
|
movementY: function (e) {
|
|
return 'movementY' in e ? e.movementY : on;
|
|
},
|
|
}),
|
|
hn = ln(pn),
|
|
mn = ln(I({}, pn, { dataTransfer: 0 })),
|
|
vn = ln(I({}, fn, { relatedTarget: 0 })),
|
|
gn = ln(
|
|
I({}, sn, { animationName: 0, elapsedTime: 0, pseudoElement: 0 })
|
|
),
|
|
yn = I({}, sn, {
|
|
clipboardData: function (e) {
|
|
return 'clipboardData' in e
|
|
? e.clipboardData
|
|
: window.clipboardData;
|
|
},
|
|
}),
|
|
bn = ln(yn),
|
|
kn = ln(I({}, sn, { data: 0 })),
|
|
wn = {
|
|
Esc: 'Escape',
|
|
Spacebar: ' ',
|
|
Left: 'ArrowLeft',
|
|
Up: 'ArrowUp',
|
|
Right: 'ArrowRight',
|
|
Down: 'ArrowDown',
|
|
Del: 'Delete',
|
|
Win: 'OS',
|
|
Menu: 'ContextMenu',
|
|
Apps: 'ContextMenu',
|
|
Scroll: 'ScrollLock',
|
|
MozPrintableKey: 'Unidentified',
|
|
},
|
|
Sn = {
|
|
8: 'Backspace',
|
|
9: 'Tab',
|
|
12: 'Clear',
|
|
13: 'Enter',
|
|
16: 'Shift',
|
|
17: 'Control',
|
|
18: 'Alt',
|
|
19: 'Pause',
|
|
20: 'CapsLock',
|
|
27: 'Escape',
|
|
32: ' ',
|
|
33: 'PageUp',
|
|
34: 'PageDown',
|
|
35: 'End',
|
|
36: 'Home',
|
|
37: 'ArrowLeft',
|
|
38: 'ArrowUp',
|
|
39: 'ArrowRight',
|
|
40: 'ArrowDown',
|
|
45: 'Insert',
|
|
46: 'Delete',
|
|
112: 'F1',
|
|
113: 'F2',
|
|
114: 'F3',
|
|
115: 'F4',
|
|
116: 'F5',
|
|
117: 'F6',
|
|
118: 'F7',
|
|
119: 'F8',
|
|
120: 'F9',
|
|
121: 'F10',
|
|
122: 'F11',
|
|
123: 'F12',
|
|
144: 'NumLock',
|
|
145: 'ScrollLock',
|
|
224: 'Meta',
|
|
},
|
|
xn = {
|
|
Alt: 'altKey',
|
|
Control: 'ctrlKey',
|
|
Meta: 'metaKey',
|
|
Shift: 'shiftKey',
|
|
};
|
|
function En(e) {
|
|
var t = this.nativeEvent;
|
|
return t.getModifierState
|
|
? t.getModifierState(e)
|
|
: !!(e = xn[e]) && !!t[e];
|
|
}
|
|
function Cn() {
|
|
return En;
|
|
}
|
|
var _n = I({}, fn, {
|
|
key: function (e) {
|
|
if (e.key) {
|
|
var t = wn[e.key] || e.key;
|
|
if ('Unidentified' !== t) return t;
|
|
}
|
|
return 'keypress' === e.type
|
|
? 13 === (e = tn(e))
|
|
? 'Enter'
|
|
: String.fromCharCode(e)
|
|
: 'keydown' === e.type || 'keyup' === e.type
|
|
? Sn[e.keyCode] || 'Unidentified'
|
|
: '';
|
|
},
|
|
code: 0,
|
|
location: 0,
|
|
ctrlKey: 0,
|
|
shiftKey: 0,
|
|
altKey: 0,
|
|
metaKey: 0,
|
|
repeat: 0,
|
|
locale: 0,
|
|
getModifierState: Cn,
|
|
charCode: function (e) {
|
|
return 'keypress' === e.type ? tn(e) : 0;
|
|
},
|
|
keyCode: function (e) {
|
|
return 'keydown' === e.type || 'keyup' === e.type ? e.keyCode : 0;
|
|
},
|
|
which: function (e) {
|
|
return 'keypress' === e.type
|
|
? tn(e)
|
|
: 'keydown' === e.type || 'keyup' === e.type
|
|
? e.keyCode
|
|
: 0;
|
|
},
|
|
}),
|
|
Pn = ln(_n),
|
|
Nn = ln(
|
|
I({}, pn, {
|
|
pointerId: 0,
|
|
width: 0,
|
|
height: 0,
|
|
pressure: 0,
|
|
tangentialPressure: 0,
|
|
tiltX: 0,
|
|
tiltY: 0,
|
|
twist: 0,
|
|
pointerType: 0,
|
|
isPrimary: 0,
|
|
})
|
|
),
|
|
zn = ln(
|
|
I({}, fn, {
|
|
touches: 0,
|
|
targetTouches: 0,
|
|
changedTouches: 0,
|
|
altKey: 0,
|
|
metaKey: 0,
|
|
ctrlKey: 0,
|
|
shiftKey: 0,
|
|
getModifierState: Cn,
|
|
})
|
|
),
|
|
Tn = ln(
|
|
I({}, sn, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 })
|
|
),
|
|
Mn = I({}, pn, {
|
|
deltaX: function (e) {
|
|
return 'deltaX' in e
|
|
? e.deltaX
|
|
: 'wheelDeltaX' in e
|
|
? -e.wheelDeltaX
|
|
: 0;
|
|
},
|
|
deltaY: function (e) {
|
|
return 'deltaY' in e
|
|
? e.deltaY
|
|
: 'wheelDeltaY' in e
|
|
? -e.wheelDeltaY
|
|
: 'wheelDelta' in e
|
|
? -e.wheelDelta
|
|
: 0;
|
|
},
|
|
deltaZ: 0,
|
|
deltaMode: 0,
|
|
}),
|
|
Ln = ln(Mn),
|
|
Dn = [9, 13, 27, 32],
|
|
Rn = c && 'CompositionEvent' in window,
|
|
On = null;
|
|
c && 'documentMode' in document && (On = document.documentMode);
|
|
var Fn = c && 'TextEvent' in window && !On,
|
|
In = c && (!Rn || (On && 8 < On && 11 >= On)),
|
|
Un = String.fromCharCode(32),
|
|
jn = !1;
|
|
function An(e, t) {
|
|
switch (e) {
|
|
case 'keyup':
|
|
return -1 !== Dn.indexOf(t.keyCode);
|
|
case 'keydown':
|
|
return 229 !== t.keyCode;
|
|
case 'keypress':
|
|
case 'mousedown':
|
|
case 'focusout':
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
function Bn(e) {
|
|
return 'object' === typeof (e = e.detail) && 'data' in e
|
|
? e.data
|
|
: null;
|
|
}
|
|
var Vn = !1;
|
|
var $n = {
|
|
color: !0,
|
|
date: !0,
|
|
datetime: !0,
|
|
'datetime-local': !0,
|
|
email: !0,
|
|
month: !0,
|
|
number: !0,
|
|
password: !0,
|
|
range: !0,
|
|
search: !0,
|
|
tel: !0,
|
|
text: !0,
|
|
time: !0,
|
|
url: !0,
|
|
week: !0,
|
|
};
|
|
function Hn(e) {
|
|
var t = e && e.nodeName && e.nodeName.toLowerCase();
|
|
return 'input' === t ? !!$n[e.type] : 'textarea' === t;
|
|
}
|
|
function Wn(e, t, n, r) {
|
|
(_e(r),
|
|
0 < (t = Kr(t, 'onChange')).length &&
|
|
((n = new cn('onChange', 'change', null, n, r)),
|
|
e.push({ event: n, listeners: t })));
|
|
}
|
|
var Kn = null,
|
|
Qn = null;
|
|
function qn(e) {
|
|
Ur(e, 0);
|
|
}
|
|
function Yn(e) {
|
|
if (Q(kl(e))) return e;
|
|
}
|
|
function Xn(e, t) {
|
|
if ('change' === e) return t;
|
|
}
|
|
var Gn = !1;
|
|
if (c) {
|
|
var Zn;
|
|
if (c) {
|
|
var Jn = 'oninput' in document;
|
|
if (!Jn) {
|
|
var er = document.createElement('div');
|
|
(er.setAttribute('oninput', 'return;'),
|
|
(Jn = 'function' === typeof er.oninput));
|
|
}
|
|
Zn = Jn;
|
|
} else Zn = !1;
|
|
Gn = Zn && (!document.documentMode || 9 < document.documentMode);
|
|
}
|
|
function tr() {
|
|
Kn && (Kn.detachEvent('onpropertychange', nr), (Qn = Kn = null));
|
|
}
|
|
function nr(e) {
|
|
if ('value' === e.propertyName && Yn(Qn)) {
|
|
var t = [];
|
|
(Wn(t, Qn, e, we(e)), Me(qn, t));
|
|
}
|
|
}
|
|
function rr(e, t, n) {
|
|
'focusin' === e
|
|
? (tr(), (Qn = n), (Kn = t).attachEvent('onpropertychange', nr))
|
|
: 'focusout' === e && tr();
|
|
}
|
|
function lr(e) {
|
|
if ('selectionchange' === e || 'keyup' === e || 'keydown' === e)
|
|
return Yn(Qn);
|
|
}
|
|
function ar(e, t) {
|
|
if ('click' === e) return Yn(t);
|
|
}
|
|
function or(e, t) {
|
|
if ('input' === e || 'change' === e) return Yn(t);
|
|
}
|
|
var ir =
|
|
'function' === typeof Object.is
|
|
? Object.is
|
|
: function (e, t) {
|
|
return (
|
|
(e === t && (0 !== e || 1 / e === 1 / t)) ||
|
|
(e !== e && t !== t)
|
|
);
|
|
};
|
|
function ur(e, t) {
|
|
if (ir(e, t)) return !0;
|
|
if (
|
|
'object' !== typeof e ||
|
|
null === e ||
|
|
'object' !== typeof t ||
|
|
null === t
|
|
)
|
|
return !1;
|
|
var n = Object.keys(e),
|
|
r = Object.keys(t);
|
|
if (n.length !== r.length) return !1;
|
|
for (r = 0; r < n.length; r++) {
|
|
var l = n[r];
|
|
if (!f.call(t, l) || !ir(e[l], t[l])) return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
function sr(e) {
|
|
for (; e && e.firstChild; ) e = e.firstChild;
|
|
return e;
|
|
}
|
|
function cr(e, t) {
|
|
var n,
|
|
r = sr(e);
|
|
for (e = 0; r; ) {
|
|
if (3 === r.nodeType) {
|
|
if (((n = e + r.textContent.length), e <= t && n >= t))
|
|
return { node: r, offset: t - e };
|
|
e = n;
|
|
}
|
|
e: {
|
|
for (; r; ) {
|
|
if (r.nextSibling) {
|
|
r = r.nextSibling;
|
|
break e;
|
|
}
|
|
r = r.parentNode;
|
|
}
|
|
r = void 0;
|
|
}
|
|
r = sr(r);
|
|
}
|
|
}
|
|
function fr(e, t) {
|
|
return (
|
|
!(!e || !t) &&
|
|
(e === t ||
|
|
((!e || 3 !== e.nodeType) &&
|
|
(t && 3 === t.nodeType
|
|
? fr(e, t.parentNode)
|
|
: 'contains' in e
|
|
? e.contains(t)
|
|
: !!e.compareDocumentPosition &&
|
|
!!(16 & e.compareDocumentPosition(t)))))
|
|
);
|
|
}
|
|
function dr() {
|
|
for (var e = window, t = q(); t instanceof e.HTMLIFrameElement; ) {
|
|
try {
|
|
var n = 'string' === typeof t.contentWindow.location.href;
|
|
} catch (r) {
|
|
n = !1;
|
|
}
|
|
if (!n) break;
|
|
t = q((e = t.contentWindow).document);
|
|
}
|
|
return t;
|
|
}
|
|
function pr(e) {
|
|
var t = e && e.nodeName && e.nodeName.toLowerCase();
|
|
return (
|
|
t &&
|
|
(('input' === t &&
|
|
('text' === e.type ||
|
|
'search' === e.type ||
|
|
'tel' === e.type ||
|
|
'url' === e.type ||
|
|
'password' === e.type)) ||
|
|
'textarea' === t ||
|
|
'true' === e.contentEditable)
|
|
);
|
|
}
|
|
function hr(e) {
|
|
var t = dr(),
|
|
n = e.focusedElem,
|
|
r = e.selectionRange;
|
|
if (
|
|
t !== n &&
|
|
n &&
|
|
n.ownerDocument &&
|
|
fr(n.ownerDocument.documentElement, n)
|
|
) {
|
|
if (null !== r && pr(n))
|
|
if (
|
|
((t = r.start),
|
|
void 0 === (e = r.end) && (e = t),
|
|
'selectionStart' in n)
|
|
)
|
|
((n.selectionStart = t),
|
|
(n.selectionEnd = Math.min(e, n.value.length)));
|
|
else if (
|
|
(e =
|
|
((t = n.ownerDocument || document) && t.defaultView) ||
|
|
window).getSelection
|
|
) {
|
|
e = e.getSelection();
|
|
var l = n.textContent.length,
|
|
a = Math.min(r.start, l);
|
|
((r = void 0 === r.end ? a : Math.min(r.end, l)),
|
|
!e.extend && a > r && ((l = r), (r = a), (a = l)),
|
|
(l = cr(n, a)));
|
|
var o = cr(n, r);
|
|
l &&
|
|
o &&
|
|
(1 !== e.rangeCount ||
|
|
e.anchorNode !== l.node ||
|
|
e.anchorOffset !== l.offset ||
|
|
e.focusNode !== o.node ||
|
|
e.focusOffset !== o.offset) &&
|
|
((t = t.createRange()).setStart(l.node, l.offset),
|
|
e.removeAllRanges(),
|
|
a > r
|
|
? (e.addRange(t), e.extend(o.node, o.offset))
|
|
: (t.setEnd(o.node, o.offset), e.addRange(t)));
|
|
}
|
|
for (t = [], e = n; (e = e.parentNode); )
|
|
1 === e.nodeType &&
|
|
t.push({ element: e, left: e.scrollLeft, top: e.scrollTop });
|
|
for (
|
|
'function' === typeof n.focus && n.focus(), n = 0;
|
|
n < t.length;
|
|
n++
|
|
)
|
|
(((e = t[n]).element.scrollLeft = e.left),
|
|
(e.element.scrollTop = e.top));
|
|
}
|
|
}
|
|
var mr = c && 'documentMode' in document && 11 >= document.documentMode,
|
|
vr = null,
|
|
gr = null,
|
|
yr = null,
|
|
br = !1;
|
|
function kr(e, t, n) {
|
|
var r =
|
|
n.window === n
|
|
? n.document
|
|
: 9 === n.nodeType
|
|
? n
|
|
: n.ownerDocument;
|
|
br ||
|
|
null == vr ||
|
|
vr !== q(r) ||
|
|
('selectionStart' in (r = vr) && pr(r)
|
|
? (r = { start: r.selectionStart, end: r.selectionEnd })
|
|
: (r = {
|
|
anchorNode: (r = (
|
|
(r.ownerDocument && r.ownerDocument.defaultView) ||
|
|
window
|
|
).getSelection()).anchorNode,
|
|
anchorOffset: r.anchorOffset,
|
|
focusNode: r.focusNode,
|
|
focusOffset: r.focusOffset,
|
|
}),
|
|
(yr && ur(yr, r)) ||
|
|
((yr = r),
|
|
0 < (r = Kr(gr, 'onSelect')).length &&
|
|
((t = new cn('onSelect', 'select', null, t, n)),
|
|
e.push({ event: t, listeners: r }),
|
|
(t.target = vr))));
|
|
}
|
|
function wr(e, t) {
|
|
var n = {};
|
|
return (
|
|
(n[e.toLowerCase()] = t.toLowerCase()),
|
|
(n['Webkit' + e] = 'webkit' + t),
|
|
(n['Moz' + e] = 'moz' + t),
|
|
n
|
|
);
|
|
}
|
|
var Sr = {
|
|
animationend: wr('Animation', 'AnimationEnd'),
|
|
animationiteration: wr('Animation', 'AnimationIteration'),
|
|
animationstart: wr('Animation', 'AnimationStart'),
|
|
transitionend: wr('Transition', 'TransitionEnd'),
|
|
},
|
|
xr = {},
|
|
Er = {};
|
|
function Cr(e) {
|
|
if (xr[e]) return xr[e];
|
|
if (!Sr[e]) return e;
|
|
var t,
|
|
n = Sr[e];
|
|
for (t in n)
|
|
if (n.hasOwnProperty(t) && t in Er) return (xr[e] = n[t]);
|
|
return e;
|
|
}
|
|
c &&
|
|
((Er = document.createElement('div').style),
|
|
'AnimationEvent' in window ||
|
|
(delete Sr.animationend.animation,
|
|
delete Sr.animationiteration.animation,
|
|
delete Sr.animationstart.animation),
|
|
'TransitionEvent' in window || delete Sr.transitionend.transition);
|
|
var _r = Cr('animationend'),
|
|
Pr = Cr('animationiteration'),
|
|
Nr = Cr('animationstart'),
|
|
zr = Cr('transitionend'),
|
|
Tr = new Map(),
|
|
Mr =
|
|
'abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel'.split(
|
|
' '
|
|
);
|
|
function Lr(e, t) {
|
|
(Tr.set(e, t), u(t, [e]));
|
|
}
|
|
for (var Dr = 0; Dr < Mr.length; Dr++) {
|
|
var Rr = Mr[Dr];
|
|
Lr(Rr.toLowerCase(), 'on' + (Rr[0].toUpperCase() + Rr.slice(1)));
|
|
}
|
|
(Lr(_r, 'onAnimationEnd'),
|
|
Lr(Pr, 'onAnimationIteration'),
|
|
Lr(Nr, 'onAnimationStart'),
|
|
Lr('dblclick', 'onDoubleClick'),
|
|
Lr('focusin', 'onFocus'),
|
|
Lr('focusout', 'onBlur'),
|
|
Lr(zr, 'onTransitionEnd'),
|
|
s('onMouseEnter', ['mouseout', 'mouseover']),
|
|
s('onMouseLeave', ['mouseout', 'mouseover']),
|
|
s('onPointerEnter', ['pointerout', 'pointerover']),
|
|
s('onPointerLeave', ['pointerout', 'pointerover']),
|
|
u(
|
|
'onChange',
|
|
'change click focusin focusout input keydown keyup selectionchange'.split(
|
|
' '
|
|
)
|
|
),
|
|
u(
|
|
'onSelect',
|
|
'focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange'.split(
|
|
' '
|
|
)
|
|
),
|
|
u('onBeforeInput', [
|
|
'compositionend',
|
|
'keypress',
|
|
'textInput',
|
|
'paste',
|
|
]),
|
|
u(
|
|
'onCompositionEnd',
|
|
'compositionend focusout keydown keypress keyup mousedown'.split(
|
|
' '
|
|
)
|
|
),
|
|
u(
|
|
'onCompositionStart',
|
|
'compositionstart focusout keydown keypress keyup mousedown'.split(
|
|
' '
|
|
)
|
|
),
|
|
u(
|
|
'onCompositionUpdate',
|
|
'compositionupdate focusout keydown keypress keyup mousedown'.split(
|
|
' '
|
|
)
|
|
));
|
|
var Or =
|
|
'abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting'.split(
|
|
' '
|
|
),
|
|
Fr = new Set(
|
|
'cancel close invalid load scroll toggle'.split(' ').concat(Or)
|
|
);
|
|
function Ir(e, t, n) {
|
|
var r = e.type || 'unknown-event';
|
|
((e.currentTarget = n),
|
|
(function (e, t, n, r, l, o, i, u, s) {
|
|
if ((Be.apply(this, arguments), Fe)) {
|
|
if (!Fe) throw Error(a(198));
|
|
var c = Ie;
|
|
((Fe = !1), (Ie = null), Ue || ((Ue = !0), (je = c)));
|
|
}
|
|
})(r, t, void 0, e),
|
|
(e.currentTarget = null));
|
|
}
|
|
function Ur(e, t) {
|
|
t = 0 !== (4 & t);
|
|
for (var n = 0; n < e.length; n++) {
|
|
var r = e[n],
|
|
l = r.event;
|
|
r = r.listeners;
|
|
e: {
|
|
var a = void 0;
|
|
if (t)
|
|
for (var o = r.length - 1; 0 <= o; o--) {
|
|
var i = r[o],
|
|
u = i.instance,
|
|
s = i.currentTarget;
|
|
if (((i = i.listener), u !== a && l.isPropagationStopped()))
|
|
break e;
|
|
(Ir(l, i, s), (a = u));
|
|
}
|
|
else
|
|
for (o = 0; o < r.length; o++) {
|
|
if (
|
|
((u = (i = r[o]).instance),
|
|
(s = i.currentTarget),
|
|
(i = i.listener),
|
|
u !== a && l.isPropagationStopped())
|
|
)
|
|
break e;
|
|
(Ir(l, i, s), (a = u));
|
|
}
|
|
}
|
|
}
|
|
if (Ue) throw ((e = je), (Ue = !1), (je = null), e);
|
|
}
|
|
function jr(e, t) {
|
|
var n = t[ml];
|
|
void 0 === n && (n = t[ml] = new Set());
|
|
var r = e + '__bubble';
|
|
n.has(r) || ($r(t, e, 2, !1), n.add(r));
|
|
}
|
|
function Ar(e, t, n) {
|
|
var r = 0;
|
|
(t && (r |= 4), $r(n, e, r, t));
|
|
}
|
|
var Br = '_reactListening' + Math.random().toString(36).slice(2);
|
|
function Vr(e) {
|
|
if (!e[Br]) {
|
|
((e[Br] = !0),
|
|
o.forEach(function (t) {
|
|
'selectionchange' !== t &&
|
|
(Fr.has(t) || Ar(t, !1, e), Ar(t, !0, e));
|
|
}));
|
|
var t = 9 === e.nodeType ? e : e.ownerDocument;
|
|
null === t || t[Br] || ((t[Br] = !0), Ar('selectionchange', !1, t));
|
|
}
|
|
}
|
|
function $r(e, t, n, r) {
|
|
switch (Xt(t)) {
|
|
case 1:
|
|
var l = Wt;
|
|
break;
|
|
case 4:
|
|
l = Kt;
|
|
break;
|
|
default:
|
|
l = Qt;
|
|
}
|
|
((n = l.bind(null, t, n, e)),
|
|
(l = void 0),
|
|
!De ||
|
|
('touchstart' !== t && 'touchmove' !== t && 'wheel' !== t) ||
|
|
(l = !0),
|
|
r
|
|
? void 0 !== l
|
|
? e.addEventListener(t, n, { capture: !0, passive: l })
|
|
: e.addEventListener(t, n, !0)
|
|
: void 0 !== l
|
|
? e.addEventListener(t, n, { passive: l })
|
|
: e.addEventListener(t, n, !1));
|
|
}
|
|
function Hr(e, t, n, r, l) {
|
|
var a = r;
|
|
if (0 === (1 & t) && 0 === (2 & t) && null !== r)
|
|
e: for (;;) {
|
|
if (null === r) return;
|
|
var o = r.tag;
|
|
if (3 === o || 4 === o) {
|
|
var i = r.stateNode.containerInfo;
|
|
if (i === l || (8 === i.nodeType && i.parentNode === l)) break;
|
|
if (4 === o)
|
|
for (o = r.return; null !== o; ) {
|
|
var u = o.tag;
|
|
if (
|
|
(3 === u || 4 === u) &&
|
|
((u = o.stateNode.containerInfo) === l ||
|
|
(8 === u.nodeType && u.parentNode === l))
|
|
)
|
|
return;
|
|
o = o.return;
|
|
}
|
|
for (; null !== i; ) {
|
|
if (null === (o = yl(i))) return;
|
|
if (5 === (u = o.tag) || 6 === u) {
|
|
r = a = o;
|
|
continue e;
|
|
}
|
|
i = i.parentNode;
|
|
}
|
|
}
|
|
r = r.return;
|
|
}
|
|
Me(function () {
|
|
var r = a,
|
|
l = we(n),
|
|
o = [];
|
|
e: {
|
|
var i = Tr.get(e);
|
|
if (void 0 !== i) {
|
|
var u = cn,
|
|
s = e;
|
|
switch (e) {
|
|
case 'keypress':
|
|
if (0 === tn(n)) break e;
|
|
case 'keydown':
|
|
case 'keyup':
|
|
u = Pn;
|
|
break;
|
|
case 'focusin':
|
|
((s = 'focus'), (u = vn));
|
|
break;
|
|
case 'focusout':
|
|
((s = 'blur'), (u = vn));
|
|
break;
|
|
case 'beforeblur':
|
|
case 'afterblur':
|
|
u = vn;
|
|
break;
|
|
case 'click':
|
|
if (2 === n.button) break e;
|
|
case 'auxclick':
|
|
case 'dblclick':
|
|
case 'mousedown':
|
|
case 'mousemove':
|
|
case 'mouseup':
|
|
case 'mouseout':
|
|
case 'mouseover':
|
|
case 'contextmenu':
|
|
u = hn;
|
|
break;
|
|
case 'drag':
|
|
case 'dragend':
|
|
case 'dragenter':
|
|
case 'dragexit':
|
|
case 'dragleave':
|
|
case 'dragover':
|
|
case 'dragstart':
|
|
case 'drop':
|
|
u = mn;
|
|
break;
|
|
case 'touchcancel':
|
|
case 'touchend':
|
|
case 'touchmove':
|
|
case 'touchstart':
|
|
u = zn;
|
|
break;
|
|
case _r:
|
|
case Pr:
|
|
case Nr:
|
|
u = gn;
|
|
break;
|
|
case zr:
|
|
u = Tn;
|
|
break;
|
|
case 'scroll':
|
|
u = dn;
|
|
break;
|
|
case 'wheel':
|
|
u = Ln;
|
|
break;
|
|
case 'copy':
|
|
case 'cut':
|
|
case 'paste':
|
|
u = bn;
|
|
break;
|
|
case 'gotpointercapture':
|
|
case 'lostpointercapture':
|
|
case 'pointercancel':
|
|
case 'pointerdown':
|
|
case 'pointermove':
|
|
case 'pointerout':
|
|
case 'pointerover':
|
|
case 'pointerup':
|
|
u = Nn;
|
|
}
|
|
var c = 0 !== (4 & t),
|
|
f = !c && 'scroll' === e,
|
|
d = c ? (null !== i ? i + 'Capture' : null) : i;
|
|
c = [];
|
|
for (var p, h = r; null !== h; ) {
|
|
var m = (p = h).stateNode;
|
|
if (
|
|
(5 === p.tag &&
|
|
null !== m &&
|
|
((p = m),
|
|
null !== d &&
|
|
null != (m = Le(h, d)) &&
|
|
c.push(Wr(h, m, p))),
|
|
f)
|
|
)
|
|
break;
|
|
h = h.return;
|
|
}
|
|
0 < c.length &&
|
|
((i = new u(i, s, null, n, l)),
|
|
o.push({ event: i, listeners: c }));
|
|
}
|
|
}
|
|
if (0 === (7 & t)) {
|
|
if (
|
|
((u = 'mouseout' === e || 'pointerout' === e),
|
|
(!(i = 'mouseover' === e || 'pointerover' === e) ||
|
|
n === ke ||
|
|
!(s = n.relatedTarget || n.fromElement) ||
|
|
(!yl(s) && !s[hl])) &&
|
|
(u || i) &&
|
|
((i =
|
|
l.window === l
|
|
? l
|
|
: (i = l.ownerDocument)
|
|
? i.defaultView || i.parentWindow
|
|
: window),
|
|
u
|
|
? ((u = r),
|
|
null !==
|
|
(s = (s = n.relatedTarget || n.toElement)
|
|
? yl(s)
|
|
: null) &&
|
|
(s !== (f = Ve(s)) || (5 !== s.tag && 6 !== s.tag)) &&
|
|
(s = null))
|
|
: ((u = null), (s = r)),
|
|
u !== s))
|
|
) {
|
|
if (
|
|
((c = hn),
|
|
(m = 'onMouseLeave'),
|
|
(d = 'onMouseEnter'),
|
|
(h = 'mouse'),
|
|
('pointerout' !== e && 'pointerover' !== e) ||
|
|
((c = Nn),
|
|
(m = 'onPointerLeave'),
|
|
(d = 'onPointerEnter'),
|
|
(h = 'pointer')),
|
|
(f = null == u ? i : kl(u)),
|
|
(p = null == s ? i : kl(s)),
|
|
((i = new c(m, h + 'leave', u, n, l)).target = f),
|
|
(i.relatedTarget = p),
|
|
(m = null),
|
|
yl(l) === r &&
|
|
(((c = new c(d, h + 'enter', s, n, l)).target = p),
|
|
(c.relatedTarget = f),
|
|
(m = c)),
|
|
(f = m),
|
|
u && s)
|
|
)
|
|
e: {
|
|
for (d = s, h = 0, p = c = u; p; p = Qr(p)) h++;
|
|
for (p = 0, m = d; m; m = Qr(m)) p++;
|
|
for (; 0 < h - p; ) ((c = Qr(c)), h--);
|
|
for (; 0 < p - h; ) ((d = Qr(d)), p--);
|
|
for (; h--; ) {
|
|
if (c === d || (null !== d && c === d.alternate)) break e;
|
|
((c = Qr(c)), (d = Qr(d)));
|
|
}
|
|
c = null;
|
|
}
|
|
else c = null;
|
|
(null !== u && qr(o, i, u, c, !1),
|
|
null !== s && null !== f && qr(o, f, s, c, !0));
|
|
}
|
|
if (
|
|
'select' ===
|
|
(u =
|
|
(i = r ? kl(r) : window).nodeName &&
|
|
i.nodeName.toLowerCase()) ||
|
|
('input' === u && 'file' === i.type)
|
|
)
|
|
var v = Xn;
|
|
else if (Hn(i))
|
|
if (Gn) v = or;
|
|
else {
|
|
v = lr;
|
|
var g = rr;
|
|
}
|
|
else
|
|
(u = i.nodeName) &&
|
|
'input' === u.toLowerCase() &&
|
|
('checkbox' === i.type || 'radio' === i.type) &&
|
|
(v = ar);
|
|
switch (
|
|
(v && (v = v(e, r))
|
|
? Wn(o, v, n, l)
|
|
: (g && g(e, i, r),
|
|
'focusout' === e &&
|
|
(g = i._wrapperState) &&
|
|
g.controlled &&
|
|
'number' === i.type &&
|
|
ee(i, 'number', i.value)),
|
|
(g = r ? kl(r) : window),
|
|
e)
|
|
) {
|
|
case 'focusin':
|
|
(Hn(g) || 'true' === g.contentEditable) &&
|
|
((vr = g), (gr = r), (yr = null));
|
|
break;
|
|
case 'focusout':
|
|
yr = gr = vr = null;
|
|
break;
|
|
case 'mousedown':
|
|
br = !0;
|
|
break;
|
|
case 'contextmenu':
|
|
case 'mouseup':
|
|
case 'dragend':
|
|
((br = !1), kr(o, n, l));
|
|
break;
|
|
case 'selectionchange':
|
|
if (mr) break;
|
|
case 'keydown':
|
|
case 'keyup':
|
|
kr(o, n, l);
|
|
}
|
|
var y;
|
|
if (Rn)
|
|
e: {
|
|
switch (e) {
|
|
case 'compositionstart':
|
|
var b = 'onCompositionStart';
|
|
break e;
|
|
case 'compositionend':
|
|
b = 'onCompositionEnd';
|
|
break e;
|
|
case 'compositionupdate':
|
|
b = 'onCompositionUpdate';
|
|
break e;
|
|
}
|
|
b = void 0;
|
|
}
|
|
else
|
|
Vn
|
|
? An(e, n) && (b = 'onCompositionEnd')
|
|
: 'keydown' === e &&
|
|
229 === n.keyCode &&
|
|
(b = 'onCompositionStart');
|
|
(b &&
|
|
(In &&
|
|
'ko' !== n.locale &&
|
|
(Vn || 'onCompositionStart' !== b
|
|
? 'onCompositionEnd' === b && Vn && (y = en())
|
|
: ((Zt = 'value' in (Gt = l) ? Gt.value : Gt.textContent),
|
|
(Vn = !0))),
|
|
0 < (g = Kr(r, b)).length &&
|
|
((b = new kn(b, e, null, n, l)),
|
|
o.push({ event: b, listeners: g }),
|
|
y ? (b.data = y) : null !== (y = Bn(n)) && (b.data = y))),
|
|
(y = Fn
|
|
? (function (e, t) {
|
|
switch (e) {
|
|
case 'compositionend':
|
|
return Bn(t);
|
|
case 'keypress':
|
|
return 32 !== t.which ? null : ((jn = !0), Un);
|
|
case 'textInput':
|
|
return (e = t.data) === Un && jn ? null : e;
|
|
default:
|
|
return null;
|
|
}
|
|
})(e, n)
|
|
: (function (e, t) {
|
|
if (Vn)
|
|
return 'compositionend' === e || (!Rn && An(e, t))
|
|
? ((e = en()), (Jt = Zt = Gt = null), (Vn = !1), e)
|
|
: null;
|
|
switch (e) {
|
|
case 'paste':
|
|
default:
|
|
return null;
|
|
case 'keypress':
|
|
if (
|
|
!(t.ctrlKey || t.altKey || t.metaKey) ||
|
|
(t.ctrlKey && t.altKey)
|
|
) {
|
|
if (t.char && 1 < t.char.length) return t.char;
|
|
if (t.which) return String.fromCharCode(t.which);
|
|
}
|
|
return null;
|
|
case 'compositionend':
|
|
return In && 'ko' !== t.locale ? null : t.data;
|
|
}
|
|
})(e, n)) &&
|
|
0 < (r = Kr(r, 'onBeforeInput')).length &&
|
|
((l = new kn('onBeforeInput', 'beforeinput', null, n, l)),
|
|
o.push({ event: l, listeners: r }),
|
|
(l.data = y)));
|
|
}
|
|
Ur(o, t);
|
|
});
|
|
}
|
|
function Wr(e, t, n) {
|
|
return { instance: e, listener: t, currentTarget: n };
|
|
}
|
|
function Kr(e, t) {
|
|
for (var n = t + 'Capture', r = []; null !== e; ) {
|
|
var l = e,
|
|
a = l.stateNode;
|
|
(5 === l.tag &&
|
|
null !== a &&
|
|
((l = a),
|
|
null != (a = Le(e, n)) && r.unshift(Wr(e, a, l)),
|
|
null != (a = Le(e, t)) && r.push(Wr(e, a, l))),
|
|
(e = e.return));
|
|
}
|
|
return r;
|
|
}
|
|
function Qr(e) {
|
|
if (null === e) return null;
|
|
do {
|
|
e = e.return;
|
|
} while (e && 5 !== e.tag);
|
|
return e || null;
|
|
}
|
|
function qr(e, t, n, r, l) {
|
|
for (var a = t._reactName, o = []; null !== n && n !== r; ) {
|
|
var i = n,
|
|
u = i.alternate,
|
|
s = i.stateNode;
|
|
if (null !== u && u === r) break;
|
|
(5 === i.tag &&
|
|
null !== s &&
|
|
((i = s),
|
|
l
|
|
? null != (u = Le(n, a)) && o.unshift(Wr(n, u, i))
|
|
: l || (null != (u = Le(n, a)) && o.push(Wr(n, u, i)))),
|
|
(n = n.return));
|
|
}
|
|
0 !== o.length && e.push({ event: t, listeners: o });
|
|
}
|
|
var Yr = /\r\n?/g,
|
|
Xr = /\u0000|\uFFFD/g;
|
|
function Gr(e) {
|
|
return ('string' === typeof e ? e : '' + e)
|
|
.replace(Yr, '\n')
|
|
.replace(Xr, '');
|
|
}
|
|
function Zr(e, t, n) {
|
|
if (((t = Gr(t)), Gr(e) !== t && n)) throw Error(a(425));
|
|
}
|
|
function Jr() {}
|
|
var el = null,
|
|
tl = null;
|
|
function nl(e, t) {
|
|
return (
|
|
'textarea' === e ||
|
|
'noscript' === e ||
|
|
'string' === typeof t.children ||
|
|
'number' === typeof t.children ||
|
|
('object' === typeof t.dangerouslySetInnerHTML &&
|
|
null !== t.dangerouslySetInnerHTML &&
|
|
null != t.dangerouslySetInnerHTML.__html)
|
|
);
|
|
}
|
|
var rl = 'function' === typeof setTimeout ? setTimeout : void 0,
|
|
ll = 'function' === typeof clearTimeout ? clearTimeout : void 0,
|
|
al = 'function' === typeof Promise ? Promise : void 0,
|
|
ol =
|
|
'function' === typeof queueMicrotask
|
|
? queueMicrotask
|
|
: 'undefined' !== typeof al
|
|
? function (e) {
|
|
return al.resolve(null).then(e).catch(il);
|
|
}
|
|
: rl;
|
|
function il(e) {
|
|
setTimeout(function () {
|
|
throw e;
|
|
});
|
|
}
|
|
function ul(e, t) {
|
|
var n = t,
|
|
r = 0;
|
|
do {
|
|
var l = n.nextSibling;
|
|
if ((e.removeChild(n), l && 8 === l.nodeType))
|
|
if ('/$' === (n = l.data)) {
|
|
if (0 === r) return (e.removeChild(l), void Vt(t));
|
|
r--;
|
|
} else ('$' !== n && '$?' !== n && '$!' !== n) || r++;
|
|
n = l;
|
|
} while (n);
|
|
Vt(t);
|
|
}
|
|
function sl(e) {
|
|
for (; null != e; e = e.nextSibling) {
|
|
var t = e.nodeType;
|
|
if (1 === t || 3 === t) break;
|
|
if (8 === t) {
|
|
if ('$' === (t = e.data) || '$!' === t || '$?' === t) break;
|
|
if ('/$' === t) return null;
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
function cl(e) {
|
|
e = e.previousSibling;
|
|
for (var t = 0; e; ) {
|
|
if (8 === e.nodeType) {
|
|
var n = e.data;
|
|
if ('$' === n || '$!' === n || '$?' === n) {
|
|
if (0 === t) return e;
|
|
t--;
|
|
} else '/$' === n && t++;
|
|
}
|
|
e = e.previousSibling;
|
|
}
|
|
return null;
|
|
}
|
|
var fl = Math.random().toString(36).slice(2),
|
|
dl = '__reactFiber$' + fl,
|
|
pl = '__reactProps$' + fl,
|
|
hl = '__reactContainer$' + fl,
|
|
ml = '__reactEvents$' + fl,
|
|
vl = '__reactListeners$' + fl,
|
|
gl = '__reactHandles$' + fl;
|
|
function yl(e) {
|
|
var t = e[dl];
|
|
if (t) return t;
|
|
for (var n = e.parentNode; n; ) {
|
|
if ((t = n[hl] || n[dl])) {
|
|
if (
|
|
((n = t.alternate),
|
|
null !== t.child || (null !== n && null !== n.child))
|
|
)
|
|
for (e = cl(e); null !== e; ) {
|
|
if ((n = e[dl])) return n;
|
|
e = cl(e);
|
|
}
|
|
return t;
|
|
}
|
|
n = (e = n).parentNode;
|
|
}
|
|
return null;
|
|
}
|
|
function bl(e) {
|
|
return !(e = e[dl] || e[hl]) ||
|
|
(5 !== e.tag && 6 !== e.tag && 13 !== e.tag && 3 !== e.tag)
|
|
? null
|
|
: e;
|
|
}
|
|
function kl(e) {
|
|
if (5 === e.tag || 6 === e.tag) return e.stateNode;
|
|
throw Error(a(33));
|
|
}
|
|
function wl(e) {
|
|
return e[pl] || null;
|
|
}
|
|
var Sl = [],
|
|
xl = -1;
|
|
function El(e) {
|
|
return { current: e };
|
|
}
|
|
function Cl(e) {
|
|
0 > xl || ((e.current = Sl[xl]), (Sl[xl] = null), xl--);
|
|
}
|
|
function _l(e, t) {
|
|
(xl++, (Sl[xl] = e.current), (e.current = t));
|
|
}
|
|
var Pl = {},
|
|
Nl = El(Pl),
|
|
zl = El(!1),
|
|
Tl = Pl;
|
|
function Ml(e, t) {
|
|
var n = e.type.contextTypes;
|
|
if (!n) return Pl;
|
|
var r = e.stateNode;
|
|
if (r && r.__reactInternalMemoizedUnmaskedChildContext === t)
|
|
return r.__reactInternalMemoizedMaskedChildContext;
|
|
var l,
|
|
a = {};
|
|
for (l in n) a[l] = t[l];
|
|
return (
|
|
r &&
|
|
(((e = e.stateNode).__reactInternalMemoizedUnmaskedChildContext =
|
|
t),
|
|
(e.__reactInternalMemoizedMaskedChildContext = a)),
|
|
a
|
|
);
|
|
}
|
|
function Ll(e) {
|
|
return null !== (e = e.childContextTypes) && void 0 !== e;
|
|
}
|
|
function Dl() {
|
|
(Cl(zl), Cl(Nl));
|
|
}
|
|
function Rl(e, t, n) {
|
|
if (Nl.current !== Pl) throw Error(a(168));
|
|
(_l(Nl, t), _l(zl, n));
|
|
}
|
|
function Ol(e, t, n) {
|
|
var r = e.stateNode;
|
|
if (
|
|
((t = t.childContextTypes), 'function' !== typeof r.getChildContext)
|
|
)
|
|
return n;
|
|
for (var l in (r = r.getChildContext()))
|
|
if (!(l in t)) throw Error(a(108, $(e) || 'Unknown', l));
|
|
return I({}, n, r);
|
|
}
|
|
function Fl(e) {
|
|
return (
|
|
(e =
|
|
((e = e.stateNode) &&
|
|
e.__reactInternalMemoizedMergedChildContext) ||
|
|
Pl),
|
|
(Tl = Nl.current),
|
|
_l(Nl, e),
|
|
_l(zl, zl.current),
|
|
!0
|
|
);
|
|
}
|
|
function Il(e, t, n) {
|
|
var r = e.stateNode;
|
|
if (!r) throw Error(a(169));
|
|
(n
|
|
? ((e = Ol(e, t, Tl)),
|
|
(r.__reactInternalMemoizedMergedChildContext = e),
|
|
Cl(zl),
|
|
Cl(Nl),
|
|
_l(Nl, e))
|
|
: Cl(zl),
|
|
_l(zl, n));
|
|
}
|
|
var Ul = null,
|
|
jl = !1,
|
|
Al = !1;
|
|
function Bl(e) {
|
|
null === Ul ? (Ul = [e]) : Ul.push(e);
|
|
}
|
|
function Vl() {
|
|
if (!Al && null !== Ul) {
|
|
Al = !0;
|
|
var e = 0,
|
|
t = bt;
|
|
try {
|
|
var n = Ul;
|
|
for (bt = 1; e < n.length; e++) {
|
|
var r = n[e];
|
|
do {
|
|
r = r(!0);
|
|
} while (null !== r);
|
|
}
|
|
((Ul = null), (jl = !1));
|
|
} catch (l) {
|
|
throw (null !== Ul && (Ul = Ul.slice(e + 1)), Qe(Je, Vl), l);
|
|
} finally {
|
|
((bt = t), (Al = !1));
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
var $l = [],
|
|
Hl = 0,
|
|
Wl = null,
|
|
Kl = 0,
|
|
Ql = [],
|
|
ql = 0,
|
|
Yl = null,
|
|
Xl = 1,
|
|
Gl = '';
|
|
function Zl(e, t) {
|
|
(($l[Hl++] = Kl), ($l[Hl++] = Wl), (Wl = e), (Kl = t));
|
|
}
|
|
function Jl(e, t, n) {
|
|
((Ql[ql++] = Xl), (Ql[ql++] = Gl), (Ql[ql++] = Yl), (Yl = e));
|
|
var r = Xl;
|
|
e = Gl;
|
|
var l = 32 - ot(r) - 1;
|
|
((r &= ~(1 << l)), (n += 1));
|
|
var a = 32 - ot(t) + l;
|
|
if (30 < a) {
|
|
var o = l - (l % 5);
|
|
((a = (r & ((1 << o) - 1)).toString(32)),
|
|
(r >>= o),
|
|
(l -= o),
|
|
(Xl = (1 << (32 - ot(t) + l)) | (n << l) | r),
|
|
(Gl = a + e));
|
|
} else ((Xl = (1 << a) | (n << l) | r), (Gl = e));
|
|
}
|
|
function ea(e) {
|
|
null !== e.return && (Zl(e, 1), Jl(e, 1, 0));
|
|
}
|
|
function ta(e) {
|
|
for (; e === Wl; )
|
|
((Wl = $l[--Hl]),
|
|
($l[Hl] = null),
|
|
(Kl = $l[--Hl]),
|
|
($l[Hl] = null));
|
|
for (; e === Yl; )
|
|
((Yl = Ql[--ql]),
|
|
(Ql[ql] = null),
|
|
(Gl = Ql[--ql]),
|
|
(Ql[ql] = null),
|
|
(Xl = Ql[--ql]),
|
|
(Ql[ql] = null));
|
|
}
|
|
var na = null,
|
|
ra = null,
|
|
la = !1,
|
|
aa = null;
|
|
function oa(e, t) {
|
|
var n = Ls(5, null, null, 0);
|
|
((n.elementType = 'DELETED'),
|
|
(n.stateNode = t),
|
|
(n.return = e),
|
|
null === (t = e.deletions)
|
|
? ((e.deletions = [n]), (e.flags |= 16))
|
|
: t.push(n));
|
|
}
|
|
function ia(e, t) {
|
|
switch (e.tag) {
|
|
case 5:
|
|
var n = e.type;
|
|
return (
|
|
null !==
|
|
(t =
|
|
1 !== t.nodeType ||
|
|
n.toLowerCase() !== t.nodeName.toLowerCase()
|
|
? null
|
|
: t) &&
|
|
((e.stateNode = t), (na = e), (ra = sl(t.firstChild)), !0)
|
|
);
|
|
case 6:
|
|
return (
|
|
null !==
|
|
(t = '' === e.pendingProps || 3 !== t.nodeType ? null : t) &&
|
|
((e.stateNode = t), (na = e), (ra = null), !0)
|
|
);
|
|
case 13:
|
|
return (
|
|
null !== (t = 8 !== t.nodeType ? null : t) &&
|
|
((n = null !== Yl ? { id: Xl, overflow: Gl } : null),
|
|
(e.memoizedState = {
|
|
dehydrated: t,
|
|
treeContext: n,
|
|
retryLane: 1073741824,
|
|
}),
|
|
((n = Ls(18, null, null, 0)).stateNode = t),
|
|
(n.return = e),
|
|
(e.child = n),
|
|
(na = e),
|
|
(ra = null),
|
|
!0)
|
|
);
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
function ua(e) {
|
|
return 0 !== (1 & e.mode) && 0 === (128 & e.flags);
|
|
}
|
|
function sa(e) {
|
|
if (la) {
|
|
var t = ra;
|
|
if (t) {
|
|
var n = t;
|
|
if (!ia(e, t)) {
|
|
if (ua(e)) throw Error(a(418));
|
|
t = sl(n.nextSibling);
|
|
var r = na;
|
|
t && ia(e, t)
|
|
? oa(r, n)
|
|
: ((e.flags = (-4097 & e.flags) | 2), (la = !1), (na = e));
|
|
}
|
|
} else {
|
|
if (ua(e)) throw Error(a(418));
|
|
((e.flags = (-4097 & e.flags) | 2), (la = !1), (na = e));
|
|
}
|
|
}
|
|
}
|
|
function ca(e) {
|
|
for (
|
|
e = e.return;
|
|
null !== e && 5 !== e.tag && 3 !== e.tag && 13 !== e.tag;
|
|
)
|
|
e = e.return;
|
|
na = e;
|
|
}
|
|
function fa(e) {
|
|
if (e !== na) return !1;
|
|
if (!la) return (ca(e), (la = !0), !1);
|
|
var t;
|
|
if (
|
|
((t = 3 !== e.tag) &&
|
|
!(t = 5 !== e.tag) &&
|
|
(t =
|
|
'head' !== (t = e.type) &&
|
|
'body' !== t &&
|
|
!nl(e.type, e.memoizedProps)),
|
|
t && (t = ra))
|
|
) {
|
|
if (ua(e)) throw (da(), Error(a(418)));
|
|
for (; t; ) (oa(e, t), (t = sl(t.nextSibling)));
|
|
}
|
|
if ((ca(e), 13 === e.tag)) {
|
|
if (!(e = null !== (e = e.memoizedState) ? e.dehydrated : null))
|
|
throw Error(a(317));
|
|
e: {
|
|
for (e = e.nextSibling, t = 0; e; ) {
|
|
if (8 === e.nodeType) {
|
|
var n = e.data;
|
|
if ('/$' === n) {
|
|
if (0 === t) {
|
|
ra = sl(e.nextSibling);
|
|
break e;
|
|
}
|
|
t--;
|
|
} else ('$' !== n && '$!' !== n && '$?' !== n) || t++;
|
|
}
|
|
e = e.nextSibling;
|
|
}
|
|
ra = null;
|
|
}
|
|
} else ra = na ? sl(e.stateNode.nextSibling) : null;
|
|
return !0;
|
|
}
|
|
function da() {
|
|
for (var e = ra; e; ) e = sl(e.nextSibling);
|
|
}
|
|
function pa() {
|
|
((ra = na = null), (la = !1));
|
|
}
|
|
function ha(e) {
|
|
null === aa ? (aa = [e]) : aa.push(e);
|
|
}
|
|
var ma = k.ReactCurrentBatchConfig;
|
|
function va(e, t) {
|
|
if (e && e.defaultProps) {
|
|
for (var n in ((t = I({}, t)), (e = e.defaultProps)))
|
|
void 0 === t[n] && (t[n] = e[n]);
|
|
return t;
|
|
}
|
|
return t;
|
|
}
|
|
var ga = El(null),
|
|
ya = null,
|
|
ba = null,
|
|
ka = null;
|
|
function wa() {
|
|
ka = ba = ya = null;
|
|
}
|
|
function Sa(e) {
|
|
var t = ga.current;
|
|
(Cl(ga), (e._currentValue = t));
|
|
}
|
|
function xa(e, t, n) {
|
|
for (; null !== e; ) {
|
|
var r = e.alternate;
|
|
if (
|
|
((e.childLanes & t) !== t
|
|
? ((e.childLanes |= t), null !== r && (r.childLanes |= t))
|
|
: null !== r && (r.childLanes & t) !== t && (r.childLanes |= t),
|
|
e === n)
|
|
)
|
|
break;
|
|
e = e.return;
|
|
}
|
|
}
|
|
function Ea(e, t) {
|
|
((ya = e),
|
|
(ka = ba = null),
|
|
null !== (e = e.dependencies) &&
|
|
null !== e.firstContext &&
|
|
(0 !== (e.lanes & t) && (ki = !0), (e.firstContext = null)));
|
|
}
|
|
function Ca(e) {
|
|
var t = e._currentValue;
|
|
if (ka !== e)
|
|
if (
|
|
((e = { context: e, memoizedValue: t, next: null }), null === ba)
|
|
) {
|
|
if (null === ya) throw Error(a(308));
|
|
((ba = e), (ya.dependencies = { lanes: 0, firstContext: e }));
|
|
} else ba = ba.next = e;
|
|
return t;
|
|
}
|
|
var _a = null;
|
|
function Pa(e) {
|
|
null === _a ? (_a = [e]) : _a.push(e);
|
|
}
|
|
function Na(e, t, n, r) {
|
|
var l = t.interleaved;
|
|
return (
|
|
null === l
|
|
? ((n.next = n), Pa(t))
|
|
: ((n.next = l.next), (l.next = n)),
|
|
(t.interleaved = n),
|
|
za(e, r)
|
|
);
|
|
}
|
|
function za(e, t) {
|
|
e.lanes |= t;
|
|
var n = e.alternate;
|
|
for (null !== n && (n.lanes |= t), n = e, e = e.return; null !== e; )
|
|
((e.childLanes |= t),
|
|
null !== (n = e.alternate) && (n.childLanes |= t),
|
|
(n = e),
|
|
(e = e.return));
|
|
return 3 === n.tag ? n.stateNode : null;
|
|
}
|
|
var Ta = !1;
|
|
function Ma(e) {
|
|
e.updateQueue = {
|
|
baseState: e.memoizedState,
|
|
firstBaseUpdate: null,
|
|
lastBaseUpdate: null,
|
|
shared: { pending: null, interleaved: null, lanes: 0 },
|
|
effects: null,
|
|
};
|
|
}
|
|
function La(e, t) {
|
|
((e = e.updateQueue),
|
|
t.updateQueue === e &&
|
|
(t.updateQueue = {
|
|
baseState: e.baseState,
|
|
firstBaseUpdate: e.firstBaseUpdate,
|
|
lastBaseUpdate: e.lastBaseUpdate,
|
|
shared: e.shared,
|
|
effects: e.effects,
|
|
}));
|
|
}
|
|
function Da(e, t) {
|
|
return {
|
|
eventTime: e,
|
|
lane: t,
|
|
tag: 0,
|
|
payload: null,
|
|
callback: null,
|
|
next: null,
|
|
};
|
|
}
|
|
function Ra(e, t, n) {
|
|
var r = e.updateQueue;
|
|
if (null === r) return null;
|
|
if (((r = r.shared), 0 !== (2 & zu))) {
|
|
var l = r.pending;
|
|
return (
|
|
null === l ? (t.next = t) : ((t.next = l.next), (l.next = t)),
|
|
(r.pending = t),
|
|
za(e, n)
|
|
);
|
|
}
|
|
return (
|
|
null === (l = r.interleaved)
|
|
? ((t.next = t), Pa(r))
|
|
: ((t.next = l.next), (l.next = t)),
|
|
(r.interleaved = t),
|
|
za(e, n)
|
|
);
|
|
}
|
|
function Oa(e, t, n) {
|
|
if (
|
|
null !== (t = t.updateQueue) &&
|
|
((t = t.shared), 0 !== (4194240 & n))
|
|
) {
|
|
var r = t.lanes;
|
|
((n |= r &= e.pendingLanes), (t.lanes = n), yt(e, n));
|
|
}
|
|
}
|
|
function Fa(e, t) {
|
|
var n = e.updateQueue,
|
|
r = e.alternate;
|
|
if (null !== r && n === (r = r.updateQueue)) {
|
|
var l = null,
|
|
a = null;
|
|
if (null !== (n = n.firstBaseUpdate)) {
|
|
do {
|
|
var o = {
|
|
eventTime: n.eventTime,
|
|
lane: n.lane,
|
|
tag: n.tag,
|
|
payload: n.payload,
|
|
callback: n.callback,
|
|
next: null,
|
|
};
|
|
(null === a ? (l = a = o) : (a = a.next = o), (n = n.next));
|
|
} while (null !== n);
|
|
null === a ? (l = a = t) : (a = a.next = t);
|
|
} else l = a = t;
|
|
return (
|
|
(n = {
|
|
baseState: r.baseState,
|
|
firstBaseUpdate: l,
|
|
lastBaseUpdate: a,
|
|
shared: r.shared,
|
|
effects: r.effects,
|
|
}),
|
|
void (e.updateQueue = n)
|
|
);
|
|
}
|
|
(null === (e = n.lastBaseUpdate)
|
|
? (n.firstBaseUpdate = t)
|
|
: (e.next = t),
|
|
(n.lastBaseUpdate = t));
|
|
}
|
|
function Ia(e, t, n, r) {
|
|
var l = e.updateQueue;
|
|
Ta = !1;
|
|
var a = l.firstBaseUpdate,
|
|
o = l.lastBaseUpdate,
|
|
i = l.shared.pending;
|
|
if (null !== i) {
|
|
l.shared.pending = null;
|
|
var u = i,
|
|
s = u.next;
|
|
((u.next = null), null === o ? (a = s) : (o.next = s), (o = u));
|
|
var c = e.alternate;
|
|
null !== c &&
|
|
(i = (c = c.updateQueue).lastBaseUpdate) !== o &&
|
|
(null === i ? (c.firstBaseUpdate = s) : (i.next = s),
|
|
(c.lastBaseUpdate = u));
|
|
}
|
|
if (null !== a) {
|
|
var f = l.baseState;
|
|
for (o = 0, c = s = u = null, i = a; ; ) {
|
|
var d = i.lane,
|
|
p = i.eventTime;
|
|
if ((r & d) === d) {
|
|
null !== c &&
|
|
(c = c.next =
|
|
{
|
|
eventTime: p,
|
|
lane: 0,
|
|
tag: i.tag,
|
|
payload: i.payload,
|
|
callback: i.callback,
|
|
next: null,
|
|
});
|
|
e: {
|
|
var h = e,
|
|
m = i;
|
|
switch (((d = t), (p = n), m.tag)) {
|
|
case 1:
|
|
if ('function' === typeof (h = m.payload)) {
|
|
f = h.call(p, f, d);
|
|
break e;
|
|
}
|
|
f = h;
|
|
break e;
|
|
case 3:
|
|
h.flags = (-65537 & h.flags) | 128;
|
|
case 0:
|
|
if (
|
|
null ===
|
|
(d =
|
|
'function' === typeof (h = m.payload)
|
|
? h.call(p, f, d)
|
|
: h) ||
|
|
void 0 === d
|
|
)
|
|
break e;
|
|
f = I({}, f, d);
|
|
break e;
|
|
case 2:
|
|
Ta = !0;
|
|
}
|
|
}
|
|
null !== i.callback &&
|
|
0 !== i.lane &&
|
|
((e.flags |= 64),
|
|
null === (d = l.effects) ? (l.effects = [i]) : d.push(i));
|
|
} else
|
|
((p = {
|
|
eventTime: p,
|
|
lane: d,
|
|
tag: i.tag,
|
|
payload: i.payload,
|
|
callback: i.callback,
|
|
next: null,
|
|
}),
|
|
null === c ? ((s = c = p), (u = f)) : (c = c.next = p),
|
|
(o |= d));
|
|
if (null === (i = i.next)) {
|
|
if (null === (i = l.shared.pending)) break;
|
|
((i = (d = i).next),
|
|
(d.next = null),
|
|
(l.lastBaseUpdate = d),
|
|
(l.shared.pending = null));
|
|
}
|
|
}
|
|
if (
|
|
(null === c && (u = f),
|
|
(l.baseState = u),
|
|
(l.firstBaseUpdate = s),
|
|
(l.lastBaseUpdate = c),
|
|
null !== (t = l.shared.interleaved))
|
|
) {
|
|
l = t;
|
|
do {
|
|
((o |= l.lane), (l = l.next));
|
|
} while (l !== t);
|
|
} else null === a && (l.shared.lanes = 0);
|
|
((Iu |= o), (e.lanes = o), (e.memoizedState = f));
|
|
}
|
|
}
|
|
function Ua(e, t, n) {
|
|
if (((e = t.effects), (t.effects = null), null !== e))
|
|
for (t = 0; t < e.length; t++) {
|
|
var r = e[t],
|
|
l = r.callback;
|
|
if (null !== l) {
|
|
if (((r.callback = null), (r = n), 'function' !== typeof l))
|
|
throw Error(a(191, l));
|
|
l.call(r);
|
|
}
|
|
}
|
|
}
|
|
var ja = new r.Component().refs;
|
|
function Aa(e, t, n, r) {
|
|
((n =
|
|
null === (n = n(r, (t = e.memoizedState))) || void 0 === n
|
|
? t
|
|
: I({}, t, n)),
|
|
(e.memoizedState = n),
|
|
0 === e.lanes && (e.updateQueue.baseState = n));
|
|
}
|
|
var Ba = {
|
|
isMounted: function (e) {
|
|
return !!(e = e._reactInternals) && Ve(e) === e;
|
|
},
|
|
enqueueSetState: function (e, t, n) {
|
|
e = e._reactInternals;
|
|
var r = ts(),
|
|
l = ns(e),
|
|
a = Da(r, l);
|
|
((a.payload = t),
|
|
void 0 !== n && null !== n && (a.callback = n),
|
|
null !== (t = Ra(e, a, l)) && (rs(t, e, l, r), Oa(t, e, l)));
|
|
},
|
|
enqueueReplaceState: function (e, t, n) {
|
|
e = e._reactInternals;
|
|
var r = ts(),
|
|
l = ns(e),
|
|
a = Da(r, l);
|
|
((a.tag = 1),
|
|
(a.payload = t),
|
|
void 0 !== n && null !== n && (a.callback = n),
|
|
null !== (t = Ra(e, a, l)) && (rs(t, e, l, r), Oa(t, e, l)));
|
|
},
|
|
enqueueForceUpdate: function (e, t) {
|
|
e = e._reactInternals;
|
|
var n = ts(),
|
|
r = ns(e),
|
|
l = Da(n, r);
|
|
((l.tag = 2),
|
|
void 0 !== t && null !== t && (l.callback = t),
|
|
null !== (t = Ra(e, l, r)) && (rs(t, e, r, n), Oa(t, e, r)));
|
|
},
|
|
};
|
|
function Va(e, t, n, r, l, a, o) {
|
|
return 'function' === typeof (e = e.stateNode).shouldComponentUpdate
|
|
? e.shouldComponentUpdate(r, a, o)
|
|
: !t.prototype ||
|
|
!t.prototype.isPureReactComponent ||
|
|
!ur(n, r) ||
|
|
!ur(l, a);
|
|
}
|
|
function $a(e, t, n) {
|
|
var r = !1,
|
|
l = Pl,
|
|
a = t.contextType;
|
|
return (
|
|
'object' === typeof a && null !== a
|
|
? (a = Ca(a))
|
|
: ((l = Ll(t) ? Tl : Nl.current),
|
|
(a = (r = null !== (r = t.contextTypes) && void 0 !== r)
|
|
? Ml(e, l)
|
|
: Pl)),
|
|
(t = new t(n, a)),
|
|
(e.memoizedState =
|
|
null !== t.state && void 0 !== t.state ? t.state : null),
|
|
(t.updater = Ba),
|
|
(e.stateNode = t),
|
|
(t._reactInternals = e),
|
|
r &&
|
|
(((e = e.stateNode).__reactInternalMemoizedUnmaskedChildContext =
|
|
l),
|
|
(e.__reactInternalMemoizedMaskedChildContext = a)),
|
|
t
|
|
);
|
|
}
|
|
function Ha(e, t, n, r) {
|
|
((e = t.state),
|
|
'function' === typeof t.componentWillReceiveProps &&
|
|
t.componentWillReceiveProps(n, r),
|
|
'function' === typeof t.UNSAFE_componentWillReceiveProps &&
|
|
t.UNSAFE_componentWillReceiveProps(n, r),
|
|
t.state !== e && Ba.enqueueReplaceState(t, t.state, null));
|
|
}
|
|
function Wa(e, t, n, r) {
|
|
var l = e.stateNode;
|
|
((l.props = n), (l.state = e.memoizedState), (l.refs = ja), Ma(e));
|
|
var a = t.contextType;
|
|
('object' === typeof a && null !== a
|
|
? (l.context = Ca(a))
|
|
: ((a = Ll(t) ? Tl : Nl.current), (l.context = Ml(e, a))),
|
|
(l.state = e.memoizedState),
|
|
'function' === typeof (a = t.getDerivedStateFromProps) &&
|
|
(Aa(e, t, a, n), (l.state = e.memoizedState)),
|
|
'function' === typeof t.getDerivedStateFromProps ||
|
|
'function' === typeof l.getSnapshotBeforeUpdate ||
|
|
('function' !== typeof l.UNSAFE_componentWillMount &&
|
|
'function' !== typeof l.componentWillMount) ||
|
|
((t = l.state),
|
|
'function' === typeof l.componentWillMount &&
|
|
l.componentWillMount(),
|
|
'function' === typeof l.UNSAFE_componentWillMount &&
|
|
l.UNSAFE_componentWillMount(),
|
|
t !== l.state && Ba.enqueueReplaceState(l, l.state, null),
|
|
Ia(e, n, l, r),
|
|
(l.state = e.memoizedState)),
|
|
'function' === typeof l.componentDidMount && (e.flags |= 4194308));
|
|
}
|
|
function Ka(e, t, n) {
|
|
if (
|
|
null !== (e = n.ref) &&
|
|
'function' !== typeof e &&
|
|
'object' !== typeof e
|
|
) {
|
|
if (n._owner) {
|
|
if ((n = n._owner)) {
|
|
if (1 !== n.tag) throw Error(a(309));
|
|
var r = n.stateNode;
|
|
}
|
|
if (!r) throw Error(a(147, e));
|
|
var l = r,
|
|
o = '' + e;
|
|
return null !== t &&
|
|
null !== t.ref &&
|
|
'function' === typeof t.ref &&
|
|
t.ref._stringRef === o
|
|
? t.ref
|
|
: ((t = function (e) {
|
|
var t = l.refs;
|
|
(t === ja && (t = l.refs = {}),
|
|
null === e ? delete t[o] : (t[o] = e));
|
|
}),
|
|
(t._stringRef = o),
|
|
t);
|
|
}
|
|
if ('string' !== typeof e) throw Error(a(284));
|
|
if (!n._owner) throw Error(a(290, e));
|
|
}
|
|
return e;
|
|
}
|
|
function Qa(e, t) {
|
|
throw (
|
|
(e = Object.prototype.toString.call(t)),
|
|
Error(
|
|
a(
|
|
31,
|
|
'[object Object]' === e
|
|
? 'object with keys {' + Object.keys(t).join(', ') + '}'
|
|
: e
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function qa(e) {
|
|
return (0, e._init)(e._payload);
|
|
}
|
|
function Ya(e) {
|
|
function t(t, n) {
|
|
if (e) {
|
|
var r = t.deletions;
|
|
null === r ? ((t.deletions = [n]), (t.flags |= 16)) : r.push(n);
|
|
}
|
|
}
|
|
function n(n, r) {
|
|
if (!e) return null;
|
|
for (; null !== r; ) (t(n, r), (r = r.sibling));
|
|
return null;
|
|
}
|
|
function r(e, t) {
|
|
for (e = new Map(); null !== t; )
|
|
(null !== t.key ? e.set(t.key, t) : e.set(t.index, t),
|
|
(t = t.sibling));
|
|
return e;
|
|
}
|
|
function l(e, t) {
|
|
return (((e = Rs(e, t)).index = 0), (e.sibling = null), e);
|
|
}
|
|
function o(t, n, r) {
|
|
return (
|
|
(t.index = r),
|
|
e
|
|
? null !== (r = t.alternate)
|
|
? (r = r.index) < n
|
|
? ((t.flags |= 2), n)
|
|
: r
|
|
: ((t.flags |= 2), n)
|
|
: ((t.flags |= 1048576), n)
|
|
);
|
|
}
|
|
function i(t) {
|
|
return (e && null === t.alternate && (t.flags |= 2), t);
|
|
}
|
|
function u(e, t, n, r) {
|
|
return null === t || 6 !== t.tag
|
|
? (((t = Us(n, e.mode, r)).return = e), t)
|
|
: (((t = l(t, n)).return = e), t);
|
|
}
|
|
function s(e, t, n, r) {
|
|
var a = n.type;
|
|
return a === x
|
|
? f(e, t, n.props.children, r, n.key)
|
|
: null !== t &&
|
|
(t.elementType === a ||
|
|
('object' === typeof a &&
|
|
null !== a &&
|
|
a.$$typeof === L &&
|
|
qa(a) === t.type))
|
|
? (((r = l(t, n.props)).ref = Ka(e, t, n)), (r.return = e), r)
|
|
: (((r = Os(n.type, n.key, n.props, null, e.mode, r)).ref = Ka(
|
|
e,
|
|
t,
|
|
n
|
|
)),
|
|
(r.return = e),
|
|
r);
|
|
}
|
|
function c(e, t, n, r) {
|
|
return null === t ||
|
|
4 !== t.tag ||
|
|
t.stateNode.containerInfo !== n.containerInfo ||
|
|
t.stateNode.implementation !== n.implementation
|
|
? (((t = js(n, e.mode, r)).return = e), t)
|
|
: (((t = l(t, n.children || [])).return = e), t);
|
|
}
|
|
function f(e, t, n, r, a) {
|
|
return null === t || 7 !== t.tag
|
|
? (((t = Fs(n, e.mode, r, a)).return = e), t)
|
|
: (((t = l(t, n)).return = e), t);
|
|
}
|
|
function d(e, t, n) {
|
|
if (('string' === typeof t && '' !== t) || 'number' === typeof t)
|
|
return (((t = Us('' + t, e.mode, n)).return = e), t);
|
|
if ('object' === typeof t && null !== t) {
|
|
switch (t.$$typeof) {
|
|
case w:
|
|
return (
|
|
((n = Os(t.type, t.key, t.props, null, e.mode, n)).ref = Ka(
|
|
e,
|
|
null,
|
|
t
|
|
)),
|
|
(n.return = e),
|
|
n
|
|
);
|
|
case S:
|
|
return (((t = js(t, e.mode, n)).return = e), t);
|
|
case L:
|
|
return d(e, (0, t._init)(t._payload), n);
|
|
}
|
|
if (te(t) || O(t))
|
|
return (((t = Fs(t, e.mode, n, null)).return = e), t);
|
|
Qa(e, t);
|
|
}
|
|
return null;
|
|
}
|
|
function p(e, t, n, r) {
|
|
var l = null !== t ? t.key : null;
|
|
if (('string' === typeof n && '' !== n) || 'number' === typeof n)
|
|
return null !== l ? null : u(e, t, '' + n, r);
|
|
if ('object' === typeof n && null !== n) {
|
|
switch (n.$$typeof) {
|
|
case w:
|
|
return n.key === l ? s(e, t, n, r) : null;
|
|
case S:
|
|
return n.key === l ? c(e, t, n, r) : null;
|
|
case L:
|
|
return p(e, t, (l = n._init)(n._payload), r);
|
|
}
|
|
if (te(n) || O(n)) return null !== l ? null : f(e, t, n, r, null);
|
|
Qa(e, n);
|
|
}
|
|
return null;
|
|
}
|
|
function h(e, t, n, r, l) {
|
|
if (('string' === typeof r && '' !== r) || 'number' === typeof r)
|
|
return u(t, (e = e.get(n) || null), '' + r, l);
|
|
if ('object' === typeof r && null !== r) {
|
|
switch (r.$$typeof) {
|
|
case w:
|
|
return s(
|
|
t,
|
|
(e = e.get(null === r.key ? n : r.key) || null),
|
|
r,
|
|
l
|
|
);
|
|
case S:
|
|
return c(
|
|
t,
|
|
(e = e.get(null === r.key ? n : r.key) || null),
|
|
r,
|
|
l
|
|
);
|
|
case L:
|
|
return h(e, t, n, (0, r._init)(r._payload), l);
|
|
}
|
|
if (te(r) || O(r))
|
|
return f(t, (e = e.get(n) || null), r, l, null);
|
|
Qa(t, r);
|
|
}
|
|
return null;
|
|
}
|
|
function m(l, a, i, u) {
|
|
for (
|
|
var s = null, c = null, f = a, m = (a = 0), v = null;
|
|
null !== f && m < i.length;
|
|
m++
|
|
) {
|
|
f.index > m ? ((v = f), (f = null)) : (v = f.sibling);
|
|
var g = p(l, f, i[m], u);
|
|
if (null === g) {
|
|
null === f && (f = v);
|
|
break;
|
|
}
|
|
(e && f && null === g.alternate && t(l, f),
|
|
(a = o(g, a, m)),
|
|
null === c ? (s = g) : (c.sibling = g),
|
|
(c = g),
|
|
(f = v));
|
|
}
|
|
if (m === i.length) return (n(l, f), la && Zl(l, m), s);
|
|
if (null === f) {
|
|
for (; m < i.length; m++)
|
|
null !== (f = d(l, i[m], u)) &&
|
|
((a = o(f, a, m)),
|
|
null === c ? (s = f) : (c.sibling = f),
|
|
(c = f));
|
|
return (la && Zl(l, m), s);
|
|
}
|
|
for (f = r(l, f); m < i.length; m++)
|
|
null !== (v = h(f, l, m, i[m], u)) &&
|
|
(e &&
|
|
null !== v.alternate &&
|
|
f.delete(null === v.key ? m : v.key),
|
|
(a = o(v, a, m)),
|
|
null === c ? (s = v) : (c.sibling = v),
|
|
(c = v));
|
|
return (
|
|
e &&
|
|
f.forEach(function (e) {
|
|
return t(l, e);
|
|
}),
|
|
la && Zl(l, m),
|
|
s
|
|
);
|
|
}
|
|
function v(l, i, u, s) {
|
|
var c = O(u);
|
|
if ('function' !== typeof c) throw Error(a(150));
|
|
if (null == (u = c.call(u))) throw Error(a(151));
|
|
for (
|
|
var f = (c = null), m = i, v = (i = 0), g = null, y = u.next();
|
|
null !== m && !y.done;
|
|
v++, y = u.next()
|
|
) {
|
|
m.index > v ? ((g = m), (m = null)) : (g = m.sibling);
|
|
var b = p(l, m, y.value, s);
|
|
if (null === b) {
|
|
null === m && (m = g);
|
|
break;
|
|
}
|
|
(e && m && null === b.alternate && t(l, m),
|
|
(i = o(b, i, v)),
|
|
null === f ? (c = b) : (f.sibling = b),
|
|
(f = b),
|
|
(m = g));
|
|
}
|
|
if (y.done) return (n(l, m), la && Zl(l, v), c);
|
|
if (null === m) {
|
|
for (; !y.done; v++, y = u.next())
|
|
null !== (y = d(l, y.value, s)) &&
|
|
((i = o(y, i, v)),
|
|
null === f ? (c = y) : (f.sibling = y),
|
|
(f = y));
|
|
return (la && Zl(l, v), c);
|
|
}
|
|
for (m = r(l, m); !y.done; v++, y = u.next())
|
|
null !== (y = h(m, l, v, y.value, s)) &&
|
|
(e &&
|
|
null !== y.alternate &&
|
|
m.delete(null === y.key ? v : y.key),
|
|
(i = o(y, i, v)),
|
|
null === f ? (c = y) : (f.sibling = y),
|
|
(f = y));
|
|
return (
|
|
e &&
|
|
m.forEach(function (e) {
|
|
return t(l, e);
|
|
}),
|
|
la && Zl(l, v),
|
|
c
|
|
);
|
|
}
|
|
return function e(r, a, o, u) {
|
|
if (
|
|
('object' === typeof o &&
|
|
null !== o &&
|
|
o.type === x &&
|
|
null === o.key &&
|
|
(o = o.props.children),
|
|
'object' === typeof o && null !== o)
|
|
) {
|
|
switch (o.$$typeof) {
|
|
case w:
|
|
e: {
|
|
for (var s = o.key, c = a; null !== c; ) {
|
|
if (c.key === s) {
|
|
if ((s = o.type) === x) {
|
|
if (7 === c.tag) {
|
|
(n(r, c.sibling),
|
|
((a = l(c, o.props.children)).return = r),
|
|
(r = a));
|
|
break e;
|
|
}
|
|
} else if (
|
|
c.elementType === s ||
|
|
('object' === typeof s &&
|
|
null !== s &&
|
|
s.$$typeof === L &&
|
|
qa(s) === c.type)
|
|
) {
|
|
(n(r, c.sibling),
|
|
((a = l(c, o.props)).ref = Ka(r, c, o)),
|
|
(a.return = r),
|
|
(r = a));
|
|
break e;
|
|
}
|
|
n(r, c);
|
|
break;
|
|
}
|
|
(t(r, c), (c = c.sibling));
|
|
}
|
|
o.type === x
|
|
? (((a = Fs(o.props.children, r.mode, u, o.key)).return =
|
|
r),
|
|
(r = a))
|
|
: (((u = Os(
|
|
o.type,
|
|
o.key,
|
|
o.props,
|
|
null,
|
|
r.mode,
|
|
u
|
|
)).ref = Ka(r, a, o)),
|
|
(u.return = r),
|
|
(r = u));
|
|
}
|
|
return i(r);
|
|
case S:
|
|
e: {
|
|
for (c = o.key; null !== a; ) {
|
|
if (a.key === c) {
|
|
if (
|
|
4 === a.tag &&
|
|
a.stateNode.containerInfo === o.containerInfo &&
|
|
a.stateNode.implementation === o.implementation
|
|
) {
|
|
(n(r, a.sibling),
|
|
((a = l(a, o.children || [])).return = r),
|
|
(r = a));
|
|
break e;
|
|
}
|
|
n(r, a);
|
|
break;
|
|
}
|
|
(t(r, a), (a = a.sibling));
|
|
}
|
|
(((a = js(o, r.mode, u)).return = r), (r = a));
|
|
}
|
|
return i(r);
|
|
case L:
|
|
return e(r, a, (c = o._init)(o._payload), u);
|
|
}
|
|
if (te(o)) return m(r, a, o, u);
|
|
if (O(o)) return v(r, a, o, u);
|
|
Qa(r, o);
|
|
}
|
|
return ('string' === typeof o && '' !== o) || 'number' === typeof o
|
|
? ((o = '' + o),
|
|
null !== a && 6 === a.tag
|
|
? (n(r, a.sibling), ((a = l(a, o)).return = r), (r = a))
|
|
: (n(r, a), ((a = Us(o, r.mode, u)).return = r), (r = a)),
|
|
i(r))
|
|
: n(r, a);
|
|
};
|
|
}
|
|
var Xa = Ya(!0),
|
|
Ga = Ya(!1),
|
|
Za = {},
|
|
Ja = El(Za),
|
|
eo = El(Za),
|
|
to = El(Za);
|
|
function no(e) {
|
|
if (e === Za) throw Error(a(174));
|
|
return e;
|
|
}
|
|
function ro(e, t) {
|
|
switch ((_l(to, t), _l(eo, e), _l(Ja, Za), (e = t.nodeType))) {
|
|
case 9:
|
|
case 11:
|
|
t = (t = t.documentElement) ? t.namespaceURI : ue(null, '');
|
|
break;
|
|
default:
|
|
t = ue(
|
|
(t = (e = 8 === e ? t.parentNode : t).namespaceURI || null),
|
|
(e = e.tagName)
|
|
);
|
|
}
|
|
(Cl(Ja), _l(Ja, t));
|
|
}
|
|
function lo() {
|
|
(Cl(Ja), Cl(eo), Cl(to));
|
|
}
|
|
function ao(e) {
|
|
no(to.current);
|
|
var t = no(Ja.current),
|
|
n = ue(t, e.type);
|
|
t !== n && (_l(eo, e), _l(Ja, n));
|
|
}
|
|
function oo(e) {
|
|
eo.current === e && (Cl(Ja), Cl(eo));
|
|
}
|
|
var io = El(0);
|
|
function uo(e) {
|
|
for (var t = e; null !== t; ) {
|
|
if (13 === t.tag) {
|
|
var n = t.memoizedState;
|
|
if (
|
|
null !== n &&
|
|
(null === (n = n.dehydrated) ||
|
|
'$?' === n.data ||
|
|
'$!' === n.data)
|
|
)
|
|
return t;
|
|
} else if (19 === t.tag && void 0 !== t.memoizedProps.revealOrder) {
|
|
if (0 !== (128 & t.flags)) return t;
|
|
} else if (null !== t.child) {
|
|
((t.child.return = t), (t = t.child));
|
|
continue;
|
|
}
|
|
if (t === e) break;
|
|
for (; null === t.sibling; ) {
|
|
if (null === t.return || t.return === e) return null;
|
|
t = t.return;
|
|
}
|
|
((t.sibling.return = t.return), (t = t.sibling));
|
|
}
|
|
return null;
|
|
}
|
|
var so = [];
|
|
function co() {
|
|
for (var e = 0; e < so.length; e++)
|
|
so[e]._workInProgressVersionPrimary = null;
|
|
so.length = 0;
|
|
}
|
|
var fo = k.ReactCurrentDispatcher,
|
|
po = k.ReactCurrentBatchConfig,
|
|
ho = 0,
|
|
mo = null,
|
|
vo = null,
|
|
go = null,
|
|
yo = !1,
|
|
bo = !1,
|
|
ko = 0,
|
|
wo = 0;
|
|
function So() {
|
|
throw Error(a(321));
|
|
}
|
|
function xo(e, t) {
|
|
if (null === t) return !1;
|
|
for (var n = 0; n < t.length && n < e.length; n++)
|
|
if (!ir(e[n], t[n])) return !1;
|
|
return !0;
|
|
}
|
|
function Eo(e, t, n, r, l, o) {
|
|
if (
|
|
((ho = o),
|
|
(mo = t),
|
|
(t.memoizedState = null),
|
|
(t.updateQueue = null),
|
|
(t.lanes = 0),
|
|
(fo.current = null === e || null === e.memoizedState ? ii : ui),
|
|
(e = n(r, l)),
|
|
bo)
|
|
) {
|
|
o = 0;
|
|
do {
|
|
if (((bo = !1), (ko = 0), 25 <= o)) throw Error(a(301));
|
|
((o += 1),
|
|
(go = vo = null),
|
|
(t.updateQueue = null),
|
|
(fo.current = si),
|
|
(e = n(r, l)));
|
|
} while (bo);
|
|
}
|
|
if (
|
|
((fo.current = oi),
|
|
(t = null !== vo && null !== vo.next),
|
|
(ho = 0),
|
|
(go = vo = mo = null),
|
|
(yo = !1),
|
|
t)
|
|
)
|
|
throw Error(a(300));
|
|
return e;
|
|
}
|
|
function Co() {
|
|
var e = 0 !== ko;
|
|
return ((ko = 0), e);
|
|
}
|
|
function _o() {
|
|
var e = {
|
|
memoizedState: null,
|
|
baseState: null,
|
|
baseQueue: null,
|
|
queue: null,
|
|
next: null,
|
|
};
|
|
return (
|
|
null === go ? (mo.memoizedState = go = e) : (go = go.next = e),
|
|
go
|
|
);
|
|
}
|
|
function Po() {
|
|
if (null === vo) {
|
|
var e = mo.alternate;
|
|
e = null !== e ? e.memoizedState : null;
|
|
} else e = vo.next;
|
|
var t = null === go ? mo.memoizedState : go.next;
|
|
if (null !== t) ((go = t), (vo = e));
|
|
else {
|
|
if (null === e) throw Error(a(310));
|
|
((e = {
|
|
memoizedState: (vo = e).memoizedState,
|
|
baseState: vo.baseState,
|
|
baseQueue: vo.baseQueue,
|
|
queue: vo.queue,
|
|
next: null,
|
|
}),
|
|
null === go ? (mo.memoizedState = go = e) : (go = go.next = e));
|
|
}
|
|
return go;
|
|
}
|
|
function No(e, t) {
|
|
return 'function' === typeof t ? t(e) : t;
|
|
}
|
|
function zo(e) {
|
|
var t = Po(),
|
|
n = t.queue;
|
|
if (null === n) throw Error(a(311));
|
|
n.lastRenderedReducer = e;
|
|
var r = vo,
|
|
l = r.baseQueue,
|
|
o = n.pending;
|
|
if (null !== o) {
|
|
if (null !== l) {
|
|
var i = l.next;
|
|
((l.next = o.next), (o.next = i));
|
|
}
|
|
((r.baseQueue = l = o), (n.pending = null));
|
|
}
|
|
if (null !== l) {
|
|
((o = l.next), (r = r.baseState));
|
|
var u = (i = null),
|
|
s = null,
|
|
c = o;
|
|
do {
|
|
var f = c.lane;
|
|
if ((ho & f) === f)
|
|
(null !== s &&
|
|
(s = s.next =
|
|
{
|
|
lane: 0,
|
|
action: c.action,
|
|
hasEagerState: c.hasEagerState,
|
|
eagerState: c.eagerState,
|
|
next: null,
|
|
}),
|
|
(r = c.hasEagerState ? c.eagerState : e(r, c.action)));
|
|
else {
|
|
var d = {
|
|
lane: f,
|
|
action: c.action,
|
|
hasEagerState: c.hasEagerState,
|
|
eagerState: c.eagerState,
|
|
next: null,
|
|
};
|
|
(null === s ? ((u = s = d), (i = r)) : (s = s.next = d),
|
|
(mo.lanes |= f),
|
|
(Iu |= f));
|
|
}
|
|
c = c.next;
|
|
} while (null !== c && c !== o);
|
|
(null === s ? (i = r) : (s.next = u),
|
|
ir(r, t.memoizedState) || (ki = !0),
|
|
(t.memoizedState = r),
|
|
(t.baseState = i),
|
|
(t.baseQueue = s),
|
|
(n.lastRenderedState = r));
|
|
}
|
|
if (null !== (e = n.interleaved)) {
|
|
l = e;
|
|
do {
|
|
((o = l.lane), (mo.lanes |= o), (Iu |= o), (l = l.next));
|
|
} while (l !== e);
|
|
} else null === l && (n.lanes = 0);
|
|
return [t.memoizedState, n.dispatch];
|
|
}
|
|
function To(e) {
|
|
var t = Po(),
|
|
n = t.queue;
|
|
if (null === n) throw Error(a(311));
|
|
n.lastRenderedReducer = e;
|
|
var r = n.dispatch,
|
|
l = n.pending,
|
|
o = t.memoizedState;
|
|
if (null !== l) {
|
|
n.pending = null;
|
|
var i = (l = l.next);
|
|
do {
|
|
((o = e(o, i.action)), (i = i.next));
|
|
} while (i !== l);
|
|
(ir(o, t.memoizedState) || (ki = !0),
|
|
(t.memoizedState = o),
|
|
null === t.baseQueue && (t.baseState = o),
|
|
(n.lastRenderedState = o));
|
|
}
|
|
return [o, r];
|
|
}
|
|
function Mo() {}
|
|
function Lo(e, t) {
|
|
var n = mo,
|
|
r = Po(),
|
|
l = t(),
|
|
o = !ir(r.memoizedState, l);
|
|
if (
|
|
(o && ((r.memoizedState = l), (ki = !0)),
|
|
(r = r.queue),
|
|
Ho(Oo.bind(null, n, r, e), [e]),
|
|
r.getSnapshot !== t ||
|
|
o ||
|
|
(null !== go && 1 & go.memoizedState.tag))
|
|
) {
|
|
if (
|
|
((n.flags |= 2048),
|
|
jo(9, Ro.bind(null, n, r, l, t), void 0, null),
|
|
null === Tu)
|
|
)
|
|
throw Error(a(349));
|
|
0 !== (30 & ho) || Do(n, t, l);
|
|
}
|
|
return l;
|
|
}
|
|
function Do(e, t, n) {
|
|
((e.flags |= 16384),
|
|
(e = { getSnapshot: t, value: n }),
|
|
null === (t = mo.updateQueue)
|
|
? ((t = { lastEffect: null, stores: null }),
|
|
(mo.updateQueue = t),
|
|
(t.stores = [e]))
|
|
: null === (n = t.stores)
|
|
? (t.stores = [e])
|
|
: n.push(e));
|
|
}
|
|
function Ro(e, t, n, r) {
|
|
((t.value = n), (t.getSnapshot = r), Fo(t) && Io(e));
|
|
}
|
|
function Oo(e, t, n) {
|
|
return n(function () {
|
|
Fo(t) && Io(e);
|
|
});
|
|
}
|
|
function Fo(e) {
|
|
var t = e.getSnapshot;
|
|
e = e.value;
|
|
try {
|
|
var n = t();
|
|
return !ir(e, n);
|
|
} catch (r) {
|
|
return !0;
|
|
}
|
|
}
|
|
function Io(e) {
|
|
var t = za(e, 1);
|
|
null !== t && rs(t, e, 1, -1);
|
|
}
|
|
function Uo(e) {
|
|
var t = _o();
|
|
return (
|
|
'function' === typeof e && (e = e()),
|
|
(t.memoizedState = t.baseState = e),
|
|
(e = {
|
|
pending: null,
|
|
interleaved: null,
|
|
lanes: 0,
|
|
dispatch: null,
|
|
lastRenderedReducer: No,
|
|
lastRenderedState: e,
|
|
}),
|
|
(t.queue = e),
|
|
(e = e.dispatch = ni.bind(null, mo, e)),
|
|
[t.memoizedState, e]
|
|
);
|
|
}
|
|
function jo(e, t, n, r) {
|
|
return (
|
|
(e = { tag: e, create: t, destroy: n, deps: r, next: null }),
|
|
null === (t = mo.updateQueue)
|
|
? ((t = { lastEffect: null, stores: null }),
|
|
(mo.updateQueue = t),
|
|
(t.lastEffect = e.next = e))
|
|
: null === (n = t.lastEffect)
|
|
? (t.lastEffect = e.next = e)
|
|
: ((r = n.next),
|
|
(n.next = e),
|
|
(e.next = r),
|
|
(t.lastEffect = e)),
|
|
e
|
|
);
|
|
}
|
|
function Ao() {
|
|
return Po().memoizedState;
|
|
}
|
|
function Bo(e, t, n, r) {
|
|
var l = _o();
|
|
((mo.flags |= e),
|
|
(l.memoizedState = jo(1 | t, n, void 0, void 0 === r ? null : r)));
|
|
}
|
|
function Vo(e, t, n, r) {
|
|
var l = Po();
|
|
r = void 0 === r ? null : r;
|
|
var a = void 0;
|
|
if (null !== vo) {
|
|
var o = vo.memoizedState;
|
|
if (((a = o.destroy), null !== r && xo(r, o.deps)))
|
|
return void (l.memoizedState = jo(t, n, a, r));
|
|
}
|
|
((mo.flags |= e), (l.memoizedState = jo(1 | t, n, a, r)));
|
|
}
|
|
function $o(e, t) {
|
|
return Bo(8390656, 8, e, t);
|
|
}
|
|
function Ho(e, t) {
|
|
return Vo(2048, 8, e, t);
|
|
}
|
|
function Wo(e, t) {
|
|
return Vo(4, 2, e, t);
|
|
}
|
|
function Ko(e, t) {
|
|
return Vo(4, 4, e, t);
|
|
}
|
|
function Qo(e, t) {
|
|
return 'function' === typeof t
|
|
? ((e = e()),
|
|
t(e),
|
|
function () {
|
|
t(null);
|
|
})
|
|
: null !== t && void 0 !== t
|
|
? ((e = e()),
|
|
(t.current = e),
|
|
function () {
|
|
t.current = null;
|
|
})
|
|
: void 0;
|
|
}
|
|
function qo(e, t, n) {
|
|
return (
|
|
(n = null !== n && void 0 !== n ? n.concat([e]) : null),
|
|
Vo(4, 4, Qo.bind(null, t, e), n)
|
|
);
|
|
}
|
|
function Yo() {}
|
|
function Xo(e, t) {
|
|
var n = Po();
|
|
t = void 0 === t ? null : t;
|
|
var r = n.memoizedState;
|
|
return null !== r && null !== t && xo(t, r[1])
|
|
? r[0]
|
|
: ((n.memoizedState = [e, t]), e);
|
|
}
|
|
function Go(e, t) {
|
|
var n = Po();
|
|
t = void 0 === t ? null : t;
|
|
var r = n.memoizedState;
|
|
return null !== r && null !== t && xo(t, r[1])
|
|
? r[0]
|
|
: ((e = e()), (n.memoizedState = [e, t]), e);
|
|
}
|
|
function Zo(e, t, n) {
|
|
return 0 === (21 & ho)
|
|
? (e.baseState && ((e.baseState = !1), (ki = !0)),
|
|
(e.memoizedState = n))
|
|
: (ir(n, t) ||
|
|
((n = mt()), (mo.lanes |= n), (Iu |= n), (e.baseState = !0)),
|
|
t);
|
|
}
|
|
function Jo(e, t) {
|
|
var n = bt;
|
|
((bt = 0 !== n && 4 > n ? n : 4), e(!0));
|
|
var r = po.transition;
|
|
po.transition = {};
|
|
try {
|
|
(e(!1), t());
|
|
} finally {
|
|
((bt = n), (po.transition = r));
|
|
}
|
|
}
|
|
function ei() {
|
|
return Po().memoizedState;
|
|
}
|
|
function ti(e, t, n) {
|
|
var r = ns(e);
|
|
if (
|
|
((n = {
|
|
lane: r,
|
|
action: n,
|
|
hasEagerState: !1,
|
|
eagerState: null,
|
|
next: null,
|
|
}),
|
|
ri(e))
|
|
)
|
|
li(t, n);
|
|
else if (null !== (n = Na(e, t, n, r))) {
|
|
(rs(n, e, r, ts()), ai(n, t, r));
|
|
}
|
|
}
|
|
function ni(e, t, n) {
|
|
var r = ns(e),
|
|
l = {
|
|
lane: r,
|
|
action: n,
|
|
hasEagerState: !1,
|
|
eagerState: null,
|
|
next: null,
|
|
};
|
|
if (ri(e)) li(t, l);
|
|
else {
|
|
var a = e.alternate;
|
|
if (
|
|
0 === e.lanes &&
|
|
(null === a || 0 === a.lanes) &&
|
|
null !== (a = t.lastRenderedReducer)
|
|
)
|
|
try {
|
|
var o = t.lastRenderedState,
|
|
i = a(o, n);
|
|
if (((l.hasEagerState = !0), (l.eagerState = i), ir(i, o))) {
|
|
var u = t.interleaved;
|
|
return (
|
|
null === u
|
|
? ((l.next = l), Pa(t))
|
|
: ((l.next = u.next), (u.next = l)),
|
|
void (t.interleaved = l)
|
|
);
|
|
}
|
|
} catch (s) {}
|
|
null !== (n = Na(e, t, l, r)) &&
|
|
(rs(n, e, r, (l = ts())), ai(n, t, r));
|
|
}
|
|
}
|
|
function ri(e) {
|
|
var t = e.alternate;
|
|
return e === mo || (null !== t && t === mo);
|
|
}
|
|
function li(e, t) {
|
|
bo = yo = !0;
|
|
var n = e.pending;
|
|
(null === n ? (t.next = t) : ((t.next = n.next), (n.next = t)),
|
|
(e.pending = t));
|
|
}
|
|
function ai(e, t, n) {
|
|
if (0 !== (4194240 & n)) {
|
|
var r = t.lanes;
|
|
((n |= r &= e.pendingLanes), (t.lanes = n), yt(e, n));
|
|
}
|
|
}
|
|
var oi = {
|
|
readContext: Ca,
|
|
useCallback: So,
|
|
useContext: So,
|
|
useEffect: So,
|
|
useImperativeHandle: So,
|
|
useInsertionEffect: So,
|
|
useLayoutEffect: So,
|
|
useMemo: So,
|
|
useReducer: So,
|
|
useRef: So,
|
|
useState: So,
|
|
useDebugValue: So,
|
|
useDeferredValue: So,
|
|
useTransition: So,
|
|
useMutableSource: So,
|
|
useSyncExternalStore: So,
|
|
useId: So,
|
|
unstable_isNewReconciler: !1,
|
|
},
|
|
ii = {
|
|
readContext: Ca,
|
|
useCallback: function (e, t) {
|
|
return ((_o().memoizedState = [e, void 0 === t ? null : t]), e);
|
|
},
|
|
useContext: Ca,
|
|
useEffect: $o,
|
|
useImperativeHandle: function (e, t, n) {
|
|
return (
|
|
(n = null !== n && void 0 !== n ? n.concat([e]) : null),
|
|
Bo(4194308, 4, Qo.bind(null, t, e), n)
|
|
);
|
|
},
|
|
useLayoutEffect: function (e, t) {
|
|
return Bo(4194308, 4, e, t);
|
|
},
|
|
useInsertionEffect: function (e, t) {
|
|
return Bo(4, 2, e, t);
|
|
},
|
|
useMemo: function (e, t) {
|
|
var n = _o();
|
|
return (
|
|
(t = void 0 === t ? null : t),
|
|
(e = e()),
|
|
(n.memoizedState = [e, t]),
|
|
e
|
|
);
|
|
},
|
|
useReducer: function (e, t, n) {
|
|
var r = _o();
|
|
return (
|
|
(t = void 0 !== n ? n(t) : t),
|
|
(r.memoizedState = r.baseState = t),
|
|
(e = {
|
|
pending: null,
|
|
interleaved: null,
|
|
lanes: 0,
|
|
dispatch: null,
|
|
lastRenderedReducer: e,
|
|
lastRenderedState: t,
|
|
}),
|
|
(r.queue = e),
|
|
(e = e.dispatch = ti.bind(null, mo, e)),
|
|
[r.memoizedState, e]
|
|
);
|
|
},
|
|
useRef: function (e) {
|
|
return ((e = { current: e }), (_o().memoizedState = e));
|
|
},
|
|
useState: Uo,
|
|
useDebugValue: Yo,
|
|
useDeferredValue: function (e) {
|
|
return (_o().memoizedState = e);
|
|
},
|
|
useTransition: function () {
|
|
var e = Uo(!1),
|
|
t = e[0];
|
|
return (
|
|
(e = Jo.bind(null, e[1])),
|
|
(_o().memoizedState = e),
|
|
[t, e]
|
|
);
|
|
},
|
|
useMutableSource: function () {},
|
|
useSyncExternalStore: function (e, t, n) {
|
|
var r = mo,
|
|
l = _o();
|
|
if (la) {
|
|
if (void 0 === n) throw Error(a(407));
|
|
n = n();
|
|
} else {
|
|
if (((n = t()), null === Tu)) throw Error(a(349));
|
|
0 !== (30 & ho) || Do(r, t, n);
|
|
}
|
|
l.memoizedState = n;
|
|
var o = { value: n, getSnapshot: t };
|
|
return (
|
|
(l.queue = o),
|
|
$o(Oo.bind(null, r, o, e), [e]),
|
|
(r.flags |= 2048),
|
|
jo(9, Ro.bind(null, r, o, n, t), void 0, null),
|
|
n
|
|
);
|
|
},
|
|
useId: function () {
|
|
var e = _o(),
|
|
t = Tu.identifierPrefix;
|
|
if (la) {
|
|
var n = Gl;
|
|
((t =
|
|
':' +
|
|
t +
|
|
'R' +
|
|
(n = (Xl & ~(1 << (32 - ot(Xl) - 1))).toString(32) + n)),
|
|
0 < (n = ko++) && (t += 'H' + n.toString(32)),
|
|
(t += ':'));
|
|
} else t = ':' + t + 'r' + (n = wo++).toString(32) + ':';
|
|
return (e.memoizedState = t);
|
|
},
|
|
unstable_isNewReconciler: !1,
|
|
},
|
|
ui = {
|
|
readContext: Ca,
|
|
useCallback: Xo,
|
|
useContext: Ca,
|
|
useEffect: Ho,
|
|
useImperativeHandle: qo,
|
|
useInsertionEffect: Wo,
|
|
useLayoutEffect: Ko,
|
|
useMemo: Go,
|
|
useReducer: zo,
|
|
useRef: Ao,
|
|
useState: function () {
|
|
return zo(No);
|
|
},
|
|
useDebugValue: Yo,
|
|
useDeferredValue: function (e) {
|
|
return Zo(Po(), vo.memoizedState, e);
|
|
},
|
|
useTransition: function () {
|
|
return [zo(No)[0], Po().memoizedState];
|
|
},
|
|
useMutableSource: Mo,
|
|
useSyncExternalStore: Lo,
|
|
useId: ei,
|
|
unstable_isNewReconciler: !1,
|
|
},
|
|
si = {
|
|
readContext: Ca,
|
|
useCallback: Xo,
|
|
useContext: Ca,
|
|
useEffect: Ho,
|
|
useImperativeHandle: qo,
|
|
useInsertionEffect: Wo,
|
|
useLayoutEffect: Ko,
|
|
useMemo: Go,
|
|
useReducer: To,
|
|
useRef: Ao,
|
|
useState: function () {
|
|
return To(No);
|
|
},
|
|
useDebugValue: Yo,
|
|
useDeferredValue: function (e) {
|
|
var t = Po();
|
|
return null === vo
|
|
? (t.memoizedState = e)
|
|
: Zo(t, vo.memoizedState, e);
|
|
},
|
|
useTransition: function () {
|
|
return [To(No)[0], Po().memoizedState];
|
|
},
|
|
useMutableSource: Mo,
|
|
useSyncExternalStore: Lo,
|
|
useId: ei,
|
|
unstable_isNewReconciler: !1,
|
|
};
|
|
function ci(e, t) {
|
|
try {
|
|
var n = '',
|
|
r = t;
|
|
do {
|
|
((n += B(r)), (r = r.return));
|
|
} while (r);
|
|
var l = n;
|
|
} catch (a) {
|
|
l = '\nError generating stack: ' + a.message + '\n' + a.stack;
|
|
}
|
|
return { value: e, source: t, stack: l, digest: null };
|
|
}
|
|
function fi(e, t, n) {
|
|
return {
|
|
value: e,
|
|
source: null,
|
|
stack: null != n ? n : null,
|
|
digest: null != t ? t : null,
|
|
};
|
|
}
|
|
function di(e, t) {
|
|
try {
|
|
console.error(t.value);
|
|
} catch (n) {
|
|
setTimeout(function () {
|
|
throw n;
|
|
});
|
|
}
|
|
}
|
|
var pi = 'function' === typeof WeakMap ? WeakMap : Map;
|
|
function hi(e, t, n) {
|
|
(((n = Da(-1, n)).tag = 3), (n.payload = { element: null }));
|
|
var r = t.value;
|
|
return (
|
|
(n.callback = function () {
|
|
(Wu || ((Wu = !0), (Ku = r)), di(0, t));
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
function mi(e, t, n) {
|
|
(n = Da(-1, n)).tag = 3;
|
|
var r = e.type.getDerivedStateFromError;
|
|
if ('function' === typeof r) {
|
|
var l = t.value;
|
|
((n.payload = function () {
|
|
return r(l);
|
|
}),
|
|
(n.callback = function () {
|
|
di(0, t);
|
|
}));
|
|
}
|
|
var a = e.stateNode;
|
|
return (
|
|
null !== a &&
|
|
'function' === typeof a.componentDidCatch &&
|
|
(n.callback = function () {
|
|
(di(0, t),
|
|
'function' !== typeof r &&
|
|
(null === Qu ? (Qu = new Set([this])) : Qu.add(this)));
|
|
var e = t.stack;
|
|
this.componentDidCatch(t.value, {
|
|
componentStack: null !== e ? e : '',
|
|
});
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
function vi(e, t, n) {
|
|
var r = e.pingCache;
|
|
if (null === r) {
|
|
r = e.pingCache = new pi();
|
|
var l = new Set();
|
|
r.set(t, l);
|
|
} else void 0 === (l = r.get(t)) && ((l = new Set()), r.set(t, l));
|
|
l.has(n) || (l.add(n), (e = _s.bind(null, e, t, n)), t.then(e, e));
|
|
}
|
|
function gi(e) {
|
|
do {
|
|
var t;
|
|
if (
|
|
((t = 13 === e.tag) &&
|
|
(t = null === (t = e.memoizedState) || null !== t.dehydrated),
|
|
t)
|
|
)
|
|
return e;
|
|
e = e.return;
|
|
} while (null !== e);
|
|
return null;
|
|
}
|
|
function yi(e, t, n, r, l) {
|
|
return 0 === (1 & e.mode)
|
|
? (e === t
|
|
? (e.flags |= 65536)
|
|
: ((e.flags |= 128),
|
|
(n.flags |= 131072),
|
|
(n.flags &= -52805),
|
|
1 === n.tag &&
|
|
(null === n.alternate
|
|
? (n.tag = 17)
|
|
: (((t = Da(-1, 1)).tag = 2), Ra(n, t, 1))),
|
|
(n.lanes |= 1)),
|
|
e)
|
|
: ((e.flags |= 65536), (e.lanes = l), e);
|
|
}
|
|
var bi = k.ReactCurrentOwner,
|
|
ki = !1;
|
|
function wi(e, t, n, r) {
|
|
t.child = null === e ? Ga(t, null, n, r) : Xa(t, e.child, n, r);
|
|
}
|
|
function Si(e, t, n, r, l) {
|
|
n = n.render;
|
|
var a = t.ref;
|
|
return (
|
|
Ea(t, l),
|
|
(r = Eo(e, t, n, r, a, l)),
|
|
(n = Co()),
|
|
null === e || ki
|
|
? (la && n && ea(t), (t.flags |= 1), wi(e, t, r, l), t.child)
|
|
: ((t.updateQueue = e.updateQueue),
|
|
(t.flags &= -2053),
|
|
(e.lanes &= ~l),
|
|
Wi(e, t, l))
|
|
);
|
|
}
|
|
function xi(e, t, n, r, l) {
|
|
if (null === e) {
|
|
var a = n.type;
|
|
return 'function' !== typeof a ||
|
|
Ds(a) ||
|
|
void 0 !== a.defaultProps ||
|
|
null !== n.compare ||
|
|
void 0 !== n.defaultProps
|
|
? (((e = Os(n.type, null, r, t, t.mode, l)).ref = t.ref),
|
|
(e.return = t),
|
|
(t.child = e))
|
|
: ((t.tag = 15), (t.type = a), Ei(e, t, a, r, l));
|
|
}
|
|
if (((a = e.child), 0 === (e.lanes & l))) {
|
|
var o = a.memoizedProps;
|
|
if (
|
|
(n = null !== (n = n.compare) ? n : ur)(o, r) &&
|
|
e.ref === t.ref
|
|
)
|
|
return Wi(e, t, l);
|
|
}
|
|
return (
|
|
(t.flags |= 1),
|
|
((e = Rs(a, r)).ref = t.ref),
|
|
(e.return = t),
|
|
(t.child = e)
|
|
);
|
|
}
|
|
function Ei(e, t, n, r, l) {
|
|
if (null !== e) {
|
|
var a = e.memoizedProps;
|
|
if (ur(a, r) && e.ref === t.ref) {
|
|
if (((ki = !1), (t.pendingProps = r = a), 0 === (e.lanes & l)))
|
|
return ((t.lanes = e.lanes), Wi(e, t, l));
|
|
0 !== (131072 & e.flags) && (ki = !0);
|
|
}
|
|
}
|
|
return Pi(e, t, n, r, l);
|
|
}
|
|
function Ci(e, t, n) {
|
|
var r = t.pendingProps,
|
|
l = r.children,
|
|
a = null !== e ? e.memoizedState : null;
|
|
if ('hidden' === r.mode)
|
|
if (0 === (1 & t.mode))
|
|
((t.memoizedState = {
|
|
baseLanes: 0,
|
|
cachePool: null,
|
|
transitions: null,
|
|
}),
|
|
_l(Ru, Du),
|
|
(Du |= n));
|
|
else {
|
|
if (0 === (1073741824 & n))
|
|
return (
|
|
(e = null !== a ? a.baseLanes | n : n),
|
|
(t.lanes = t.childLanes = 1073741824),
|
|
(t.memoizedState = {
|
|
baseLanes: e,
|
|
cachePool: null,
|
|
transitions: null,
|
|
}),
|
|
(t.updateQueue = null),
|
|
_l(Ru, Du),
|
|
(Du |= e),
|
|
null
|
|
);
|
|
((t.memoizedState = {
|
|
baseLanes: 0,
|
|
cachePool: null,
|
|
transitions: null,
|
|
}),
|
|
(r = null !== a ? a.baseLanes : n),
|
|
_l(Ru, Du),
|
|
(Du |= r));
|
|
}
|
|
else
|
|
(null !== a
|
|
? ((r = a.baseLanes | n), (t.memoizedState = null))
|
|
: (r = n),
|
|
_l(Ru, Du),
|
|
(Du |= r));
|
|
return (wi(e, t, l, n), t.child);
|
|
}
|
|
function _i(e, t) {
|
|
var n = t.ref;
|
|
((null === e && null !== n) || (null !== e && e.ref !== n)) &&
|
|
((t.flags |= 512), (t.flags |= 2097152));
|
|
}
|
|
function Pi(e, t, n, r, l) {
|
|
var a = Ll(n) ? Tl : Nl.current;
|
|
return (
|
|
(a = Ml(t, a)),
|
|
Ea(t, l),
|
|
(n = Eo(e, t, n, r, a, l)),
|
|
(r = Co()),
|
|
null === e || ki
|
|
? (la && r && ea(t), (t.flags |= 1), wi(e, t, n, l), t.child)
|
|
: ((t.updateQueue = e.updateQueue),
|
|
(t.flags &= -2053),
|
|
(e.lanes &= ~l),
|
|
Wi(e, t, l))
|
|
);
|
|
}
|
|
function Ni(e, t, n, r, l) {
|
|
if (Ll(n)) {
|
|
var a = !0;
|
|
Fl(t);
|
|
} else a = !1;
|
|
if ((Ea(t, l), null === t.stateNode))
|
|
(Hi(e, t), $a(t, n, r), Wa(t, n, r, l), (r = !0));
|
|
else if (null === e) {
|
|
var o = t.stateNode,
|
|
i = t.memoizedProps;
|
|
o.props = i;
|
|
var u = o.context,
|
|
s = n.contextType;
|
|
'object' === typeof s && null !== s
|
|
? (s = Ca(s))
|
|
: (s = Ml(t, (s = Ll(n) ? Tl : Nl.current)));
|
|
var c = n.getDerivedStateFromProps,
|
|
f =
|
|
'function' === typeof c ||
|
|
'function' === typeof o.getSnapshotBeforeUpdate;
|
|
(f ||
|
|
('function' !== typeof o.UNSAFE_componentWillReceiveProps &&
|
|
'function' !== typeof o.componentWillReceiveProps) ||
|
|
((i !== r || u !== s) && Ha(t, o, r, s)),
|
|
(Ta = !1));
|
|
var d = t.memoizedState;
|
|
((o.state = d),
|
|
Ia(t, r, o, l),
|
|
(u = t.memoizedState),
|
|
i !== r || d !== u || zl.current || Ta
|
|
? ('function' === typeof c &&
|
|
(Aa(t, n, c, r), (u = t.memoizedState)),
|
|
(i = Ta || Va(t, n, i, r, d, u, s))
|
|
? (f ||
|
|
('function' !== typeof o.UNSAFE_componentWillMount &&
|
|
'function' !== typeof o.componentWillMount) ||
|
|
('function' === typeof o.componentWillMount &&
|
|
o.componentWillMount(),
|
|
'function' === typeof o.UNSAFE_componentWillMount &&
|
|
o.UNSAFE_componentWillMount()),
|
|
'function' === typeof o.componentDidMount &&
|
|
(t.flags |= 4194308))
|
|
: ('function' === typeof o.componentDidMount &&
|
|
(t.flags |= 4194308),
|
|
(t.memoizedProps = r),
|
|
(t.memoizedState = u)),
|
|
(o.props = r),
|
|
(o.state = u),
|
|
(o.context = s),
|
|
(r = i))
|
|
: ('function' === typeof o.componentDidMount &&
|
|
(t.flags |= 4194308),
|
|
(r = !1)));
|
|
} else {
|
|
((o = t.stateNode),
|
|
La(e, t),
|
|
(i = t.memoizedProps),
|
|
(s = t.type === t.elementType ? i : va(t.type, i)),
|
|
(o.props = s),
|
|
(f = t.pendingProps),
|
|
(d = o.context),
|
|
'object' === typeof (u = n.contextType) && null !== u
|
|
? (u = Ca(u))
|
|
: (u = Ml(t, (u = Ll(n) ? Tl : Nl.current))));
|
|
var p = n.getDerivedStateFromProps;
|
|
((c =
|
|
'function' === typeof p ||
|
|
'function' === typeof o.getSnapshotBeforeUpdate) ||
|
|
('function' !== typeof o.UNSAFE_componentWillReceiveProps &&
|
|
'function' !== typeof o.componentWillReceiveProps) ||
|
|
((i !== f || d !== u) && Ha(t, o, r, u)),
|
|
(Ta = !1),
|
|
(d = t.memoizedState),
|
|
(o.state = d),
|
|
Ia(t, r, o, l));
|
|
var h = t.memoizedState;
|
|
i !== f || d !== h || zl.current || Ta
|
|
? ('function' === typeof p &&
|
|
(Aa(t, n, p, r), (h = t.memoizedState)),
|
|
(s = Ta || Va(t, n, s, r, d, h, u) || !1)
|
|
? (c ||
|
|
('function' !== typeof o.UNSAFE_componentWillUpdate &&
|
|
'function' !== typeof o.componentWillUpdate) ||
|
|
('function' === typeof o.componentWillUpdate &&
|
|
o.componentWillUpdate(r, h, u),
|
|
'function' === typeof o.UNSAFE_componentWillUpdate &&
|
|
o.UNSAFE_componentWillUpdate(r, h, u)),
|
|
'function' === typeof o.componentDidUpdate &&
|
|
(t.flags |= 4),
|
|
'function' === typeof o.getSnapshotBeforeUpdate &&
|
|
(t.flags |= 1024))
|
|
: ('function' !== typeof o.componentDidUpdate ||
|
|
(i === e.memoizedProps && d === e.memoizedState) ||
|
|
(t.flags |= 4),
|
|
'function' !== typeof o.getSnapshotBeforeUpdate ||
|
|
(i === e.memoizedProps && d === e.memoizedState) ||
|
|
(t.flags |= 1024),
|
|
(t.memoizedProps = r),
|
|
(t.memoizedState = h)),
|
|
(o.props = r),
|
|
(o.state = h),
|
|
(o.context = u),
|
|
(r = s))
|
|
: ('function' !== typeof o.componentDidUpdate ||
|
|
(i === e.memoizedProps && d === e.memoizedState) ||
|
|
(t.flags |= 4),
|
|
'function' !== typeof o.getSnapshotBeforeUpdate ||
|
|
(i === e.memoizedProps && d === e.memoizedState) ||
|
|
(t.flags |= 1024),
|
|
(r = !1));
|
|
}
|
|
return zi(e, t, n, r, a, l);
|
|
}
|
|
function zi(e, t, n, r, l, a) {
|
|
_i(e, t);
|
|
var o = 0 !== (128 & t.flags);
|
|
if (!r && !o) return (l && Il(t, n, !1), Wi(e, t, a));
|
|
((r = t.stateNode), (bi.current = t));
|
|
var i =
|
|
o && 'function' !== typeof n.getDerivedStateFromError
|
|
? null
|
|
: r.render();
|
|
return (
|
|
(t.flags |= 1),
|
|
null !== e && o
|
|
? ((t.child = Xa(t, e.child, null, a)),
|
|
(t.child = Xa(t, null, i, a)))
|
|
: wi(e, t, i, a),
|
|
(t.memoizedState = r.state),
|
|
l && Il(t, n, !0),
|
|
t.child
|
|
);
|
|
}
|
|
function Ti(e) {
|
|
var t = e.stateNode;
|
|
(t.pendingContext
|
|
? Rl(0, t.pendingContext, t.pendingContext !== t.context)
|
|
: t.context && Rl(0, t.context, !1),
|
|
ro(e, t.containerInfo));
|
|
}
|
|
function Mi(e, t, n, r, l) {
|
|
return (pa(), ha(l), (t.flags |= 256), wi(e, t, n, r), t.child);
|
|
}
|
|
var Li,
|
|
Di,
|
|
Ri,
|
|
Oi,
|
|
Fi = { dehydrated: null, treeContext: null, retryLane: 0 };
|
|
function Ii(e) {
|
|
return { baseLanes: e, cachePool: null, transitions: null };
|
|
}
|
|
function Ui(e, t, n) {
|
|
var r,
|
|
l = t.pendingProps,
|
|
o = io.current,
|
|
i = !1,
|
|
u = 0 !== (128 & t.flags);
|
|
if (
|
|
((r = u) ||
|
|
(r = (null === e || null !== e.memoizedState) && 0 !== (2 & o)),
|
|
r
|
|
? ((i = !0), (t.flags &= -129))
|
|
: (null !== e && null === e.memoizedState) || (o |= 1),
|
|
_l(io, 1 & o),
|
|
null === e)
|
|
)
|
|
return (
|
|
sa(t),
|
|
null !== (e = t.memoizedState) && null !== (e = e.dehydrated)
|
|
? (0 === (1 & t.mode)
|
|
? (t.lanes = 1)
|
|
: '$!' === e.data
|
|
? (t.lanes = 8)
|
|
: (t.lanes = 1073741824),
|
|
null)
|
|
: ((u = l.children),
|
|
(e = l.fallback),
|
|
i
|
|
? ((l = t.mode),
|
|
(i = t.child),
|
|
(u = { mode: 'hidden', children: u }),
|
|
0 === (1 & l) && null !== i
|
|
? ((i.childLanes = 0), (i.pendingProps = u))
|
|
: (i = Is(u, l, 0, null)),
|
|
(e = Fs(e, l, n, null)),
|
|
(i.return = t),
|
|
(e.return = t),
|
|
(i.sibling = e),
|
|
(t.child = i),
|
|
(t.child.memoizedState = Ii(n)),
|
|
(t.memoizedState = Fi),
|
|
e)
|
|
: ji(t, u))
|
|
);
|
|
if (null !== (o = e.memoizedState) && null !== (r = o.dehydrated))
|
|
return (function (e, t, n, r, l, o, i) {
|
|
if (n)
|
|
return 256 & t.flags
|
|
? ((t.flags &= -257), Ai(e, t, i, (r = fi(Error(a(422))))))
|
|
: null !== t.memoizedState
|
|
? ((t.child = e.child), (t.flags |= 128), null)
|
|
: ((o = r.fallback),
|
|
(l = t.mode),
|
|
(r = Is(
|
|
{ mode: 'visible', children: r.children },
|
|
l,
|
|
0,
|
|
null
|
|
)),
|
|
((o = Fs(o, l, i, null)).flags |= 2),
|
|
(r.return = t),
|
|
(o.return = t),
|
|
(r.sibling = o),
|
|
(t.child = r),
|
|
0 !== (1 & t.mode) && Xa(t, e.child, null, i),
|
|
(t.child.memoizedState = Ii(i)),
|
|
(t.memoizedState = Fi),
|
|
o);
|
|
if (0 === (1 & t.mode)) return Ai(e, t, i, null);
|
|
if ('$!' === l.data) {
|
|
if ((r = l.nextSibling && l.nextSibling.dataset))
|
|
var u = r.dgst;
|
|
return (
|
|
(r = u),
|
|
Ai(e, t, i, (r = fi((o = Error(a(419))), r, void 0)))
|
|
);
|
|
}
|
|
if (((u = 0 !== (i & e.childLanes)), ki || u)) {
|
|
if (null !== (r = Tu)) {
|
|
switch (i & -i) {
|
|
case 4:
|
|
l = 2;
|
|
break;
|
|
case 16:
|
|
l = 8;
|
|
break;
|
|
case 64:
|
|
case 128:
|
|
case 256:
|
|
case 512:
|
|
case 1024:
|
|
case 2048:
|
|
case 4096:
|
|
case 8192:
|
|
case 16384:
|
|
case 32768:
|
|
case 65536:
|
|
case 131072:
|
|
case 262144:
|
|
case 524288:
|
|
case 1048576:
|
|
case 2097152:
|
|
case 4194304:
|
|
case 8388608:
|
|
case 16777216:
|
|
case 33554432:
|
|
case 67108864:
|
|
l = 32;
|
|
break;
|
|
case 536870912:
|
|
l = 268435456;
|
|
break;
|
|
default:
|
|
l = 0;
|
|
}
|
|
0 !== (l = 0 !== (l & (r.suspendedLanes | i)) ? 0 : l) &&
|
|
l !== o.retryLane &&
|
|
((o.retryLane = l), za(e, l), rs(r, e, l, -1));
|
|
}
|
|
return (vs(), Ai(e, t, i, (r = fi(Error(a(421))))));
|
|
}
|
|
return '$?' === l.data
|
|
? ((t.flags |= 128),
|
|
(t.child = e.child),
|
|
(t = Ns.bind(null, e)),
|
|
(l._reactRetry = t),
|
|
null)
|
|
: ((e = o.treeContext),
|
|
(ra = sl(l.nextSibling)),
|
|
(na = t),
|
|
(la = !0),
|
|
(aa = null),
|
|
null !== e &&
|
|
((Ql[ql++] = Xl),
|
|
(Ql[ql++] = Gl),
|
|
(Ql[ql++] = Yl),
|
|
(Xl = e.id),
|
|
(Gl = e.overflow),
|
|
(Yl = t)),
|
|
(t = ji(t, r.children)),
|
|
(t.flags |= 4096),
|
|
t);
|
|
})(e, t, u, l, r, o, n);
|
|
if (i) {
|
|
((i = l.fallback), (u = t.mode), (r = (o = e.child).sibling));
|
|
var s = { mode: 'hidden', children: l.children };
|
|
return (
|
|
0 === (1 & u) && t.child !== o
|
|
? (((l = t.child).childLanes = 0),
|
|
(l.pendingProps = s),
|
|
(t.deletions = null))
|
|
: ((l = Rs(o, s)).subtreeFlags = 14680064 & o.subtreeFlags),
|
|
null !== r
|
|
? (i = Rs(r, i))
|
|
: ((i = Fs(i, u, n, null)).flags |= 2),
|
|
(i.return = t),
|
|
(l.return = t),
|
|
(l.sibling = i),
|
|
(t.child = l),
|
|
(l = i),
|
|
(i = t.child),
|
|
(u =
|
|
null === (u = e.child.memoizedState)
|
|
? Ii(n)
|
|
: {
|
|
baseLanes: u.baseLanes | n,
|
|
cachePool: null,
|
|
transitions: u.transitions,
|
|
}),
|
|
(i.memoizedState = u),
|
|
(i.childLanes = e.childLanes & ~n),
|
|
(t.memoizedState = Fi),
|
|
l
|
|
);
|
|
}
|
|
return (
|
|
(e = (i = e.child).sibling),
|
|
(l = Rs(i, { mode: 'visible', children: l.children })),
|
|
0 === (1 & t.mode) && (l.lanes = n),
|
|
(l.return = t),
|
|
(l.sibling = null),
|
|
null !== e &&
|
|
(null === (n = t.deletions)
|
|
? ((t.deletions = [e]), (t.flags |= 16))
|
|
: n.push(e)),
|
|
(t.child = l),
|
|
(t.memoizedState = null),
|
|
l
|
|
);
|
|
}
|
|
function ji(e, t) {
|
|
return (
|
|
((t = Is(
|
|
{ mode: 'visible', children: t },
|
|
e.mode,
|
|
0,
|
|
null
|
|
)).return = e),
|
|
(e.child = t)
|
|
);
|
|
}
|
|
function Ai(e, t, n, r) {
|
|
return (
|
|
null !== r && ha(r),
|
|
Xa(t, e.child, null, n),
|
|
((e = ji(t, t.pendingProps.children)).flags |= 2),
|
|
(t.memoizedState = null),
|
|
e
|
|
);
|
|
}
|
|
function Bi(e, t, n) {
|
|
e.lanes |= t;
|
|
var r = e.alternate;
|
|
(null !== r && (r.lanes |= t), xa(e.return, t, n));
|
|
}
|
|
function Vi(e, t, n, r, l) {
|
|
var a = e.memoizedState;
|
|
null === a
|
|
? (e.memoizedState = {
|
|
isBackwards: t,
|
|
rendering: null,
|
|
renderingStartTime: 0,
|
|
last: r,
|
|
tail: n,
|
|
tailMode: l,
|
|
})
|
|
: ((a.isBackwards = t),
|
|
(a.rendering = null),
|
|
(a.renderingStartTime = 0),
|
|
(a.last = r),
|
|
(a.tail = n),
|
|
(a.tailMode = l));
|
|
}
|
|
function $i(e, t, n) {
|
|
var r = t.pendingProps,
|
|
l = r.revealOrder,
|
|
a = r.tail;
|
|
if ((wi(e, t, r.children, n), 0 !== (2 & (r = io.current))))
|
|
((r = (1 & r) | 2), (t.flags |= 128));
|
|
else {
|
|
if (null !== e && 0 !== (128 & e.flags))
|
|
e: for (e = t.child; null !== e; ) {
|
|
if (13 === e.tag) null !== e.memoizedState && Bi(e, n, t);
|
|
else if (19 === e.tag) Bi(e, n, t);
|
|
else if (null !== e.child) {
|
|
((e.child.return = e), (e = e.child));
|
|
continue;
|
|
}
|
|
if (e === t) break e;
|
|
for (; null === e.sibling; ) {
|
|
if (null === e.return || e.return === t) break e;
|
|
e = e.return;
|
|
}
|
|
((e.sibling.return = e.return), (e = e.sibling));
|
|
}
|
|
r &= 1;
|
|
}
|
|
if ((_l(io, r), 0 === (1 & t.mode))) t.memoizedState = null;
|
|
else
|
|
switch (l) {
|
|
case 'forwards':
|
|
for (n = t.child, l = null; null !== n; )
|
|
(null !== (e = n.alternate) && null === uo(e) && (l = n),
|
|
(n = n.sibling));
|
|
(null === (n = l)
|
|
? ((l = t.child), (t.child = null))
|
|
: ((l = n.sibling), (n.sibling = null)),
|
|
Vi(t, !1, l, n, a));
|
|
break;
|
|
case 'backwards':
|
|
for (n = null, l = t.child, t.child = null; null !== l; ) {
|
|
if (null !== (e = l.alternate) && null === uo(e)) {
|
|
t.child = l;
|
|
break;
|
|
}
|
|
((e = l.sibling), (l.sibling = n), (n = l), (l = e));
|
|
}
|
|
Vi(t, !0, n, null, a);
|
|
break;
|
|
case 'together':
|
|
Vi(t, !1, null, null, void 0);
|
|
break;
|
|
default:
|
|
t.memoizedState = null;
|
|
}
|
|
return t.child;
|
|
}
|
|
function Hi(e, t) {
|
|
0 === (1 & t.mode) &&
|
|
null !== e &&
|
|
((e.alternate = null), (t.alternate = null), (t.flags |= 2));
|
|
}
|
|
function Wi(e, t, n) {
|
|
if (
|
|
(null !== e && (t.dependencies = e.dependencies),
|
|
(Iu |= t.lanes),
|
|
0 === (n & t.childLanes))
|
|
)
|
|
return null;
|
|
if (null !== e && t.child !== e.child) throw Error(a(153));
|
|
if (null !== t.child) {
|
|
for (
|
|
n = Rs((e = t.child), e.pendingProps), t.child = n, n.return = t;
|
|
null !== e.sibling;
|
|
)
|
|
((e = e.sibling),
|
|
((n = n.sibling = Rs(e, e.pendingProps)).return = t));
|
|
n.sibling = null;
|
|
}
|
|
return t.child;
|
|
}
|
|
function Ki(e, t) {
|
|
if (!la)
|
|
switch (e.tailMode) {
|
|
case 'hidden':
|
|
t = e.tail;
|
|
for (var n = null; null !== t; )
|
|
(null !== t.alternate && (n = t), (t = t.sibling));
|
|
null === n ? (e.tail = null) : (n.sibling = null);
|
|
break;
|
|
case 'collapsed':
|
|
n = e.tail;
|
|
for (var r = null; null !== n; )
|
|
(null !== n.alternate && (r = n), (n = n.sibling));
|
|
null === r
|
|
? t || null === e.tail
|
|
? (e.tail = null)
|
|
: (e.tail.sibling = null)
|
|
: (r.sibling = null);
|
|
}
|
|
}
|
|
function Qi(e) {
|
|
var t = null !== e.alternate && e.alternate.child === e.child,
|
|
n = 0,
|
|
r = 0;
|
|
if (t)
|
|
for (var l = e.child; null !== l; )
|
|
((n |= l.lanes | l.childLanes),
|
|
(r |= 14680064 & l.subtreeFlags),
|
|
(r |= 14680064 & l.flags),
|
|
(l.return = e),
|
|
(l = l.sibling));
|
|
else
|
|
for (l = e.child; null !== l; )
|
|
((n |= l.lanes | l.childLanes),
|
|
(r |= l.subtreeFlags),
|
|
(r |= l.flags),
|
|
(l.return = e),
|
|
(l = l.sibling));
|
|
return ((e.subtreeFlags |= r), (e.childLanes = n), t);
|
|
}
|
|
function qi(e, t, n) {
|
|
var r = t.pendingProps;
|
|
switch ((ta(t), t.tag)) {
|
|
case 2:
|
|
case 16:
|
|
case 15:
|
|
case 0:
|
|
case 11:
|
|
case 7:
|
|
case 8:
|
|
case 12:
|
|
case 9:
|
|
case 14:
|
|
return (Qi(t), null);
|
|
case 1:
|
|
case 17:
|
|
return (Ll(t.type) && Dl(), Qi(t), null);
|
|
case 3:
|
|
return (
|
|
(r = t.stateNode),
|
|
lo(),
|
|
Cl(zl),
|
|
Cl(Nl),
|
|
co(),
|
|
r.pendingContext &&
|
|
((r.context = r.pendingContext), (r.pendingContext = null)),
|
|
(null !== e && null !== e.child) ||
|
|
(fa(t)
|
|
? (t.flags |= 4)
|
|
: null === e ||
|
|
(e.memoizedState.isDehydrated && 0 === (256 & t.flags)) ||
|
|
((t.flags |= 1024),
|
|
null !== aa && (is(aa), (aa = null)))),
|
|
Di(e, t),
|
|
Qi(t),
|
|
null
|
|
);
|
|
case 5:
|
|
oo(t);
|
|
var l = no(to.current);
|
|
if (((n = t.type), null !== e && null != t.stateNode))
|
|
(Ri(e, t, n, r, l),
|
|
e.ref !== t.ref && ((t.flags |= 512), (t.flags |= 2097152)));
|
|
else {
|
|
if (!r) {
|
|
if (null === t.stateNode) throw Error(a(166));
|
|
return (Qi(t), null);
|
|
}
|
|
if (((e = no(Ja.current)), fa(t))) {
|
|
((r = t.stateNode), (n = t.type));
|
|
var o = t.memoizedProps;
|
|
switch (
|
|
((r[dl] = t), (r[pl] = o), (e = 0 !== (1 & t.mode)), n)
|
|
) {
|
|
case 'dialog':
|
|
(jr('cancel', r), jr('close', r));
|
|
break;
|
|
case 'iframe':
|
|
case 'object':
|
|
case 'embed':
|
|
jr('load', r);
|
|
break;
|
|
case 'video':
|
|
case 'audio':
|
|
for (l = 0; l < Or.length; l++) jr(Or[l], r);
|
|
break;
|
|
case 'source':
|
|
jr('error', r);
|
|
break;
|
|
case 'img':
|
|
case 'image':
|
|
case 'link':
|
|
(jr('error', r), jr('load', r));
|
|
break;
|
|
case 'details':
|
|
jr('toggle', r);
|
|
break;
|
|
case 'input':
|
|
(X(r, o), jr('invalid', r));
|
|
break;
|
|
case 'select':
|
|
((r._wrapperState = { wasMultiple: !!o.multiple }),
|
|
jr('invalid', r));
|
|
break;
|
|
case 'textarea':
|
|
(le(r, o), jr('invalid', r));
|
|
}
|
|
for (var u in (ye(n, o), (l = null), o))
|
|
if (o.hasOwnProperty(u)) {
|
|
var s = o[u];
|
|
'children' === u
|
|
? 'string' === typeof s
|
|
? r.textContent !== s &&
|
|
(!0 !== o.suppressHydrationWarning &&
|
|
Zr(r.textContent, s, e),
|
|
(l = ['children', s]))
|
|
: 'number' === typeof s &&
|
|
r.textContent !== '' + s &&
|
|
(!0 !== o.suppressHydrationWarning &&
|
|
Zr(r.textContent, s, e),
|
|
(l = ['children', '' + s]))
|
|
: i.hasOwnProperty(u) &&
|
|
null != s &&
|
|
'onScroll' === u &&
|
|
jr('scroll', r);
|
|
}
|
|
switch (n) {
|
|
case 'input':
|
|
(K(r), J(r, o, !0));
|
|
break;
|
|
case 'textarea':
|
|
(K(r), oe(r));
|
|
break;
|
|
case 'select':
|
|
case 'option':
|
|
break;
|
|
default:
|
|
'function' === typeof o.onClick && (r.onclick = Jr);
|
|
}
|
|
((r = l), (t.updateQueue = r), null !== r && (t.flags |= 4));
|
|
} else {
|
|
((u = 9 === l.nodeType ? l : l.ownerDocument),
|
|
'http://www.w3.org/1999/xhtml' === e && (e = ie(n)),
|
|
'http://www.w3.org/1999/xhtml' === e
|
|
? 'script' === n
|
|
? (((e = u.createElement('div')).innerHTML =
|
|
'<script><\/script>'),
|
|
(e = e.removeChild(e.firstChild)))
|
|
: 'string' === typeof r.is
|
|
? (e = u.createElement(n, { is: r.is }))
|
|
: ((e = u.createElement(n)),
|
|
'select' === n &&
|
|
((u = e),
|
|
r.multiple
|
|
? (u.multiple = !0)
|
|
: r.size && (u.size = r.size)))
|
|
: (e = u.createElementNS(e, n)),
|
|
(e[dl] = t),
|
|
(e[pl] = r),
|
|
Li(e, t, !1, !1),
|
|
(t.stateNode = e));
|
|
e: {
|
|
switch (((u = be(n, r)), n)) {
|
|
case 'dialog':
|
|
(jr('cancel', e), jr('close', e), (l = r));
|
|
break;
|
|
case 'iframe':
|
|
case 'object':
|
|
case 'embed':
|
|
(jr('load', e), (l = r));
|
|
break;
|
|
case 'video':
|
|
case 'audio':
|
|
for (l = 0; l < Or.length; l++) jr(Or[l], e);
|
|
l = r;
|
|
break;
|
|
case 'source':
|
|
(jr('error', e), (l = r));
|
|
break;
|
|
case 'img':
|
|
case 'image':
|
|
case 'link':
|
|
(jr('error', e), jr('load', e), (l = r));
|
|
break;
|
|
case 'details':
|
|
(jr('toggle', e), (l = r));
|
|
break;
|
|
case 'input':
|
|
(X(e, r), (l = Y(e, r)), jr('invalid', e));
|
|
break;
|
|
case 'option':
|
|
default:
|
|
l = r;
|
|
break;
|
|
case 'select':
|
|
((e._wrapperState = { wasMultiple: !!r.multiple }),
|
|
(l = I({}, r, { value: void 0 })),
|
|
jr('invalid', e));
|
|
break;
|
|
case 'textarea':
|
|
(le(e, r), (l = re(e, r)), jr('invalid', e));
|
|
}
|
|
for (o in (ye(n, l), (s = l)))
|
|
if (s.hasOwnProperty(o)) {
|
|
var c = s[o];
|
|
'style' === o
|
|
? ve(e, c)
|
|
: 'dangerouslySetInnerHTML' === o
|
|
? null != (c = c ? c.__html : void 0) && fe(e, c)
|
|
: 'children' === o
|
|
? 'string' === typeof c
|
|
? ('textarea' !== n || '' !== c) && de(e, c)
|
|
: 'number' === typeof c && de(e, '' + c)
|
|
: 'suppressContentEditableWarning' !== o &&
|
|
'suppressHydrationWarning' !== o &&
|
|
'autoFocus' !== o &&
|
|
(i.hasOwnProperty(o)
|
|
? null != c &&
|
|
'onScroll' === o &&
|
|
jr('scroll', e)
|
|
: null != c && b(e, o, c, u));
|
|
}
|
|
switch (n) {
|
|
case 'input':
|
|
(K(e), J(e, r, !1));
|
|
break;
|
|
case 'textarea':
|
|
(K(e), oe(e));
|
|
break;
|
|
case 'option':
|
|
null != r.value &&
|
|
e.setAttribute('value', '' + H(r.value));
|
|
break;
|
|
case 'select':
|
|
((e.multiple = !!r.multiple),
|
|
null != (o = r.value)
|
|
? ne(e, !!r.multiple, o, !1)
|
|
: null != r.defaultValue &&
|
|
ne(e, !!r.multiple, r.defaultValue, !0));
|
|
break;
|
|
default:
|
|
'function' === typeof l.onClick && (e.onclick = Jr);
|
|
}
|
|
switch (n) {
|
|
case 'button':
|
|
case 'input':
|
|
case 'select':
|
|
case 'textarea':
|
|
r = !!r.autoFocus;
|
|
break e;
|
|
case 'img':
|
|
r = !0;
|
|
break e;
|
|
default:
|
|
r = !1;
|
|
}
|
|
}
|
|
r && (t.flags |= 4);
|
|
}
|
|
null !== t.ref && ((t.flags |= 512), (t.flags |= 2097152));
|
|
}
|
|
return (Qi(t), null);
|
|
case 6:
|
|
if (e && null != t.stateNode) Oi(e, t, e.memoizedProps, r);
|
|
else {
|
|
if ('string' !== typeof r && null === t.stateNode)
|
|
throw Error(a(166));
|
|
if (((n = no(to.current)), no(Ja.current), fa(t))) {
|
|
if (
|
|
((r = t.stateNode),
|
|
(n = t.memoizedProps),
|
|
(r[dl] = t),
|
|
(o = r.nodeValue !== n) && null !== (e = na))
|
|
)
|
|
switch (e.tag) {
|
|
case 3:
|
|
Zr(r.nodeValue, n, 0 !== (1 & e.mode));
|
|
break;
|
|
case 5:
|
|
!0 !== e.memoizedProps.suppressHydrationWarning &&
|
|
Zr(r.nodeValue, n, 0 !== (1 & e.mode));
|
|
}
|
|
o && (t.flags |= 4);
|
|
} else
|
|
(((r = (
|
|
9 === n.nodeType ? n : n.ownerDocument
|
|
).createTextNode(r))[dl] = t),
|
|
(t.stateNode = r));
|
|
}
|
|
return (Qi(t), null);
|
|
case 13:
|
|
if (
|
|
(Cl(io),
|
|
(r = t.memoizedState),
|
|
null === e ||
|
|
(null !== e.memoizedState &&
|
|
null !== e.memoizedState.dehydrated))
|
|
) {
|
|
if (
|
|
la &&
|
|
null !== ra &&
|
|
0 !== (1 & t.mode) &&
|
|
0 === (128 & t.flags)
|
|
)
|
|
(da(), pa(), (t.flags |= 98560), (o = !1));
|
|
else if (((o = fa(t)), null !== r && null !== r.dehydrated)) {
|
|
if (null === e) {
|
|
if (!o) throw Error(a(318));
|
|
if (
|
|
!(o =
|
|
null !== (o = t.memoizedState) ? o.dehydrated : null)
|
|
)
|
|
throw Error(a(317));
|
|
o[dl] = t;
|
|
} else
|
|
(pa(),
|
|
0 === (128 & t.flags) && (t.memoizedState = null),
|
|
(t.flags |= 4));
|
|
(Qi(t), (o = !1));
|
|
} else (null !== aa && (is(aa), (aa = null)), (o = !0));
|
|
if (!o) return 65536 & t.flags ? t : null;
|
|
}
|
|
return 0 !== (128 & t.flags)
|
|
? ((t.lanes = n), t)
|
|
: ((r = null !== r) !==
|
|
(null !== e && null !== e.memoizedState) &&
|
|
r &&
|
|
((t.child.flags |= 8192),
|
|
0 !== (1 & t.mode) &&
|
|
(null === e || 0 !== (1 & io.current)
|
|
? 0 === Ou && (Ou = 3)
|
|
: vs())),
|
|
null !== t.updateQueue && (t.flags |= 4),
|
|
Qi(t),
|
|
null);
|
|
case 4:
|
|
return (
|
|
lo(),
|
|
Di(e, t),
|
|
null === e && Vr(t.stateNode.containerInfo),
|
|
Qi(t),
|
|
null
|
|
);
|
|
case 10:
|
|
return (Sa(t.type._context), Qi(t), null);
|
|
case 19:
|
|
if ((Cl(io), null === (o = t.memoizedState)))
|
|
return (Qi(t), null);
|
|
if (((r = 0 !== (128 & t.flags)), null === (u = o.rendering)))
|
|
if (r) Ki(o, !1);
|
|
else {
|
|
if (0 !== Ou || (null !== e && 0 !== (128 & e.flags)))
|
|
for (e = t.child; null !== e; ) {
|
|
if (null !== (u = uo(e))) {
|
|
for (
|
|
t.flags |= 128,
|
|
Ki(o, !1),
|
|
null !== (r = u.updateQueue) &&
|
|
((t.updateQueue = r), (t.flags |= 4)),
|
|
t.subtreeFlags = 0,
|
|
r = n,
|
|
n = t.child;
|
|
null !== n;
|
|
)
|
|
((e = r),
|
|
((o = n).flags &= 14680066),
|
|
null === (u = o.alternate)
|
|
? ((o.childLanes = 0),
|
|
(o.lanes = e),
|
|
(o.child = null),
|
|
(o.subtreeFlags = 0),
|
|
(o.memoizedProps = null),
|
|
(o.memoizedState = null),
|
|
(o.updateQueue = null),
|
|
(o.dependencies = null),
|
|
(o.stateNode = null))
|
|
: ((o.childLanes = u.childLanes),
|
|
(o.lanes = u.lanes),
|
|
(o.child = u.child),
|
|
(o.subtreeFlags = 0),
|
|
(o.deletions = null),
|
|
(o.memoizedProps = u.memoizedProps),
|
|
(o.memoizedState = u.memoizedState),
|
|
(o.updateQueue = u.updateQueue),
|
|
(o.type = u.type),
|
|
(e = u.dependencies),
|
|
(o.dependencies =
|
|
null === e
|
|
? null
|
|
: {
|
|
lanes: e.lanes,
|
|
firstContext: e.firstContext,
|
|
})),
|
|
(n = n.sibling));
|
|
return (_l(io, (1 & io.current) | 2), t.child);
|
|
}
|
|
e = e.sibling;
|
|
}
|
|
null !== o.tail &&
|
|
Ge() > $u &&
|
|
((t.flags |= 128),
|
|
(r = !0),
|
|
Ki(o, !1),
|
|
(t.lanes = 4194304));
|
|
}
|
|
else {
|
|
if (!r)
|
|
if (null !== (e = uo(u))) {
|
|
if (
|
|
((t.flags |= 128),
|
|
(r = !0),
|
|
null !== (n = e.updateQueue) &&
|
|
((t.updateQueue = n), (t.flags |= 4)),
|
|
Ki(o, !0),
|
|
null === o.tail &&
|
|
'hidden' === o.tailMode &&
|
|
!u.alternate &&
|
|
!la)
|
|
)
|
|
return (Qi(t), null);
|
|
} else
|
|
2 * Ge() - o.renderingStartTime > $u &&
|
|
1073741824 !== n &&
|
|
((t.flags |= 128),
|
|
(r = !0),
|
|
Ki(o, !1),
|
|
(t.lanes = 4194304));
|
|
o.isBackwards
|
|
? ((u.sibling = t.child), (t.child = u))
|
|
: (null !== (n = o.last) ? (n.sibling = u) : (t.child = u),
|
|
(o.last = u));
|
|
}
|
|
return null !== o.tail
|
|
? ((t = o.tail),
|
|
(o.rendering = t),
|
|
(o.tail = t.sibling),
|
|
(o.renderingStartTime = Ge()),
|
|
(t.sibling = null),
|
|
(n = io.current),
|
|
_l(io, r ? (1 & n) | 2 : 1 & n),
|
|
t)
|
|
: (Qi(t), null);
|
|
case 22:
|
|
case 23:
|
|
return (
|
|
ds(),
|
|
(r = null !== t.memoizedState),
|
|
null !== e &&
|
|
(null !== e.memoizedState) !== r &&
|
|
(t.flags |= 8192),
|
|
r && 0 !== (1 & t.mode)
|
|
? 0 !== (1073741824 & Du) &&
|
|
(Qi(t), 6 & t.subtreeFlags && (t.flags |= 8192))
|
|
: Qi(t),
|
|
null
|
|
);
|
|
case 24:
|
|
case 25:
|
|
return null;
|
|
}
|
|
throw Error(a(156, t.tag));
|
|
}
|
|
function Yi(e, t) {
|
|
switch ((ta(t), t.tag)) {
|
|
case 1:
|
|
return (
|
|
Ll(t.type) && Dl(),
|
|
65536 & (e = t.flags)
|
|
? ((t.flags = (-65537 & e) | 128), t)
|
|
: null
|
|
);
|
|
case 3:
|
|
return (
|
|
lo(),
|
|
Cl(zl),
|
|
Cl(Nl),
|
|
co(),
|
|
0 !== (65536 & (e = t.flags)) && 0 === (128 & e)
|
|
? ((t.flags = (-65537 & e) | 128), t)
|
|
: null
|
|
);
|
|
case 5:
|
|
return (oo(t), null);
|
|
case 13:
|
|
if (
|
|
(Cl(io),
|
|
null !== (e = t.memoizedState) && null !== e.dehydrated)
|
|
) {
|
|
if (null === t.alternate) throw Error(a(340));
|
|
pa();
|
|
}
|
|
return 65536 & (e = t.flags)
|
|
? ((t.flags = (-65537 & e) | 128), t)
|
|
: null;
|
|
case 19:
|
|
return (Cl(io), null);
|
|
case 4:
|
|
return (lo(), null);
|
|
case 10:
|
|
return (Sa(t.type._context), null);
|
|
case 22:
|
|
case 23:
|
|
return (ds(), null);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
((Li = function (e, t) {
|
|
for (var n = t.child; null !== n; ) {
|
|
if (5 === n.tag || 6 === n.tag) e.appendChild(n.stateNode);
|
|
else if (4 !== n.tag && null !== n.child) {
|
|
((n.child.return = n), (n = n.child));
|
|
continue;
|
|
}
|
|
if (n === t) break;
|
|
for (; null === n.sibling; ) {
|
|
if (null === n.return || n.return === t) return;
|
|
n = n.return;
|
|
}
|
|
((n.sibling.return = n.return), (n = n.sibling));
|
|
}
|
|
}),
|
|
(Di = function () {}),
|
|
(Ri = function (e, t, n, r) {
|
|
var l = e.memoizedProps;
|
|
if (l !== r) {
|
|
((e = t.stateNode), no(Ja.current));
|
|
var a,
|
|
o = null;
|
|
switch (n) {
|
|
case 'input':
|
|
((l = Y(e, l)), (r = Y(e, r)), (o = []));
|
|
break;
|
|
case 'select':
|
|
((l = I({}, l, { value: void 0 })),
|
|
(r = I({}, r, { value: void 0 })),
|
|
(o = []));
|
|
break;
|
|
case 'textarea':
|
|
((l = re(e, l)), (r = re(e, r)), (o = []));
|
|
break;
|
|
default:
|
|
'function' !== typeof l.onClick &&
|
|
'function' === typeof r.onClick &&
|
|
(e.onclick = Jr);
|
|
}
|
|
for (c in (ye(n, r), (n = null), l))
|
|
if (!r.hasOwnProperty(c) && l.hasOwnProperty(c) && null != l[c])
|
|
if ('style' === c) {
|
|
var u = l[c];
|
|
for (a in u)
|
|
u.hasOwnProperty(a) && (n || (n = {}), (n[a] = ''));
|
|
} else
|
|
'dangerouslySetInnerHTML' !== c &&
|
|
'children' !== c &&
|
|
'suppressContentEditableWarning' !== c &&
|
|
'suppressHydrationWarning' !== c &&
|
|
'autoFocus' !== c &&
|
|
(i.hasOwnProperty(c)
|
|
? o || (o = [])
|
|
: (o = o || []).push(c, null));
|
|
for (c in r) {
|
|
var s = r[c];
|
|
if (
|
|
((u = null != l ? l[c] : void 0),
|
|
r.hasOwnProperty(c) && s !== u && (null != s || null != u))
|
|
)
|
|
if ('style' === c)
|
|
if (u) {
|
|
for (a in u)
|
|
!u.hasOwnProperty(a) ||
|
|
(s && s.hasOwnProperty(a)) ||
|
|
(n || (n = {}), (n[a] = ''));
|
|
for (a in s)
|
|
s.hasOwnProperty(a) &&
|
|
u[a] !== s[a] &&
|
|
(n || (n = {}), (n[a] = s[a]));
|
|
} else (n || (o || (o = []), o.push(c, n)), (n = s));
|
|
else
|
|
'dangerouslySetInnerHTML' === c
|
|
? ((s = s ? s.__html : void 0),
|
|
(u = u ? u.__html : void 0),
|
|
null != s && u !== s && (o = o || []).push(c, s))
|
|
: 'children' === c
|
|
? ('string' !== typeof s && 'number' !== typeof s) ||
|
|
(o = o || []).push(c, '' + s)
|
|
: 'suppressContentEditableWarning' !== c &&
|
|
'suppressHydrationWarning' !== c &&
|
|
(i.hasOwnProperty(c)
|
|
? (null != s && 'onScroll' === c && jr('scroll', e),
|
|
o || u === s || (o = []))
|
|
: (o = o || []).push(c, s));
|
|
}
|
|
n && (o = o || []).push('style', n);
|
|
var c = o;
|
|
(t.updateQueue = c) && (t.flags |= 4);
|
|
}
|
|
}),
|
|
(Oi = function (e, t, n, r) {
|
|
n !== r && (t.flags |= 4);
|
|
}));
|
|
var Xi = !1,
|
|
Gi = !1,
|
|
Zi = 'function' === typeof WeakSet ? WeakSet : Set,
|
|
Ji = null;
|
|
function eu(e, t) {
|
|
var n = e.ref;
|
|
if (null !== n)
|
|
if ('function' === typeof n)
|
|
try {
|
|
n(null);
|
|
} catch (r) {
|
|
Cs(e, t, r);
|
|
}
|
|
else n.current = null;
|
|
}
|
|
function tu(e, t, n) {
|
|
try {
|
|
n();
|
|
} catch (r) {
|
|
Cs(e, t, r);
|
|
}
|
|
}
|
|
var nu = !1;
|
|
function ru(e, t, n) {
|
|
var r = t.updateQueue;
|
|
if (null !== (r = null !== r ? r.lastEffect : null)) {
|
|
var l = (r = r.next);
|
|
do {
|
|
if ((l.tag & e) === e) {
|
|
var a = l.destroy;
|
|
((l.destroy = void 0), void 0 !== a && tu(t, n, a));
|
|
}
|
|
l = l.next;
|
|
} while (l !== r);
|
|
}
|
|
}
|
|
function lu(e, t) {
|
|
if (
|
|
null !== (t = null !== (t = t.updateQueue) ? t.lastEffect : null)
|
|
) {
|
|
var n = (t = t.next);
|
|
do {
|
|
if ((n.tag & e) === e) {
|
|
var r = n.create;
|
|
n.destroy = r();
|
|
}
|
|
n = n.next;
|
|
} while (n !== t);
|
|
}
|
|
}
|
|
function au(e) {
|
|
var t = e.ref;
|
|
if (null !== t) {
|
|
var n = e.stateNode;
|
|
(e.tag, (e = n), 'function' === typeof t ? t(e) : (t.current = e));
|
|
}
|
|
}
|
|
function ou(e) {
|
|
var t = e.alternate;
|
|
(null !== t && ((e.alternate = null), ou(t)),
|
|
(e.child = null),
|
|
(e.deletions = null),
|
|
(e.sibling = null),
|
|
5 === e.tag &&
|
|
null !== (t = e.stateNode) &&
|
|
(delete t[dl],
|
|
delete t[pl],
|
|
delete t[ml],
|
|
delete t[vl],
|
|
delete t[gl]),
|
|
(e.stateNode = null),
|
|
(e.return = null),
|
|
(e.dependencies = null),
|
|
(e.memoizedProps = null),
|
|
(e.memoizedState = null),
|
|
(e.pendingProps = null),
|
|
(e.stateNode = null),
|
|
(e.updateQueue = null));
|
|
}
|
|
function iu(e) {
|
|
return 5 === e.tag || 3 === e.tag || 4 === e.tag;
|
|
}
|
|
function uu(e) {
|
|
e: for (;;) {
|
|
for (; null === e.sibling; ) {
|
|
if (null === e.return || iu(e.return)) return null;
|
|
e = e.return;
|
|
}
|
|
for (
|
|
e.sibling.return = e.return, e = e.sibling;
|
|
5 !== e.tag && 6 !== e.tag && 18 !== e.tag;
|
|
) {
|
|
if (2 & e.flags) continue e;
|
|
if (null === e.child || 4 === e.tag) continue e;
|
|
((e.child.return = e), (e = e.child));
|
|
}
|
|
if (!(2 & e.flags)) return e.stateNode;
|
|
}
|
|
}
|
|
function su(e, t, n) {
|
|
var r = e.tag;
|
|
if (5 === r || 6 === r)
|
|
((e = e.stateNode),
|
|
t
|
|
? 8 === n.nodeType
|
|
? n.parentNode.insertBefore(e, t)
|
|
: n.insertBefore(e, t)
|
|
: (8 === n.nodeType
|
|
? (t = n.parentNode).insertBefore(e, n)
|
|
: (t = n).appendChild(e),
|
|
(null !== (n = n._reactRootContainer) && void 0 !== n) ||
|
|
null !== t.onclick ||
|
|
(t.onclick = Jr)));
|
|
else if (4 !== r && null !== (e = e.child))
|
|
for (su(e, t, n), e = e.sibling; null !== e; )
|
|
(su(e, t, n), (e = e.sibling));
|
|
}
|
|
function cu(e, t, n) {
|
|
var r = e.tag;
|
|
if (5 === r || 6 === r)
|
|
((e = e.stateNode), t ? n.insertBefore(e, t) : n.appendChild(e));
|
|
else if (4 !== r && null !== (e = e.child))
|
|
for (cu(e, t, n), e = e.sibling; null !== e; )
|
|
(cu(e, t, n), (e = e.sibling));
|
|
}
|
|
var fu = null,
|
|
du = !1;
|
|
function pu(e, t, n) {
|
|
for (n = n.child; null !== n; ) (hu(e, t, n), (n = n.sibling));
|
|
}
|
|
function hu(e, t, n) {
|
|
if (at && 'function' === typeof at.onCommitFiberUnmount)
|
|
try {
|
|
at.onCommitFiberUnmount(lt, n);
|
|
} catch (i) {}
|
|
switch (n.tag) {
|
|
case 5:
|
|
Gi || eu(n, t);
|
|
case 6:
|
|
var r = fu,
|
|
l = du;
|
|
((fu = null),
|
|
pu(e, t, n),
|
|
(du = l),
|
|
null !== (fu = r) &&
|
|
(du
|
|
? ((e = fu),
|
|
(n = n.stateNode),
|
|
8 === e.nodeType
|
|
? e.parentNode.removeChild(n)
|
|
: e.removeChild(n))
|
|
: fu.removeChild(n.stateNode)));
|
|
break;
|
|
case 18:
|
|
null !== fu &&
|
|
(du
|
|
? ((e = fu),
|
|
(n = n.stateNode),
|
|
8 === e.nodeType
|
|
? ul(e.parentNode, n)
|
|
: 1 === e.nodeType && ul(e, n),
|
|
Vt(e))
|
|
: ul(fu, n.stateNode));
|
|
break;
|
|
case 4:
|
|
((r = fu),
|
|
(l = du),
|
|
(fu = n.stateNode.containerInfo),
|
|
(du = !0),
|
|
pu(e, t, n),
|
|
(fu = r),
|
|
(du = l));
|
|
break;
|
|
case 0:
|
|
case 11:
|
|
case 14:
|
|
case 15:
|
|
if (
|
|
!Gi &&
|
|
null !== (r = n.updateQueue) &&
|
|
null !== (r = r.lastEffect)
|
|
) {
|
|
l = r = r.next;
|
|
do {
|
|
var a = l,
|
|
o = a.destroy;
|
|
((a = a.tag),
|
|
void 0 !== o &&
|
|
(0 !== (2 & a) || 0 !== (4 & a)) &&
|
|
tu(n, t, o),
|
|
(l = l.next));
|
|
} while (l !== r);
|
|
}
|
|
pu(e, t, n);
|
|
break;
|
|
case 1:
|
|
if (
|
|
!Gi &&
|
|
(eu(n, t),
|
|
'function' === typeof (r = n.stateNode).componentWillUnmount)
|
|
)
|
|
try {
|
|
((r.props = n.memoizedProps),
|
|
(r.state = n.memoizedState),
|
|
r.componentWillUnmount());
|
|
} catch (i) {
|
|
Cs(n, t, i);
|
|
}
|
|
pu(e, t, n);
|
|
break;
|
|
case 21:
|
|
pu(e, t, n);
|
|
break;
|
|
case 22:
|
|
1 & n.mode
|
|
? ((Gi = (r = Gi) || null !== n.memoizedState),
|
|
pu(e, t, n),
|
|
(Gi = r))
|
|
: pu(e, t, n);
|
|
break;
|
|
default:
|
|
pu(e, t, n);
|
|
}
|
|
}
|
|
function mu(e) {
|
|
var t = e.updateQueue;
|
|
if (null !== t) {
|
|
e.updateQueue = null;
|
|
var n = e.stateNode;
|
|
(null === n && (n = e.stateNode = new Zi()),
|
|
t.forEach(function (t) {
|
|
var r = zs.bind(null, e, t);
|
|
n.has(t) || (n.add(t), t.then(r, r));
|
|
}));
|
|
}
|
|
}
|
|
function vu(e, t) {
|
|
var n = t.deletions;
|
|
if (null !== n)
|
|
for (var r = 0; r < n.length; r++) {
|
|
var l = n[r];
|
|
try {
|
|
var o = e,
|
|
i = t,
|
|
u = i;
|
|
e: for (; null !== u; ) {
|
|
switch (u.tag) {
|
|
case 5:
|
|
((fu = u.stateNode), (du = !1));
|
|
break e;
|
|
case 3:
|
|
case 4:
|
|
((fu = u.stateNode.containerInfo), (du = !0));
|
|
break e;
|
|
}
|
|
u = u.return;
|
|
}
|
|
if (null === fu) throw Error(a(160));
|
|
(hu(o, i, l), (fu = null), (du = !1));
|
|
var s = l.alternate;
|
|
(null !== s && (s.return = null), (l.return = null));
|
|
} catch (c) {
|
|
Cs(l, t, c);
|
|
}
|
|
}
|
|
if (12854 & t.subtreeFlags)
|
|
for (t = t.child; null !== t; ) (gu(t, e), (t = t.sibling));
|
|
}
|
|
function gu(e, t) {
|
|
var n = e.alternate,
|
|
r = e.flags;
|
|
switch (e.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 14:
|
|
case 15:
|
|
if ((vu(t, e), yu(e), 4 & r)) {
|
|
try {
|
|
(ru(3, e, e.return), lu(3, e));
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
try {
|
|
ru(5, e, e.return);
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
(vu(t, e), yu(e), 512 & r && null !== n && eu(n, n.return));
|
|
break;
|
|
case 5:
|
|
if (
|
|
(vu(t, e),
|
|
yu(e),
|
|
512 & r && null !== n && eu(n, n.return),
|
|
32 & e.flags)
|
|
) {
|
|
var l = e.stateNode;
|
|
try {
|
|
de(l, '');
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
}
|
|
if (4 & r && null != (l = e.stateNode)) {
|
|
var o = e.memoizedProps,
|
|
i = null !== n ? n.memoizedProps : o,
|
|
u = e.type,
|
|
s = e.updateQueue;
|
|
if (((e.updateQueue = null), null !== s))
|
|
try {
|
|
('input' === u &&
|
|
'radio' === o.type &&
|
|
null != o.name &&
|
|
G(l, o),
|
|
be(u, i));
|
|
var c = be(u, o);
|
|
for (i = 0; i < s.length; i += 2) {
|
|
var f = s[i],
|
|
d = s[i + 1];
|
|
'style' === f
|
|
? ve(l, d)
|
|
: 'dangerouslySetInnerHTML' === f
|
|
? fe(l, d)
|
|
: 'children' === f
|
|
? de(l, d)
|
|
: b(l, f, d, c);
|
|
}
|
|
switch (u) {
|
|
case 'input':
|
|
Z(l, o);
|
|
break;
|
|
case 'textarea':
|
|
ae(l, o);
|
|
break;
|
|
case 'select':
|
|
var p = l._wrapperState.wasMultiple;
|
|
l._wrapperState.wasMultiple = !!o.multiple;
|
|
var h = o.value;
|
|
null != h
|
|
? ne(l, !!o.multiple, h, !1)
|
|
: p !== !!o.multiple &&
|
|
(null != o.defaultValue
|
|
? ne(l, !!o.multiple, o.defaultValue, !0)
|
|
: ne(l, !!o.multiple, o.multiple ? [] : '', !1));
|
|
}
|
|
l[pl] = o;
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
}
|
|
break;
|
|
case 6:
|
|
if ((vu(t, e), yu(e), 4 & r)) {
|
|
if (null === e.stateNode) throw Error(a(162));
|
|
((l = e.stateNode), (o = e.memoizedProps));
|
|
try {
|
|
l.nodeValue = o;
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
if (
|
|
(vu(t, e),
|
|
yu(e),
|
|
4 & r && null !== n && n.memoizedState.isDehydrated)
|
|
)
|
|
try {
|
|
Vt(t.containerInfo);
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
break;
|
|
case 4:
|
|
default:
|
|
(vu(t, e), yu(e));
|
|
break;
|
|
case 13:
|
|
(vu(t, e),
|
|
yu(e),
|
|
8192 & (l = e.child).flags &&
|
|
((o = null !== l.memoizedState),
|
|
(l.stateNode.isHidden = o),
|
|
!o ||
|
|
(null !== l.alternate &&
|
|
null !== l.alternate.memoizedState) ||
|
|
(Vu = Ge())),
|
|
4 & r && mu(e));
|
|
break;
|
|
case 22:
|
|
if (
|
|
((f = null !== n && null !== n.memoizedState),
|
|
1 & e.mode
|
|
? ((Gi = (c = Gi) || f), vu(t, e), (Gi = c))
|
|
: vu(t, e),
|
|
yu(e),
|
|
8192 & r)
|
|
) {
|
|
if (
|
|
((c = null !== e.memoizedState),
|
|
(e.stateNode.isHidden = c) && !f && 0 !== (1 & e.mode))
|
|
)
|
|
for (Ji = e, f = e.child; null !== f; ) {
|
|
for (d = Ji = f; null !== Ji; ) {
|
|
switch (((h = (p = Ji).child), p.tag)) {
|
|
case 0:
|
|
case 11:
|
|
case 14:
|
|
case 15:
|
|
ru(4, p, p.return);
|
|
break;
|
|
case 1:
|
|
eu(p, p.return);
|
|
var m = p.stateNode;
|
|
if ('function' === typeof m.componentWillUnmount) {
|
|
((r = p), (n = p.return));
|
|
try {
|
|
((t = r),
|
|
(m.props = t.memoizedProps),
|
|
(m.state = t.memoizedState),
|
|
m.componentWillUnmount());
|
|
} catch (v) {
|
|
Cs(r, n, v);
|
|
}
|
|
}
|
|
break;
|
|
case 5:
|
|
eu(p, p.return);
|
|
break;
|
|
case 22:
|
|
if (null !== p.memoizedState) {
|
|
Su(d);
|
|
continue;
|
|
}
|
|
}
|
|
null !== h ? ((h.return = p), (Ji = h)) : Su(d);
|
|
}
|
|
f = f.sibling;
|
|
}
|
|
e: for (f = null, d = e; ; ) {
|
|
if (5 === d.tag) {
|
|
if (null === f) {
|
|
f = d;
|
|
try {
|
|
((l = d.stateNode),
|
|
c
|
|
? 'function' === typeof (o = l.style).setProperty
|
|
? o.setProperty('display', 'none', 'important')
|
|
: (o.display = 'none')
|
|
: ((u = d.stateNode),
|
|
(i =
|
|
void 0 !== (s = d.memoizedProps.style) &&
|
|
null !== s &&
|
|
s.hasOwnProperty('display')
|
|
? s.display
|
|
: null),
|
|
(u.style.display = me('display', i))));
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
}
|
|
} else if (6 === d.tag) {
|
|
if (null === f)
|
|
try {
|
|
d.stateNode.nodeValue = c ? '' : d.memoizedProps;
|
|
} catch (v) {
|
|
Cs(e, e.return, v);
|
|
}
|
|
} else if (
|
|
((22 !== d.tag && 23 !== d.tag) ||
|
|
null === d.memoizedState ||
|
|
d === e) &&
|
|
null !== d.child
|
|
) {
|
|
((d.child.return = d), (d = d.child));
|
|
continue;
|
|
}
|
|
if (d === e) break e;
|
|
for (; null === d.sibling; ) {
|
|
if (null === d.return || d.return === e) break e;
|
|
(f === d && (f = null), (d = d.return));
|
|
}
|
|
(f === d && (f = null),
|
|
(d.sibling.return = d.return),
|
|
(d = d.sibling));
|
|
}
|
|
}
|
|
break;
|
|
case 19:
|
|
(vu(t, e), yu(e), 4 & r && mu(e));
|
|
case 21:
|
|
}
|
|
}
|
|
function yu(e) {
|
|
var t = e.flags;
|
|
if (2 & t) {
|
|
try {
|
|
e: {
|
|
for (var n = e.return; null !== n; ) {
|
|
if (iu(n)) {
|
|
var r = n;
|
|
break e;
|
|
}
|
|
n = n.return;
|
|
}
|
|
throw Error(a(160));
|
|
}
|
|
switch (r.tag) {
|
|
case 5:
|
|
var l = r.stateNode;
|
|
(32 & r.flags && (de(l, ''), (r.flags &= -33)),
|
|
cu(e, uu(e), l));
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
var o = r.stateNode.containerInfo;
|
|
su(e, uu(e), o);
|
|
break;
|
|
default:
|
|
throw Error(a(161));
|
|
}
|
|
} catch (i) {
|
|
Cs(e, e.return, i);
|
|
}
|
|
e.flags &= -3;
|
|
}
|
|
4096 & t && (e.flags &= -4097);
|
|
}
|
|
function bu(e, t, n) {
|
|
((Ji = e), ku(e, t, n));
|
|
}
|
|
function ku(e, t, n) {
|
|
for (var r = 0 !== (1 & e.mode); null !== Ji; ) {
|
|
var l = Ji,
|
|
a = l.child;
|
|
if (22 === l.tag && r) {
|
|
var o = null !== l.memoizedState || Xi;
|
|
if (!o) {
|
|
var i = l.alternate,
|
|
u = (null !== i && null !== i.memoizedState) || Gi;
|
|
i = Xi;
|
|
var s = Gi;
|
|
if (((Xi = o), (Gi = u) && !s))
|
|
for (Ji = l; null !== Ji; )
|
|
((u = (o = Ji).child),
|
|
22 === o.tag && null !== o.memoizedState
|
|
? xu(l)
|
|
: null !== u
|
|
? ((u.return = o), (Ji = u))
|
|
: xu(l));
|
|
for (; null !== a; ) ((Ji = a), ku(a, t, n), (a = a.sibling));
|
|
((Ji = l), (Xi = i), (Gi = s));
|
|
}
|
|
wu(e);
|
|
} else
|
|
0 !== (8772 & l.subtreeFlags) && null !== a
|
|
? ((a.return = l), (Ji = a))
|
|
: wu(e);
|
|
}
|
|
}
|
|
function wu(e) {
|
|
for (; null !== Ji; ) {
|
|
var t = Ji;
|
|
if (0 !== (8772 & t.flags)) {
|
|
var n = t.alternate;
|
|
try {
|
|
if (0 !== (8772 & t.flags))
|
|
switch (t.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 15:
|
|
Gi || lu(5, t);
|
|
break;
|
|
case 1:
|
|
var r = t.stateNode;
|
|
if (4 & t.flags && !Gi)
|
|
if (null === n) r.componentDidMount();
|
|
else {
|
|
var l =
|
|
t.elementType === t.type
|
|
? n.memoizedProps
|
|
: va(t.type, n.memoizedProps);
|
|
r.componentDidUpdate(
|
|
l,
|
|
n.memoizedState,
|
|
r.__reactInternalSnapshotBeforeUpdate
|
|
);
|
|
}
|
|
var o = t.updateQueue;
|
|
null !== o && Ua(t, o, r);
|
|
break;
|
|
case 3:
|
|
var i = t.updateQueue;
|
|
if (null !== i) {
|
|
if (((n = null), null !== t.child))
|
|
switch (t.child.tag) {
|
|
case 5:
|
|
case 1:
|
|
n = t.child.stateNode;
|
|
}
|
|
Ua(t, i, n);
|
|
}
|
|
break;
|
|
case 5:
|
|
var u = t.stateNode;
|
|
if (null === n && 4 & t.flags) {
|
|
n = u;
|
|
var s = t.memoizedProps;
|
|
switch (t.type) {
|
|
case 'button':
|
|
case 'input':
|
|
case 'select':
|
|
case 'textarea':
|
|
s.autoFocus && n.focus();
|
|
break;
|
|
case 'img':
|
|
s.src && (n.src = s.src);
|
|
}
|
|
}
|
|
break;
|
|
case 6:
|
|
case 4:
|
|
case 12:
|
|
case 19:
|
|
case 17:
|
|
case 21:
|
|
case 22:
|
|
case 23:
|
|
case 25:
|
|
break;
|
|
case 13:
|
|
if (null === t.memoizedState) {
|
|
var c = t.alternate;
|
|
if (null !== c) {
|
|
var f = c.memoizedState;
|
|
if (null !== f) {
|
|
var d = f.dehydrated;
|
|
null !== d && Vt(d);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw Error(a(163));
|
|
}
|
|
Gi || (512 & t.flags && au(t));
|
|
} catch (p) {
|
|
Cs(t, t.return, p);
|
|
}
|
|
}
|
|
if (t === e) {
|
|
Ji = null;
|
|
break;
|
|
}
|
|
if (null !== (n = t.sibling)) {
|
|
((n.return = t.return), (Ji = n));
|
|
break;
|
|
}
|
|
Ji = t.return;
|
|
}
|
|
}
|
|
function Su(e) {
|
|
for (; null !== Ji; ) {
|
|
var t = Ji;
|
|
if (t === e) {
|
|
Ji = null;
|
|
break;
|
|
}
|
|
var n = t.sibling;
|
|
if (null !== n) {
|
|
((n.return = t.return), (Ji = n));
|
|
break;
|
|
}
|
|
Ji = t.return;
|
|
}
|
|
}
|
|
function xu(e) {
|
|
for (; null !== Ji; ) {
|
|
var t = Ji;
|
|
try {
|
|
switch (t.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 15:
|
|
var n = t.return;
|
|
try {
|
|
lu(4, t);
|
|
} catch (u) {
|
|
Cs(t, n, u);
|
|
}
|
|
break;
|
|
case 1:
|
|
var r = t.stateNode;
|
|
if ('function' === typeof r.componentDidMount) {
|
|
var l = t.return;
|
|
try {
|
|
r.componentDidMount();
|
|
} catch (u) {
|
|
Cs(t, l, u);
|
|
}
|
|
}
|
|
var a = t.return;
|
|
try {
|
|
au(t);
|
|
} catch (u) {
|
|
Cs(t, a, u);
|
|
}
|
|
break;
|
|
case 5:
|
|
var o = t.return;
|
|
try {
|
|
au(t);
|
|
} catch (u) {
|
|
Cs(t, o, u);
|
|
}
|
|
}
|
|
} catch (u) {
|
|
Cs(t, t.return, u);
|
|
}
|
|
if (t === e) {
|
|
Ji = null;
|
|
break;
|
|
}
|
|
var i = t.sibling;
|
|
if (null !== i) {
|
|
((i.return = t.return), (Ji = i));
|
|
break;
|
|
}
|
|
Ji = t.return;
|
|
}
|
|
}
|
|
var Eu,
|
|
Cu = Math.ceil,
|
|
_u = k.ReactCurrentDispatcher,
|
|
Pu = k.ReactCurrentOwner,
|
|
Nu = k.ReactCurrentBatchConfig,
|
|
zu = 0,
|
|
Tu = null,
|
|
Mu = null,
|
|
Lu = 0,
|
|
Du = 0,
|
|
Ru = El(0),
|
|
Ou = 0,
|
|
Fu = null,
|
|
Iu = 0,
|
|
Uu = 0,
|
|
ju = 0,
|
|
Au = null,
|
|
Bu = null,
|
|
Vu = 0,
|
|
$u = 1 / 0,
|
|
Hu = null,
|
|
Wu = !1,
|
|
Ku = null,
|
|
Qu = null,
|
|
qu = !1,
|
|
Yu = null,
|
|
Xu = 0,
|
|
Gu = 0,
|
|
Zu = null,
|
|
Ju = -1,
|
|
es = 0;
|
|
function ts() {
|
|
return 0 !== (6 & zu) ? Ge() : -1 !== Ju ? Ju : (Ju = Ge());
|
|
}
|
|
function ns(e) {
|
|
return 0 === (1 & e.mode)
|
|
? 1
|
|
: 0 !== (2 & zu) && 0 !== Lu
|
|
? Lu & -Lu
|
|
: null !== ma.transition
|
|
? (0 === es && (es = mt()), es)
|
|
: 0 !== (e = bt)
|
|
? e
|
|
: (e = void 0 === (e = window.event) ? 16 : Xt(e.type));
|
|
}
|
|
function rs(e, t, n, r) {
|
|
if (50 < Gu) throw ((Gu = 0), (Zu = null), Error(a(185)));
|
|
(gt(e, n, r),
|
|
(0 !== (2 & zu) && e === Tu) ||
|
|
(e === Tu && (0 === (2 & zu) && (Uu |= n), 4 === Ou && us(e, Lu)),
|
|
ls(e, r),
|
|
1 === n &&
|
|
0 === zu &&
|
|
0 === (1 & t.mode) &&
|
|
(($u = Ge() + 500), jl && Vl())));
|
|
}
|
|
function ls(e, t) {
|
|
var n = e.callbackNode;
|
|
!(function (e, t) {
|
|
for (
|
|
var n = e.suspendedLanes,
|
|
r = e.pingedLanes,
|
|
l = e.expirationTimes,
|
|
a = e.pendingLanes;
|
|
0 < a;
|
|
) {
|
|
var o = 31 - ot(a),
|
|
i = 1 << o,
|
|
u = l[o];
|
|
(-1 === u
|
|
? (0 !== (i & n) && 0 === (i & r)) || (l[o] = pt(i, t))
|
|
: u <= t && (e.expiredLanes |= i),
|
|
(a &= ~i));
|
|
}
|
|
})(e, t);
|
|
var r = dt(e, e === Tu ? Lu : 0);
|
|
if (0 === r)
|
|
(null !== n && qe(n),
|
|
(e.callbackNode = null),
|
|
(e.callbackPriority = 0));
|
|
else if (((t = r & -r), e.callbackPriority !== t)) {
|
|
if ((null != n && qe(n), 1 === t))
|
|
(0 === e.tag
|
|
? (function (e) {
|
|
((jl = !0), Bl(e));
|
|
})(ss.bind(null, e))
|
|
: Bl(ss.bind(null, e)),
|
|
ol(function () {
|
|
0 === (6 & zu) && Vl();
|
|
}),
|
|
(n = null));
|
|
else {
|
|
switch (kt(r)) {
|
|
case 1:
|
|
n = Je;
|
|
break;
|
|
case 4:
|
|
n = et;
|
|
break;
|
|
case 16:
|
|
default:
|
|
n = tt;
|
|
break;
|
|
case 536870912:
|
|
n = rt;
|
|
}
|
|
n = Ts(n, as.bind(null, e));
|
|
}
|
|
((e.callbackPriority = t), (e.callbackNode = n));
|
|
}
|
|
}
|
|
function as(e, t) {
|
|
if (((Ju = -1), (es = 0), 0 !== (6 & zu))) throw Error(a(327));
|
|
var n = e.callbackNode;
|
|
if (xs() && e.callbackNode !== n) return null;
|
|
var r = dt(e, e === Tu ? Lu : 0);
|
|
if (0 === r) return null;
|
|
if (0 !== (30 & r) || 0 !== (r & e.expiredLanes) || t) t = gs(e, r);
|
|
else {
|
|
t = r;
|
|
var l = zu;
|
|
zu |= 2;
|
|
var o = ms();
|
|
for (
|
|
(Tu === e && Lu === t) ||
|
|
((Hu = null), ($u = Ge() + 500), ps(e, t));
|
|
;
|
|
)
|
|
try {
|
|
bs();
|
|
break;
|
|
} catch (u) {
|
|
hs(e, u);
|
|
}
|
|
(wa(),
|
|
(_u.current = o),
|
|
(zu = l),
|
|
null !== Mu ? (t = 0) : ((Tu = null), (Lu = 0), (t = Ou)));
|
|
}
|
|
if (0 !== t) {
|
|
if (
|
|
(2 === t && 0 !== (l = ht(e)) && ((r = l), (t = os(e, l))),
|
|
1 === t)
|
|
)
|
|
throw ((n = Fu), ps(e, 0), us(e, r), ls(e, Ge()), n);
|
|
if (6 === t) us(e, r);
|
|
else {
|
|
if (
|
|
((l = e.current.alternate),
|
|
0 === (30 & r) &&
|
|
!(function (e) {
|
|
for (var t = e; ; ) {
|
|
if (16384 & t.flags) {
|
|
var n = t.updateQueue;
|
|
if (null !== n && null !== (n = n.stores))
|
|
for (var r = 0; r < n.length; r++) {
|
|
var l = n[r],
|
|
a = l.getSnapshot;
|
|
l = l.value;
|
|
try {
|
|
if (!ir(a(), l)) return !1;
|
|
} catch (i) {
|
|
return !1;
|
|
}
|
|
}
|
|
}
|
|
if (((n = t.child), 16384 & t.subtreeFlags && null !== n))
|
|
((n.return = t), (t = n));
|
|
else {
|
|
if (t === e) break;
|
|
for (; null === t.sibling; ) {
|
|
if (null === t.return || t.return === e) return !0;
|
|
t = t.return;
|
|
}
|
|
((t.sibling.return = t.return), (t = t.sibling));
|
|
}
|
|
}
|
|
return !0;
|
|
})(l) &&
|
|
(2 === (t = gs(e, r)) &&
|
|
0 !== (o = ht(e)) &&
|
|
((r = o), (t = os(e, o))),
|
|
1 === t))
|
|
)
|
|
throw ((n = Fu), ps(e, 0), us(e, r), ls(e, Ge()), n);
|
|
switch (((e.finishedWork = l), (e.finishedLanes = r), t)) {
|
|
case 0:
|
|
case 1:
|
|
throw Error(a(345));
|
|
case 2:
|
|
case 5:
|
|
Ss(e, Bu, Hu);
|
|
break;
|
|
case 3:
|
|
if (
|
|
(us(e, r),
|
|
(130023424 & r) === r && 10 < (t = Vu + 500 - Ge()))
|
|
) {
|
|
if (0 !== dt(e, 0)) break;
|
|
if (((l = e.suspendedLanes) & r) !== r) {
|
|
(ts(), (e.pingedLanes |= e.suspendedLanes & l));
|
|
break;
|
|
}
|
|
e.timeoutHandle = rl(Ss.bind(null, e, Bu, Hu), t);
|
|
break;
|
|
}
|
|
Ss(e, Bu, Hu);
|
|
break;
|
|
case 4:
|
|
if ((us(e, r), (4194240 & r) === r)) break;
|
|
for (t = e.eventTimes, l = -1; 0 < r; ) {
|
|
var i = 31 - ot(r);
|
|
((o = 1 << i), (i = t[i]) > l && (l = i), (r &= ~o));
|
|
}
|
|
if (
|
|
((r = l),
|
|
10 <
|
|
(r =
|
|
(120 > (r = Ge() - r)
|
|
? 120
|
|
: 480 > r
|
|
? 480
|
|
: 1080 > r
|
|
? 1080
|
|
: 1920 > r
|
|
? 1920
|
|
: 3e3 > r
|
|
? 3e3
|
|
: 4320 > r
|
|
? 4320
|
|
: 1960 * Cu(r / 1960)) - r))
|
|
) {
|
|
e.timeoutHandle = rl(Ss.bind(null, e, Bu, Hu), r);
|
|
break;
|
|
}
|
|
Ss(e, Bu, Hu);
|
|
break;
|
|
default:
|
|
throw Error(a(329));
|
|
}
|
|
}
|
|
}
|
|
return (ls(e, Ge()), e.callbackNode === n ? as.bind(null, e) : null);
|
|
}
|
|
function os(e, t) {
|
|
var n = Au;
|
|
return (
|
|
e.current.memoizedState.isDehydrated && (ps(e, t).flags |= 256),
|
|
2 !== (e = gs(e, t)) && ((t = Bu), (Bu = n), null !== t && is(t)),
|
|
e
|
|
);
|
|
}
|
|
function is(e) {
|
|
null === Bu ? (Bu = e) : Bu.push.apply(Bu, e);
|
|
}
|
|
function us(e, t) {
|
|
for (
|
|
t &= ~ju,
|
|
t &= ~Uu,
|
|
e.suspendedLanes |= t,
|
|
e.pingedLanes &= ~t,
|
|
e = e.expirationTimes;
|
|
0 < t;
|
|
) {
|
|
var n = 31 - ot(t),
|
|
r = 1 << n;
|
|
((e[n] = -1), (t &= ~r));
|
|
}
|
|
}
|
|
function ss(e) {
|
|
if (0 !== (6 & zu)) throw Error(a(327));
|
|
xs();
|
|
var t = dt(e, 0);
|
|
if (0 === (1 & t)) return (ls(e, Ge()), null);
|
|
var n = gs(e, t);
|
|
if (0 !== e.tag && 2 === n) {
|
|
var r = ht(e);
|
|
0 !== r && ((t = r), (n = os(e, r)));
|
|
}
|
|
if (1 === n) throw ((n = Fu), ps(e, 0), us(e, t), ls(e, Ge()), n);
|
|
if (6 === n) throw Error(a(345));
|
|
return (
|
|
(e.finishedWork = e.current.alternate),
|
|
(e.finishedLanes = t),
|
|
Ss(e, Bu, Hu),
|
|
ls(e, Ge()),
|
|
null
|
|
);
|
|
}
|
|
function cs(e, t) {
|
|
var n = zu;
|
|
zu |= 1;
|
|
try {
|
|
return e(t);
|
|
} finally {
|
|
0 === (zu = n) && (($u = Ge() + 500), jl && Vl());
|
|
}
|
|
}
|
|
function fs(e) {
|
|
null !== Yu && 0 === Yu.tag && 0 === (6 & zu) && xs();
|
|
var t = zu;
|
|
zu |= 1;
|
|
var n = Nu.transition,
|
|
r = bt;
|
|
try {
|
|
if (((Nu.transition = null), (bt = 1), e)) return e();
|
|
} finally {
|
|
((bt = r), (Nu.transition = n), 0 === (6 & (zu = t)) && Vl());
|
|
}
|
|
}
|
|
function ds() {
|
|
((Du = Ru.current), Cl(Ru));
|
|
}
|
|
function ps(e, t) {
|
|
((e.finishedWork = null), (e.finishedLanes = 0));
|
|
var n = e.timeoutHandle;
|
|
if ((-1 !== n && ((e.timeoutHandle = -1), ll(n)), null !== Mu))
|
|
for (n = Mu.return; null !== n; ) {
|
|
var r = n;
|
|
switch ((ta(r), r.tag)) {
|
|
case 1:
|
|
null !== (r = r.type.childContextTypes) &&
|
|
void 0 !== r &&
|
|
Dl();
|
|
break;
|
|
case 3:
|
|
(lo(), Cl(zl), Cl(Nl), co());
|
|
break;
|
|
case 5:
|
|
oo(r);
|
|
break;
|
|
case 4:
|
|
lo();
|
|
break;
|
|
case 13:
|
|
case 19:
|
|
Cl(io);
|
|
break;
|
|
case 10:
|
|
Sa(r.type._context);
|
|
break;
|
|
case 22:
|
|
case 23:
|
|
ds();
|
|
}
|
|
n = n.return;
|
|
}
|
|
if (
|
|
((Tu = e),
|
|
(Mu = e = Rs(e.current, null)),
|
|
(Lu = Du = t),
|
|
(Ou = 0),
|
|
(Fu = null),
|
|
(ju = Uu = Iu = 0),
|
|
(Bu = Au = null),
|
|
null !== _a)
|
|
) {
|
|
for (t = 0; t < _a.length; t++)
|
|
if (null !== (r = (n = _a[t]).interleaved)) {
|
|
n.interleaved = null;
|
|
var l = r.next,
|
|
a = n.pending;
|
|
if (null !== a) {
|
|
var o = a.next;
|
|
((a.next = l), (r.next = o));
|
|
}
|
|
n.pending = r;
|
|
}
|
|
_a = null;
|
|
}
|
|
return e;
|
|
}
|
|
function hs(e, t) {
|
|
for (;;) {
|
|
var n = Mu;
|
|
try {
|
|
if ((wa(), (fo.current = oi), yo)) {
|
|
for (var r = mo.memoizedState; null !== r; ) {
|
|
var l = r.queue;
|
|
(null !== l && (l.pending = null), (r = r.next));
|
|
}
|
|
yo = !1;
|
|
}
|
|
if (
|
|
((ho = 0),
|
|
(go = vo = mo = null),
|
|
(bo = !1),
|
|
(ko = 0),
|
|
(Pu.current = null),
|
|
null === n || null === n.return)
|
|
) {
|
|
((Ou = 1), (Fu = t), (Mu = null));
|
|
break;
|
|
}
|
|
e: {
|
|
var o = e,
|
|
i = n.return,
|
|
u = n,
|
|
s = t;
|
|
if (
|
|
((t = Lu),
|
|
(u.flags |= 32768),
|
|
null !== s &&
|
|
'object' === typeof s &&
|
|
'function' === typeof s.then)
|
|
) {
|
|
var c = s,
|
|
f = u,
|
|
d = f.tag;
|
|
if (0 === (1 & f.mode) && (0 === d || 11 === d || 15 === d)) {
|
|
var p = f.alternate;
|
|
p
|
|
? ((f.updateQueue = p.updateQueue),
|
|
(f.memoizedState = p.memoizedState),
|
|
(f.lanes = p.lanes))
|
|
: ((f.updateQueue = null), (f.memoizedState = null));
|
|
}
|
|
var h = gi(i);
|
|
if (null !== h) {
|
|
((h.flags &= -257),
|
|
yi(h, i, u, 0, t),
|
|
1 & h.mode && vi(o, c, t),
|
|
(s = c));
|
|
var m = (t = h).updateQueue;
|
|
if (null === m) {
|
|
var v = new Set();
|
|
(v.add(s), (t.updateQueue = v));
|
|
} else m.add(s);
|
|
break e;
|
|
}
|
|
if (0 === (1 & t)) {
|
|
(vi(o, c, t), vs());
|
|
break e;
|
|
}
|
|
s = Error(a(426));
|
|
} else if (la && 1 & u.mode) {
|
|
var g = gi(i);
|
|
if (null !== g) {
|
|
(0 === (65536 & g.flags) && (g.flags |= 256),
|
|
yi(g, i, u, 0, t),
|
|
ha(ci(s, u)));
|
|
break e;
|
|
}
|
|
}
|
|
((o = s = ci(s, u)),
|
|
4 !== Ou && (Ou = 2),
|
|
null === Au ? (Au = [o]) : Au.push(o),
|
|
(o = i));
|
|
do {
|
|
switch (o.tag) {
|
|
case 3:
|
|
((o.flags |= 65536),
|
|
(t &= -t),
|
|
(o.lanes |= t),
|
|
Fa(o, hi(0, s, t)));
|
|
break e;
|
|
case 1:
|
|
u = s;
|
|
var y = o.type,
|
|
b = o.stateNode;
|
|
if (
|
|
0 === (128 & o.flags) &&
|
|
('function' === typeof y.getDerivedStateFromError ||
|
|
(null !== b &&
|
|
'function' === typeof b.componentDidCatch &&
|
|
(null === Qu || !Qu.has(b))))
|
|
) {
|
|
((o.flags |= 65536),
|
|
(t &= -t),
|
|
(o.lanes |= t),
|
|
Fa(o, mi(o, u, t)));
|
|
break e;
|
|
}
|
|
}
|
|
o = o.return;
|
|
} while (null !== o);
|
|
}
|
|
ws(n);
|
|
} catch (k) {
|
|
((t = k), Mu === n && null !== n && (Mu = n = n.return));
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function ms() {
|
|
var e = _u.current;
|
|
return ((_u.current = oi), null === e ? oi : e);
|
|
}
|
|
function vs() {
|
|
((0 !== Ou && 3 !== Ou && 2 !== Ou) || (Ou = 4),
|
|
null === Tu ||
|
|
(0 === (268435455 & Iu) && 0 === (268435455 & Uu)) ||
|
|
us(Tu, Lu));
|
|
}
|
|
function gs(e, t) {
|
|
var n = zu;
|
|
zu |= 2;
|
|
var r = ms();
|
|
for ((Tu === e && Lu === t) || ((Hu = null), ps(e, t)); ; )
|
|
try {
|
|
ys();
|
|
break;
|
|
} catch (l) {
|
|
hs(e, l);
|
|
}
|
|
if ((wa(), (zu = n), (_u.current = r), null !== Mu))
|
|
throw Error(a(261));
|
|
return ((Tu = null), (Lu = 0), Ou);
|
|
}
|
|
function ys() {
|
|
for (; null !== Mu; ) ks(Mu);
|
|
}
|
|
function bs() {
|
|
for (; null !== Mu && !Ye(); ) ks(Mu);
|
|
}
|
|
function ks(e) {
|
|
var t = Eu(e.alternate, e, Du);
|
|
((e.memoizedProps = e.pendingProps),
|
|
null === t ? ws(e) : (Mu = t),
|
|
(Pu.current = null));
|
|
}
|
|
function ws(e) {
|
|
var t = e;
|
|
do {
|
|
var n = t.alternate;
|
|
if (((e = t.return), 0 === (32768 & t.flags))) {
|
|
if (null !== (n = qi(n, t, Du))) return void (Mu = n);
|
|
} else {
|
|
if (null !== (n = Yi(n, t)))
|
|
return ((n.flags &= 32767), void (Mu = n));
|
|
if (null === e) return ((Ou = 6), void (Mu = null));
|
|
((e.flags |= 32768), (e.subtreeFlags = 0), (e.deletions = null));
|
|
}
|
|
if (null !== (t = t.sibling)) return void (Mu = t);
|
|
Mu = t = e;
|
|
} while (null !== t);
|
|
0 === Ou && (Ou = 5);
|
|
}
|
|
function Ss(e, t, n) {
|
|
var r = bt,
|
|
l = Nu.transition;
|
|
try {
|
|
((Nu.transition = null),
|
|
(bt = 1),
|
|
(function (e, t, n, r) {
|
|
do {
|
|
xs();
|
|
} while (null !== Yu);
|
|
if (0 !== (6 & zu)) throw Error(a(327));
|
|
n = e.finishedWork;
|
|
var l = e.finishedLanes;
|
|
if (null === n) return null;
|
|
if (
|
|
((e.finishedWork = null),
|
|
(e.finishedLanes = 0),
|
|
n === e.current)
|
|
)
|
|
throw Error(a(177));
|
|
((e.callbackNode = null), (e.callbackPriority = 0));
|
|
var o = n.lanes | n.childLanes;
|
|
if (
|
|
((function (e, t) {
|
|
var n = e.pendingLanes & ~t;
|
|
((e.pendingLanes = t),
|
|
(e.suspendedLanes = 0),
|
|
(e.pingedLanes = 0),
|
|
(e.expiredLanes &= t),
|
|
(e.mutableReadLanes &= t),
|
|
(e.entangledLanes &= t),
|
|
(t = e.entanglements));
|
|
var r = e.eventTimes;
|
|
for (e = e.expirationTimes; 0 < n; ) {
|
|
var l = 31 - ot(n),
|
|
a = 1 << l;
|
|
((t[l] = 0), (r[l] = -1), (e[l] = -1), (n &= ~a));
|
|
}
|
|
})(e, o),
|
|
e === Tu && ((Mu = Tu = null), (Lu = 0)),
|
|
(0 === (2064 & n.subtreeFlags) && 0 === (2064 & n.flags)) ||
|
|
qu ||
|
|
((qu = !0),
|
|
Ts(tt, function () {
|
|
return (xs(), null);
|
|
})),
|
|
(o = 0 !== (15990 & n.flags)),
|
|
0 !== (15990 & n.subtreeFlags) || o)
|
|
) {
|
|
((o = Nu.transition), (Nu.transition = null));
|
|
var i = bt;
|
|
bt = 1;
|
|
var u = zu;
|
|
((zu |= 4),
|
|
(Pu.current = null),
|
|
(function (e, t) {
|
|
if (((el = Ht), pr((e = dr())))) {
|
|
if ('selectionStart' in e)
|
|
var n = {
|
|
start: e.selectionStart,
|
|
end: e.selectionEnd,
|
|
};
|
|
else
|
|
e: {
|
|
var r =
|
|
(n =
|
|
((n = e.ownerDocument) && n.defaultView) ||
|
|
window).getSelection && n.getSelection();
|
|
if (r && 0 !== r.rangeCount) {
|
|
n = r.anchorNode;
|
|
var l = r.anchorOffset,
|
|
o = r.focusNode;
|
|
r = r.focusOffset;
|
|
try {
|
|
(n.nodeType, o.nodeType);
|
|
} catch (w) {
|
|
n = null;
|
|
break e;
|
|
}
|
|
var i = 0,
|
|
u = -1,
|
|
s = -1,
|
|
c = 0,
|
|
f = 0,
|
|
d = e,
|
|
p = null;
|
|
t: for (;;) {
|
|
for (
|
|
var h;
|
|
d !== n ||
|
|
(0 !== l && 3 !== d.nodeType) ||
|
|
(u = i + l),
|
|
d !== o ||
|
|
(0 !== r && 3 !== d.nodeType) ||
|
|
(s = i + r),
|
|
3 === d.nodeType &&
|
|
(i += d.nodeValue.length),
|
|
null !== (h = d.firstChild);
|
|
)
|
|
((p = d), (d = h));
|
|
for (;;) {
|
|
if (d === e) break t;
|
|
if (
|
|
(p === n && ++c === l && (u = i),
|
|
p === o && ++f === r && (s = i),
|
|
null !== (h = d.nextSibling))
|
|
)
|
|
break;
|
|
p = (d = p).parentNode;
|
|
}
|
|
d = h;
|
|
}
|
|
n =
|
|
-1 === u || -1 === s
|
|
? null
|
|
: { start: u, end: s };
|
|
} else n = null;
|
|
}
|
|
n = n || { start: 0, end: 0 };
|
|
} else n = null;
|
|
for (
|
|
tl = { focusedElem: e, selectionRange: n },
|
|
Ht = !1,
|
|
Ji = t;
|
|
null !== Ji;
|
|
)
|
|
if (
|
|
((e = (t = Ji).child),
|
|
0 !== (1028 & t.subtreeFlags) && null !== e)
|
|
)
|
|
((e.return = t), (Ji = e));
|
|
else
|
|
for (; null !== Ji; ) {
|
|
t = Ji;
|
|
try {
|
|
var m = t.alternate;
|
|
if (0 !== (1024 & t.flags))
|
|
switch (t.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 15:
|
|
case 5:
|
|
case 6:
|
|
case 4:
|
|
case 17:
|
|
break;
|
|
case 1:
|
|
if (null !== m) {
|
|
var v = m.memoizedProps,
|
|
g = m.memoizedState,
|
|
y = t.stateNode,
|
|
b = y.getSnapshotBeforeUpdate(
|
|
t.elementType === t.type
|
|
? v
|
|
: va(t.type, v),
|
|
g
|
|
);
|
|
y.__reactInternalSnapshotBeforeUpdate = b;
|
|
}
|
|
break;
|
|
case 3:
|
|
var k = t.stateNode.containerInfo;
|
|
1 === k.nodeType
|
|
? (k.textContent = '')
|
|
: 9 === k.nodeType &&
|
|
k.documentElement &&
|
|
k.removeChild(k.documentElement);
|
|
break;
|
|
default:
|
|
throw Error(a(163));
|
|
}
|
|
} catch (w) {
|
|
Cs(t, t.return, w);
|
|
}
|
|
if (null !== (e = t.sibling)) {
|
|
((e.return = t.return), (Ji = e));
|
|
break;
|
|
}
|
|
Ji = t.return;
|
|
}
|
|
((m = nu), (nu = !1));
|
|
})(e, n),
|
|
gu(n, e),
|
|
hr(tl),
|
|
(Ht = !!el),
|
|
(tl = el = null),
|
|
(e.current = n),
|
|
bu(n, e, l),
|
|
Xe(),
|
|
(zu = u),
|
|
(bt = i),
|
|
(Nu.transition = o));
|
|
} else e.current = n;
|
|
if (
|
|
(qu && ((qu = !1), (Yu = e), (Xu = l)),
|
|
(o = e.pendingLanes),
|
|
0 === o && (Qu = null),
|
|
(function (e) {
|
|
if (at && 'function' === typeof at.onCommitFiberRoot)
|
|
try {
|
|
at.onCommitFiberRoot(
|
|
lt,
|
|
e,
|
|
void 0,
|
|
128 === (128 & e.current.flags)
|
|
);
|
|
} catch (t) {}
|
|
})(n.stateNode),
|
|
ls(e, Ge()),
|
|
null !== t)
|
|
)
|
|
for (r = e.onRecoverableError, n = 0; n < t.length; n++)
|
|
((l = t[n]),
|
|
r(l.value, {
|
|
componentStack: l.stack,
|
|
digest: l.digest,
|
|
}));
|
|
if (Wu) throw ((Wu = !1), (e = Ku), (Ku = null), e);
|
|
(0 !== (1 & Xu) && 0 !== e.tag && xs(),
|
|
(o = e.pendingLanes),
|
|
0 !== (1 & o)
|
|
? e === Zu
|
|
? Gu++
|
|
: ((Gu = 0), (Zu = e))
|
|
: (Gu = 0),
|
|
Vl());
|
|
})(e, t, n, r));
|
|
} finally {
|
|
((Nu.transition = l), (bt = r));
|
|
}
|
|
return null;
|
|
}
|
|
function xs() {
|
|
if (null !== Yu) {
|
|
var e = kt(Xu),
|
|
t = Nu.transition,
|
|
n = bt;
|
|
try {
|
|
if (((Nu.transition = null), (bt = 16 > e ? 16 : e), null === Yu))
|
|
var r = !1;
|
|
else {
|
|
if (((e = Yu), (Yu = null), (Xu = 0), 0 !== (6 & zu)))
|
|
throw Error(a(331));
|
|
var l = zu;
|
|
for (zu |= 4, Ji = e.current; null !== Ji; ) {
|
|
var o = Ji,
|
|
i = o.child;
|
|
if (0 !== (16 & Ji.flags)) {
|
|
var u = o.deletions;
|
|
if (null !== u) {
|
|
for (var s = 0; s < u.length; s++) {
|
|
var c = u[s];
|
|
for (Ji = c; null !== Ji; ) {
|
|
var f = Ji;
|
|
switch (f.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 15:
|
|
ru(8, f, o);
|
|
}
|
|
var d = f.child;
|
|
if (null !== d) ((d.return = f), (Ji = d));
|
|
else
|
|
for (; null !== Ji; ) {
|
|
var p = (f = Ji).sibling,
|
|
h = f.return;
|
|
if ((ou(f), f === c)) {
|
|
Ji = null;
|
|
break;
|
|
}
|
|
if (null !== p) {
|
|
((p.return = h), (Ji = p));
|
|
break;
|
|
}
|
|
Ji = h;
|
|
}
|
|
}
|
|
}
|
|
var m = o.alternate;
|
|
if (null !== m) {
|
|
var v = m.child;
|
|
if (null !== v) {
|
|
m.child = null;
|
|
do {
|
|
var g = v.sibling;
|
|
((v.sibling = null), (v = g));
|
|
} while (null !== v);
|
|
}
|
|
}
|
|
Ji = o;
|
|
}
|
|
}
|
|
if (0 !== (2064 & o.subtreeFlags) && null !== i)
|
|
((i.return = o), (Ji = i));
|
|
else
|
|
e: for (; null !== Ji; ) {
|
|
if (0 !== (2048 & (o = Ji).flags))
|
|
switch (o.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 15:
|
|
ru(9, o, o.return);
|
|
}
|
|
var y = o.sibling;
|
|
if (null !== y) {
|
|
((y.return = o.return), (Ji = y));
|
|
break e;
|
|
}
|
|
Ji = o.return;
|
|
}
|
|
}
|
|
var b = e.current;
|
|
for (Ji = b; null !== Ji; ) {
|
|
var k = (i = Ji).child;
|
|
if (0 !== (2064 & i.subtreeFlags) && null !== k)
|
|
((k.return = i), (Ji = k));
|
|
else
|
|
e: for (i = b; null !== Ji; ) {
|
|
if (0 !== (2048 & (u = Ji).flags))
|
|
try {
|
|
switch (u.tag) {
|
|
case 0:
|
|
case 11:
|
|
case 15:
|
|
lu(9, u);
|
|
}
|
|
} catch (S) {
|
|
Cs(u, u.return, S);
|
|
}
|
|
if (u === i) {
|
|
Ji = null;
|
|
break e;
|
|
}
|
|
var w = u.sibling;
|
|
if (null !== w) {
|
|
((w.return = u.return), (Ji = w));
|
|
break e;
|
|
}
|
|
Ji = u.return;
|
|
}
|
|
}
|
|
if (
|
|
((zu = l),
|
|
Vl(),
|
|
at && 'function' === typeof at.onPostCommitFiberRoot)
|
|
)
|
|
try {
|
|
at.onPostCommitFiberRoot(lt, e);
|
|
} catch (S) {}
|
|
r = !0;
|
|
}
|
|
return r;
|
|
} finally {
|
|
((bt = n), (Nu.transition = t));
|
|
}
|
|
}
|
|
return !1;
|
|
}
|
|
function Es(e, t, n) {
|
|
((e = Ra(e, (t = hi(0, (t = ci(n, t)), 1)), 1)),
|
|
(t = ts()),
|
|
null !== e && (gt(e, 1, t), ls(e, t)));
|
|
}
|
|
function Cs(e, t, n) {
|
|
if (3 === e.tag) Es(e, e, n);
|
|
else
|
|
for (; null !== t; ) {
|
|
if (3 === t.tag) {
|
|
Es(t, e, n);
|
|
break;
|
|
}
|
|
if (1 === t.tag) {
|
|
var r = t.stateNode;
|
|
if (
|
|
'function' === typeof t.type.getDerivedStateFromError ||
|
|
('function' === typeof r.componentDidCatch &&
|
|
(null === Qu || !Qu.has(r)))
|
|
) {
|
|
((t = Ra(t, (e = mi(t, (e = ci(n, e)), 1)), 1)),
|
|
(e = ts()),
|
|
null !== t && (gt(t, 1, e), ls(t, e)));
|
|
break;
|
|
}
|
|
}
|
|
t = t.return;
|
|
}
|
|
}
|
|
function _s(e, t, n) {
|
|
var r = e.pingCache;
|
|
(null !== r && r.delete(t),
|
|
(t = ts()),
|
|
(e.pingedLanes |= e.suspendedLanes & n),
|
|
Tu === e &&
|
|
(Lu & n) === n &&
|
|
(4 === Ou ||
|
|
(3 === Ou && (130023424 & Lu) === Lu && 500 > Ge() - Vu)
|
|
? ps(e, 0)
|
|
: (ju |= n)),
|
|
ls(e, t));
|
|
}
|
|
function Ps(e, t) {
|
|
0 === t &&
|
|
(0 === (1 & e.mode)
|
|
? (t = 1)
|
|
: ((t = ct), 0 === (130023424 & (ct <<= 1)) && (ct = 4194304)));
|
|
var n = ts();
|
|
null !== (e = za(e, t)) && (gt(e, t, n), ls(e, n));
|
|
}
|
|
function Ns(e) {
|
|
var t = e.memoizedState,
|
|
n = 0;
|
|
(null !== t && (n = t.retryLane), Ps(e, n));
|
|
}
|
|
function zs(e, t) {
|
|
var n = 0;
|
|
switch (e.tag) {
|
|
case 13:
|
|
var r = e.stateNode,
|
|
l = e.memoizedState;
|
|
null !== l && (n = l.retryLane);
|
|
break;
|
|
case 19:
|
|
r = e.stateNode;
|
|
break;
|
|
default:
|
|
throw Error(a(314));
|
|
}
|
|
(null !== r && r.delete(t), Ps(e, n));
|
|
}
|
|
function Ts(e, t) {
|
|
return Qe(e, t);
|
|
}
|
|
function Ms(e, t, n, r) {
|
|
((this.tag = e),
|
|
(this.key = n),
|
|
(this.sibling =
|
|
this.child =
|
|
this.return =
|
|
this.stateNode =
|
|
this.type =
|
|
this.elementType =
|
|
null),
|
|
(this.index = 0),
|
|
(this.ref = null),
|
|
(this.pendingProps = t),
|
|
(this.dependencies =
|
|
this.memoizedState =
|
|
this.updateQueue =
|
|
this.memoizedProps =
|
|
null),
|
|
(this.mode = r),
|
|
(this.subtreeFlags = this.flags = 0),
|
|
(this.deletions = null),
|
|
(this.childLanes = this.lanes = 0),
|
|
(this.alternate = null));
|
|
}
|
|
function Ls(e, t, n, r) {
|
|
return new Ms(e, t, n, r);
|
|
}
|
|
function Ds(e) {
|
|
return !(!(e = e.prototype) || !e.isReactComponent);
|
|
}
|
|
function Rs(e, t) {
|
|
var n = e.alternate;
|
|
return (
|
|
null === n
|
|
? (((n = Ls(e.tag, t, e.key, e.mode)).elementType =
|
|
e.elementType),
|
|
(n.type = e.type),
|
|
(n.stateNode = e.stateNode),
|
|
(n.alternate = e),
|
|
(e.alternate = n))
|
|
: ((n.pendingProps = t),
|
|
(n.type = e.type),
|
|
(n.flags = 0),
|
|
(n.subtreeFlags = 0),
|
|
(n.deletions = null)),
|
|
(n.flags = 14680064 & e.flags),
|
|
(n.childLanes = e.childLanes),
|
|
(n.lanes = e.lanes),
|
|
(n.child = e.child),
|
|
(n.memoizedProps = e.memoizedProps),
|
|
(n.memoizedState = e.memoizedState),
|
|
(n.updateQueue = e.updateQueue),
|
|
(t = e.dependencies),
|
|
(n.dependencies =
|
|
null === t
|
|
? null
|
|
: { lanes: t.lanes, firstContext: t.firstContext }),
|
|
(n.sibling = e.sibling),
|
|
(n.index = e.index),
|
|
(n.ref = e.ref),
|
|
n
|
|
);
|
|
}
|
|
function Os(e, t, n, r, l, o) {
|
|
var i = 2;
|
|
if (((r = e), 'function' === typeof e)) Ds(e) && (i = 1);
|
|
else if ('string' === typeof e) i = 5;
|
|
else
|
|
e: switch (e) {
|
|
case x:
|
|
return Fs(n.children, l, o, t);
|
|
case E:
|
|
((i = 8), (l |= 8));
|
|
break;
|
|
case C:
|
|
return (
|
|
((e = Ls(12, n, t, 2 | l)).elementType = C),
|
|
(e.lanes = o),
|
|
e
|
|
);
|
|
case z:
|
|
return (
|
|
((e = Ls(13, n, t, l)).elementType = z),
|
|
(e.lanes = o),
|
|
e
|
|
);
|
|
case T:
|
|
return (
|
|
((e = Ls(19, n, t, l)).elementType = T),
|
|
(e.lanes = o),
|
|
e
|
|
);
|
|
case D:
|
|
return Is(n, l, o, t);
|
|
default:
|
|
if ('object' === typeof e && null !== e)
|
|
switch (e.$$typeof) {
|
|
case _:
|
|
i = 10;
|
|
break e;
|
|
case P:
|
|
i = 9;
|
|
break e;
|
|
case N:
|
|
i = 11;
|
|
break e;
|
|
case M:
|
|
i = 14;
|
|
break e;
|
|
case L:
|
|
((i = 16), (r = null));
|
|
break e;
|
|
}
|
|
throw Error(a(130, null == e ? e : typeof e, ''));
|
|
}
|
|
return (
|
|
((t = Ls(i, n, t, l)).elementType = e),
|
|
(t.type = r),
|
|
(t.lanes = o),
|
|
t
|
|
);
|
|
}
|
|
function Fs(e, t, n, r) {
|
|
return (((e = Ls(7, e, r, t)).lanes = n), e);
|
|
}
|
|
function Is(e, t, n, r) {
|
|
return (
|
|
((e = Ls(22, e, r, t)).elementType = D),
|
|
(e.lanes = n),
|
|
(e.stateNode = { isHidden: !1 }),
|
|
e
|
|
);
|
|
}
|
|
function Us(e, t, n) {
|
|
return (((e = Ls(6, e, null, t)).lanes = n), e);
|
|
}
|
|
function js(e, t, n) {
|
|
return (
|
|
((t = Ls(
|
|
4,
|
|
null !== e.children ? e.children : [],
|
|
e.key,
|
|
t
|
|
)).lanes = n),
|
|
(t.stateNode = {
|
|
containerInfo: e.containerInfo,
|
|
pendingChildren: null,
|
|
implementation: e.implementation,
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
function As(e, t, n, r, l) {
|
|
((this.tag = t),
|
|
(this.containerInfo = e),
|
|
(this.finishedWork =
|
|
this.pingCache =
|
|
this.current =
|
|
this.pendingChildren =
|
|
null),
|
|
(this.timeoutHandle = -1),
|
|
(this.callbackNode = this.pendingContext = this.context = null),
|
|
(this.callbackPriority = 0),
|
|
(this.eventTimes = vt(0)),
|
|
(this.expirationTimes = vt(-1)),
|
|
(this.entangledLanes =
|
|
this.finishedLanes =
|
|
this.mutableReadLanes =
|
|
this.expiredLanes =
|
|
this.pingedLanes =
|
|
this.suspendedLanes =
|
|
this.pendingLanes =
|
|
0),
|
|
(this.entanglements = vt(0)),
|
|
(this.identifierPrefix = r),
|
|
(this.onRecoverableError = l),
|
|
(this.mutableSourceEagerHydrationData = null));
|
|
}
|
|
function Bs(e, t, n, r, l, a, o, i, u) {
|
|
return (
|
|
(e = new As(e, t, n, i, u)),
|
|
1 === t ? ((t = 1), !0 === a && (t |= 8)) : (t = 0),
|
|
(a = Ls(3, null, null, t)),
|
|
(e.current = a),
|
|
(a.stateNode = e),
|
|
(a.memoizedState = {
|
|
element: r,
|
|
isDehydrated: n,
|
|
cache: null,
|
|
transitions: null,
|
|
pendingSuspenseBoundaries: null,
|
|
}),
|
|
Ma(a),
|
|
e
|
|
);
|
|
}
|
|
function Vs(e) {
|
|
if (!e) return Pl;
|
|
e: {
|
|
if (Ve((e = e._reactInternals)) !== e || 1 !== e.tag)
|
|
throw Error(a(170));
|
|
var t = e;
|
|
do {
|
|
switch (t.tag) {
|
|
case 3:
|
|
t = t.stateNode.context;
|
|
break e;
|
|
case 1:
|
|
if (Ll(t.type)) {
|
|
t = t.stateNode.__reactInternalMemoizedMergedChildContext;
|
|
break e;
|
|
}
|
|
}
|
|
t = t.return;
|
|
} while (null !== t);
|
|
throw Error(a(171));
|
|
}
|
|
if (1 === e.tag) {
|
|
var n = e.type;
|
|
if (Ll(n)) return Ol(e, n, t);
|
|
}
|
|
return t;
|
|
}
|
|
function $s(e, t, n, r, l, a, o, i, u) {
|
|
return (
|
|
((e = Bs(n, r, !0, e, 0, a, 0, i, u)).context = Vs(null)),
|
|
(n = e.current),
|
|
((a = Da((r = ts()), (l = ns(n)))).callback =
|
|
void 0 !== t && null !== t ? t : null),
|
|
Ra(n, a, l),
|
|
(e.current.lanes = l),
|
|
gt(e, l, r),
|
|
ls(e, r),
|
|
e
|
|
);
|
|
}
|
|
function Hs(e, t, n, r) {
|
|
var l = t.current,
|
|
a = ts(),
|
|
o = ns(l);
|
|
return (
|
|
(n = Vs(n)),
|
|
null === t.context ? (t.context = n) : (t.pendingContext = n),
|
|
((t = Da(a, o)).payload = { element: e }),
|
|
null !== (r = void 0 === r ? null : r) && (t.callback = r),
|
|
null !== (e = Ra(l, t, o)) && (rs(e, l, o, a), Oa(e, l, o)),
|
|
o
|
|
);
|
|
}
|
|
function Ws(e) {
|
|
return (e = e.current).child
|
|
? (e.child.tag, e.child.stateNode)
|
|
: null;
|
|
}
|
|
function Ks(e, t) {
|
|
if (null !== (e = e.memoizedState) && null !== e.dehydrated) {
|
|
var n = e.retryLane;
|
|
e.retryLane = 0 !== n && n < t ? n : t;
|
|
}
|
|
}
|
|
function Qs(e, t) {
|
|
(Ks(e, t), (e = e.alternate) && Ks(e, t));
|
|
}
|
|
Eu = function (e, t, n) {
|
|
if (null !== e)
|
|
if (e.memoizedProps !== t.pendingProps || zl.current) ki = !0;
|
|
else {
|
|
if (0 === (e.lanes & n) && 0 === (128 & t.flags))
|
|
return (
|
|
(ki = !1),
|
|
(function (e, t, n) {
|
|
switch (t.tag) {
|
|
case 3:
|
|
(Ti(t), pa());
|
|
break;
|
|
case 5:
|
|
ao(t);
|
|
break;
|
|
case 1:
|
|
Ll(t.type) && Fl(t);
|
|
break;
|
|
case 4:
|
|
ro(t, t.stateNode.containerInfo);
|
|
break;
|
|
case 10:
|
|
var r = t.type._context,
|
|
l = t.memoizedProps.value;
|
|
(_l(ga, r._currentValue), (r._currentValue = l));
|
|
break;
|
|
case 13:
|
|
if (null !== (r = t.memoizedState))
|
|
return null !== r.dehydrated
|
|
? (_l(io, 1 & io.current), (t.flags |= 128), null)
|
|
: 0 !== (n & t.child.childLanes)
|
|
? Ui(e, t, n)
|
|
: (_l(io, 1 & io.current),
|
|
null !== (e = Wi(e, t, n)) ? e.sibling : null);
|
|
_l(io, 1 & io.current);
|
|
break;
|
|
case 19:
|
|
if (
|
|
((r = 0 !== (n & t.childLanes)),
|
|
0 !== (128 & e.flags))
|
|
) {
|
|
if (r) return $i(e, t, n);
|
|
t.flags |= 128;
|
|
}
|
|
if (
|
|
(null !== (l = t.memoizedState) &&
|
|
((l.rendering = null),
|
|
(l.tail = null),
|
|
(l.lastEffect = null)),
|
|
_l(io, io.current),
|
|
r)
|
|
)
|
|
break;
|
|
return null;
|
|
case 22:
|
|
case 23:
|
|
return ((t.lanes = 0), Ci(e, t, n));
|
|
}
|
|
return Wi(e, t, n);
|
|
})(e, t, n)
|
|
);
|
|
ki = 0 !== (131072 & e.flags);
|
|
}
|
|
else
|
|
((ki = !1), la && 0 !== (1048576 & t.flags) && Jl(t, Kl, t.index));
|
|
switch (((t.lanes = 0), t.tag)) {
|
|
case 2:
|
|
var r = t.type;
|
|
(Hi(e, t), (e = t.pendingProps));
|
|
var l = Ml(t, Nl.current);
|
|
(Ea(t, n), (l = Eo(null, t, r, e, l, n)));
|
|
var o = Co();
|
|
return (
|
|
(t.flags |= 1),
|
|
'object' === typeof l &&
|
|
null !== l &&
|
|
'function' === typeof l.render &&
|
|
void 0 === l.$$typeof
|
|
? ((t.tag = 1),
|
|
(t.memoizedState = null),
|
|
(t.updateQueue = null),
|
|
Ll(r) ? ((o = !0), Fl(t)) : (o = !1),
|
|
(t.memoizedState =
|
|
null !== l.state && void 0 !== l.state ? l.state : null),
|
|
Ma(t),
|
|
(l.updater = Ba),
|
|
(t.stateNode = l),
|
|
(l._reactInternals = t),
|
|
Wa(t, r, e, n),
|
|
(t = zi(null, t, r, !0, o, n)))
|
|
: ((t.tag = 0),
|
|
la && o && ea(t),
|
|
wi(null, t, l, n),
|
|
(t = t.child)),
|
|
t
|
|
);
|
|
case 16:
|
|
r = t.elementType;
|
|
e: {
|
|
switch (
|
|
(Hi(e, t),
|
|
(e = t.pendingProps),
|
|
(r = (l = r._init)(r._payload)),
|
|
(t.type = r),
|
|
(l = t.tag =
|
|
(function (e) {
|
|
if ('function' === typeof e) return Ds(e) ? 1 : 0;
|
|
if (void 0 !== e && null !== e) {
|
|
if ((e = e.$$typeof) === N) return 11;
|
|
if (e === M) return 14;
|
|
}
|
|
return 2;
|
|
})(r)),
|
|
(e = va(r, e)),
|
|
l)
|
|
) {
|
|
case 0:
|
|
t = Pi(null, t, r, e, n);
|
|
break e;
|
|
case 1:
|
|
t = Ni(null, t, r, e, n);
|
|
break e;
|
|
case 11:
|
|
t = Si(null, t, r, e, n);
|
|
break e;
|
|
case 14:
|
|
t = xi(null, t, r, va(r.type, e), n);
|
|
break e;
|
|
}
|
|
throw Error(a(306, r, ''));
|
|
}
|
|
return t;
|
|
case 0:
|
|
return (
|
|
(r = t.type),
|
|
(l = t.pendingProps),
|
|
Pi(e, t, r, (l = t.elementType === r ? l : va(r, l)), n)
|
|
);
|
|
case 1:
|
|
return (
|
|
(r = t.type),
|
|
(l = t.pendingProps),
|
|
Ni(e, t, r, (l = t.elementType === r ? l : va(r, l)), n)
|
|
);
|
|
case 3:
|
|
e: {
|
|
if ((Ti(t), null === e)) throw Error(a(387));
|
|
((r = t.pendingProps),
|
|
(l = (o = t.memoizedState).element),
|
|
La(e, t),
|
|
Ia(t, r, null, n));
|
|
var i = t.memoizedState;
|
|
if (((r = i.element), o.isDehydrated)) {
|
|
if (
|
|
((o = {
|
|
element: r,
|
|
isDehydrated: !1,
|
|
cache: i.cache,
|
|
pendingSuspenseBoundaries: i.pendingSuspenseBoundaries,
|
|
transitions: i.transitions,
|
|
}),
|
|
(t.updateQueue.baseState = o),
|
|
(t.memoizedState = o),
|
|
256 & t.flags)
|
|
) {
|
|
t = Mi(e, t, r, n, (l = ci(Error(a(423)), t)));
|
|
break e;
|
|
}
|
|
if (r !== l) {
|
|
t = Mi(e, t, r, n, (l = ci(Error(a(424)), t)));
|
|
break e;
|
|
}
|
|
for (
|
|
ra = sl(t.stateNode.containerInfo.firstChild),
|
|
na = t,
|
|
la = !0,
|
|
aa = null,
|
|
n = Ga(t, null, r, n),
|
|
t.child = n;
|
|
n;
|
|
)
|
|
((n.flags = (-3 & n.flags) | 4096), (n = n.sibling));
|
|
} else {
|
|
if ((pa(), r === l)) {
|
|
t = Wi(e, t, n);
|
|
break e;
|
|
}
|
|
wi(e, t, r, n);
|
|
}
|
|
t = t.child;
|
|
}
|
|
return t;
|
|
case 5:
|
|
return (
|
|
ao(t),
|
|
null === e && sa(t),
|
|
(r = t.type),
|
|
(l = t.pendingProps),
|
|
(o = null !== e ? e.memoizedProps : null),
|
|
(i = l.children),
|
|
nl(r, l)
|
|
? (i = null)
|
|
: null !== o && nl(r, o) && (t.flags |= 32),
|
|
_i(e, t),
|
|
wi(e, t, i, n),
|
|
t.child
|
|
);
|
|
case 6:
|
|
return (null === e && sa(t), null);
|
|
case 13:
|
|
return Ui(e, t, n);
|
|
case 4:
|
|
return (
|
|
ro(t, t.stateNode.containerInfo),
|
|
(r = t.pendingProps),
|
|
null === e ? (t.child = Xa(t, null, r, n)) : wi(e, t, r, n),
|
|
t.child
|
|
);
|
|
case 11:
|
|
return (
|
|
(r = t.type),
|
|
(l = t.pendingProps),
|
|
Si(e, t, r, (l = t.elementType === r ? l : va(r, l)), n)
|
|
);
|
|
case 7:
|
|
return (wi(e, t, t.pendingProps, n), t.child);
|
|
case 8:
|
|
case 12:
|
|
return (wi(e, t, t.pendingProps.children, n), t.child);
|
|
case 10:
|
|
e: {
|
|
if (
|
|
((r = t.type._context),
|
|
(l = t.pendingProps),
|
|
(o = t.memoizedProps),
|
|
(i = l.value),
|
|
_l(ga, r._currentValue),
|
|
(r._currentValue = i),
|
|
null !== o)
|
|
)
|
|
if (ir(o.value, i)) {
|
|
if (o.children === l.children && !zl.current) {
|
|
t = Wi(e, t, n);
|
|
break e;
|
|
}
|
|
} else
|
|
for (
|
|
null !== (o = t.child) && (o.return = t);
|
|
null !== o;
|
|
) {
|
|
var u = o.dependencies;
|
|
if (null !== u) {
|
|
i = o.child;
|
|
for (var s = u.firstContext; null !== s; ) {
|
|
if (s.context === r) {
|
|
if (1 === o.tag) {
|
|
(s = Da(-1, n & -n)).tag = 2;
|
|
var c = o.updateQueue;
|
|
if (null !== c) {
|
|
var f = (c = c.shared).pending;
|
|
(null === f
|
|
? (s.next = s)
|
|
: ((s.next = f.next), (f.next = s)),
|
|
(c.pending = s));
|
|
}
|
|
}
|
|
((o.lanes |= n),
|
|
null !== (s = o.alternate) && (s.lanes |= n),
|
|
xa(o.return, n, t),
|
|
(u.lanes |= n));
|
|
break;
|
|
}
|
|
s = s.next;
|
|
}
|
|
} else if (10 === o.tag)
|
|
i = o.type === t.type ? null : o.child;
|
|
else if (18 === o.tag) {
|
|
if (null === (i = o.return)) throw Error(a(341));
|
|
((i.lanes |= n),
|
|
null !== (u = i.alternate) && (u.lanes |= n),
|
|
xa(i, n, t),
|
|
(i = o.sibling));
|
|
} else i = o.child;
|
|
if (null !== i) i.return = o;
|
|
else
|
|
for (i = o; null !== i; ) {
|
|
if (i === t) {
|
|
i = null;
|
|
break;
|
|
}
|
|
if (null !== (o = i.sibling)) {
|
|
((o.return = i.return), (i = o));
|
|
break;
|
|
}
|
|
i = i.return;
|
|
}
|
|
o = i;
|
|
}
|
|
(wi(e, t, l.children, n), (t = t.child));
|
|
}
|
|
return t;
|
|
case 9:
|
|
return (
|
|
(l = t.type),
|
|
(r = t.pendingProps.children),
|
|
Ea(t, n),
|
|
(r = r((l = Ca(l)))),
|
|
(t.flags |= 1),
|
|
wi(e, t, r, n),
|
|
t.child
|
|
);
|
|
case 14:
|
|
return (
|
|
(l = va((r = t.type), t.pendingProps)),
|
|
xi(e, t, r, (l = va(r.type, l)), n)
|
|
);
|
|
case 15:
|
|
return Ei(e, t, t.type, t.pendingProps, n);
|
|
case 17:
|
|
return (
|
|
(r = t.type),
|
|
(l = t.pendingProps),
|
|
(l = t.elementType === r ? l : va(r, l)),
|
|
Hi(e, t),
|
|
(t.tag = 1),
|
|
Ll(r) ? ((e = !0), Fl(t)) : (e = !1),
|
|
Ea(t, n),
|
|
$a(t, r, l),
|
|
Wa(t, r, l, n),
|
|
zi(null, t, r, !0, e, n)
|
|
);
|
|
case 19:
|
|
return $i(e, t, n);
|
|
case 22:
|
|
return Ci(e, t, n);
|
|
}
|
|
throw Error(a(156, t.tag));
|
|
};
|
|
var qs =
|
|
'function' === typeof reportError
|
|
? reportError
|
|
: function (e) {
|
|
console.error(e);
|
|
};
|
|
function Ys(e) {
|
|
this._internalRoot = e;
|
|
}
|
|
function Xs(e) {
|
|
this._internalRoot = e;
|
|
}
|
|
function Gs(e) {
|
|
return !(
|
|
!e ||
|
|
(1 !== e.nodeType && 9 !== e.nodeType && 11 !== e.nodeType)
|
|
);
|
|
}
|
|
function Zs(e) {
|
|
return !(
|
|
!e ||
|
|
(1 !== e.nodeType &&
|
|
9 !== e.nodeType &&
|
|
11 !== e.nodeType &&
|
|
(8 !== e.nodeType ||
|
|
' react-mount-point-unstable ' !== e.nodeValue))
|
|
);
|
|
}
|
|
function Js() {}
|
|
function ec(e, t, n, r, l) {
|
|
var a = n._reactRootContainer;
|
|
if (a) {
|
|
var o = a;
|
|
if ('function' === typeof l) {
|
|
var i = l;
|
|
l = function () {
|
|
var e = Ws(o);
|
|
i.call(e);
|
|
};
|
|
}
|
|
Hs(t, o, e, l);
|
|
} else
|
|
o = (function (e, t, n, r, l) {
|
|
if (l) {
|
|
if ('function' === typeof r) {
|
|
var a = r;
|
|
r = function () {
|
|
var e = Ws(o);
|
|
a.call(e);
|
|
};
|
|
}
|
|
var o = $s(t, r, e, 0, null, !1, 0, '', Js);
|
|
return (
|
|
(e._reactRootContainer = o),
|
|
(e[hl] = o.current),
|
|
Vr(8 === e.nodeType ? e.parentNode : e),
|
|
fs(),
|
|
o
|
|
);
|
|
}
|
|
for (; (l = e.lastChild); ) e.removeChild(l);
|
|
if ('function' === typeof r) {
|
|
var i = r;
|
|
r = function () {
|
|
var e = Ws(u);
|
|
i.call(e);
|
|
};
|
|
}
|
|
var u = Bs(e, 0, !1, null, 0, !1, 0, '', Js);
|
|
return (
|
|
(e._reactRootContainer = u),
|
|
(e[hl] = u.current),
|
|
Vr(8 === e.nodeType ? e.parentNode : e),
|
|
fs(function () {
|
|
Hs(t, u, n, r);
|
|
}),
|
|
u
|
|
);
|
|
})(n, t, e, l, r);
|
|
return Ws(o);
|
|
}
|
|
((Xs.prototype.render = Ys.prototype.render =
|
|
function (e) {
|
|
var t = this._internalRoot;
|
|
if (null === t) throw Error(a(409));
|
|
Hs(e, t, null, null);
|
|
}),
|
|
(Xs.prototype.unmount = Ys.prototype.unmount =
|
|
function () {
|
|
var e = this._internalRoot;
|
|
if (null !== e) {
|
|
this._internalRoot = null;
|
|
var t = e.containerInfo;
|
|
(fs(function () {
|
|
Hs(null, e, null, null);
|
|
}),
|
|
(t[hl] = null));
|
|
}
|
|
}),
|
|
(Xs.prototype.unstable_scheduleHydration = function (e) {
|
|
if (e) {
|
|
var t = Et();
|
|
e = { blockedOn: null, target: e, priority: t };
|
|
for (
|
|
var n = 0;
|
|
n < Dt.length && 0 !== t && t < Dt[n].priority;
|
|
n++
|
|
);
|
|
(Dt.splice(n, 0, e), 0 === n && It(e));
|
|
}
|
|
}),
|
|
(wt = function (e) {
|
|
switch (e.tag) {
|
|
case 3:
|
|
var t = e.stateNode;
|
|
if (t.current.memoizedState.isDehydrated) {
|
|
var n = ft(t.pendingLanes);
|
|
0 !== n &&
|
|
(yt(t, 1 | n),
|
|
ls(t, Ge()),
|
|
0 === (6 & zu) && (($u = Ge() + 500), Vl()));
|
|
}
|
|
break;
|
|
case 13:
|
|
(fs(function () {
|
|
var t = za(e, 1);
|
|
if (null !== t) {
|
|
var n = ts();
|
|
rs(t, e, 1, n);
|
|
}
|
|
}),
|
|
Qs(e, 1));
|
|
}
|
|
}),
|
|
(St = function (e) {
|
|
if (13 === e.tag) {
|
|
var t = za(e, 134217728);
|
|
if (null !== t) rs(t, e, 134217728, ts());
|
|
Qs(e, 134217728);
|
|
}
|
|
}),
|
|
(xt = function (e) {
|
|
if (13 === e.tag) {
|
|
var t = ns(e),
|
|
n = za(e, t);
|
|
if (null !== n) rs(n, e, t, ts());
|
|
Qs(e, t);
|
|
}
|
|
}),
|
|
(Et = function () {
|
|
return bt;
|
|
}),
|
|
(Ct = function (e, t) {
|
|
var n = bt;
|
|
try {
|
|
return ((bt = e), t());
|
|
} finally {
|
|
bt = n;
|
|
}
|
|
}),
|
|
(Se = function (e, t, n) {
|
|
switch (t) {
|
|
case 'input':
|
|
if ((Z(e, n), (t = n.name), 'radio' === n.type && null != t)) {
|
|
for (n = e; n.parentNode; ) n = n.parentNode;
|
|
for (
|
|
n = n.querySelectorAll(
|
|
'input[name=' + JSON.stringify('' + t) + '][type="radio"]'
|
|
),
|
|
t = 0;
|
|
t < n.length;
|
|
t++
|
|
) {
|
|
var r = n[t];
|
|
if (r !== e && r.form === e.form) {
|
|
var l = wl(r);
|
|
if (!l) throw Error(a(90));
|
|
(Q(r), Z(r, l));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 'textarea':
|
|
ae(e, n);
|
|
break;
|
|
case 'select':
|
|
null != (t = n.value) && ne(e, !!n.multiple, t, !1);
|
|
}
|
|
}),
|
|
(Ne = cs),
|
|
(ze = fs));
|
|
var tc = {
|
|
usingClientEntryPoint: !1,
|
|
Events: [bl, kl, wl, _e, Pe, cs],
|
|
},
|
|
nc = {
|
|
findFiberByHostInstance: yl,
|
|
bundleType: 0,
|
|
version: '18.2.0',
|
|
rendererPackageName: 'react-dom',
|
|
},
|
|
rc = {
|
|
bundleType: nc.bundleType,
|
|
version: nc.version,
|
|
rendererPackageName: nc.rendererPackageName,
|
|
rendererConfig: nc.rendererConfig,
|
|
overrideHookState: null,
|
|
overrideHookStateDeletePath: null,
|
|
overrideHookStateRenamePath: null,
|
|
overrideProps: null,
|
|
overridePropsDeletePath: null,
|
|
overridePropsRenamePath: null,
|
|
setErrorHandler: null,
|
|
setSuspenseHandler: null,
|
|
scheduleUpdate: null,
|
|
currentDispatcherRef: k.ReactCurrentDispatcher,
|
|
findHostInstanceByFiber: function (e) {
|
|
return null === (e = We(e)) ? null : e.stateNode;
|
|
},
|
|
findFiberByHostInstance:
|
|
nc.findFiberByHostInstance ||
|
|
function () {
|
|
return null;
|
|
},
|
|
findHostInstancesForRefresh: null,
|
|
scheduleRefresh: null,
|
|
scheduleRoot: null,
|
|
setRefreshHandler: null,
|
|
getCurrentFiber: null,
|
|
reconcilerVersion: '18.2.0-next-9e3b772b8-20220608',
|
|
};
|
|
if ('undefined' !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
|
|
var lc = __REACT_DEVTOOLS_GLOBAL_HOOK__;
|
|
if (!lc.isDisabled && lc.supportsFiber)
|
|
try {
|
|
((lt = lc.inject(rc)), (at = lc));
|
|
} catch (ce) {}
|
|
}
|
|
((t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = tc),
|
|
(t.createPortal = function (e, t) {
|
|
var n =
|
|
2 < arguments.length && void 0 !== arguments[2]
|
|
? arguments[2]
|
|
: null;
|
|
if (!Gs(t)) throw Error(a(200));
|
|
return (function (e, t, n) {
|
|
var r =
|
|
3 < arguments.length && void 0 !== arguments[3]
|
|
? arguments[3]
|
|
: null;
|
|
return {
|
|
$$typeof: S,
|
|
key: null == r ? null : '' + r,
|
|
children: e,
|
|
containerInfo: t,
|
|
implementation: n,
|
|
};
|
|
})(e, t, null, n);
|
|
}),
|
|
(t.createRoot = function (e, t) {
|
|
if (!Gs(e)) throw Error(a(299));
|
|
var n = !1,
|
|
r = '',
|
|
l = qs;
|
|
return (
|
|
null !== t &&
|
|
void 0 !== t &&
|
|
(!0 === t.unstable_strictMode && (n = !0),
|
|
void 0 !== t.identifierPrefix && (r = t.identifierPrefix),
|
|
void 0 !== t.onRecoverableError && (l = t.onRecoverableError)),
|
|
(t = Bs(e, 1, !1, null, 0, n, 0, r, l)),
|
|
(e[hl] = t.current),
|
|
Vr(8 === e.nodeType ? e.parentNode : e),
|
|
new Ys(t)
|
|
);
|
|
}),
|
|
(t.findDOMNode = function (e) {
|
|
if (null == e) return null;
|
|
if (1 === e.nodeType) return e;
|
|
var t = e._reactInternals;
|
|
if (void 0 === t) {
|
|
if ('function' === typeof e.render) throw Error(a(188));
|
|
throw ((e = Object.keys(e).join(',')), Error(a(268, e)));
|
|
}
|
|
return (e = null === (e = We(t)) ? null : e.stateNode);
|
|
}),
|
|
(t.flushSync = function (e) {
|
|
return fs(e);
|
|
}),
|
|
(t.hydrate = function (e, t, n) {
|
|
if (!Zs(t)) throw Error(a(200));
|
|
return ec(null, e, t, !0, n);
|
|
}),
|
|
(t.hydrateRoot = function (e, t, n) {
|
|
if (!Gs(e)) throw Error(a(405));
|
|
var r = (null != n && n.hydratedSources) || null,
|
|
l = !1,
|
|
o = '',
|
|
i = qs;
|
|
if (
|
|
(null !== n &&
|
|
void 0 !== n &&
|
|
(!0 === n.unstable_strictMode && (l = !0),
|
|
void 0 !== n.identifierPrefix && (o = n.identifierPrefix),
|
|
void 0 !== n.onRecoverableError && (i = n.onRecoverableError)),
|
|
(t = $s(t, null, e, 1, null != n ? n : null, l, 0, o, i)),
|
|
(e[hl] = t.current),
|
|
Vr(e),
|
|
r)
|
|
)
|
|
for (e = 0; e < r.length; e++)
|
|
((l = (l = (n = r[e])._getVersion)(n._source)),
|
|
null == t.mutableSourceEagerHydrationData
|
|
? (t.mutableSourceEagerHydrationData = [n, l])
|
|
: t.mutableSourceEagerHydrationData.push(n, l));
|
|
return new Xs(t);
|
|
}),
|
|
(t.render = function (e, t, n) {
|
|
if (!Zs(t)) throw Error(a(200));
|
|
return ec(null, e, t, !1, n);
|
|
}),
|
|
(t.unmountComponentAtNode = function (e) {
|
|
if (!Zs(e)) throw Error(a(40));
|
|
return (
|
|
!!e._reactRootContainer &&
|
|
(fs(function () {
|
|
ec(null, null, e, !1, function () {
|
|
((e._reactRootContainer = null), (e[hl] = null));
|
|
});
|
|
}),
|
|
!0)
|
|
);
|
|
}),
|
|
(t.unstable_batchedUpdates = cs),
|
|
(t.unstable_renderSubtreeIntoContainer = function (e, t, n, r) {
|
|
if (!Zs(n)) throw Error(a(200));
|
|
if (null == e || void 0 === e._reactInternals) throw Error(a(38));
|
|
return ec(e, t, n, !1, r);
|
|
}),
|
|
(t.version = '18.2.0-next-9e3b772b8-20220608'));
|
|
},
|
|
250: (e, t, n) => {
|
|
var r = n(164);
|
|
((t.createRoot = r.createRoot), (t.hydrateRoot = r.hydrateRoot));
|
|
},
|
|
164: (e, t, n) => {
|
|
(!(function e() {
|
|
if (
|
|
'undefined' !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
|
'function' === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE
|
|
)
|
|
try {
|
|
__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e);
|
|
} catch (t) {
|
|
console.error(t);
|
|
}
|
|
})(),
|
|
(e.exports = n(463)));
|
|
},
|
|
374: (e, t, n) => {
|
|
var r = n(791),
|
|
l = Symbol.for('react.element'),
|
|
a = Symbol.for('react.fragment'),
|
|
o = Object.prototype.hasOwnProperty,
|
|
i =
|
|
r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
|
|
.ReactCurrentOwner,
|
|
u = { key: !0, ref: !0, __self: !0, __source: !0 };
|
|
function s(e, t, n) {
|
|
var r,
|
|
a = {},
|
|
s = null,
|
|
c = null;
|
|
for (r in (void 0 !== n && (s = '' + n),
|
|
void 0 !== t.key && (s = '' + t.key),
|
|
void 0 !== t.ref && (c = t.ref),
|
|
t))
|
|
o.call(t, r) && !u.hasOwnProperty(r) && (a[r] = t[r]);
|
|
if (e && e.defaultProps)
|
|
for (r in (t = e.defaultProps)) void 0 === a[r] && (a[r] = t[r]);
|
|
return {
|
|
$$typeof: l,
|
|
type: e,
|
|
key: s,
|
|
ref: c,
|
|
props: a,
|
|
_owner: i.current,
|
|
};
|
|
}
|
|
((t.Fragment = a), (t.jsx = s), (t.jsxs = s));
|
|
},
|
|
117: (e, t) => {
|
|
var n = Symbol.for('react.element'),
|
|
r = Symbol.for('react.portal'),
|
|
l = Symbol.for('react.fragment'),
|
|
a = Symbol.for('react.strict_mode'),
|
|
o = Symbol.for('react.profiler'),
|
|
i = Symbol.for('react.provider'),
|
|
u = Symbol.for('react.context'),
|
|
s = Symbol.for('react.forward_ref'),
|
|
c = Symbol.for('react.suspense'),
|
|
f = Symbol.for('react.memo'),
|
|
d = Symbol.for('react.lazy'),
|
|
p = Symbol.iterator;
|
|
var h = {
|
|
isMounted: function () {
|
|
return !1;
|
|
},
|
|
enqueueForceUpdate: function () {},
|
|
enqueueReplaceState: function () {},
|
|
enqueueSetState: function () {},
|
|
},
|
|
m = Object.assign,
|
|
v = {};
|
|
function g(e, t, n) {
|
|
((this.props = e),
|
|
(this.context = t),
|
|
(this.refs = v),
|
|
(this.updater = n || h));
|
|
}
|
|
function y() {}
|
|
function b(e, t, n) {
|
|
((this.props = e),
|
|
(this.context = t),
|
|
(this.refs = v),
|
|
(this.updater = n || h));
|
|
}
|
|
((g.prototype.isReactComponent = {}),
|
|
(g.prototype.setState = function (e, t) {
|
|
if ('object' !== typeof e && 'function' !== typeof e && null != e)
|
|
throw Error(
|
|
'setState(...): takes an object of state variables to update or a function which returns an object of state variables.'
|
|
);
|
|
this.updater.enqueueSetState(this, e, t, 'setState');
|
|
}),
|
|
(g.prototype.forceUpdate = function (e) {
|
|
this.updater.enqueueForceUpdate(this, e, 'forceUpdate');
|
|
}),
|
|
(y.prototype = g.prototype));
|
|
var k = (b.prototype = new y());
|
|
((k.constructor = b), m(k, g.prototype), (k.isPureReactComponent = !0));
|
|
var w = Array.isArray,
|
|
S = Object.prototype.hasOwnProperty,
|
|
x = { current: null },
|
|
E = { key: !0, ref: !0, __self: !0, __source: !0 };
|
|
function C(e, t, r) {
|
|
var l,
|
|
a = {},
|
|
o = null,
|
|
i = null;
|
|
if (null != t)
|
|
for (l in (void 0 !== t.ref && (i = t.ref),
|
|
void 0 !== t.key && (o = '' + t.key),
|
|
t))
|
|
S.call(t, l) && !E.hasOwnProperty(l) && (a[l] = t[l]);
|
|
var u = arguments.length - 2;
|
|
if (1 === u) a.children = r;
|
|
else if (1 < u) {
|
|
for (var s = Array(u), c = 0; c < u; c++) s[c] = arguments[c + 2];
|
|
a.children = s;
|
|
}
|
|
if (e && e.defaultProps)
|
|
for (l in (u = e.defaultProps)) void 0 === a[l] && (a[l] = u[l]);
|
|
return {
|
|
$$typeof: n,
|
|
type: e,
|
|
key: o,
|
|
ref: i,
|
|
props: a,
|
|
_owner: x.current,
|
|
};
|
|
}
|
|
function _(e) {
|
|
return 'object' === typeof e && null !== e && e.$$typeof === n;
|
|
}
|
|
var P = /\/+/g;
|
|
function N(e, t) {
|
|
return 'object' === typeof e && null !== e && null != e.key
|
|
? (function (e) {
|
|
var t = { '=': '=0', ':': '=2' };
|
|
return (
|
|
'$' +
|
|
e.replace(/[=:]/g, function (e) {
|
|
return t[e];
|
|
})
|
|
);
|
|
})('' + e.key)
|
|
: t.toString(36);
|
|
}
|
|
function z(e, t, l, a, o) {
|
|
var i = typeof e;
|
|
('undefined' !== i && 'boolean' !== i) || (e = null);
|
|
var u = !1;
|
|
if (null === e) u = !0;
|
|
else
|
|
switch (i) {
|
|
case 'string':
|
|
case 'number':
|
|
u = !0;
|
|
break;
|
|
case 'object':
|
|
switch (e.$$typeof) {
|
|
case n:
|
|
case r:
|
|
u = !0;
|
|
}
|
|
}
|
|
if (u)
|
|
return (
|
|
(o = o((u = e))),
|
|
(e = '' === a ? '.' + N(u, 0) : a),
|
|
w(o)
|
|
? ((l = ''),
|
|
null != e && (l = e.replace(P, '$&/') + '/'),
|
|
z(o, t, l, '', function (e) {
|
|
return e;
|
|
}))
|
|
: null != o &&
|
|
(_(o) &&
|
|
(o = (function (e, t) {
|
|
return {
|
|
$$typeof: n,
|
|
type: e.type,
|
|
key: t,
|
|
ref: e.ref,
|
|
props: e.props,
|
|
_owner: e._owner,
|
|
};
|
|
})(
|
|
o,
|
|
l +
|
|
(!o.key || (u && u.key === o.key)
|
|
? ''
|
|
: ('' + o.key).replace(P, '$&/') + '/') +
|
|
e
|
|
)),
|
|
t.push(o)),
|
|
1
|
|
);
|
|
if (((u = 0), (a = '' === a ? '.' : a + ':'), w(e)))
|
|
for (var s = 0; s < e.length; s++) {
|
|
var c = a + N((i = e[s]), s);
|
|
u += z(i, t, l, c, o);
|
|
}
|
|
else if (
|
|
((c = (function (e) {
|
|
return null === e || 'object' !== typeof e
|
|
? null
|
|
: 'function' === typeof (e = (p && e[p]) || e['@@iterator'])
|
|
? e
|
|
: null;
|
|
})(e)),
|
|
'function' === typeof c)
|
|
)
|
|
for (e = c.call(e), s = 0; !(i = e.next()).done; )
|
|
u += z((i = i.value), t, l, (c = a + N(i, s++)), o);
|
|
else if ('object' === i)
|
|
throw (
|
|
(t = String(e)),
|
|
Error(
|
|
'Objects are not valid as a React child (found: ' +
|
|
('[object Object]' === t
|
|
? 'object with keys {' + Object.keys(e).join(', ') + '}'
|
|
: t) +
|
|
'). If you meant to render a collection of children, use an array instead.'
|
|
)
|
|
);
|
|
return u;
|
|
}
|
|
function T(e, t, n) {
|
|
if (null == e) return e;
|
|
var r = [],
|
|
l = 0;
|
|
return (
|
|
z(e, r, '', '', function (e) {
|
|
return t.call(n, e, l++);
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
function M(e) {
|
|
if (-1 === e._status) {
|
|
var t = e._result;
|
|
((t = t()).then(
|
|
function (t) {
|
|
(0 !== e._status && -1 !== e._status) ||
|
|
((e._status = 1), (e._result = t));
|
|
},
|
|
function (t) {
|
|
(0 !== e._status && -1 !== e._status) ||
|
|
((e._status = 2), (e._result = t));
|
|
}
|
|
),
|
|
-1 === e._status && ((e._status = 0), (e._result = t)));
|
|
}
|
|
if (1 === e._status) return e._result.default;
|
|
throw e._result;
|
|
}
|
|
var L = { current: null },
|
|
D = { transition: null },
|
|
R = {
|
|
ReactCurrentDispatcher: L,
|
|
ReactCurrentBatchConfig: D,
|
|
ReactCurrentOwner: x,
|
|
};
|
|
((t.Children = {
|
|
map: T,
|
|
forEach: function (e, t, n) {
|
|
T(
|
|
e,
|
|
function () {
|
|
t.apply(this, arguments);
|
|
},
|
|
n
|
|
);
|
|
},
|
|
count: function (e) {
|
|
var t = 0;
|
|
return (
|
|
T(e, function () {
|
|
t++;
|
|
}),
|
|
t
|
|
);
|
|
},
|
|
toArray: function (e) {
|
|
return (
|
|
T(e, function (e) {
|
|
return e;
|
|
}) || []
|
|
);
|
|
},
|
|
only: function (e) {
|
|
if (!_(e))
|
|
throw Error(
|
|
'React.Children.only expected to receive a single React element child.'
|
|
);
|
|
return e;
|
|
},
|
|
}),
|
|
(t.Component = g),
|
|
(t.Fragment = l),
|
|
(t.Profiler = o),
|
|
(t.PureComponent = b),
|
|
(t.StrictMode = a),
|
|
(t.Suspense = c),
|
|
(t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = R),
|
|
(t.cloneElement = function (e, t, r) {
|
|
if (null === e || void 0 === e)
|
|
throw Error(
|
|
'React.cloneElement(...): The argument must be a React element, but you passed ' +
|
|
e +
|
|
'.'
|
|
);
|
|
var l = m({}, e.props),
|
|
a = e.key,
|
|
o = e.ref,
|
|
i = e._owner;
|
|
if (null != t) {
|
|
if (
|
|
(void 0 !== t.ref && ((o = t.ref), (i = x.current)),
|
|
void 0 !== t.key && (a = '' + t.key),
|
|
e.type && e.type.defaultProps)
|
|
)
|
|
var u = e.type.defaultProps;
|
|
for (s in t)
|
|
S.call(t, s) &&
|
|
!E.hasOwnProperty(s) &&
|
|
(l[s] = void 0 === t[s] && void 0 !== u ? u[s] : t[s]);
|
|
}
|
|
var s = arguments.length - 2;
|
|
if (1 === s) l.children = r;
|
|
else if (1 < s) {
|
|
u = Array(s);
|
|
for (var c = 0; c < s; c++) u[c] = arguments[c + 2];
|
|
l.children = u;
|
|
}
|
|
return {
|
|
$$typeof: n,
|
|
type: e.type,
|
|
key: a,
|
|
ref: o,
|
|
props: l,
|
|
_owner: i,
|
|
};
|
|
}),
|
|
(t.createContext = function (e) {
|
|
return (
|
|
((e = {
|
|
$$typeof: u,
|
|
_currentValue: e,
|
|
_currentValue2: e,
|
|
_threadCount: 0,
|
|
Provider: null,
|
|
Consumer: null,
|
|
_defaultValue: null,
|
|
_globalName: null,
|
|
}).Provider = { $$typeof: i, _context: e }),
|
|
(e.Consumer = e)
|
|
);
|
|
}),
|
|
(t.createElement = C),
|
|
(t.createFactory = function (e) {
|
|
var t = C.bind(null, e);
|
|
return ((t.type = e), t);
|
|
}),
|
|
(t.createRef = function () {
|
|
return { current: null };
|
|
}),
|
|
(t.forwardRef = function (e) {
|
|
return { $$typeof: s, render: e };
|
|
}),
|
|
(t.isValidElement = _),
|
|
(t.lazy = function (e) {
|
|
return {
|
|
$$typeof: d,
|
|
_payload: { _status: -1, _result: e },
|
|
_init: M,
|
|
};
|
|
}),
|
|
(t.memo = function (e, t) {
|
|
return { $$typeof: f, type: e, compare: void 0 === t ? null : t };
|
|
}),
|
|
(t.startTransition = function (e) {
|
|
var t = D.transition;
|
|
D.transition = {};
|
|
try {
|
|
e();
|
|
} finally {
|
|
D.transition = t;
|
|
}
|
|
}),
|
|
(t.unstable_act = function () {
|
|
throw Error(
|
|
'act(...) is not supported in production builds of React.'
|
|
);
|
|
}),
|
|
(t.useCallback = function (e, t) {
|
|
return L.current.useCallback(e, t);
|
|
}),
|
|
(t.useContext = function (e) {
|
|
return L.current.useContext(e);
|
|
}),
|
|
(t.useDebugValue = function () {}),
|
|
(t.useDeferredValue = function (e) {
|
|
return L.current.useDeferredValue(e);
|
|
}),
|
|
(t.useEffect = function (e, t) {
|
|
return L.current.useEffect(e, t);
|
|
}),
|
|
(t.useId = function () {
|
|
return L.current.useId();
|
|
}),
|
|
(t.useImperativeHandle = function (e, t, n) {
|
|
return L.current.useImperativeHandle(e, t, n);
|
|
}),
|
|
(t.useInsertionEffect = function (e, t) {
|
|
return L.current.useInsertionEffect(e, t);
|
|
}),
|
|
(t.useLayoutEffect = function (e, t) {
|
|
return L.current.useLayoutEffect(e, t);
|
|
}),
|
|
(t.useMemo = function (e, t) {
|
|
return L.current.useMemo(e, t);
|
|
}),
|
|
(t.useReducer = function (e, t, n) {
|
|
return L.current.useReducer(e, t, n);
|
|
}),
|
|
(t.useRef = function (e) {
|
|
return L.current.useRef(e);
|
|
}),
|
|
(t.useState = function (e) {
|
|
return L.current.useState(e);
|
|
}),
|
|
(t.useSyncExternalStore = function (e, t, n) {
|
|
return L.current.useSyncExternalStore(e, t, n);
|
|
}),
|
|
(t.useTransition = function () {
|
|
return L.current.useTransition();
|
|
}),
|
|
(t.version = '18.2.0'));
|
|
},
|
|
791: (e, t, n) => {
|
|
e.exports = n(117);
|
|
},
|
|
184: (e, t, n) => {
|
|
e.exports = n(374);
|
|
},
|
|
813: (e, t) => {
|
|
function n(e, t) {
|
|
var n = e.length;
|
|
e.push(t);
|
|
e: for (; 0 < n; ) {
|
|
var r = (n - 1) >>> 1,
|
|
l = e[r];
|
|
if (!(0 < a(l, t))) break e;
|
|
((e[r] = t), (e[n] = l), (n = r));
|
|
}
|
|
}
|
|
function r(e) {
|
|
return 0 === e.length ? null : e[0];
|
|
}
|
|
function l(e) {
|
|
if (0 === e.length) return null;
|
|
var t = e[0],
|
|
n = e.pop();
|
|
if (n !== t) {
|
|
e[0] = n;
|
|
e: for (var r = 0, l = e.length, o = l >>> 1; r < o; ) {
|
|
var i = 2 * (r + 1) - 1,
|
|
u = e[i],
|
|
s = i + 1,
|
|
c = e[s];
|
|
if (0 > a(u, n))
|
|
s < l && 0 > a(c, u)
|
|
? ((e[r] = c), (e[s] = n), (r = s))
|
|
: ((e[r] = u), (e[i] = n), (r = i));
|
|
else {
|
|
if (!(s < l && 0 > a(c, n))) break e;
|
|
((e[r] = c), (e[s] = n), (r = s));
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
function a(e, t) {
|
|
var n = e.sortIndex - t.sortIndex;
|
|
return 0 !== n ? n : e.id - t.id;
|
|
}
|
|
if (
|
|
'object' === typeof performance &&
|
|
'function' === typeof performance.now
|
|
) {
|
|
var o = performance;
|
|
t.unstable_now = function () {
|
|
return o.now();
|
|
};
|
|
} else {
|
|
var i = Date,
|
|
u = i.now();
|
|
t.unstable_now = function () {
|
|
return i.now() - u;
|
|
};
|
|
}
|
|
var s = [],
|
|
c = [],
|
|
f = 1,
|
|
d = null,
|
|
p = 3,
|
|
h = !1,
|
|
m = !1,
|
|
v = !1,
|
|
g = 'function' === typeof setTimeout ? setTimeout : null,
|
|
y = 'function' === typeof clearTimeout ? clearTimeout : null,
|
|
b = 'undefined' !== typeof setImmediate ? setImmediate : null;
|
|
function k(e) {
|
|
for (var t = r(c); null !== t; ) {
|
|
if (null === t.callback) l(c);
|
|
else {
|
|
if (!(t.startTime <= e)) break;
|
|
(l(c), (t.sortIndex = t.expirationTime), n(s, t));
|
|
}
|
|
t = r(c);
|
|
}
|
|
}
|
|
function w(e) {
|
|
if (((v = !1), k(e), !m))
|
|
if (null !== r(s)) ((m = !0), D(S));
|
|
else {
|
|
var t = r(c);
|
|
null !== t && R(w, t.startTime - e);
|
|
}
|
|
}
|
|
function S(e, n) {
|
|
((m = !1), v && ((v = !1), y(_), (_ = -1)), (h = !0));
|
|
var a = p;
|
|
try {
|
|
for (
|
|
k(n), d = r(s);
|
|
null !== d && (!(d.expirationTime > n) || (e && !z()));
|
|
) {
|
|
var o = d.callback;
|
|
if ('function' === typeof o) {
|
|
((d.callback = null), (p = d.priorityLevel));
|
|
var i = o(d.expirationTime <= n);
|
|
((n = t.unstable_now()),
|
|
'function' === typeof i
|
|
? (d.callback = i)
|
|
: d === r(s) && l(s),
|
|
k(n));
|
|
} else l(s);
|
|
d = r(s);
|
|
}
|
|
if (null !== d) var u = !0;
|
|
else {
|
|
var f = r(c);
|
|
(null !== f && R(w, f.startTime - n), (u = !1));
|
|
}
|
|
return u;
|
|
} finally {
|
|
((d = null), (p = a), (h = !1));
|
|
}
|
|
}
|
|
'undefined' !== typeof navigator &&
|
|
void 0 !== navigator.scheduling &&
|
|
void 0 !== navigator.scheduling.isInputPending &&
|
|
navigator.scheduling.isInputPending.bind(navigator.scheduling);
|
|
var x,
|
|
E = !1,
|
|
C = null,
|
|
_ = -1,
|
|
P = 5,
|
|
N = -1;
|
|
function z() {
|
|
return !(t.unstable_now() - N < P);
|
|
}
|
|
function T() {
|
|
if (null !== C) {
|
|
var e = t.unstable_now();
|
|
N = e;
|
|
var n = !0;
|
|
try {
|
|
n = C(!0, e);
|
|
} finally {
|
|
n ? x() : ((E = !1), (C = null));
|
|
}
|
|
} else E = !1;
|
|
}
|
|
if ('function' === typeof b)
|
|
x = function () {
|
|
b(T);
|
|
};
|
|
else if ('undefined' !== typeof MessageChannel) {
|
|
var M = new MessageChannel(),
|
|
L = M.port2;
|
|
((M.port1.onmessage = T),
|
|
(x = function () {
|
|
L.postMessage(null);
|
|
}));
|
|
} else
|
|
x = function () {
|
|
g(T, 0);
|
|
};
|
|
function D(e) {
|
|
((C = e), E || ((E = !0), x()));
|
|
}
|
|
function R(e, n) {
|
|
_ = g(function () {
|
|
e(t.unstable_now());
|
|
}, n);
|
|
}
|
|
((t.unstable_IdlePriority = 5),
|
|
(t.unstable_ImmediatePriority = 1),
|
|
(t.unstable_LowPriority = 4),
|
|
(t.unstable_NormalPriority = 3),
|
|
(t.unstable_Profiling = null),
|
|
(t.unstable_UserBlockingPriority = 2),
|
|
(t.unstable_cancelCallback = function (e) {
|
|
e.callback = null;
|
|
}),
|
|
(t.unstable_continueExecution = function () {
|
|
m || h || ((m = !0), D(S));
|
|
}),
|
|
(t.unstable_forceFrameRate = function (e) {
|
|
0 > e || 125 < e
|
|
? console.error(
|
|
'forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported'
|
|
)
|
|
: (P = 0 < e ? Math.floor(1e3 / e) : 5);
|
|
}),
|
|
(t.unstable_getCurrentPriorityLevel = function () {
|
|
return p;
|
|
}),
|
|
(t.unstable_getFirstCallbackNode = function () {
|
|
return r(s);
|
|
}),
|
|
(t.unstable_next = function (e) {
|
|
switch (p) {
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
var t = 3;
|
|
break;
|
|
default:
|
|
t = p;
|
|
}
|
|
var n = p;
|
|
p = t;
|
|
try {
|
|
return e();
|
|
} finally {
|
|
p = n;
|
|
}
|
|
}),
|
|
(t.unstable_pauseExecution = function () {}),
|
|
(t.unstable_requestPaint = function () {}),
|
|
(t.unstable_runWithPriority = function (e, t) {
|
|
switch (e) {
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
break;
|
|
default:
|
|
e = 3;
|
|
}
|
|
var n = p;
|
|
p = e;
|
|
try {
|
|
return t();
|
|
} finally {
|
|
p = n;
|
|
}
|
|
}),
|
|
(t.unstable_scheduleCallback = function (e, l, a) {
|
|
var o = t.unstable_now();
|
|
switch (
|
|
('object' === typeof a && null !== a
|
|
? (a = 'number' === typeof (a = a.delay) && 0 < a ? o + a : o)
|
|
: (a = o),
|
|
e)
|
|
) {
|
|
case 1:
|
|
var i = -1;
|
|
break;
|
|
case 2:
|
|
i = 250;
|
|
break;
|
|
case 5:
|
|
i = 1073741823;
|
|
break;
|
|
case 4:
|
|
i = 1e4;
|
|
break;
|
|
default:
|
|
i = 5e3;
|
|
}
|
|
return (
|
|
(e = {
|
|
id: f++,
|
|
callback: l,
|
|
priorityLevel: e,
|
|
startTime: a,
|
|
expirationTime: (i = a + i),
|
|
sortIndex: -1,
|
|
}),
|
|
a > o
|
|
? ((e.sortIndex = a),
|
|
n(c, e),
|
|
null === r(s) &&
|
|
e === r(c) &&
|
|
(v ? (y(_), (_ = -1)) : (v = !0), R(w, a - o)))
|
|
: ((e.sortIndex = i), n(s, e), m || h || ((m = !0), D(S))),
|
|
e
|
|
);
|
|
}),
|
|
(t.unstable_shouldYield = z),
|
|
(t.unstable_wrapCallback = function (e) {
|
|
var t = p;
|
|
return function () {
|
|
var n = p;
|
|
p = t;
|
|
try {
|
|
return e.apply(this, arguments);
|
|
} finally {
|
|
p = n;
|
|
}
|
|
};
|
|
}));
|
|
},
|
|
296: (e, t, n) => {
|
|
e.exports = n(813);
|
|
},
|
|
},
|
|
t = {};
|
|
function n(r) {
|
|
var l = t[r];
|
|
if (void 0 !== l) return l.exports;
|
|
var a = (t[r] = { exports: {} });
|
|
return (e[r](a, a.exports, n), a.exports);
|
|
}
|
|
(() => {
|
|
var e = n(791),
|
|
t = n(250),
|
|
r = n(184);
|
|
const l = (e) => {
|
|
let { colour: t, onMouseDown: n, onMouseEnter: l, cellSize: a } = e;
|
|
return (0, r.jsx)('div', {
|
|
className: 'cell',
|
|
style: {
|
|
width: ''.concat(a, 'px'),
|
|
height: ''.concat(a, 'px'),
|
|
backgroundColor: t,
|
|
},
|
|
onMouseDown: n,
|
|
onMouseEnter: l,
|
|
onDragStart: (e) => e.preventDefault(),
|
|
});
|
|
},
|
|
a = (e) => {
|
|
let {
|
|
board: t,
|
|
onCellMouseDown: n,
|
|
onCellMouseEnter: a,
|
|
onPointerUp: o,
|
|
cellSize: i,
|
|
stateColours: u,
|
|
} = e;
|
|
return (0, r.jsx)('div', {
|
|
className: 'board',
|
|
onMouseUp: o,
|
|
onMouseLeave: o,
|
|
children: t.map((e, t) =>
|
|
(0, r.jsx)(
|
|
'div',
|
|
{
|
|
className: 'row',
|
|
children: e.map((e, o) =>
|
|
(0, r.jsx)(
|
|
l,
|
|
{
|
|
state: e,
|
|
colour: u[e],
|
|
onMouseDown: () => n(t, o),
|
|
onMouseEnter: () => a(t, o),
|
|
cellSize: i,
|
|
},
|
|
o
|
|
)
|
|
),
|
|
},
|
|
t
|
|
)
|
|
),
|
|
});
|
|
};
|
|
function o(e, t) {
|
|
return (
|
|
(o = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (e, t) {
|
|
return ((e.__proto__ = t), e);
|
|
}),
|
|
o(e, t)
|
|
);
|
|
}
|
|
function i(e) {
|
|
return (
|
|
e && e.stopPropagation && e.stopPropagation(),
|
|
e && e.preventDefault && e.preventDefault(),
|
|
!1
|
|
);
|
|
}
|
|
function u(e) {
|
|
return null == e ? [] : Array.isArray(e) ? e.slice() : [e];
|
|
}
|
|
function s(e) {
|
|
return null !== e && 1 === e.length ? e[0] : e.slice();
|
|
}
|
|
function c(e) {
|
|
Object.keys(e).forEach((t) => {
|
|
'undefined' != typeof document &&
|
|
document.addEventListener(t, e[t], !1);
|
|
});
|
|
}
|
|
function f(e, t) {
|
|
return d(
|
|
(function (e, t) {
|
|
let n = e;
|
|
return (n <= t.min && (n = t.min), n >= t.max && (n = t.max), n);
|
|
})(e, t),
|
|
t
|
|
);
|
|
}
|
|
function d(e, t) {
|
|
const n = (e - t.min) % t.step;
|
|
let r = e - n;
|
|
return (
|
|
2 * Math.abs(n) >= t.step && (r += n > 0 ? t.step : -t.step),
|
|
parseFloat(r.toFixed(5))
|
|
);
|
|
}
|
|
let p = (function (t) {
|
|
function n(n) {
|
|
var r;
|
|
(((r = t.call(this, n) || this).onKeyUp = () => {
|
|
r.onEnd();
|
|
}),
|
|
(r.onMouseUp = () => {
|
|
r.onEnd(r.getMouseEventMap());
|
|
}),
|
|
(r.onTouchEnd = (e) => {
|
|
(e.preventDefault(), r.onEnd(r.getTouchEventMap()));
|
|
}),
|
|
(r.onBlur = () => {
|
|
r.setState({ index: -1 }, r.onEnd(r.getKeyDownEventMap()));
|
|
}),
|
|
(r.onMouseMove = (e) => {
|
|
r.setState({ pending: !0 });
|
|
const t = r.getMousePosition(e),
|
|
n = r.getDiffPosition(t[0]),
|
|
l = r.getValueFromPosition(n);
|
|
r.move(l);
|
|
}),
|
|
(r.onTouchMove = (e) => {
|
|
if (e.touches.length > 1) return;
|
|
r.setState({ pending: !0 });
|
|
const t = r.getTouchPosition(e);
|
|
if (void 0 === r.isScrolling) {
|
|
const e = t[0] - r.startPosition[0],
|
|
n = t[1] - r.startPosition[1];
|
|
r.isScrolling = Math.abs(n) > Math.abs(e);
|
|
}
|
|
if (r.isScrolling) return void r.setState({ index: -1 });
|
|
const n = r.getDiffPosition(t[0]),
|
|
l = r.getValueFromPosition(n);
|
|
r.move(l);
|
|
}),
|
|
(r.onKeyDown = (e) => {
|
|
if (!(e.ctrlKey || e.shiftKey || e.altKey || e.metaKey))
|
|
switch ((r.setState({ pending: !0 }), e.key)) {
|
|
case 'ArrowLeft':
|
|
case 'ArrowDown':
|
|
case 'Left':
|
|
case 'Down':
|
|
(e.preventDefault(), r.moveDownByStep());
|
|
break;
|
|
case 'ArrowRight':
|
|
case 'ArrowUp':
|
|
case 'Right':
|
|
case 'Up':
|
|
(e.preventDefault(), r.moveUpByStep());
|
|
break;
|
|
case 'Home':
|
|
(e.preventDefault(), r.move(r.props.min));
|
|
break;
|
|
case 'End':
|
|
(e.preventDefault(), r.move(r.props.max));
|
|
break;
|
|
case 'PageDown':
|
|
(e.preventDefault(),
|
|
r.moveDownByStep(r.props.pageFn(r.props.step)));
|
|
break;
|
|
case 'PageUp':
|
|
(e.preventDefault(),
|
|
r.moveUpByStep(r.props.pageFn(r.props.step)));
|
|
}
|
|
}),
|
|
(r.onSliderMouseDown = (e) => {
|
|
if (!r.props.disabled && 2 !== e.button) {
|
|
if ((r.setState({ pending: !0 }), !r.props.snapDragDisabled)) {
|
|
const t = r.getMousePosition(e);
|
|
r.forceValueFromPosition(t[0], (e) => {
|
|
(r.start(e, t[0]), c(r.getMouseEventMap()));
|
|
});
|
|
}
|
|
i(e);
|
|
}
|
|
}),
|
|
(r.onSliderClick = (e) => {
|
|
if (!r.props.disabled && r.props.onSliderClick && !r.hasMoved) {
|
|
const t = r.getMousePosition(e),
|
|
n = f(r.calcValue(r.calcOffsetFromPosition(t[0])), r.props);
|
|
r.props.onSliderClick(n);
|
|
}
|
|
}),
|
|
(r.createOnKeyDown = (e) => (t) => {
|
|
r.props.disabled || (r.start(e), c(r.getKeyDownEventMap()), i(t));
|
|
}),
|
|
(r.createOnMouseDown = (e) => (t) => {
|
|
if (r.props.disabled || 2 === t.button) return;
|
|
r.setState({ pending: !0 });
|
|
const n = r.getMousePosition(t);
|
|
(r.start(e, n[0]), c(r.getMouseEventMap()), i(t));
|
|
}),
|
|
(r.createOnTouchStart = (e) => (t) => {
|
|
if (r.props.disabled || t.touches.length > 1) return;
|
|
r.setState({ pending: !0 });
|
|
const n = r.getTouchPosition(t);
|
|
((r.startPosition = n),
|
|
(r.isScrolling = void 0),
|
|
r.start(e, n[0]),
|
|
c(r.getTouchEventMap()),
|
|
(function (e) {
|
|
e.stopPropagation && e.stopPropagation();
|
|
})(t));
|
|
}),
|
|
(r.handleResize = () => {
|
|
const e = window.setTimeout(() => {
|
|
(r.pendingResizeTimeouts.shift(), r.resize());
|
|
}, 0);
|
|
r.pendingResizeTimeouts.push(e);
|
|
}),
|
|
(r.renderThumb = (e, t) => {
|
|
const n =
|
|
r.props.thumbClassName +
|
|
' ' +
|
|
r.props.thumbClassName +
|
|
'-' +
|
|
t +
|
|
' ' +
|
|
(r.state.index === t ? r.props.thumbActiveClassName : ''),
|
|
l = {
|
|
ref: (e) => {
|
|
r['thumb' + t] = e;
|
|
},
|
|
key: r.props.thumbClassName + '-' + t,
|
|
className: n,
|
|
style: e,
|
|
onMouseDown: r.createOnMouseDown(t),
|
|
onTouchStart: r.createOnTouchStart(t),
|
|
onFocus: r.createOnKeyDown(t),
|
|
tabIndex: 0,
|
|
role: 'slider',
|
|
'aria-orientation': r.props.orientation,
|
|
'aria-valuenow': r.state.value[t],
|
|
'aria-valuemin': r.props.min,
|
|
'aria-valuemax': r.props.max,
|
|
'aria-label': Array.isArray(r.props.ariaLabel)
|
|
? r.props.ariaLabel[t]
|
|
: r.props.ariaLabel,
|
|
'aria-labelledby': Array.isArray(r.props.ariaLabelledby)
|
|
? r.props.ariaLabelledby[t]
|
|
: r.props.ariaLabelledby,
|
|
'aria-disabled': r.props.disabled,
|
|
},
|
|
a = {
|
|
index: t,
|
|
value: s(r.state.value),
|
|
valueNow: r.state.value[t],
|
|
};
|
|
return (
|
|
r.props.ariaValuetext &&
|
|
(l['aria-valuetext'] =
|
|
'string' == typeof r.props.ariaValuetext
|
|
? r.props.ariaValuetext
|
|
: r.props.ariaValuetext(a)),
|
|
r.props.renderThumb(l, a)
|
|
);
|
|
}),
|
|
(r.renderTrack = (e, t, n) => {
|
|
const l = {
|
|
key: r.props.trackClassName + '-' + e,
|
|
className:
|
|
r.props.trackClassName +
|
|
' ' +
|
|
r.props.trackClassName +
|
|
'-' +
|
|
e,
|
|
style: r.buildTrackStyle(t, r.state.upperBound - n),
|
|
},
|
|
a = { index: e, value: s(r.state.value) };
|
|
return r.props.renderTrack(l, a);
|
|
}));
|
|
let l = u(n.value);
|
|
(l.length || (l = u(n.defaultValue)), (r.pendingResizeTimeouts = []));
|
|
const a = [];
|
|
for (let e = 0; e < l.length; e += 1) ((l[e] = f(l[e], n)), a.push(e));
|
|
return (
|
|
(r.resizeObserver = null),
|
|
(r.resizeElementRef = e.createRef()),
|
|
(r.state = {
|
|
index: -1,
|
|
upperBound: 0,
|
|
sliderLength: 0,
|
|
value: l,
|
|
zIndices: a,
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
var r, l;
|
|
((l = t),
|
|
((r = n).prototype = Object.create(l.prototype)),
|
|
(r.prototype.constructor = r),
|
|
o(r, l));
|
|
var a = n.prototype;
|
|
return (
|
|
(a.componentDidMount = function () {
|
|
'undefined' != typeof window &&
|
|
((this.resizeObserver = new ResizeObserver(this.handleResize)),
|
|
this.resizeObserver.observe(this.resizeElementRef.current),
|
|
this.resize());
|
|
}),
|
|
(n.getDerivedStateFromProps = function (e, t) {
|
|
const n = u(e.value);
|
|
return n.length
|
|
? t.pending
|
|
? null
|
|
: { value: n.map((t) => f(t, e)) }
|
|
: null;
|
|
}),
|
|
(a.componentDidUpdate = function () {
|
|
0 === this.state.upperBound && this.resize();
|
|
}),
|
|
(a.componentWillUnmount = function () {
|
|
(this.clearPendingResizeTimeouts(),
|
|
this.resizeObserver && this.resizeObserver.disconnect());
|
|
}),
|
|
(a.onEnd = function (e) {
|
|
(e &&
|
|
(function (e) {
|
|
Object.keys(e).forEach((t) => {
|
|
'undefined' != typeof document &&
|
|
document.removeEventListener(t, e[t], !1);
|
|
});
|
|
})(e),
|
|
this.hasMoved && this.fireChangeEvent('onAfterChange'),
|
|
this.setState({ pending: !1 }),
|
|
(this.hasMoved = !1));
|
|
}),
|
|
(a.getValue = function () {
|
|
return s(this.state.value);
|
|
}),
|
|
(a.getClosestIndex = function (e) {
|
|
let t = Number.MAX_VALUE,
|
|
n = -1;
|
|
const { value: r } = this.state,
|
|
l = r.length;
|
|
for (let a = 0; a < l; a += 1) {
|
|
const l = this.calcOffset(r[a]),
|
|
o = Math.abs(e - l);
|
|
o < t && ((t = o), (n = a));
|
|
}
|
|
return n;
|
|
}),
|
|
(a.getMousePosition = function (e) {
|
|
return [
|
|
e['page' + this.axisKey()],
|
|
e['page' + this.orthogonalAxisKey()],
|
|
];
|
|
}),
|
|
(a.getTouchPosition = function (e) {
|
|
const t = e.touches[0];
|
|
return [
|
|
t['page' + this.axisKey()],
|
|
t['page' + this.orthogonalAxisKey()],
|
|
];
|
|
}),
|
|
(a.getKeyDownEventMap = function () {
|
|
return {
|
|
keydown: this.onKeyDown,
|
|
keyup: this.onKeyUp,
|
|
focusout: this.onBlur,
|
|
};
|
|
}),
|
|
(a.getMouseEventMap = function () {
|
|
return { mousemove: this.onMouseMove, mouseup: this.onMouseUp };
|
|
}),
|
|
(a.getTouchEventMap = function () {
|
|
return { touchmove: this.onTouchMove, touchend: this.onTouchEnd };
|
|
}),
|
|
(a.getValueFromPosition = function (e) {
|
|
const t =
|
|
(e / (this.state.sliderLength - this.state.thumbSize)) *
|
|
(this.props.max - this.props.min);
|
|
return f(this.state.startValue + t, this.props);
|
|
}),
|
|
(a.getDiffPosition = function (e) {
|
|
let t = e - this.state.startPosition;
|
|
return (this.props.invert && (t *= -1), t);
|
|
}),
|
|
(a.resize = function () {
|
|
const { slider: e, thumb0: t } = this;
|
|
if (!e || !t) return;
|
|
const n = this.sizeKey(),
|
|
r = e.getBoundingClientRect(),
|
|
l = e[n],
|
|
a = r[this.posMaxKey()],
|
|
o = r[this.posMinKey()],
|
|
i =
|
|
t.getBoundingClientRect()[n.replace('client', '').toLowerCase()],
|
|
u = l - i,
|
|
s = Math.abs(a - o);
|
|
(this.state.upperBound === u &&
|
|
this.state.sliderLength === s &&
|
|
this.state.thumbSize === i) ||
|
|
this.setState({ upperBound: u, sliderLength: s, thumbSize: i });
|
|
}),
|
|
(a.calcOffset = function (e) {
|
|
const t = this.props.max - this.props.min;
|
|
return 0 === t
|
|
? 0
|
|
: ((e - this.props.min) / t) * this.state.upperBound;
|
|
}),
|
|
(a.calcValue = function (e) {
|
|
return (
|
|
(e / this.state.upperBound) * (this.props.max - this.props.min) +
|
|
this.props.min
|
|
);
|
|
}),
|
|
(a.calcOffsetFromPosition = function (e) {
|
|
const { slider: t } = this,
|
|
n = t.getBoundingClientRect(),
|
|
r = n[this.posMaxKey()],
|
|
l = n[this.posMinKey()];
|
|
let a =
|
|
e -
|
|
(window['page' + this.axisKey() + 'Offset'] +
|
|
(this.props.invert ? r : l));
|
|
return (
|
|
this.props.invert && (a = this.state.sliderLength - a),
|
|
(a -= this.state.thumbSize / 2),
|
|
a
|
|
);
|
|
}),
|
|
(a.forceValueFromPosition = function (e, t) {
|
|
const n = this.calcOffsetFromPosition(e),
|
|
r = this.getClosestIndex(n),
|
|
l = f(this.calcValue(n), this.props),
|
|
a = this.state.value.slice();
|
|
a[r] = l;
|
|
for (let o = 0; o < a.length - 1; o += 1)
|
|
if (a[o + 1] - a[o] < this.props.minDistance) return;
|
|
(this.fireChangeEvent('onBeforeChange'),
|
|
(this.hasMoved = !0),
|
|
this.setState({ value: a }, () => {
|
|
(t(r), this.fireChangeEvent('onChange'));
|
|
}));
|
|
}),
|
|
(a.clearPendingResizeTimeouts = function () {
|
|
do {
|
|
const e = this.pendingResizeTimeouts.shift();
|
|
clearTimeout(e);
|
|
} while (this.pendingResizeTimeouts.length);
|
|
}),
|
|
(a.start = function (e, t) {
|
|
const n = this['thumb' + e];
|
|
n && n.focus();
|
|
const { zIndices: r } = this.state;
|
|
(r.splice(r.indexOf(e), 1),
|
|
r.push(e),
|
|
this.setState((n) => ({
|
|
startValue: n.value[e],
|
|
startPosition: void 0 !== t ? t : n.startPosition,
|
|
index: e,
|
|
zIndices: r,
|
|
})));
|
|
}),
|
|
(a.moveUpByStep = function (e) {
|
|
void 0 === e && (e = this.props.step);
|
|
const t = this.state.value[this.state.index],
|
|
n = f(
|
|
this.props.invert && 'horizontal' === this.props.orientation
|
|
? t - e
|
|
: t + e,
|
|
this.props
|
|
);
|
|
this.move(Math.min(n, this.props.max));
|
|
}),
|
|
(a.moveDownByStep = function (e) {
|
|
void 0 === e && (e = this.props.step);
|
|
const t = this.state.value[this.state.index],
|
|
n = f(
|
|
this.props.invert && 'horizontal' === this.props.orientation
|
|
? t + e
|
|
: t - e,
|
|
this.props
|
|
);
|
|
this.move(Math.max(n, this.props.min));
|
|
}),
|
|
(a.move = function (e) {
|
|
const t = this.state.value.slice(),
|
|
{ index: n } = this.state,
|
|
{ length: r } = t,
|
|
l = t[n];
|
|
if (e === l) return;
|
|
(this.hasMoved || this.fireChangeEvent('onBeforeChange'),
|
|
(this.hasMoved = !0));
|
|
const { pearling: a, max: o, min: i, minDistance: u } = this.props;
|
|
if (!a) {
|
|
if (n > 0) {
|
|
const r = t[n - 1];
|
|
e < r + u && (e = r + u);
|
|
}
|
|
if (n < r - 1) {
|
|
const r = t[n + 1];
|
|
e > r - u && (e = r - u);
|
|
}
|
|
}
|
|
((t[n] = e),
|
|
a &&
|
|
r > 1 &&
|
|
(e > l
|
|
? (this.pushSucceeding(t, u, n),
|
|
(function (e, t, n, r) {
|
|
for (let l = 0; l < e; l += 1) {
|
|
const a = r - l * n;
|
|
t[e - 1 - l] > a && (t[e - 1 - l] = a);
|
|
}
|
|
})(r, t, u, o))
|
|
: e < l &&
|
|
(this.pushPreceding(t, u, n),
|
|
(function (e, t, n, r) {
|
|
for (let l = 0; l < e; l += 1) {
|
|
const e = r + l * n;
|
|
t[l] < e && (t[l] = e);
|
|
}
|
|
})(r, t, u, i))),
|
|
this.setState(
|
|
{ value: t },
|
|
this.fireChangeEvent.bind(this, 'onChange')
|
|
));
|
|
}),
|
|
(a.pushSucceeding = function (e, t, n) {
|
|
let r, l;
|
|
for (
|
|
r = n, l = e[r] + t;
|
|
null !== e[r + 1] && l > e[r + 1];
|
|
r += 1, l = e[r] + t
|
|
)
|
|
e[r + 1] = d(l, this.props);
|
|
}),
|
|
(a.pushPreceding = function (e, t, n) {
|
|
for (
|
|
let r = n, l = e[r] - t;
|
|
null !== e[r - 1] && l < e[r - 1];
|
|
r -= 1, l = e[r] - t
|
|
)
|
|
e[r - 1] = d(l, this.props);
|
|
}),
|
|
(a.axisKey = function () {
|
|
return 'vertical' === this.props.orientation ? 'Y' : 'X';
|
|
}),
|
|
(a.orthogonalAxisKey = function () {
|
|
return 'vertical' === this.props.orientation ? 'X' : 'Y';
|
|
}),
|
|
(a.posMinKey = function () {
|
|
return 'vertical' === this.props.orientation
|
|
? this.props.invert
|
|
? 'bottom'
|
|
: 'top'
|
|
: this.props.invert
|
|
? 'right'
|
|
: 'left';
|
|
}),
|
|
(a.posMaxKey = function () {
|
|
return 'vertical' === this.props.orientation
|
|
? this.props.invert
|
|
? 'top'
|
|
: 'bottom'
|
|
: this.props.invert
|
|
? 'left'
|
|
: 'right';
|
|
}),
|
|
(a.sizeKey = function () {
|
|
return 'vertical' === this.props.orientation
|
|
? 'clientHeight'
|
|
: 'clientWidth';
|
|
}),
|
|
(a.fireChangeEvent = function (e) {
|
|
this.props[e] && this.props[e](s(this.state.value), this.state.index);
|
|
}),
|
|
(a.buildThumbStyle = function (e, t) {
|
|
const n = {
|
|
position: 'absolute',
|
|
touchAction: 'none',
|
|
willChange: this.state.index >= 0 ? this.posMinKey() : void 0,
|
|
zIndex: this.state.zIndices.indexOf(t) + 1,
|
|
};
|
|
return ((n[this.posMinKey()] = e + 'px'), n);
|
|
}),
|
|
(a.buildTrackStyle = function (e, t) {
|
|
const n = {
|
|
position: 'absolute',
|
|
willChange:
|
|
this.state.index >= 0
|
|
? this.posMinKey() + ',' + this.posMaxKey()
|
|
: void 0,
|
|
};
|
|
return ((n[this.posMinKey()] = e), (n[this.posMaxKey()] = t), n);
|
|
}),
|
|
(a.buildMarkStyle = function (e) {
|
|
var t;
|
|
return (((t = { position: 'absolute' })[this.posMinKey()] = e), t);
|
|
}),
|
|
(a.renderThumbs = function (e) {
|
|
const { length: t } = e,
|
|
n = [];
|
|
for (let l = 0; l < t; l += 1) n[l] = this.buildThumbStyle(e[l], l);
|
|
const r = [];
|
|
for (let l = 0; l < t; l += 1) r[l] = this.renderThumb(n[l], l);
|
|
return r;
|
|
}),
|
|
(a.renderTracks = function (e) {
|
|
const t = [],
|
|
n = e.length - 1;
|
|
t.push(this.renderTrack(0, 0, e[0]));
|
|
for (let r = 0; r < n; r += 1)
|
|
t.push(this.renderTrack(r + 1, e[r], e[r + 1]));
|
|
return (
|
|
t.push(this.renderTrack(n + 1, e[n], this.state.upperBound)),
|
|
t
|
|
);
|
|
}),
|
|
(a.renderMarks = function () {
|
|
let { marks: e } = this.props;
|
|
const t = this.props.max - this.props.min + 1;
|
|
return (
|
|
'boolean' == typeof e
|
|
? (e = Array.from({ length: t }).map((e, t) => t))
|
|
: 'number' == typeof e &&
|
|
(e = Array.from({ length: t })
|
|
.map((e, t) => t)
|
|
.filter((t) => t % e == 0)),
|
|
e
|
|
.map(parseFloat)
|
|
.sort((e, t) => e - t)
|
|
.map((e) => {
|
|
const t = this.calcOffset(e),
|
|
n = {
|
|
key: e,
|
|
className: this.props.markClassName,
|
|
style: this.buildMarkStyle(t),
|
|
};
|
|
return this.props.renderMark(n);
|
|
})
|
|
);
|
|
}),
|
|
(a.render = function () {
|
|
const t = [],
|
|
{ value: n } = this.state,
|
|
r = n.length;
|
|
for (let e = 0; e < r; e += 1) t[e] = this.calcOffset(n[e], e);
|
|
const l = this.props.withTracks ? this.renderTracks(t) : null,
|
|
a = this.renderThumbs(t),
|
|
o = this.props.marks ? this.renderMarks() : null;
|
|
return e.createElement(
|
|
'div',
|
|
{
|
|
ref: (e) => {
|
|
((this.slider = e), (this.resizeElementRef.current = e));
|
|
},
|
|
style: { position: 'relative' },
|
|
className:
|
|
this.props.className + (this.props.disabled ? ' disabled' : ''),
|
|
onMouseDown: this.onSliderMouseDown,
|
|
onClick: this.onSliderClick,
|
|
},
|
|
l,
|
|
a,
|
|
o
|
|
);
|
|
}),
|
|
n
|
|
);
|
|
})(e.Component);
|
|
((p.displayName = 'ReactSlider'),
|
|
(p.defaultProps = {
|
|
min: 0,
|
|
max: 100,
|
|
step: 1,
|
|
pageFn: (e) => 10 * e,
|
|
minDistance: 0,
|
|
defaultValue: 0,
|
|
orientation: 'horizontal',
|
|
className: 'slider',
|
|
thumbClassName: 'thumb',
|
|
thumbActiveClassName: 'active',
|
|
trackClassName: 'track',
|
|
markClassName: 'mark',
|
|
withTracks: !0,
|
|
pearling: !1,
|
|
disabled: !1,
|
|
snapDragDisabled: !1,
|
|
invert: !1,
|
|
marks: [],
|
|
renderThumb: (t) => e.createElement('div', t),
|
|
renderTrack: (t) => e.createElement('div', t),
|
|
renderMark: (t) => e.createElement('span', t),
|
|
}));
|
|
var h = p;
|
|
const m = (e) =>
|
|
(0, r.jsx)(h, {
|
|
className: 'horizontal-slider',
|
|
thumbClassName: 'example-thumb',
|
|
trackClassName: 'example-track',
|
|
...e,
|
|
}),
|
|
v = (e) => {
|
|
let {
|
|
title: t,
|
|
name: n,
|
|
options: l,
|
|
selectedBrush: a,
|
|
onChange: o,
|
|
} = e;
|
|
return (0, r.jsxs)('div', {
|
|
className: 'panelSection',
|
|
children: [
|
|
(0, r.jsx)('h3', { children: t }),
|
|
(0, r.jsx)('div', {
|
|
className: 'radioGroup',
|
|
children: l.map((e) => {
|
|
const t = ''.concat(n, '-').concat(e.value);
|
|
return (0, r.jsxs)(
|
|
'label',
|
|
{
|
|
className: 'radioOption',
|
|
htmlFor: t,
|
|
children: [
|
|
(0, r.jsx)('input', {
|
|
type: 'radio',
|
|
id: t,
|
|
name: n,
|
|
value: e.value,
|
|
checked: parseInt(a, 10) === e.value,
|
|
onChange: o,
|
|
}),
|
|
(0, r.jsx)('span', { children: e.label }),
|
|
],
|
|
},
|
|
e.value
|
|
);
|
|
}),
|
|
}),
|
|
],
|
|
});
|
|
},
|
|
g = 50,
|
|
y = 60,
|
|
b = {
|
|
gameOfLife: {
|
|
label: 'Game of Life',
|
|
rules: [
|
|
{ transitions: { 53: 1 }, default: 0, colour: '#000000' },
|
|
{ transitions: { 62: 1, 53: 1 }, default: 0, colour: '#ffffff' },
|
|
],
|
|
brushes: [
|
|
{ value: 1, label: 'Alive' },
|
|
{ value: 0, label: 'Dead' },
|
|
],
|
|
},
|
|
seeds: {
|
|
label: 'Seeds',
|
|
rules: [
|
|
{ transitions: { 62: 1 }, default: 0, colour: '#000000' },
|
|
{ transitions: {}, default: 0, colour: '#ffffff' },
|
|
],
|
|
brushes: [
|
|
{ value: 1, label: 'Alive' },
|
|
{ value: 0, label: 'Dead' },
|
|
],
|
|
},
|
|
lifeWithoutDeath: {
|
|
label: 'Life without Death',
|
|
rules: [
|
|
{ transitions: { 53: 1 }, default: 0, colour: '#000000' },
|
|
{ transitions: {}, default: 1, colour: '#ffffff' },
|
|
],
|
|
brushes: [
|
|
{ value: 1, label: 'Alive' },
|
|
{ value: 0, label: 'Dead' },
|
|
],
|
|
},
|
|
briansBrain: {
|
|
label: "Brian's Brain",
|
|
rules: [
|
|
{
|
|
transitions: (() => {
|
|
const e = {};
|
|
for (let t = 0; t <= 6; t++) {
|
|
e[''.concat(6 - t, '2').concat(t)] = 1;
|
|
}
|
|
return e;
|
|
})(),
|
|
default: 0,
|
|
colour: '#000000',
|
|
},
|
|
{ transitions: {}, default: 2, colour: '#2f7df6' },
|
|
{ transitions: {}, default: 0, colour: '#e53935' },
|
|
],
|
|
brushes: [
|
|
{ value: 1, label: 'Firing' },
|
|
{ value: 2, label: 'Refractory' },
|
|
{ value: 0, label: 'Off' },
|
|
],
|
|
},
|
|
},
|
|
k = (e, t, n, r) => {
|
|
const l = new Array(t).fill(0);
|
|
for (let a = -1; a < 2; a++)
|
|
for (let t = -1; t < 2; t++) {
|
|
if (0 === a && 0 === t) continue;
|
|
const o = r + a,
|
|
i = n + t;
|
|
o < 0 || o >= g || i < 0 || i >= y || l[e[o][i]]++;
|
|
}
|
|
return l.join('');
|
|
},
|
|
w = (e, t) => Array.from({ length: e }, () => new Array(t).fill(0)),
|
|
S = (e, t) => {
|
|
const n = w(g, y);
|
|
for (let r = 0; r < g; r++)
|
|
for (let l = 0; l < y; l++) {
|
|
const a = k(e, t.length, l, r),
|
|
o = t[e[r][l]],
|
|
i = o.transitions[a];
|
|
n[r][l] = void 0 === i ? o.default : Number.parseInt(i, 10);
|
|
}
|
|
return n;
|
|
},
|
|
x = () => {
|
|
const [t, n] = (0, e.useState)(w(g, y)),
|
|
[l, o] = (0, e.useState)(15),
|
|
[i, u] = (0, e.useState)(!1),
|
|
[s, c] = (0, e.useState)(1),
|
|
[f, d] = (0, e.useState)('gameOfLife'),
|
|
[p, h] = (0, e.useState)(!1),
|
|
k = (0, e.useMemo)(() => b[f], [f]),
|
|
x = k.rules,
|
|
E = k.brushes,
|
|
C = (0, e.useMemo)(() => x.map((e) => e.colour), [x]),
|
|
_ = (e) => {
|
|
const t = e.target.value;
|
|
(d(t), u(!1), c(b[t].brushes[0].value), n(w(g, y)));
|
|
},
|
|
P = (e, t) => {
|
|
i ||
|
|
n((n) => {
|
|
if (n[e][t] === s) return n;
|
|
const r = n.map((t, n) => (n === e ? [...t] : t));
|
|
return ((r[e][t] = s), r);
|
|
});
|
|
};
|
|
return (
|
|
(0, e.useEffect)(() => {
|
|
if (!i) return;
|
|
const e = Math.max(1, Math.round(1e3 / Math.max(1, l))),
|
|
t = setInterval(() => {
|
|
n((e) => S(e, x));
|
|
}, e);
|
|
return () => clearInterval(t);
|
|
}, [i, l, x]),
|
|
(0, e.useEffect)(() => {
|
|
const e = () => h(!1);
|
|
return (
|
|
window.addEventListener('mouseup', e),
|
|
() => window.removeEventListener('mouseup', e)
|
|
);
|
|
}, []),
|
|
(0, r.jsxs)(r.Fragment, {
|
|
children: [
|
|
(0, r.jsx)('div', {
|
|
className: 'title',
|
|
children: (0, r.jsx)('h1', { children: 'Cellular Automata' }),
|
|
}),
|
|
(0, r.jsxs)('div', {
|
|
className: 'body',
|
|
children: [
|
|
(0, r.jsx)('div', {
|
|
className: 'gameBoard',
|
|
children: (0, r.jsx)(a, {
|
|
board: t,
|
|
onCellMouseDown: (e, t) => {
|
|
(h(!0), P(e, t));
|
|
},
|
|
onCellMouseEnter: (e, t) => {
|
|
p && P(e, t);
|
|
},
|
|
onPointerUp: () => h(!1),
|
|
cellSize: 10,
|
|
stateColours: C,
|
|
}),
|
|
}),
|
|
(0, r.jsxs)('div', {
|
|
className: 'controlPanel',
|
|
children: [
|
|
(0, r.jsxs)('div', {
|
|
className: 'panelSection',
|
|
children: [
|
|
(0, r.jsx)('h3', { children: 'Automaton' }),
|
|
Object.entries(b).map((e) => {
|
|
let [t, n] = e;
|
|
return (0, r.jsxs)(
|
|
'label',
|
|
{
|
|
className: 'radioOption',
|
|
htmlFor: 'automaton-'.concat(t),
|
|
children: [
|
|
(0, r.jsx)('input', {
|
|
id: 'automaton-'.concat(t),
|
|
type: 'radio',
|
|
name: 'automaton',
|
|
value: t,
|
|
checked: f === t,
|
|
onChange: _,
|
|
}),
|
|
(0, r.jsx)('span', { children: n.label }),
|
|
],
|
|
},
|
|
t
|
|
);
|
|
}),
|
|
],
|
|
}),
|
|
(0, r.jsx)(v, {
|
|
title: 'Brush',
|
|
name: 'brush',
|
|
options: E,
|
|
selectedBrush: s,
|
|
onChange: (e) => {
|
|
c(Number.parseInt(e.target.value, 10));
|
|
},
|
|
}),
|
|
(0, r.jsxs)('div', {
|
|
className: 'buttonRow',
|
|
children: [
|
|
(0, r.jsx)('button', {
|
|
className: 'controlButton',
|
|
onClick: () => u(!i),
|
|
children: i ? 'Pause' : 'Play',
|
|
}),
|
|
(0, r.jsx)('button', {
|
|
className: 'controlButton',
|
|
onClick: () => {
|
|
n((e) => S(e, x));
|
|
},
|
|
children: 'Step',
|
|
}),
|
|
(0, r.jsx)('button', {
|
|
className: 'controlButton',
|
|
onClick: () => n(w(g, y)),
|
|
children: 'Clear',
|
|
}),
|
|
],
|
|
}),
|
|
(0, r.jsxs)('div', {
|
|
className: 'sliderContainer',
|
|
children: [
|
|
(0, r.jsx)('span', { children: 'Speed' }),
|
|
(0, r.jsx)(m, {
|
|
min: 1,
|
|
max: 30,
|
|
value: l,
|
|
onChange: o,
|
|
}),
|
|
(0, r.jsxs)('p', {
|
|
className: 'fpsValue',
|
|
children: [l, ' fps'],
|
|
}),
|
|
],
|
|
}),
|
|
],
|
|
}),
|
|
],
|
|
}),
|
|
],
|
|
})
|
|
);
|
|
};
|
|
t.createRoot(document.getElementById('root')).render(
|
|
(0, r.jsx)(r.Fragment, { children: (0, r.jsx)(x, {}) })
|
|
);
|
|
})();
|
|
})();
|
|
//# sourceMappingURL=main.608a23ae.js.map
|