diff --git "a/code/Untitled-2 (2).js" "b/code/Untitled-2 (2).js" new file mode 100644--- /dev/null +++ "b/code/Untitled-2 (2).js" @@ -0,0 +1,12220 @@ +import { d as xc, g as em, R as Dp, e as um, r as lt, j as gl } from "/static/js/app.js"; +import { ae as bp, f as Rp, O as Cp, P as qp, q as Bp, af as Oc, ag as Qp, ah as Yp, ai as Gp, aj as Vp, o as Xp, i as nm, K as Zp, ak as Kp, al as Qs, C as xp, am as Jp, U as Lp, V as ju, a as Wp, an as Fp } from "/static/js/three.module.js"; +var Hc = { + exports: {} +}; +var jl = {}; +/** +* @license React +* react-reconciler-constants.production.js +* +* Copyright (c) Meta Platforms, Inc. and affiliates. +* +* This source code is licensed under the MIT license found in the +* LICENSE file in the root directory of this source tree. +*/ +var Ys; +function Pp() { + if (!Ys) { + Ys = 1; + jl.ConcurrentRoot = 1; + jl.ContinuousEventPriority = 8; + jl.DefaultEventPriority = 32; + jl.DiscreteEventPriority = 2; + jl.IdleEventPriority = 268435456; + jl.LegacyRoot = 0; + jl.NoEventPriority = 0; + } + return jl; +} +var Gs; +function Ip() { + if (!Gs) { + Gs = 1; + Hc.exports = Pp(); + } + return Hc.exports; +} +var gu = Ip(); +var Uc = { + exports: {} +}; +var _c = {}; +var rc = { + exports: {} +}; +var Ac = {}; +/** +* @license React +* use-sync-external-store-shim.production.js +* +* Copyright (c) Meta Platforms, Inc. and affiliates. +* +* This source code is licensed under the MIT license found in the +* LICENSE file in the root directory of this source tree. +*/ +var Vs; +function $p() { + if (Vs) { + return Ac; + } + Vs = 1; + var f = xc(); + function c(O, D) { + return O === D && (O !== 0 || 1 / O === 1 / D) || O !== O && D !== D; + } + var s = typeof Object.is == "function" ? Object.is : c; + var p = f.useState; + var m = f.useEffect; + var h = f.useLayoutEffect; + var T = f.useDebugValue; + function A(O, D) { + var b = D(); + var W = p({ + inst: { + value: b, + getSnapshot: D + } + }); + var x = W[0].inst; + var V = W[1]; + h(function () { + x.value = b; + x.getSnapshot = D; + if (z(x)) { + V({ + inst: x + }); + } + }, [O, b, D]); + m(function () { + if (z(x)) { + V({ + inst: x + }); + } + return O(function () { + if (z(x)) { + V({ + inst: x + }); + } + }); + }, [O]); + T(b); + return b; + } + function z(O) { + var D = O.getSnapshot; + O = O.value; + try { + var b = D(); + return !s(O, b); + } catch { + return true; + } + } + function g(O, D) { + return D(); + } + var U = typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined" ? g : A; + Ac.useSyncExternalStore = f.useSyncExternalStore !== undefined ? f.useSyncExternalStore : U; + return Ac; +} +var Xs; +function wp() { + if (!Xs) { + Xs = 1; + rc.exports = $p(); + } + return rc.exports; +} /** + * @license React + * use-sync-external-store-shim/with-selector.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var Zs; +function kp() { + if (Zs) { + return _c; + } + Zs = 1; + var f = xc(); + var c = wp(); + function s(g, U) { + return g === U && (g !== 0 || 1 / g === 1 / U) || g !== g && U !== U; + } + var p = typeof Object.is == "function" ? Object.is : s; + var m = c.useSyncExternalStore; + var h = f.useRef; + var T = f.useEffect; + var A = f.useMemo; + var z = f.useDebugValue; + _c.useSyncExternalStoreWithSelector = function (g, U, O, D, b) { + var W = h(null); + if (W.current === null) { + var x = { + hasValue: false, + value: null + }; + W.current = x; + } else { + x = W.current; + } + W = A(function () { + function _(B) { + if (!N) { + N = true; + X = B; + B = D(B); + if (b !== undefined && x.hasValue) { + var ct = x.value; + if (b(ct, B)) { + return Y = ct; + } + } + return Y = B; + } + ct = Y; + if (p(X, B)) { + return ct; + } + var pt = D(B); + if (b !== undefined && b(ct, pt)) { + X = B; + return ct; + } else { + X = B; + return Y = pt; + } + } + var N = false; + var X; + var Y; + var F = O === undefined ? null : O; + return [function () { + return _(U()); + }, F === null ? undefined : function () { + return _(F()); + }]; + }, [U, O, D, b]); + var V = m(g, W[0], W[1]); + T(function () { + x.hasValue = true; + x.value = V; + }, [V]); + z(V); + return V; + }; + return _c; +} +var Ks; +function t0() { + if (!Ks) { + Ks = 1; + Uc.exports = kp(); + } + return Uc.exports; +} +var l0 = t0(); +const a0 = em(l0); +const xs = f => { + let c; + const s = new Set(); + const p = (g, U) => { + const O = typeof g == "function" ? g(c) : g; + if (!Object.is(O, c)) { + const D = c; + c = U ?? (typeof O != "object" || O === null) ? O : Object.assign({}, c, O); + s.forEach(b => b(c, D)); + } + }; + const m = () => c; + const A = { + setState: p, + getState: m, + getInitialState: () => z, + subscribe: g => { + s.add(g); + return () => s.delete(g); + } + }; + const z = c = f(p, m, A); + return A; +}; +const e0 = f => f ? xs(f) : xs; +const { + useSyncExternalStoreWithSelector: u0 +} = a0; +const n0 = f => f; +function c0(f, c = n0, s) { + const p = u0(f.subscribe, f.getState, f.getInitialState, c, s); + Dp.useDebugValue(p); + return p; +} +const Js = (f, c) => { + const s = e0(f); + const p = (m, h = c) => c0(s, m, h); + Object.assign(p, s); + return p; +}; +const f0 = (f, c) => f ? Js(f, c) : Js; +var jc = { + exports: {} +}; +var gc = { + exports: {} +}; +/** +* @license React +* react-reconciler.production.js +* +* Copyright (c) Meta Platforms, Inc. and affiliates. +* +* This source code is licensed under the MIT license found in the +* LICENSE file in the root directory of this source tree. +*/ +var Ls; +function i0() { + if (!Ls) { + Ls = 1; + (function (f) { + f.exports = function (c) { + function s(t, l, a, e) { + return new Fm(t, l, a, e); + } + function p() {} + function m(t) { + var l = "https://react.dev/errors/" + t; + if (arguments.length > 1) { + l += "?args[]=" + encodeURIComponent(arguments[1]); + for (var a = 2; a < arguments.length; a++) { + l += "&args[]=" + encodeURIComponent(arguments[a]); + } + } + return "Minified React error #" + t + "; visit " + l + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; + } + function h(t) { + if (t === null || typeof t != "object") { + return null; + } else { + t = es && t[es] || t["@@iterator"]; + if (typeof t == "function") { + return t; + } else { + return null; + } + } + } + function T(t) { + if (t == null) { + return null; + } + if (typeof t == "function") { + if (t.$$typeof === tv) { + return null; + } else { + return t.displayName || t.name || null; + } + } + if (typeof t == "string") { + return t; + } + switch (t) { + case Da: + return "Fragment"; + case ga: + return "Portal"; + case xn: + return "Profiler"; + case ts: + return "StrictMode"; + case Ln: + return "Suspense"; + case Wn: + return "SuspenseList"; + } + if (typeof t == "object") { + switch (t.$$typeof) { + case Kl: + return (t.displayName || "Context") + ".Provider"; + case ls: + return (t._context.displayName || "Context") + ".Consumer"; + case Jn: + var l = t.render; + t = t.displayName; + if (!t) { + t = l.displayName || l.name || ""; + t = t !== "" ? "ForwardRef(" + t + ")" : "ForwardRef"; + } + return t; + case Fn: + l = t.displayName || null; + if (l !== null) { + return l; + } else { + return T(t.type) || "Memo"; + } + case xl: + l = t._payload; + t = t._init; + try { + return T(t(l)); + } catch {} + } + } + return null; + } + function A(t) { + if (Pn === undefined) { + try { + throw Error(); + } catch (a) { + var l = a.stack.trim().match(/\n( *(at )?)/); + Pn = l && l[1] || ""; + us = a.stack.indexOf(` + at`) > -1 ? " ()" : a.stack.indexOf("@") > -1 ? "@unknown:0:0" : ""; + } + } + return ` +${Pn}${t}${us}`; + } + function z(t, l) { + if (!t || In) { + return ""; + } + In = true; + var a = Error.prepareStackTrace; + Error.prepareStackTrace = undefined; + try { + var e = { + DetermineComponentFrameRoot: function () { + try { + if (l) { + function r() { + throw Error(); + } + Object.defineProperty(r.prototype, "props", { + set: function () { + throw Error(); + } + }); + if (typeof Reflect == "object" && Reflect.construct) { + try { + Reflect.construct(r, []); + } catch (Q) { + var j = Q; + } + Reflect.construct(t, [], r); + } else { + try { + r.call(); + } catch (Q) { + j = Q; + } + t.call(r.prototype); + } + } else { + try { + throw Error(); + } catch (Q) { + j = Q; + } + if ((r = t()) && typeof r.catch == "function") { + r.catch(function () {}); + } + } + } catch (Q) { + if (Q && j && typeof Q.stack == "string") { + return [Q.stack, j.stack]; + } + } + return [null, null]; + } + }; + e.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot"; + var u = Object.getOwnPropertyDescriptor(e.DetermineComponentFrameRoot, "name"); + if (u && u.configurable) { + Object.defineProperty(e.DetermineComponentFrameRoot, "name", { + value: "DetermineComponentFrameRoot" + }); + } + var n = e.DetermineComponentFrameRoot(); + var i = n[0]; + var v = n[1]; + if (i && v) { + var d = i.split(` +`); + var E = v.split(` +`); + for (u = e = 0; e < d.length && !d[e].includes("DetermineComponentFrameRoot");) { + e++; + } + while (u < E.length && !E[u].includes("DetermineComponentFrameRoot")) { + u++; + } + if (e === d.length || u === E.length) { + e = d.length - 1; + u = E.length - 1; + while (e >= 1 && u >= 0 && d[e] !== E[u]) { + u--; + } + } + for (; e >= 1 && u >= 0; e--, u--) { + if (d[e] !== E[u]) { + if (e !== 1 || u !== 1) { + do { + e--; + u--; + if (u < 0 || d[e] !== E[u]) { + var H = ` +${d[e].replace(" at new ", " at ")}`; + if (t.displayName && H.includes("")) { + H = H.replace("", t.displayName); + } + return H; + } + } while (e >= 1 && u >= 0); + } + break; + } + } + } + } finally { + In = false; + Error.prepareStackTrace = a; + } + if (a = t ? t.displayName || t.name : "") { + return A(a); + } else { + return ""; + } + } + function g(t) { + switch (t.tag) { + case 26: + case 27: + case 5: + return A(t.type); + case 16: + return A("Lazy"); + case 13: + return A("Suspense"); + case 19: + return A("SuspenseList"); + case 0: + case 15: + t = z(t.type, false); + return t; + case 11: + t = z(t.type.render, false); + return t; + case 1: + t = z(t.type, true); + return t; + default: + return ""; + } + } + function U(t) { + try { + var l = ""; + do { + l += g(t); + t = t.return; + } while (t); + return l; + } catch (a) { + return ` +Error generating stack: ${a.message} +${a.stack}`; + } + } + function O(t) { + var l = t; + var a = t; + if (t.alternate) { + while (l.return) { + l = l.return; + } + } else { + t = l; + do { + l = t; + if ((l.flags & 4098) !== 0) { + a = l.return; + } + t = l.return; + } while (t); + } + if (l.tag === 3) { + return a; + } else { + return null; + } + } + function D(t) { + if (O(t) !== t) { + throw Error(m(188)); + } + } + function b(t) { + var l = t.alternate; + if (!l) { + l = O(t); + if (l === null) { + throw Error(m(188)); + } + if (l !== t) { + return null; + } else { + return t; + } + } + var a = t; + var e = l; + while (true) { + var u = a.return; + if (u === null) { + break; + } + var n = u.alternate; + if (n === null) { + e = u.return; + if (e !== null) { + a = e; + continue; + } + break; + } + if (u.child === n.child) { + for (n = u.child; n;) { + if (n === a) { + D(u); + return t; + } + if (n === e) { + D(u); + return l; + } + n = n.sibling; + } + throw Error(m(188)); + } + if (a.return !== e.return) { + a = u; + e = n; + } else { + var i = false; + for (var v = u.child; v;) { + if (v === a) { + i = true; + a = u; + e = n; + break; + } + if (v === e) { + i = true; + e = u; + a = n; + break; + } + v = v.sibling; + } + if (!i) { + for (v = n.child; v;) { + if (v === a) { + i = true; + a = n; + e = u; + break; + } + if (v === e) { + i = true; + e = n; + a = u; + break; + } + v = v.sibling; + } + if (!i) { + throw Error(m(189)); + } + } + } + if (a.alternate !== e) { + throw Error(m(190)); + } + } + if (a.tag !== 3) { + throw Error(m(188)); + } + if (a.stateNode.current === a) { + return t; + } else { + return l; + } + } + function W(t) { + var l = t.tag; + if (l === 5 || l === 26 || l === 27 || l === 6) { + return t; + } + for (t = t.child; t !== null;) { + l = W(t); + if (l !== null) { + return l; + } + t = t.sibling; + } + return null; + } + function x(t) { + var l = t.tag; + if (l === 5 || l === 26 || l === 27 || l === 6) { + return t; + } + for (t = t.child; t !== null;) { + if (t.tag !== 4 && (l = x(t), l !== null)) { + return l; + } + t = t.sibling; + } + return null; + } + function V(t) { + return { + current: t + }; + } + function _(t) { + if (!(Ra < 0)) { + t.current = ac[Ra]; + ac[Ra] = null; + Ra--; + } + } + function N(t, l) { + Ra++; + ac[Ra] = t.current; + t.current = l; + } + function X(t) { + t >>>= 0; + if (t === 0) { + return 32; + } else { + return 31 - (yp(t) / Sp | 0) | 0; + } + } + function Y(t) { + var l = t & 42; + if (l !== 0) { + return l; + } + switch (t & -t) { + 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: + return 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 & 4194176; + case 4194304: + case 8388608: + case 16777216: + case 33554432: + return t & 62914560; + case 67108864: + return 67108864; + case 134217728: + return 134217728; + case 268435456: + return 268435456; + case 536870912: + return 536870912; + case 1073741824: + return 0; + default: + return t; + } + } + function F(t, l) { + var a = t.pendingLanes; + if (a === 0) { + return 0; + } + var e = 0; + var u = t.suspendedLanes; + var n = t.pingedLanes; + var i = t.warmLanes; + t = t.finishedLanes !== 0; + var v = a & 134217727; + if (v !== 0) { + a = v & ~u; + if (a !== 0) { + e = Y(a); + } else { + n &= v; + if (n !== 0) { + e = Y(n); + } else if (!t) { + i = v & ~i; + if (i !== 0) { + e = Y(i); + } + } + } + } else { + v = a & ~u; + if (v !== 0) { + e = Y(v); + } else if (n !== 0) { + e = Y(n); + } else if (!t) { + i = a & ~i; + if (i !== 0) { + e = Y(i); + } + } + } + if (e === 0) { + return 0; + } else if (l !== 0 && l !== e && (l & u) === 0 && (u = e & -e, i = l & -l, u >= i || u === 32 && (i & 4194176) !== 0)) { + return l; + } else { + return e; + } + } + function B(t, l) { + return (t.pendingLanes & ~(t.suspendedLanes & ~t.pingedLanes) & l) === 0; + } + function ct(t, l) { + switch (t) { + case 1: + case 2: + case 4: + case 8: + return l + 250; + 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 l + 5000; + case 4194304: + case 8388608: + case 16777216: + case 33554432: + return -1; + case 67108864: + case 134217728: + case 268435456: + case 536870912: + case 1073741824: + return -1; + default: + return -1; + } + } + function pt() { + var t = fu; + fu <<= 1; + if ((fu & 4194176) === 0) { + fu = 128; + } + return t; + } + function at() { + var t = iu; + iu <<= 1; + if ((iu & 62914560) === 0) { + iu = 4194304; + } + return t; + } + function st(t) { + var l = []; + for (var a = 0; a < 31; a++) { + l.push(t); + } + return l; + } + function et(t, l) { + t.pendingLanes |= l; + if (l !== 268435456) { + t.suspendedLanes = 0; + t.pingedLanes = 0; + t.warmLanes = 0; + } + } + function Ma(t, l, a, e, u, n) { + var i = t.pendingLanes; + t.pendingLanes = a; + t.suspendedLanes = 0; + t.pingedLanes = 0; + t.warmLanes = 0; + t.expiredLanes &= a; + t.entangledLanes &= a; + t.errorRecoveryDisabledLanes &= a; + t.shellSuspendCounter = 0; + var v = t.entanglements; + var d = t.expirationTimes; + var E = t.hiddenUpdates; + for (a = i & ~a; a > 0;) { + var H = 31 - Jt(a); + var r = 1 << H; + v[H] = 0; + d[H] = -1; + var j = E[H]; + if (j !== null) { + E[H] = null; + H = 0; + for (; H < j.length; H++) { + var Q = j[H]; + if (Q !== null) { + Q.lane &= -536870913; + } + } + } + a &= ~r; + } + if (e !== 0) { + J(t, e, 0); + } + if (n !== 0 && u === 0 && t.tag !== 0) { + t.suspendedLanes |= n & ~(i & ~l); + } + } + function J(t, l, a) { + t.pendingLanes |= l; + t.suspendedLanes &= ~l; + var e = 31 - Jt(l); + t.entangledLanes |= l; + t.entanglements[e] = t.entanglements[e] | 1073741824 | a & 4194218; + } + function ht(t, l) { + var a = t.entangledLanes |= l; + for (t = t.entanglements; a;) { + var e = 31 - Jt(a); + var u = 1 << e; + if (u & l | t[e] & l) { + t[e] |= l; + } + a &= ~u; + } + } + function ul(t) { + t &= -t; + if (t > 2) { + if (t > 8) { + if ((t & 134217727) !== 0) { + return 32; + } else { + return 268435456; + } + } else { + return 8; + } + } else { + return 2; + } + } + function Ce(t) { + if (Lt && typeof Lt.onCommitFiberRoot == "function") { + try { + Lt.onCommitFiberRoot(Ne, t, undefined, (t.current.flags & 128) === 128); + } catch {} + } + } + function nl(t) { + if (typeof Tp == "function") { + Mp(t); + } + if (Lt && typeof Lt.setStrictMode == "function") { + try { + Lt.setStrictMode(Ne, t); + } catch {} + } + } + function ta(t, l) { + return t === l && (t !== 0 || 1 / t === 1 / l) || t !== t && l !== l; + } + function Rt(t, l) { + if (typeof t == "object" && t !== null) { + var a = gs.get(t); + if (a !== undefined) { + return a; + } else { + l = { + value: t, + source: l, + stack: U(l) + }; + gs.set(t, l); + return l; + } + } + return { + value: t, + source: l, + stack: U(l) + }; + } + function ml(t, l) { + qa[Ba++] = vu; + qa[Ba++] = mu; + mu = t; + vu = l; + } + function mt(t, l, a) { + wt[kt++] = Ol; + wt[kt++] = Hl; + wt[kt++] = ma; + ma = t; + var e = Ol; + t = Hl; + var u = 32 - Jt(e) - 1; + e &= ~(1 << u); + a += 1; + var n = 32 - Jt(l) + u; + if (n > 30) { + var i = u - u % 5; + n = (e & (1 << i) - 1).toString(32); + e >>= i; + u -= i; + Ol = 1 << 32 - Jt(l) + u | a << u | e; + Hl = n + t; + } else { + Ol = 1 << n | a << u | e; + Hl = t; + } + } + function ot(t) { + if (t.return !== null) { + ml(t, 1); + mt(t, 1, 0); + } + } + function Dl(t) { + while (t === mu) { + mu = qa[--Ba]; + qa[Ba] = null; + vu = qa[--Ba]; + qa[Ba] = null; + } + while (t === ma) { + ma = wt[--kt]; + wt[kt] = null; + Hl = wt[--kt]; + wt[kt] = null; + Ol = wt[--kt]; + wt[kt] = null; + } + } + function Mt(t, l) { + N(Ll, l); + N(Te, t); + N(At, null); + t = ev(l); + _(At); + N(At, t); + } + function bl() { + _(At); + _(Te); + _(Ll); + } + function Oa(t) { + if (t.memoizedState !== null) { + N(pu, t); + } + var l = At.current; + var a = uv(l, t.type); + if (l !== a) { + N(Te, t); + N(At, a); + } + } + function qe(t) { + if (Te.current === t) { + _(At); + _(Te); + } + if (pu.current === t) { + _(pu); + if (Ml) { + sa._currentValue = ba; + } else { + sa._currentValue2 = ba; + } + } + } + function la(t) { + var l = Error(m(418, "")); + ee(Rt(l, t)); + throw nc; + } + function Fc(t, l) { + if (!It) { + throw Error(m(175)); + } + if (!$v(t.stateNode, t.type, t.memoizedProps, l, t)) { + la(t); + } + } + function Pc(t) { + for (qt = t.return; qt;) { + switch (qt.tag) { + case 3: + case 27: + pl = true; + return; + case 5: + case 13: + pl = false; + return; + default: + qt = qt.return; + } + } + } + function le(t) { + if (!It || t !== qt) { + return false; + } + if (!P) { + Pc(t); + P = true; + return false; + } + var l = false; + if (Dt) { + if (t.tag !== 3 && t.tag !== 27 && (t.tag !== 5 || zs(t.type) && !cu(t.type, t.memoizedProps))) { + l = true; + } + } else if (t.tag !== 3 && (t.tag !== 5 || zs(t.type) && !cu(t.type, t.memoizedProps))) { + l = true; + } + if (l && bt) { + la(t); + } + Pc(t); + if (t.tag === 13) { + if (!It) { + throw Error(m(316)); + } + t = t.memoizedState; + t = t !== null ? t.dehydrated : null; + if (!t) { + throw Error(m(317)); + } + bt = tp(t); + } else { + bt = qt ? hs(t.stateNode) : null; + } + return true; + } + function ae() { + if (It) { + bt = qt = null; + P = false; + } + } + function ee(t) { + if (il === null) { + il = [t]; + } else { + il.push(t); + } + } + function Be() { + for (var t = Qa, l = cc = Qa = 0; l < t;) { + var a = tl[l]; + tl[l++] = null; + var e = tl[l]; + tl[l++] = null; + var u = tl[l]; + tl[l++] = null; + var n = tl[l]; + tl[l++] = null; + if (e !== null && u !== null) { + var i = e.pending; + if (i === null) { + u.next = u; + } else { + u.next = i.next; + i.next = u; + } + e.pending = u; + } + if (n !== 0) { + Ic(a, u, n); + } + } + } + function Qe(t, l, a, e) { + tl[Qa++] = t; + tl[Qa++] = l; + tl[Qa++] = a; + tl[Qa++] = e; + cc |= e; + t.lanes |= e; + t = t.alternate; + if (t !== null) { + t.lanes |= e; + } + } + function Yu(t, l, a, e) { + Qe(t, l, a, e); + return Ye(t); + } + function Rl(t, l) { + Qe(t, null, null, l); + return Ye(t); + } + function Ic(t, l, a) { + t.lanes |= a; + var e = t.alternate; + if (e !== null) { + e.lanes |= a; + } + var u = false; + for (var n = t.return; n !== null;) { + n.childLanes |= a; + e = n.alternate; + if (e !== null) { + e.childLanes |= a; + } + if (n.tag === 22) { + t = n.stateNode; + if (t !== null && !(t._visibility & 1)) { + u = true; + } + } + t = n; + n = n.return; + } + if (u && l !== null && t.tag === 3) { + n = t.stateNode; + u = 31 - Jt(a); + n = n.hiddenUpdates; + t = n[u]; + if (t === null) { + n[u] = [l]; + } else { + t.push(l); + } + l.lane = a | 536870912; + } + } + function Ye(t) { + if (ge > 50) { + ge = 0; + Mc = null; + throw Error(m(185)); + } + for (var l = t.return; l !== null;) { + t = l; + l = t.return; + } + if (t.tag === 3) { + return t.stateNode; + } else { + return null; + } + } + function vl(t) { + if (t !== Ya && t.next === null) { + if (Ya === null) { + ou = Ya = t; + } else { + Ya = Ya.next = t; + } + } + du = true; + if (!fc) { + fc = true; + Um(Hm); + } + } + function Ha(t, l) { + if (!ic && du) { + ic = true; + do { + var a = false; + for (var e = ou; e !== null;) { + if (t !== 0) { + var u = e.pendingLanes; + if (u === 0) { + var n = 0; + } else { + var i = e.suspendedLanes; + var v = e.pingedLanes; + n = (1 << 31 - Jt(t | 42) + 1) - 1; + n &= u & ~(i & ~v); + n = n & 201326677 ? n & 201326677 | 1 : n ? n | 2 : 0; + } + if (n !== 0) { + a = true; + kc(e, n); + } + } else { + n = L; + n = F(e, e === ut ? n : 0); + if ((n & 3) !== 0 && !B(e, n)) { + a = true; + kc(e, n); + } + } + e = e.next; + } + } while (a); + ic = false; + } + } + function Hm() { + du = fc = false; + var t = 0; + if (Ga !== 0) { + if (pv()) { + t = Ga; + } + Ga = 0; + } + var l = fl(); + var a = null; + for (var e = ou; e !== null;) { + var u = e.next; + var n = $c(e, l); + if (n === 0) { + e.next = null; + if (a === null) { + ou = u; + } else { + a.next = u; + } + if (u === null) { + Ya = a; + } + } else { + a = e; + if (t !== 0 || (n & 3) !== 0) { + du = true; + } + } + e = u; + } + Ha(t); + } + function $c(t, l) { + var a = t.suspendedLanes; + var e = t.pingedLanes; + var u = t.expirationTimes; + for (var n = t.pendingLanes & -62914561; n > 0;) { + var i = 31 - Jt(n); + var v = 1 << i; + var d = u[i]; + if (d === -1) { + if ((v & a) === 0 || (v & e) !== 0) { + u[i] = ct(v, l); + } + } else if (d <= l) { + t.expiredLanes |= v; + } + n &= ~v; + } + l = ut; + a = L; + a = F(t, t === l ? a : 0); + e = t.callbackNode; + if (a === 0 || t === l && nt === 2 || t.cancelPendingCommit !== null) { + if (e !== null && e !== null) { + ec(e); + } + t.callbackNode = null; + return t.callbackPriority = 0; + } + if ((a & 3) === 0 || B(t, a)) { + l = a & -a; + if (l === t.callbackPriority) { + return l; + } + if (e !== null) { + ec(e); + } + switch (ul(a)) { + case 2: + case 8: + a = zp; + break; + case 32: + a = uc; + break; + case 268435456: + a = Np; + break; + default: + a = uc; + } + e = wc.bind(null, t); + a = su(a, e); + t.callbackPriority = l; + t.callbackNode = a; + return l; + } + if (e !== null && e !== null) { + ec(e); + } + t.callbackPriority = 2; + t.callbackNode = null; + return 2; + } + function wc(t, l) { + var a = t.callbackNode; + if (ca() && t.callbackNode !== a) { + return null; + } + var e = L; + e = F(t, t === ut ? e : 0); + if (e === 0) { + return null; + } else { + Ri(t, e, l); + $c(t, fl()); + if (t.callbackNode != null && t.callbackNode === a) { + return wc.bind(null, t); + } else { + return null; + } + } + } + function kc(t, l) { + if (ca()) { + return null; + } + Ri(t, l, true); + } + function Um(t) { + if (Ev) { + zv(function () { + if ((tt & 6) !== 0) { + su(js, t); + } else { + t(); + } + }); + } else { + su(js, t); + } + } + function Gu() { + if (Ga === 0) { + Ga = pt(); + } + return Ga; + } + function _m(t, l) { + if (Me === null) { + var a = Me = []; + sc = 0; + Va = Gu(); + Xa = { + status: "pending", + value: undefined, + then: function (e) { + a.push(e); + } + }; + } + sc++; + l.then(tf, tf); + return l; + } + function tf() { + if (--sc === 0 && Me !== null) { + if (Xa !== null) { + Xa.status = "fulfilled"; + } + var t = Me; + Me = null; + Va = 0; + Xa = null; + for (var l = 0; l < t.length; l++) { + (0, t[l])(); + } + } + } + function rm(t, l) { + var a = []; + var e = { + status: "pending", + value: null, + reason: null, + then: function (u) { + a.push(u); + } + }; + t.then(function () { + e.status = "fulfilled"; + e.value = l; + for (var u = 0; u < a.length; u++) { + (0, a[u])(l); + } + }, function (u) { + e.status = "rejected"; + e.reason = u; + u = 0; + for (; u < a.length; u++) { + (0, a[u])(undefined); + } + }); + return e; + } + function Vu(t) { + t.updateQueue = { + baseState: t.memoizedState, + firstBaseUpdate: null, + lastBaseUpdate: null, + shared: { + pending: null, + lanes: 0, + hiddenCallbacks: null + }, + callbacks: null + }; + } + function Xu(t, l) { + t = t.updateQueue; + if (l.updateQueue === t) { + l.updateQueue = { + baseState: t.baseState, + firstBaseUpdate: t.firstBaseUpdate, + lastBaseUpdate: t.lastBaseUpdate, + shared: t.shared, + callbacks: null + }; + } + } + function Cl(t) { + return { + lane: t, + tag: 0, + payload: null, + callback: null, + next: null + }; + } + function ql(t, l, a) { + var e = t.updateQueue; + if (e === null) { + return null; + } + e = e.shared; + if ((tt & 2) !== 0) { + var u = e.pending; + if (u === null) { + l.next = l; + } else { + l.next = u.next; + u.next = l; + } + e.pending = l; + l = Ye(t); + Ic(t, null, a); + return l; + } + Qe(t, e, l, a); + return Ye(t); + } + function ue(t, l, a) { + l = l.updateQueue; + if (l !== null && (l = l.shared, (a & 4194176) !== 0)) { + var e = l.lanes; + e &= t.pendingLanes; + a |= e; + l.lanes = a; + ht(t, a); + } + } + function Zu(t, l) { + var a = t.updateQueue; + var e = t.alternate; + if (e !== null && (e = e.updateQueue, a === e)) { + var u = null; + var n = null; + a = a.firstBaseUpdate; + if (a !== null) { + do { + var i = { + lane: a.lane, + tag: a.tag, + payload: a.payload, + callback: null, + next: null + }; + if (n === null) { + u = n = i; + } else { + n = n.next = i; + } + a = a.next; + } while (a !== null); + if (n === null) { + u = n = l; + } else { + n = n.next = l; + } + } else { + u = n = l; + } + a = { + baseState: e.baseState, + firstBaseUpdate: u, + lastBaseUpdate: n, + shared: e.shared, + callbacks: e.callbacks + }; + t.updateQueue = a; + return; + } + t = a.lastBaseUpdate; + if (t === null) { + a.firstBaseUpdate = l; + } else { + t.next = l; + } + a.lastBaseUpdate = l; + } + function ne() { + if (mc) { + var t = Xa; + if (t !== null) { + throw t; + } + } + } + function ce(t, l, a, e) { + mc = false; + var u = t.updateQueue; + Wl = false; + var n = u.firstBaseUpdate; + var i = u.lastBaseUpdate; + var v = u.shared.pending; + if (v !== null) { + u.shared.pending = null; + var d = v; + var E = d.next; + d.next = null; + if (i === null) { + n = E; + } else { + i.next = E; + } + i = d; + var H = t.alternate; + if (H !== null) { + H = H.updateQueue; + v = H.lastBaseUpdate; + if (v !== i) { + if (v === null) { + H.firstBaseUpdate = E; + } else { + v.next = E; + } + H.lastBaseUpdate = d; + } + } + } + if (n !== null) { + var r = u.baseState; + i = 0; + H = E = d = null; + v = n; + do { + var j = v.lane & -536870913; + var Q = j !== v.lane; + if (Q ? (L & j) === j : (e & j) === j) { + if (j !== 0 && j === Va) { + mc = true; + } + if (H !== null) { + H = H.next = { + lane: 0, + tag: v.tag, + payload: v.payload, + callback: null, + next: null + }; + } + t: { + var el = t; + var De = v; + j = l; + var za = a; + switch (De.tag) { + case 1: + el = De.payload; + if (typeof el == "function") { + r = el.call(za, r, j); + break t; + } + r = el; + break t; + case 3: + el.flags = el.flags & -65537 | 128; + case 0: + el = De.payload; + j = typeof el == "function" ? el.call(za, r, j) : el; + if (j == null) { + break t; + } + r = Kn({}, r, j); + break t; + case 2: + Wl = true; + } + } + j = v.callback; + if (j !== null) { + t.flags |= 64; + if (Q) { + t.flags |= 8192; + } + Q = u.callbacks; + if (Q === null) { + u.callbacks = [j]; + } else { + Q.push(j); + } + } + } else { + Q = { + lane: j, + tag: v.tag, + payload: v.payload, + callback: v.callback, + next: null + }; + if (H === null) { + E = H = Q; + d = r; + } else { + H = H.next = Q; + } + i |= j; + } + v = v.next; + if (v === null) { + v = u.shared.pending; + if (v === null) { + break; + } + Q = v; + v = Q.next; + Q.next = null; + u.lastBaseUpdate = Q; + u.shared.pending = null; + } + } while (true); + if (H === null) { + d = r; + } + u.baseState = d; + u.firstBaseUpdate = E; + u.lastBaseUpdate = H; + if (n === null) { + u.shared.lanes = 0; + } + Il |= i; + t.lanes = i; + t.memoizedState = r; + } + } + function lf(t, l) { + if (typeof t != "function") { + throw Error(m(191, t)); + } + t.call(l); + } + function af(t, l) { + var a = t.callbacks; + if (a !== null) { + t.callbacks = null; + t = 0; + for (; t < a.length; t++) { + lf(a[t], l); + } + } + } + function Ge(t, l) { + if (Wt(t, l)) { + return true; + } + if (typeof t != "object" || t === null || typeof l != "object" || l === null) { + return false; + } + var a = Object.keys(t); + var e = Object.keys(l); + if (a.length !== e.length) { + return false; + } + for (e = 0; e < a.length; e++) { + var u = a[e]; + if (!Op.call(l, u) || !Wt(t[u], l[u])) { + return false; + } + } + return true; + } + function ef(t) { + t = t.status; + return t === "fulfilled" || t === "rejected"; + } + function Ve() {} + function uf(t, l, a) { + a = t[a]; + if (a === undefined) { + t.push(l); + } else if (a !== l) { + l.then(Ve, Ve); + l = a; + } + switch (l.status) { + case "fulfilled": + return l.value; + case "rejected": + t = l.reason; + throw t === Oe ? Error(m(483)) : t; + default: + if (typeof l.status == "string") { + l.then(Ve, Ve); + } else { + t = ut; + if (t !== null && t.shellSuspendCounter > 100) { + throw Error(m(482)); + } + t = l; + t.status = "pending"; + t.then(function (e) { + if (l.status === "pending") { + var u = l; + u.status = "fulfilled"; + u.value = e; + } + }, function (e) { + if (l.status === "pending") { + var u = l; + u.status = "rejected"; + u.reason = e; + } + }); + } + switch (l.status) { + case "fulfilled": + return l.value; + case "rejected": + t = l.reason; + throw t === Oe ? Error(m(483)) : t; + } + Za = l; + throw Oe; + } + } + function nf() { + if (Za === null) { + throw Error(m(459)); + } + var t = Za; + Za = null; + return t; + } + function Xe(t) { + var l = He; + He += 1; + if (Ka === null) { + Ka = []; + } + return uf(Ka, t, l); + } + function fe(t, l) { + l = l.props.ref; + t.ref = l !== undefined ? l : null; + } + function Ze(t, l) { + throw l.$$typeof === $m ? Error(m(525)) : (t = Object.prototype.toString.call(l), Error(m(31, t === "[object Object]" ? "object with keys {" + Object.keys(l).join(", ") + "}" : t))); + } + function cf(t) { + var l = t._init; + return l(t._payload); + } + function ff(t) { + function l(y, o) { + if (t) { + var S = y.deletions; + if (S === null) { + y.deletions = [o]; + y.flags |= 16; + } else { + S.push(o); + } + } + } + function a(y, o) { + if (!t) { + return null; + } + while (o !== null) { + l(y, o); + o = o.sibling; + } + return null; + } + function e(y) { + var o = new Map(); + while (y !== null) { + if (y.key !== null) { + o.set(y.key, y); + } else { + o.set(y.index, y); + } + y = y.sibling; + } + return o; + } + function u(y, o) { + y = Zl(y, o); + y.index = 0; + y.sibling = null; + return y; + } + function n(y, o, S) { + y.index = S; + if (t) { + S = y.alternate; + if (S !== null) { + S = S.index; + if (S < o) { + y.flags |= 33554434; + return o; + } else { + return S; + } + } else { + y.flags |= 33554434; + return o; + } + } else { + y.flags |= 1048576; + return o; + } + } + function i(y) { + if (t && y.alternate === null) { + y.flags |= 33554434; + } + return y; + } + function v(y, o, S, M) { + if (o === null || o.tag !== 6) { + o = Vn(S, y.mode, M); + o.return = y; + return o; + } else { + o = u(o, S); + o.return = y; + return o; + } + } + function d(y, o, S, M) { + var R = S.type; + if (R === Da) { + return H(y, o, S.props.children, M, S.key); + } else if (o !== null && (o.elementType === R || typeof R == "object" && R !== null && R.$$typeof === xl && cf(R) === o.type)) { + o = u(o, S.props); + fe(o, S); + o.return = y; + return o; + } else { + o = eu(S.type, S.key, S.props, null, y.mode, M); + fe(o, S); + o.return = y; + return o; + } + } + function E(y, o, S, M) { + if (o === null || o.tag !== 4 || o.stateNode.containerInfo !== S.containerInfo || o.stateNode.implementation !== S.implementation) { + o = Xn(S, y.mode, M); + o.return = y; + return o; + } else { + o = u(o, S.children || []); + o.return = y; + return o; + } + } + function H(y, o, S, M, R) { + if (o === null || o.tag !== 7) { + o = fa(S, y.mode, M, R); + o.return = y; + return o; + } else { + o = u(o, S); + o.return = y; + return o; + } + } + function r(y, o, S) { + if (typeof o == "string" && o !== "" || typeof o == "number" || typeof o == "bigint") { + o = Vn("" + o, y.mode, S); + o.return = y; + return o; + } + if (typeof o == "object" && o !== null) { + switch (o.$$typeof) { + case uu: + S = eu(o.type, o.key, o.props, null, y.mode, S); + fe(S, o); + S.return = y; + return S; + case ga: + o = Xn(o, y.mode, S); + o.return = y; + return o; + case xl: + var M = o._init; + o = M(o._payload); + return r(y, o, S); + } + if (nu(o) || h(o)) { + o = fa(o, y.mode, S, null); + o.return = y; + return o; + } + if (typeof o.then == "function") { + return r(y, Xe(o), S); + } + if (o.$$typeof === Kl) { + return r(y, $e(y, o), S); + } + Ze(y, o); + } + return null; + } + function j(y, o, S, M) { + var R = o !== null ? o.key : null; + if (typeof S == "string" && S !== "" || typeof S == "number" || typeof S == "bigint") { + if (R !== null) { + return null; + } else { + return v(y, o, "" + S, M); + } + } + if (typeof S == "object" && S !== null) { + switch (S.$$typeof) { + case uu: + if (S.key === R) { + return d(y, o, S, M); + } else { + return null; + } + case ga: + if (S.key === R) { + return E(y, o, S, M); + } else { + return null; + } + case xl: + R = S._init; + S = R(S._payload); + return j(y, o, S, M); + } + if (nu(S) || h(S)) { + if (R !== null) { + return null; + } else { + return H(y, o, S, M, null); + } + } + if (typeof S.then == "function") { + return j(y, o, Xe(S), M); + } + if (S.$$typeof === Kl) { + return j(y, o, $e(y, S), M); + } + Ze(y, S); + } + return null; + } + function Q(y, o, S, M, R) { + if (typeof M == "string" && M !== "" || typeof M == "number" || typeof M == "bigint") { + y = y.get(S) || null; + return v(o, y, "" + M, R); + } + if (typeof M == "object" && M !== null) { + switch (M.$$typeof) { + case uu: + y = y.get(M.key === null ? S : M.key) || null; + return d(o, y, M, R); + case ga: + y = y.get(M.key === null ? S : M.key) || null; + return E(o, y, M, R); + case xl: + var ft = M._init; + M = ft(M._payload); + return Q(y, o, S, M, R); + } + if (nu(M) || h(M)) { + y = y.get(S) || null; + return H(o, y, M, R, null); + } + if (typeof M.then == "function") { + return Q(y, o, S, Xe(M), R); + } + if (M.$$typeof === Kl) { + return Q(y, o, S, $e(o, M), R); + } + Ze(o, M); + } + return null; + } + function el(y, o, S, M) { + var R = null; + var ft = null; + for (var C = o, I = o = 0, _t = null; C !== null && I < S.length; I++) { + if (C.index > I) { + _t = C; + C = null; + } else { + _t = C.sibling; + } + var $ = j(y, C, S[I], M); + if ($ === null) { + if (C === null) { + C = _t; + } + break; + } + if (t && C && $.alternate === null) { + l(y, C); + } + o = n($, o, I); + if (ft === null) { + R = $; + } else { + ft.sibling = $; + } + ft = $; + C = _t; + } + if (I === S.length) { + a(y, C); + if (P) { + ml(y, I); + } + return R; + } + if (C === null) { + for (; I < S.length; I++) { + C = r(y, S[I], M); + if (C !== null) { + o = n(C, o, I); + if (ft === null) { + R = C; + } else { + ft.sibling = C; + } + ft = C; + } + } + if (P) { + ml(y, I); + } + return R; + } + for (C = e(C); I < S.length; I++) { + _t = Q(C, y, I, S[I], M); + if (_t !== null) { + if (t && _t.alternate !== null) { + C.delete(_t.key === null ? I : _t.key); + } + o = n(_t, o, I); + if (ft === null) { + R = _t; + } else { + ft.sibling = _t; + } + ft = _t; + } + } + if (t) { + C.forEach(function (wl) { + return l(y, wl); + }); + } + if (P) { + ml(y, I); + } + return R; + } + function De(y, o, S, M) { + if (S == null) { + throw Error(m(151)); + } + var R = null; + var ft = null; + for (var C = o, I = o = 0, _t = null, $ = S.next(); C !== null && !$.done; I++, $ = S.next()) { + if (C.index > I) { + _t = C; + C = null; + } else { + _t = C.sibling; + } + var wl = j(y, C, $.value, M); + if (wl === null) { + if (C === null) { + C = _t; + } + break; + } + if (t && C && wl.alternate === null) { + l(y, C); + } + o = n(wl, o, I); + if (ft === null) { + R = wl; + } else { + ft.sibling = wl; + } + ft = wl; + C = _t; + } + if ($.done) { + a(y, C); + if (P) { + ml(y, I); + } + return R; + } + if (C === null) { + for (; !$.done; I++, $ = S.next()) { + $ = r(y, $.value, M); + if ($ !== null) { + o = n($, o, I); + if (ft === null) { + R = $; + } else { + ft.sibling = $; + } + ft = $; + } + } + if (P) { + ml(y, I); + } + return R; + } + for (C = e(C); !$.done; I++, $ = S.next()) { + $ = Q(C, y, I, $.value, M); + if ($ !== null) { + if (t && $.alternate !== null) { + C.delete($.key === null ? I : $.key); + } + o = n($, o, I); + if (ft === null) { + R = $; + } else { + ft.sibling = $; + } + ft = $; + } + } + if (t) { + C.forEach(function (gp) { + return l(y, gp); + }); + } + if (P) { + ml(y, I); + } + return R; + } + function za(y, o, S, M) { + if (typeof S == "object" && S !== null && S.type === Da && S.key === null) { + S = S.props.children; + } + if (typeof S == "object" && S !== null) { + switch (S.$$typeof) { + case uu: + t: { + var R = S.key; + while (o !== null) { + if (o.key === R) { + R = S.type; + if (R === Da) { + if (o.tag === 7) { + a(y, o.sibling); + M = u(o, S.props.children); + M.return = y; + y = M; + break t; + } + } else if (o.elementType === R || typeof R == "object" && R !== null && R.$$typeof === xl && cf(R) === o.type) { + a(y, o.sibling); + M = u(o, S.props); + fe(M, S); + M.return = y; + y = M; + break t; + } + a(y, o); + break; + } else { + l(y, o); + } + o = o.sibling; + } + if (S.type === Da) { + M = fa(S.props.children, y.mode, M, S.key); + M.return = y; + y = M; + } else { + M = eu(S.type, S.key, S.props, null, y.mode, M); + fe(M, S); + M.return = y; + y = M; + } + } + return i(y); + case ga: + t: { + for (R = S.key; o !== null;) { + if (o.key === R) { + if (o.tag === 4 && o.stateNode.containerInfo === S.containerInfo && o.stateNode.implementation === S.implementation) { + a(y, o.sibling); + M = u(o, S.children || []); + M.return = y; + y = M; + break t; + } else { + a(y, o); + break; + } + } else { + l(y, o); + } + o = o.sibling; + } + M = Xn(S, y.mode, M); + M.return = y; + y = M; + } + return i(y); + case xl: + R = S._init; + S = R(S._payload); + return za(y, o, S, M); + } + if (nu(S)) { + return el(y, o, S, M); + } + if (h(S)) { + R = h(S); + if (typeof R != "function") { + throw Error(m(150)); + } + S = R.call(S); + return De(y, o, S, M); + } + if (typeof S.then == "function") { + return za(y, o, Xe(S), M); + } + if (S.$$typeof === Kl) { + return za(y, o, $e(y, S), M); + } + Ze(y, S); + } + if (typeof S == "string" && S !== "" || typeof S == "number" || typeof S == "bigint") { + S = "" + S; + if (o !== null && o.tag === 6) { + a(y, o.sibling); + M = u(o, S); + M.return = y; + y = M; + } else { + a(y, o); + M = Vn(S, y.mode, M); + M.return = y; + y = M; + } + return i(y); + } else { + return a(y, o); + } + } + return function (y, o, S, M) { + try { + He = 0; + var R = za(y, o, S, M); + Ka = null; + return R; + } catch (C) { + if (C === Oe) { + throw C; + } + var ft = s(29, C, null, y.mode); + ft.lanes = M; + ft.return = y; + return ft; + } finally {} + }; + } + function sf(t, l) { + t = Al; + N(Su, t); + N(xa, l); + Al = t | l.baseLanes; + } + function Ku() { + N(Su, Al); + N(xa, xa.current); + } + function xu() { + Al = Su.current; + _(xa); + _(Su); + } + function Bl(t) { + var l = t.alternate; + N(Ot, Ot.current & 1); + N(ll, t); + if (ol === null && (l === null || xa.current !== null || l.memoizedState !== null)) { + ol = t; + } + } + function mf(t) { + if (t.tag === 22) { + N(Ot, Ot.current); + N(ll, t); + if (ol === null) { + var l = t.alternate; + if (l !== null && l.memoizedState !== null) { + ol = t; + } + } + } else { + Ql(); + } + } + function Ql() { + N(Ot, Ot.current); + N(ll, ll.current); + } + function Sl(t) { + _(ll); + if (ol === t) { + ol = null; + } + _(Ot); + } + function Ke(t) { + for (var l = t; l !== null;) { + if (l.tag === 13) { + var a = l.memoizedState; + if (a !== null && (a = a.dehydrated, a === null || kn(a) || tc(a))) { + return l; + } + } else if (l.tag === 19 && l.memoizedProps.revealOrder !== undefined) { + if ((l.flags & 128) !== 0) { + return l; + } + } else if (l.child !== null) { + l.child.return = l; + l = l.child; + continue; + } + if (l === t) { + break; + } + while (l.sibling === null) { + if (l.return === null || l.return === t) { + return null; + } + l = l.return; + } + l.sibling.return = l.return; + l = l.sibling; + } + return null; + } + function Et() { + throw Error(m(321)); + } + function Ju(t, l) { + if (l === null) { + return false; + } + for (var a = 0; a < l.length && a < t.length; a++) { + if (!Wt(t[a], l[a])) { + return false; + } + } + return true; + } + function Lu(t, l, a, e, u, n) { + Fl = n; + G = l; + l.memoizedState = null; + l.updateQueue = null; + l.lanes = 0; + q.H = t === null || t.memoizedState === null ? oa : Pl; + pa = false; + n = a(e, u); + pa = false; + if (Ja) { + n = pf(l, a, e, u); + } + vf(t); + return n; + } + function vf(t) { + q.H = dl; + var l = k !== null && k.next !== null; + Fl = 0; + Nt = k = G = null; + hu = false; + Ue = 0; + La = null; + if (l) { + throw Error(m(300)); + } + if (t !== null && !Ht) { + t = t.dependencies; + if (t !== null && Ie(t)) { + Ht = true; + } + } + } + function pf(t, l, a, e) { + G = t; + var u = 0; + do { + if (Ja) { + La = null; + } + Ue = 0; + Ja = false; + if (u >= 25) { + throw Error(m(301)); + } + u += 1; + Nt = k = null; + if (t.updateQueue != null) { + var n = t.updateQueue; + n.lastEffect = null; + n.events = null; + n.stores = null; + if (n.memoCache != null) { + n.memoCache.index = 0; + } + } + q.H = da; + n = l(a, e); + } while (Ja); + return n; + } + function Am() { + var t = q.H; + var l = t.useState()[0]; + l = typeof l.then == "function" ? ie(l) : l; + t = t.useState()[0]; + if ((k !== null ? k.memoizedState : null) !== t) { + G.flags |= 1024; + } + return l; + } + function Wu() { + var t = Eu !== 0; + Eu = 0; + return t; + } + function Fu(t, l, a) { + l.updateQueue = t.updateQueue; + l.flags &= -2053; + t.lanes &= ~a; + } + function Pu(t) { + if (hu) { + for (t = t.memoizedState; t !== null;) { + var l = t.queue; + if (l !== null) { + l.pending = null; + } + t = t.next; + } + hu = false; + } + Fl = 0; + Nt = k = G = null; + Ja = false; + Ue = Eu = 0; + La = null; + } + function Qt() { + var t = { + memoizedState: null, + baseState: null, + baseQueue: null, + queue: null, + next: null + }; + if (Nt === null) { + G.memoizedState = Nt = t; + } else { + Nt = Nt.next = t; + } + return Nt; + } + function zt() { + if (k === null) { + var t = G.alternate; + t = t !== null ? t.memoizedState : null; + } else { + t = k.next; + } + var l = Nt === null ? G.memoizedState : Nt.next; + if (l !== null) { + Nt = l; + k = t; + } else { + if (t === null) { + throw G.alternate === null ? Error(m(467)) : Error(m(310)); + } + k = t; + t = { + memoizedState: k.memoizedState, + baseState: k.baseState, + baseQueue: k.baseQueue, + queue: k.queue, + next: null + }; + if (Nt === null) { + G.memoizedState = Nt = t; + } else { + Nt = Nt.next = t; + } + } + return Nt; + } + function ie(t) { + var l = Ue; + Ue += 1; + if (La === null) { + La = []; + } + t = uf(La, t, l); + l = G; + if ((Nt === null ? l.memoizedState : Nt.next) === null) { + l = l.alternate; + q.H = l === null || l.memoizedState === null ? oa : Pl; + } + return t; + } + function xe(t) { + if (t !== null && typeof t == "object") { + if (typeof t.then == "function") { + return ie(t); + } + if (t.$$typeof === Kl) { + return jt(t); + } + } + throw Error(m(438, String(t))); + } + function Iu(t) { + var l = null; + var a = G.updateQueue; + if (a !== null) { + l = a.memoCache; + } + if (l == null) { + var e = G.alternate; + if (e !== null) { + e = e.updateQueue; + if (e !== null) { + e = e.memoCache; + if (e != null) { + l = { + data: e.data.map(function (u) { + return u.slice(); + }), + index: 0 + }; + } + } + } + } + if (l == null) { + l = { + data: [], + index: 0 + }; + } + if (a === null) { + a = pc(); + G.updateQueue = a; + } + a.memoCache = l; + a = l.data[l.index]; + if (a === undefined) { + a = l.data[l.index] = Array(t); + e = 0; + for (; e < t; e++) { + a[e] = km; + } + } + l.index++; + return a; + } + function hl(t, l) { + if (typeof l == "function") { + return l(t); + } else { + return l; + } + } + function Je(t) { + var l = zt(); + return $u(l, k, t); + } + function $u(t, l, a) { + var e = t.queue; + if (e === null) { + throw Error(m(311)); + } + e.lastRenderedReducer = a; + var u = t.baseQueue; + var n = e.pending; + if (n !== null) { + if (u !== null) { + var i = u.next; + u.next = n.next; + n.next = i; + } + l.baseQueue = u = n; + e.pending = null; + } + n = t.baseState; + if (u === null) { + t.memoizedState = n; + } else { + l = u.next; + var v = i = null; + var d = null; + var E = l; + var H = false; + do { + var r = E.lane & -536870913; + if (r !== E.lane ? (L & r) === r : (Fl & r) === r) { + var j = E.revertLane; + if (j === 0) { + if (d !== null) { + d = d.next = { + lane: 0, + revertLane: 0, + action: E.action, + hasEagerState: E.hasEagerState, + eagerState: E.eagerState, + next: null + }; + } + if (r === Va) { + H = true; + } + } else if ((Fl & j) === j) { + E = E.next; + if (j === Va) { + H = true; + } + continue; + } else { + r = { + lane: 0, + revertLane: E.revertLane, + action: E.action, + hasEagerState: E.hasEagerState, + eagerState: E.eagerState, + next: null + }; + if (d === null) { + v = d = r; + i = n; + } else { + d = d.next = r; + } + G.lanes |= j; + Il |= j; + } + r = E.action; + if (pa) { + a(n, r); + } + n = E.hasEagerState ? E.eagerState : a(n, r); + } else { + j = { + lane: r, + revertLane: E.revertLane, + action: E.action, + hasEagerState: E.hasEagerState, + eagerState: E.eagerState, + next: null + }; + if (d === null) { + v = d = j; + i = n; + } else { + d = d.next = j; + } + G.lanes |= r; + Il |= r; + } + E = E.next; + } while (E !== null && E !== l); + if (d === null) { + i = n; + } else { + d.next = v; + } + if (!Wt(n, t.memoizedState) && (Ht = true, H && (a = Xa, a !== null))) { + throw a; + } + t.memoizedState = n; + t.baseState = i; + t.baseQueue = d; + e.lastRenderedState = n; + } + if (u === null) { + e.lanes = 0; + } + return [t.memoizedState, e.dispatch]; + } + function wu(t) { + var l = zt(); + var a = l.queue; + if (a === null) { + throw Error(m(311)); + } + a.lastRenderedReducer = t; + var e = a.dispatch; + var u = a.pending; + var n = l.memoizedState; + if (u !== null) { + a.pending = null; + var i = u = u.next; + do { + n = t(n, i.action); + i = i.next; + } while (i !== u); + if (!Wt(n, l.memoizedState)) { + Ht = true; + } + l.memoizedState = n; + if (l.baseQueue === null) { + l.baseState = n; + } + a.lastRenderedState = n; + } + return [n, e]; + } + function of(t, l, a) { + var e = G; + var u = zt(); + var n = P; + if (n) { + if (a === undefined) { + throw Error(m(407)); + } + a = a(); + } else { + a = l(); + } + var i = !Wt((k || u).memoizedState, a); + if (i) { + u.memoizedState = a; + Ht = true; + } + u = u.queue; + ln(Sf.bind(null, e, u, t), [t]); + if (u.getSnapshot !== l || i || Nt !== null && Nt.memoizedState.tag & 1) { + e.flags |= 2048; + Ua(9, yf.bind(null, e, u, a, l), { + destroy: undefined + }, null); + if (ut === null) { + throw Error(m(349)); + } + if (!n && (Fl & 60) === 0) { + df(e, l, a); + } + } + return a; + } + function df(t, l, a) { + t.flags |= 16384; + t = { + getSnapshot: l, + value: a + }; + l = G.updateQueue; + if (l === null) { + l = pc(); + G.updateQueue = l; + l.stores = [t]; + } else { + a = l.stores; + if (a === null) { + l.stores = [t]; + } else { + a.push(t); + } + } + } + function yf(t, l, a, e) { + l.value = a; + l.getSnapshot = e; + if (hf(l)) { + Ef(t); + } + } + function Sf(t, l, a) { + return a(function () { + if (hf(l)) { + Ef(t); + } + }); + } + function hf(t) { + var l = t.getSnapshot; + t = t.value; + try { + var a = l(); + return !Wt(t, a); + } catch { + return true; + } + } + function Ef(t) { + var l = Rl(t, 2); + if (l !== null) { + Ct(l, t, 2); + } + } + function ku(t) { + var l = Qt(); + if (typeof t == "function") { + var a = t; + t = a(); + if (pa) { + nl(true); + try { + a(); + } finally { + nl(false); + } + } + } + l.memoizedState = l.baseState = t; + l.queue = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: hl, + lastRenderedState: t + }; + return l; + } + function zf(t, l, a, e) { + t.baseState = a; + return $u(t, k, typeof e == "function" ? e : hl); + } + function jm(t, l, a, e, u) { + if (Fe(t)) { + throw Error(m(485)); + } + t = l.action; + if (t !== null) { + var n = { + payload: u, + action: t, + next: null, + isTransition: true, + status: "pending", + value: null, + reason: null, + listeners: [], + then: function (i) { + n.listeners.push(i); + } + }; + if (q.T !== null) { + a(true); + } else { + n.isTransition = false; + } + e(n); + a = l.pending; + if (a === null) { + n.next = l.pending = n; + Nf(l, n); + } else { + n.next = a.next; + l.pending = a.next = n; + } + } + } + function Nf(t, l) { + var a = l.action; + var e = l.payload; + var u = t.state; + if (l.isTransition) { + var n = q.T; + var i = {}; + q.T = i; + try { + var v = a(u, e); + var d = q.S; + if (d !== null) { + d(i, v); + } + Tf(t, l, v); + } catch (E) { + tn(t, l, E); + } finally { + q.T = n; + } + } else { + try { + n = a(u, e); + Tf(t, l, n); + } catch (E) { + tn(t, l, E); + } + } + } + function Tf(t, l, a) { + if (a !== null && typeof a == "object" && typeof a.then == "function") { + a.then(function (e) { + Mf(t, l, e); + }, function (e) { + return tn(t, l, e); + }); + } else { + Mf(t, l, a); + } + } + function Mf(t, l, a) { + l.status = "fulfilled"; + l.value = a; + Of(l); + t.state = a; + l = t.pending; + if (l !== null) { + a = l.next; + if (a === l) { + t.pending = null; + } else { + a = a.next; + l.next = a; + Nf(t, a); + } + } + } + function tn(t, l, a) { + var e = t.pending; + t.pending = null; + if (e !== null) { + e = e.next; + do { + l.status = "rejected"; + l.reason = a; + Of(l); + l = l.next; + } while (l !== e); + } + t.action = null; + } + function Of(t) { + t = t.listeners; + for (var l = 0; l < t.length; l++) { + (0, t[l])(); + } + } + function Hf(t, l) { + return l; + } + function Uf(t, l) { + if (P) { + var a = ut.formState; + if (a !== null) { + t: { + var e = G; + if (P) { + if (bt) { + var u = xv(bt, pl); + if (u) { + bt = hs(u); + e = Jv(u); + break t; + } + } + la(e); + } + e = false; + } + if (e) { + l = a[0]; + } + } + } + a = Qt(); + a.memoizedState = a.baseState = l; + e = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: Hf, + lastRenderedState: l + }; + a.queue = e; + a = Zf.bind(null, G, e); + e.dispatch = a; + e = ku(false); + var n = nn.bind(null, G, false, e.queue); + e = Qt(); + u = { + state: l, + dispatch: null, + action: t, + pending: null + }; + e.queue = u; + a = jm.bind(null, G, u, n, a); + u.dispatch = a; + e.memoizedState = t; + return [l, a, false]; + } + function _f(t) { + var l = zt(); + return rf(l, k, t); + } + function rf(t, l, a) { + l = $u(t, l, Hf)[0]; + t = Je(hl)[0]; + l = typeof l == "object" && l !== null && typeof l.then == "function" ? ie(l) : l; + var e = zt(); + var u = e.queue; + var n = u.dispatch; + if (a !== e.memoizedState) { + G.flags |= 2048; + Ua(9, gm.bind(null, u, a), { + destroy: undefined + }, null); + } + return [l, n, t]; + } + function gm(t, l) { + t.action = l; + } + function Af(t) { + var l = zt(); + var a = k; + if (a !== null) { + return rf(l, a, t); + } + zt(); + l = l.memoizedState; + a = zt(); + var e = a.queue.dispatch; + a.memoizedState = t; + return [l, e, false]; + } + function Ua(t, l, a, e) { + t = { + tag: t, + create: l, + inst: a, + deps: e, + next: null + }; + l = G.updateQueue; + if (l === null) { + l = pc(); + G.updateQueue = l; + } + a = l.lastEffect; + if (a === null) { + l.lastEffect = t.next = t; + } else { + e = a.next; + a.next = t; + t.next = e; + l.lastEffect = t; + } + return t; + } + function jf() { + return zt().memoizedState; + } + function Le(t, l, a, e) { + var u = Qt(); + G.flags |= t; + u.memoizedState = Ua(l | 1, a, { + destroy: undefined + }, e === undefined ? null : e); + } + function We(t, l, a, e) { + var u = zt(); + e = e === undefined ? null : e; + var n = u.memoizedState.inst; + if (k !== null && e !== null && Ju(e, k.memoizedState.deps)) { + u.memoizedState = Ua(l, a, n, e); + } else { + G.flags |= t; + u.memoizedState = Ua(l | 1, a, n, e); + } + } + function gf(t, l) { + Le(8390656, 8, t, l); + } + function ln(t, l) { + We(2048, 8, t, l); + } + function Df(t, l) { + return We(4, 2, t, l); + } + function bf(t, l) { + return We(4, 4, t, l); + } + function Rf(t, l) { + if (typeof l == "function") { + t = t(); + var a = l(t); + return function () { + if (typeof a == "function") { + a(); + } else { + l(null); + } + }; + } + if (l != null) { + t = t(); + l.current = t; + return function () { + l.current = null; + }; + } + } + function Cf(t, l, a) { + a = a != null ? a.concat([t]) : null; + We(4, 4, Rf.bind(null, l, t), a); + } + function an() {} + function qf(t, l) { + var a = zt(); + l = l === undefined ? null : l; + var e = a.memoizedState; + if (l !== null && Ju(l, e[1])) { + return e[0]; + } else { + a.memoizedState = [t, l]; + return t; + } + } + function Bf(t, l) { + var a = zt(); + l = l === undefined ? null : l; + var e = a.memoizedState; + if (l !== null && Ju(l, e[1])) { + return e[0]; + } + e = t(); + if (pa) { + nl(true); + try { + t(); + } finally { + nl(false); + } + } + a.memoizedState = [e, l]; + return e; + } + function en(t, l, a) { + if (a === undefined || (Fl & 1073741824) !== 0) { + return t.memoizedState = l; + } else { + t.memoizedState = a; + t = bi(); + G.lanes |= t; + Il |= t; + return a; + } + } + function Qf(t, l, a, e) { + if (Wt(a, l)) { + return a; + } else if (xa.current !== null) { + t = en(t, a, e); + if (!Wt(t, l)) { + Ht = true; + } + return t; + } else if ((Fl & 42) === 0) { + Ht = true; + return t.memoizedState = a; + } else { + t = bi(); + G.lanes |= t; + Il |= t; + return l; + } + } + function Yf(t, l, a, e, u) { + var n = ia(); + Gt(n !== 0 && n < 8 ? n : 8); + var i = q.T; + var v = {}; + q.T = v; + nn(t, false, l, a); + try { + var d = u(); + var E = q.S; + if (E !== null) { + E(v, d); + } + if (d !== null && typeof d == "object" && typeof d.then == "function") { + var H = rm(d, e); + se(t, l, H, Kt(t)); + } else { + se(t, l, e, Kt(t)); + } + } catch (r) { + se(t, l, { + then: function () {}, + status: "rejected", + reason: r + }, Kt()); + } finally { + Gt(n); + q.T = i; + } + } + function Gf(t) { + var l = t.memoizedState; + if (l !== null) { + return l; + } + l = { + memoizedState: ba, + baseState: ba, + baseQueue: null, + queue: { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: hl, + lastRenderedState: ba + }, + next: null + }; + var a = {}; + l.next = { + memoizedState: a, + baseState: a, + baseQueue: null, + queue: { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: hl, + lastRenderedState: a + }, + next: null + }; + t.memoizedState = l; + t = t.alternate; + if (t !== null) { + t.memoizedState = l; + } + return l; + } + function un() { + return jt(sa); + } + function Vf() { + return zt().memoizedState; + } + function Xf() { + return zt().memoizedState; + } + function Dm(t) { + for (var l = t.return; l !== null;) { + switch (l.tag) { + case 24: + case 3: + var a = Kt(); + t = Cl(a); + var e = ql(l, t, a); + if (e !== null) { + Ct(e, l, a); + ue(e, l, a); + } + l = { + cache: zn() + }; + t.payload = l; + return; + } + l = l.return; + } + } + function bm(t, l, a) { + var e = Kt(); + a = { + lane: e, + revertLane: 0, + action: a, + hasEagerState: false, + eagerState: null, + next: null + }; + if (Fe(t)) { + Kf(l, a); + } else { + a = Yu(t, l, a, e); + if (a !== null) { + Ct(a, t, e); + xf(a, l, e); + } + } + } + function Zf(t, l, a) { + var e = Kt(); + se(t, l, a, e); + } + function se(t, l, a, e) { + var u = { + lane: e, + revertLane: 0, + action: a, + hasEagerState: false, + eagerState: null, + next: null + }; + if (Fe(t)) { + Kf(l, u); + } else { + var n = t.alternate; + if (t.lanes === 0 && (n === null || n.lanes === 0) && (n = l.lastRenderedReducer, n !== null)) { + try { + var i = l.lastRenderedState; + var v = n(i, a); + u.hasEagerState = true; + u.eagerState = v; + if (Wt(v, i)) { + Qe(t, l, u, 0); + if (ut === null) { + Be(); + } + return false; + } + } catch {} finally {} + } + a = Yu(t, l, u, e); + if (a !== null) { + Ct(a, t, e); + xf(a, l, e); + return true; + } + } + return false; + } + function nn(t, l, a, e) { + e = { + lane: 2, + revertLane: Gu(), + action: e, + hasEagerState: false, + eagerState: null, + next: null + }; + if (Fe(t)) { + if (l) { + throw Error(m(479)); + } + } else { + l = Yu(t, a, e, 2); + if (l !== null) { + Ct(l, t, 2); + } + } + } + function Fe(t) { + var l = t.alternate; + return t === G || l !== null && l === G; + } + function Kf(t, l) { + Ja = hu = true; + var a = t.pending; + if (a === null) { + l.next = l; + } else { + l.next = a.next; + a.next = l; + } + t.pending = l; + } + function xf(t, l, a) { + if ((a & 4194176) !== 0) { + var e = l.lanes; + e &= t.pendingLanes; + a |= e; + l.lanes = a; + ht(t, a); + } + } + function cn(t, l, a, e) { + l = t.memoizedState; + a = a(e, l); + a = a == null ? l : Kn({}, l, a); + t.memoizedState = a; + if (t.lanes === 0) { + t.updateQueue.baseState = a; + } + } + function Jf(t, l, a, e, u, n, i) { + t = t.stateNode; + if (typeof t.shouldComponentUpdate == "function") { + return t.shouldComponentUpdate(e, n, i); + } else if (l.prototype && l.prototype.isPureReactComponent) { + return !Ge(a, e) || !Ge(u, n); + } else { + return true; + } + } + function Lf(t, l, a, e) { + t = l.state; + if (typeof l.componentWillReceiveProps == "function") { + l.componentWillReceiveProps(a, e); + } + if (typeof l.UNSAFE_componentWillReceiveProps == "function") { + l.UNSAFE_componentWillReceiveProps(a, e); + } + if (l.state !== t) { + oc.enqueueReplaceState(l, l.state, null); + } + } + function aa(t, l) { + var a = l; + if ("ref" in l) { + a = {}; + for (var e in l) { + if (e !== "ref") { + a[e] = l[e]; + } + } + } + if (t = t.defaultProps) { + if (a === l) { + a = Kn({}, a); + } + for (var u in t) { + if (a[u] === undefined) { + a[u] = t[u]; + } + } + } + return a; + } + function Pe(t, l) { + try { + var a = t.onUncaughtError; + a(l.value, { + componentStack: l.stack + }); + } catch (e) { + setTimeout(function () { + throw e; + }); + } + } + function Wf(t, l, a) { + try { + var e = t.onCaughtError; + e(a.value, { + componentStack: a.stack, + errorBoundary: l.tag === 1 ? l.stateNode : null + }); + } catch (u) { + setTimeout(function () { + throw u; + }); + } + } + function fn(t, l, a) { + a = Cl(a); + a.tag = 3; + a.payload = { + element: null + }; + a.callback = function () { + Pe(t, l); + }; + return a; + } + function Ff(t) { + t = Cl(t); + t.tag = 3; + return t; + } + function Pf(t, l, a, e) { + var u = a.type.getDerivedStateFromError; + if (typeof u == "function") { + var n = e.value; + t.payload = function () { + return u(n); + }; + t.callback = function () { + Wf(l, a, e); + }; + } + var i = a.stateNode; + if (i !== null && typeof i.componentDidCatch == "function") { + t.callback = function () { + Wf(l, a, e); + if (typeof u != "function") { + if ($l === null) { + $l = new Set([this]); + } else { + $l.add(this); + } + } + var v = e.stack; + this.componentDidCatch(e.value, { + componentStack: v !== null ? v : "" + }); + }; + } + } + function Rm(t, l, a, e, u) { + a.flags |= 32768; + if (e !== null && typeof e == "object" && typeof e.then == "function") { + l = a.alternate; + if (l !== null) { + ve(l, a, u, true); + } + a = ll.current; + if (a !== null) { + switch (a.tag) { + case 13: + if (ol === null) { + Bn(); + } else if (a.alternate === null && St === 0) { + St = 3; + } + a.flags &= -257; + a.flags |= 65536; + a.lanes = u; + if (e === yu) { + a.flags |= 16384; + } else { + l = a.updateQueue; + if (l === null) { + a.updateQueue = new Set([e]); + } else { + l.add(e); + } + Yn(t, e, u); + } + return false; + case 22: + a.flags |= 65536; + if (e === yu) { + a.flags |= 16384; + } else { + l = a.updateQueue; + if (l === null) { + l = { + transitions: null, + markerInstances: null, + retryQueue: new Set([e]) + }; + a.updateQueue = l; + } else { + a = l.retryQueue; + if (a === null) { + l.retryQueue = new Set([e]); + } else { + a.add(e); + } + } + Yn(t, e, u); + } + return false; + } + throw Error(m(435, a.tag)); + } + Yn(t, e, u); + Bn(); + return false; + } + if (P) { + l = ll.current; + if (l !== null) { + if ((l.flags & 65536) === 0) { + l.flags |= 256; + } + l.flags |= 65536; + l.lanes = u; + if (e !== nc) { + t = Error(m(422), { + cause: e + }); + ee(Rt(t, a)); + } + } else { + if (e !== nc) { + l = Error(m(423), { + cause: e + }); + ee(Rt(l, a)); + } + t = t.current.alternate; + t.flags |= 65536; + u &= -u; + t.lanes |= u; + e = Rt(e, a); + u = fn(t.stateNode, e, u); + Zu(t, u); + if (St !== 4) { + St = 2; + } + } + return false; + } + var n = Error(m(520), { + cause: e + }); + n = Rt(n, a); + if (re === null) { + re = [n]; + } else { + re.push(n); + } + if (St !== 4) { + St = 2; + } + if (l === null) { + return true; + } + e = Rt(e, a); + a = l; + do { + switch (a.tag) { + case 3: + a.flags |= 65536; + t = u & -u; + a.lanes |= t; + t = fn(a.stateNode, e, t); + Zu(a, t); + return false; + case 1: + l = a.type; + n = a.stateNode; + if ((a.flags & 128) === 0 && (typeof l.getDerivedStateFromError == "function" || n !== null && typeof n.componentDidCatch == "function" && ($l === null || !$l.has(n)))) { + a.flags |= 65536; + u &= -u; + a.lanes |= u; + u = Ff(u); + Pf(u, t, a, e); + Zu(a, u); + return false; + } + } + a = a.return; + } while (a !== null); + return false; + } + function rt(t, l, a, e) { + l.child = t === null ? Ds(l, null, a, e) : va(l, t.child, a, e); + } + function If(t, l, a, e, u) { + a = a.render; + var n = l.ref; + if ("ref" in e) { + var i = {}; + for (var v in e) { + if (v !== "ref") { + i[v] = e[v]; + } + } + } else { + i = e; + } + ea(l); + e = Lu(t, l, a, i, n, u); + v = Wu(); + if (t !== null && !Ht) { + Fu(t, l, u); + return El(t, l, u); + } else { + if (P && v) { + ot(l); + } + l.flags |= 1; + rt(t, l, e, u); + return l.child; + } + } + function $f(t, l, a, e, u) { + if (t === null) { + var n = a.type; + if (typeof n == "function" && !Gn(n) && n.defaultProps === undefined && a.compare === null) { + l.tag = 15; + l.type = n; + return wf(t, l, n, e, u); + } else { + t = eu(a.type, null, e, l, l.mode, u); + t.ref = l.ref; + t.return = l; + return l.child = t; + } + } + n = t.child; + if (!Sn(t, u)) { + var i = n.memoizedProps; + a = a.compare; + a = a !== null ? a : Ge; + if (a(i, e) && t.ref === l.ref) { + return El(t, l, u); + } + } + l.flags |= 1; + t = Zl(n, e); + t.ref = l.ref; + t.return = l; + return l.child = t; + } + function wf(t, l, a, e, u) { + if (t !== null) { + var n = t.memoizedProps; + if (Ge(n, e) && t.ref === l.ref) { + Ht = false; + l.pendingProps = e = n; + if (Sn(t, u)) { + if ((t.flags & 131072) !== 0) { + Ht = true; + } + } else { + l.lanes = t.lanes; + return El(t, l, u); + } + } + } + return sn(t, l, a, e, u); + } + function kf(t, l, a) { + var e = l.pendingProps; + var u = e.children; + var n = (l.stateNode._pendingVisibility & 2) !== 0; + var i = t !== null ? t.memoizedState : null; + me(t, l); + if (e.mode === "hidden" || n) { + if ((l.flags & 128) !== 0) { + e = i !== null ? i.baseLanes | a : a; + if (t !== null) { + u = l.child = t.child; + n = 0; + while (u !== null) { + n = n | u.lanes | u.childLanes; + u = u.sibling; + } + l.childLanes = n & ~e; + } else { + l.childLanes = 0; + l.child = null; + } + return ti(t, l, e, a); + } + if ((a & 536870912) !== 0) { + l.memoizedState = { + baseLanes: 0, + cachePool: null + }; + if (t !== null) { + we(l, i !== null ? i.cachePool : null); + } + if (i !== null) { + sf(l, i); + } else { + Ku(); + } + mf(l); + } else { + l.lanes = l.childLanes = 536870912; + return ti(t, l, i !== null ? i.baseLanes | a : a, a); + } + } else if (i !== null) { + we(l, i.cachePool); + sf(l, i); + Ql(); + l.memoizedState = null; + } else { + if (t !== null) { + we(l, null); + } + Ku(); + Ql(); + } + rt(t, l, u, a); + return l.child; + } + function ti(t, l, a, e) { + var u = Nn(); + u = u === null ? null : { + parent: Ml ? dt._currentValue : dt._currentValue2, + pool: u + }; + l.memoizedState = { + baseLanes: a, + cachePool: u + }; + if (t !== null) { + we(l, null); + } + Ku(); + mf(l); + if (t !== null) { + ve(t, l, e, true); + } + return null; + } + function me(t, l) { + var a = l.ref; + if (a === null) { + if (t !== null && t.ref !== null) { + l.flags |= 2097664; + } + } else { + if (typeof a != "function" && typeof a != "object") { + throw Error(m(284)); + } + if (t === null || t.ref !== a) { + l.flags |= 2097664; + } + } + } + function sn(t, l, a, e, u) { + ea(l); + a = Lu(t, l, a, e, undefined, u); + e = Wu(); + if (t !== null && !Ht) { + Fu(t, l, u); + return El(t, l, u); + } else { + if (P && e) { + ot(l); + } + l.flags |= 1; + rt(t, l, a, u); + return l.child; + } + } + function li(t, l, a, e, u, n) { + ea(l); + l.updateQueue = null; + a = pf(l, e, a, u); + vf(t); + e = Wu(); + if (t !== null && !Ht) { + Fu(t, l, n); + return El(t, l, n); + } else { + if (P && e) { + ot(l); + } + l.flags |= 1; + rt(t, l, a, n); + return l.child; + } + } + function ai(t, l, a, e, u) { + ea(l); + if (l.stateNode === null) { + var n = Ca; + var i = a.contextType; + if (typeof i == "object" && i !== null) { + n = jt(i); + } + n = new a(e, n); + l.memoizedState = n.state ?? null; + n.updater = oc; + l.stateNode = n; + n._reactInternals = l; + n = l.stateNode; + n.props = e; + n.state = l.memoizedState; + n.refs = {}; + Vu(l); + i = a.contextType; + n.context = typeof i == "object" && i !== null ? jt(i) : Ca; + n.state = l.memoizedState; + i = a.getDerivedStateFromProps; + if (typeof i == "function") { + cn(l, a, i, e); + n.state = l.memoizedState; + } + if (typeof a.getDerivedStateFromProps != "function" && typeof n.getSnapshotBeforeUpdate != "function" && (typeof n.UNSAFE_componentWillMount == "function" || typeof n.componentWillMount == "function")) { + i = n.state; + if (typeof n.componentWillMount == "function") { + n.componentWillMount(); + } + if (typeof n.UNSAFE_componentWillMount == "function") { + n.UNSAFE_componentWillMount(); + } + if (i !== n.state) { + oc.enqueueReplaceState(n, n.state, null); + } + ce(l, e, n, u); + ne(); + n.state = l.memoizedState; + } + if (typeof n.componentDidMount == "function") { + l.flags |= 4194308; + } + e = true; + } else if (t === null) { + n = l.stateNode; + var v = l.memoizedProps; + var d = aa(a, v); + n.props = d; + var E = n.context; + var H = a.contextType; + i = Ca; + if (typeof H == "object" && H !== null) { + i = jt(H); + } + var r = a.getDerivedStateFromProps; + H = typeof r == "function" || typeof n.getSnapshotBeforeUpdate == "function"; + v = l.pendingProps !== v; + if (!H && (typeof n.UNSAFE_componentWillReceiveProps == "function" || typeof n.componentWillReceiveProps == "function")) { + if (v || E !== i) { + Lf(l, n, e, i); + } + } + Wl = false; + var j = l.memoizedState; + n.state = j; + ce(l, e, n, u); + ne(); + E = l.memoizedState; + if (v || j !== E || Wl) { + if (typeof r == "function") { + cn(l, a, r, e); + E = l.memoizedState; + } + if (d = Wl || Jf(l, a, d, e, j, E, i)) { + if (!H && (typeof n.UNSAFE_componentWillMount == "function" || typeof n.componentWillMount == "function")) { + if (typeof n.componentWillMount == "function") { + n.componentWillMount(); + } + if (typeof n.UNSAFE_componentWillMount == "function") { + n.UNSAFE_componentWillMount(); + } + } + if (typeof n.componentDidMount == "function") { + l.flags |= 4194308; + } + } else { + if (typeof n.componentDidMount == "function") { + l.flags |= 4194308; + } + l.memoizedProps = e; + l.memoizedState = E; + } + n.props = e; + n.state = E; + n.context = i; + e = d; + } else { + if (typeof n.componentDidMount == "function") { + l.flags |= 4194308; + } + e = false; + } + } else { + n = l.stateNode; + Xu(t, l); + i = l.memoizedProps; + H = aa(a, i); + n.props = H; + r = l.pendingProps; + j = n.context; + E = a.contextType; + d = Ca; + if (typeof E == "object" && E !== null) { + d = jt(E); + } + v = a.getDerivedStateFromProps; + if (!(E = typeof v == "function" || typeof n.getSnapshotBeforeUpdate == "function") && (typeof n.UNSAFE_componentWillReceiveProps == "function" || typeof n.componentWillReceiveProps == "function")) { + if (i !== r || j !== d) { + Lf(l, n, e, d); + } + } + Wl = false; + j = l.memoizedState; + n.state = j; + ce(l, e, n, u); + ne(); + var Q = l.memoizedState; + if (i !== r || j !== Q || Wl || t !== null && t.dependencies !== null && Ie(t.dependencies)) { + if (typeof v == "function") { + cn(l, a, v, e); + Q = l.memoizedState; + } + if (H = Wl || Jf(l, a, H, e, j, Q, d) || t !== null && t.dependencies !== null && Ie(t.dependencies)) { + if (!E && (typeof n.UNSAFE_componentWillUpdate == "function" || typeof n.componentWillUpdate == "function")) { + if (typeof n.componentWillUpdate == "function") { + n.componentWillUpdate(e, Q, d); + } + if (typeof n.UNSAFE_componentWillUpdate == "function") { + n.UNSAFE_componentWillUpdate(e, Q, d); + } + } + if (typeof n.componentDidUpdate == "function") { + l.flags |= 4; + } + if (typeof n.getSnapshotBeforeUpdate == "function") { + l.flags |= 1024; + } + } else { + if (typeof n.componentDidUpdate == "function" && (i !== t.memoizedProps || j !== t.memoizedState)) { + l.flags |= 4; + } + if (typeof n.getSnapshotBeforeUpdate == "function" && (i !== t.memoizedProps || j !== t.memoizedState)) { + l.flags |= 1024; + } + l.memoizedProps = e; + l.memoizedState = Q; + } + n.props = e; + n.state = Q; + n.context = d; + e = H; + } else { + if (typeof n.componentDidUpdate == "function" && (i !== t.memoizedProps || j !== t.memoizedState)) { + l.flags |= 4; + } + if (typeof n.getSnapshotBeforeUpdate == "function" && (i !== t.memoizedProps || j !== t.memoizedState)) { + l.flags |= 1024; + } + e = false; + } + } + n = e; + me(t, l); + e = (l.flags & 128) !== 0; + if (n || e) { + n = l.stateNode; + a = e && typeof a.getDerivedStateFromError != "function" ? null : n.render(); + l.flags |= 1; + if (t !== null && e) { + l.child = va(l, t.child, null, u); + l.child = va(l, null, a, u); + } else { + rt(t, l, a, u); + } + l.memoizedState = n.state; + t = l.child; + } else { + t = El(t, l, u); + } + return t; + } + function ei(t, l, a, e) { + ae(); + l.flags |= 256; + rt(t, l, a, e); + return l.child; + } + function mn(t) { + return { + baseLanes: t, + cachePool: si() + }; + } + function vn(t, l, a) { + t = t !== null ? t.childLanes & ~a : 0; + if (l) { + t |= al; + } + return t; + } + function ui(t, l, a) { + var e = l.pendingProps; + var u = false; + var n = (l.flags & 128) !== 0; + var i; + if (!(i = n)) { + i = t !== null && t.memoizedState === null ? false : (Ot.current & 2) !== 0; + } + if (i) { + u = true; + l.flags &= -129; + } + i = (l.flags & 32) !== 0; + l.flags &= -33; + if (t === null) { + if (P) { + if (u) { + Bl(l); + } else { + Ql(); + } + if (P) { + var v = bt; + var d; + if (d = v) { + v = Iv(v, pl); + if (v !== null) { + l.memoizedState = { + dehydrated: v, + treeContext: ma !== null ? { + id: Ol, + overflow: Hl + } : null, + retryLane: 536870912 + }; + d = s(18, null, null, 0); + d.stateNode = v; + d.return = l; + l.child = d; + qt = l; + bt = null; + d = true; + } else { + d = false; + } + } + if (!d) { + la(l); + } + } + v = l.memoizedState; + if (v !== null && (v = v.dehydrated, v !== null)) { + if (tc(v)) { + l.lanes = 16; + } else { + l.lanes = 536870912; + } + return null; + } + Sl(l); + } + v = e.children; + e = e.fallback; + if (u) { + Ql(); + u = l.mode; + v = on({ + mode: "hidden", + children: v + }, u); + e = fa(e, u, a, null); + v.return = l; + e.return = l; + v.sibling = e; + l.child = v; + u = l.child; + u.memoizedState = mn(a); + u.childLanes = vn(t, i, a); + l.memoizedState = dc; + return e; + } else { + Bl(l); + return pn(l, v); + } + } + d = t.memoizedState; + if (d !== null && (v = d.dehydrated, v !== null)) { + if (n) { + if (l.flags & 256) { + Bl(l); + l.flags &= -257; + l = dn(t, l, a); + } else if (l.memoizedState !== null) { + Ql(); + l.child = t.child; + l.flags |= 128; + l = null; + } else { + Ql(); + u = e.fallback; + v = l.mode; + e = on({ + mode: "visible", + children: e.children + }, v); + u = fa(u, v, a, null); + u.flags |= 2; + e.return = l; + u.return = l; + e.sibling = u; + l.child = e; + va(l, t.child, null, a); + e = l.child; + e.memoizedState = mn(a); + e.childLanes = vn(t, i, a); + l.memoizedState = dc; + l = u; + } + } else { + Bl(l); + if (tc(v)) { + i = Zv(v).digest; + e = Error(m(419)); + e.stack = ""; + e.digest = i; + ee({ + value: e, + source: null, + stack: null + }); + l = dn(t, l, a); + } else { + if (!Ht) { + ve(t, l, a, false); + } + i = (a & t.childLanes) !== 0; + if (Ht || i) { + i = ut; + if (i !== null) { + e = a & -a; + if ((e & 42) !== 0) { + e = 1; + } else { + switch (e) { + case 2: + e = 1; + break; + case 8: + e = 4; + break; + case 32: + e = 16; + break; + 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: + e = 64; + break; + case 268435456: + e = 134217728; + break; + default: + e = 0; + } + } + e = (e & (i.suspendedLanes | a)) !== 0 ? 0 : e; + if (e !== 0 && e !== d.retryLane) { + d.retryLane = e; + Rl(t, e); + Ct(i, t, e); + throw Rs; + } + } + if (!kn(v)) { + Bn(); + } + l = dn(t, l, a); + } else if (kn(v)) { + l.flags |= 128; + l.child = t.child; + l = Jm.bind(null, t); + Kv(v, l); + l = null; + } else { + t = d.treeContext; + if (It) { + bt = Wv(v); + qt = l; + P = true; + il = null; + pl = false; + if (t !== null) { + wt[kt++] = Ol; + wt[kt++] = Hl; + wt[kt++] = ma; + Ol = t.id; + Hl = t.overflow; + ma = l; + } + } + l = pn(l, e.children); + l.flags |= 4096; + } + } + } + return l; + } + if (u) { + Ql(); + u = e.fallback; + v = l.mode; + d = t.child; + n = d.sibling; + e = Zl(d, { + mode: "hidden", + children: e.children + }); + e.subtreeFlags = d.subtreeFlags & 31457280; + if (n !== null) { + u = Zl(n, u); + } else { + u = fa(u, v, a, null); + u.flags |= 2; + } + u.return = l; + e.return = l; + e.sibling = u; + l.child = e; + e = u; + u = l.child; + v = t.child.memoizedState; + if (v === null) { + v = mn(a); + } else { + d = v.cachePool; + if (d !== null) { + n = Ml ? dt._currentValue : dt._currentValue2; + d = d.parent !== n ? { + parent: n, + pool: n + } : d; + } else { + d = si(); + } + v = { + baseLanes: v.baseLanes | a, + cachePool: d + }; + } + u.memoizedState = v; + u.childLanes = vn(t, i, a); + l.memoizedState = dc; + return e; + } else { + Bl(l); + a = t.child; + t = a.sibling; + a = Zl(a, { + mode: "visible", + children: e.children + }); + a.return = l; + a.sibling = null; + if (t !== null) { + i = l.deletions; + if (i === null) { + l.deletions = [t]; + l.flags |= 16; + } else { + i.push(t); + } + } + l.child = a; + l.memoizedState = null; + return a; + } + } + function pn(t, l) { + l = on({ + mode: "visible", + children: l + }, t.mode); + l.return = t; + return t.child = l; + } + function on(t, l) { + return Fi(t, l, 0, null); + } + function dn(t, l, a) { + va(l, t.child, null, a); + t = pn(l, l.pendingProps.children); + t.flags |= 2; + l.memoizedState = null; + return t; + } + function ni(t, l, a) { + t.lanes |= l; + var e = t.alternate; + if (e !== null) { + e.lanes |= l; + } + hn(t.return, l, a); + } + function yn(t, l, a, e, u) { + var n = t.memoizedState; + if (n === null) { + t.memoizedState = { + isBackwards: l, + rendering: null, + renderingStartTime: 0, + last: e, + tail: a, + tailMode: u + }; + } else { + n.isBackwards = l; + n.rendering = null; + n.renderingStartTime = 0; + n.last = e; + n.tail = a; + n.tailMode = u; + } + } + function ci(t, l, a) { + var e = l.pendingProps; + var u = e.revealOrder; + var n = e.tail; + rt(t, l, e.children, a); + e = Ot.current; + if ((e & 2) !== 0) { + e = e & 1 | 2; + l.flags |= 128; + } else { + if (t !== null && (t.flags & 128) !== 0) { + t: for (t = l.child; t !== null;) { + if (t.tag === 13) { + if (t.memoizedState !== null) { + ni(t, a, l); + } + } else if (t.tag === 19) { + ni(t, a, l); + } else if (t.child !== null) { + t.child.return = t; + t = t.child; + continue; + } + if (t === l) { + break t; + } + while (t.sibling === null) { + if (t.return === null || t.return === l) { + break t; + } + t = t.return; + } + t.sibling.return = t.return; + t = t.sibling; + } + } + e &= 1; + } + N(Ot, e); + switch (u) { + case "forwards": + a = l.child; + u = null; + while (a !== null) { + t = a.alternate; + if (t !== null && Ke(t) === null) { + u = a; + } + a = a.sibling; + } + a = u; + if (a === null) { + u = l.child; + l.child = null; + } else { + u = a.sibling; + a.sibling = null; + } + yn(l, false, u, a, n); + break; + case "backwards": + a = null; + u = l.child; + l.child = null; + while (u !== null) { + t = u.alternate; + if (t !== null && Ke(t) === null) { + l.child = u; + break; + } + t = u.sibling; + u.sibling = a; + a = u; + u = t; + } + yn(l, true, a, null, n); + break; + case "together": + yn(l, false, null, null, undefined); + break; + default: + l.memoizedState = null; + } + return l.child; + } + function El(t, l, a) { + if (t !== null) { + l.dependencies = t.dependencies; + } + Il |= l.lanes; + if ((a & l.childLanes) === 0) { + if (t !== null) { + ve(t, l, a, false); + if ((a & l.childLanes) === 0) { + return null; + } + } else { + return null; + } + } + if (t !== null && l.child !== t.child) { + throw Error(m(153)); + } + if (l.child !== null) { + t = l.child; + a = Zl(t, t.pendingProps); + l.child = a; + a.return = l; + while (t.sibling !== null) { + t = t.sibling; + a = a.sibling = Zl(t, t.pendingProps); + a.return = l; + } + a.sibling = null; + } + return l.child; + } + function Sn(t, l) { + if ((t.lanes & l) !== 0) { + return true; + } else { + t = t.dependencies; + return t !== null && !!Ie(t); + } + } + function Cm(t, l, a) { + switch (l.tag) { + case 3: + Mt(l, l.stateNode.containerInfo); + Yl(l, dt, t.memoizedState.cache); + ae(); + break; + case 27: + case 5: + Oa(l); + break; + case 4: + Mt(l, l.stateNode.containerInfo); + break; + case 10: + Yl(l, l.type, l.memoizedProps.value); + break; + case 13: + var e = l.memoizedState; + if (e !== null) { + if (e.dehydrated !== null) { + Bl(l); + l.flags |= 128; + return null; + } else if ((a & l.child.childLanes) !== 0) { + return ui(t, l, a); + } else { + Bl(l); + t = El(t, l, a); + if (t !== null) { + return t.sibling; + } else { + return null; + } + } + } + Bl(l); + break; + case 19: + var u = (t.flags & 128) !== 0; + e = (a & l.childLanes) !== 0; + if (!e) { + ve(t, l, a, false); + e = (a & l.childLanes) !== 0; + } + if (u) { + if (e) { + return ci(t, l, a); + } + l.flags |= 128; + } + u = l.memoizedState; + if (u !== null) { + u.rendering = null; + u.tail = null; + u.lastEffect = null; + } + N(Ot, Ot.current); + if (e) { + break; + } + return null; + case 22: + case 23: + l.lanes = 0; + return kf(t, l, a); + case 24: + Yl(l, dt, t.memoizedState.cache); + } + return El(t, l, a); + } + function fi(t, l, a) { + if (t !== null) { + if (t.memoizedProps !== l.pendingProps) { + Ht = true; + } else { + if (!Sn(t, a) && (l.flags & 128) === 0) { + Ht = false; + return Cm(t, l, a); + } + Ht = (t.flags & 131072) !== 0; + } + } else { + Ht = false; + if (P && (l.flags & 1048576) !== 0) { + mt(l, vu, l.index); + } + } + l.lanes = 0; + switch (l.tag) { + case 16: + t: { + t = l.pendingProps; + var e = l.elementType; + var u = e._init; + e = u(e._payload); + l.type = e; + if (typeof e == "function") { + if (Gn(e)) { + t = aa(e, t); + l.tag = 1; + l = ai(null, l, e, t, a); + } else { + l.tag = 0; + l = sn(null, l, e, t, a); + } + } else { + if (e != null) { + u = e.$$typeof; + if (u === Jn) { + l.tag = 11; + l = If(null, l, e, t, a); + break t; + } else if (u === Fn) { + l.tag = 14; + l = $f(null, l, e, t, a); + break t; + } + } + l = T(e) || e; + throw Error(m(306, l, "")); + } + } + return l; + case 0: + return sn(t, l, l.type, l.pendingProps, a); + case 1: + e = l.type; + u = aa(e, l.pendingProps); + return ai(t, l, e, u, a); + case 3: + t: { + Mt(l, l.stateNode.containerInfo); + if (t === null) { + throw Error(m(387)); + } + var n = l.pendingProps; + u = l.memoizedState; + e = u.element; + Xu(t, l); + ce(l, n, null, a); + var i = l.memoizedState; + n = i.cache; + Yl(l, dt, n); + if (n !== u.cache) { + En(l, [dt], a, true); + } + ne(); + n = i.element; + if (It && u.isDehydrated) { + u = { + element: n, + isDehydrated: false, + cache: i.cache + }; + l.updateQueue.baseState = u; + l.memoizedState = u; + if (l.flags & 256) { + l = ei(t, l, n, a); + break t; + } else if (n !== e) { + e = Rt(Error(m(424)), l); + ee(e); + l = ei(t, l, n, a); + break t; + } else { + if (It) { + bt = Lv(l.stateNode.containerInfo); + qt = l; + P = true; + il = null; + pl = true; + } + a = Ds(l, null, n, a); + l.child = a; + while (a) { + a.flags = a.flags & -3 | 4096; + a = a.sibling; + } + } + } else { + ae(); + if (n === e) { + l = El(t, l, a); + break t; + } + rt(t, l, n, a); + } + l = l.child; + } + return l; + case 26: + if ($t) { + me(t, l); + if (t === null) { + if (a = Ts(l.type, null, l.pendingProps, null)) { + l.memoizedState = a; + } else if (!P) { + l.stateNode = ip(l.type, l.pendingProps, Ll.current, l); + } + } else { + l.memoizedState = Ts(l.type, t.memoizedProps, l.pendingProps, t.memoizedState); + } + return null; + } + case 27: + if (Dt) { + Oa(l); + if (t === null && Dt && P) { + e = l.stateNode = rs(l.type, l.pendingProps, Ll.current, At.current, false); + qt = l; + pl = true; + bt = Es(e); + } + e = l.pendingProps.children; + if (t !== null || P) { + rt(t, l, e, a); + } else { + l.child = va(l, null, e, a); + } + me(t, l); + return l.child; + } + case 5: + if (t === null && P) { + np(l.type, l.pendingProps, At.current); + if (u = e = bt) { + e = Fv(e, l.type, l.pendingProps, pl); + if (e !== null) { + l.stateNode = e; + qt = l; + bt = Es(e); + pl = false; + u = true; + } else { + u = false; + } + } + if (!u) { + la(l); + } + } + Oa(l); + u = l.type; + n = l.pendingProps; + i = t !== null ? t.memoizedProps : null; + e = n.children; + if (cu(u, n)) { + e = null; + } else if (i !== null && cu(u, i)) { + l.flags |= 32; + } + if (l.memoizedState !== null) { + u = Lu(t, l, Am, null, null, a); + if (Ml) { + sa._currentValue = u; + } else { + sa._currentValue2 = u; + } + } + me(t, l); + rt(t, l, e, a); + return l.child; + case 6: + if (t === null && P) { + cp(l.pendingProps, At.current); + if (t = a = bt) { + a = Pv(a, l.pendingProps, pl); + if (a !== null) { + l.stateNode = a; + qt = l; + bt = null; + t = true; + } else { + t = false; + } + } + if (!t) { + la(l); + } + } + return null; + case 13: + return ui(t, l, a); + case 4: + Mt(l, l.stateNode.containerInfo); + e = l.pendingProps; + if (t === null) { + l.child = va(l, null, e, a); + } else { + rt(t, l, e, a); + } + return l.child; + case 11: + return If(t, l, l.type, l.pendingProps, a); + case 7: + rt(t, l, l.pendingProps, a); + return l.child; + case 8: + rt(t, l, l.pendingProps.children, a); + return l.child; + case 12: + rt(t, l, l.pendingProps.children, a); + return l.child; + case 10: + e = l.pendingProps; + Yl(l, l.type, e.value); + rt(t, l, e.children, a); + return l.child; + case 9: + u = l.type._context; + e = l.pendingProps.children; + ea(l); + u = jt(u); + e = e(u); + l.flags |= 1; + rt(t, l, e, a); + return l.child; + case 14: + return $f(t, l, l.type, l.pendingProps, a); + case 15: + return wf(t, l, l.type, l.pendingProps, a); + case 19: + return ci(t, l, a); + case 22: + return kf(t, l, a); + case 24: + ea(l); + e = jt(dt); + if (t === null) { + u = Nn(); + if (u === null) { + u = ut; + n = zn(); + u.pooledCache = n; + n.refCount++; + if (n !== null) { + u.pooledCacheLanes |= a; + } + u = n; + } + l.memoizedState = { + parent: e, + cache: u + }; + Vu(l); + Yl(l, dt, u); + } else { + if ((t.lanes & a) !== 0) { + Xu(t, l); + ce(l, null, null, a); + ne(); + } + u = t.memoizedState; + n = l.memoizedState; + if (u.parent !== e) { + u = { + parent: e, + cache: e + }; + l.memoizedState = u; + if (l.lanes === 0) { + l.memoizedState = l.updateQueue.baseState = u; + } + Yl(l, dt, e); + } else { + e = n.cache; + Yl(l, dt, e); + if (e !== u.cache) { + En(l, [dt], a, true); + } + } + } + rt(t, l, l.pendingProps.children, a); + return l.child; + case 29: + throw l.pendingProps; + } + throw Error(m(156, l.tag)); + } + function Yl(t, l, a) { + if (Ml) { + N(zu, l._currentValue); + l._currentValue = a; + } else { + N(zu, l._currentValue2); + l._currentValue2 = a; + } + } + function zl(t) { + var l = zu.current; + if (Ml) { + t._currentValue = l; + } else { + t._currentValue2 = l; + } + _(zu); + } + function hn(t, l, a) { + while (t !== null) { + var e = t.alternate; + if ((t.childLanes & l) !== l) { + t.childLanes |= l; + if (e !== null) { + e.childLanes |= l; + } + } else if (e !== null && (e.childLanes & l) !== l) { + e.childLanes |= l; + } + if (t === a) { + break; + } + t = t.return; + } + } + function En(t, l, a, e) { + var u = t.child; + for (u !== null && (u.return = t); u !== null;) { + var n = u.dependencies; + if (n !== null) { + var i = u.child; + n = n.firstContext; + t: while (n !== null) { + var v = n; + n = u; + for (var d = 0; d < l.length; d++) { + if (v.context === l[d]) { + n.lanes |= a; + v = n.alternate; + if (v !== null) { + v.lanes |= a; + } + hn(n.return, a, t); + if (!e) { + i = null; + } + break t; + } + } + n = v.next; + } + } else if (u.tag === 18) { + i = u.return; + if (i === null) { + throw Error(m(341)); + } + i.lanes |= a; + n = i.alternate; + if (n !== null) { + n.lanes |= a; + } + hn(i, a, t); + i = null; + } else { + i = u.child; + } + if (i !== null) { + i.return = u; + } else { + for (i = u; i !== null;) { + if (i === t) { + i = null; + break; + } + u = i.sibling; + if (u !== null) { + u.return = i.return; + i = u; + break; + } + i = i.return; + } + } + u = i; + } + } + function ve(t, l, a, e) { + t = null; + for (var u = l, n = false; u !== null;) { + if (!n) { + if ((u.flags & 524288) !== 0) { + n = true; + } else if ((u.flags & 262144) !== 0) { + break; + } + } + if (u.tag === 10) { + var i = u.alternate; + if (i === null) { + throw Error(m(387)); + } + i = i.memoizedProps; + if (i !== null) { + var v = u.type; + if (!Wt(u.pendingProps.value, i.value)) { + if (t !== null) { + t.push(v); + } else { + t = [v]; + } + } + } + } else if (u === pu.current) { + i = u.alternate; + if (i === null) { + throw Error(m(387)); + } + if (i.memoizedState.memoizedState !== u.memoizedState.memoizedState) { + if (t !== null) { + t.push(sa); + } else { + t = [sa]; + } + } + } + u = u.return; + } + if (t !== null) { + En(l, t, a, e); + } + l.flags |= 262144; + } + function Ie(t) { + for (t = t.firstContext; t !== null;) { + var l = t.context; + if (!Wt(Ml ? l._currentValue : l._currentValue2, t.memoizedValue)) { + return true; + } + t = t.next; + } + return false; + } + function ea(t) { + ya = t; + Ul = null; + t = t.dependencies; + if (t !== null) { + t.firstContext = null; + } + } + function jt(t) { + return ii(ya, t); + } + function $e(t, l) { + if (ya === null) { + ea(t); + } + return ii(t, l); + } + function ii(t, l) { + var a = Ml ? l._currentValue : l._currentValue2; + l = { + context: l, + memoizedValue: a, + next: null + }; + if (Ul === null) { + if (t === null) { + throw Error(m(308)); + } + Ul = l; + t.dependencies = { + lanes: 0, + firstContext: l + }; + t.flags |= 524288; + } else { + Ul = Ul.next = l; + } + return a; + } + function zn() { + return { + controller: new Up(), + data: new Map(), + refCount: 0 + }; + } + function pe(t) { + t.refCount--; + if (t.refCount === 0) { + _p(rp, function () { + t.controller.abort(); + }); + } + } + function Nn() { + var t = Sa.current; + if (t !== null) { + return t; + } else { + return ut.pooledCache; + } + } + function we(t, l) { + if (l === null) { + N(Sa, Sa.current); + } else { + N(Sa, l.pool); + } + } + function si() { + var t = Nn(); + if (t === null) { + return null; + } else { + return { + parent: Ml ? dt._currentValue : dt._currentValue2, + pool: t + }; + } + } + function Vt(t) { + t.flags |= 4; + } + function mi(t, l) { + if (t !== null && t.child === l.child) { + return false; + } + if ((l.flags & 16) !== 0) { + return true; + } + for (t = l.child; t !== null;) { + if ((t.flags & 13878) !== 0 || (t.subtreeFlags & 13878) !== 0) { + return true; + } + t = t.sibling; + } + return false; + } + function Tn(t, l, a, e) { + if (gt) { + for (a = l.child; a !== null;) { + if (a.tag === 5 || a.tag === 6) { + $n(t, a.stateNode); + } else if (a.tag !== 4 && (!Dt || a.tag !== 27) && a.child !== null) { + a.child.return = a; + a = a.child; + continue; + } + if (a === l) { + break; + } + while (a.sibling === null) { + if (a.return === null || a.return === l) { + return; + } + a = a.return; + } + a.sibling.return = a.return; + a = a.sibling; + } + } else if (Jl) { + for (var u = l.child; u !== null;) { + if (u.tag === 5) { + var n = u.stateNode; + if (a && e) { + n = ys(n, u.type, u.memoizedProps); + } + $n(t, n); + } else if (u.tag === 6) { + n = u.stateNode; + if (a && e) { + n = Ss(n, u.memoizedProps); + } + $n(t, n); + } else if (u.tag !== 4) { + if (u.tag === 22 && u.memoizedState !== null) { + n = u.child; + if (n !== null) { + n.return = u; + } + Tn(t, u, true, true); + } else if (u.child !== null) { + u.child.return = u; + u = u.child; + continue; + } + } + if (u === l) { + break; + } + while (u.sibling === null) { + if (u.return === null || u.return === l) { + return; + } + u = u.return; + } + u.sibling.return = u.return; + u = u.sibling; + } + } + } + function vi(t, l, a, e) { + if (Jl) { + for (var u = l.child; u !== null;) { + if (u.tag === 5) { + var n = u.stateNode; + if (a && e) { + n = ys(n, u.type, u.memoizedProps); + } + os(t, n); + } else if (u.tag === 6) { + n = u.stateNode; + if (a && e) { + n = Ss(n, u.memoizedProps); + } + os(t, n); + } else if (u.tag !== 4) { + if (u.tag === 22 && u.memoizedState !== null) { + n = u.child; + if (n !== null) { + n.return = u; + } + vi(t, u, u.memoizedProps === null || u.memoizedProps.mode !== "manual", true); + } else if (u.child !== null) { + u.child.return = u; + u = u.child; + continue; + } + } + if (u === l) { + break; + } + while (u.sibling === null) { + if (u.return === null || u.return === l) { + return; + } + u = u.return; + } + u.sibling.return = u.return; + u = u.sibling; + } + } + } + function pi(t, l) { + if (Jl && mi(t, l)) { + t = l.stateNode; + var a = t.containerInfo; + var e = ps(); + vi(e, l, false, false); + t.pendingChildren = e; + Vt(l); + Xv(a, e); + } + } + function Mn(t, l, a, e) { + if (gt) { + if (t.memoizedProps !== e) { + Vt(l); + } + } else if (Jl) { + var u = t.stateNode; + var n = t.memoizedProps; + if ((t = mi(t, l)) || n !== e) { + var i = At.current; + n = Vv(u, a, n, e, !t, null); + if (n === u) { + l.stateNode = u; + } else { + if (cs(n, a, e, i)) { + Vt(l); + } + l.stateNode = n; + if (t) { + Tn(n, l, false, false); + } else { + Vt(l); + } + } + } else { + l.stateNode = u; + } + } + } + function On(t, l, a) { + if (dv(l, a)) { + t.flags |= 16777216; + if (!ss(l, a)) { + if (Qi()) { + t.flags |= 8192; + } else { + Za = yu; + throw vc; + } + } + } else { + t.flags &= -16777217; + } + } + function oi(t, l) { + if (mp(l)) { + t.flags |= 16777216; + if (!_s(l)) { + if (Qi()) { + t.flags |= 8192; + } else { + Za = yu; + throw vc; + } + } + } else { + t.flags &= -16777217; + } + } + function ke(t, l) { + if (l !== null) { + t.flags |= 4; + } + if (t.flags & 16384) { + l = t.tag !== 22 ? at() : 536870912; + t.lanes |= l; + Pa |= l; + } + } + function oe(t, l) { + if (!P) { + switch (t.tailMode) { + case "hidden": + l = t.tail; + var a = null; + while (l !== null) { + if (l.alternate !== null) { + a = l; + } + l = l.sibling; + } + if (a === null) { + t.tail = null; + } else { + a.sibling = null; + } + break; + case "collapsed": + a = t.tail; + var e = null; + while (a !== null) { + if (a.alternate !== null) { + e = a; + } + a = a.sibling; + } + if (e === null) { + if (l || t.tail === null) { + t.tail = null; + } else { + t.tail.sibling = null; + } + } else { + e.sibling = null; + } + } + } + } + function vt(t) { + var l = t.alternate !== null && t.alternate.child === t.child; + var a = 0; + var e = 0; + if (l) { + for (var u = t.child; u !== null;) { + a |= u.lanes | u.childLanes; + e |= u.subtreeFlags & 31457280; + e |= u.flags & 31457280; + u.return = t; + u = u.sibling; + } + } else { + for (u = t.child; u !== null;) { + a |= u.lanes | u.childLanes; + e |= u.subtreeFlags; + e |= u.flags; + u.return = t; + u = u.sibling; + } + } + t.subtreeFlags |= e; + t.childLanes = a; + return l; + } + function qm(t, l, a) { + var e = l.pendingProps; + Dl(l); + switch (l.tag) { + case 16: + case 15: + case 0: + case 11: + case 7: + case 8: + case 12: + case 9: + case 14: + vt(l); + return null; + case 1: + vt(l); + return null; + case 3: + a = l.stateNode; + e = null; + if (t !== null) { + e = t.memoizedState.cache; + } + if (l.memoizedState.cache !== e) { + l.flags |= 2048; + } + zl(dt); + bl(); + if (a.pendingContext) { + a.context = a.pendingContext; + a.pendingContext = null; + } + if (t === null || t.child === null) { + if (le(l)) { + Vt(l); + } else if (t !== null && (!t.memoizedState.isDehydrated || (l.flags & 256) !== 0)) { + l.flags |= 1024; + if (il !== null) { + Cn(il); + il = null; + } + } + } + pi(t, l); + vt(l); + return null; + case 26: + if ($t) { + a = l.type; + var u = l.memoizedState; + if (t === null) { + Vt(l); + if (u !== null) { + vt(l); + oi(l, u); + } else { + vt(l); + On(l, a, e); + } + } else if (u) { + if (u !== t.memoizedState) { + Vt(l); + vt(l); + oi(l, u); + } else { + vt(l); + l.flags &= -16777217; + } + } else { + if (gt) { + if (t.memoizedProps !== e) { + Vt(l); + } + } else { + Mn(t, l, a, e); + } + vt(l); + On(l, a, e); + } + return null; + } + case 27: + if (Dt) { + qe(l); + a = Ll.current; + u = l.type; + if (t !== null && l.stateNode != null) { + if (gt) { + if (t.memoizedProps !== e) { + Vt(l); + } + } else { + Mn(t, l, u, e); + } + } else { + if (!e) { + if (l.stateNode === null) { + throw Error(m(166)); + } + vt(l); + return null; + } + t = At.current; + if (le(l)) { + Fc(l, t); + } else { + t = rs(u, e, a, t, true); + l.stateNode = t; + Vt(l); + } + } + vt(l); + return null; + } + case 5: + qe(l); + a = l.type; + if (t !== null && l.stateNode != null) { + Mn(t, l, a, e); + } else { + if (!e) { + if (l.stateNode === null) { + throw Error(m(166)); + } + vt(l); + return null; + } + t = At.current; + if (le(l)) { + Fc(l, t); + } else { + u = fv(a, e, Ll.current, t, l); + Tn(u, l, false, false); + l.stateNode = u; + if (cs(u, a, e, t)) { + Vt(l); + } + } + } + vt(l); + On(l, l.type, l.pendingProps); + return null; + case 6: + if (t && l.stateNode != null) { + a = t.memoizedProps; + if (gt) { + if (a !== e) { + Vt(l); + } + } else if (Jl) { + if (a !== e) { + l.stateNode = fs(e, Ll.current, At.current, l); + Vt(l); + } else { + l.stateNode = t.stateNode; + } + } + } else { + if (typeof e != "string" && l.stateNode === null) { + throw Error(m(166)); + } + t = Ll.current; + a = At.current; + if (le(l)) { + if (!It) { + throw Error(m(176)); + } + t = l.stateNode; + a = l.memoizedProps; + e = null; + u = qt; + if (u !== null) { + switch (u.tag) { + case 27: + case 5: + e = u.memoizedProps; + } + } + if (!wv(t, a, l, e)) { + la(l); + } + } else { + l.stateNode = fs(e, t, a, l); + } + } + vt(l); + return null; + case 13: + e = l.memoizedState; + if (t === null || t.memoizedState !== null && t.memoizedState.dehydrated !== null) { + u = le(l); + if (e !== null && e.dehydrated !== null) { + if (t === null) { + if (!u) { + throw Error(m(318)); + } + if (!It) { + throw Error(m(344)); + } + u = l.memoizedState; + u = u !== null ? u.dehydrated : null; + if (!u) { + throw Error(m(317)); + } + kv(u, l); + } else { + ae(); + if ((l.flags & 128) === 0) { + l.memoizedState = null; + } + l.flags |= 4; + } + vt(l); + u = false; + } else { + if (il !== null) { + Cn(il); + il = null; + } + u = true; + } + if (!u) { + if (l.flags & 256) { + Sl(l); + return l; + } else { + Sl(l); + return null; + } + } + } + Sl(l); + if ((l.flags & 128) !== 0) { + l.lanes = a; + return l; + } + a = e !== null; + t = t !== null && t.memoizedState !== null; + if (a) { + e = l.child; + u = null; + if (e.alternate !== null && e.alternate.memoizedState !== null && e.alternate.memoizedState.cachePool !== null) { + u = e.alternate.memoizedState.cachePool.pool; + } + var n = null; + if (e.memoizedState !== null && e.memoizedState.cachePool !== null) { + n = e.memoizedState.cachePool.pool; + } + if (n !== u) { + e.flags |= 2048; + } + } + if (a !== t && a) { + l.child.flags |= 8192; + } + ke(l, l.updateQueue); + vt(l); + return null; + case 4: + bl(); + pi(t, l); + if (t === null) { + mv(l.stateNode.containerInfo); + } + vt(l); + return null; + case 10: + zl(l.type); + vt(l); + return null; + case 19: + _(Ot); + u = l.memoizedState; + if (u === null) { + vt(l); + return null; + } + e = (l.flags & 128) !== 0; + n = u.rendering; + if (n === null) { + if (e) { + oe(u, false); + } else { + if (St !== 0 || t !== null && (t.flags & 128) !== 0) { + for (t = l.child; t !== null;) { + n = Ke(t); + if (n !== null) { + l.flags |= 128; + oe(u, false); + t = n.updateQueue; + l.updateQueue = t; + ke(l, t); + l.subtreeFlags = 0; + t = a; + a = l.child; + while (a !== null) { + Wi(a, t); + a = a.sibling; + } + N(Ot, Ot.current & 1 | 2); + return l.child; + } + t = t.sibling; + } + } + if (u.tail !== null && fl() > Ae) { + l.flags |= 128; + e = true; + oe(u, false); + l.lanes = 4194304; + } + } + } else { + if (!e) { + t = Ke(n); + if (t !== null) { + l.flags |= 128; + e = true; + t = t.updateQueue; + l.updateQueue = t; + ke(l, t); + oe(u, true); + if (u.tail === null && u.tailMode === "hidden" && !n.alternate && !P) { + vt(l); + return null; + } + } else if (fl() * 2 - u.renderingStartTime > Ae && a !== 536870912) { + l.flags |= 128; + e = true; + oe(u, false); + l.lanes = 4194304; + } + } + if (u.isBackwards) { + n.sibling = l.child; + l.child = n; + } else { + t = u.last; + if (t !== null) { + t.sibling = n; + } else { + l.child = n; + } + u.last = n; + } + } + if (u.tail !== null) { + l = u.tail; + u.rendering = l; + u.tail = l.sibling; + u.renderingStartTime = fl(); + l.sibling = null; + t = Ot.current; + N(Ot, e ? t & 1 | 2 : t & 1); + return l; + } else { + vt(l); + return null; + } + case 22: + case 23: + Sl(l); + xu(); + e = l.memoizedState !== null; + if (t !== null) { + if (t.memoizedState !== null !== e) { + l.flags |= 8192; + } + } else if (e) { + l.flags |= 8192; + } + if (e) { + if ((a & 536870912) !== 0 && (l.flags & 128) === 0) { + vt(l); + if (l.subtreeFlags & 6) { + l.flags |= 8192; + } + } + } else { + vt(l); + } + a = l.updateQueue; + if (a !== null) { + ke(l, a.retryQueue); + } + a = null; + if (t !== null && t.memoizedState !== null && t.memoizedState.cachePool !== null) { + a = t.memoizedState.cachePool.pool; + } + e = null; + if (l.memoizedState !== null && l.memoizedState.cachePool !== null) { + e = l.memoizedState.cachePool.pool; + } + if (e !== a) { + l.flags |= 2048; + } + if (t !== null) { + _(Sa); + } + return null; + case 24: + a = null; + if (t !== null) { + a = t.memoizedState.cache; + } + if (l.memoizedState.cache !== a) { + l.flags |= 2048; + } + zl(dt); + vt(l); + return null; + case 25: + return null; + } + throw Error(m(156, l.tag)); + } + function Bm(t, l) { + Dl(l); + switch (l.tag) { + case 1: + t = l.flags; + if (t & 65536) { + l.flags = t & -65537 | 128; + return l; + } else { + return null; + } + case 3: + zl(dt); + bl(); + t = l.flags; + if ((t & 65536) !== 0 && (t & 128) === 0) { + l.flags = t & -65537 | 128; + return l; + } else { + return null; + } + case 26: + case 27: + case 5: + qe(l); + return null; + case 13: + Sl(l); + t = l.memoizedState; + if (t !== null && t.dehydrated !== null) { + if (l.alternate === null) { + throw Error(m(340)); + } + ae(); + } + t = l.flags; + if (t & 65536) { + l.flags = t & -65537 | 128; + return l; + } else { + return null; + } + case 19: + _(Ot); + return null; + case 4: + bl(); + return null; + case 10: + zl(l.type); + return null; + case 22: + case 23: + Sl(l); + xu(); + if (t !== null) { + _(Sa); + } + t = l.flags; + if (t & 65536) { + l.flags = t & -65537 | 128; + return l; + } else { + return null; + } + case 24: + zl(dt); + return null; + case 25: + return null; + default: + return null; + } + } + function di(t, l) { + Dl(l); + switch (l.tag) { + case 3: + zl(dt); + bl(); + break; + case 26: + case 27: + case 5: + qe(l); + break; + case 4: + bl(); + break; + case 13: + Sl(l); + break; + case 19: + _(Ot); + break; + case 10: + zl(l.type); + break; + case 22: + case 23: + Sl(l); + xu(); + if (t !== null) { + _(Sa); + } + break; + case 24: + zl(dt); + } + } + function de(t, l) { + try { + var a = l.updateQueue; + var e = a !== null ? a.lastEffect : null; + if (e !== null) { + var u = e.next; + a = u; + do { + if ((a.tag & t) === t) { + e = undefined; + var n = a.create; + var i = a.inst; + e = n(); + i.destroy = e; + } + a = a.next; + } while (a !== u); + } + } catch (v) { + w(l, l.return, v); + } + } + function Gl(t, l, a) { + try { + var e = l.updateQueue; + var u = e !== null ? e.lastEffect : null; + if (u !== null) { + var n = u.next; + e = n; + do { + if ((e.tag & t) === t) { + var i = e.inst; + var v = i.destroy; + if (v !== undefined) { + i.destroy = undefined; + u = l; + var d = a; + try { + v(); + } catch (E) { + w(u, d, E); + } + } + } + e = e.next; + } while (e !== n); + } + } catch (E) { + w(l, l.return, E); + } + } + function yi(t) { + var l = t.updateQueue; + if (l !== null) { + var a = t.stateNode; + try { + af(l, a); + } catch (e) { + w(t, t.return, e); + } + } + } + function Si(t, l, a) { + a.props = aa(t.type, t.memoizedProps); + a.state = t.memoizedState; + try { + a.componentWillUnmount(); + } catch (e) { + w(t, l, e); + } + } + function ua(t, l) { + try { + var a = t.ref; + if (a !== null) { + var e = t.stateNode; + switch (t.tag) { + case 26: + case 27: + case 5: + var u = he(e); + break; + default: + u = e; + } + if (typeof a == "function") { + t.refCleanup = a(u); + } else { + a.current = u; + } + } + } catch (n) { + w(t, l, n); + } + } + function Xt(t, l) { + var a = t.ref; + var e = t.refCleanup; + if (a !== null) { + if (typeof e == "function") { + try { + e(); + } catch (u) { + w(t, l, u); + } finally { + t.refCleanup = null; + t = t.alternate; + if (t != null) { + t.refCleanup = null; + } + } + } else if (typeof a == "function") { + try { + a(null); + } catch (u) { + w(t, l, u); + } + } else { + a.current = null; + } + } + } + function hi(t) { + var l = t.type; + var a = t.memoizedProps; + var e = t.stateNode; + try { + jv(e, l, a, t); + } catch (u) { + w(t, t.return, u); + } + } + function Ei(t, l, a) { + try { + gv(t.stateNode, t.type, a, l, t); + } catch (e) { + w(t, t.return, e); + } + } + function zi(t) { + return t.tag === 5 || t.tag === 3 || ($t ? t.tag === 26 : false) || (Dt ? t.tag === 27 : false) || t.tag === 4; + } + function Hn(t) { + t: while (true) { + while (t.sibling === null) { + if (t.return === null || zi(t.return)) { + return null; + } + t = t.return; + } + t.sibling.return = t.return; + t = t.sibling; + while (t.tag !== 5 && t.tag !== 6 && (!Dt || t.tag !== 27) && t.tag !== 18) { + if (t.flags & 2 || t.child === null || t.tag === 4) { + continue t; + } + t.child.return = t; + t = t.child; + } + if (!(t.flags & 2)) { + return t.stateNode; + } + } + } + function Un(t, l, a) { + var e = t.tag; + if (e === 5 || e === 6) { + t = t.stateNode; + if (l) { + bv(a, t, l); + } else { + rv(a, t); + } + } else if (e !== 4 && (!Dt || e !== 27) && (t = t.child, t !== null)) { + Un(t, l, a); + t = t.sibling; + while (t !== null) { + Un(t, l, a); + t = t.sibling; + } + } + } + function tu(t, l, a) { + var e = t.tag; + if (e === 5 || e === 6) { + t = t.stateNode; + if (l) { + Dv(a, t, l); + } else { + _v(a, t); + } + } else if (e !== 4 && (!Dt || e !== 27) && (t = t.child, t !== null)) { + tu(t, l, a); + t = t.sibling; + while (t !== null) { + tu(t, l, a); + t = t.sibling; + } + } + } + function Ni(t, l, a) { + t = t.containerInfo; + try { + ds(t, a); + } catch (e) { + w(l, l.return, e); + } + } + function Qm(t, l) { + nv(t.containerInfo); + Ut = l; + while (Ut !== null) { + t = Ut; + l = t.child; + if ((t.subtreeFlags & 1028) !== 0 && l !== null) { + l.return = t; + Ut = l; + } else { + while (Ut !== null) { + t = Ut; + var a = t.alternate; + l = t.flags; + switch (t.tag) { + case 0: + break; + case 11: + case 15: + break; + case 1: + if ((l & 1024) !== 0 && a !== null) { + l = undefined; + var e = t; + var u = a.memoizedProps; + a = a.memoizedState; + var n = e.stateNode; + try { + var i = aa(e.type, u, e.elementType === e.type); + l = n.getSnapshotBeforeUpdate(i, a); + n.__reactInternalSnapshotBeforeUpdate = l; + } catch (v) { + w(e, e.return, v); + } + } + break; + case 3: + if ((l & 1024) !== 0 && gt) { + Gv(t.stateNode.containerInfo); + } + break; + case 5: + case 26: + case 27: + case 6: + case 4: + case 17: + break; + default: + if ((l & 1024) !== 0) { + throw Error(m(163)); + } + } + l = t.sibling; + if (l !== null) { + l.return = t.return; + Ut = l; + break; + } + Ut = t.return; + } + } + } + i = Bs; + Bs = false; + return i; + } + function Ti(t, l, a) { + var e = a.flags; + switch (a.tag) { + case 0: + case 11: + case 15: + Nl(t, a); + if (e & 4) { + de(5, a); + } + break; + case 1: + Nl(t, a); + if (e & 4) { + t = a.stateNode; + if (l === null) { + try { + t.componentDidMount(); + } catch (v) { + w(a, a.return, v); + } + } else { + var u = aa(a.type, l.memoizedProps); + l = l.memoizedState; + try { + t.componentDidUpdate(u, l, t.__reactInternalSnapshotBeforeUpdate); + } catch (v) { + w(a, a.return, v); + } + } + } + if (e & 64) { + yi(a); + } + if (e & 512) { + ua(a, a.return); + } + break; + case 3: + Nl(t, a); + if (e & 64 && (e = a.updateQueue, e !== null)) { + t = null; + if (a.child !== null) { + switch (a.child.tag) { + case 27: + case 5: + t = he(a.child.stateNode); + break; + case 1: + t = a.child.stateNode; + } + } + try { + af(e, t); + } catch (v) { + w(a, a.return, v); + } + } + break; + case 26: + if ($t) { + Nl(t, a); + if (e & 512) { + ua(a, a.return); + } + break; + } + case 27: + case 5: + Nl(t, a); + if (l === null && e & 4) { + hi(a); + } + if (e & 512) { + ua(a, a.return); + } + break; + case 12: + Nl(t, a); + break; + case 13: + Nl(t, a); + if (e & 4) { + Oi(t, a); + } + break; + case 22: + u = a.memoizedState !== null || _l; + if (!u) { + l = l !== null && l.memoizedState !== null || yt; + var n = _l; + var i = yt; + _l = u; + if ((yt = l) && !i) { + Vl(t, a, (a.subtreeFlags & 8772) !== 0); + } else { + Nl(t, a); + } + _l = n; + yt = i; + } + if (e & 512) { + if (a.memoizedProps.mode === "manual") { + ua(a, a.return); + } else { + Xt(a, a.return); + } + } + break; + default: + Nl(t, a); + } + } + function Mi(t) { + var l = t.alternate; + if (l !== null) { + t.alternate = null; + Mi(l); + } + t.child = null; + t.deletions = null; + t.sibling = null; + if (t.tag === 5) { + l = t.stateNode; + if (l !== null) { + ov(l); + } + } + t.stateNode = null; + t.return = null; + t.dependencies = null; + t.memoizedProps = null; + t.memoizedState = null; + t.pendingProps = null; + t.stateNode = null; + t.updateQueue = null; + } + function cl(t, l, a) { + for (a = a.child; a !== null;) { + _n(t, l, a); + a = a.sibling; + } + } + function _n(t, l, a) { + if (Lt && typeof Lt.onCommitFiberUnmount == "function") { + try { + Lt.onCommitFiberUnmount(Ne, a); + } catch {} + } + switch (a.tag) { + case 26: + if ($t) { + if (!yt) { + Xt(a, l); + } + cl(t, l, a); + if (a.memoizedState) { + Os(a.memoizedState); + } else if (a.stateNode) { + Us(a.stateNode); + } + break; + } + case 27: + if (Dt) { + if (!yt) { + Xt(a, l); + } + var e = Tt; + var u = Ft; + Tt = a.stateNode; + cl(t, l, a); + dp(a.stateNode); + Tt = e; + Ft = u; + break; + } + case 5: + if (!yt) { + Xt(a, l); + } + case 6: + if (gt) { + e = Tt; + u = Ft; + Tt = null; + cl(t, l, a); + Tt = e; + Ft = u; + if (Tt !== null) { + if (Ft) { + try { + Cv(Tt, a.stateNode); + } catch (n) { + w(a, l, n); + } + } else { + try { + Rv(Tt, a.stateNode); + } catch (n) { + w(a, l, n); + } + } + } + } else { + cl(t, l, a); + } + break; + case 18: + if (gt && Tt !== null) { + if (Ft) { + up(Tt, a.stateNode); + } else { + ep(Tt, a.stateNode); + } + } + break; + case 4: + if (gt) { + e = Tt; + u = Ft; + Tt = a.stateNode.containerInfo; + Ft = true; + cl(t, l, a); + Tt = e; + Ft = u; + } else { + if (Jl) { + Ni(a.stateNode, a, ps()); + } + cl(t, l, a); + } + break; + case 0: + case 11: + case 14: + case 15: + if (!yt) { + Gl(2, a, l); + } + if (!yt) { + Gl(4, a, l); + } + cl(t, l, a); + break; + case 1: + if (!yt) { + Xt(a, l); + e = a.stateNode; + if (typeof e.componentWillUnmount == "function") { + Si(a, l, e); + } + } + cl(t, l, a); + break; + case 21: + cl(t, l, a); + break; + case 22: + if (!yt) { + Xt(a, l); + } + yt = (e = yt) || a.memoizedState !== null; + cl(t, l, a); + yt = e; + break; + default: + cl(t, l, a); + } + } + function Oi(t, l) { + if (It && l.memoizedState === null && (t = l.alternate, t !== null && (t = t.memoizedState, t !== null && (t = t.dehydrated, t !== null)))) { + try { + ap(t); + } catch (a) { + w(l, l.return, a); + } + } + } + function Ym(t) { + switch (t.tag) { + case 13: + case 19: + var l = t.stateNode; + if (l === null) { + l = t.stateNode = new qs(); + } + return l; + case 22: + t = t.stateNode; + l = t._retryCache; + if (l === null) { + l = t._retryCache = new qs(); + } + return l; + default: + throw Error(m(435, t.tag)); + } + } + function rn(t, l) { + var a = Ym(t); + l.forEach(function (e) { + var u = Lm.bind(null, t, e); + if (!a.has(e)) { + a.add(e); + e.then(u, u); + } + }); + } + function Yt(t, l) { + var a = l.deletions; + if (a !== null) { + for (var e = 0; e < a.length; e++) { + var u = a[e]; + var n = t; + var i = l; + if (gt) { + var v = i; + t: while (v !== null) { + switch (v.tag) { + case 27: + case 5: + Tt = v.stateNode; + Ft = false; + break t; + case 3: + Tt = v.stateNode.containerInfo; + Ft = true; + break t; + case 4: + Tt = v.stateNode.containerInfo; + Ft = true; + break t; + } + v = v.return; + } + if (Tt === null) { + throw Error(m(160)); + } + _n(n, i, u); + Tt = null; + Ft = false; + } else { + _n(n, i, u); + } + n = u.alternate; + if (n !== null) { + n.return = null; + } + u.return = null; + } + } + if (l.subtreeFlags & 13878) { + for (l = l.child; l !== null;) { + Hi(l, t); + l = l.sibling; + } + } + } + function Hi(t, l) { + var a = t.alternate; + var e = t.flags; + switch (t.tag) { + case 0: + case 11: + case 14: + case 15: + Yt(l, t); + Zt(t); + if (e & 4) { + Gl(3, t, t.return); + de(3, t); + Gl(5, t, t.return); + } + break; + case 1: + Yt(l, t); + Zt(t); + if (e & 512) { + if (!yt && a !== null) { + Xt(a, a.return); + } + } + if (e & 64 && _l) { + t = t.updateQueue; + if (t !== null) { + e = t.callbacks; + if (e !== null) { + a = t.shared.hiddenCallbacks; + t.shared.hiddenCallbacks = a === null ? e : a.concat(e); + } + } + } + break; + case 26: + if ($t) { + var u = sl; + Yt(l, t); + Zt(t); + if (e & 512) { + if (!yt && a !== null) { + Xt(a, a.return); + } + } + if (e & 4) { + e = a !== null ? a.memoizedState : null; + l = t.memoizedState; + if (a === null) { + if (l === null) { + if (t.stateNode === null) { + t.stateNode = fp(u, t.type, t.memoizedProps, t); + } else { + Hs(u, t.type, t.stateNode); + } + } else { + t.stateNode = Ms(u, l, t.memoizedProps); + } + } else if (e !== l) { + if (e === null) { + if (a.stateNode !== null) { + Us(a.stateNode); + } + } else { + Os(e); + } + if (l === null) { + Hs(u, t.type, t.stateNode); + } else { + Ms(u, l, t.memoizedProps); + } + } else if (l === null && t.stateNode !== null) { + Ei(t, t.memoizedProps, a.memoizedProps); + } + } + break; + } + case 27: + if (Dt && e & 4 && t.alternate === null) { + u = t.stateNode; + var n = t.memoizedProps; + try { + pp(u); + op(t.type, n, u, t); + } catch (H) { + w(t, t.return, H); + } + } + case 5: + Yt(l, t); + Zt(t); + if (e & 512) { + if (!yt && a !== null) { + Xt(a, a.return); + } + } + if (gt) { + if (t.flags & 32) { + l = t.stateNode; + try { + vs(l); + } catch (H) { + w(t, t.return, H); + } + } + if (e & 4 && t.stateNode != null) { + l = t.memoizedProps; + Ei(t, l, a !== null ? a.memoizedProps : l); + } + if (e & 1024) { + yc = true; + } + } + break; + case 6: + Yt(l, t); + Zt(t); + if (e & 4 && gt) { + if (t.stateNode === null) { + throw Error(m(162)); + } + e = t.memoizedProps; + a = a !== null ? a.memoizedProps : e; + l = t.stateNode; + try { + Av(l, a, e); + } catch (H) { + w(t, t.return, H); + } + } + break; + case 3: + if ($t) { + sp(); + u = sl; + sl = lc(l.containerInfo); + Yt(l, t); + sl = u; + } else { + Yt(l, t); + } + Zt(t); + if (e & 4) { + if (gt && It && a !== null && a.memoizedState.isDehydrated) { + try { + lp(l.containerInfo); + } catch (H) { + w(t, t.return, H); + } + } + if (Jl) { + e = l.containerInfo; + a = l.pendingChildren; + try { + ds(e, a); + } catch (H) { + w(t, t.return, H); + } + } + } + if (yc) { + yc = false; + Ui(t); + } + break; + case 4: + if ($t) { + a = sl; + sl = lc(t.stateNode.containerInfo); + Yt(l, t); + Zt(t); + sl = a; + } else { + Yt(l, t); + Zt(t); + } + if (e & 4 && Jl) { + Ni(t.stateNode, t, t.stateNode.pendingChildren); + } + break; + case 12: + Yt(l, t); + Zt(t); + break; + case 13: + Yt(l, t); + Zt(t); + if (t.child.flags & 8192 && t.memoizedState !== null != (a !== null && a.memoizedState !== null)) { + zc = fl(); + } + if (e & 4) { + e = t.updateQueue; + if (e !== null) { + t.updateQueue = null; + rn(t, e); + } + } + break; + case 22: + if (e & 512) { + if (!yt && a !== null) { + Xt(a, a.return); + } + } + u = t.memoizedState !== null; + var i = a !== null && a.memoizedState !== null; + var v = _l; + var d = yt; + _l = v || u; + yt = d || i; + Yt(l, t); + yt = d; + _l = v; + Zt(t); + l = t.stateNode; + l._current = t; + l._visibility &= -3; + l._visibility |= l._pendingVisibility & 2; + if (e & 8192 && (l._visibility = u ? l._visibility & -2 : l._visibility | 1, u && (l = _l || yt, a === null || i || l || _a(t)), gt && (t.memoizedProps === null || t.memoizedProps.mode !== "manual"))) { + a = null; + t: if (gt) { + for (l = t;;) { + if (l.tag === 5 || $t && l.tag === 26 || Dt && l.tag === 27) { + if (a === null) { + i = a = l; + try { + n = i.stateNode; + if (u) { + qv(n); + } else { + Qv(i.stateNode, i.memoizedProps); + } + } catch (H) { + w(i, i.return, H); + } + } + } else if (l.tag === 6) { + if (a === null) { + i = l; + try { + var E = i.stateNode; + if (u) { + Bv(E); + } else { + Yv(E, i.memoizedProps); + } + } catch (H) { + w(i, i.return, H); + } + } + } else if ((l.tag !== 22 && l.tag !== 23 || l.memoizedState === null || l === t) && l.child !== null) { + l.child.return = l; + l = l.child; + continue; + } + if (l === t) { + break t; + } + while (l.sibling === null) { + if (l.return === null || l.return === t) { + break t; + } + if (a === l) { + a = null; + } + l = l.return; + } + if (a === l) { + a = null; + } + l.sibling.return = l.return; + l = l.sibling; + } + } + } + if (e & 4) { + e = t.updateQueue; + if (e !== null) { + a = e.retryQueue; + if (a !== null) { + e.retryQueue = null; + rn(t, a); + } + } + } + break; + case 19: + Yt(l, t); + Zt(t); + if (e & 4) { + e = t.updateQueue; + if (e !== null) { + t.updateQueue = null; + rn(t, e); + } + } + break; + case 21: + break; + default: + Yt(l, t); + Zt(t); + } + } + function Zt(t) { + var l = t.flags; + if (l & 2) { + try { + if (gt && (!Dt || t.tag !== 27)) { + t: { + for (var a = t.return; a !== null;) { + if (zi(a)) { + var e = a; + break t; + } + a = a.return; + } + throw Error(m(160)); + } + switch (e.tag) { + case 27: + if (Dt) { + var u = e.stateNode; + var n = Hn(t); + tu(t, n, u); + break; + } + case 5: + var i = e.stateNode; + if (e.flags & 32) { + vs(i); + e.flags &= -33; + } + var v = Hn(t); + tu(t, v, i); + break; + case 3: + case 4: + var d = e.stateNode.containerInfo; + var E = Hn(t); + Un(t, E, d); + break; + default: + throw Error(m(161)); + } + } + } catch (H) { + w(t, t.return, H); + } + t.flags &= -3; + } + if (l & 4096) { + t.flags &= -4097; + } + } + function Ui(t) { + if (t.subtreeFlags & 1024) { + for (t = t.child; t !== null;) { + var l = t; + Ui(l); + if (l.tag === 5 && l.flags & 1024) { + hv(l.stateNode); + } + t = t.sibling; + } + } + } + function Nl(t, l) { + if (l.subtreeFlags & 8772) { + for (l = l.child; l !== null;) { + Ti(t, l.alternate, l); + l = l.sibling; + } + } + } + function _a(t) { + for (t = t.child; t !== null;) { + var l = t; + switch (l.tag) { + case 0: + case 11: + case 14: + case 15: + Gl(4, l, l.return); + _a(l); + break; + case 1: + Xt(l, l.return); + var a = l.stateNode; + if (typeof a.componentWillUnmount == "function") { + Si(l, l.return, a); + } + _a(l); + break; + case 26: + case 27: + case 5: + Xt(l, l.return); + _a(l); + break; + case 22: + Xt(l, l.return); + if (l.memoizedState === null) { + _a(l); + } + break; + default: + _a(l); + } + t = t.sibling; + } + } + function Vl(t, l, a) { + a = a && (l.subtreeFlags & 8772) !== 0; + l = l.child; + while (l !== null) { + var e = l.alternate; + var u = t; + var n = l; + var i = n.flags; + switch (n.tag) { + case 0: + case 11: + case 15: + Vl(u, n, a); + de(4, n); + break; + case 1: + Vl(u, n, a); + e = n; + u = e.stateNode; + if (typeof u.componentDidMount == "function") { + try { + u.componentDidMount(); + } catch (E) { + w(e, e.return, E); + } + } + e = n; + u = e.updateQueue; + if (u !== null) { + var v = e.stateNode; + try { + var d = u.shared.hiddenCallbacks; + if (d !== null) { + u.shared.hiddenCallbacks = null; + u = 0; + for (; u < d.length; u++) { + lf(d[u], v); + } + } + } catch (E) { + w(e, e.return, E); + } + } + if (a && i & 64) { + yi(n); + } + ua(n, n.return); + break; + case 26: + case 27: + case 5: + Vl(u, n, a); + if (a && e === null && i & 4) { + hi(n); + } + ua(n, n.return); + break; + case 12: + Vl(u, n, a); + break; + case 13: + Vl(u, n, a); + if (a && i & 4) { + Oi(u, n); + } + break; + case 22: + if (n.memoizedState === null) { + Vl(u, n, a); + } + ua(n, n.return); + break; + default: + Vl(u, n, a); + } + l = l.sibling; + } + } + function An(t, l) { + var a = null; + if (t !== null && t.memoizedState !== null && t.memoizedState.cachePool !== null) { + a = t.memoizedState.cachePool.pool; + } + t = null; + if (l.memoizedState !== null && l.memoizedState.cachePool !== null) { + t = l.memoizedState.cachePool.pool; + } + if (t !== a) { + if (t != null) { + t.refCount++; + } + if (a != null) { + pe(a); + } + } + } + function jn(t, l) { + t = null; + if (l.alternate !== null) { + t = l.alternate.memoizedState.cache; + } + l = l.memoizedState.cache; + if (l !== t) { + l.refCount++; + if (t != null) { + pe(t); + } + } + } + function Xl(t, l, a, e) { + if (l.subtreeFlags & 10256) { + for (l = l.child; l !== null;) { + _i(t, l, a, e); + l = l.sibling; + } + } + } + function _i(t, l, a, e) { + var u = l.flags; + switch (l.tag) { + case 0: + case 11: + case 15: + Xl(t, l, a, e); + if (u & 2048) { + de(9, l); + } + break; + case 3: + Xl(t, l, a, e); + if (u & 2048) { + t = null; + if (l.alternate !== null) { + t = l.alternate.memoizedState.cache; + } + l = l.memoizedState.cache; + if (l !== t) { + l.refCount++; + if (t != null) { + pe(t); + } + } + } + break; + case 12: + if (u & 2048) { + Xl(t, l, a, e); + t = l.stateNode; + try { + var n = l.memoizedProps; + var i = n.id; + var v = n.onPostCommit; + if (typeof v == "function") { + v(i, l.alternate === null ? "mount" : "update", t.passiveEffectDuration, -0); + } + } catch (d) { + w(l, l.return, d); + } + } else { + Xl(t, l, a, e); + } + break; + case 23: + break; + case 22: + n = l.stateNode; + if (l.memoizedState !== null) { + if (n._visibility & 4) { + Xl(t, l, a, e); + } else { + ye(t, l); + } + } else if (n._visibility & 4) { + Xl(t, l, a, e); + } else { + n._visibility |= 4; + ra(t, l, a, e, (l.subtreeFlags & 10256) !== 0); + } + if (u & 2048) { + An(l.alternate, l); + } + break; + case 24: + Xl(t, l, a, e); + if (u & 2048) { + jn(l.alternate, l); + } + break; + default: + Xl(t, l, a, e); + } + } + function ra(t, l, a, e, u) { + u = u && (l.subtreeFlags & 10256) !== 0; + l = l.child; + while (l !== null) { + var n = t; + var i = l; + var v = a; + var d = e; + var E = i.flags; + switch (i.tag) { + case 0: + case 11: + case 15: + ra(n, i, v, d, u); + de(8, i); + break; + case 23: + break; + case 22: + var H = i.stateNode; + if (i.memoizedState !== null) { + if (H._visibility & 4) { + ra(n, i, v, d, u); + } else { + ye(n, i); + } + } else { + H._visibility |= 4; + ra(n, i, v, d, u); + } + if (u && E & 2048) { + An(i.alternate, i); + } + break; + case 24: + ra(n, i, v, d, u); + if (u && E & 2048) { + jn(i.alternate, i); + } + break; + default: + ra(n, i, v, d, u); + } + l = l.sibling; + } + } + function ye(t, l) { + if (l.subtreeFlags & 10256) { + for (l = l.child; l !== null;) { + var a = t; + var e = l; + var u = e.flags; + switch (e.tag) { + case 22: + ye(a, e); + if (u & 2048) { + An(e.alternate, e); + } + break; + case 24: + ye(a, e); + if (u & 2048) { + jn(e.alternate, e); + } + break; + default: + ye(a, e); + } + l = l.sibling; + } + } + } + function na(t) { + if (t.subtreeFlags & Wa) { + for (t = t.child; t !== null;) { + ri(t); + t = t.sibling; + } + } + } + function ri(t) { + switch (t.tag) { + case 26: + na(t); + if (t.flags & Wa) { + if (t.memoizedState !== null) { + vp(sl, t.memoizedState, t.memoizedProps); + } else { + ms(t.type, t.memoizedProps); + } + } + break; + case 5: + na(t); + if (t.flags & Wa) { + ms(t.type, t.memoizedProps); + } + break; + case 3: + case 4: + if ($t) { + var l = sl; + sl = lc(t.stateNode.containerInfo); + na(t); + sl = l; + } else { + na(t); + } + break; + case 22: + if (t.memoizedState === null) { + l = t.alternate; + if (l !== null && l.memoizedState !== null) { + l = Wa; + Wa = 16777216; + na(t); + Wa = l; + } else { + na(t); + } + } + break; + default: + na(t); + } + } + function Ai(t) { + var l = t.alternate; + if (l !== null && (t = l.child, t !== null)) { + l.child = null; + do { + l = t.sibling; + t.sibling = null; + t = l; + } while (t !== null); + } + } + function Se(t) { + var l = t.deletions; + if ((t.flags & 16) !== 0) { + if (l !== null) { + for (var a = 0; a < l.length; a++) { + var e = l[a]; + Ut = e; + gi(e, t); + } + } + Ai(t); + } + if (t.subtreeFlags & 10256) { + for (t = t.child; t !== null;) { + ji(t); + t = t.sibling; + } + } + } + function ji(t) { + switch (t.tag) { + case 0: + case 11: + case 15: + Se(t); + if (t.flags & 2048) { + Gl(9, t, t.return); + } + break; + case 3: + Se(t); + break; + case 12: + Se(t); + break; + case 22: + var l = t.stateNode; + if (t.memoizedState !== null && l._visibility & 4 && (t.return === null || t.return.tag !== 13)) { + l._visibility &= -5; + lu(t); + } else { + Se(t); + } + break; + default: + Se(t); + } + } + function lu(t) { + var l = t.deletions; + if ((t.flags & 16) !== 0) { + if (l !== null) { + for (var a = 0; a < l.length; a++) { + var e = l[a]; + Ut = e; + gi(e, t); + } + } + Ai(t); + } + for (t = t.child; t !== null;) { + l = t; + switch (l.tag) { + case 0: + case 11: + case 15: + Gl(8, l, l.return); + lu(l); + break; + case 22: + a = l.stateNode; + if (a._visibility & 4) { + a._visibility &= -5; + lu(l); + } + break; + default: + lu(l); + } + t = t.sibling; + } + } + function gi(t, l) { + while (Ut !== null) { + var a = Ut; + switch (a.tag) { + case 0: + case 11: + case 15: + Gl(8, a, l); + break; + case 23: + case 22: + if (a.memoizedState !== null && a.memoizedState.cachePool !== null) { + var e = a.memoizedState.cachePool.pool; + if (e != null) { + e.refCount++; + } + } + break; + case 24: + pe(a.memoizedState.cache); + } + e = a.child; + if (e !== null) { + e.return = a; + Ut = e; + } else { + t: for (a = t; Ut !== null;) { + e = Ut; + var u = e.sibling; + var n = e.return; + Mi(e); + if (e === a) { + Ut = null; + break t; + } + if (u !== null) { + u.return = n; + Ut = u; + break t; + } + Ut = n; + } + } + } + } + function gn(t) { + var l = is(t); + if (l != null) { + if (typeof l.memoizedProps["data-testname"] != "string") { + throw Error(m(364)); + } + return l; + } + t = Nv(t); + if (t === null) { + throw Error(m(362)); + } + return t.stateNode.current; + } + function Dn(t, l) { + var a = t.tag; + switch (l.$$typeof) { + case Nu: + if (t.type === l.value) { + return true; + } + break; + case Tu: + t: { + l = l.value; + t = [t, 0]; + a = 0; + while (a < t.length) { + var e = t[a++]; + var u = e.tag; + var n = t[a++]; + var i = l[n]; + if (u !== 5 && u !== 26 && u !== 27 || !ze(e)) { + while (i != null && Dn(e, i)) { + n++; + i = l[n]; + } + if (n === l.length) { + l = true; + break t; + } else { + for (e = e.child; e !== null;) { + t.push(e, n); + e = e.sibling; + } + } + } + } + l = false; + } + return l; + case Mu: + if ((a === 5 || a === 26 || a === 27) && Ov(t.stateNode, l.value)) { + return true; + } + break; + case Hu: + if ((a === 5 || a === 6 || a === 26 || a === 27) && (t = Mv(t), t !== null && t.indexOf(l.value) >= 0)) { + return true; + } + break; + case Ou: + if ((a === 5 || a === 26 || a === 27) && (t = t.memoizedProps["data-testname"], typeof t == "string" && t.toLowerCase() === l.value.toLowerCase())) { + return true; + } + break; + default: + throw Error(m(365)); + } + return false; + } + function bn(t) { + switch (t.$$typeof) { + case Nu: + return "<" + (T(t.value) || "Unknown") + ">"; + case Tu: + return ":has(" + (bn(t) || "") + ")"; + case Mu: + return "[role=\"" + t.value + "\"]"; + case Hu: + return "\"" + t.value + "\""; + case Ou: + return "[data-testname=\"" + t.value + "\"]"; + default: + throw Error(m(365)); + } + } + function Di(t, l) { + var a = []; + t = [t, 0]; + for (var e = 0; e < t.length;) { + var u = t[e++]; + var n = u.tag; + var i = t[e++]; + var v = l[i]; + if (n !== 5 && n !== 26 && n !== 27 || !ze(u)) { + while (v != null && Dn(u, v)) { + i++; + v = l[i]; + } + if (i === l.length) { + a.push(u); + } else { + for (u = u.child; u !== null;) { + t.push(u, i); + u = u.sibling; + } + } + } + } + return a; + } + function Rn(t, l) { + if (!Ee) { + throw Error(m(363)); + } + t = gn(t); + t = Di(t, l); + l = []; + t = Array.from(t); + for (var a = 0; a < t.length;) { + var e = t[a++]; + var u = e.tag; + if (u === 5 || u === 26 || u === 27) { + if (!ze(e)) { + l.push(e.stateNode); + } + } else { + for (e = e.child; e !== null;) { + t.push(e); + e = e.sibling; + } + } + } + return l; + } + function Kt() { + if ((tt & 2) !== 0 && L !== 0) { + return L & -L; + } + if (q.T !== null) { + var t = Va; + if (t !== 0) { + return t; + } else { + return Gu(); + } + } + return vv(); + } + function bi() { + if (al === 0) { + al = (L & 536870912) === 0 || P ? pt() : 536870912; + } + var t = ll.current; + if (t !== null) { + t.flags |= 32; + } + return al; + } + function Ct(t, l, a) { + if (t === ut && nt === 2 || t.cancelPendingCommit !== null) { + Aa(t, 0); + Tl(t, L, al, false); + } + et(t, a); + if ((tt & 2) === 0 || t !== ut) { + if (t === ut) { + if ((tt & 2) === 0) { + ha |= a; + } + if (St === 4) { + Tl(t, L, al, false); + } + } + vl(t); + } + } + function Ri(t, l, a) { + if ((tt & 6) !== 0) { + throw Error(m(327)); + } + var e = !a && (l & 60) === 0 && (l & t.expiredLanes) === 0 || B(t, l); + var u = e ? Xm(t, l) : Qn(t, l, true); + var n = e; + do { + if (u === 0) { + if (Fa && !e) { + Tl(t, l, 0, false); + } + break; + } else if (u === 6) { + Tl(t, l, 0, !rl); + } else { + a = t.current.alternate; + if (n && !Gm(a)) { + u = Qn(t, l, false); + n = false; + continue; + } + if (u === 2) { + n = l; + if (t.errorRecoveryDisabledLanes & n) { + var i = 0; + } else { + i = t.pendingLanes & -536870913; + i = i !== 0 ? i : i & 536870912 ? 536870912 : 0; + } + if (i !== 0) { + l = i; + t: { + var v = t; + u = re; + var d = It && v.current.memoizedState.isDehydrated; + if (d) { + Aa(v, i).flags |= 256; + } + i = Qn(v, i, false); + if (i !== 2) { + if (Sc && !d) { + v.errorRecoveryDisabledLanes |= n; + ha |= n; + u = 4; + break t; + } + n = yl; + yl = u; + if (n !== null) { + Cn(n); + } + } + u = i; + } + n = false; + if (u !== 2) { + continue; + } + } + } + if (u === 1) { + Aa(t, 0); + Tl(t, l, 0, true); + break; + } + t: { + e = t; + switch (u) { + case 0: + case 1: + throw Error(m(345)); + case 4: + if ((l & 4194176) === l) { + Tl(e, l, al, !rl); + break t; + } + break; + case 2: + yl = null; + break; + case 3: + case 5: + break; + default: + throw Error(m(329)); + } + e.finishedWork = a; + e.finishedLanes = l; + if ((l & 62914560) === l && (n = zc + 300 - fl(), n > 10)) { + Tl(e, l, al, !rl); + if (F(e, 0) !== 0) { + break t; + } + e.timeoutHandle = iv(Ci.bind(null, e, a, yl, Uu, Ec, l, al, ha, Pa, rl, 2, -0, 0), n); + break t; + } + Ci(e, a, yl, Uu, Ec, l, al, ha, Pa, rl, 0, -0, 0); + } + } + break; + } while (true); + vl(t); + } + function Cn(t) { + if (yl === null) { + yl = t; + } else { + yl.push.apply(yl, t); + } + } + function Ci(t, l, a, e, u, n, i, v, d, E, H, r, j) { + var Q = l.subtreeFlags; + if ((Q & 8192 || (Q & 16785408) === 16785408) && (yv(), ri(l), l = Sv(), l !== null)) { + t.cancelPendingCommit = l(Ki.bind(null, t, a, e, u, i, v, d, 1, r, j)); + Tl(t, n, i, !E); + return; + } + Ki(t, a, e, u, i, v, d, H, r, j); + } + function Gm(t) { + var l = t; + while (true) { + var a = l.tag; + if ((a === 0 || a === 11 || a === 15) && l.flags & 16384 && (a = l.updateQueue, a !== null && (a = a.stores, a !== null))) { + for (var e = 0; e < a.length; e++) { + var u = a[e]; + var n = u.getSnapshot; + u = u.value; + try { + if (!Wt(n(), u)) { + return false; + } + } catch { + return false; + } + } + } + a = l.child; + if (l.subtreeFlags & 16384 && a !== null) { + a.return = l; + l = a; + } else { + if (l === t) { + break; + } + while (l.sibling === null) { + if (l.return === null || l.return === t) { + return true; + } + l = l.return; + } + l.sibling.return = l.return; + l = l.sibling; + } + } + return true; + } + function Tl(t, l, a, e) { + l &= ~hc; + l &= ~ha; + t.suspendedLanes |= l; + t.pingedLanes &= ~l; + if (e) { + t.warmLanes |= l; + } + e = t.expirationTimes; + for (var u = l; u > 0;) { + var n = 31 - Jt(u); + var i = 1 << n; + e[n] = -1; + u &= ~i; + } + if (a !== 0) { + J(t, a, l); + } + } + function qi() { + if ((tt & 6) === 0) { + Ha(0); + return false; + } else { + return true; + } + } + function qn() { + if (K !== null) { + if (nt === 0) { + var t = K.return; + } else { + t = K; + Ul = ya = null; + Pu(t); + Ka = null; + He = 0; + t = K; + } + while (t !== null) { + di(t.alternate, t); + t = t.return; + } + K = null; + } + } + function Aa(t, l) { + t.finishedWork = null; + t.finishedLanes = 0; + var a = t.timeoutHandle; + if (a !== wn) { + t.timeoutHandle = wn; + sv(a); + } + a = t.cancelPendingCommit; + if (a !== null) { + t.cancelPendingCommit = null; + a(); + } + qn(); + ut = t; + K = a = Zl(t.current, null); + L = l; + nt = 0; + Pt = null; + rl = false; + Fa = B(t, l); + Sc = false; + Pa = al = hc = ha = Il = St = 0; + yl = re = null; + Ec = false; + if ((l & 8) !== 0) { + l |= l & 32; + } + var e = t.entangledLanes; + if (e !== 0) { + t = t.entanglements; + e &= l; + while (e > 0) { + var u = 31 - Jt(e); + var n = 1 << u; + l |= t[u]; + e &= ~n; + } + } + Al = l; + Be(); + return a; + } + function Bi(t, l) { + G = null; + q.H = dl; + if (l === Oe) { + l = nf(); + nt = 3; + } else if (l === vc) { + l = nf(); + nt = 4; + } else { + nt = l === Rs ? 8 : l !== null && typeof l == "object" && typeof l.then == "function" ? 6 : 1; + } + Pt = l; + if (K === null) { + St = 1; + Pe(t, Rt(l, t.current)); + } + } + function Qi() { + var t = ll.current; + if (t === null) { + return true; + } else if ((L & 4194176) === L) { + return ol === null; + } else if ((L & 62914560) === L || (L & 536870912) !== 0) { + return t === ol; + } else { + return false; + } + } + function Yi() { + var t = q.H; + q.H = dl; + if (t === null) { + return dl; + } else { + return t; + } + } + function Gi() { + var t = q.A; + q.A = Ap; + return t; + } + function Bn() { + St = 4; + if (!rl && ((L & 4194176) === L || ll.current === null)) { + Fa = true; + } + if (((Il & 134217727) !== 0 || (ha & 134217727) !== 0) && ut !== null) { + Tl(ut, L, al, false); + } + } + function Qn(t, l, a) { + var e = tt; + tt |= 2; + var u = Yi(); + var n = Gi(); + if (ut !== t || L !== l) { + Uu = null; + Aa(t, l); + } + l = false; + var i = St; + t: do { + try { + if (nt !== 0 && K !== null) { + var v = K; + var d = Pt; + switch (nt) { + case 8: + qn(); + i = 6; + break t; + case 3: + case 2: + case 6: + if (ll.current === null) { + l = true; + } + var E = nt; + nt = 0; + Pt = null; + ja(t, v, d, E); + if (a && Fa) { + i = 0; + break t; + } + break; + default: + E = nt; + nt = 0; + Pt = null; + ja(t, v, d, E); + } + } + Vm(); + i = St; + break; + } catch (H) { + Bi(t, H); + } + } while (true); + if (l) { + t.shellSuspendCounter++; + } + Ul = ya = null; + tt = e; + q.H = u; + q.A = n; + if (K === null) { + ut = null; + L = 0; + Be(); + } + return i; + } + function Vm() { + while (K !== null) { + Vi(K); + } + } + function Xm(t, l) { + var a = tt; + tt |= 2; + var e = Yi(); + var u = Gi(); + if (ut !== t || L !== l) { + Uu = null; + Ae = fl() + 500; + Aa(t, l); + } else { + Fa = B(t, l); + } + t: do { + try { + if (nt !== 0 && K !== null) { + l = K; + var n = Pt; + l: switch (nt) { + case 1: + nt = 0; + Pt = null; + ja(t, l, n, 1); + break; + case 2: + if (ef(n)) { + nt = 0; + Pt = null; + Xi(l); + break; + } + l = function () { + if (nt === 2 && ut === t) { + nt = 7; + } + vl(t); + }; + n.then(l, l); + break t; + case 3: + nt = 7; + break t; + case 4: + nt = 5; + break t; + case 7: + if (ef(n)) { + nt = 0; + Pt = null; + Xi(l); + } else { + nt = 0; + Pt = null; + ja(t, l, n, 7); + } + break; + case 5: + var i = null; + switch (K.tag) { + case 26: + i = K.memoizedState; + case 5: + case 27: + var v = K; + var d = v.type; + var E = v.pendingProps; + if (i ? _s(i) : ss(d, E)) { + nt = 0; + Pt = null; + var H = v.sibling; + if (H !== null) { + K = H; + } else { + var r = v.return; + if (r !== null) { + K = r; + au(r); + } else { + K = null; + } + } + break l; + } + } + nt = 0; + Pt = null; + ja(t, l, n, 5); + break; + case 6: + nt = 0; + Pt = null; + ja(t, l, n, 6); + break; + case 8: + qn(); + St = 6; + break t; + default: + throw Error(m(462)); + } + } + Zm(); + break; + } catch (j) { + Bi(t, j); + } + } while (true); + Ul = ya = null; + q.H = e; + q.A = u; + tt = a; + if (K !== null) { + return 0; + } else { + ut = null; + L = 0; + Be(); + return St; + } + } + function Zm() { + while (K !== null && !hp()) { + Vi(K); + } + } + function Vi(t) { + var l = fi(t.alternate, t, Al); + t.memoizedProps = t.pendingProps; + if (l === null) { + au(t); + } else { + K = l; + } + } + function Xi(t) { + var l = t; + var a = l.alternate; + switch (l.tag) { + case 15: + case 0: + l = li(a, l, l.pendingProps, l.type, undefined, L); + break; + case 11: + l = li(a, l, l.pendingProps, l.type.render, l.ref, L); + break; + case 5: + Pu(l); + default: + di(a, l); + l = K = Wi(l, Al); + l = fi(a, l, Al); + } + t.memoizedProps = t.pendingProps; + if (l === null) { + au(t); + } else { + K = l; + } + } + function ja(t, l, a, e) { + Ul = ya = null; + Pu(l); + Ka = null; + He = 0; + var u = l.return; + try { + if (Rm(t, u, l, a, L)) { + St = 1; + Pe(t, Rt(a, t.current)); + K = null; + return; + } + } catch (n) { + if (u !== null) { + K = u; + throw n; + } + St = 1; + Pe(t, Rt(a, t.current)); + K = null; + return; + } + if (l.flags & 32768) { + if (P || e === 1) { + t = true; + } else if (Fa || (L & 536870912) !== 0) { + t = false; + } else { + rl = t = true; + if (e === 2 || e === 3 || e === 6) { + e = ll.current; + if (e !== null && e.tag === 13) { + e.flags |= 16384; + } + } + } + Zi(l, t); + } else { + au(l); + } + } + function au(t) { + var l = t; + do { + if ((l.flags & 32768) !== 0) { + Zi(l, rl); + return; + } + t = l.return; + var a = qm(l.alternate, l, Al); + if (a !== null) { + K = a; + return; + } + l = l.sibling; + if (l !== null) { + K = l; + return; + } + K = l = t; + } while (l !== null); + if (St === 0) { + St = 5; + } + } + function Zi(t, l) { + do { + var a = Bm(t.alternate, t); + if (a !== null) { + a.flags &= 32767; + K = a; + return; + } + a = t.return; + if (a !== null) { + a.flags |= 32768; + a.subtreeFlags = 0; + a.deletions = null; + } + if (!l && (t = t.sibling, t !== null)) { + K = t; + return; + } + K = t = a; + } while (t !== null); + St = 6; + K = null; + } + function Ki(t, l, a, e, u, n, i, v, d, E) { + var H = q.T; + var r = ia(); + try { + Gt(2); + q.T = null; + Km(t, l, a, e, r, u, n, i, v, d, E); + } finally { + q.T = H; + Gt(r); + } + } + function Km(t, l, a, e, u, n, i, v) { + do { + ca(); + } while (Ea !== null); + if ((tt & 6) !== 0) { + throw Error(m(327)); + } + var d = t.finishedWork; + e = t.finishedLanes; + if (d === null) { + return null; + } + t.finishedWork = null; + t.finishedLanes = 0; + if (d === t.current) { + throw Error(m(177)); + } + t.callbackNode = null; + t.callbackPriority = 0; + t.cancelPendingCommit = null; + var E = d.lanes | d.childLanes; + E |= cc; + Ma(t, e, E, n, i, v); + if (t === ut) { + K = ut = null; + L = 0; + } + if (((d.subtreeFlags & 10256) !== 0 || (d.flags & 10256) !== 0) && !_u) { + _u = true; + Nc = E; + Tc = a; + Wm(uc, function () { + ca(); + return null; + }); + } + a = (d.flags & 15990) !== 0; + if ((d.subtreeFlags & 15990) !== 0 || a) { + a = q.T; + q.T = null; + n = ia(); + Gt(2); + i = tt; + tt |= 4; + Qm(t, d); + Hi(d, t); + cv(t.containerInfo); + t.current = d; + Ti(t, d.alternate, d); + Ep(); + tt = i; + Gt(n); + q.T = a; + } else { + t.current = d; + } + if (_u) { + _u = false; + Ea = t; + je = e; + } else { + xi(t, E); + } + E = t.pendingLanes; + if (E === 0) { + $l = null; + } + Ce(d.stateNode); + vl(t); + if (l !== null) { + u = t.onRecoverableError; + d = 0; + for (; d < l.length; d++) { + E = l[d]; + u(E.value, { + componentStack: E.stack + }); + } + } + if ((je & 3) !== 0) { + ca(); + } + E = t.pendingLanes; + if ((e & 4194218) !== 0 && (E & 42) !== 0) { + if (t === Mc) { + ge++; + } else { + ge = 0; + Mc = t; + } + } else { + ge = 0; + } + Ha(0); + return null; + } + function xi(t, l) { + if ((t.pooledCacheLanes &= l) === 0) { + l = t.pooledCache; + if (l != null) { + t.pooledCache = null; + pe(l); + } + } + } + function ca() { + if (Ea !== null) { + var t = Ea; + var l = Nc; + Nc = 0; + var a = ul(je); + var e = a < 32 ? 32 : a; + a = q.T; + var u = ia(); + try { + Gt(e); + q.T = null; + if (Ea === null) { + var n = false; + } else { + e = Tc; + Tc = null; + var i = Ea; + var v = je; + Ea = null; + je = 0; + if ((tt & 6) !== 0) { + throw Error(m(331)); + } + var d = tt; + tt |= 4; + ji(i.current); + _i(i, i.current, v, e); + tt = d; + Ha(0, false); + if (Lt && typeof Lt.onPostCommitFiberRoot == "function") { + try { + Lt.onPostCommitFiberRoot(Ne, i); + } catch {} + } + n = true; + } + return n; + } finally { + Gt(u); + q.T = a; + xi(t, l); + } + } + return false; + } + function Ji(t, l, a) { + l = Rt(a, l); + l = fn(t.stateNode, l, 2); + t = ql(t, l, 2); + if (t !== null) { + et(t, 2); + vl(t); + } + } + function w(t, l, a) { + if (t.tag === 3) { + Ji(t, t, a); + } else { + while (l !== null) { + if (l.tag === 3) { + Ji(l, t, a); + break; + } else if (l.tag === 1) { + var e = l.stateNode; + if (typeof l.type.getDerivedStateFromError == "function" || typeof e.componentDidCatch == "function" && ($l === null || !$l.has(e))) { + t = Rt(a, t); + a = Ff(2); + e = ql(l, a, 2); + if (e !== null) { + Pf(a, e, l, t); + et(e, 2); + vl(e); + } + break; + } + } + l = l.return; + } + } + } + function Yn(t, l, a) { + var e = t.pingCache; + if (e === null) { + e = t.pingCache = new jp(); + var u = new Set(); + e.set(l, u); + } else { + u = e.get(l); + if (u === undefined) { + u = new Set(); + e.set(l, u); + } + } + if (!u.has(a)) { + Sc = true; + u.add(a); + t = xm.bind(null, t, l, a); + l.then(t, t); + } + } + function xm(t, l, a) { + var e = t.pingCache; + if (e !== null) { + e.delete(l); + } + t.pingedLanes |= t.suspendedLanes & a; + t.warmLanes &= ~a; + if (ut === t && (L & a) === a) { + if (St === 4 || St === 3 && (L & 62914560) === L && fl() - zc < 300) { + if ((tt & 2) === 0) { + Aa(t, 0); + } + } else { + hc |= a; + } + if (Pa === L) { + Pa = 0; + } + } + vl(t); + } + function Li(t, l) { + if (l === 0) { + l = at(); + } + t = Rl(t, l); + if (t !== null) { + et(t, l); + vl(t); + } + } + function Jm(t) { + var l = t.memoizedState; + var a = 0; + if (l !== null) { + a = l.retryLane; + } + Li(t, a); + } + function Lm(t, l) { + var a = 0; + switch (t.tag) { + case 13: + var e = t.stateNode; + var u = t.memoizedState; + if (u !== null) { + a = u.retryLane; + } + break; + case 19: + e = t.stateNode; + break; + case 22: + e = t.stateNode._retryCache; + break; + default: + throw Error(m(314)); + } + if (e !== null) { + e.delete(l); + } + Li(t, a); + } + function Wm(t, l) { + return su(t, l); + } + function Fm(t, l, a, e) { + this.tag = t; + this.key = a; + this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null; + this.index = 0; + this.refCleanup = this.ref = null; + this.pendingProps = l; + this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null; + this.mode = e; + this.subtreeFlags = this.flags = 0; + this.deletions = null; + this.childLanes = this.lanes = 0; + this.alternate = null; + } + function Gn(t) { + t = t.prototype; + return !!t && !!t.isReactComponent; + } + function Zl(t, l) { + var a = t.alternate; + if (a === null) { + a = s(t.tag, l, t.key, t.mode); + a.elementType = t.elementType; + a.type = t.type; + a.stateNode = t.stateNode; + a.alternate = t; + t.alternate = a; + } else { + a.pendingProps = l; + a.type = t.type; + a.flags = 0; + a.subtreeFlags = 0; + a.deletions = null; + } + a.flags = t.flags & 31457280; + a.childLanes = t.childLanes; + a.lanes = t.lanes; + a.child = t.child; + a.memoizedProps = t.memoizedProps; + a.memoizedState = t.memoizedState; + a.updateQueue = t.updateQueue; + l = t.dependencies; + a.dependencies = l === null ? null : { + lanes: l.lanes, + firstContext: l.firstContext + }; + a.sibling = t.sibling; + a.index = t.index; + a.ref = t.ref; + a.refCleanup = t.refCleanup; + return a; + } + function Wi(t, l) { + t.flags &= 31457282; + var a = t.alternate; + if (a === null) { + t.childLanes = 0; + t.lanes = l; + t.child = null; + t.subtreeFlags = 0; + t.memoizedProps = null; + t.memoizedState = null; + t.updateQueue = null; + t.dependencies = null; + t.stateNode = null; + } else { + t.childLanes = a.childLanes; + t.lanes = a.lanes; + t.child = a.child; + t.subtreeFlags = 0; + t.deletions = null; + t.memoizedProps = a.memoizedProps; + t.memoizedState = a.memoizedState; + t.updateQueue = a.updateQueue; + t.type = a.type; + l = a.dependencies; + t.dependencies = l === null ? null : { + lanes: l.lanes, + firstContext: l.firstContext + }; + } + return t; + } + function eu(t, l, a, e, u, n) { + var i = 0; + e = t; + if (typeof t == "function") { + if (Gn(t)) { + i = 1; + } + } else if (typeof t == "string") { + i = $t && Dt ? Ns(t, a, At.current) ? 26 : As(t) ? 27 : 5 : $t ? Ns(t, a, At.current) ? 26 : 5 : Dt && As(t) ? 27 : 5; + } else { + t: switch (t) { + case Da: + return fa(a.children, u, n, l); + case ts: + i = 8; + u |= 24; + break; + case xn: + t = s(12, a, l, u | 2); + t.elementType = xn; + t.lanes = n; + return t; + case Ln: + t = s(13, a, l, u); + t.elementType = Ln; + t.lanes = n; + return t; + case Wn: + t = s(19, a, l, u); + t.elementType = Wn; + t.lanes = n; + return t; + case as: + return Fi(a, u, n, l); + default: + if (typeof t == "object" && t !== null) { + switch (t.$$typeof) { + case wm: + case Kl: + i = 10; + break t; + case ls: + i = 9; + break t; + case Jn: + i = 11; + break t; + case Fn: + i = 14; + break t; + case xl: + i = 16; + e = null; + break t; + } + } + i = 29; + a = Error(m(130, t === null ? "null" : typeof t, "")); + e = null; + } + } + l = s(i, a, l, u); + l.elementType = t; + l.type = e; + l.lanes = n; + return l; + } + function fa(t, l, a, e) { + t = s(7, t, e, l); + t.lanes = a; + return t; + } + function Fi(t, l, a, e) { + t = s(22, t, e, l); + t.elementType = as; + t.lanes = a; + var u = { + _visibility: 1, + _pendingVisibility: 1, + _pendingMarkers: null, + _retryCache: null, + _transitions: null, + _current: null, + detach: function () { + var n = u._current; + if (n === null) { + throw Error(m(456)); + } + if ((u._pendingVisibility & 2) === 0) { + var i = Rl(n, 2); + if (i !== null) { + u._pendingVisibility |= 2; + Ct(i, n, 2); + } + } + }, + attach: function () { + var n = u._current; + if (n === null) { + throw Error(m(456)); + } + if ((u._pendingVisibility & 2) !== 0) { + var i = Rl(n, 2); + if (i !== null) { + u._pendingVisibility &= -3; + Ct(i, n, 2); + } + } + } + }; + t.stateNode = u; + return t; + } + function Vn(t, l, a) { + t = s(6, t, null, l); + t.lanes = a; + return t; + } + function Xn(t, l, a) { + l = s(4, t.children !== null ? t.children : [], t.key, l); + l.lanes = a; + l.stateNode = { + containerInfo: t.containerInfo, + pendingChildren: null, + implementation: t.implementation + }; + return l; + } + function Pm(t, l, a, e, u, n, i, v) { + this.tag = 1; + this.containerInfo = t; + this.finishedWork = this.pingCache = this.current = this.pendingChildren = null; + this.timeoutHandle = wn; + this.callbackNode = this.next = this.pendingContext = this.context = this.cancelPendingCommit = null; + this.callbackPriority = 0; + this.expirationTimes = st(-1); + this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.finishedLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0; + this.entanglements = st(0); + this.hiddenUpdates = st(null); + this.identifierPrefix = e; + this.onUncaughtError = u; + this.onCaughtError = n; + this.onRecoverableError = i; + this.pooledCache = null; + this.pooledCacheLanes = 0; + this.formState = v; + this.incompleteTransitions = new Map(); + } + function Pi(t, l, a, e, u, n, i, v, d, E, H, r) { + t = new Pm(t, l, a, i, v, d, E, r); + l = 1; + if (n === true) { + l |= 24; + } + n = s(3, null, null, l); + t.current = n; + n.stateNode = t; + l = zn(); + l.refCount++; + t.pooledCache = l; + l.refCount++; + n.memoizedState = { + element: e, + isDehydrated: a, + cache: l + }; + Vu(n); + return t; + } + function Ii(t) { + if (t) { + t = Ca; + return t; + } else { + return Ca; + } + } + function $i(t) { + var l = t._reactInternals; + if (l === undefined) { + throw typeof t.render == "function" ? Error(m(188)) : (t = Object.keys(t).join(","), Error(m(268, t))); + } + t = b(l); + t = t !== null ? W(t) : null; + if (t === null) { + return null; + } else { + return he(t.stateNode); + } + } + function wi(t, l, a, e, u, n) { + u = Ii(u); + if (e.context === null) { + e.context = u; + } else { + e.pendingContext = u; + } + e = Cl(l); + e.payload = { + element: a + }; + n = n === undefined ? null : n; + if (n !== null) { + e.callback = n; + } + a = ql(t, e, l); + if (a !== null) { + Ct(a, t, l); + ue(a, t, l); + } + } + function ki(t, l) { + t = t.memoizedState; + if (t !== null && t.dehydrated !== null) { + var a = t.retryLane; + t.retryLane = a !== 0 && a < l ? a : l; + } + } + function Zn(t, l) { + ki(t, l); + if (t = t.alternate) { + ki(t, l); + } + } + var Z = {}; + var Im = xc(); + var xt = um(); + var Kn = Object.assign; + var $m = Symbol.for("react.element"); + var uu = Symbol.for("react.transitional.element"); + var ga = Symbol.for("react.portal"); + var Da = Symbol.for("react.fragment"); + var ts = Symbol.for("react.strict_mode"); + var xn = Symbol.for("react.profiler"); + var wm = Symbol.for("react.provider"); + var ls = Symbol.for("react.consumer"); + var Kl = Symbol.for("react.context"); + var Jn = Symbol.for("react.forward_ref"); + var Ln = Symbol.for("react.suspense"); + var Wn = Symbol.for("react.suspense_list"); + var Fn = Symbol.for("react.memo"); + var xl = Symbol.for("react.lazy"); + var as = Symbol.for("react.offscreen"); + var km = Symbol.for("react.memo_cache_sentinel"); + var es = Symbol.iterator; + var tv = Symbol.for("react.client.reference"); + var q = Im.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE; + var Pn; + var us; + var In = false; + var nu = Array.isArray; + var lv = c.rendererVersion; + var av = c.rendererPackageName; + var ns = c.extraDevToolsConfig; + var he = c.getPublicInstance; + var ev = c.getRootHostContext; + var uv = c.getChildHostContext; + var nv = c.prepareForCommit; + var cv = c.resetAfterCommit; + var fv = c.createInstance; + var $n = c.appendInitialChild; + var cs = c.finalizeInitialChildren; + var cu = c.shouldSetTextContent; + var fs = c.createTextInstance; + var iv = c.scheduleTimeout; + var sv = c.cancelTimeout; + var wn = c.noTimeout; + var Ml = c.isPrimaryRenderer; + c.warnsIfNotActing; + var gt = c.supportsMutation; + var Jl = c.supportsPersistence; + var It = c.supportsHydration; + var is = c.getInstanceFromNode; + c.beforeActiveInstanceBlur; + c.afterActiveInstanceBlur; + var mv = c.preparePortalMount; + c.prepareScopeUpdate; + c.getInstanceFromScope; + var Gt = c.setCurrentUpdatePriority; + var ia = c.getCurrentUpdatePriority; + var vv = c.resolveUpdatePriority; + c.resolveEventType; + c.resolveEventTimeStamp; + var pv = c.shouldAttemptEagerTransition; + var ov = c.detachDeletedInstance; + c.requestPostPaintCallback; + var dv = c.maySuspendCommit; + var ss = c.preloadInstance; + var yv = c.startSuspendingCommit; + var ms = c.suspendInstance; + var Sv = c.waitForCommitToBeReady; + var ba = c.NotPendingTransition; + var sa = c.HostTransitionContext; + var hv = c.resetFormInstance; + c.bindToConsole; + var Ev = c.supportsMicrotasks; + var zv = c.scheduleMicrotask; + var Ee = c.supportsTestSelectors; + var Nv = c.findFiberRoot; + var Tv = c.getBoundingRect; + var Mv = c.getTextContent; + var ze = c.isHiddenSubtree; + var Ov = c.matchAccessibilityRole; + var Hv = c.setFocusIfFocusable; + var Uv = c.setupIntersectionObserver; + var _v = c.appendChild; + var rv = c.appendChildToContainer; + var Av = c.commitTextUpdate; + var jv = c.commitMount; + var gv = c.commitUpdate; + var Dv = c.insertBefore; + var bv = c.insertInContainerBefore; + var Rv = c.removeChild; + var Cv = c.removeChildFromContainer; + var vs = c.resetTextContent; + var qv = c.hideInstance; + var Bv = c.hideTextInstance; + var Qv = c.unhideInstance; + var Yv = c.unhideTextInstance; + var Gv = c.clearContainer; + var Vv = c.cloneInstance; + var ps = c.createContainerChildSet; + var os = c.appendChildToContainerChildSet; + var Xv = c.finalizeContainerChildren; + var ds = c.replaceContainerChildren; + var ys = c.cloneHiddenInstance; + var Ss = c.cloneHiddenTextInstance; + var kn = c.isSuspenseInstancePending; + var tc = c.isSuspenseInstanceFallback; + var Zv = c.getSuspenseInstanceFallbackErrorDetails; + var Kv = c.registerSuspenseInstanceRetry; + var xv = c.canHydrateFormStateMarker; + var Jv = c.isFormStateMarkerMatching; + var hs = c.getNextHydratableSibling; + var Es = c.getFirstHydratableChild; + var Lv = c.getFirstHydratableChildWithinContainer; + var Wv = c.getFirstHydratableChildWithinSuspenseInstance; + var Fv = c.canHydrateInstance; + var Pv = c.canHydrateTextInstance; + var Iv = c.canHydrateSuspenseInstance; + var $v = c.hydrateInstance; + var wv = c.hydrateTextInstance; + var kv = c.hydrateSuspenseInstance; + var tp = c.getNextHydratableInstanceAfterSuspenseInstance; + var lp = c.commitHydratedContainer; + var ap = c.commitHydratedSuspenseInstance; + var ep = c.clearSuspenseBoundary; + var up = c.clearSuspenseBoundaryFromContainer; + var zs = c.shouldDeleteUnhydratedTailInstances; + c.diffHydratedPropsForDevWarnings; + c.diffHydratedTextForDevWarnings; + c.describeHydratableInstanceForDevWarnings; + var np = c.validateHydratableInstance; + var cp = c.validateHydratableTextInstance; + var $t = c.supportsResources; + var Ns = c.isHostHoistableType; + var lc = c.getHoistableRoot; + var Ts = c.getResource; + var Ms = c.acquireResource; + var Os = c.releaseResource; + var fp = c.hydrateHoistable; + var Hs = c.mountHoistable; + var Us = c.unmountHoistable; + var ip = c.createHoistableInstance; + var sp = c.prepareToCommitHoistables; + var mp = c.mayResourceSuspendCommit; + var _s = c.preloadResource; + var vp = c.suspendResource; + var Dt = c.supportsSingletons; + var rs = c.resolveSingletonInstance; + var pp = c.clearSingleton; + var op = c.acquireSingletonInstance; + var dp = c.releaseSingletonInstance; + var As = c.isHostSingletonType; + var ac = []; + var Ra = -1; + var Ca = {}; + var Jt = Math.clz32 ? Math.clz32 : X; + var yp = Math.log; + var Sp = Math.LN2; + var fu = 128; + var iu = 4194304; + var su = xt.unstable_scheduleCallback; + var ec = xt.unstable_cancelCallback; + var hp = xt.unstable_shouldYield; + var Ep = xt.unstable_requestPaint; + var fl = xt.unstable_now; + var js = xt.unstable_ImmediatePriority; + var zp = xt.unstable_UserBlockingPriority; + var uc = xt.unstable_NormalPriority; + var Np = xt.unstable_IdlePriority; + var Tp = xt.log; + var Mp = xt.unstable_setDisableYieldValue; + var Ne = null; + var Lt = null; + var Wt = typeof Object.is == "function" ? Object.is : ta; + var gs = new WeakMap(); + var qa = []; + var Ba = 0; + var mu = null; + var vu = 0; + var wt = []; + var kt = 0; + var ma = null; + var Ol = 1; + var Hl = ""; + var At = V(null); + var Te = V(null); + var Ll = V(null); + var pu = V(null); + var qt = null; + var bt = null; + var P = false; + var il = null; + var pl = false; + var nc = Error(m(519)); + var tl = []; + var Qa = 0; + var cc = 0; + var ou = null; + var Ya = null; + var fc = false; + var du = false; + var ic = false; + var Ga = 0; + var Me = null; + var sc = 0; + var Va = 0; + var Xa = null; + var Wl = false; + var mc = false; + var Op = Object.prototype.hasOwnProperty; + var Oe = Error(m(460)); + var vc = Error(m(474)); + var yu = { + then: function () {} + }; + var Za = null; + var Ka = null; + var He = 0; + var va = ff(true); + var Ds = ff(false); + var xa = V(null); + var Su = V(0); + var ll = V(null); + var ol = null; + var Ot = V(0); + var Fl = 0; + var G = null; + var k = null; + var Nt = null; + var hu = false; + var Ja = false; + var pa = false; + var Eu = 0; + var Ue = 0; + var La = null; + var Hp = 0; + function pc() { + return { + lastEffect: null, + events: null, + stores: null, + memoCache: null + }; + } + var dl = { + readContext: jt, + use: xe, + useCallback: Et, + useContext: Et, + useEffect: Et, + useImperativeHandle: Et, + useLayoutEffect: Et, + useInsertionEffect: Et, + useMemo: Et, + useReducer: Et, + useRef: Et, + useState: Et, + useDebugValue: Et, + useDeferredValue: Et, + useTransition: Et, + useSyncExternalStore: Et, + useId: Et + }; + dl.useCacheRefresh = Et; + dl.useMemoCache = Et; + dl.useHostTransitionStatus = Et; + dl.useFormState = Et; + dl.useActionState = Et; + dl.useOptimistic = Et; + var oa = { + readContext: jt, + use: xe, + useCallback: function (t, l) { + Qt().memoizedState = [t, l === undefined ? null : l]; + return t; + }, + useContext: jt, + useEffect: gf, + useImperativeHandle: function (t, l, a) { + a = a != null ? a.concat([t]) : null; + Le(4194308, 4, Rf.bind(null, l, t), a); + }, + useLayoutEffect: function (t, l) { + return Le(4194308, 4, t, l); + }, + useInsertionEffect: function (t, l) { + Le(4, 2, t, l); + }, + useMemo: function (t, l) { + var a = Qt(); + l = l === undefined ? null : l; + var e = t(); + if (pa) { + nl(true); + try { + t(); + } finally { + nl(false); + } + } + a.memoizedState = [e, l]; + return e; + }, + useReducer: function (t, l, a) { + var e = Qt(); + if (a !== undefined) { + var u = a(l); + if (pa) { + nl(true); + try { + a(l); + } finally { + nl(false); + } + } + } else { + u = l; + } + e.memoizedState = e.baseState = u; + t = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: t, + lastRenderedState: u + }; + e.queue = t; + t = t.dispatch = bm.bind(null, G, t); + return [e.memoizedState, t]; + }, + useRef: function (t) { + var l = Qt(); + t = { + current: t + }; + return l.memoizedState = t; + }, + useState: function (t) { + t = ku(t); + var l = t.queue; + var a = Zf.bind(null, G, l); + l.dispatch = a; + return [t.memoizedState, a]; + }, + useDebugValue: an, + useDeferredValue: function (t, l) { + var a = Qt(); + return en(a, t, l); + }, + useTransition: function () { + var t = ku(false); + t = Yf.bind(null, G, t.queue, true, false); + Qt().memoizedState = t; + return [false, t]; + }, + useSyncExternalStore: function (t, l, a) { + var e = G; + var u = Qt(); + if (P) { + if (a === undefined) { + throw Error(m(407)); + } + a = a(); + } else { + a = l(); + if (ut === null) { + throw Error(m(349)); + } + if ((L & 60) === 0) { + df(e, l, a); + } + } + u.memoizedState = a; + var n = { + value: a, + getSnapshot: l + }; + u.queue = n; + gf(Sf.bind(null, e, n, t), [t]); + e.flags |= 2048; + Ua(9, yf.bind(null, e, n, a, l), { + destroy: undefined + }, null); + return a; + }, + useId: function () { + var t = Qt(); + var l = ut.identifierPrefix; + if (P) { + var a = Hl; + var e = Ol; + a = (e & ~(1 << 32 - Jt(e) - 1)).toString(32) + a; + l = ":" + l + "R" + a; + a = Eu++; + if (a > 0) { + l += "H" + a.toString(32); + } + l += ":"; + } else { + a = Hp++; + l = ":" + l + "r" + a.toString(32) + ":"; + } + return t.memoizedState = l; + }, + useCacheRefresh: function () { + return Qt().memoizedState = Dm.bind(null, G); + } + }; + oa.useMemoCache = Iu; + oa.useHostTransitionStatus = un; + oa.useFormState = Uf; + oa.useActionState = Uf; + oa.useOptimistic = function (t) { + var l = Qt(); + l.memoizedState = l.baseState = t; + var a = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: null, + lastRenderedState: null + }; + l.queue = a; + l = nn.bind(null, G, true, a); + a.dispatch = l; + return [t, l]; + }; + var Pl = { + readContext: jt, + use: xe, + useCallback: qf, + useContext: jt, + useEffect: ln, + useImperativeHandle: Cf, + useInsertionEffect: Df, + useLayoutEffect: bf, + useMemo: Bf, + useReducer: Je, + useRef: jf, + useState: function () { + return Je(hl); + }, + useDebugValue: an, + useDeferredValue: function (t, l) { + var a = zt(); + return Qf(a, k.memoizedState, t, l); + }, + useTransition: function () { + var t = Je(hl)[0]; + var l = zt().memoizedState; + return [typeof t == "boolean" ? t : ie(t), l]; + }, + useSyncExternalStore: of, + useId: Vf + }; + Pl.useCacheRefresh = Xf; + Pl.useMemoCache = Iu; + Pl.useHostTransitionStatus = un; + Pl.useFormState = _f; + Pl.useActionState = _f; + Pl.useOptimistic = function (t, l) { + var a = zt(); + return zf(a, k, t, l); + }; + var da = { + readContext: jt, + use: xe, + useCallback: qf, + useContext: jt, + useEffect: ln, + useImperativeHandle: Cf, + useInsertionEffect: Df, + useLayoutEffect: bf, + useMemo: Bf, + useReducer: wu, + useRef: jf, + useState: function () { + return wu(hl); + }, + useDebugValue: an, + useDeferredValue: function (t, l) { + var a = zt(); + if (k === null) { + return en(a, t, l); + } else { + return Qf(a, k.memoizedState, t, l); + } + }, + useTransition: function () { + var t = wu(hl)[0]; + var l = zt().memoizedState; + return [typeof t == "boolean" ? t : ie(t), l]; + }, + useSyncExternalStore: of, + useId: Vf + }; + da.useCacheRefresh = Xf; + da.useMemoCache = Iu; + da.useHostTransitionStatus = un; + da.useFormState = Af; + da.useActionState = Af; + da.useOptimistic = function (t, l) { + var a = zt(); + if (k !== null) { + return zf(a, k, t, l); + } else { + a.baseState = t; + return [t, a.queue.dispatch]; + } + }; + var oc = { + isMounted: function (t) { + if (t = t._reactInternals) { + return O(t) === t; + } else { + return false; + } + }, + enqueueSetState: function (t, l, a) { + t = t._reactInternals; + var e = Kt(); + var u = Cl(e); + u.payload = l; + if (a != null) { + u.callback = a; + } + l = ql(t, u, e); + if (l !== null) { + Ct(l, t, e); + ue(l, t, e); + } + }, + enqueueReplaceState: function (t, l, a) { + t = t._reactInternals; + var e = Kt(); + var u = Cl(e); + u.tag = 1; + u.payload = l; + if (a != null) { + u.callback = a; + } + l = ql(t, u, e); + if (l !== null) { + Ct(l, t, e); + ue(l, t, e); + } + }, + enqueueForceUpdate: function (t, l) { + t = t._reactInternals; + var a = Kt(); + var e = Cl(a); + e.tag = 2; + if (l != null) { + e.callback = l; + } + l = ql(t, e, a); + if (l !== null) { + Ct(l, t, a); + ue(l, t, a); + } + } + }; + var bs = typeof reportError == "function" ? reportError : function (t) { + if (typeof window == "object" && typeof window.ErrorEvent == "function") { + var l = new window.ErrorEvent("error", { + bubbles: true, + cancelable: true, + message: typeof t == "object" && t !== null && typeof t.message == "string" ? String(t.message) : String(t), + error: t + }); + if (!window.dispatchEvent(l)) { + return; + } + } else if (typeof process == "object" && typeof process.emit == "function") { + process.emit("uncaughtException", t); + return; + } + console.error(t); + }; + var Rs = Error(m(461)); + var Ht = false; + var dc = { + dehydrated: null, + treeContext: null, + retryLane: 0 + }; + var zu = V(null); + var ya = null; + var Ul = null; + var Up = typeof AbortController !== "undefined" ? AbortController : function () { + var t = []; + var l = this.signal = { + aborted: false, + addEventListener: function (a, e) { + t.push(e); + } + }; + this.abort = function () { + l.aborted = true; + t.forEach(function (a) { + return a(); + }); + }; + }; + var _p = xt.unstable_scheduleCallback; + var rp = xt.unstable_NormalPriority; + var dt = { + $$typeof: Kl, + Consumer: null, + Provider: null, + _currentValue: null, + _currentValue2: null, + _threadCount: 0 + }; + var Cs = q.S; + q.S = function (t, l) { + if (typeof l == "object" && l !== null && typeof l.then == "function") { + _m(t, l); + } + if (Cs !== null) { + Cs(t, l); + } + }; + var Sa = V(null); + var _l = false; + var yt = false; + var yc = false; + var qs = typeof WeakSet == "function" ? WeakSet : Set; + var Ut = null; + var Bs = false; + var Tt = null; + var Ft = false; + var sl = null; + var Wa = 8192; + var Ap = { + getCacheForType: function (t) { + var l = jt(dt); + var a = l.data.get(t); + if (a === undefined) { + a = t(); + l.data.set(t, a); + } + return a; + } + }; + var Nu = 0; + var Tu = 1; + var Mu = 2; + var Ou = 3; + var Hu = 4; + if (typeof Symbol == "function" && Symbol.for) { + var _e = Symbol.for; + Nu = _e("selector.component"); + Tu = _e("selector.has_pseudo_class"); + Mu = _e("selector.role"); + Ou = _e("selector.test_id"); + Hu = _e("selector.text"); + } + var jp = typeof WeakMap == "function" ? WeakMap : Map; + var tt = 0; + var ut = null; + var K = null; + var L = 0; + var nt = 0; + var Pt = null; + var rl = false; + var Fa = false; + var Sc = false; + var Al = 0; + var St = 0; + var Il = 0; + var ha = 0; + var hc = 0; + var al = 0; + var Pa = 0; + var re = null; + var yl = null; + var Ec = false; + var zc = 0; + var Ae = Infinity; + var Uu = null; + var $l = null; + var _u = false; + var Ea = null; + var je = 0; + var Nc = 0; + var Tc = null; + var ge = 0; + var Mc = null; + Z.attemptContinuousHydration = function (t) { + if (t.tag === 13) { + var l = Rl(t, 67108864); + if (l !== null) { + Ct(l, t, 67108864); + } + Zn(t, 67108864); + } + }; + Z.attemptHydrationAtCurrentPriority = function (t) { + if (t.tag === 13) { + var l = Kt(); + var a = Rl(t, l); + if (a !== null) { + Ct(a, t, l); + } + Zn(t, l); + } + }; + Z.attemptSynchronousHydration = function (t) { + switch (t.tag) { + case 3: + t = t.stateNode; + if (t.current.memoizedState.isDehydrated) { + var l = Y(t.pendingLanes); + if (l !== 0) { + t.pendingLanes |= 2; + t.entangledLanes |= 2; + while (l) { + var a = 1 << 31 - Jt(l); + t.entanglements[1] |= a; + l &= ~a; + } + vl(t); + if ((tt & 6) === 0) { + Ae = fl() + 500; + Ha(0); + } + } + } + break; + case 13: + l = Rl(t, 2); + if (l !== null) { + Ct(l, t, 2); + } + qi(); + Zn(t, 2); + } + }; + Z.batchedUpdates = function (t, l) { + return t(l); + }; + Z.createComponentSelector = function (t) { + return { + $$typeof: Nu, + value: t + }; + }; + Z.createContainer = function (t, l, a, e, u, n, i, v, d, E) { + return Pi(t, l, false, null, a, e, n, i, v, d, E, null); + }; + Z.createHasPseudoClassSelector = function (t) { + return { + $$typeof: Tu, + value: t + }; + }; + Z.createHydrationContainer = function (t, l, a, e, u, n, i, v, d, E, H, r, j) { + t = Pi(a, e, true, t, u, n, v, d, E, H, r, j); + t.context = Ii(null); + a = t.current; + e = Kt(); + u = Cl(e); + u.callback = l ?? null; + ql(a, u, e); + t.current.lanes = e; + et(t, e); + vl(t); + return t; + }; + Z.createPortal = function (t, l, a, e = null) { + return { + $$typeof: ga, + key: e == null ? null : "" + e, + children: t, + containerInfo: l, + implementation: a + }; + }; + Z.createRoleSelector = function (t) { + return { + $$typeof: Mu, + value: t + }; + }; + Z.createTestNameSelector = function (t) { + return { + $$typeof: Ou, + value: t + }; + }; + Z.createTextSelector = function (t) { + return { + $$typeof: Hu, + value: t + }; + }; + Z.defaultOnCaughtError = function (t) { + console.error(t); + }; + Z.defaultOnRecoverableError = function (t) { + bs(t); + }; + Z.defaultOnUncaughtError = function (t) { + bs(t); + }; + Z.deferredUpdates = function (t) { + var l = q.T; + var a = ia(); + try { + Gt(32); + q.T = null; + return t(); + } finally { + Gt(a); + q.T = l; + } + }; + Z.discreteUpdates = function (t, l, a, e, u) { + var n = q.T; + var i = ia(); + try { + Gt(2); + q.T = null; + return t(l, a, e, u); + } finally { + Gt(i); + q.T = n; + if (tt === 0) { + Ae = fl() + 500; + } + } + }; + Z.findAllNodes = Rn; + Z.findBoundingRects = function (t, l) { + if (!Ee) { + throw Error(m(363)); + } + l = Rn(t, l); + t = []; + for (var a = 0; a < l.length; a++) { + t.push(Tv(l[a])); + } + for (l = t.length - 1; l > 0; l--) { + a = t[l]; + var e = a.x; + var u = e + a.width; + var n = a.y; + var i = n + a.height; + for (var v = l - 1; v >= 0; v--) { + if (l !== v) { + var d = t[v]; + var E = d.x; + var H = E + d.width; + var r = d.y; + var j = r + d.height; + if (e >= E && n >= r && u <= H && i <= j) { + t.splice(l, 1); + break; + } else if (e !== E || a.width !== d.width || j < n || r > i) { + if (n === r && a.height === d.height && !(H < e) && !(E > u)) { + if (E > e) { + d.width += E - e; + d.x = e; + } + if (H < u) { + d.width = u - E; + } + t.splice(l, 1); + break; + } + } else { + if (r > n) { + d.height += r - n; + d.y = n; + } + if (j < i) { + d.height = i - r; + } + t.splice(l, 1); + break; + } + } + } + } + return t; + }; + Z.findHostInstance = $i; + Z.findHostInstanceWithNoPortals = function (t) { + t = b(t); + t = t !== null ? x(t) : null; + if (t === null) { + return null; + } else { + return he(t.stateNode); + } + }; + Z.findHostInstanceWithWarning = function (t) { + return $i(t); + }; + Z.flushPassiveEffects = ca; + Z.flushSyncFromReconciler = function (t) { + var l = tt; + tt |= 1; + var a = q.T; + var e = ia(); + try { + Gt(2); + q.T = null; + if (t) { + return t(); + } + } finally { + Gt(e); + q.T = a; + tt = l; + if ((tt & 6) === 0) { + Ha(0); + } + } + }; + Z.flushSyncWork = qi; + Z.focusWithin = function (t, l) { + if (!Ee) { + throw Error(m(363)); + } + t = gn(t); + l = Di(t, l); + l = Array.from(l); + t = 0; + while (t < l.length) { + var a = l[t++]; + var e = a.tag; + if (!ze(a)) { + if ((e === 5 || e === 26 || e === 27) && Hv(a.stateNode)) { + return true; + } + for (a = a.child; a !== null;) { + l.push(a); + a = a.sibling; + } + } + } + return false; + }; + Z.getFindAllNodesFailureDescription = function (t, l) { + if (!Ee) { + throw Error(m(363)); + } + var a = 0; + var e = []; + t = [gn(t), 0]; + for (var u = 0; u < t.length;) { + var n = t[u++]; + var i = n.tag; + var v = t[u++]; + var d = l[v]; + if ((i !== 5 && i !== 26 && i !== 27 || !ze(n)) && (Dn(n, d) && (e.push(bn(d)), v++, v > a && (a = v)), v < l.length)) { + for (n = n.child; n !== null;) { + t.push(n, v); + n = n.sibling; + } + } + } + if (a < l.length) { + for (t = []; a < l.length; a++) { + t.push(bn(l[a])); + } + return `findAllNodes was able to match part of the selector: + ${e.join(" > ")} + +No matching component was found for: + ${t.join(" > ")}`; + } + return null; + }; + Z.getPublicRootInstance = function (t) { + t = t.current; + if (!t.child) { + return null; + } + switch (t.child.tag) { + case 27: + case 5: + return he(t.child.stateNode); + default: + return t.child.stateNode; + } + }; + Z.injectIntoDevTools = function () { + var t = { + bundleType: 0, + version: lv, + rendererPackageName: av, + currentDispatcherRef: q, + findFiberByHostInstance: is, + reconcilerVersion: "19.0.0" + }; + if (ns !== null) { + t.rendererConfig = ns; + } + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") { + t = false; + } else { + var l = __REACT_DEVTOOLS_GLOBAL_HOOK__; + if (l.isDisabled || !l.supportsFiber) { + t = true; + } else { + try { + Ne = l.inject(t); + Lt = l; + } catch {} + t = !!l.checkDCE; + } + } + return t; + }; + Z.isAlreadyRendering = function () { + return false; + }; + Z.observeVisibleRects = function (t, l, a, e) { + if (!Ee) { + throw Error(m(363)); + } + t = Rn(t, l); + var u = Uv(t, a, e).disconnect; + return { + disconnect: function () { + u(); + } + }; + }; + Z.shouldError = function () { + return null; + }; + Z.shouldSuspend = function () { + return false; + }; + Z.startHostTransition = function (t, l, a, e) { + if (t.tag !== 5) { + throw Error(m(476)); + } + var u = Gf(t).queue; + Yf(t, u, l, ba, a === null ? p : function () { + var n = Gf(t).next.queue; + se(t, n, {}, Kt()); + return a(e); + }); + }; + Z.updateContainer = function (t, l, a, e) { + var u = l.current; + var n = Kt(); + wi(u, n, t, l, a, e); + return n; + }; + Z.updateContainerSync = function (t, l, a, e) { + if (l.tag === 0) { + ca(); + } + wi(l.current, 2, t, l, a, e); + return 2; + }; + return Z; + }; + f.exports.default = f.exports; + Object.defineProperty(f.exports, "__esModule", { + value: true + }); + })(gc); + } + return gc.exports; +} +var Ws; +function s0() { + if (!Ws) { + Ws = 1; + jc.exports = i0(); + } + return jc.exports; +} +var m0 = s0(); +const v0 = em(m0); +var Fs = um(); +const p0 = f => typeof f == "object" && typeof f.then == "function"; +const Na = []; +function cm(f, c, s = (p, m) => p === m) { + if (f === c) { + return true; + } + if (!f || !c) { + return false; + } + const p = f.length; + if (c.length !== p) { + return false; + } + for (let m = 0; m < p; m++) { + if (!s(f[m], c[m])) { + return false; + } + } + return true; +} +function fm(f, c = null, s = false, p = {}) { + if (c === null) { + c = [f]; + } + for (const h of Na) { + if (cm(c, h.keys, h.equal)) { + if (s) { + return; + } + if (Object.prototype.hasOwnProperty.call(h, "error")) { + throw h.error; + } + if (Object.prototype.hasOwnProperty.call(h, "response")) { + if (p.lifespan && p.lifespan > 0) { + if (h.timeout) { + clearTimeout(h.timeout); + } + h.timeout = setTimeout(h.remove, p.lifespan); + } + return h.response; + } + if (!s) { + throw h.promise; + } + } + } + const m = { + keys: c, + equal: p.equal, + remove: () => { + const h = Na.indexOf(m); + if (h !== -1) { + Na.splice(h, 1); + } + }, + promise: (p0(f) ? f : f(...c)).then(h => { + m.response = h; + if (p.lifespan && p.lifespan > 0) { + m.timeout = setTimeout(m.remove, p.lifespan); + } + }).catch(h => m.error = h) + }; + Na.push(m); + if (!s) { + throw m.promise; + } +} +const o0 = (f, c, s) => fm(f, c, false, s); +const d0 = (f, c, s) => void fm(f, c, true, s); +const y0 = f => { + if (f === undefined || f.length === 0) { + Na.splice(0, Na.length); + } else { + const c = Na.find(s => cm(f, s.keys, s.equal)); + if (c) { + c.remove(); + } + } +}; +function Jc(f, c, s) { + if (!f) { + return; + } + if (s(f) === true) { + return f; + } + let p = c ? f.return : f.child; + while (p) { + const m = Jc(p, c, s); + if (m) { + return m; + } + p = c ? null : p.sibling; + } +} +function im(f) { + try { + return Object.defineProperties(f, { + _currentRenderer: { + get() { + return null; + }, + set() {} + }, + _currentRenderer2: { + get() { + return null; + }, + set() {} + } + }); + } catch { + return f; + } +} +const Lc = im(lt.createContext(null)); +class S0 extends lt.Component { + render() { + return lt.createElement(Lc.Provider, { + value: this._reactInternals + }, this.props.children); + } +} +function sm() { + const f = lt.useContext(Lc); + if (f === null) { + throw new Error("its-fine: useFiber must be called within a !"); + } + const c = lt.useId(); + return lt.useMemo(() => { + for (const s of [f, f == null ? undefined : f.alternate]) { + if (!s) { + continue; + } + const p = Jc(s, false, m => { + let h = m.memoizedState; + while (h) { + if (h.memoizedState === c) { + return true; + } + h = h.next; + } + }); + if (p) { + return p; + } + } + }, [f, c]); +} +const h0 = Symbol.for("react.context"); +const E0 = f => f !== null && typeof f == "object" && "$$typeof" in f && f.$$typeof === h0; +function z0() { + const f = sm(); + const [c] = lt.useState(() => new Map()); + c.clear(); + let s = f; + while (s) { + const p = s.type; + if (E0(p) && p !== Lc && !c.has(p)) { + c.set(p, lt.use(im(p))); + } + s = s.return; + } + return c; +} +function N0() { + const f = z0(); + return lt.useMemo(() => Array.from(f.keys()).reduce((c, s) => p => lt.createElement(c, null, lt.createElement(s.Provider, { + ...p, + value: f.get(s) + })), c => lt.createElement(S0, { + ...c + })), [f]); +} +function mm(f) { + let c = f.root; + while (c.getState().previousRoot) { + c = c.getState().previousRoot; + } + return c; +} +const vm = f => f && f.isOrthographicCamera; +const lo = f => f && f.hasOwnProperty("current"); +const T0 = f => f != null && (typeof f == "string" || typeof f == "number" || f.isColor); +const Bu = ((f, c) => typeof window !== "undefined" && (((f = window.document) == null ? undefined : f.createElement) || ((c = window.navigator) == null ? undefined : c.product) === "ReactNative"))() ? lt.useLayoutEffect : lt.useEffect; +function M0(f) { + const c = lt.useRef(f); + Bu(() => void (c.current = f), [f]); + return c; +} +function ao() { + const f = sm(); + const _Component = N0(); + return lt.useMemo(() => ({ + children: s + }) => { + const _Component2 = Jc(f, true, h => h.type === lt.StrictMode) ? lt.StrictMode : lt.Fragment; + return <_Component2><_Component>{s}; + }, [f, _Component]); +} +function eo({ + set: f +}) { + Bu(() => { + f(new Promise(() => null)); + return () => f(false); + }, [f]); + return null; +} +const uo = (f => { + f = class extends lt.Component { + constructor(...s) { + super(...s); + this.state = { + error: false + }; + } + componentDidCatch(s) { + this.props.set(s); + } + render() { + if (this.state.error) { + return null; + } else { + return this.props.children; + } + } + }; + f.getDerivedStateFromError = () => ({ + error: true + }); + return f; +})(); +function pm(f) { + const s = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1; + if (Array.isArray(f)) { + return Math.min(Math.max(f[0], s), f[1]); + } else { + return f; + } +} +function Ia(f) { + var c; + if ((c = f.__r3f) == null) { + return undefined; + } else { + return c.root.getState(); + } +} +const it = { + obj: f => f === Object(f) && !it.arr(f) && typeof f != "function", + fun: f => typeof f == "function", + str: f => typeof f == "string", + num: f => typeof f == "number", + boo: f => typeof f == "boolean", + und: f => f === undefined, + nul: f => f === null, + arr: f => Array.isArray(f), + equ(f, c, { + arrays: s = "shallow", + objects: p = "reference", + strict: m = true + } = {}) { + if (typeof f != typeof c || !!f != !!c) { + return false; + } + if (it.str(f) || it.num(f) || it.boo(f)) { + return f === c; + } + const h = it.obj(f); + if (h && p === "reference") { + return f === c; + } + const T = it.arr(f); + if (T && s === "reference") { + return f === c; + } + if ((T || h) && f === c) { + return true; + } + let A; + for (A in f) { + if (!(A in c)) { + return false; + } + } + if (h && s === "shallow" && p === "shallow") { + for (A in m ? c : f) { + if (!it.equ(f[A], c[A], { + strict: m, + objects: "reference" + })) { + return false; + } + } + } else { + for (A in m ? c : f) { + if (f[A] !== c[A]) { + return false; + } + } + } + if (it.und(A)) { + if (T && f.length === 0 && c.length === 0 || h && Object.keys(f).length === 0 && Object.keys(c).length === 0) { + return true; + } + if (f !== c) { + return false; + } + } + return true; + } +}; +function O0(f) { + const c = { + nodes: {}, + materials: {}, + meshes: {} + }; + if (f) { + f.traverse(s => { + if (s.name) { + c.nodes[s.name] = s; + } + if (s.material && !c.materials[s.material.name]) { + c.materials[s.material.name] = s.material; + } + if (s.isMesh && !c.meshes[s.name]) { + c.meshes[s.name] = s; + } + }); + } + return c; +} +function H0(f) { + if (f.type !== "Scene") { + if (f.dispose != null) { + f.dispose(); + } + } + for (const c in f) { + const s = f[c]; + if ((s == null ? undefined : s.type) !== "Scene") { + if (s != null && s.dispose != null) { + s.dispose(); + } + } + } +} +const om = ["children", "key", "ref"]; +function U0(f) { + const c = {}; + for (const s in f) { + if (!om.includes(s)) { + c[s] = f[s]; + } + } + return c; +} +function bu(f, c, s, p) { + const m = f; + let h = m == null ? undefined : m.__r3f; + if (!h) { + h = { + root: c, + type: s, + parent: null, + children: [], + props: U0(p), + object: m, + eventCount: 0, + handlers: {}, + isHidden: false + }; + if (m) { + m.__r3f = h; + } + } + return h; +} +function Re(f, c) { + let s = f[c]; + if (!c.includes("-")) { + return { + root: f, + key: c, + target: s + }; + } + s = f; + for (const m of c.split("-")) { + var p; + c = m; + f = s; + s = (p = s) == null ? undefined : p[c]; + } + return { + root: f, + key: c, + target: s + }; +} +const Ps = /-\d+$/; +function Ru(f, c) { + if (it.str(c.props.attach)) { + if (Ps.test(c.props.attach)) { + const m = c.props.attach.replace(Ps, ""); + const { + root: h, + key: T + } = Re(f.object, m); + if (!Array.isArray(h[T])) { + h[T] = []; + } + } + const { + root: s, + key: p + } = Re(f.object, c.props.attach); + c.previousAttach = s[p]; + s[p] = c.object; + } else if (it.fun(c.props.attach)) { + c.previousAttach = c.props.attach(f.object, c.object); + } +} +function Cu(f, c) { + if (it.str(c.props.attach)) { + const { + root: s, + key: p + } = Re(f.object, c.props.attach); + const m = c.previousAttach; + if (m === undefined) { + delete s[p]; + } else { + s[p] = m; + } + } else if (c.previousAttach != null) { + c.previousAttach(f.object, c.object); + } + delete c.previousAttach; +} +const Yc = [...om, "args", "dispose", "attach", "object", "onUpdate", "dispose"]; +const Is = new Map(); +function _0(f) { + let c = Is.get(f.constructor); + try { + if (!c) { + c = new f.constructor(); + Is.set(f.constructor, c); + } + } catch {} + return c; +} +function r0(f, c) { + const s = {}; + for (const p in c) { + if (!Yc.includes(p) && !it.equ(c[p], f.props[p])) { + s[p] = c[p]; + for (const m in c) { + if (m.startsWith(`${p}-`)) { + s[m] = c[m]; + } + } + } + } + for (const p in f.props) { + if (Yc.includes(p) || c.hasOwnProperty(p)) { + continue; + } + const { + root: m, + key: h + } = Re(f.object, p); + if (m.constructor && m.constructor.length === 0) { + const T = _0(m); + if (!it.und(T)) { + s[h] = T[h]; + } + } else { + s[h] = 0; + } + } + return s; +} +const A0 = ["map", "emissiveMap", "sheenColorMap", "specularColorMap", "envMap"]; +const j0 = /^on(Pointer|Click|DoubleClick|ContextMenu|Wheel)/; +function kl(f, c) { + var s; + const p = f.__r3f; + const m = p && mm(p).getState(); + const h = p == null ? undefined : p.eventCount; + for (const A in c) { + let z = c[A]; + if (Yc.includes(A)) { + continue; + } + if (p && j0.test(A)) { + if (typeof z == "function") { + p.handlers[A] = z; + } else { + delete p.handlers[A]; + } + p.eventCount = Object.keys(p.handlers).length; + continue; + } + if (z === undefined) { + continue; + } + let { + root: g, + key: U, + target: O + } = Re(f, A); + if (O instanceof Qs && z instanceof Qs) { + O.mask = z.mask; + } else if (O instanceof xp && T0(z)) { + O.set(z); + } else if (O !== null && typeof O == "object" && typeof O.set == "function" && typeof O.copy == "function" && z != null && z.constructor && O.constructor === z.constructor) { + O.copy(z); + } else if (O !== null && typeof O == "object" && typeof O.set == "function" && Array.isArray(z)) { + if (typeof O.fromArray == "function") { + O.fromArray(z); + } else { + O.set(...z); + } + } else if (O !== null && typeof O == "object" && typeof O.set == "function" && typeof z == "number") { + if (typeof O.setScalar == "function") { + O.setScalar(z); + } else { + O.set(z); + } + } else { + var T; + g[U] = z; + if (m && !m.linear && A0.includes(U) && (T = g[U]) != null && T.isTexture && g[U].format === Jp && g[U].type === Lp) { + g[U].colorSpace = nm; + } + } + } + if (p != null && p.parent && m != null && m.internal && (s = p.object) != null && s.isObject3D && h !== p.eventCount) { + const A = p.object; + const z = m.internal.interaction.indexOf(A); + if (z > -1) { + m.internal.interaction.splice(z, 1); + } + if (p.eventCount && A.raycast !== null) { + m.internal.interaction.push(A); + } + } + if (p && p.props.attach === undefined) { + if (p.object.isBufferGeometry) { + p.props.attach = "geometry"; + } else if (p.object.isMaterial) { + p.props.attach = "material"; + } + } + if (p) { + te(p); + } + return f; +} +function te(f) { + var c; + if (!f.parent) { + return; + } + if (f.props.onUpdate != null) { + f.props.onUpdate(f.object); + } + const s = (c = f.root) == null || c.getState == null ? undefined : c.getState(); + if (s && s.internal.frames === 0) { + s.invalidate(); + } +} +function g0(f, c) { + if (!f.manual) { + if (vm(f)) { + f.left = c.width / -2; + f.right = c.width / 2; + f.top = c.height / 2; + f.bottom = c.height / -2; + } else { + f.aspect = c.width / c.height; + } + f.updateProjectionMatrix(); + } +} +const Bt = f => f == null ? undefined : f.isObject3D; +function ru(f) { + return (f.eventObject || f.object).uuid + "/" + f.index + f.instanceId; +} +function dm(f, c, s, p) { + const m = s.get(c); + if (m) { + s.delete(c); + if (s.size === 0) { + f.delete(p); + m.target.releasePointerCapture(p); + } + } +} +function D0(f, c) { + const { + internal: s + } = f.getState(); + s.interaction = s.interaction.filter(p => p !== c); + s.initialHits = s.initialHits.filter(p => p !== c); + s.hovered.forEach((p, m) => { + if (p.eventObject === c || p.object === c) { + s.hovered.delete(m); + } + }); + s.capturedMap.forEach((p, m) => { + dm(s.capturedMap, c, p, m); + }); +} +function b0(f) { + function c(z) { + const { + internal: g + } = f.getState(); + const U = z.offsetX - g.initialClick[0]; + const O = z.offsetY - g.initialClick[1]; + return Math.round(Math.sqrt(U * U + O * O)); + } + function s(z) { + return z.filter(g => ["Move", "Over", "Enter", "Out", "Leave"].some(U => { + var O; + if ((O = g.__r3f) == null) { + return undefined; + } else { + return O.handlers["onPointer" + U]; + } + })); + } + function p(z, g) { + const U = f.getState(); + const O = new Set(); + const D = []; + const b = g ? g(U.internal.interaction) : U.internal.interaction; + for (let _ = 0; _ < b.length; _++) { + const N = Ia(b[_]); + if (N) { + N.raycaster.camera = undefined; + } + } + if (!U.previousRoot && U.events.compute != null) { + U.events.compute(z, U); + } + function W(_) { + const N = Ia(_); + if (!N || !N.events.enabled || N.raycaster.camera === null) { + return []; + } + if (N.raycaster.camera === undefined) { + var X; + if (N.events.compute != null) { + N.events.compute(z, N, (X = N.previousRoot) == null ? undefined : X.getState()); + } + if (N.raycaster.camera === undefined) { + N.raycaster.camera = null; + } + } + if (N.raycaster.camera) { + return N.raycaster.intersectObject(_, true); + } else { + return []; + } + } + let x = b.flatMap(W).sort((_, N) => { + const X = Ia(_.object); + const Y = Ia(N.object); + if (!X || !Y) { + return _.distance - N.distance; + } else { + return Y.events.priority - X.events.priority || _.distance - N.distance; + } + }).filter(_ => { + const N = ru(_); + if (O.has(N)) { + return false; + } else { + O.add(N); + return true; + } + }); + if (U.events.filter) { + x = U.events.filter(x, U); + } + for (const _ of x) { + let N = _.object; + while (N) { + var V; + if ((V = N.__r3f) != null && V.eventCount) { + D.push({ + ..._, + eventObject: N + }); + } + N = N.parent; + } + } + if ("pointerId" in z && U.internal.capturedMap.has(z.pointerId)) { + for (let _ of U.internal.capturedMap.get(z.pointerId).values()) { + if (!O.has(ru(_.intersection))) { + D.push(_.intersection); + } + } + } + return D; + } + function m(z, g, U, O) { + if (z.length) { + const D = { + stopped: false + }; + for (const b of z) { + let W = Ia(b.object); + if (!W) { + b.object.traverseAncestors(x => { + const V = Ia(x); + if (V) { + W = V; + return false; + } + }); + } + if (W) { + const { + raycaster: x, + pointer: V, + camera: _, + internal: N + } = W; + const X = new ju(V.x, V.y, 0).unproject(_); + const Y = at => { + var et; + return ((et = N.capturedMap.get(at)) == null ? undefined : et.has(b.eventObject)) ?? false; + }; + const F = at => { + const st = { + intersection: b, + target: g.target + }; + if (N.capturedMap.has(at)) { + N.capturedMap.get(at).set(b.eventObject, st); + } else { + N.capturedMap.set(at, new Map([[b.eventObject, st]])); + } + g.target.setPointerCapture(at); + }; + const B = at => { + const st = N.capturedMap.get(at); + if (st) { + dm(N.capturedMap, b.eventObject, st, at); + } + }; + let ct = {}; + for (let at in g) { + let st = g[at]; + if (typeof st != "function") { + ct[at] = st; + } + } + let pt = { + ...b, + ...ct, + pointer: V, + intersections: z, + stopped: D.stopped, + delta: U, + unprojectedPoint: X, + ray: x.ray, + camera: _, + stopPropagation() { + const at = "pointerId" in g && N.capturedMap.get(g.pointerId); + if ((!at || at.has(b.eventObject)) && (pt.stopped = D.stopped = true, N.hovered.size && Array.from(N.hovered.values()).find(st => st.eventObject === b.eventObject))) { + const st = z.slice(0, z.indexOf(b)); + h([...st, b]); + } + }, + target: { + hasPointerCapture: Y, + setPointerCapture: F, + releasePointerCapture: B + }, + currentTarget: { + hasPointerCapture: Y, + setPointerCapture: F, + releasePointerCapture: B + }, + nativeEvent: g + }; + O(pt); + if (D.stopped === true) { + break; + } + } + } + } + return z; + } + function h(z) { + const { + internal: g + } = f.getState(); + for (const U of g.hovered.values()) { + if (!z.length || !z.find(O => O.object === U.object && O.index === U.index && O.instanceId === U.instanceId)) { + const D = U.eventObject.__r3f; + g.hovered.delete(ru(U)); + if (D != null && D.eventCount) { + const b = D.handlers; + const W = { + ...U, + intersections: z + }; + if (b.onPointerOut != null) { + b.onPointerOut(W); + } + if (b.onPointerLeave != null) { + b.onPointerLeave(W); + } + } + } + } + } + function T(z, g) { + for (let U = 0; U < g.length; U++) { + const O = g[U].__r3f; + if (O != null && O.handlers.onPointerMissed != null) { + O.handlers.onPointerMissed(z); + } + } + } + function A(z) { + switch (z) { + case "onPointerLeave": + case "onPointerCancel": + return () => h([]); + case "onLostPointerCapture": + return g => { + const { + internal: U + } = f.getState(); + if ("pointerId" in g && U.capturedMap.has(g.pointerId)) { + requestAnimationFrame(() => { + if (U.capturedMap.has(g.pointerId)) { + U.capturedMap.delete(g.pointerId); + h([]); + } + }); + } + }; + } + return function (U) { + const { + onPointerMissed: O, + internal: D + } = f.getState(); + D.lastEvent.current = U; + const b = z === "onPointerMove"; + const W = z === "onClick" || z === "onContextMenu" || z === "onDoubleClick"; + const V = p(U, b ? s : undefined); + const _ = W ? c(U) : 0; + if (z === "onPointerDown") { + D.initialClick = [U.offsetX, U.offsetY]; + D.initialHits = V.map(X => X.eventObject); + } + if (W && !V.length && _ <= 2) { + T(U, D.interaction); + if (O) { + O(U); + } + } + if (b) { + h(V); + } + function N(X) { + const Y = X.eventObject; + const F = Y.__r3f; + if (F == null || !F.eventCount) { + return; + } + const B = F.handlers; + if (b) { + if (B.onPointerOver || B.onPointerEnter || B.onPointerOut || B.onPointerLeave) { + const ct = ru(X); + const pt = D.hovered.get(ct); + if (pt) { + if (pt.stopped) { + X.stopPropagation(); + } + } else { + D.hovered.set(ct, X); + if (B.onPointerOver != null) { + B.onPointerOver(X); + } + if (B.onPointerEnter != null) { + B.onPointerEnter(X); + } + } + } + if (B.onPointerMove != null) { + B.onPointerMove(X); + } + } else { + const ct = B[z]; + if (ct) { + if (!W || D.initialHits.includes(Y)) { + T(U, D.interaction.filter(pt => !D.initialHits.includes(pt))); + ct(X); + } + } else if (W && D.initialHits.includes(Y)) { + T(U, D.interaction.filter(pt => !D.initialHits.includes(pt))); + } + } + } + m(V, U, _, N); + }; + } + return { + handlePointer: A + }; +} +const $s = f => f != null && !!f.render; +const ym = lt.createContext(null); +const R0 = (f, c) => { + const s = f0((A, z) => { + const g = new ju(); + const U = new ju(); + const O = new ju(); + function D(_ = z().camera, N = U, X = z().size) { + const { + width: Y, + height: F, + top: B, + left: ct + } = X; + const pt = Y / F; + if (N.isVector3) { + O.copy(N); + } else { + O.set(...N); + } + const at = _.getWorldPosition(g).distanceTo(O); + if (vm(_)) { + return { + width: Y / _.zoom, + height: F / _.zoom, + top: B, + left: ct, + factor: 1, + distance: at, + aspect: pt + }; + } + { + const st = _.fov * Math.PI / 180; + const et = Math.tan(st / 2) * 2 * at; + const Ma = et * (Y / F); + return { + width: Ma, + height: et, + top: B, + left: ct, + factor: Y / Ma, + distance: at, + aspect: pt + }; + } + } + let b; + const W = _ => A(N => ({ + performance: { + ...N.performance, + current: _ + } + })); + const x = new Wp(); + return { + set: A, + get: z, + gl: null, + camera: null, + raycaster: null, + events: { + priority: 1, + enabled: true, + connected: false + }, + scene: null, + xr: null, + invalidate: (_ = 1) => f(z(), _), + advance: (_, N) => c(_, N, z()), + legacy: false, + linear: false, + flat: false, + controls: null, + clock: new Fp(), + pointer: x, + mouse: x, + frameloop: "always", + onPointerMissed: undefined, + performance: { + current: 1, + min: 0.5, + max: 1, + debounce: 200, + regress: () => { + const _ = z(); + if (b) { + clearTimeout(b); + } + if (_.performance.current !== _.performance.min) { + W(_.performance.min); + } + b = setTimeout(() => W(z().performance.max), _.performance.debounce); + } + }, + size: { + width: 0, + height: 0, + top: 0, + left: 0 + }, + viewport: { + initialDpr: 0, + dpr: 0, + width: 0, + height: 0, + top: 0, + left: 0, + aspect: 0, + distance: 0, + factor: 0, + getCurrentViewport: D + }, + setEvents: _ => A(N => ({ + ...N, + events: { + ...N.events, + ..._ + } + })), + setSize: (_, N, X = 0, Y = 0) => { + const F = z().camera; + const B = { + width: _, + height: N, + top: X, + left: Y + }; + A(ct => ({ + size: B, + viewport: { + ...ct.viewport, + ...D(F, U, B) + } + })); + }, + setDpr: _ => A(N => { + const X = pm(_); + return { + viewport: { + ...N.viewport, + dpr: X, + initialDpr: N.viewport.initialDpr || X + } + }; + }), + setFrameloop: (_ = "always") => { + const N = z().clock; + N.stop(); + N.elapsedTime = 0; + if (_ !== "never") { + N.start(); + N.elapsedTime = 0; + } + A(() => ({ + frameloop: _ + })); + }, + previousRoot: undefined, + internal: { + interaction: [], + hovered: new Map(), + subscribers: [], + initialClick: [0, 0], + initialHits: [], + capturedMap: new Map(), + lastEvent: lt.createRef(), + active: false, + frames: 0, + priority: 0, + subscribe: (_, N, X) => { + const Y = z().internal; + Y.priority = Y.priority + (N > 0 ? 1 : 0); + Y.subscribers.push({ + ref: _, + priority: N, + store: X + }); + Y.subscribers = Y.subscribers.sort((F, B) => F.priority - B.priority); + return () => { + const F = z().internal; + if (F != null && F.subscribers) { + F.priority = F.priority - (N > 0 ? 1 : 0); + F.subscribers = F.subscribers.filter(B => B.ref !== _); + } + }; + } + } + }; + }); + const p = s.getState(); + let m = p.size; + let h = p.viewport.dpr; + let T = p.camera; + s.subscribe(() => { + const { + camera: A, + size: z, + viewport: g, + gl: U, + set: O + } = s.getState(); + if (z.width !== m.width || z.height !== m.height || g.dpr !== h) { + m = z; + h = g.dpr; + g0(A, z); + if (g.dpr > 0) { + U.setPixelRatio(g.dpr); + } + const D = typeof HTMLCanvasElement !== "undefined" && U.domElement instanceof HTMLCanvasElement; + U.setSize(z.width, z.height, D); + } + if (A !== T) { + T = A; + O(D => ({ + viewport: { + ...D.viewport, + ...D.viewport.getCurrentViewport(A) + } + })); + } + }); + s.subscribe(A => f(A)); + return s; +}; +function Sm() { + const f = lt.useContext(ym); + if (!f) { + throw new Error("R3F: Hooks can only be used within the Canvas component!"); + } + return f; +} +function co(f = s => s, c) { + return Sm()(f, c); +} +function C0(f, c = 0) { + const s = Sm(); + const p = s.getState().internal.subscribe; + const m = M0(f); + Bu(() => p(m, c, s), [c, p, s]); + return null; +} +const ws = new WeakMap(); +const q0 = f => { + var c; + return typeof f == "function" && (f == null || (c = f.prototype) == null ? undefined : c.constructor) === f; +}; +function hm(f, c) { + return function (s, ...p) { + let m; + if (q0(s)) { + m = ws.get(s); + if (!m) { + m = new s(); + ws.set(s, m); + } + } else { + m = s; + } + if (f) { + f(m); + } + return Promise.all(p.map(h => new Promise((T, A) => m.load(h, z => { + if (Bt(z == null ? undefined : z.scene)) { + Object.assign(z, O0(z.scene)); + } + T(z); + }, c, z => A(new Error(`Could not load ${h}: ${z == null ? undefined : z.message}`)))))); + }; +} +function Em(f, c, s, p) { + const m = Array.isArray(c) ? c : [c]; + const h = o0(hm(s, p), [f, ...m], { + equal: it.equ + }); + if (Array.isArray(c)) { + return h; + } else { + return h[0]; + } +} +Em.preload = function (f, c, s) { + const p = Array.isArray(c) ? c : [c]; + return d0(hm(s), [f, ...p]); +}; +Em.clear = function (f, c) { + const s = Array.isArray(c) ? c : [c]; + return y0([f, ...s]); +}; +function B0(f) { + const c = v0(f); + c.injectIntoDevTools({ + bundleType: 0, + rendererPackageName: "@react-three/fiber", + version: lt.version + }); + return c; +} +const zm = 0; +const ka = {}; +const Q0 = /^three(?=[A-Z])/; +const Qu = f => `${f[0].toUpperCase()}${f.slice(1)}`; +let Y0 = 0; +const G0 = f => typeof f == "function"; +function fo(f) { + if (G0(f)) { + const c = `${Y0++}`; + ka[c] = f; + return c; + } else { + Object.assign(ka, f); + } +} +function Nm(f, c) { + const s = Qu(f); + const p = ka[s]; + if (f !== "primitive" && !p) { + throw new Error(`R3F: ${s} is not part of the THREE namespace! Did you forget to extend? See: https://docs.pmnd.rs/react-three-fiber/api/objects#using-3rd-party-objects-declaratively`); + } + if (f === "primitive" && !c.object) { + throw new Error("R3F: Primitives without 'object' are invalid!"); + } + if (c.args !== undefined && !Array.isArray(c.args)) { + throw new Error("R3F: The args prop must be an array!"); + } +} +function V0(f, c, s) { + var p; + f = Qu(f) in ka ? f : f.replace(Q0, ""); + Nm(f, c); + if (f === "primitive" && (p = c.object) != null && p.__r3f) { + delete c.object.__r3f; + } + return bu(c.object, s, f, c); +} +function X0(f) { + if (!f.isHidden) { + var c; + if (f.props.attach && (c = f.parent) != null && c.object) { + Cu(f.parent, f); + } else if (Bt(f.object)) { + f.object.visible = false; + } + f.isHidden = true; + te(f); + } +} +function Tm(f) { + if (f.isHidden) { + var c; + if (f.props.attach && (c = f.parent) != null && c.object) { + Ru(f.parent, f); + } else if (Bt(f.object) && f.props.visible !== false) { + f.object.visible = true; + } + f.isHidden = false; + te(f); + } +} +function Wc(f, c, s) { + const p = c.root.getState(); + if (!!f.parent || f.object === p.scene) { + if (!c.object) { + const T = ka[Qu(c.type)]; + c.object = c.props.object ?? new T(...(c.props.args ?? [])); + c.object.__r3f = c; + } + kl(c.object, c.props); + if (c.props.attach) { + Ru(f, c); + } else if (Bt(c.object) && Bt(f.object)) { + const T = f.object.children.indexOf(s == null ? undefined : s.object); + if (s && T !== -1) { + const A = f.object.children.indexOf(c.object); + if (A !== -1) { + f.object.children.splice(A, 1); + const z = A < T ? T - 1 : T; + f.object.children.splice(z, 0, c.object); + } else { + c.object.parent = f.object; + f.object.children.splice(T, 0, c.object); + c.object.dispatchEvent({ + type: "added" + }); + f.object.dispatchEvent({ + type: "childadded", + child: c.object + }); + } + } else { + f.object.add(c.object); + } + } + for (const T of c.children) { + Wc(c, T); + } + te(c); + } +} +function Dc(f, c) { + if (c) { + c.parent = f; + f.children.push(c); + Wc(f, c); + } +} +function ks(f, c, s) { + if (!c || !s) { + return; + } + c.parent = f; + const p = f.children.indexOf(s); + if (p !== -1) { + f.children.splice(p, 0, c); + } else { + f.children.push(c); + } + Wc(f, c, s); +} +function Mm(f) { + if (typeof f.dispose == "function") { + const c = () => { + try { + f.dispose(); + } catch {} + }; + if (typeof IS_REACT_ACT_ENVIRONMENT !== "undefined") { + c(); + } else { + Fs.unstable_scheduleCallback(Fs.unstable_IdlePriority, c); + } + } +} +function Gc(f, c, s) { + if (!c) { + return; + } + c.parent = null; + const p = f.children.indexOf(c); + if (p !== -1) { + f.children.splice(p, 1); + } + if (c.props.attach) { + Cu(f, c); + } else if (Bt(c.object) && Bt(f.object)) { + f.object.remove(c.object); + D0(mm(c), c.object); + } + const m = c.props.dispose !== null && s !== false; + for (let h = c.children.length - 1; h >= 0; h--) { + const T = c.children[h]; + Gc(c, T, m); + } + c.children.length = 0; + delete c.object.__r3f; + if (m && c.type !== "primitive" && c.object.type !== "Scene") { + Mm(c.object); + } + if (s === undefined) { + te(c); + } +} +function Z0(f, c) { + for (const s of [f, f.alternate]) { + if (s !== null) { + if (typeof s.ref == "function") { + if (s.refCleanup != null) { + s.refCleanup(); + } + const p = s.ref(c); + if (typeof p == "function") { + s.refCleanup = p; + } + } else if (s.ref) { + s.ref.current = c; + } + } + } +} +const Du = []; +function K0() { + for (const [s] of Du) { + const p = s.parent; + if (p) { + if (s.props.attach) { + Cu(p, s); + } else if (Bt(s.object) && Bt(p.object)) { + p.object.remove(s.object); + } + for (const m of s.children) { + if (m.props.attach) { + Cu(s, m); + } else if (Bt(m.object) && Bt(s.object)) { + s.object.remove(m.object); + } + } + } + if (s.isHidden) { + Tm(s); + } + if (s.object.__r3f) { + delete s.object.__r3f; + } + if (s.type !== "primitive") { + Mm(s.object); + } + } + for (const [s, p, m] of Du) { + s.props = p; + const h = s.parent; + if (h) { + const T = ka[Qu(s.type)]; + s.object = s.props.object ?? new T(...(s.props.args ?? [])); + s.object.__r3f = s; + Z0(m, s.object); + kl(s.object, s.props); + if (s.props.attach) { + Ru(h, s); + } else if (Bt(s.object) && Bt(h.object)) { + h.object.add(s.object); + } + for (const A of s.children) { + if (A.props.attach) { + Ru(s, A); + } else if (Bt(A.object) && Bt(s.object)) { + s.object.add(A.object); + } + } + te(s); + } + } + Du.length = 0; +} +const bc = () => {}; +const tm = {}; +let Au = zm; +const x0 = 0; +const J0 = 4; +const Vc = B0({ + isPrimaryRenderer: false, + warnsIfNotActing: false, + supportsMutation: true, + supportsPersistence: false, + supportsHydration: false, + createInstance: V0, + removeChild: Gc, + appendChild: Dc, + appendInitialChild: Dc, + insertBefore: ks, + appendChildToContainer(f, c) { + const s = f.getState().scene.__r3f; + if (!!c && !!s) { + Dc(s, c); + } + }, + removeChildFromContainer(f, c) { + const s = f.getState().scene.__r3f; + if (!!c && !!s) { + Gc(s, c); + } + }, + insertInContainerBefore(f, c, s) { + const p = f.getState().scene.__r3f; + if (!!c && !!s && !!p) { + ks(p, c, s); + } + }, + getRootHostContext: () => tm, + getChildHostContext: () => tm, + commitUpdate(f, c, s, p, m) { + var h; + var T; + var A; + Nm(c, p); + let z = false; + if (f.type === "primitive" && s.object !== p.object || ((h = p.args) == null ? undefined : h.length) !== ((T = s.args) == null ? undefined : T.length) || (A = p.args) != null && A.some((U, O) => { + var D; + return U !== ((D = s.args) == null ? undefined : D[O]); + })) { + z = true; + } + if (z) { + Du.push([f, { + ...p + }, m]); + } else { + const U = r0(f, p); + if (Object.keys(U).length) { + Object.assign(f.props, U); + kl(f.object, U); + } + } + if (m.sibling === null || (m.flags & J0) === x0) { + K0(); + } + }, + finalizeInitialChildren: () => false, + commitMount() {}, + getPublicInstance: f => f == null ? undefined : f.object, + prepareForCommit: () => null, + preparePortalMount: f => bu(f.getState().scene, f, "", {}), + resetAfterCommit: () => {}, + shouldSetTextContent: () => false, + clearContainer: () => false, + hideInstance: X0, + unhideInstance: Tm, + createTextInstance: bc, + hideTextInstance: bc, + unhideTextInstance: bc, + scheduleTimeout: typeof setTimeout == "function" ? setTimeout : undefined, + cancelTimeout: typeof clearTimeout == "function" ? clearTimeout : undefined, + noTimeout: -1, + getInstanceFromNode: () => null, + beforeActiveInstanceBlur() {}, + afterActiveInstanceBlur() {}, + detachDeletedInstance() {}, + prepareScopeUpdate() {}, + getInstanceFromScope: () => null, + shouldAttemptEagerTransition: () => false, + trackSchedulerEvent: () => {}, + resolveEventType: () => null, + resolveEventTimeStamp: () => -1.1, + requestPostPaintCallback() {}, + maySuspendCommit: () => false, + preloadInstance: () => true, + startSuspendingCommit() {}, + suspendInstance() {}, + waitForCommitToBeReady: () => null, + NotPendingTransition: null, + HostTransitionContext: lt.createContext(null), + setCurrentUpdatePriority(f) { + Au = f; + }, + getCurrentUpdatePriority() { + return Au; + }, + resolveUpdatePriority() { + var f; + if (Au !== zm) { + return Au; + } + switch (typeof window !== "undefined" && ((f = window.event) == null ? undefined : f.type)) { + case "click": + case "contextmenu": + case "dblclick": + case "pointercancel": + case "pointerdown": + case "pointerup": + return gu.DiscreteEventPriority; + case "pointermove": + case "pointerout": + case "pointerover": + case "pointerenter": + case "pointerleave": + case "wheel": + return gu.ContinuousEventPriority; + default: + return gu.DefaultEventPriority; + } + }, + resetFormInstance() {} +}); +const Ta = new Map(); +const $a = { + objects: "shallow", + strict: false +}; +function L0(f, c) { + if (!c && typeof HTMLCanvasElement !== "undefined" && f instanceof HTMLCanvasElement && f.parentElement) { + const { + width: s, + height: p, + top: m, + left: h + } = f.parentElement.getBoundingClientRect(); + return { + width: s, + height: p, + top: m, + left: h + }; + } else if (!c && typeof OffscreenCanvas !== "undefined" && f instanceof OffscreenCanvas) { + return { + width: f.width, + height: f.height, + top: 0, + left: 0 + }; + } + return { + width: 0, + height: 0, + top: 0, + left: 0, + ...c + }; +} +function io(f) { + const c = Ta.get(f); + const s = c == null ? undefined : c.fiber; + const p = c == null ? undefined : c.store; + if (c) { + console.warn("R3F.createRoot should only be called once!"); + } + const m = typeof reportError == "function" ? reportError : console.error; + const h = p || R0(Kc, am); + const T = s || Vc.createContainer(h, gu.ConcurrentRoot, null, false, null, "", m, m, m, null); + if (!c) { + Ta.set(f, { + fiber: T, + store: h + }); + } + let A; + let z; + let g = false; + let U = null; + return { + async configure(O = {}) { + let D; + U = new Promise(mt => D = mt); + let { + gl: b, + size: W, + scene: x, + events: V, + onCreated: _, + shadows: N = false, + linear: X = false, + flat: Y = false, + legacy: F = false, + orthographic: B = false, + frameloop: ct = "always", + dpr: pt = [1, 2], + performance: at, + raycaster: st, + camera: et, + onPointerMissed: Ma + } = O; + let J = h.getState(); + let ht = J.gl; + if (!J.gl) { + const mt = { + canvas: f, + powerPreference: "high-performance", + antialias: true, + alpha: true + }; + const ot = typeof b == "function" ? await b(mt) : b; + if ($s(ot)) { + ht = ot; + } else { + ht = new bp({ + ...mt, + ...b + }); + } + J.set({ + gl: ht + }); + } + let ul = J.raycaster; + if (!ul) { + J.set({ + raycaster: ul = new Rp() + }); + } + const { + params: Ce, + ...nl + } = st || {}; + if (!it.equ(nl, ul, $a)) { + kl(ul, { + ...nl + }); + } + if (!it.equ(Ce, ul.params, $a)) { + kl(ul, { + params: { + ...ul.params, + ...Ce + } + }); + } + if (!J.camera || J.camera === z && !it.equ(z, et, $a)) { + z = et; + const mt = et == null ? undefined : et.isCamera; + const ot = mt ? et : B ? new Cp(0, 0, 0, 0, 0.1, 1000) : new qp(75, 0, 0.1, 1000); + if (!mt) { + ot.position.z = 5; + if (et) { + kl(ot, et); + if (!ot.manual) { + if ("aspect" in et || "left" in et || "right" in et || "bottom" in et || "top" in et) { + ot.manual = true; + ot.updateProjectionMatrix(); + } + } + } + if (!J.camera && (et == null || !et.rotation)) { + ot.lookAt(0, 0, 0); + } + } + J.set({ + camera: ot + }); + ul.camera = ot; + } + if (!J.scene) { + let mt; + if (x != null && x.isScene) { + mt = x; + bu(mt, h, "", {}); + } else { + mt = new Bp(); + bu(mt, h, "", {}); + if (x) { + kl(mt, x); + } + } + J.set({ + scene: mt + }); + } + if (V && !J.events.handlers) { + J.set({ + events: V(h) + }); + } + const ta = L0(f, W); + if (!it.equ(ta, J.size, $a)) { + J.setSize(ta.width, ta.height, ta.top, ta.left); + } + if (pt && J.viewport.dpr !== pm(pt)) { + J.setDpr(pt); + } + if (J.frameloop !== ct) { + J.setFrameloop(ct); + } + if (!J.onPointerMissed) { + J.set({ + onPointerMissed: Ma + }); + } + if (at && !it.equ(at, J.performance, $a)) { + J.set(mt => ({ + performance: { + ...mt.performance, + ...at + } + })); + } + if (!J.xr) { + var Rt; + const mt = (Mt, bl) => { + const Oa = h.getState(); + if (Oa.frameloop !== "never") { + am(Mt, true, Oa, bl); + } + }; + const ot = () => { + const Mt = h.getState(); + Mt.gl.xr.enabled = Mt.gl.xr.isPresenting; + Mt.gl.xr.setAnimationLoop(Mt.gl.xr.isPresenting ? mt : null); + if (!Mt.gl.xr.isPresenting) { + Kc(Mt); + } + }; + const Dl = { + connect() { + const Mt = h.getState().gl; + Mt.xr.addEventListener("sessionstart", ot); + Mt.xr.addEventListener("sessionend", ot); + }, + disconnect() { + const Mt = h.getState().gl; + Mt.xr.removeEventListener("sessionstart", ot); + Mt.xr.removeEventListener("sessionend", ot); + } + }; + if (typeof ((Rt = ht.xr) == null ? undefined : Rt.addEventListener) == "function") { + Dl.connect(); + } + J.set({ + xr: Dl + }); + } + if (ht.shadowMap) { + const mt = ht.shadowMap.enabled; + const ot = ht.shadowMap.type; + ht.shadowMap.enabled = !!N; + if (it.boo(N)) { + ht.shadowMap.type = Oc; + } else if (it.str(N)) { + const Dl = { + basic: Gp, + percentage: Yp, + soft: Oc, + variance: Qp + }; + ht.shadowMap.type = Dl[N] ?? Oc; + } else if (it.obj(N)) { + Object.assign(ht.shadowMap, N); + } + if (mt !== ht.shadowMap.enabled || ot !== ht.shadowMap.type) { + ht.shadowMap.needsUpdate = true; + } + } + Vp.enabled = !F; + if (!g) { + ht.outputColorSpace = X ? Xp : nm; + ht.toneMapping = Y ? Zp : Kp; + } + if (J.legacy !== F) { + J.set(() => ({ + legacy: F + })); + } + if (J.linear !== X) { + J.set(() => ({ + linear: X + })); + } + if (J.flat !== Y) { + J.set(() => ({ + flat: Y + })); + } + if (b && !it.fun(b) && !$s(b) && !it.equ(b, ht, $a)) { + kl(ht, b); + } + A = _; + g = true; + D(); + return this; + }, + render(O) { + if (!g && !U) { + this.configure(); + } + U.then(() => { + Vc.updateContainer({O}, T, null, () => {}); + }); + return h; + }, + unmount() { + F0(f); + } + }; +} +function W0({ + store: f, + children: c, + onCreated: s, + rootElement: p +}) { + Bu(() => { + const m = f.getState(); + m.set(h => ({ + internal: { + ...h.internal, + active: true + } + })); + if (s) { + s(m); + } + if (!f.getState().events.connected && m.events.connect != null) { + m.events.connect(p); + } + }, []); + return {c}; +} +function F0(f, c) { + const s = Ta.get(f); + const p = s == null ? undefined : s.fiber; + if (p) { + const m = s == null ? undefined : s.store.getState(); + if (m) { + m.internal.active = false; + } + Vc.updateContainer(null, p, null, () => { + if (m) { + setTimeout(() => { + try { + var h; + var T; + var A; + var z; + if (m.events.disconnect != null) { + m.events.disconnect(); + } + if ((h = m.gl) != null && (T = h.renderLists) != null && T.dispose != null) { + T.dispose(); + } + if ((A = m.gl) != null && A.forceContextLoss != null) { + A.forceContextLoss(); + } + if ((z = m.gl) != null && z.xr) { + m.xr.disconnect(); + } + H0(m.scene); + Ta.delete(f); + } catch {} + }, 500); + } + }); + } +} +const P0 = new Set(); +const I0 = new Set(); +const $0 = new Set(); +function Rc(f, c) { + if (f.size) { + for (const { + callback: s + } of f.values()) { + s(c); + } + } +} +function be(f, c) { + switch (f) { + case "before": + return Rc(P0, c); + case "after": + return Rc(I0, c); + case "tail": + return Rc($0, c); + } +} +let Cc; +let qc; +function Xc(f, c, s) { + let p = c.clock.getDelta(); + if (c.frameloop === "never" && typeof f == "number") { + p = f - c.clock.elapsedTime; + c.clock.oldTime = c.clock.elapsedTime; + c.clock.elapsedTime = f; + } + Cc = c.internal.subscribers; + for (let m = 0; m < Cc.length; m++) { + qc = Cc[m]; + qc.ref.current(qc.store.getState(), p, s); + } + if (!c.internal.priority && c.gl.render) { + c.gl.render(c.scene, c.camera); + } + c.internal.frames = Math.max(0, c.internal.frames - 1); + if (c.frameloop === "always") { + return 1; + } else { + return c.internal.frames; + } +} +let qu = false; +let Zc = false; +let Bc; +let lm; +let wa; +function Om(f) { + lm = requestAnimationFrame(Om); + qu = true; + Bc = 0; + be("before", f); + Zc = true; + for (const s of Ta.values()) { + var c; + wa = s.store.getState(); + if (wa.internal.active && (wa.frameloop === "always" || wa.internal.frames > 0) && ((c = wa.gl.xr) == null || !c.isPresenting)) { + Bc += Xc(f, wa); + } + } + Zc = false; + be("after", f); + if (Bc === 0) { + be("tail", f); + qu = false; + return cancelAnimationFrame(lm); + } +} +function Kc(f, c = 1) { + var s; + if (!f) { + return Ta.forEach(p => Kc(p.store.getState(), c)); + } + if (((s = f.gl.xr) == null || !s.isPresenting) && !!f.internal.active && f.frameloop !== "never") { + if (c > 1) { + f.internal.frames = Math.min(60, f.internal.frames + c); + } else if (Zc) { + f.internal.frames = 2; + } else { + f.internal.frames = 1; + } + if (!qu) { + qu = true; + requestAnimationFrame(Om); + } + } +} +function am(f, c = true, s, p) { + if (c) { + be("before", f); + } + if (s) { + Xc(f, s, p); + } else { + for (const m of Ta.values()) { + Xc(f, m.store.getState()); + } + } + if (c) { + be("after", f); + } +} +const Qc = { + onClick: ["click", false], + onContextMenu: ["contextmenu", false], + onDoubleClick: ["dblclick", false], + onWheel: ["wheel", true], + onPointerDown: ["pointerdown", true], + onPointerUp: ["pointerup", true], + onPointerLeave: ["pointerleave", true], + onPointerMove: ["pointermove", true], + onPointerCancel: ["pointercancel", true], + onLostPointerCapture: ["lostpointercapture", true] +}; +function so(f) { + const { + handlePointer: c + } = b0(f); + return { + priority: 1, + enabled: true, + compute(s, p, m) { + p.pointer.set(s.offsetX / p.size.width * 2 - 1, -(s.offsetY / p.size.height) * 2 + 1); + p.raycaster.setFromCamera(p.pointer, p.camera); + }, + connected: undefined, + handlers: Object.keys(Qc).reduce((s, p) => ({ + ...s, + [p]: c(p) + }), {}), + update: () => { + var s; + const { + events: p, + internal: m + } = f.getState(); + if ((s = m.lastEvent) != null && s.current && p.handlers) { + p.handlers.onPointerMove(m.lastEvent.current); + } + }, + connect: s => { + const { + set: p, + events: m + } = f.getState(); + if (m.disconnect != null) { + m.disconnect(); + } + p(h => ({ + events: { + ...h.events, + connected: s + } + })); + if (m.handlers) { + for (const h in m.handlers) { + const T = m.handlers[h]; + const [A, z] = Qc[h]; + s.addEventListener(A, T, { + passive: z + }); + } + } + }, + disconnect: () => { + const { + set: s, + events: p + } = f.getState(); + if (p.connected) { + if (p.handlers) { + for (const m in p.handlers) { + const h = p.handlers[m]; + const [T] = Qc[m]; + p.connected.removeEventListener(T, h); + } + } + s(m => ({ + events: { + ...m.events, + connected: undefined + } + })); + } + } + }; +} +const w0 = () => { + const f = lt.useRef(); + const c = lt.useMemo(() => { + const p = new Float32Array(3000); + const m = new Float32Array(3000); + for (let h = 0; h < 1000; h++) { + const T = h * 3; + p[T] = (Math.random() - 0.5) * 50; + p[T + 1] = (Math.random() - 0.5) * 100; + p[T + 2] = (Math.random() - 0.5) * 50; + m[T] = (Math.random() - 0.5) * 0.1; + m[T + 1] = 0.02 + Math.random() * 0.05; + m[T + 2] = (Math.random() - 0.5) * 0.1; + } + return { + positions: p, + speeds: m + }; + }, []); + C0((s, p) => { + if (f.current) { + const m = f.current.geometry.attributes.position.array; + const h = f.current.geometry.attributes.speed.array; + for (let T = 0; T < m.length; T += 3) { + if (!isFinite(m[T]) || !isFinite(m[T + 1]) || !isFinite(m[T + 2]) || !isFinite(h[T]) || !isFinite(h[T + 1]) || !isFinite(h[T + 2])) { + console.warn(`Particle ${T / 3} bị lỗi NaN, reset lại.`); + m[T] = (Math.random() - 0.5) * 50; + m[T + 1] = -25; + m[T + 2] = (Math.random() - 0.5) * 50; + h[T] = (Math.random() - 0.5) * 2; + h[T + 1] = Math.random() * 2; + h[T + 2] = (Math.random() - 0.5) * 2; + } + m[T] += h[T] * p * 80; + m[T + 1] += h[T + 1] * p * 20; + m[T + 2] += h[T + 2] * p * 80; + if (m[T + 1] > 25) { + m[T + 1] = -25; + m[T] = (Math.random() - 0.5) * 50; + m[T + 2] = (Math.random() - 0.5) * 50; + } + } + f.current.geometry.attributes.position.needsUpdate = true; + } + }); + return ; +}; +const mo = Object.freeze(Object.defineProperty({ + __proto__: null, + default: w0 +}, Symbol.toStringTag, { + value: "Module" +})); +export { eo as B, uo as E, w0 as P, M0 as a, Bu as b, io as c, so as d, fo as e, F0 as f, co as g, C0 as h, lo as i, Em as j, S0 as m, mo as p, o0 as s, ao as u }; \ No newline at end of file