From dc14d2ed7c78ff870f05f368e28cca075c646d0e Mon Sep 17 00:00:00 2001 From: marherb Date: Sun, 5 May 2024 03:37:56 +0000 Subject: [PATCH] deploy: a994a5417d8ee81f742d8a0a17006ad0d26596ac --- .nojekyll | 0 _cosmos.ico | Bin 0 -> 15086 bytes assets/_virtual_cosmos-imports-Ben4PWJR.js | 263 + assets/index-u9zs8jxH.js | 105 + assets/vendors-Dre0VOQR.js | 18309 +++++++++++++++++++ index.html | 19 + playground.bundle.js | 1376 ++ playground.bundle.js.map | 1 + renderer.html | 13 + 9 files changed, 20086 insertions(+) create mode 100644 .nojekyll create mode 100644 _cosmos.ico create mode 100644 assets/_virtual_cosmos-imports-Ben4PWJR.js create mode 100644 assets/index-u9zs8jxH.js create mode 100644 assets/vendors-Dre0VOQR.js create mode 100644 index.html create mode 100644 playground.bundle.js create mode 100644 playground.bundle.js.map create mode 100644 renderer.html diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000..e69de29 diff --git a/_cosmos.ico b/_cosmos.ico new file mode 100644 index 0000000000000000000000000000000000000000..d29d12a20b6e9ad6300064fd234478c57a7edae7 GIT binary patch literal 15086 zcmdU#3$RYr7r+k}H;lKHTOI(Cnxb;#q&05UKRbPymvXz8>R#el}4+0Jr&6}sC(+Kgnuh3 zzZQ!96lW+dQ{1k2Sn*^6Ns~tzG|*Cqx@Q8iR485aAH{`=I~9*BN`?q6b*Kvuc)_!@ zp{xpMqBurzvm*VQsm^h9@POA_itt88X+Sk)I#}@!#W-Dxn-6bfAgiRHj52Din5TF` zvA8;>tB(w1Arslf0ksBRcg51|^SJgP6WQo+I#6CK4N%;x7$>8&^O21X=u#BOQex^I zP|QfjtgI|K=bUrof(tH?s#UAXrI%hRmtA(5A?b@RzSzp3fi_dV2_4V{oiYW+EwbN{ zeaR)4$o1D>FZbSiuRQ(q(=vAKSeY|tjx1QPKz{h)2U)ptrTq5WZ?bOPIz!Ur{rKaL zvT)%-`QU>Otj;sfJR|qrcc0vF!wpicTD4T|LYE#HD&I!w0`t9W*|JinP91sZp@(F~ zj2ZIFFTcp{-Mi()i4&3vPM$m|U@Cyeo;`bH)v8tU-h1!KBab{HS6+FgAXD}5BQ_S@ zQUP{rkz%qQeLZBz5c&Q0-vjy{J$h8OZrv)&mMxRdKKo22Po6BVyz+_+7%;$e=-Rcb z+;h)8hNRJpvY|tV8ZC9G3lDfXpgkKmZj_f^ddcRXUzdb#scb8@m;J=_KkvNrRfo?g~kJ3@Ps!q9K8Sj z`%Ej9zA+U_wL;-eb-%gNxOFK-mc>zL2-yep?=W^igTvyt!1aT-jtG3z>`u?Fs9p z-(wWf*#YOLK;P@PlrLZ2Y$5y_Hf$)lxw&RT&@;R)j~zQE`}Xa#@!zy*ldYGvYu5_M z+98j*0S&Z%fEVrh{`>D`@ZiDHpg{xcFKljjjL=JQlVT%92b=+;+G%!xIl!87Kwoa& zyji~d@=JO1%{Qf2uU^u*b7yJMqJ=bS)JSr2a-?R>no_-bbwkqRQ3egPy?ghTkt0Xi z_`wUF4mNDqAP+q7K$H#g>xj+(XYd7z{<376`MPb}He=1)Kxf)>)m2y7eic_Q(|qqwCV8i}lUn!-s9JI{*ChQ}HZT8MX#Hge=Ab*>QR$ zbVhf4q2qCM@BqI3_FLQk&d%qHY$tmldoJ+#=by)|rO3Lc+a7Ev z^9Vq8#6IkohcCJ`N*4BpGYxACI1~CKd-m+vX8WRa)I9v@ZBb?HL4G@TCiJJ@&;ebd zbWG?@Y@ks2S)xC>C(k?ncAO>pqx;#ef8_jW)~uQN9?U@i--Nx!KSrgIu2`|6ELyb4 zWb%U#gf20%&^>bfa^~UegwF&lU%p%}y6B=fJ|&jVnTN9-e!zqY6XfcvuTGvFBiexO z*q})H*xp&QW|{t+qa)6;k@e#EWs=YNh_l@G?c41fm!=N3pFJQ_55N92;?-AQP1P5X zJmPpq@!bipTi=y-8p?mE4A*}z-ojX(6;&if7mZLlV=3jsPW%_^o@yB+4 z_vsq0@6Hb`lqT~07SM5yJt5&+bJuENs8yQzzafJ|zV9q#r_St76>3!`% zXLOG}Kf@azlvu;Tg9jaJI~(GcOr1Ja`t|E4_=c@pw>CS0&xT)IuU@?X;*(H@ErFK( zg}T$GO*0$gKmQ}|rkid`r@uQtYZEMnU5Fn2iPbD#yjb$`@{;<86YTN(_wP4f86OLO zfpPL9d6fP0&p&eDz=6QoB+L)LlGuUjl?t8zg8uko_+$Zkr$0XMgAYEK^ew{jO7fet zKQXPaE}?IHU3^{#_`>+afqG7VVl~7I@TW@~KKbMm$-qY<*5LQwX$LWhfDiBVpEqxw ztySUD1Lb3 zjW=4nN6Tz((GFsP>;)wS*iB*rjJJ~$^S>yeqyEK08!ZXUBmEBWMNX$qo#f}Ae=ZaU zDoUG(`~39NPjdV1w`a1i6H`XFOrVDnMaIuHKiL-cotIyJS%}x9i$(j}1?~Fv>t%?> zg)hJS@+3b$?@$_Dx+`W18Q)(p7R0-WN8vB8S+mCW0qh|A0!W(q{p+v4+I~p9ka#@n zOBG6o+@Tcp{(^QE`TmG_BQZDj*jsM7#rEYp@4VB}oW;3^DPpXeen<^_m7Vt(!syh}fK5bynX777T5gW^XQrx)$ z4|s8YDb4o-%03BMnmQZbZzLPwOSl-ei>2aEZ&xHXK;MF-$)n8qe9rgKtkVaPf^5+l zki;XNSDWuWp2uyD|mfX+_V|YFhFC{{?(!pL)>1 z4RjvgzW-dl)k1{-$u3FAg;|80Jo0_|xbFh;Rqt?nTsv`IX}9YK;ah)_{gjvJH`kA@ zU!gHP)$dH=9L2VZ$#+^+^yBmZTisak3B?Z;*D3B-Jdr@sj%c@zl!E>a8~2K{JZbIGoR+rp+gp5AP!YfP+;fL6)RQ<$k~*8V9JO= zK#L#5eb=yI!{pj)ul4&d$OzAevYN*{vHtAVt((P+h&K}RB|gYo3;bN}G&wJFpGNyY z(&SOb{W!GLA+`b!;v@J`j(v9q2%d&+IM-DdYn+}TqX9>kJ9`sgG7Jsq-;39vrLE1G_s`#BR6m+08BqrCIZ zJNAx%_ztly?%C;E-U=`dAZhX_gNB$evF1sWCfR!scrgaf*G|YnCbAnV<|pz@2i{6C zr?{7f7jcH?pMT!ski>zRkF{&pw!3uh&`EQzM;Wn7<|r{0bcP4K;OUozzI%Hpsk<&^d}n$~hb7KD_<1H0}29Wc~{;yilU@+q7w8^AD!*j*uVde{2}{?En7zudUq>eYk$wZ{D=f z|JXBlhxj2oF#jmWmI18e5Pgxqd0T{iB9;-s3)zL%pOeq~M(kEZy^Qj(y~KccI~ier z;DPKX6a)6>$tRyo#=m%fNDK!1#y-P42x1l3Qa_SM88p!H4s7-6)z*)^Sf!5tyupcl7BIM_59dhmM?{=M(8ujRnzX&p_Fv?4N5p=E%`8qlmG~)d1K}A$|Ng5*7IPo& zXgDkI#)a?4AAj8T)uMI*_M3QIOe_vr{_}@^+L?&6kjr@cB!#3<{k;HP_m3%{AA^m@#AQ&7XTq=2wV3VyB}=kG8vQ>O~;yJ?{LeMF#El zw~$TJJX>$XcA3xI(Y^TMi-vvs_O-Zmn!8JQ!aEZ{M|_4e;eR;&7$fG%PQ|Fc%p{Mx z@Q534ElLU427E|-$$Z6toz(9r9iS;tEUy2lERujP-AEBzjm=)Cn9BcdtmPT`-?FE& zNNyR?fgYls`hz#n)IqkQ>5osjWXY10_gjqL%$YOoZFGV!b*=x{PkGbMyIIbM4?p~{`PS^2 zq=`Xr-ol4Y%mL(6*T#?e!Px@8G7i`~eP { + const gap = control2 ? gaps[size] : 0; + if (position === "left") { + return { + marginRight: `${gap}rem` + }; + } + if (position === "right") { + return { + marginLeft: `${gap}rem` + }; + } + if (position === "center") { + return { + margin: `0rem ${gap}rem` + }; + } + return {}; + }); + if (animation === "none") { + return null; + } + if (animation === "default") { + return /* @__PURE__ */ jsxRuntimeExports.jsx( + "img", + { + alt: "", + src, + onClick, + style: { + width: `${iconSize[size]}rem`, + height: `${iconSize[size]}rem`, + objectFit: "contain", + transition: "all 0.3s", + cursor: !!onClick ? "pointer" : "default", + ...getMargin(true), + ...style + } + } + ); + } + if (animation === "width") { + return /* @__PURE__ */ jsxRuntimeExports.jsx( + "img", + { + alt: "", + src, + onClick, + style: { + width: `${control ? iconSize[size] : 0}rem`, + height: `${iconSize[size]}rem`, + opacity: control ? 1 : 0, + objectFit: "contain", + transition: "all 0.3s", + cursor: !!onClick ? "pointer" : "default", + ...getMargin(control), + ...style + } + } + ); + } + if (animation === "rotate") { + return /* @__PURE__ */ jsxRuntimeExports.jsx( + "img", + { + alt: "", + src, + onClick, + style: { + width: `${iconSize[size]}rem`, + height: `${iconSize[size]}rem`, + objectFit: "contain", + transform: `rotate3d(0,1,0,${control ? "180deg" : "0deg"})`, + transition: "all 0.5s", + cursor: !!onClick ? "pointer" : "default", + ...getMargin(control), + ...style + } + } + ); + } + return null; +} +function CusButton({ + children, + size = "m", + type = "solid", + disabled, + block, + style = {}, + onClick, + importantClassName, + leftIcon, + rightIcon +}) { + const ref = reactExports.useRef(null); + const isHovering = useHover(ref); + return /* @__PURE__ */ jsxRuntimeExports.jsxs( + Button, + { + ref, + style: { + display: "flex", + justifyContent: "center", + alignItems: "center", + fontFamily: "Poppins-Medium", + fontWeight: 500, + height: "unset", + padding: `${paddings[size]}rem ${paddings[size] * 2}rem`, + borderRadius: `${borderRadius[size]}rem`, + borderColor: isHovering ? borderColorsOnHover[type] : borderColors[type], + fontSize: `${fontSizes[size]}rem`, + lineHeight: `${lineHeights[size]}rem`, + background: backgrounds[type], + color: color[type], + filter: !!disabled ? "brightness(0.6)" : "none", + ...style + }, + className: importantClassName, + disabled, + block, + onClick, + children: [ + !!leftIcon && /* @__PURE__ */ jsxRuntimeExports.jsx( + CusComIcon, + { + control: isHovering, + size, + position: "left", + ...leftIcon + } + ), + children, + !!rightIcon && /* @__PURE__ */ jsxRuntimeExports.jsx( + CusComIcon, + { + control: isHovering, + size, + position: "right", + ...rightIcon + } + ) + ] + } + ); +} +const index_fixture = () => { + return /* @__PURE__ */ jsxRuntimeExports.jsxs(Space, { direction: "vertical", children: [ + /* @__PURE__ */ jsxRuntimeExports.jsxs(Space, { children: [ + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { size: "el", children: "size=el" }), + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { size: "l", children: "size=l" }), + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { size: "m", children: "size=m" }), + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { size: "s", children: "size=s" }), + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { size: "es", children: "size=es" }) + ] }), + /* @__PURE__ */ jsxRuntimeExports.jsxs(Space, { children: [ + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { type: "solid", children: "type=solid" }), + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { type: "outline", children: "type=outline" }), + /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { type: "text", children: "type=text" }) + ] }), + /* @__PURE__ */ jsxRuntimeExports.jsx(Space, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { disabled: true, children: "disabled" }) }), + /* @__PURE__ */ jsxRuntimeExports.jsx(Space, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(CusButton, { block: true, children: "block" }) }) + ] }); +}; +const fixture0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: index_fixture +}, Symbol.toStringTag, { value: "Module" })); +const rendererConfig = { + "playgroundUrl": "http://localhost:5000", + "containerQuerySelector": null +}; +const fixtures = { + "src/CusButton/index.fixture.tsx": { module: fixture0 } +}; +const decorators = {}; +const moduleWrappers = { + lazy: false, + fixtures, + decorators +}; +export { + moduleWrappers, + rendererConfig +}; diff --git a/assets/index-u9zs8jxH.js b/assets/index-u9zs8jxH.js new file mode 100644 index 0000000..9abb7f4 --- /dev/null +++ b/assets/index-u9zs8jxH.js @@ -0,0 +1,105 @@ +const __vite__fileDeps=["./_virtual_cosmos-imports-Ben4PWJR.js","./vendors-Dre0VOQR.js"],__vite__mapDeps=i=>i.map(i=>__vite__fileDeps[i]); +import { m as mountDomRenderer } from "./vendors-Dre0VOQR.js"; +(function polyfill() { + const relList = document.createElement("link").relList; + if (relList && relList.supports && relList.supports("modulepreload")) { + return; + } + for (const link of document.querySelectorAll('link[rel="modulepreload"]')) { + processPreload(link); + } + new MutationObserver((mutations) => { + for (const mutation of mutations) { + if (mutation.type !== "childList") { + continue; + } + for (const node of mutation.addedNodes) { + if (node.tagName === "LINK" && node.rel === "modulepreload") + processPreload(node); + } + } + }).observe(document, { childList: true, subtree: true }); + function getFetchOpts(link) { + const fetchOpts = {}; + if (link.integrity) + fetchOpts.integrity = link.integrity; + if (link.referrerPolicy) + fetchOpts.referrerPolicy = link.referrerPolicy; + if (link.crossOrigin === "use-credentials") + fetchOpts.credentials = "include"; + else if (link.crossOrigin === "anonymous") + fetchOpts.credentials = "omit"; + else + fetchOpts.credentials = "same-origin"; + return fetchOpts; + } + function processPreload(link) { + if (link.ep) + return; + link.ep = true; + const fetchOpts = getFetchOpts(link); + fetch(link.href, fetchOpts); + } +})(); +const scriptRel = "modulepreload"; +const assetsURL = function(dep, importerUrl) { + return new URL(dep, importerUrl).href; +}; +const seen = {}; +const __vitePreload = function preload(baseModule, deps, importerUrl) { + let promise = Promise.resolve(); + if (deps && deps.length > 0) { + const links = document.getElementsByTagName("link"); + const cspNonceMeta = document.querySelector("meta[property=csp-nonce]"); + const cspNonce = (cspNonceMeta == null ? void 0 : cspNonceMeta.nonce) || (cspNonceMeta == null ? void 0 : cspNonceMeta.getAttribute("nonce")); + promise = Promise.all(deps.map((dep) => { + dep = assetsURL(dep, importerUrl); + if (dep in seen) + return; + seen[dep] = true; + const isCss = dep.endsWith(".css"); + const cssSelector = isCss ? '[rel="stylesheet"]' : ""; + const isBaseRelative = !!importerUrl; + if (isBaseRelative) { + for (let i = links.length - 1; i >= 0; i--) { + const link2 = links[i]; + if (link2.href === dep && (!isCss || link2.rel === "stylesheet")) { + return; + } + } + } else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) { + return; + } + const link = document.createElement("link"); + link.rel = isCss ? "stylesheet" : scriptRel; + if (!isCss) { + link.as = "script"; + link.crossOrigin = ""; + } + link.href = dep; + if (cspNonce) { + link.setAttribute("nonce", cspNonce); + } + document.head.appendChild(link); + if (isCss) { + return new Promise((res, rej) => { + link.addEventListener("load", res); + link.addEventListener("error", () => rej(new Error(`Unable to preload CSS for ${dep}`))); + }); + } + })); + } + return promise.then(() => baseModule()).catch((err) => { + const e = new Event("vite:preloadError", { cancelable: true }); + e.payload = err; + window.dispatchEvent(e); + if (!e.defaultPrevented) { + throw err; + } + }); +}; +mount(); +async function mount() { + const args = await __vitePreload(() => import("./_virtual_cosmos-imports-Ben4PWJR.js"), true ? __vite__mapDeps([0,1]) : void 0, import.meta.url); + mountDomRenderer(args); +} diff --git a/assets/vendors-Dre0VOQR.js b/assets/vendors-Dre0VOQR.js new file mode 100644 index 0000000..862a1b1 --- /dev/null +++ b/assets/vendors-Dre0VOQR.js @@ -0,0 +1,18309 @@ +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +function _mergeNamespaces(n2, m2) { + for (var i = 0; i < m2.length; i++) { + const e2 = m2[i]; + if (typeof e2 !== "string" && !Array.isArray(e2)) { + for (const k2 in e2) { + if (k2 !== "default" && !(k2 in n2)) { + const d2 = Object.getOwnPropertyDescriptor(e2, k2); + if (d2) { + Object.defineProperty(n2, k2, d2.get ? d2 : { + enumerable: true, + get: () => e2[k2] + }); + } + } + } + } + } + return Object.freeze(Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" })); +} +function getDefaultExportFromCjs(x2) { + return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2; +} +var react = { exports: {} }; +var react_production_min = {}; +/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var l$3 = Symbol.for("react.element"), n$3 = Symbol.for("react.portal"), p$4 = Symbol.for("react.fragment"), q$3 = Symbol.for("react.strict_mode"), r = Symbol.for("react.profiler"), t$2 = Symbol.for("react.provider"), u$2 = Symbol.for("react.context"), v$3 = Symbol.for("react.forward_ref"), w = Symbol.for("react.suspense"), x = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), z$1 = Symbol.iterator; +function A$1(a) { + if (null === a || "object" !== typeof a) + return null; + a = z$1 && a[z$1] || a["@@iterator"]; + return "function" === typeof a ? a : null; +} +var B$1 = { isMounted: function() { + return false; +}, enqueueForceUpdate: function() { +}, enqueueReplaceState: function() { +}, enqueueSetState: function() { +} }, C$1 = Object.assign, D$1 = {}; +function E$1(a, b2, e2) { + this.props = a; + this.context = b2; + this.refs = D$1; + this.updater = e2 || B$1; +} +E$1.prototype.isReactComponent = {}; +E$1.prototype.setState = function(a, b2) { + if ("object" !== typeof a && "function" !== typeof a && null != a) + throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables."); + this.updater.enqueueSetState(this, a, b2, "setState"); +}; +E$1.prototype.forceUpdate = function(a) { + this.updater.enqueueForceUpdate(this, a, "forceUpdate"); +}; +function F() { +} +F.prototype = E$1.prototype; +function G$1(a, b2, e2) { + this.props = a; + this.context = b2; + this.refs = D$1; + this.updater = e2 || B$1; +} +var H$1 = G$1.prototype = new F(); +H$1.constructor = G$1; +C$1(H$1, E$1.prototype); +H$1.isPureReactComponent = true; +var I$1 = Array.isArray, J = Object.prototype.hasOwnProperty, K$1 = { current: null }, L$1 = { key: true, ref: true, __self: true, __source: true }; +function M$1(a, b2, e2) { + var d2, c2 = {}, k2 = null, h2 = null; + if (null != b2) + for (d2 in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2) + J.call(b2, d2) && !L$1.hasOwnProperty(d2) && (c2[d2] = b2[d2]); + var g2 = arguments.length - 2; + if (1 === g2) + c2.children = e2; + else if (1 < g2) { + for (var f2 = Array(g2), m2 = 0; m2 < g2; m2++) + f2[m2] = arguments[m2 + 2]; + c2.children = f2; + } + if (a && a.defaultProps) + for (d2 in g2 = a.defaultProps, g2) + void 0 === c2[d2] && (c2[d2] = g2[d2]); + return { $$typeof: l$3, type: a, key: k2, ref: h2, props: c2, _owner: K$1.current }; +} +function N$1(a, b2) { + return { $$typeof: l$3, type: a.type, key: b2, ref: a.ref, props: a.props, _owner: a._owner }; +} +function O$1(a) { + return "object" === typeof a && null !== a && a.$$typeof === l$3; +} +function escape(a) { + var b2 = { "=": "=0", ":": "=2" }; + return "$" + a.replace(/[=:]/g, function(a2) { + return b2[a2]; + }); +} +var P$1 = /\/+/g; +function Q$1(a, b2) { + return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b2.toString(36); +} +function R$1(a, b2, e2, d2, c2) { + var k2 = typeof a; + if ("undefined" === k2 || "boolean" === k2) + a = null; + var h2 = false; + if (null === a) + h2 = true; + else + switch (k2) { + case "string": + case "number": + h2 = true; + break; + case "object": + switch (a.$$typeof) { + case l$3: + case n$3: + h2 = true; + } + } + if (h2) + return h2 = a, c2 = c2(h2), a = "" === d2 ? "." + Q$1(h2, 0) : d2, I$1(c2) ? (e2 = "", null != a && (e2 = a.replace(P$1, "$&/") + "/"), R$1(c2, b2, e2, "", function(a2) { + return a2; + })) : null != c2 && (O$1(c2) && (c2 = N$1(c2, e2 + (!c2.key || h2 && h2.key === c2.key ? "" : ("" + c2.key).replace(P$1, "$&/") + "/") + a)), b2.push(c2)), 1; + h2 = 0; + d2 = "" === d2 ? "." : d2 + ":"; + if (I$1(a)) + for (var g2 = 0; g2 < a.length; g2++) { + k2 = a[g2]; + var f2 = d2 + Q$1(k2, g2); + h2 += R$1(k2, b2, e2, f2, c2); + } + else if (f2 = A$1(a), "function" === typeof f2) + for (a = f2.call(a), g2 = 0; !(k2 = a.next()).done; ) + k2 = k2.value, f2 = d2 + Q$1(k2, g2++), h2 += R$1(k2, b2, e2, f2, c2); + else if ("object" === k2) + throw b2 = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b2 ? "object with keys {" + Object.keys(a).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead."); + return h2; +} +function S$1(a, b2, e2) { + if (null == a) + return a; + var d2 = [], c2 = 0; + R$1(a, d2, "", "", function(a2) { + return b2.call(e2, a2, c2++); + }); + return d2; +} +function T$1(a) { + if (-1 === a._status) { + var b2 = a._result; + b2 = b2(); + b2.then(function(b3) { + if (0 === a._status || -1 === a._status) + a._status = 1, a._result = b3; + }, function(b3) { + if (0 === a._status || -1 === a._status) + a._status = 2, a._result = b3; + }); + -1 === a._status && (a._status = 0, a._result = b2); + } + if (1 === a._status) + return a._result.default; + throw a._result; +} +var U$1 = { current: null }, V$1 = { transition: null }, W$1 = { ReactCurrentDispatcher: U$1, ReactCurrentBatchConfig: V$1, ReactCurrentOwner: K$1 }; +function X$1() { + throw Error("act(...) is not supported in production builds of React."); +} +react_production_min.Children = { map: S$1, forEach: function(a, b2, e2) { + S$1(a, function() { + b2.apply(this, arguments); + }, e2); +}, count: function(a) { + var b2 = 0; + S$1(a, function() { + b2++; + }); + return b2; +}, toArray: function(a) { + return S$1(a, function(a2) { + return a2; + }) || []; +}, only: function(a) { + if (!O$1(a)) + throw Error("React.Children.only expected to receive a single React element child."); + return a; +} }; +react_production_min.Component = E$1; +react_production_min.Fragment = p$4; +react_production_min.Profiler = r; +react_production_min.PureComponent = G$1; +react_production_min.StrictMode = q$3; +react_production_min.Suspense = w; +react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W$1; +react_production_min.act = X$1; +react_production_min.cloneElement = function(a, b2, e2) { + if (null === a || void 0 === a) + throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + "."); + var d2 = C$1({}, a.props), c2 = a.key, k2 = a.ref, h2 = a._owner; + if (null != b2) { + void 0 !== b2.ref && (k2 = b2.ref, h2 = K$1.current); + void 0 !== b2.key && (c2 = "" + b2.key); + if (a.type && a.type.defaultProps) + var g2 = a.type.defaultProps; + for (f2 in b2) + J.call(b2, f2) && !L$1.hasOwnProperty(f2) && (d2[f2] = void 0 === b2[f2] && void 0 !== g2 ? g2[f2] : b2[f2]); + } + var f2 = arguments.length - 2; + if (1 === f2) + d2.children = e2; + else if (1 < f2) { + g2 = Array(f2); + for (var m2 = 0; m2 < f2; m2++) + g2[m2] = arguments[m2 + 2]; + d2.children = g2; + } + return { $$typeof: l$3, type: a.type, key: c2, ref: k2, props: d2, _owner: h2 }; +}; +react_production_min.createContext = function(a) { + a = { $$typeof: u$2, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null }; + a.Provider = { $$typeof: t$2, _context: a }; + return a.Consumer = a; +}; +react_production_min.createElement = M$1; +react_production_min.createFactory = function(a) { + var b2 = M$1.bind(null, a); + b2.type = a; + return b2; +}; +react_production_min.createRef = function() { + return { current: null }; +}; +react_production_min.forwardRef = function(a) { + return { $$typeof: v$3, render: a }; +}; +react_production_min.isValidElement = O$1; +react_production_min.lazy = function(a) { + return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T$1 }; +}; +react_production_min.memo = function(a, b2) { + return { $$typeof: x, type: a, compare: void 0 === b2 ? null : b2 }; +}; +react_production_min.startTransition = function(a) { + var b2 = V$1.transition; + V$1.transition = {}; + try { + a(); + } finally { + V$1.transition = b2; + } +}; +react_production_min.unstable_act = X$1; +react_production_min.useCallback = function(a, b2) { + return U$1.current.useCallback(a, b2); +}; +react_production_min.useContext = function(a) { + return U$1.current.useContext(a); +}; +react_production_min.useDebugValue = function() { +}; +react_production_min.useDeferredValue = function(a) { + return U$1.current.useDeferredValue(a); +}; +react_production_min.useEffect = function(a, b2) { + return U$1.current.useEffect(a, b2); +}; +react_production_min.useId = function() { + return U$1.current.useId(); +}; +react_production_min.useImperativeHandle = function(a, b2, e2) { + return U$1.current.useImperativeHandle(a, b2, e2); +}; +react_production_min.useInsertionEffect = function(a, b2) { + return U$1.current.useInsertionEffect(a, b2); +}; +react_production_min.useLayoutEffect = function(a, b2) { + return U$1.current.useLayoutEffect(a, b2); +}; +react_production_min.useMemo = function(a, b2) { + return U$1.current.useMemo(a, b2); +}; +react_production_min.useReducer = function(a, b2, e2) { + return U$1.current.useReducer(a, b2, e2); +}; +react_production_min.useRef = function(a) { + return U$1.current.useRef(a); +}; +react_production_min.useState = function(a) { + return U$1.current.useState(a); +}; +react_production_min.useSyncExternalStore = function(a, b2, e2) { + return U$1.current.useSyncExternalStore(a, b2, e2); +}; +react_production_min.useTransition = function() { + return U$1.current.useTransition(); +}; +react_production_min.version = "18.3.1"; +{ + react.exports = react_production_min; +} +var reactExports = react.exports; +const React = /* @__PURE__ */ getDefaultExportFromCjs(reactExports); +const React$1 = /* @__PURE__ */ _mergeNamespaces({ + __proto__: null, + default: React +}, [reactExports]); +var freeGlobal = typeof global == "object" && global && global.Object === Object && global; +var freeSelf = typeof self == "object" && self && self.Object === Object && self; +var root = freeGlobal || freeSelf || Function("return this")(); +var Symbol$1 = root.Symbol; +var objectProto$d = Object.prototype; +var hasOwnProperty$a = objectProto$d.hasOwnProperty; +var nativeObjectToString$1 = objectProto$d.toString; +var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0; +function getRawTag(value) { + var isOwn = hasOwnProperty$a.call(value, symToStringTag$1), tag = value[symToStringTag$1]; + try { + value[symToStringTag$1] = void 0; + var unmasked = true; + } catch (e2) { + } + var result = nativeObjectToString$1.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag$1] = tag; + } else { + delete value[symToStringTag$1]; + } + } + return result; +} +var objectProto$c = Object.prototype; +var nativeObjectToString = objectProto$c.toString; +function objectToString(value) { + return nativeObjectToString.call(value); +} +var nullTag = "[object Null]", undefinedTag = "[object Undefined]"; +var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0; +function baseGetTag(value) { + if (value == null) { + return value === void 0 ? undefinedTag : nullTag; + } + return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); +} +function isObjectLike(value) { + return value != null && typeof value == "object"; +} +var symbolTag$1 = "[object Symbol]"; +function isSymbol(value) { + return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$1; +} +function arrayMap(array, iteratee) { + var index = -1, length2 = array == null ? 0 : array.length, result = Array(length2); + while (++index < length2) { + result[index] = iteratee(array[index], index, array); + } + return result; +} +var isArray$1 = Array.isArray; +var INFINITY$2 = 1 / 0; +var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0; +function baseToString(value) { + if (typeof value == "string") { + return value; + } + if (isArray$1(value)) { + return arrayMap(value, baseToString) + ""; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ""; + } + var result = value + ""; + return result == "0" && 1 / value == -INFINITY$2 ? "-0" : result; +} +var reWhitespace = /\s/; +function trimmedEndIndex(string) { + var index = string.length; + while (index-- && reWhitespace.test(string.charAt(index))) { + } + return index; +} +var reTrimStart = /^\s+/; +function baseTrim(string) { + return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string; +} +function isObject$2(value) { + var type = typeof value; + return value != null && (type == "object" || type == "function"); +} +var NAN = 0 / 0; +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; +var reIsBinary = /^0b[01]+$/i; +var reIsOctal = /^0o[0-7]+$/i; +var freeParseInt = parseInt; +function toNumber(value) { + if (typeof value == "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject$2(value)) { + var other = typeof value.valueOf == "function" ? value.valueOf() : value; + value = isObject$2(other) ? other + "" : other; + } + if (typeof value != "string") { + return value === 0 ? value : +value; + } + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; +} +var INFINITY$1 = 1 / 0, MAX_INTEGER = 17976931348623157e292; +function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY$1 || value === -INFINITY$1) { + var sign = value < 0 ? -1 : 1; + return sign * MAX_INTEGER; + } + return value === value ? value : 0; +} +function toInteger(value) { + var result = toFinite(value), remainder = result % 1; + return result === result ? remainder ? result - remainder : result : 0; +} +function identity(value) { + return value; +} +var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]"; +function isFunction$1(value) { + if (!isObject$2(value)) { + return false; + } + var tag = baseGetTag(value); + return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag; +} +var coreJsData = root["__core-js_shared__"]; +var maskSrcKey = function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; +}(); +function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; +} +var funcProto$2 = Function.prototype; +var funcToString$2 = funcProto$2.toString; +function toSource(func) { + if (func != null) { + try { + return funcToString$2.call(func); + } catch (e2) { + } + try { + return func + ""; + } catch (e2) { + } + } + return ""; +} +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; +var reIsHostCtor = /^\[object .+?Constructor\]$/; +var funcProto$1 = Function.prototype, objectProto$b = Object.prototype; +var funcToString$1 = funcProto$1.toString; +var hasOwnProperty$9 = objectProto$b.hasOwnProperty; +var reIsNative = RegExp( + "^" + funcToString$1.call(hasOwnProperty$9).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$" +); +function baseIsNative(value) { + if (!isObject$2(value) || isMasked(value)) { + return false; + } + var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} +function getValue$1(object, key) { + return object == null ? void 0 : object[key]; +} +function getNative(object, key) { + var value = getValue$1(object, key); + return baseIsNative(value) ? value : void 0; +} +var WeakMap$1 = getNative(root, "WeakMap"); +var defineProperty = function() { + try { + var func = getNative(Object, "defineProperty"); + func({}, "", {}); + return func; + } catch (e2) { + } +}(); +function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length2 = array.length, index = fromIndex + -1; + while (++index < length2) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; +} +var MAX_SAFE_INTEGER$1 = 9007199254740991; +var reIsUint = /^(?:0|[1-9]\d*)$/; +function isIndex(value, length2) { + var type = typeof value; + length2 = length2 == null ? MAX_SAFE_INTEGER$1 : length2; + return !!length2 && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length2); +} +function baseAssignValue(object, key, value) { + if (key == "__proto__" && defineProperty) { + defineProperty(object, key, { + "configurable": true, + "enumerable": true, + "value": value, + "writable": true + }); + } else { + object[key] = value; + } +} +function eq(value, other) { + return value === other || value !== value && other !== other; +} +var objectProto$a = Object.prototype; +var hasOwnProperty$8 = objectProto$a.hasOwnProperty; +function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty$8.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) { + baseAssignValue(object, key, value); + } +} +var MAX_SAFE_INTEGER = 9007199254740991; +function isLength(value) { + return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +} +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction$1(value); +} +var objectProto$9 = Object.prototype; +function isPrototype(value) { + var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$9; + return value === proto; +} +function baseTimes(n2, iteratee) { + var index = -1, result = Array(n2); + while (++index < n2) { + result[index] = iteratee(index); + } + return result; +} +var argsTag$2 = "[object Arguments]"; +function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag$2; +} +var objectProto$8 = Object.prototype; +var hasOwnProperty$7 = objectProto$8.hasOwnProperty; +var propertyIsEnumerable$1 = objectProto$8.propertyIsEnumerable; +var isArguments = baseIsArguments(/* @__PURE__ */ function() { + return arguments; +}()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty$7.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee"); +}; +function stubFalse() { + return false; +} +var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports; +var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module; +var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1; +var Buffer2 = moduleExports$1 ? root.Buffer : void 0; +var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0; +var isBuffer = nativeIsBuffer || stubFalse; +var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", objectTag$3 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", weakMapTag$1 = "[object WeakMap]"; +var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]"; +var typedArrayTags = {}; +typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true; +typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag$1] = false; +function baseIsTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; +} +function baseUnary(func) { + return function(value) { + return func(value); + }; +} +var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports; +var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module; +var moduleExports = freeModule && freeModule.exports === freeExports; +var freeProcess = moduleExports && freeGlobal.process; +var nodeUtil = function() { + try { + var types = freeModule && freeModule.require && freeModule.require("util").types; + if (types) { + return types; + } + return freeProcess && freeProcess.binding && freeProcess.binding("util"); + } catch (e2) { + } +}(); +var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; +var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; +var objectProto$7 = Object.prototype; +var hasOwnProperty$6 = objectProto$7.hasOwnProperty; +function arrayLikeKeys(value, inherited) { + var isArr = isArray$1(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length2 = result.length; + for (var key in value) { + if (hasOwnProperty$6.call(value, key) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode. + (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers. + isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays. + isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties. + isIndex(key, length2)))) { + result.push(key); + } + } + return result; +} +function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; +} +var nativeKeys = overArg(Object.keys, Object); +var objectProto$6 = Object.prototype; +var hasOwnProperty$5 = objectProto$6.hasOwnProperty; +function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty$5.call(object, key) && key != "constructor") { + result.push(key); + } + } + return result; +} +function keys$1(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +} +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/; +function isKey(value, object) { + if (isArray$1(value)) { + return false; + } + var type = typeof value; + if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object); +} +var nativeCreate = getNative(Object, "create"); +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; +} +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} +var HASH_UNDEFINED$2 = "__lodash_hash_undefined__"; +var objectProto$5 = Object.prototype; +var hasOwnProperty$4 = objectProto$5.hasOwnProperty; +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED$2 ? void 0 : result; + } + return hasOwnProperty$4.call(data, key) ? data[key] : void 0; +} +var objectProto$4 = Object.prototype; +var hasOwnProperty$3 = objectProto$4.hasOwnProperty; +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== void 0 : hasOwnProperty$3.call(data, key); +} +var HASH_UNDEFINED$1 = "__lodash_hash_undefined__"; +function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value; + return this; +} +function Hash(entries) { + var index = -1, length2 = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length2) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} +Hash.prototype.clear = hashClear; +Hash.prototype["delete"] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; +function listCacheClear() { + this.__data__ = []; + this.size = 0; +} +function assocIndexOf(array, key) { + var length2 = array.length; + while (length2--) { + if (eq(array[length2][0], key)) { + return length2; + } + } + return -1; +} +var arrayProto = Array.prototype; +var splice = arrayProto.splice; +function listCacheDelete(key) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; +} +function listCacheGet(key) { + var data = this.__data__, index = assocIndexOf(data, key); + return index < 0 ? void 0 : data[index][1]; +} +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} +function listCacheSet(key, value) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} +function ListCache(entries) { + var index = -1, length2 = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length2) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} +ListCache.prototype.clear = listCacheClear; +ListCache.prototype["delete"] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; +var Map$1 = getNative(root, "Map"); +function mapCacheClear() { + this.size = 0; + this.__data__ = { + "hash": new Hash(), + "map": new (Map$1 || ListCache)(), + "string": new Hash() + }; +} +function isKeyable(value) { + var type = typeof value; + return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null; +} +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map; +} +function mapCacheDelete(key) { + var result = getMapData(this, key)["delete"](key); + this.size -= result ? 1 : 0; + return result; +} +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} +function mapCacheSet(key, value) { + var data = getMapData(this, key), size = data.size; + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; +} +function MapCache(entries) { + var index = -1, length2 = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length2) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype["delete"] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; +var FUNC_ERROR_TEXT = "Expected a function"; +function memoize(func, resolver) { + if (typeof func != "function" || resolver != null && typeof resolver != "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache)(); + return memoized; +} +memoize.Cache = MapCache; +var MAX_MEMOIZE_SIZE = 500; +function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + var cache = result.cache; + return result; +} +var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; +var reEscapeChar = /\\(\\)?/g; +var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46) { + result.push(""); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match); + }); + return result; +}); +function toString(value) { + return value == null ? "" : baseToString(value); +} +function castPath(value, object) { + if (isArray$1(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); +} +var INFINITY = 1 / 0; +function toKey(value) { + if (typeof value == "string" || isSymbol(value)) { + return value; + } + var result = value + ""; + return result == "0" && 1 / value == -INFINITY ? "-0" : result; +} +function baseGet(object, path) { + path = castPath(path, object); + var index = 0, length2 = path.length; + while (object != null && index < length2) { + object = object[toKey(path[index++])]; + } + return index && index == length2 ? object : void 0; +} +function get$1(object, path, defaultValue) { + var result = object == null ? void 0 : baseGet(object, path); + return result === void 0 ? defaultValue : result; +} +function arrayPush(array, values) { + var index = -1, length2 = values.length, offset = array.length; + while (++index < length2) { + array[offset + index] = values[index]; + } + return array; +} +var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0; +function isFlattenable(value) { + return isArray$1(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]); +} +function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, length2 = array.length; + predicate || (predicate = isFlattenable); + result || (result = []); + while (++index < length2) { + var value = array[index]; + if (predicate(value)) { + { + arrayPush(result, value); + } + } else { + result[result.length] = value; + } + } + return result; +} +function flatten(array) { + var length2 = array == null ? 0 : array.length; + return length2 ? baseFlatten(array) : []; +} +var getPrototype = overArg(Object.getPrototypeOf, Object); +var objectTag$2 = "[object Object]"; +var funcProto = Function.prototype, objectProto$3 = Object.prototype; +var funcToString = funcProto.toString; +var hasOwnProperty$2 = objectProto$3.hasOwnProperty; +var objectCtorString = funcToString.call(Object); +function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag$2) { + return false; + } + var proto = getPrototype(value); + if (proto === null) { + return true; + } + var Ctor = hasOwnProperty$2.call(proto, "constructor") && proto.constructor; + return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString; +} +function stackClear() { + this.__data__ = new ListCache(); + this.size = 0; +} +function stackDelete(key) { + var data = this.__data__, result = data["delete"](key); + this.size = data.size; + return result; +} +function stackGet(key) { + return this.__data__.get(key); +} +function stackHas(key) { + return this.__data__.has(key); +} +var LARGE_ARRAY_SIZE = 200; +function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; +} +function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; +} +Stack.prototype.clear = stackClear; +Stack.prototype["delete"] = stackDelete; +Stack.prototype.get = stackGet; +Stack.prototype.has = stackHas; +Stack.prototype.set = stackSet; +function arrayFilter(array, predicate) { + var index = -1, length2 = array == null ? 0 : array.length, resIndex = 0, result = []; + while (++index < length2) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; +} +function stubArray() { + return []; +} +var objectProto$2 = Object.prototype; +var propertyIsEnumerable = objectProto$2.propertyIsEnumerable; +var nativeGetSymbols = Object.getOwnPropertySymbols; +var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); +}; +function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object)); +} +function getAllKeys(object) { + return baseGetAllKeys(object, keys$1, getSymbols); +} +var DataView = getNative(root, "DataView"); +var Promise$1 = getNative(root, "Promise"); +var Set$1 = getNative(root, "Set"); +var mapTag$1 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$1 = "[object Set]", weakMapTag = "[object WeakMap]"; +var dataViewTag$1 = "[object DataView]"; +var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap$1); +var getTag = baseGetTag; +if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$1 || Map$1 && getTag(new Map$1()) != mapTag$1 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$1 || WeakMap$1 && getTag(new WeakMap$1()) != weakMapTag) { + getTag = function(value) { + var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : ""; + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: + return dataViewTag$1; + case mapCtorString: + return mapTag$1; + case promiseCtorString: + return promiseTag; + case setCtorString: + return setTag$1; + case weakMapCtorString: + return weakMapTag; + } + } + return result; + }; +} +var Uint8Array2 = root.Uint8Array; +var HASH_UNDEFINED = "__lodash_hash_undefined__"; +function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; +} +function setCacheHas(value) { + return this.__data__.has(value); +} +function SetCache(values) { + var index = -1, length2 = values == null ? 0 : values.length; + this.__data__ = new MapCache(); + while (++index < length2) { + this.add(values[index]); + } +} +SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; +SetCache.prototype.has = setCacheHas; +function arraySome(array, predicate) { + var index = -1, length2 = array == null ? 0 : array.length; + while (++index < length2) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; +} +function cacheHas(cache, key) { + return cache.has(key); +} +var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2; +function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length; + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + var arrStacked = stack.get(array); + var othStacked = stack.get(other); + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array; + } + var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0; + stack.set(array, other); + stack.set(other, array); + while (++index < arrLength) { + var arrValue = array[index], othValue = other[index]; + if (customizer) { + var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== void 0) { + if (compared) { + continue; + } + result = false; + break; + } + if (seen) { + if (!arraySome(other, function(othValue2, othIndex) { + if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + result = false; + break; + } + } + stack["delete"](array); + stack["delete"](other); + return result; +} +function mapToArray(map) { + var index = -1, result = Array(map.size); + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; +} +function setToArray(set2) { + var index = -1, result = Array(set2.size); + set2.forEach(function(value) { + result[++index] = value; + }); + return result; +} +var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2; +var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]"; +var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]"; +var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0; +function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) { + return false; + } + object = object.buffer; + other = other.buffer; + case arrayBufferTag: + if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) { + return false; + } + return true; + case boolTag: + case dateTag: + case numberTag: + return eq(+object, +other); + case errorTag: + return object.name == other.name && object.message == other.message; + case regexpTag: + case stringTag: + return object == other + ""; + case mapTag: + var convert = mapToArray; + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4; + convert || (convert = setToArray); + if (object.size != other.size && !isPartial) { + return false; + } + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG$2; + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack["delete"](object); + return result; + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; +} +var COMPARE_PARTIAL_FLAG$3 = 1; +var objectProto$1 = Object.prototype; +var hasOwnProperty$1 = objectProto$1.hasOwnProperty; +function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length; + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) { + return false; + } + } + var objStacked = stack.get(object); + var othStacked = stack.get(other); + if (objStacked && othStacked) { + return objStacked == other && othStacked == object; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], othValue = other[key]; + if (customizer) { + var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); + } + if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) { + result = false; + break; + } + skipCtor || (skipCtor = key == "constructor"); + } + if (result && !skipCtor) { + var objCtor = object.constructor, othCtor = other.constructor; + if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) { + result = false; + } + } + stack["delete"](object); + stack["delete"](other); + return result; +} +var COMPARE_PARTIAL_FLAG$2 = 1; +var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]"; +var objectProto = Object.prototype; +var hasOwnProperty = objectProto.hasOwnProperty; +function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray$1(object), othIsArr = isArray$1(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other); + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag; + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack()); + return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__"); + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other; + stack || (stack = new Stack()); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack()); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); +} +function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); +} +var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2; +function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, length2 = index; + if (object == null) { + return !length2; + } + object = Object(object); + while (index--) { + var data = matchData[index]; + if (data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) { + return false; + } + } + while (++index < length2) { + data = matchData[index]; + var key = data[0], objValue = object[key], srcValue = data[1]; + if (data[2]) { + if (objValue === void 0 && !(key in object)) { + return false; + } + } else { + var stack = new Stack(); + var result; + if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) { + return false; + } + } + } + return true; +} +function isStrictComparable(value) { + return value === value && !isObject$2(value); +} +function getMatchData(object) { + var result = keys$1(object), length2 = result.length; + while (length2--) { + var key = result[length2], value = object[key]; + result[length2] = [key, value, isStrictComparable(value)]; + } + return result; +} +function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && (srcValue !== void 0 || key in Object(object)); + }; +} +function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + return function(object) { + return object === source || baseIsMatch(object, source, matchData); + }; +} +function baseHasIn(object, key) { + return object != null && key in Object(object); +} +function hasPath(object, path, hasFunc) { + path = castPath(path, object); + var index = -1, length2 = path.length, result = false; + while (++index < length2) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result || ++index != length2) { + return result; + } + length2 = object == null ? 0 : object.length; + return !!length2 && isLength(length2) && isIndex(key, length2) && (isArray$1(object) || isArguments(object)); +} +function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); +} +var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2; +function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + return function(object) { + var objValue = get$1(object, path); + return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); + }; +} +function baseProperty(key) { + return function(object) { + return object == null ? void 0 : object[key]; + }; +} +function basePropertyDeep(path) { + return function(object) { + return baseGet(object, path); + }; +} +function property(path) { + return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); +} +function baseIteratee(value) { + if (typeof value == "function") { + return value; + } + if (value == null) { + return identity; + } + if (typeof value == "object") { + return isArray$1(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value); + } + return property(value); +} +function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, iterable = Object(object), props = keysFunc(object), length2 = props.length; + while (length2--) { + var key = props[++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; +} +var baseFor = createBaseFor(); +function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys$1); +} +function createFind(findIndexFunc) { + return function(collection, predicate, fromIndex) { + var iterable = Object(collection); + if (!isArrayLike(collection)) { + var iteratee = baseIteratee(predicate); + collection = keys$1(collection); + predicate = function(key) { + return iteratee(iterable[key], key, iterable); + }; + } + var index = findIndexFunc(collection, predicate, fromIndex); + return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0; + }; +} +var nativeMax = Math.max; +function findIndex(array, predicate, fromIndex) { + var length2 = array == null ? 0 : array.length; + if (!length2) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length2 + index, 0); + } + return baseFindIndex(array, baseIteratee(predicate), index); +} +var find = createFind(findIndex); +function isEqual$1(value, other) { + return baseIsEqual(value, other); +} +function isEqualWith(value, other, customizer) { + customizer = typeof customizer == "function" ? customizer : void 0; + var result = customizer ? customizer(value, other) : void 0; + return result === void 0 ? baseIsEqual(value, other, void 0, customizer) : !!result; +} +function mapValues(object, iteratee) { + var result = {}; + iteratee = baseIteratee(iteratee); + baseForOwn(object, function(value, key, object2) { + baseAssignValue(result, key, iteratee(value, key, object2)); + }); + return result; +} +function baseSet(object, path, value, customizer) { + if (!isObject$2(object)) { + return object; + } + path = castPath(path, object); + var index = -1, length2 = path.length, lastIndex = length2 - 1, nested = object; + while (nested != null && ++index < length2) { + var key = toKey(path[index]), newValue = value; + if (key === "__proto__" || key === "constructor" || key === "prototype") { + return object; + } + if (index != lastIndex) { + var objValue = nested[key]; + newValue = void 0; + if (newValue === void 0) { + newValue = isObject$2(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {}; + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; +} +function set$1(object, path, value) { + return object == null ? object : baseSet(object, path, value); +} +function updateItem(items, item, update) { + const index = items.indexOf(item); + return [ + ...items.slice(0, index), + { ...item, ...update }, + ...items.slice(index + 1) + ]; +} +function replaceOrAddItem(items, matcher, item) { + const index = findIndex(items, matcher); + return index !== -1 ? [...items.slice(0, index), item, ...items.slice(index + 1)] : [...items, item]; +} +function removeItemMatch(items, matcher) { + const index = findIndex(items, matcher); + return index === -1 ? [...items] : [...items.slice(0, index), ...items.slice(index + 1)]; +} +function filterClassStateFixtureState(classStateFs, decoratorId) { + return classStateFs ? classStateFs.filter((s) => s.elementId.decoratorId === decoratorId) : []; +} +function findClassStateFixtureStateItem(classStateFs, elementId) { + return classStateFs && find(classStateFs, (s) => isEqual$1(s.elementId, elementId)); +} +function createClassStateFixtureStateItem({ classStateFs, elementId, values, componentName }) { + return replaceOrAddItem(classStateFs ?? [], createClassStateMatcher(elementId), { elementId, values, componentName }); +} +function updateClassStateFixtureStateItem({ classStateFs, elementId, values }) { + const item = expectClassStateItem(classStateFs, elementId); + return updateItem(classStateFs, item, { values }); +} +function removeClassStateFixtureStateItem(classStateFs, elementId) { + return removeItemMatch(classStateFs ?? [], createClassStateMatcher(elementId)); +} +function createClassStateMatcher(elementId) { + return (p2) => isEqual$1(p2.elementId, elementId); +} +function expectClassStateItem(classStateFs, elementId) { + const item = findClassStateFixtureStateItem(classStateFs, elementId); + if (!item) { + const elId = JSON.stringify(elementId); + throw new Error(`Fixture state class state missing for element "${elId}"`); + } + return item; +} +var reactIs$1 = { exports: {} }; +var reactIs_production_min$1 = {}; +/** + * @license React + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var b$1 = Symbol.for("react.element"), c$1 = Symbol.for("react.portal"), d$1 = Symbol.for("react.fragment"), e$1 = Symbol.for("react.strict_mode"), f$2 = Symbol.for("react.profiler"), g$1 = Symbol.for("react.provider"), h$1 = Symbol.for("react.context"), k$2 = Symbol.for("react.server_context"), l$2 = Symbol.for("react.forward_ref"), m$3 = Symbol.for("react.suspense"), n$2 = Symbol.for("react.suspense_list"), p$3 = Symbol.for("react.memo"), q$2 = Symbol.for("react.lazy"), t$1 = Symbol.for("react.offscreen"), u$1; +u$1 = Symbol.for("react.module.reference"); +function v$2(a) { + if ("object" === typeof a && null !== a) { + var r2 = a.$$typeof; + switch (r2) { + case b$1: + switch (a = a.type, a) { + case d$1: + case f$2: + case e$1: + case m$3: + case n$2: + return a; + default: + switch (a = a && a.$$typeof, a) { + case k$2: + case h$1: + case l$2: + case q$2: + case p$3: + case g$1: + return a; + default: + return r2; + } + } + case c$1: + return r2; + } + } +} +reactIs_production_min$1.ContextConsumer = h$1; +reactIs_production_min$1.ContextProvider = g$1; +reactIs_production_min$1.Element = b$1; +reactIs_production_min$1.ForwardRef = l$2; +reactIs_production_min$1.Fragment = d$1; +reactIs_production_min$1.Lazy = q$2; +reactIs_production_min$1.Memo = p$3; +reactIs_production_min$1.Portal = c$1; +reactIs_production_min$1.Profiler = f$2; +reactIs_production_min$1.StrictMode = e$1; +reactIs_production_min$1.Suspense = m$3; +reactIs_production_min$1.SuspenseList = n$2; +reactIs_production_min$1.isAsyncMode = function() { + return false; +}; +reactIs_production_min$1.isConcurrentMode = function() { + return false; +}; +reactIs_production_min$1.isContextConsumer = function(a) { + return v$2(a) === h$1; +}; +reactIs_production_min$1.isContextProvider = function(a) { + return v$2(a) === g$1; +}; +reactIs_production_min$1.isElement = function(a) { + return "object" === typeof a && null !== a && a.$$typeof === b$1; +}; +reactIs_production_min$1.isForwardRef = function(a) { + return v$2(a) === l$2; +}; +reactIs_production_min$1.isFragment = function(a) { + return v$2(a) === d$1; +}; +reactIs_production_min$1.isLazy = function(a) { + return v$2(a) === q$2; +}; +reactIs_production_min$1.isMemo = function(a) { + return v$2(a) === p$3; +}; +reactIs_production_min$1.isPortal = function(a) { + return v$2(a) === c$1; +}; +reactIs_production_min$1.isProfiler = function(a) { + return v$2(a) === f$2; +}; +reactIs_production_min$1.isStrictMode = function(a) { + return v$2(a) === e$1; +}; +reactIs_production_min$1.isSuspense = function(a) { + return v$2(a) === m$3; +}; +reactIs_production_min$1.isSuspenseList = function(a) { + return v$2(a) === n$2; +}; +reactIs_production_min$1.isValidElementType = function(a) { + return "string" === typeof a || "function" === typeof a || a === d$1 || a === f$2 || a === e$1 || a === m$3 || a === n$2 || a === t$1 || "object" === typeof a && null !== a && (a.$$typeof === q$2 || a.$$typeof === p$3 || a.$$typeof === g$1 || a.$$typeof === h$1 || a.$$typeof === l$2 || a.$$typeof === u$1 || void 0 !== a.getModuleId) ? true : false; +}; +reactIs_production_min$1.typeOf = v$2; +{ + reactIs$1.exports = reactIs_production_min$1; +} +var reactIsExports$1 = reactIs$1.exports; +function isString$1(value) { + return typeof value === "string"; +} +function isNumber(value) { + return typeof value === "number"; +} +function isBoolean(value) { + return typeof value === "boolean"; +} +function isNull(value) { + return value === null; +} +function isUndefined(value) { + return value === void 0; +} +function isPrimitiveData(data) { + return isString$1(data) || isNumber(data) || isBoolean(data) || isNull(data) || isUndefined(data); +} +function isObject$1(data) { + return isPlainObject(data) && !reactIsExports$1.isElement(data); +} +function isArray(data) { + return Array.isArray(data); +} +function createValues(obj) { + const values = {}; + Object.keys(obj).forEach((key) => { + values[key] = createValue(obj[key]); + }); + return values; +} +function createValue(data) { + if (isPrimitiveData(data)) + return { type: "primitive", data }; + if (isArray(data)) + return { + type: "array", + values: data.map((i) => createValue(i)) + }; + if (isObject$1(data)) + return { + type: "object", + values: createValues(data) + }; + return { + type: "unserializable", + stringifiedData: stringifyUnserializableData(data) + }; +} +function stringifyUnserializableData(data) { + return reactIsExports$1.isElement(data) ? "" : String(data); +} +function extendWithValues(obj, values) { + const extendedObj = {}; + Object.keys(values).forEach((key) => { + extendedObj[key] = extendWithValue(obj[key], values[key]); + }); + return extendedObj; +} +function extendWithValue(data, value) { + if (value.type === "unserializable") + return data; + if (value.type === "object") { + const obj = isObject$1(data) ? data : {}; + return extendWithValues(obj, value.values); + } + if (value.type === "array") { + const array = isArray(data) ? data : []; + return value.values.map((v2, idx) => extendWithValue(array[idx], v2)); + } + return value.data; +} +function fixtureStateByName(fixtureState, name) { + return fixtureState[name]; +} +function updateFixtureState(fixtureState, name, change) { + const prevFs = fixtureStateByName(fixtureState, name); + const nextFs = applyFixtureStateChange(prevFs, change); + if (nextFs === prevFs) { + return fixtureState; + } + return { + ...fixtureState, + [name]: nextFs + }; +} +function applyFixtureStateChange(prevState, change) { + return isStateUpdater(change) ? change(prevState) : change; +} +function isStateUpdater(change) { + return typeof change === "function"; +} +const DEFAULT_RENDER_KEY = 0; +function filterPropsFixtureState(propsFs, decoratorId) { + return propsFs ? propsFs.filter((p2) => p2.elementId.decoratorId === decoratorId) : []; +} +function findPropsFixtureStateItem(propsFs, elementId) { + return propsFs && find(propsFs, (p2) => isEqual$1(p2.elementId, elementId)); +} +function createPropsFixtureStateItem({ propsFs, elementId, values, componentName }) { + return replaceOrAddItem(propsFs ?? [], createPropsMatcher(elementId), { + elementId, + values, + renderKey: DEFAULT_RENDER_KEY, + componentName + }); +} +function updatePropsFixtureStateItem({ propsFs, elementId, values }) { + const item = expectPropsItem(propsFs, elementId); + return updateItem(propsFs, item, { values }); +} +function removePropsFixtureStateItem(propsFs, elementId) { + return removeItemMatch(propsFs ?? [], createPropsMatcher(elementId)); +} +function createPropsMatcher(elementId) { + return (p2) => isEqual$1(p2.elementId, elementId); +} +function expectPropsItem(propsFs, elementId) { + const item = findPropsFixtureStateItem(propsFs, elementId); + if (!item) { + const elId = JSON.stringify(elementId); + throw new Error(`Fixture state props missing for element "${elId}"`); + } + return item; +} +function rendererSocketMessage(message) { + return { channel: "renderer", message }; +} +function parseQueryString(query) { + return Object.fromEntries(new URLSearchParams(query)); +} +function registerPlaygroundShortcuts(runCommand) { + window.addEventListener("keydown", handleWindowKeyDown); + function run(e2, command) { + e2.preventDefault(); + runCommand(command); + } + function handleWindowKeyDown(e2) { + if (isEditing(e2) && !e2.metaKey) { + return; + } + const keyChar = String.fromCharCode(e2.keyCode); + const metaKey = e2.metaKey || e2.ctrlKey; + if (metaKey) { + if (keyChar === "K") { + run(e2, "searchFixtures"); + } + } else { + if (keyChar === "L") { + run(e2, "toggleFixtureList"); + } else if (keyChar === "P") { + run(e2, "toggleControlPanel"); + } else if (keyChar === "F") { + run(e2, "goFullScreen"); + } else if (keyChar === "S") { + run(e2, "openFixture"); + } else if (keyChar === "R") { + run(e2, "reloadRenderer"); + } + } + } + return () => { + window.removeEventListener("keydown", handleWindowKeyDown); + }; +} +function isEditing(e2) { + if (e2.target instanceof HTMLElement && e2.target.isContentEditable) { + return true; + } + const activeElement = document.activeElement; + return activeElement && isInputTag(activeElement.tagName); +} +function isInputTag(tagName) { + const inputTags = ["input", "textarea", "select"]; + return inputTags.includes(tagName.toLowerCase()); +} +function parseRendererQueryString(query) { + return decodeRendererSearchParams(parseQueryString(query)); +} +function decodeRendererSearchParams(stringParams) { + const params = {}; + if (stringParams.fixtureId) { + params.fixtureId = JSON.parse(stringParams.fixtureId); + } + if (stringParams.locked) { + params.locked = stringParams.locked === "true"; + } + return params; +} +function isMultiFixture(fixtureExport) { + return fixtureExport !== null && typeof fixtureExport === "object" && !reactIsExports$1.isElement(fixtureExport); +} +function getFixtureFromExport(fixtureExport, fixtureName) { + if (fixtureName === void 0) { + if (isMultiFixture(fixtureExport)) { + const fixtureNames = Object.keys(fixtureExport); + return fixtureExport[fixtureNames[0]]; + } + return fixtureExport; + } + if (!isMultiFixture(fixtureExport)) { + return; + } + return fixtureExport[fixtureName]; +} +function getFixtureListFromWrappers(wrappers) { + return Object.keys(wrappers.fixtures).reduce((acc, fixturePath) => { + return { + ...acc, + [fixturePath]: wrappers.lazy ? { type: "single" } : getFixtureItemFromExport(wrappers.fixtures[fixturePath].module.default) + }; + }, {}); +} +function getFixtureItemFromExport(fixtureExport) { + return isMultiFixture(fixtureExport) ? { type: "multi", fixtureNames: Object.keys(fixtureExport) } : { type: "single" }; +} +function getSortedDecoratorsForFixturePath(fixturePath, decoratorsByPath) { + return getSortedDecorators(getDecoratorsForFixturePath(decoratorsByPath, fixturePath)); +} +function getDecoratorsForFixturePath(decoratorsByPath, fixturePath) { + return Object.keys(decoratorsByPath).filter((dPath) => isParentDir(getParentPath(dPath), fixturePath)).reduce((acc, dPath) => ({ ...acc, [dPath]: decoratorsByPath[dPath] }), {}); +} +function isParentDir(parentPath, filePath) { + return parentPath === "" || filePath.indexOf(`${parentPath}/`) === 0; +} +function getParentPath(nestedPath) { + return nestedPath.replace(/^((.+)\/)?.+$/, "$2"); +} +function getSortedDecorators(decoratorsByPath) { + return sortPathsByDepthAsc(Object.keys(decoratorsByPath)).map((decoratorPath) => decoratorsByPath[decoratorPath]); +} +function sortPathsByDepthAsc(paths) { + return [...paths].sort((a, b2) => getPathNestingLevel(a) - getPathNestingLevel(b2) || a.localeCompare(b2)); +} +function getPathNestingLevel(path) { + return path.split("/").length; +} +function stringifyFixtureId(fixtureId) { + const { path, name } = fixtureId; + return name ? `${path}-${name}` : path; +} +function DelayRender({ children, delay }) { + const [render2, setRender] = React.useState(false); + React.useEffect(() => { + const timeoutId = setTimeout(() => setRender(true), delay); + return () => clearTimeout(timeoutId); + }, [delay]); + return render2 && children; +} +const componentNames = /* @__PURE__ */ new WeakMap(); +function getComponentName(type) { + if (typeof type === "string") { + return type; + } + if (!componentNames.has(type)) { + const name = type.displayName || type.name || ""; + componentNames.set(type, name); + } + return componentNames.get(type); +} +function isReactElement(node2) { + return reactIsExports$1.isElement(node2); +} +function areNodesEqual(node1, node2, strictTypeCheck) { + if (isReactElement(node1) && isReactElement(node2)) + return areElementsEqual(node1, node2, strictTypeCheck); + if (Array.isArray(node1) && Array.isArray(node2)) + return areArrayNodesEqual(node1, node2, strictTypeCheck); + return isEqual$1(node1, node2); +} +function areElementsEqual(element1, element2, strictTypeCheck) { + if (!areElementTypesEqual(element1.type, element2.type, strictTypeCheck)) + return false; + return element1.key === element2.key && // @ts-ignore + element1.ref === element2.ref && // Children (and props in general) can contain Elements and other Nodes + arePropsEqual(element1.props, element2.props); +} +function areElementTypesEqual(type1, type2, strictTypeCheck) { + return strictTypeCheck ? type1 === type2 : getComponentName(type1) === getComponentName(type2); +} +function areArrayNodesEqual(node1, node2, strictTypeCheck) { + if (node1.length !== node2.length) + return false; + return node1.every((node3, nodeIndex) => areNodesEqual(node3, node2[nodeIndex], strictTypeCheck)); +} +function arePropsEqual(object1, object2) { + if (!isEqual$1(Object.keys(object1), Object.keys(object2))) + return false; + return Object.keys(object1).every((key) => isEqualWith(object1[key], object2[key], (value1, value2) => typeof value1 === "function" && typeof value2 === "function" ? value1 === value2 || value1.toString() === value2.toString() : isEqual$1(value1, value2))); +} +function uuid$1(a) { + return a ? (Number(a) ^ Math.random() * 16 >> Number(a) / 4).toString(16) : ("10000000-1000-4000-8000" + -1e11).replace(/[018]/g, uuid$1); +} +function isInsideWindowIframe() { + try { + return window.self !== window.parent; + } catch (e2) { + return true; + } +} +const FixtureContext = React.createContext({ + fixtureState: {}, + setFixtureState: () => { + } +}); +function useFixtureState(name) { + const { fixtureState, setFixtureState } = reactExports.useContext(FixtureContext); + return [ + fixtureStateByName(fixtureState, name), + reactExports.useCallback((change) => { + setFixtureState((prevFs) => updateFixtureState(prevFs, name, change)); + }, [name, setFixtureState]) + ]; +} +function getChildrenPath(elPath) { + return isRootPath(elPath) ? "props.children" : `${elPath}.props.children`; +} +function isRootPath(elPath) { + return elPath === ""; +} +function findElementPaths(node2, curPath = "") { + if (Array.isArray(node2)) { + return flatten(node2.map((child, idx) => findElementPaths(child, `${curPath}[${idx}]`))); + } + if (!isReactElement(node2)) { + return []; + } + const { children } = node2.props; + const childElPaths = ( + // Props of elements returned by render functions can't be read here + typeof children !== "function" ? findElementPaths(children, getChildrenPath(curPath)) : [] + ); + return node2.type === reactExports.Fragment ? childElPaths : [curPath, ...childElPaths]; +} +function getElementAtPath(node2, elPath) { + if (!isReactElement(node2) && !Array.isArray(node2)) { + return null; + } + const rootNode = node2; + const childNode = isRootPath(elPath) ? rootNode : get$1(rootNode, elPath); + if (!isReactElement(childNode)) { + return null; + } + return childNode; +} +function getExpectedElementAtPath(node2, elPath) { + const el2 = getElementAtPath(node2, elPath); + if (!el2) { + throw new Error(`Element not found at path: ${elPath}`); + } + return el2; +} +function setElementAtPath(node2, elPath, updater) { + const childEl = getExpectedElementAtPath(node2, elPath); + const newEl = updater(childEl); + if (isRootPath(elPath)) { + return newEl; + } + const clonedRoot = cloneNode(node2); + return set$1(clonedRoot, elPath, newEl); +} +function cloneNode(value) { + return Array.isArray(value) ? value.map((n2) => cloneNodeItem(n2)) : cloneNodeItem(value); +} +function cloneNodeItem(value) { + return isReactElement(value) ? cloneReactElement(value) : value; +} +function cloneReactElement(value) { + const { children, ...otherProps } = value.props; + return { + ...value, + props: { + ...otherProps, + children: cloneNode(children) + } + }; +} +function findRelevantElementPaths(node2) { + const elPaths = findElementPaths(node2); + return elPaths.filter((elPath) => { + const { type } = getExpectedElementAtPath(node2, elPath); + if (typeof type === "symbol") + return false; + if (typeof type === "string") + return isInterestingTag(type); + const classType = type; + return classType.cosmosCapture !== false && isInterestingClass(classType); + }); +} +function isInterestingTag(tagName) { + return tagName !== "div" && tagName !== "span"; +} +function isInterestingClass(type) { + return type.name !== "StyledComponent"; +} +function isRefSupported(elementType) { + if (typeof elementType === "string") { + return false; + } + const { $$typeof, prototype } = elementType; + return $$typeof === reactIsExports$1.ForwardRef || // Warning: Some functions don't have the .prototype property + prototype && // ES6 Class + // Warning: This will return false is the component is extending a + // different copy of React than the one used by Cosmos. This is relevant + // when running Cosmos from an external location instead of node_modules. + (prototype instanceof React.Component || // React.createClass + prototype.getInitialState !== void 0) && true; +} +function decorateFixtureRefs(fixture, spyRef, cachedRefHandlers) { + const elPaths = findRelevantElementPaths(fixture); + return elPaths.reduce((decoratedFixture, elPath) => { + return setElementAtPath(decoratedFixture, elPath, (element) => { + if (!isRefSupported(element.type)) { + return element; + } + return reactExports.cloneElement(element, { + ref: getDecoratedRef(element.ref, spyRef, elPath, cachedRefHandlers) + }); + }); + }, fixture); +} +function getDecoratedRef(origRef, spyRef, elPath, cachedRefHandlers) { + const found = cachedRefHandlers[elPath]; + if (found && found.origRef === origRef) { + return found.handler; + } + const handler = decorateRefWithSpy(origRef, spyRef, elPath); + cachedRefHandlers[elPath] = { origRef, handler }; + return handler; +} +function decorateRefWithSpy(origRef, spyRef, elPath) { + return (elRef) => { + if (origRef) { + callOriginalRef(origRef, elRef); + } + spyRef(elPath, elRef); + }; +} +function callOriginalRef(ref, elRef) { + if (typeof ref === "string") { + console.warn("[decorateFixtureRefs] String refs are not supported"); + return; + } + if (typeof ref === "function") { + ref(elRef); + return; + } + const refObj = ref; + refObj.current = elRef; +} +function replaceState(elRef, nextState) { + const fullState = resetOriginalKeys(elRef.state, nextState); + if (!isEqual$1(fullState, elRef.state)) { + elRef.setState(fullState); + } +} +function resetOriginalKeys(original, current) { + return Object.keys(original).reduce((result, key) => Object.keys(result).indexOf(key) === -1 ? { ...result, [key]: void 0 } : result, current); +} +function useFixtureClassState(fixture, decoratorId, elRefs) { + const elPaths = findRelevantElementPaths(fixture); + const [classStateFs, setClassStateFs] = useFixtureState("classState"); + const lastFsRef = useFixtureStateRef(classStateFs); + const prevFsRef = reactExports.useRef(classStateFs); + const initialStates = reactExports.useRef({}); + const cachedRefHandlers = reactExports.useRef({}); + reactExports.useEffect(() => { + return () => { + initialStates.current = {}; + cachedRefHandlers.current = {}; + }; + }, []); + reactExports.useEffect(() => { + const decoratorFs = filterClassStateFixtureState(classStateFs, decoratorId); + decoratorFs.forEach(({ elementId }) => { + const { elPath } = elementId; + if (elPaths.indexOf(elementId.elPath) === -1) { + setClassStateFs((prevFs) => removeClassStateFixtureStateItem(prevFs, elementId)); + if (elRefs.current[elPath]) { + delete elRefs.current[elPath]; + delete initialStates.current[elPath]; + delete cachedRefHandlers.current[elPath]; + } + } + }); + elPaths.forEach((elPath) => { + const elementId = { decoratorId, elPath }; + const fsItem = findClassStateFixtureStateItem(classStateFs, elementId); + if (!fsItem) { + if (initialStates.current[elPath]) { + const { state } = initialStates.current[elPath]; + const elRef = elRefs.current[elPath]; + if (!isEqual$1(elRef.state, state)) { + replaceState(elRef, state); + } + setClassStateFs((prevFs) => createClassStateFixtureStateItem({ + classStateFs: prevFs, + elementId, + values: createValues(state), + componentName: getComponentName(elRef.constructor) + })); + } + } else { + const elRef = elRefs.current[elPath]; + if (!elRef) { + return; + } + const prevFsItem = findClassStateFixtureStateItem(prevFsRef.current, elementId); + if (prevFsItem && !isEqual$1(prevFsItem, fsItem)) { + return replaceState(elRef, extendWithValues(elRef.state, fsItem.values)); + } + } + }); + }, [classStateFs, decoratorId, elPaths, elRefs, setClassStateFs]); + reactExports.useEffect(() => { + prevFsRef.current = classStateFs; + }); + return decorateFixtureRefs(fixture, handleRef, cachedRefHandlers.current); + function handleRef(elPath, elRef) { + if (!elRef) { + delete elRefs.current[elPath]; + return; + } + const { state } = elRef; + if (!state) { + return; + } + elRefs.current[elPath] = elRef; + setInitialState(initialStates.current, elPath, elRef); + const elementId = { decoratorId, elPath }; + const fsClassState = findClassStateFixtureStateItem(lastFsRef.current, elementId); + if (!fsClassState) { + setClassStateFs((prevFs) => createClassStateFixtureStateItem({ + classStateFs: prevFs, + elementId, + values: createValues(state), + componentName: getComponentName(elRef.constructor) + })); + } else { + replaceState(elRef, extendWithValues(state, fsClassState.values)); + } + } +} +function useFixtureStateRef(classStateFs) { + const ref = reactExports.useRef(classStateFs); + reactExports.useEffect(() => { + ref.current = classStateFs; + }); + return ref; +} +function setInitialState(initialStates, elPath, elRef) { + const found = initialStates[elPath]; + const type = elRef.constructor; + const initialStateExists = found && found.type === type; + if (!initialStateExists && elRef.state) { + initialStates[elPath] = { type, state: elRef.state }; + } +} +const REFRESH_INTERVAL = 200; +function useReadClassState(fixture, decoratorId, elRefs) { + const elPaths = findRelevantElementPaths(fixture); + const [classStateFs, setClassStateFs] = useFixtureState("classState"); + const timeoutId = reactExports.useRef(null); + reactExports.useEffect(() => { + scheduleStateCheck(); + return () => { + if (timeoutId.current) { + clearTimeout(timeoutId.current); + } + }; + }); + function scheduleStateCheck() { + timeoutId.current = window.setTimeout(checkState, REFRESH_INTERVAL); + } + function checkState() { + let fixtureStateChangeScheduled = false; + Object.keys(elRefs.current).map(async (elPath) => { + if (elPaths.indexOf(elPath) === -1) { + throw new Error(`[FixtureCapture] Child ref exists for missing element path "${elPath}"`); + } + const { state } = elRefs.current[elPath]; + const elementId = { decoratorId, elPath }; + const fsItem = findClassStateFixtureStateItem(classStateFs, elementId); + if (fsItem && state && !doesFixtureStateMatchClassState(fsItem, state)) { + fixtureStateChangeScheduled = true; + setClassStateFs((prevFs) => updateClassStateFixtureStateItem({ + classStateFs: prevFs, + elementId, + values: createValues(state) + })); + } + }); + if (!fixtureStateChangeScheduled) { + scheduleStateCheck(); + } + } +} +function doesFixtureStateMatchClassState(fsClassState, state) { + return isEqual$1(state, extendWithValues(state, fsClassState.values)); +} +function useClassStateCapture(fixture, decoratorId) { + const elRefs = React.useRef({}); + React.useEffect(() => { + return () => { + elRefs.current = {}; + }; + }, []); + useReadClassState(fixture, decoratorId, elRefs); + return useFixtureClassState(fixture, decoratorId, elRefs); +} +function useFixtureProps(fixture, propsFs, decoratorId) { + const propCache = React.useMemo( + () => ({}), + // React.useMemo is used as a cache invalidated by decoratorId + // eslint-disable-next-line react-hooks/exhaustive-deps + [decoratorId] + ); + const elPaths = findRelevantElementPaths(fixture); + return elPaths.reduce((extendedFixture, elPath) => { + const elementId = { decoratorId, elPath }; + const fsItem = findPropsFixtureStateItem(propsFs, elementId); + return setElementAtPath(extendedFixture, elPath, (element) => { + if (!fsItem || componentTypeChanged(fsItem.componentName)) { + return { + ...element, + key: getElRenderKey(elPath, DEFAULT_RENDER_KEY) + }; + } + const originalProps = element.props; + const extendedProps = extendWithValues(originalProps, fsItem.values); + const cachedProps = mapValues(extendedProps, (value, propName) => { + const key = getPropCacheKey(elPath, propName); + if (!propCache.hasOwnProperty(key)) + propCache[key] = originalProps[propName]; + if (isEqual$1(propCache[key], value)) + return propCache[key]; + propCache[key] = value; + return value; + }); + return { + ...element, + props: hasChildElPaths(elPaths, elPath) ? { ...cachedProps, children: originalProps.children } : cachedProps, + key: getElRenderKey(elPath, fsItem.renderKey) + }; + function componentTypeChanged(componentName) { + return componentName !== getComponentName(element.type); + } + }); + }, fixture); +} +function getPropCacheKey(elPath, propName) { + return elPath ? `${elPath}-${propName}` : propName; +} +function getElRenderKey(elPath, renderKey) { + return `${elPath}-${renderKey}`; +} +function hasChildElPaths(elPaths, elPath) { + return elPaths.some((p2) => p2.indexOf(getChildrenPath(elPath)) === 0); +} +function usePropsCapture(fixture, decoratorId) { + const [propsFs, setPropsFs] = useFixtureState("props"); + const prevFixtureRef = reactExports.useRef(null); + const elPaths = findRelevantElementPaths(fixture); + reactExports.useEffect(() => { + if (!propsFs && elPaths.length === 0) { + setPropsFs((prevFs) => prevFs ?? []); + return; + } + const decoratorFs = filterPropsFixtureState(propsFs, decoratorId); + decoratorFs.forEach(({ elementId }) => { + if (elPaths.indexOf(elementId.elPath) === -1) { + setPropsFs((prevFs) => removePropsFixtureStateItem(prevFs, elementId)); + } + }); + elPaths.forEach((elPath) => { + const childEl = getExpectedElementAtPath(fixture, elPath); + const elementId = { decoratorId, elPath }; + if (!findPropsFixtureStateItem(propsFs, elementId)) { + const componentName = getComponentName(childEl.type); + setPropsFs((prevFs) => createPropsFixtureStateItem({ + propsFs: prevFs, + elementId, + values: createValues(childEl.props), + componentName + })); + } else { + const prevChildEl = getElementAtPath(prevFixtureRef.current, elPath); + if (!areNodesEqual(prevChildEl, childEl, false)) { + setPropsFs((prevFs) => updatePropsFixtureStateItem({ + propsFs: prevFs, + elementId, + values: createValues(childEl.props) + })); + } + } + }); + }, [decoratorId, elPaths, fixture, propsFs, setPropsFs]); + reactExports.useEffect(() => { + prevFixtureRef.current = fixture; + }); + return useFixtureProps(fixture, propsFs, decoratorId); +} +function FixtureCapture({ children, decoratorId }) { + let fixture = usePropsCapture(children, decoratorId); + fixture = useClassStateCapture(fixture, decoratorId); + return fixture; +} +function createFixtureNode(fixture) { + return isFunctionFixture(fixture) ? React.createElement(FixtureElement, { Component: fixture }) : fixture; +} +function isFunctionFixture(fixture) { + return typeof fixture === "function"; +} +function FixtureElement({ Component }) { + return React.createElement(Component, null); +} +FixtureElement.cosmosCapture = false; +function decorateFixture(fixtureNode, decorators) { + return React.createElement(React.Fragment, null, [...decorators].reverse().reduce((prevElement, Decorator) => React.createElement(Decorator, null, prevElement), fixtureNode)); +} +function DecoratedFixture({ fixture, userDecoratorModules, globalDecorators: globalDecorators2 = [] }) { + return reactExports.useMemo(() => { + const decorators = [ + ...globalDecorators2, + ...userDecoratorModules.map((m2) => m2.default) + ]; + return decorateFixture(React.createElement(FixtureCapture, { decoratorId: "root" }, createFixtureNode(fixture)), decorators); + }, [fixture, globalDecorators2, userDecoratorModules]); +} +const RendererContext = React.createContext({ + rendererId: "default-renderer-id", + rendererConnect: { + postMessage: () => { + }, + onMessage: () => () => { + } + }, + locked: false, + selectedFixture: null, + selectFixture: () => { + }, + unselectFixture: () => { + }, + reloadRenderer: () => { + }, + lazyItems: {}, + setLazyItems: () => { + } +}); +function FixtureProvider(props) { + const [state, setState] = React.useState({ + fixtureState: props.initialFixtureState || {}, + syncedFixtureState: {} + }); + const { rendererId, rendererConnect, setLazyItems } = React.useContext(RendererContext); + React.useEffect(() => { + if (props.lazy) { + setLazyItems(props.fixtureItem.type === "multi" ? { [props.fixtureId.path]: props.fixtureItem } : noLazyItem); + } + }, [props.fixtureId.path, props.fixtureItem, props.lazy, setLazyItems]); + React.useEffect(() => { + if (!isEqual$1(state.fixtureState, state.syncedFixtureState)) { + rendererConnect.postMessage({ + type: "fixtureStateChange", + payload: { + rendererId, + fixtureId: props.fixtureId, + fixtureState: state.fixtureState + } + }); + setState((prevState) => ({ + ...prevState, + syncedFixtureState: state.fixtureState + })); + } + }, [ + props.fixtureId, + rendererConnect, + rendererId, + state.fixtureState, + state.syncedFixtureState + ]); + React.useEffect(() => rendererConnect.onMessage((msg) => { + if (msg.type === "setFixtureState" && msg.payload.rendererId === rendererId) { + const { fixtureId, fixtureState } = msg.payload; + setState((prevState) => ( + // Ensure fixture state applies to currently selected fixture + isEqual$1(fixtureId, props.fixtureId) ? { ...prevState, fixtureState, syncedFixtureState: fixtureState } : prevState + )); + } + }), [props.fixtureId, rendererConnect, rendererId]); + const setFixtureState = React.useCallback((stateUpdate) => { + setState((prevState) => ({ + ...prevState, + fixtureState: stateUpdate(prevState.fixtureState) + })); + }, [setState]); + const contextValue = React.useMemo(() => ({ fixtureState: state.fixtureState, setFixtureState }), [setFixtureState, state.fixtureState]); + return React.createElement(FixtureContext.Provider, { value: contextValue }, props.children); +} +const noLazyItem = {}; +function FixtureModule({ fixtureModule, decoratorModules, globalDecorators: globalDecorators2, fixtureId, initialFixtureState, renderKey, lazy, renderMessage: renderMessage2 }) { + const fixtureItem = React.useMemo(() => getFixtureItemFromExport(fixtureModule.default), [fixtureModule.default]); + const fixtureKey = React.useMemo(() => `${stringifyFixtureId(fixtureId)}-${renderKey}`, [fixtureId, renderKey]); + const fixture = getFixtureFromExport(fixtureModule.default, fixtureId.name); + if (typeof fixture === "undefined") { + return renderMessage2(`Invalid fixture name: ${fixtureId.name}`); + } + return React.createElement( + FixtureProvider, + { key: fixtureKey, fixtureId, initialFixtureState, fixtureItem, lazy }, + React.createElement(DecoratedFixture, { fixture, userDecoratorModules: decoratorModules, globalDecorators: globalDecorators2 }) + ); +} +async function importLazyFixtureModules(fixtureWrapper, decoratorWrappers) { + return { + fixtureModule: await fixtureWrapper.getModule(), + decoratorModules: await Promise.all(decoratorWrappers.map((d2) => d2.getModule())) + }; +} +function LazyModuleLoader({ fixtureWrapper, decorators, fixturePath, renderModules }) { + const modules = useLazyFixtureModules(fixturePath, fixtureWrapper, decorators); + return modules && renderModules(modules); +} +function useLazyFixtureModules(fixturePath, fixtureWrapper, decoratorWrappers) { + const [state, setState] = React.useState(null); + React.useEffect(() => { + let canceled = false; + (async () => { + const modules = await importLazyFixtureModules(fixtureWrapper, getSortedDecoratorsForFixturePath(fixturePath, decoratorWrappers)); + if (!canceled) { + setState({ fixturePath, modules }); + } + })(); + return () => { + canceled = true; + }; + }, [decoratorWrappers, fixturePath, fixtureWrapper]); + return state && state.fixturePath === fixturePath ? state.modules : null; +} +function StaticModuleLoader({ fixtureWrapper, decorators, fixturePath, renderModules }) { + return renderModules(React.useMemo(() => ({ + fixtureModule: fixtureWrapper.module, + decoratorModules: getSortedDecoratorsForFixturePath(fixturePath, decorators).map((d2) => d2.module) + }), [decorators, fixturePath, fixtureWrapper.module])); +} +function RendererSync({ children, fixtures }) { + const { rendererId, rendererConnect, locked, selectedFixture, selectFixture, unselectFixture, reloadRenderer, lazyItems } = React.useContext(RendererContext); + const selectedFixtureId = selectedFixture == null ? void 0 : selectedFixture.fixtureId; + const readyRef = React.useRef(false); + React.useEffect(() => { + if (!readyRef.current) { + rendererConnect.postMessage({ + type: "rendererReady", + payload: { + rendererId, + selectedFixtureId + } + }); + readyRef.current = true; + } + }, [rendererConnect, rendererId, selectedFixtureId]); + React.useEffect(() => { + rendererConnect.postMessage({ + type: "fixtureListUpdate", + payload: { + rendererId, + fixtures: { ...fixtures, ...lazyItems } + } + }); + }, [fixtures, lazyItems, rendererConnect, rendererId]); + React.useEffect(() => rendererConnect.onMessage((msg) => { + if (msg.type === "pingRenderers") { + rendererConnect.postMessage({ + type: "rendererReady", + payload: { + rendererId, + selectedFixtureId + } + }); + rendererConnect.postMessage({ + type: "fixtureListUpdate", + payload: { + rendererId, + fixtures + } + }); + } else if (msg.type === "reloadRenderer" && msg.payload.rendererId === rendererId) { + reloadRenderer(); + } + }), [fixtures, reloadRenderer, rendererConnect, rendererId, selectedFixtureId]); + React.useEffect(() => rendererConnect.onMessage((msg) => { + if (!locked && msg.type === "selectFixture" && msg.payload.rendererId === rendererId) { + const { fixtureId, fixtureState } = msg.payload; + selectFixture(fixtureId, fixtureState); + } else if (!locked && msg.type === "unselectFixture" && msg.payload.rendererId === rendererId) { + unselectFixture(); + } + }), [locked, rendererConnect, rendererId, selectFixture, unselectFixture]); + return children; +} +function FixtureLoaderConnect({ moduleWrappers, selectedFixture, renderMessage: renderMessage2, renderFixture }) { + const fixtures = React.useMemo(() => getFixtureListFromWrappers(moduleWrappers), [moduleWrappers]); + function renderInner() { + if (!selectedFixture) { + return React.createElement(DelayRender, { delay: 500 }, renderMessage2("No fixture selected.")); + } + const { fixtureId } = selectedFixture; + if (!fixtures[fixtureId.path]) { + return renderMessage2(`Fixture path not found: ${fixtureId.path}`); + } + return renderFixture(selectedFixture); + } + return React.createElement(RendererSync, { fixtures }, renderInner()); +} +function defaultRenderMessage(msg) { + return msg; +} +function ClientFixtureLoader({ moduleWrappers, globalDecorators: globalDecorators2, renderMessage: renderMessage2 = defaultRenderMessage }) { + const { selectedFixture } = React.useContext(RendererContext); + return React.createElement(FixtureLoaderConnect, { moduleWrappers, selectedFixture, renderMessage: renderMessage2, renderFixture: (selected) => { + function renderModules(modules) { + return React.createElement(FixtureModule, { ...modules, ...selected, globalDecorators: globalDecorators2, lazy: moduleWrappers.lazy, renderMessage: renderMessage2 }); + } + const { fixtureId } = selected; + return moduleWrappers.lazy ? React.createElement(LazyModuleLoader, { fixtureWrapper: moduleWrappers.fixtures[fixtureId.path], decorators: moduleWrappers.decorators, fixturePath: fixtureId.path, renderModules }) : React.createElement(StaticModuleLoader, { fixtureWrapper: moduleWrappers.fixtures[fixtureId.path], decorators: moduleWrappers.decorators, fixturePath: fixtureId.path, renderModules }); + } }); +} +function RendererProvider(props) { + const [lazyItems, setLazyItems] = React.useState({}); + const value = React.useMemo(() => { + return { + rendererId: props.rendererId, + rendererConnect: props.rendererConnect, + locked: props.locked, + selectedFixture: props.selectedFixture, + selectFixture: props.selectFixture, + unselectFixture: props.unselectFixture, + reloadRenderer: props.reloadRenderer, + lazyItems, + setLazyItems + }; + }, [ + lazyItems, + props.locked, + props.reloadRenderer, + props.rendererConnect, + props.rendererId, + props.selectFixture, + props.selectedFixture, + props.unselectFixture + ]); + return React.createElement(RendererContext.Provider, { value }, props.children); +} +function StatefulRendererProvider({ children, selectedFixtureId, ...otherProps }) { + const [selectedFixture, setSelectedFixture] = React.useState(() => selectedFixtureId && { + fixtureId: selectedFixtureId, + initialFixtureState: {}, + renderKey: 0 + }); + const selectFixture = React.useCallback((fixtureId, initialFixtureState) => { + setSelectedFixture((prevState) => ({ + fixtureId, + initialFixtureState, + renderKey: ((prevState == null ? void 0 : prevState.renderKey) ?? 0) + 1 + })); + }, []); + const unselectFixture = React.useCallback(() => { + setSelectedFixture(null); + }, []); + return React.createElement(RendererProvider, { ...otherProps, selectedFixture, selectFixture, unselectFixture }, children); +} +function GlobalErrorHandler() { + const { rendererId, rendererConnect } = React.useContext(RendererContext); + React.useEffect(() => { + function handleGlobalError() { + rendererConnect.postMessage({ + type: "rendererError", + payload: { rendererId } + }); + } + window.addEventListener("error", handleGlobalError); + window.addEventListener("unhandledrejection", handleGlobalError); + return () => { + window.removeEventListener("error", handleGlobalError); + window.removeEventListener("unhandledrejection", handleGlobalError); + }; + }, [rendererConnect, rendererId]); + return null; +} +function reloadDomRenderer() { + window.location.reload(); +} +function createNoopRendererConnect() { + return { + postMessage() { + }, + onMessage() { + return () => { + }; + } + }; +} +function createPostMessageConnect() { + function postMessage(msg) { + parent.postMessage(msg, "*"); + } + registerPlaygroundShortcuts((command) => { + postMessage({ type: "playgroundCommand", payload: { command } }); + }); + return { + postMessage, + onMessage(onMessage) { + function handleMessage(msg) { + onMessage(msg.data); + } + window.addEventListener("message", handleMessage, false); + return () => { + window.removeEventListener("message", handleMessage); + }; + } + }; +} +function createWebSocketsConnect(url) { + let pendingMessages = []; + const socket = new WebSocket(url); + socket.addEventListener("open", () => { + if (pendingMessages.length > 0) { + pendingMessages.forEach((msg) => socket.send(JSON.stringify(msg))); + pendingMessages = []; + } + }); + return { + postMessage(rendererResponse) { + const socketMessage = rendererSocketMessage(rendererResponse); + if (socket && socket.readyState === WebSocket.OPEN) { + socket.send(JSON.stringify(socketMessage)); + } else { + pendingMessages.push(socketMessage); + } + }, + onMessage(onMessage) { + function handleMessage(msg) { + const socketMessage = JSON.parse(msg.data); + if (socketMessage.channel === "renderer") { + onMessage(socketMessage.message); + } + } + socket.addEventListener("message", handleMessage); + return () => socket.removeEventListener("message", handleMessage); + } + }; +} +function createWebSocketsUrl(playgroundUrl) { + return playgroundUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:"); +} +function useDomRendererConnect(playgroundUrl) { + return React.useMemo(() => createDomRendererConnect(playgroundUrl), [playgroundUrl]); +} +function createDomRendererConnect(playgroundUrl) { + if (typeof window === "undefined") { + return createNoopRendererConnect(); + } else { + return isInsideWindowIframe() ? createPostMessageConnect() : createWebSocketsConnect(createWebSocketsUrl(playgroundUrl)); + } +} +function useDomRendererId() { + return React.useMemo(() => getDomRendererId(), []); +} +function getDomRendererId() { + if (typeof sessionStorage === "undefined") { + return uuid$1(); + } + let id2 = sessionStorage.getItem("cosmosRendererId"); + if (!id2) { + id2 = uuid$1(); + sessionStorage.setItem("cosmosRendererId", id2); + } + return id2; +} +function DomRendererProvider({ children, rendererConfig }) { + const rendererId = useDomRendererId(); + const rendererConnect = useDomRendererConnect(rendererConfig.playgroundUrl); + const { locked = false, fixtureId = null } = React.useMemo(() => parseRendererQueryString(location.search), []); + return React.createElement( + StatefulRendererProvider, + { rendererId, rendererConnect, locked, selectedFixtureId: fixtureId, reloadRenderer: reloadDomRenderer }, + children, + typeof window !== "undefined" && React.createElement(GlobalErrorHandler, null) + ); +} +class ErrorCatch extends React.Component { + constructor() { + super(...arguments); + __publicField(this, "state", { + error: null + }); + } + componentDidCatch(error, info) { + this.setState({ + error: `${error.message} +${info.componentStack}` + }); + } + componentDidMount() { + this.prevContext = this.context; + } + componentDidUpdate(prevProps) { + var _a; + if (this.state.error && (fixtureChanged(this.props.children, prevProps.children) || fixtureStateChanged(this.context.fixtureState, (_a = this.prevContext) == null ? void 0 : _a.fixtureState))) { + this.setState({ error: null }); + } + this.prevContext = this.context; + } + render() { + return this.state.error ? this.renderError(this.state.error) : this.props.children; + } + renderError(error) { + return React.createElement( + React.Fragment, + null, + React.createElement("h1", null, "Ouch, something wrong!"), + React.createElement("pre", null, error), + React.createElement("p", null, "Check console for more info.") + ); + } +} +__publicField(ErrorCatch, "contextType", FixtureContext); +__publicField(ErrorCatch, "prevContext", null); +function fixtureChanged(f1, f2) { + return !areNodesEqual(f1, f2, true); +} +function fixtureStateChanged(fS1, fS2) { + return !isEqual$1(fS1, fS2); +} +function DomFixtureLoader({ rendererConfig, moduleWrappers }) { + return React.createElement( + DomRendererProvider, + { rendererConfig }, + React.createElement(ClientFixtureLoader, { moduleWrappers, globalDecorators, renderMessage }) + ); +} +const globalDecorators = [ErrorCatch]; +const containerStyle = { + position: "absolute", + top: 0, + bottom: 0, + left: 0, + right: 0, + display: "flex", + justifyContent: "center", + alignItems: "center", + fontFamily: '-apple-system, BlinkMacSystemFont, Ubuntu, "Helvetica Neue", Helvetica, sans-serif', + fontSize: 14 +}; +function renderMessage(msg) { + return React.createElement("div", { style: containerStyle }, msg); +} +var reactDom = { exports: {} }; +var reactDom_production_min = {}; +var scheduler = { exports: {} }; +var scheduler_production_min = {}; +/** + * @license React + * scheduler.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +(function(exports2) { + function f2(a, b2) { + var c2 = a.length; + a.push(b2); + a: + for (; 0 < c2; ) { + var d2 = c2 - 1 >>> 1, e2 = a[d2]; + if (0 < g2(e2, b2)) + a[d2] = b2, a[c2] = e2, c2 = d2; + else + break a; + } + } + function h2(a) { + return 0 === a.length ? null : a[0]; + } + function k2(a) { + if (0 === a.length) + return null; + var b2 = a[0], c2 = a.pop(); + if (c2 !== b2) { + a[0] = c2; + a: + for (var d2 = 0, e2 = a.length, w2 = e2 >>> 1; d2 < w2; ) { + var m2 = 2 * (d2 + 1) - 1, C2 = a[m2], n2 = m2 + 1, x2 = a[n2]; + if (0 > g2(C2, c2)) + n2 < e2 && 0 > g2(x2, C2) ? (a[d2] = x2, a[n2] = c2, d2 = n2) : (a[d2] = C2, a[m2] = c2, d2 = m2); + else if (n2 < e2 && 0 > g2(x2, c2)) + a[d2] = x2, a[n2] = c2, d2 = n2; + else + break a; + } + } + return b2; + } + function g2(a, b2) { + var c2 = a.sortIndex - b2.sortIndex; + return 0 !== c2 ? c2 : a.id - b2.id; + } + if ("object" === typeof performance && "function" === typeof performance.now) { + var l2 = performance; + exports2.unstable_now = function() { + return l2.now(); + }; + } else { + var p2 = Date, q2 = p2.now(); + exports2.unstable_now = function() { + return p2.now() - q2; + }; + } + var r2 = [], t2 = [], u2 = 1, v2 = null, y2 = 3, z2 = false, A2 = false, B2 = false, D2 = "function" === typeof setTimeout ? setTimeout : null, E2 = "function" === typeof clearTimeout ? clearTimeout : null, F2 = "undefined" !== typeof setImmediate ? setImmediate : null; + "undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling); + function G2(a) { + for (var b2 = h2(t2); null !== b2; ) { + if (null === b2.callback) + k2(t2); + else if (b2.startTime <= a) + k2(t2), b2.sortIndex = b2.expirationTime, f2(r2, b2); + else + break; + b2 = h2(t2); + } + } + function H2(a) { + B2 = false; + G2(a); + if (!A2) + if (null !== h2(r2)) + A2 = true, I2(J2); + else { + var b2 = h2(t2); + null !== b2 && K2(H2, b2.startTime - a); + } + } + function J2(a, b2) { + A2 = false; + B2 && (B2 = false, E2(L2), L2 = -1); + z2 = true; + var c2 = y2; + try { + G2(b2); + for (v2 = h2(r2); null !== v2 && (!(v2.expirationTime > b2) || a && !M2()); ) { + var d2 = v2.callback; + if ("function" === typeof d2) { + v2.callback = null; + y2 = v2.priorityLevel; + var e2 = d2(v2.expirationTime <= b2); + b2 = exports2.unstable_now(); + "function" === typeof e2 ? v2.callback = e2 : v2 === h2(r2) && k2(r2); + G2(b2); + } else + k2(r2); + v2 = h2(r2); + } + if (null !== v2) + var w2 = true; + else { + var m2 = h2(t2); + null !== m2 && K2(H2, m2.startTime - b2); + w2 = false; + } + return w2; + } finally { + v2 = null, y2 = c2, z2 = false; + } + } + var N2 = false, O2 = null, L2 = -1, P2 = 5, Q2 = -1; + function M2() { + return exports2.unstable_now() - Q2 < P2 ? false : true; + } + function R2() { + if (null !== O2) { + var a = exports2.unstable_now(); + Q2 = a; + var b2 = true; + try { + b2 = O2(true, a); + } finally { + b2 ? S2() : (N2 = false, O2 = null); + } + } else + N2 = false; + } + var S2; + if ("function" === typeof F2) + S2 = function() { + F2(R2); + }; + else if ("undefined" !== typeof MessageChannel) { + var T2 = new MessageChannel(), U2 = T2.port2; + T2.port1.onmessage = R2; + S2 = function() { + U2.postMessage(null); + }; + } else + S2 = function() { + D2(R2, 0); + }; + function I2(a) { + O2 = a; + N2 || (N2 = true, S2()); + } + function K2(a, b2) { + L2 = D2(function() { + a(exports2.unstable_now()); + }, b2); + } + exports2.unstable_IdlePriority = 5; + exports2.unstable_ImmediatePriority = 1; + exports2.unstable_LowPriority = 4; + exports2.unstable_NormalPriority = 3; + exports2.unstable_Profiling = null; + exports2.unstable_UserBlockingPriority = 2; + exports2.unstable_cancelCallback = function(a) { + a.callback = null; + }; + exports2.unstable_continueExecution = function() { + A2 || z2 || (A2 = true, I2(J2)); + }; + exports2.unstable_forceFrameRate = function(a) { + 0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P2 = 0 < a ? Math.floor(1e3 / a) : 5; + }; + exports2.unstable_getCurrentPriorityLevel = function() { + return y2; + }; + exports2.unstable_getFirstCallbackNode = function() { + return h2(r2); + }; + exports2.unstable_next = function(a) { + switch (y2) { + case 1: + case 2: + case 3: + var b2 = 3; + break; + default: + b2 = y2; + } + var c2 = y2; + y2 = b2; + try { + return a(); + } finally { + y2 = c2; + } + }; + exports2.unstable_pauseExecution = function() { + }; + exports2.unstable_requestPaint = function() { + }; + exports2.unstable_runWithPriority = function(a, b2) { + switch (a) { + case 1: + case 2: + case 3: + case 4: + case 5: + break; + default: + a = 3; + } + var c2 = y2; + y2 = a; + try { + return b2(); + } finally { + y2 = c2; + } + }; + exports2.unstable_scheduleCallback = function(a, b2, c2) { + var d2 = exports2.unstable_now(); + "object" === typeof c2 && null !== c2 ? (c2 = c2.delay, c2 = "number" === typeof c2 && 0 < c2 ? d2 + c2 : d2) : c2 = d2; + switch (a) { + case 1: + var e2 = -1; + break; + case 2: + e2 = 250; + break; + case 5: + e2 = 1073741823; + break; + case 4: + e2 = 1e4; + break; + default: + e2 = 5e3; + } + e2 = c2 + e2; + a = { id: u2++, callback: b2, priorityLevel: a, startTime: c2, expirationTime: e2, sortIndex: -1 }; + c2 > d2 ? (a.sortIndex = c2, f2(t2, a), null === h2(r2) && a === h2(t2) && (B2 ? (E2(L2), L2 = -1) : B2 = true, K2(H2, c2 - d2))) : (a.sortIndex = e2, f2(r2, a), A2 || z2 || (A2 = true, I2(J2))); + return a; + }; + exports2.unstable_shouldYield = M2; + exports2.unstable_wrapCallback = function(a) { + var b2 = y2; + return function() { + var c2 = y2; + y2 = b2; + try { + return a.apply(this, arguments); + } finally { + y2 = c2; + } + }; + }; +})(scheduler_production_min); +{ + scheduler.exports = scheduler_production_min; +} +var schedulerExports = scheduler.exports; +/** + * @license React + * react-dom.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var aa = reactExports, ca = schedulerExports; +function p$2(a) { + for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c2 = 1; c2 < arguments.length; c2++) + b2 += "&args[]=" + encodeURIComponent(arguments[c2]); + return "Minified React error #" + a + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; +} +var da = /* @__PURE__ */ new Set(), ea = {}; +function fa(a, b2) { + ha(a, b2); + ha(a + "Capture", b2); +} +function ha(a, b2) { + ea[a] = b2; + for (a = 0; a < b2.length; a++) + da.add(b2[a]); +} +var ia = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement), ja = Object.prototype.hasOwnProperty, ka = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/, la = {}, ma = {}; +function oa(a) { + if (ja.call(ma, a)) + return true; + if (ja.call(la, a)) + return false; + if (ka.test(a)) + return ma[a] = true; + la[a] = true; + return false; +} +function pa(a, b2, c2, d2) { + if (null !== c2 && 0 === c2.type) + return false; + switch (typeof b2) { + case "function": + case "symbol": + return true; + case "boolean": + if (d2) + return false; + if (null !== c2) + return !c2.acceptsBooleans; + a = a.toLowerCase().slice(0, 5); + return "data-" !== a && "aria-" !== a; + default: + return false; + } +} +function qa(a, b2, c2, d2) { + if (null === b2 || "undefined" === typeof b2 || pa(a, b2, c2, d2)) + return true; + if (d2) + return false; + if (null !== c2) + switch (c2.type) { + case 3: + return !b2; + case 4: + return false === b2; + case 5: + return isNaN(b2); + case 6: + return isNaN(b2) || 1 > b2; + } + return false; +} +function v$1(a, b2, c2, d2, e2, f2, g2) { + this.acceptsBooleans = 2 === b2 || 3 === b2 || 4 === b2; + this.attributeName = d2; + this.attributeNamespace = e2; + this.mustUseProperty = c2; + this.propertyName = a; + this.type = b2; + this.sanitizeURL = f2; + this.removeEmptyString = g2; +} +var z = {}; +"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a) { + z[a] = new v$1(a, 0, false, a, null, false, false); +}); +[["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a) { + var b2 = a[0]; + z[b2] = new v$1(b2, 1, false, a[1], null, false, false); +}); +["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a) { + z[a] = new v$1(a, 2, false, a.toLowerCase(), null, false, false); +}); +["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a) { + z[a] = new v$1(a, 2, false, a, null, false, false); +}); +"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a) { + z[a] = new v$1(a, 3, false, a.toLowerCase(), null, false, false); +}); +["checked", "multiple", "muted", "selected"].forEach(function(a) { + z[a] = new v$1(a, 3, true, a, null, false, false); +}); +["capture", "download"].forEach(function(a) { + z[a] = new v$1(a, 4, false, a, null, false, false); +}); +["cols", "rows", "size", "span"].forEach(function(a) { + z[a] = new v$1(a, 6, false, a, null, false, false); +}); +["rowSpan", "start"].forEach(function(a) { + z[a] = new v$1(a, 5, false, a.toLowerCase(), null, false, false); +}); +var ra = /[\-:]([a-z])/g; +function sa(a) { + return a[1].toUpperCase(); +} +"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a) { + var b2 = a.replace( + ra, + sa + ); + z[b2] = new v$1(b2, 1, false, a, null, false, false); +}); +"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a) { + var b2 = a.replace(ra, sa); + z[b2] = new v$1(b2, 1, false, a, "http://www.w3.org/1999/xlink", false, false); +}); +["xml:base", "xml:lang", "xml:space"].forEach(function(a) { + var b2 = a.replace(ra, sa); + z[b2] = new v$1(b2, 1, false, a, "http://www.w3.org/XML/1998/namespace", false, false); +}); +["tabIndex", "crossOrigin"].forEach(function(a) { + z[a] = new v$1(a, 1, false, a.toLowerCase(), null, false, false); +}); +z.xlinkHref = new v$1("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false); +["src", "href", "action", "formAction"].forEach(function(a) { + z[a] = new v$1(a, 1, false, a.toLowerCase(), null, true, true); +}); +function ta(a, b2, c2, d2) { + var e2 = z.hasOwnProperty(b2) ? z[b2] : null; + if (null !== e2 ? 0 !== e2.type : d2 || !(2 < b2.length) || "o" !== b2[0] && "O" !== b2[0] || "n" !== b2[1] && "N" !== b2[1]) + qa(b2, c2, e2, d2) && (c2 = null), d2 || null === e2 ? oa(b2) && (null === c2 ? a.removeAttribute(b2) : a.setAttribute(b2, "" + c2)) : e2.mustUseProperty ? a[e2.propertyName] = null === c2 ? 3 === e2.type ? false : "" : c2 : (b2 = e2.attributeName, d2 = e2.attributeNamespace, null === c2 ? a.removeAttribute(b2) : (e2 = e2.type, c2 = 3 === e2 || 4 === e2 && true === c2 ? "" : "" + c2, d2 ? a.setAttributeNS(d2, b2, c2) : a.setAttribute(b2, c2))); +} +var ua = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, va = Symbol.for("react.element"), wa = Symbol.for("react.portal"), ya = Symbol.for("react.fragment"), za = Symbol.for("react.strict_mode"), Aa = Symbol.for("react.profiler"), Ba = Symbol.for("react.provider"), Ca = Symbol.for("react.context"), Da = Symbol.for("react.forward_ref"), Ea = Symbol.for("react.suspense"), Fa = Symbol.for("react.suspense_list"), Ga = Symbol.for("react.memo"), Ha = Symbol.for("react.lazy"); +var Ia = Symbol.for("react.offscreen"); +var Ja = Symbol.iterator; +function Ka(a) { + if (null === a || "object" !== typeof a) + return null; + a = Ja && a[Ja] || a["@@iterator"]; + return "function" === typeof a ? a : null; +} +var A = Object.assign, La; +function Ma(a) { + if (void 0 === La) + try { + throw Error(); + } catch (c2) { + var b2 = c2.stack.trim().match(/\n( *(at )?)/); + La = b2 && b2[1] || ""; + } + return "\n" + La + a; +} +var Na = false; +function Oa(a, b2) { + if (!a || Na) + return ""; + Na = true; + var c2 = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + try { + if (b2) + if (b2 = function() { + throw Error(); + }, Object.defineProperty(b2.prototype, "props", { set: function() { + throw Error(); + } }), "object" === typeof Reflect && Reflect.construct) { + try { + Reflect.construct(b2, []); + } catch (l2) { + var d2 = l2; + } + Reflect.construct(a, [], b2); + } else { + try { + b2.call(); + } catch (l2) { + d2 = l2; + } + a.call(b2.prototype); + } + else { + try { + throw Error(); + } catch (l2) { + d2 = l2; + } + a(); + } + } catch (l2) { + if (l2 && d2 && "string" === typeof l2.stack) { + for (var e2 = l2.stack.split("\n"), f2 = d2.stack.split("\n"), g2 = e2.length - 1, h2 = f2.length - 1; 1 <= g2 && 0 <= h2 && e2[g2] !== f2[h2]; ) + h2--; + for (; 1 <= g2 && 0 <= h2; g2--, h2--) + if (e2[g2] !== f2[h2]) { + if (1 !== g2 || 1 !== h2) { + do + if (g2--, h2--, 0 > h2 || e2[g2] !== f2[h2]) { + var k2 = "\n" + e2[g2].replace(" at new ", " at "); + a.displayName && k2.includes("") && (k2 = k2.replace("", a.displayName)); + return k2; + } + while (1 <= g2 && 0 <= h2); + } + break; + } + } + } finally { + Na = false, Error.prepareStackTrace = c2; + } + return (a = a ? a.displayName || a.name : "") ? Ma(a) : ""; +} +function Pa(a) { + switch (a.tag) { + case 5: + return Ma(a.type); + case 16: + return Ma("Lazy"); + case 13: + return Ma("Suspense"); + case 19: + return Ma("SuspenseList"); + case 0: + case 2: + case 15: + return a = Oa(a.type, false), a; + case 11: + return a = Oa(a.type.render, false), a; + case 1: + return a = Oa(a.type, true), a; + default: + return ""; + } +} +function Qa(a) { + if (null == a) + return null; + if ("function" === typeof a) + return a.displayName || a.name || null; + if ("string" === typeof a) + return a; + switch (a) { + case ya: + return "Fragment"; + case wa: + return "Portal"; + case Aa: + return "Profiler"; + case za: + return "StrictMode"; + case Ea: + return "Suspense"; + case Fa: + return "SuspenseList"; + } + if ("object" === typeof a) + switch (a.$$typeof) { + case Ca: + return (a.displayName || "Context") + ".Consumer"; + case Ba: + return (a._context.displayName || "Context") + ".Provider"; + case Da: + var b2 = a.render; + a = a.displayName; + a || (a = b2.displayName || b2.name || "", a = "" !== a ? "ForwardRef(" + a + ")" : "ForwardRef"); + return a; + case Ga: + return b2 = a.displayName || null, null !== b2 ? b2 : Qa(a.type) || "Memo"; + case Ha: + b2 = a._payload; + a = a._init; + try { + return Qa(a(b2)); + } catch (c2) { + } + } + return null; +} +function Ra(a) { + var b2 = a.type; + switch (a.tag) { + case 24: + return "Cache"; + case 9: + return (b2.displayName || "Context") + ".Consumer"; + case 10: + return (b2._context.displayName || "Context") + ".Provider"; + case 18: + return "DehydratedFragment"; + case 11: + return a = b2.render, a = a.displayName || a.name || "", b2.displayName || ("" !== a ? "ForwardRef(" + a + ")" : "ForwardRef"); + case 7: + return "Fragment"; + case 5: + return b2; + case 4: + return "Portal"; + case 3: + return "Root"; + case 6: + return "Text"; + case 16: + return Qa(b2); + case 8: + return b2 === za ? "StrictMode" : "Mode"; + case 22: + return "Offscreen"; + case 12: + return "Profiler"; + case 21: + return "Scope"; + case 13: + return "Suspense"; + case 19: + return "SuspenseList"; + case 25: + return "TracingMarker"; + case 1: + case 0: + case 17: + case 2: + case 14: + case 15: + if ("function" === typeof b2) + return b2.displayName || b2.name || null; + if ("string" === typeof b2) + return b2; + } + return null; +} +function Sa(a) { + switch (typeof a) { + case "boolean": + case "number": + case "string": + case "undefined": + return a; + case "object": + return a; + default: + return ""; + } +} +function Ta(a) { + var b2 = a.type; + return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b2 || "radio" === b2); +} +function Ua(a) { + var b2 = Ta(a) ? "checked" : "value", c2 = Object.getOwnPropertyDescriptor(a.constructor.prototype, b2), d2 = "" + a[b2]; + if (!a.hasOwnProperty(b2) && "undefined" !== typeof c2 && "function" === typeof c2.get && "function" === typeof c2.set) { + var e2 = c2.get, f2 = c2.set; + Object.defineProperty(a, b2, { configurable: true, get: function() { + return e2.call(this); + }, set: function(a2) { + d2 = "" + a2; + f2.call(this, a2); + } }); + Object.defineProperty(a, b2, { enumerable: c2.enumerable }); + return { getValue: function() { + return d2; + }, setValue: function(a2) { + d2 = "" + a2; + }, stopTracking: function() { + a._valueTracker = null; + delete a[b2]; + } }; + } +} +function Va(a) { + a._valueTracker || (a._valueTracker = Ua(a)); +} +function Wa(a) { + if (!a) + return false; + var b2 = a._valueTracker; + if (!b2) + return true; + var c2 = b2.getValue(); + var d2 = ""; + a && (d2 = Ta(a) ? a.checked ? "true" : "false" : a.value); + a = d2; + return a !== c2 ? (b2.setValue(a), true) : false; +} +function Xa(a) { + a = a || ("undefined" !== typeof document ? document : void 0); + if ("undefined" === typeof a) + return null; + try { + return a.activeElement || a.body; + } catch (b2) { + return a.body; + } +} +function Ya(a, b2) { + var c2 = b2.checked; + return A({}, b2, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: null != c2 ? c2 : a._wrapperState.initialChecked }); +} +function Za(a, b2) { + var c2 = null == b2.defaultValue ? "" : b2.defaultValue, d2 = null != b2.checked ? b2.checked : b2.defaultChecked; + c2 = Sa(null != b2.value ? b2.value : c2); + a._wrapperState = { initialChecked: d2, initialValue: c2, controlled: "checkbox" === b2.type || "radio" === b2.type ? null != b2.checked : null != b2.value }; +} +function ab(a, b2) { + b2 = b2.checked; + null != b2 && ta(a, "checked", b2, false); +} +function bb(a, b2) { + ab(a, b2); + var c2 = Sa(b2.value), d2 = b2.type; + if (null != c2) + if ("number" === d2) { + if (0 === c2 && "" === a.value || a.value != c2) + a.value = "" + c2; + } else + a.value !== "" + c2 && (a.value = "" + c2); + else if ("submit" === d2 || "reset" === d2) { + a.removeAttribute("value"); + return; + } + b2.hasOwnProperty("value") ? cb(a, b2.type, c2) : b2.hasOwnProperty("defaultValue") && cb(a, b2.type, Sa(b2.defaultValue)); + null == b2.checked && null != b2.defaultChecked && (a.defaultChecked = !!b2.defaultChecked); +} +function db(a, b2, c2) { + if (b2.hasOwnProperty("value") || b2.hasOwnProperty("defaultValue")) { + var d2 = b2.type; + if (!("submit" !== d2 && "reset" !== d2 || void 0 !== b2.value && null !== b2.value)) + return; + b2 = "" + a._wrapperState.initialValue; + c2 || b2 === a.value || (a.value = b2); + a.defaultValue = b2; + } + c2 = a.name; + "" !== c2 && (a.name = ""); + a.defaultChecked = !!a._wrapperState.initialChecked; + "" !== c2 && (a.name = c2); +} +function cb(a, b2, c2) { + if ("number" !== b2 || Xa(a.ownerDocument) !== a) + null == c2 ? a.defaultValue = "" + a._wrapperState.initialValue : a.defaultValue !== "" + c2 && (a.defaultValue = "" + c2); +} +var eb = Array.isArray; +function fb(a, b2, c2, d2) { + a = a.options; + if (b2) { + b2 = {}; + for (var e2 = 0; e2 < c2.length; e2++) + b2["$" + c2[e2]] = true; + for (c2 = 0; c2 < a.length; c2++) + e2 = b2.hasOwnProperty("$" + a[c2].value), a[c2].selected !== e2 && (a[c2].selected = e2), e2 && d2 && (a[c2].defaultSelected = true); + } else { + c2 = "" + Sa(c2); + b2 = null; + for (e2 = 0; e2 < a.length; e2++) { + if (a[e2].value === c2) { + a[e2].selected = true; + d2 && (a[e2].defaultSelected = true); + return; + } + null !== b2 || a[e2].disabled || (b2 = a[e2]); + } + null !== b2 && (b2.selected = true); + } +} +function gb(a, b2) { + if (null != b2.dangerouslySetInnerHTML) + throw Error(p$2(91)); + return A({}, b2, { value: void 0, defaultValue: void 0, children: "" + a._wrapperState.initialValue }); +} +function hb(a, b2) { + var c2 = b2.value; + if (null == c2) { + c2 = b2.children; + b2 = b2.defaultValue; + if (null != c2) { + if (null != b2) + throw Error(p$2(92)); + if (eb(c2)) { + if (1 < c2.length) + throw Error(p$2(93)); + c2 = c2[0]; + } + b2 = c2; + } + null == b2 && (b2 = ""); + c2 = b2; + } + a._wrapperState = { initialValue: Sa(c2) }; +} +function ib(a, b2) { + var c2 = Sa(b2.value), d2 = Sa(b2.defaultValue); + null != c2 && (c2 = "" + c2, c2 !== a.value && (a.value = c2), null == b2.defaultValue && a.defaultValue !== c2 && (a.defaultValue = c2)); + null != d2 && (a.defaultValue = "" + d2); +} +function jb(a) { + var b2 = a.textContent; + b2 === a._wrapperState.initialValue && "" !== b2 && null !== b2 && (a.value = b2); +} +function kb(a) { + switch (a) { + case "svg": + return "http://www.w3.org/2000/svg"; + case "math": + return "http://www.w3.org/1998/Math/MathML"; + default: + return "http://www.w3.org/1999/xhtml"; + } +} +function lb(a, b2) { + return null == a || "http://www.w3.org/1999/xhtml" === a ? kb(b2) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b2 ? "http://www.w3.org/1999/xhtml" : a; +} +var mb, nb = function(a) { + return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b2, c2, d2, e2) { + MSApp.execUnsafeLocalFunction(function() { + return a(b2, c2, d2, e2); + }); + } : a; +}(function(a, b2) { + if ("http://www.w3.org/2000/svg" !== a.namespaceURI || "innerHTML" in a) + a.innerHTML = b2; + else { + mb = mb || document.createElement("div"); + mb.innerHTML = "" + b2.valueOf().toString() + ""; + for (b2 = mb.firstChild; a.firstChild; ) + a.removeChild(a.firstChild); + for (; b2.firstChild; ) + a.appendChild(b2.firstChild); + } +}); +function ob(a, b2) { + if (b2) { + var c2 = a.firstChild; + if (c2 && c2 === a.lastChild && 3 === c2.nodeType) { + c2.nodeValue = b2; + return; + } + } + a.textContent = b2; +} +var pb = { + animationIterationCount: true, + aspectRatio: true, + borderImageOutset: true, + borderImageSlice: true, + borderImageWidth: true, + boxFlex: true, + boxFlexGroup: true, + boxOrdinalGroup: true, + columnCount: true, + columns: true, + flex: true, + flexGrow: true, + flexPositive: true, + flexShrink: true, + flexNegative: true, + flexOrder: true, + gridArea: true, + gridRow: true, + gridRowEnd: true, + gridRowSpan: true, + gridRowStart: true, + gridColumn: true, + gridColumnEnd: true, + gridColumnSpan: true, + gridColumnStart: true, + fontWeight: true, + lineClamp: true, + lineHeight: true, + opacity: true, + order: true, + orphans: true, + tabSize: true, + widows: true, + zIndex: true, + zoom: true, + fillOpacity: true, + floodOpacity: true, + stopOpacity: true, + strokeDasharray: true, + strokeDashoffset: true, + strokeMiterlimit: true, + strokeOpacity: true, + strokeWidth: true +}, qb = ["Webkit", "ms", "Moz", "O"]; +Object.keys(pb).forEach(function(a) { + qb.forEach(function(b2) { + b2 = b2 + a.charAt(0).toUpperCase() + a.substring(1); + pb[b2] = pb[a]; + }); +}); +function rb(a, b2, c2) { + return null == b2 || "boolean" === typeof b2 || "" === b2 ? "" : c2 || "number" !== typeof b2 || 0 === b2 || pb.hasOwnProperty(a) && pb[a] ? ("" + b2).trim() : b2 + "px"; +} +function sb(a, b2) { + a = a.style; + for (var c2 in b2) + if (b2.hasOwnProperty(c2)) { + var d2 = 0 === c2.indexOf("--"), e2 = rb(c2, b2[c2], d2); + "float" === c2 && (c2 = "cssFloat"); + d2 ? a.setProperty(c2, e2) : a[c2] = e2; + } +} +var tb = A({ menuitem: true }, { area: true, base: true, br: true, col: true, embed: true, hr: true, img: true, input: true, keygen: true, link: true, meta: true, param: true, source: true, track: true, wbr: true }); +function ub(a, b2) { + if (b2) { + if (tb[a] && (null != b2.children || null != b2.dangerouslySetInnerHTML)) + throw Error(p$2(137, a)); + if (null != b2.dangerouslySetInnerHTML) { + if (null != b2.children) + throw Error(p$2(60)); + if ("object" !== typeof b2.dangerouslySetInnerHTML || !("__html" in b2.dangerouslySetInnerHTML)) + throw Error(p$2(61)); + } + if (null != b2.style && "object" !== typeof b2.style) + throw Error(p$2(62)); + } +} +function vb(a, b2) { + if (-1 === a.indexOf("-")) + return "string" === typeof b2.is; + switch (a) { + case "annotation-xml": + case "color-profile": + case "font-face": + case "font-face-src": + case "font-face-uri": + case "font-face-format": + case "font-face-name": + case "missing-glyph": + return false; + default: + return true; + } +} +var wb = null; +function xb(a) { + a = a.target || a.srcElement || window; + a.correspondingUseElement && (a = a.correspondingUseElement); + return 3 === a.nodeType ? a.parentNode : a; +} +var yb = null, zb = null, Ab = null; +function Bb(a) { + if (a = Cb(a)) { + if ("function" !== typeof yb) + throw Error(p$2(280)); + var b2 = a.stateNode; + b2 && (b2 = Db(b2), yb(a.stateNode, a.type, b2)); + } +} +function Eb(a) { + zb ? Ab ? Ab.push(a) : Ab = [a] : zb = a; +} +function Fb() { + if (zb) { + var a = zb, b2 = Ab; + Ab = zb = null; + Bb(a); + if (b2) + for (a = 0; a < b2.length; a++) + Bb(b2[a]); + } +} +function Gb(a, b2) { + return a(b2); +} +function Hb() { +} +var Ib = false; +function Jb(a, b2, c2) { + if (Ib) + return a(b2, c2); + Ib = true; + try { + return Gb(a, b2, c2); + } finally { + if (Ib = false, null !== zb || null !== Ab) + Hb(), Fb(); + } +} +function Kb(a, b2) { + var c2 = a.stateNode; + if (null === c2) + return null; + var d2 = Db(c2); + if (null === d2) + return null; + c2 = d2[b2]; + a: + switch (b2) { + case "onClick": + case "onClickCapture": + case "onDoubleClick": + case "onDoubleClickCapture": + case "onMouseDown": + case "onMouseDownCapture": + case "onMouseMove": + case "onMouseMoveCapture": + case "onMouseUp": + case "onMouseUpCapture": + case "onMouseEnter": + (d2 = !d2.disabled) || (a = a.type, d2 = !("button" === a || "input" === a || "select" === a || "textarea" === a)); + a = !d2; + break a; + default: + a = false; + } + if (a) + return null; + if (c2 && "function" !== typeof c2) + throw Error(p$2(231, b2, typeof c2)); + return c2; +} +var Lb = false; +if (ia) + try { + var Mb = {}; + Object.defineProperty(Mb, "passive", { get: function() { + Lb = true; + } }); + window.addEventListener("test", Mb, Mb); + window.removeEventListener("test", Mb, Mb); + } catch (a) { + Lb = false; + } +function Nb(a, b2, c2, d2, e2, f2, g2, h2, k2) { + var l2 = Array.prototype.slice.call(arguments, 3); + try { + b2.apply(c2, l2); + } catch (m2) { + this.onError(m2); + } +} +var Ob = false, Pb = null, Qb = false, Rb = null, Sb = { onError: function(a) { + Ob = true; + Pb = a; +} }; +function Tb(a, b2, c2, d2, e2, f2, g2, h2, k2) { + Ob = false; + Pb = null; + Nb.apply(Sb, arguments); +} +function Ub(a, b2, c2, d2, e2, f2, g2, h2, k2) { + Tb.apply(this, arguments); + if (Ob) { + if (Ob) { + var l2 = Pb; + Ob = false; + Pb = null; + } else + throw Error(p$2(198)); + Qb || (Qb = true, Rb = l2); + } +} +function Vb(a) { + var b2 = a, c2 = a; + if (a.alternate) + for (; b2.return; ) + b2 = b2.return; + else { + a = b2; + do + b2 = a, 0 !== (b2.flags & 4098) && (c2 = b2.return), a = b2.return; + while (a); + } + return 3 === b2.tag ? c2 : null; +} +function Wb(a) { + if (13 === a.tag) { + var b2 = a.memoizedState; + null === b2 && (a = a.alternate, null !== a && (b2 = a.memoizedState)); + if (null !== b2) + return b2.dehydrated; + } + return null; +} +function Xb(a) { + if (Vb(a) !== a) + throw Error(p$2(188)); +} +function Yb(a) { + var b2 = a.alternate; + if (!b2) { + b2 = Vb(a); + if (null === b2) + throw Error(p$2(188)); + return b2 !== a ? null : a; + } + for (var c2 = a, d2 = b2; ; ) { + var e2 = c2.return; + if (null === e2) + break; + var f2 = e2.alternate; + if (null === f2) { + d2 = e2.return; + if (null !== d2) { + c2 = d2; + continue; + } + break; + } + if (e2.child === f2.child) { + for (f2 = e2.child; f2; ) { + if (f2 === c2) + return Xb(e2), a; + if (f2 === d2) + return Xb(e2), b2; + f2 = f2.sibling; + } + throw Error(p$2(188)); + } + if (c2.return !== d2.return) + c2 = e2, d2 = f2; + else { + for (var g2 = false, h2 = e2.child; h2; ) { + if (h2 === c2) { + g2 = true; + c2 = e2; + d2 = f2; + break; + } + if (h2 === d2) { + g2 = true; + d2 = e2; + c2 = f2; + break; + } + h2 = h2.sibling; + } + if (!g2) { + for (h2 = f2.child; h2; ) { + if (h2 === c2) { + g2 = true; + c2 = f2; + d2 = e2; + break; + } + if (h2 === d2) { + g2 = true; + d2 = f2; + c2 = e2; + break; + } + h2 = h2.sibling; + } + if (!g2) + throw Error(p$2(189)); + } + } + if (c2.alternate !== d2) + throw Error(p$2(190)); + } + if (3 !== c2.tag) + throw Error(p$2(188)); + return c2.stateNode.current === c2 ? a : b2; +} +function Zb(a) { + a = Yb(a); + return null !== a ? $b(a) : null; +} +function $b(a) { + if (5 === a.tag || 6 === a.tag) + return a; + for (a = a.child; null !== a; ) { + var b2 = $b(a); + if (null !== b2) + return b2; + a = a.sibling; + } + return null; +} +var ac = ca.unstable_scheduleCallback, bc = ca.unstable_cancelCallback, cc = ca.unstable_shouldYield, dc = ca.unstable_requestPaint, B = ca.unstable_now, ec = ca.unstable_getCurrentPriorityLevel, fc = ca.unstable_ImmediatePriority, gc = ca.unstable_UserBlockingPriority, hc = ca.unstable_NormalPriority, ic = ca.unstable_LowPriority, jc = ca.unstable_IdlePriority, kc = null, lc = null; +function mc(a) { + if (lc && "function" === typeof lc.onCommitFiberRoot) + try { + lc.onCommitFiberRoot(kc, a, void 0, 128 === (a.current.flags & 128)); + } catch (b2) { + } +} +var oc = Math.clz32 ? Math.clz32 : nc, pc = Math.log, qc = Math.LN2; +function nc(a) { + a >>>= 0; + return 0 === a ? 32 : 31 - (pc(a) / qc | 0) | 0; +} +var rc = 64, sc = 4194304; +function tc(a) { + switch (a & -a) { + case 1: + return 1; + case 2: + return 2; + case 4: + return 4; + case 8: + return 8; + case 16: + return 16; + case 32: + return 32; + case 64: + case 128: + case 256: + case 512: + case 1024: + case 2048: + case 4096: + case 8192: + case 16384: + case 32768: + case 65536: + case 131072: + case 262144: + case 524288: + case 1048576: + case 2097152: + return a & 4194240; + case 4194304: + case 8388608: + case 16777216: + case 33554432: + case 67108864: + return a & 130023424; + case 134217728: + return 134217728; + case 268435456: + return 268435456; + case 536870912: + return 536870912; + case 1073741824: + return 1073741824; + default: + return a; + } +} +function uc(a, b2) { + var c2 = a.pendingLanes; + if (0 === c2) + return 0; + var d2 = 0, e2 = a.suspendedLanes, f2 = a.pingedLanes, g2 = c2 & 268435455; + if (0 !== g2) { + var h2 = g2 & ~e2; + 0 !== h2 ? d2 = tc(h2) : (f2 &= g2, 0 !== f2 && (d2 = tc(f2))); + } else + g2 = c2 & ~e2, 0 !== g2 ? d2 = tc(g2) : 0 !== f2 && (d2 = tc(f2)); + if (0 === d2) + return 0; + if (0 !== b2 && b2 !== d2 && 0 === (b2 & e2) && (e2 = d2 & -d2, f2 = b2 & -b2, e2 >= f2 || 16 === e2 && 0 !== (f2 & 4194240))) + return b2; + 0 !== (d2 & 4) && (d2 |= c2 & 16); + b2 = a.entangledLanes; + if (0 !== b2) + for (a = a.entanglements, b2 &= d2; 0 < b2; ) + c2 = 31 - oc(b2), e2 = 1 << c2, d2 |= a[c2], b2 &= ~e2; + return d2; +} +function vc(a, b2) { + switch (a) { + case 1: + case 2: + case 4: + return b2 + 250; + case 8: + case 16: + case 32: + case 64: + case 128: + case 256: + case 512: + case 1024: + case 2048: + case 4096: + case 8192: + case 16384: + case 32768: + case 65536: + case 131072: + case 262144: + case 524288: + case 1048576: + case 2097152: + return b2 + 5e3; + case 4194304: + case 8388608: + case 16777216: + case 33554432: + case 67108864: + return -1; + case 134217728: + case 268435456: + case 536870912: + case 1073741824: + return -1; + default: + return -1; + } +} +function wc(a, b2) { + for (var c2 = a.suspendedLanes, d2 = a.pingedLanes, e2 = a.expirationTimes, f2 = a.pendingLanes; 0 < f2; ) { + var g2 = 31 - oc(f2), h2 = 1 << g2, k2 = e2[g2]; + if (-1 === k2) { + if (0 === (h2 & c2) || 0 !== (h2 & d2)) + e2[g2] = vc(h2, b2); + } else + k2 <= b2 && (a.expiredLanes |= h2); + f2 &= ~h2; + } +} +function xc(a) { + a = a.pendingLanes & -1073741825; + return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0; +} +function yc() { + var a = rc; + rc <<= 1; + 0 === (rc & 4194240) && (rc = 64); + return a; +} +function zc(a) { + for (var b2 = [], c2 = 0; 31 > c2; c2++) + b2.push(a); + return b2; +} +function Ac(a, b2, c2) { + a.pendingLanes |= b2; + 536870912 !== b2 && (a.suspendedLanes = 0, a.pingedLanes = 0); + a = a.eventTimes; + b2 = 31 - oc(b2); + a[b2] = c2; +} +function Bc(a, b2) { + var c2 = a.pendingLanes & ~b2; + a.pendingLanes = b2; + a.suspendedLanes = 0; + a.pingedLanes = 0; + a.expiredLanes &= b2; + a.mutableReadLanes &= b2; + a.entangledLanes &= b2; + b2 = a.entanglements; + var d2 = a.eventTimes; + for (a = a.expirationTimes; 0 < c2; ) { + var e2 = 31 - oc(c2), f2 = 1 << e2; + b2[e2] = 0; + d2[e2] = -1; + a[e2] = -1; + c2 &= ~f2; + } +} +function Cc(a, b2) { + var c2 = a.entangledLanes |= b2; + for (a = a.entanglements; c2; ) { + var d2 = 31 - oc(c2), e2 = 1 << d2; + e2 & b2 | a[d2] & b2 && (a[d2] |= b2); + c2 &= ~e2; + } +} +var C = 0; +function Dc(a) { + a &= -a; + return 1 < a ? 4 < a ? 0 !== (a & 268435455) ? 16 : 536870912 : 4 : 1; +} +var Ec, Fc, Gc, Hc, Ic, Jc = false, Kc = [], Lc = null, Mc = null, Nc = null, Oc = /* @__PURE__ */ new Map(), Pc = /* @__PURE__ */ new Map(), Qc = [], Rc = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" "); +function Sc(a, b2) { + switch (a) { + case "focusin": + case "focusout": + Lc = null; + break; + case "dragenter": + case "dragleave": + Mc = null; + break; + case "mouseover": + case "mouseout": + Nc = null; + break; + case "pointerover": + case "pointerout": + Oc.delete(b2.pointerId); + break; + case "gotpointercapture": + case "lostpointercapture": + Pc.delete(b2.pointerId); + } +} +function Tc(a, b2, c2, d2, e2, f2) { + if (null === a || a.nativeEvent !== f2) + return a = { blockedOn: b2, domEventName: c2, eventSystemFlags: d2, nativeEvent: f2, targetContainers: [e2] }, null !== b2 && (b2 = Cb(b2), null !== b2 && Fc(b2)), a; + a.eventSystemFlags |= d2; + b2 = a.targetContainers; + null !== e2 && -1 === b2.indexOf(e2) && b2.push(e2); + return a; +} +function Uc(a, b2, c2, d2, e2) { + switch (b2) { + case "focusin": + return Lc = Tc(Lc, a, b2, c2, d2, e2), true; + case "dragenter": + return Mc = Tc(Mc, a, b2, c2, d2, e2), true; + case "mouseover": + return Nc = Tc(Nc, a, b2, c2, d2, e2), true; + case "pointerover": + var f2 = e2.pointerId; + Oc.set(f2, Tc(Oc.get(f2) || null, a, b2, c2, d2, e2)); + return true; + case "gotpointercapture": + return f2 = e2.pointerId, Pc.set(f2, Tc(Pc.get(f2) || null, a, b2, c2, d2, e2)), true; + } + return false; +} +function Vc(a) { + var b2 = Wc(a.target); + if (null !== b2) { + var c2 = Vb(b2); + if (null !== c2) { + if (b2 = c2.tag, 13 === b2) { + if (b2 = Wb(c2), null !== b2) { + a.blockedOn = b2; + Ic(a.priority, function() { + Gc(c2); + }); + return; + } + } else if (3 === b2 && c2.stateNode.current.memoizedState.isDehydrated) { + a.blockedOn = 3 === c2.tag ? c2.stateNode.containerInfo : null; + return; + } + } + } + a.blockedOn = null; +} +function Xc(a) { + if (null !== a.blockedOn) + return false; + for (var b2 = a.targetContainers; 0 < b2.length; ) { + var c2 = Yc(a.domEventName, a.eventSystemFlags, b2[0], a.nativeEvent); + if (null === c2) { + c2 = a.nativeEvent; + var d2 = new c2.constructor(c2.type, c2); + wb = d2; + c2.target.dispatchEvent(d2); + wb = null; + } else + return b2 = Cb(c2), null !== b2 && Fc(b2), a.blockedOn = c2, false; + b2.shift(); + } + return true; +} +function Zc(a, b2, c2) { + Xc(a) && c2.delete(b2); +} +function $c() { + Jc = false; + null !== Lc && Xc(Lc) && (Lc = null); + null !== Mc && Xc(Mc) && (Mc = null); + null !== Nc && Xc(Nc) && (Nc = null); + Oc.forEach(Zc); + Pc.forEach(Zc); +} +function ad(a, b2) { + a.blockedOn === b2 && (a.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c))); +} +function bd(a) { + function b2(b3) { + return ad(b3, a); + } + if (0 < Kc.length) { + ad(Kc[0], a); + for (var c2 = 1; c2 < Kc.length; c2++) { + var d2 = Kc[c2]; + d2.blockedOn === a && (d2.blockedOn = null); + } + } + null !== Lc && ad(Lc, a); + null !== Mc && ad(Mc, a); + null !== Nc && ad(Nc, a); + Oc.forEach(b2); + Pc.forEach(b2); + for (c2 = 0; c2 < Qc.length; c2++) + d2 = Qc[c2], d2.blockedOn === a && (d2.blockedOn = null); + for (; 0 < Qc.length && (c2 = Qc[0], null === c2.blockedOn); ) + Vc(c2), null === c2.blockedOn && Qc.shift(); +} +var cd = ua.ReactCurrentBatchConfig, dd = true; +function ed(a, b2, c2, d2) { + var e2 = C, f2 = cd.transition; + cd.transition = null; + try { + C = 1, fd(a, b2, c2, d2); + } finally { + C = e2, cd.transition = f2; + } +} +function gd(a, b2, c2, d2) { + var e2 = C, f2 = cd.transition; + cd.transition = null; + try { + C = 4, fd(a, b2, c2, d2); + } finally { + C = e2, cd.transition = f2; + } +} +function fd(a, b2, c2, d2) { + if (dd) { + var e2 = Yc(a, b2, c2, d2); + if (null === e2) + hd(a, b2, d2, id, c2), Sc(a, d2); + else if (Uc(e2, a, b2, c2, d2)) + d2.stopPropagation(); + else if (Sc(a, d2), b2 & 4 && -1 < Rc.indexOf(a)) { + for (; null !== e2; ) { + var f2 = Cb(e2); + null !== f2 && Ec(f2); + f2 = Yc(a, b2, c2, d2); + null === f2 && hd(a, b2, d2, id, c2); + if (f2 === e2) + break; + e2 = f2; + } + null !== e2 && d2.stopPropagation(); + } else + hd(a, b2, d2, null, c2); + } +} +var id = null; +function Yc(a, b2, c2, d2) { + id = null; + a = xb(d2); + a = Wc(a); + if (null !== a) + if (b2 = Vb(a), null === b2) + a = null; + else if (c2 = b2.tag, 13 === c2) { + a = Wb(b2); + if (null !== a) + return a; + a = null; + } else if (3 === c2) { + if (b2.stateNode.current.memoizedState.isDehydrated) + return 3 === b2.tag ? b2.stateNode.containerInfo : null; + a = null; + } else + b2 !== a && (a = null); + id = a; + return null; +} +function jd(a) { + switch (a) { + case "cancel": + case "click": + case "close": + case "contextmenu": + case "copy": + case "cut": + case "auxclick": + case "dblclick": + case "dragend": + case "dragstart": + case "drop": + case "focusin": + case "focusout": + case "input": + case "invalid": + case "keydown": + case "keypress": + case "keyup": + case "mousedown": + case "mouseup": + case "paste": + case "pause": + case "play": + case "pointercancel": + case "pointerdown": + case "pointerup": + case "ratechange": + case "reset": + case "resize": + case "seeked": + case "submit": + case "touchcancel": + case "touchend": + case "touchstart": + case "volumechange": + case "change": + case "selectionchange": + case "textInput": + case "compositionstart": + case "compositionend": + case "compositionupdate": + case "beforeblur": + case "afterblur": + case "beforeinput": + case "blur": + case "fullscreenchange": + case "focus": + case "hashchange": + case "popstate": + case "select": + case "selectstart": + return 1; + case "drag": + case "dragenter": + case "dragexit": + case "dragleave": + case "dragover": + case "mousemove": + case "mouseout": + case "mouseover": + case "pointermove": + case "pointerout": + case "pointerover": + case "scroll": + case "toggle": + case "touchmove": + case "wheel": + case "mouseenter": + case "mouseleave": + case "pointerenter": + case "pointerleave": + return 4; + case "message": + switch (ec()) { + case fc: + return 1; + case gc: + return 4; + case hc: + case ic: + return 16; + case jc: + return 536870912; + default: + return 16; + } + default: + return 16; + } +} +var kd = null, ld = null, md = null; +function nd() { + if (md) + return md; + var a, b2 = ld, c2 = b2.length, d2, e2 = "value" in kd ? kd.value : kd.textContent, f2 = e2.length; + for (a = 0; a < c2 && b2[a] === e2[a]; a++) + ; + var g2 = c2 - a; + for (d2 = 1; d2 <= g2 && b2[c2 - d2] === e2[f2 - d2]; d2++) + ; + return md = e2.slice(a, 1 < d2 ? 1 - d2 : void 0); +} +function od(a) { + var b2 = a.keyCode; + "charCode" in a ? (a = a.charCode, 0 === a && 13 === b2 && (a = 13)) : a = b2; + 10 === a && (a = 13); + return 32 <= a || 13 === a ? a : 0; +} +function pd() { + return true; +} +function qd() { + return false; +} +function rd(a) { + function b2(b3, d2, e2, f2, g2) { + this._reactName = b3; + this._targetInst = e2; + this.type = d2; + this.nativeEvent = f2; + this.target = g2; + this.currentTarget = null; + for (var c2 in a) + a.hasOwnProperty(c2) && (b3 = a[c2], this[c2] = b3 ? b3(f2) : f2[c2]); + this.isDefaultPrevented = (null != f2.defaultPrevented ? f2.defaultPrevented : false === f2.returnValue) ? pd : qd; + this.isPropagationStopped = qd; + return this; + } + A(b2.prototype, { preventDefault: function() { + this.defaultPrevented = true; + var a2 = this.nativeEvent; + a2 && (a2.preventDefault ? a2.preventDefault() : "unknown" !== typeof a2.returnValue && (a2.returnValue = false), this.isDefaultPrevented = pd); + }, stopPropagation: function() { + var a2 = this.nativeEvent; + a2 && (a2.stopPropagation ? a2.stopPropagation() : "unknown" !== typeof a2.cancelBubble && (a2.cancelBubble = true), this.isPropagationStopped = pd); + }, persist: function() { + }, isPersistent: pd }); + return b2; +} +var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a) { + return a.timeStamp || Date.now(); +}, defaultPrevented: 0, isTrusted: 0 }, td = rd(sd), ud = A({}, sd, { view: 0, detail: 0 }), vd = rd(ud), wd, xd, yd, Ad = A({}, ud, { screenX: 0, screenY: 0, clientX: 0, clientY: 0, pageX: 0, pageY: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, getModifierState: zd, button: 0, buttons: 0, relatedTarget: function(a) { + return void 0 === a.relatedTarget ? a.fromElement === a.srcElement ? a.toElement : a.fromElement : a.relatedTarget; +}, movementX: function(a) { + if ("movementX" in a) + return a.movementX; + a !== yd && (yd && "mousemove" === a.type ? (wd = a.screenX - yd.screenX, xd = a.screenY - yd.screenY) : xd = wd = 0, yd = a); + return wd; +}, movementY: function(a) { + return "movementY" in a ? a.movementY : xd; +} }), Bd = rd(Ad), Cd = A({}, Ad, { dataTransfer: 0 }), Dd = rd(Cd), Ed = A({}, ud, { relatedTarget: 0 }), Fd = rd(Ed), Gd = A({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }), Hd = rd(Gd), Id = A({}, sd, { clipboardData: function(a) { + return "clipboardData" in a ? a.clipboardData : window.clipboardData; +} }), Jd = rd(Id), Kd = A({}, sd, { data: 0 }), Ld = rd(Kd), Md = { + Esc: "Escape", + Spacebar: " ", + Left: "ArrowLeft", + Up: "ArrowUp", + Right: "ArrowRight", + Down: "ArrowDown", + Del: "Delete", + Win: "OS", + Menu: "ContextMenu", + Apps: "ContextMenu", + Scroll: "ScrollLock", + MozPrintableKey: "Unidentified" +}, Nd = { + 8: "Backspace", + 9: "Tab", + 12: "Clear", + 13: "Enter", + 16: "Shift", + 17: "Control", + 18: "Alt", + 19: "Pause", + 20: "CapsLock", + 27: "Escape", + 32: " ", + 33: "PageUp", + 34: "PageDown", + 35: "End", + 36: "Home", + 37: "ArrowLeft", + 38: "ArrowUp", + 39: "ArrowRight", + 40: "ArrowDown", + 45: "Insert", + 46: "Delete", + 112: "F1", + 113: "F2", + 114: "F3", + 115: "F4", + 116: "F5", + 117: "F6", + 118: "F7", + 119: "F8", + 120: "F9", + 121: "F10", + 122: "F11", + 123: "F12", + 144: "NumLock", + 145: "ScrollLock", + 224: "Meta" +}, Od = { Alt: "altKey", Control: "ctrlKey", Meta: "metaKey", Shift: "shiftKey" }; +function Pd(a) { + var b2 = this.nativeEvent; + return b2.getModifierState ? b2.getModifierState(a) : (a = Od[a]) ? !!b2[a] : false; +} +function zd() { + return Pd; +} +var Qd = A({}, ud, { key: function(a) { + if (a.key) { + var b2 = Md[a.key] || a.key; + if ("Unidentified" !== b2) + return b2; + } + return "keypress" === a.type ? (a = od(a), 13 === a ? "Enter" : String.fromCharCode(a)) : "keydown" === a.type || "keyup" === a.type ? Nd[a.keyCode] || "Unidentified" : ""; +}, code: 0, location: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, repeat: 0, locale: 0, getModifierState: zd, charCode: function(a) { + return "keypress" === a.type ? od(a) : 0; +}, keyCode: function(a) { + return "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0; +}, which: function(a) { + return "keypress" === a.type ? od(a) : "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0; +} }), Rd = rd(Qd), Sd = A({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 }), Td = rd(Sd), Ud = A({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd }), Vd = rd(Ud), Wd = A({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }), Xd = rd(Wd), Yd = A({}, Ad, { + deltaX: function(a) { + return "deltaX" in a ? a.deltaX : "wheelDeltaX" in a ? -a.wheelDeltaX : 0; + }, + deltaY: function(a) { + return "deltaY" in a ? a.deltaY : "wheelDeltaY" in a ? -a.wheelDeltaY : "wheelDelta" in a ? -a.wheelDelta : 0; + }, + deltaZ: 0, + deltaMode: 0 +}), Zd = rd(Yd), $d = [9, 13, 27, 32], ae = ia && "CompositionEvent" in window, be = null; +ia && "documentMode" in document && (be = document.documentMode); +var ce = ia && "TextEvent" in window && !be, de = ia && (!ae || be && 8 < be && 11 >= be), ee = String.fromCharCode(32), fe = false; +function ge(a, b2) { + switch (a) { + case "keyup": + return -1 !== $d.indexOf(b2.keyCode); + case "keydown": + return 229 !== b2.keyCode; + case "keypress": + case "mousedown": + case "focusout": + return true; + default: + return false; + } +} +function he(a) { + a = a.detail; + return "object" === typeof a && "data" in a ? a.data : null; +} +var ie = false; +function je(a, b2) { + switch (a) { + case "compositionend": + return he(b2); + case "keypress": + if (32 !== b2.which) + return null; + fe = true; + return ee; + case "textInput": + return a = b2.data, a === ee && fe ? null : a; + default: + return null; + } +} +function ke(a, b2) { + if (ie) + return "compositionend" === a || !ae && ge(a, b2) ? (a = nd(), md = ld = kd = null, ie = false, a) : null; + switch (a) { + case "paste": + return null; + case "keypress": + if (!(b2.ctrlKey || b2.altKey || b2.metaKey) || b2.ctrlKey && b2.altKey) { + if (b2.char && 1 < b2.char.length) + return b2.char; + if (b2.which) + return String.fromCharCode(b2.which); + } + return null; + case "compositionend": + return de && "ko" !== b2.locale ? null : b2.data; + default: + return null; + } +} +var le = { color: true, date: true, datetime: true, "datetime-local": true, email: true, month: true, number: true, password: true, range: true, search: true, tel: true, text: true, time: true, url: true, week: true }; +function me(a) { + var b2 = a && a.nodeName && a.nodeName.toLowerCase(); + return "input" === b2 ? !!le[a.type] : "textarea" === b2 ? true : false; +} +function ne(a, b2, c2, d2) { + Eb(d2); + b2 = oe(b2, "onChange"); + 0 < b2.length && (c2 = new td("onChange", "change", null, c2, d2), a.push({ event: c2, listeners: b2 })); +} +var pe = null, qe = null; +function re(a) { + se(a, 0); +} +function te(a) { + var b2 = ue(a); + if (Wa(b2)) + return a; +} +function ve(a, b2) { + if ("change" === a) + return b2; +} +var we = false; +if (ia) { + var xe; + if (ia) { + var ye = "oninput" in document; + if (!ye) { + var ze = document.createElement("div"); + ze.setAttribute("oninput", "return;"); + ye = "function" === typeof ze.oninput; + } + xe = ye; + } else + xe = false; + we = xe && (!document.documentMode || 9 < document.documentMode); +} +function Ae() { + pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null); +} +function Be(a) { + if ("value" === a.propertyName && te(qe)) { + var b2 = []; + ne(b2, qe, a, xb(a)); + Jb(re, b2); + } +} +function Ce(a, b2, c2) { + "focusin" === a ? (Ae(), pe = b2, qe = c2, pe.attachEvent("onpropertychange", Be)) : "focusout" === a && Ae(); +} +function De(a) { + if ("selectionchange" === a || "keyup" === a || "keydown" === a) + return te(qe); +} +function Ee(a, b2) { + if ("click" === a) + return te(b2); +} +function Fe(a, b2) { + if ("input" === a || "change" === a) + return te(b2); +} +function Ge(a, b2) { + return a === b2 && (0 !== a || 1 / a === 1 / b2) || a !== a && b2 !== b2; +} +var He = "function" === typeof Object.is ? Object.is : Ge; +function Ie(a, b2) { + if (He(a, b2)) + return true; + if ("object" !== typeof a || null === a || "object" !== typeof b2 || null === b2) + return false; + var c2 = Object.keys(a), d2 = Object.keys(b2); + if (c2.length !== d2.length) + return false; + for (d2 = 0; d2 < c2.length; d2++) { + var e2 = c2[d2]; + if (!ja.call(b2, e2) || !He(a[e2], b2[e2])) + return false; + } + return true; +} +function Je(a) { + for (; a && a.firstChild; ) + a = a.firstChild; + return a; +} +function Ke(a, b2) { + var c2 = Je(a); + a = 0; + for (var d2; c2; ) { + if (3 === c2.nodeType) { + d2 = a + c2.textContent.length; + if (a <= b2 && d2 >= b2) + return { node: c2, offset: b2 - a }; + a = d2; + } + a: { + for (; c2; ) { + if (c2.nextSibling) { + c2 = c2.nextSibling; + break a; + } + c2 = c2.parentNode; + } + c2 = void 0; + } + c2 = Je(c2); + } +} +function Le(a, b2) { + return a && b2 ? a === b2 ? true : a && 3 === a.nodeType ? false : b2 && 3 === b2.nodeType ? Le(a, b2.parentNode) : "contains" in a ? a.contains(b2) : a.compareDocumentPosition ? !!(a.compareDocumentPosition(b2) & 16) : false : false; +} +function Me() { + for (var a = window, b2 = Xa(); b2 instanceof a.HTMLIFrameElement; ) { + try { + var c2 = "string" === typeof b2.contentWindow.location.href; + } catch (d2) { + c2 = false; + } + if (c2) + a = b2.contentWindow; + else + break; + b2 = Xa(a.document); + } + return b2; +} +function Ne(a) { + var b2 = a && a.nodeName && a.nodeName.toLowerCase(); + return b2 && ("input" === b2 && ("text" === a.type || "search" === a.type || "tel" === a.type || "url" === a.type || "password" === a.type) || "textarea" === b2 || "true" === a.contentEditable); +} +function Oe(a) { + var b2 = Me(), c2 = a.focusedElem, d2 = a.selectionRange; + if (b2 !== c2 && c2 && c2.ownerDocument && Le(c2.ownerDocument.documentElement, c2)) { + if (null !== d2 && Ne(c2)) { + if (b2 = d2.start, a = d2.end, void 0 === a && (a = b2), "selectionStart" in c2) + c2.selectionStart = b2, c2.selectionEnd = Math.min(a, c2.value.length); + else if (a = (b2 = c2.ownerDocument || document) && b2.defaultView || window, a.getSelection) { + a = a.getSelection(); + var e2 = c2.textContent.length, f2 = Math.min(d2.start, e2); + d2 = void 0 === d2.end ? f2 : Math.min(d2.end, e2); + !a.extend && f2 > d2 && (e2 = d2, d2 = f2, f2 = e2); + e2 = Ke(c2, f2); + var g2 = Ke( + c2, + d2 + ); + e2 && g2 && (1 !== a.rangeCount || a.anchorNode !== e2.node || a.anchorOffset !== e2.offset || a.focusNode !== g2.node || a.focusOffset !== g2.offset) && (b2 = b2.createRange(), b2.setStart(e2.node, e2.offset), a.removeAllRanges(), f2 > d2 ? (a.addRange(b2), a.extend(g2.node, g2.offset)) : (b2.setEnd(g2.node, g2.offset), a.addRange(b2))); + } + } + b2 = []; + for (a = c2; a = a.parentNode; ) + 1 === a.nodeType && b2.push({ element: a, left: a.scrollLeft, top: a.scrollTop }); + "function" === typeof c2.focus && c2.focus(); + for (c2 = 0; c2 < b2.length; c2++) + a = b2[c2], a.element.scrollLeft = a.left, a.element.scrollTop = a.top; + } +} +var Pe = ia && "documentMode" in document && 11 >= document.documentMode, Qe = null, Re = null, Se = null, Te = false; +function Ue(a, b2, c2) { + var d2 = c2.window === c2 ? c2.document : 9 === c2.nodeType ? c2 : c2.ownerDocument; + Te || null == Qe || Qe !== Xa(d2) || (d2 = Qe, "selectionStart" in d2 && Ne(d2) ? d2 = { start: d2.selectionStart, end: d2.selectionEnd } : (d2 = (d2.ownerDocument && d2.ownerDocument.defaultView || window).getSelection(), d2 = { anchorNode: d2.anchorNode, anchorOffset: d2.anchorOffset, focusNode: d2.focusNode, focusOffset: d2.focusOffset }), Se && Ie(Se, d2) || (Se = d2, d2 = oe(Re, "onSelect"), 0 < d2.length && (b2 = new td("onSelect", "select", null, b2, c2), a.push({ event: b2, listeners: d2 }), b2.target = Qe))); +} +function Ve(a, b2) { + var c2 = {}; + c2[a.toLowerCase()] = b2.toLowerCase(); + c2["Webkit" + a] = "webkit" + b2; + c2["Moz" + a] = "moz" + b2; + return c2; +} +var We = { animationend: Ve("Animation", "AnimationEnd"), animationiteration: Ve("Animation", "AnimationIteration"), animationstart: Ve("Animation", "AnimationStart"), transitionend: Ve("Transition", "TransitionEnd") }, Xe = {}, Ye = {}; +ia && (Ye = document.createElement("div").style, "AnimationEvent" in window || (delete We.animationend.animation, delete We.animationiteration.animation, delete We.animationstart.animation), "TransitionEvent" in window || delete We.transitionend.transition); +function Ze(a) { + if (Xe[a]) + return Xe[a]; + if (!We[a]) + return a; + var b2 = We[a], c2; + for (c2 in b2) + if (b2.hasOwnProperty(c2) && c2 in Ye) + return Xe[a] = b2[c2]; + return a; +} +var $e = Ze("animationend"), af = Ze("animationiteration"), bf = Ze("animationstart"), cf = Ze("transitionend"), df = /* @__PURE__ */ new Map(), ef = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" "); +function ff(a, b2) { + df.set(a, b2); + fa(b2, [a]); +} +for (var gf = 0; gf < ef.length; gf++) { + var hf = ef[gf], jf = hf.toLowerCase(), kf = hf[0].toUpperCase() + hf.slice(1); + ff(jf, "on" + kf); +} +ff($e, "onAnimationEnd"); +ff(af, "onAnimationIteration"); +ff(bf, "onAnimationStart"); +ff("dblclick", "onDoubleClick"); +ff("focusin", "onFocus"); +ff("focusout", "onBlur"); +ff(cf, "onTransitionEnd"); +ha("onMouseEnter", ["mouseout", "mouseover"]); +ha("onMouseLeave", ["mouseout", "mouseover"]); +ha("onPointerEnter", ["pointerout", "pointerover"]); +ha("onPointerLeave", ["pointerout", "pointerover"]); +fa("onChange", "change click focusin focusout input keydown keyup selectionchange".split(" ")); +fa("onSelect", "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" ")); +fa("onBeforeInput", ["compositionend", "keypress", "textInput", "paste"]); +fa("onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown".split(" ")); +fa("onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown".split(" ")); +fa("onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown".split(" ")); +var lf = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "), mf = new Set("cancel close invalid load scroll toggle".split(" ").concat(lf)); +function nf(a, b2, c2) { + var d2 = a.type || "unknown-event"; + a.currentTarget = c2; + Ub(d2, b2, void 0, a); + a.currentTarget = null; +} +function se(a, b2) { + b2 = 0 !== (b2 & 4); + for (var c2 = 0; c2 < a.length; c2++) { + var d2 = a[c2], e2 = d2.event; + d2 = d2.listeners; + a: { + var f2 = void 0; + if (b2) + for (var g2 = d2.length - 1; 0 <= g2; g2--) { + var h2 = d2[g2], k2 = h2.instance, l2 = h2.currentTarget; + h2 = h2.listener; + if (k2 !== f2 && e2.isPropagationStopped()) + break a; + nf(e2, h2, l2); + f2 = k2; + } + else + for (g2 = 0; g2 < d2.length; g2++) { + h2 = d2[g2]; + k2 = h2.instance; + l2 = h2.currentTarget; + h2 = h2.listener; + if (k2 !== f2 && e2.isPropagationStopped()) + break a; + nf(e2, h2, l2); + f2 = k2; + } + } + } + if (Qb) + throw a = Rb, Qb = false, Rb = null, a; +} +function D(a, b2) { + var c2 = b2[of]; + void 0 === c2 && (c2 = b2[of] = /* @__PURE__ */ new Set()); + var d2 = a + "__bubble"; + c2.has(d2) || (pf(b2, a, 2, false), c2.add(d2)); +} +function qf(a, b2, c2) { + var d2 = 0; + b2 && (d2 |= 4); + pf(c2, a, d2, b2); +} +var rf = "_reactListening" + Math.random().toString(36).slice(2); +function sf(a) { + if (!a[rf]) { + a[rf] = true; + da.forEach(function(b3) { + "selectionchange" !== b3 && (mf.has(b3) || qf(b3, false, a), qf(b3, true, a)); + }); + var b2 = 9 === a.nodeType ? a : a.ownerDocument; + null === b2 || b2[rf] || (b2[rf] = true, qf("selectionchange", false, b2)); + } +} +function pf(a, b2, c2, d2) { + switch (jd(b2)) { + case 1: + var e2 = ed; + break; + case 4: + e2 = gd; + break; + default: + e2 = fd; + } + c2 = e2.bind(null, b2, c2, a); + e2 = void 0; + !Lb || "touchstart" !== b2 && "touchmove" !== b2 && "wheel" !== b2 || (e2 = true); + d2 ? void 0 !== e2 ? a.addEventListener(b2, c2, { capture: true, passive: e2 }) : a.addEventListener(b2, c2, true) : void 0 !== e2 ? a.addEventListener(b2, c2, { passive: e2 }) : a.addEventListener(b2, c2, false); +} +function hd(a, b2, c2, d2, e2) { + var f2 = d2; + if (0 === (b2 & 1) && 0 === (b2 & 2) && null !== d2) + a: + for (; ; ) { + if (null === d2) + return; + var g2 = d2.tag; + if (3 === g2 || 4 === g2) { + var h2 = d2.stateNode.containerInfo; + if (h2 === e2 || 8 === h2.nodeType && h2.parentNode === e2) + break; + if (4 === g2) + for (g2 = d2.return; null !== g2; ) { + var k2 = g2.tag; + if (3 === k2 || 4 === k2) { + if (k2 = g2.stateNode.containerInfo, k2 === e2 || 8 === k2.nodeType && k2.parentNode === e2) + return; + } + g2 = g2.return; + } + for (; null !== h2; ) { + g2 = Wc(h2); + if (null === g2) + return; + k2 = g2.tag; + if (5 === k2 || 6 === k2) { + d2 = f2 = g2; + continue a; + } + h2 = h2.parentNode; + } + } + d2 = d2.return; + } + Jb(function() { + var d3 = f2, e3 = xb(c2), g3 = []; + a: { + var h3 = df.get(a); + if (void 0 !== h3) { + var k3 = td, n2 = a; + switch (a) { + case "keypress": + if (0 === od(c2)) + break a; + case "keydown": + case "keyup": + k3 = Rd; + break; + case "focusin": + n2 = "focus"; + k3 = Fd; + break; + case "focusout": + n2 = "blur"; + k3 = Fd; + break; + case "beforeblur": + case "afterblur": + k3 = Fd; + break; + case "click": + if (2 === c2.button) + break a; + case "auxclick": + case "dblclick": + case "mousedown": + case "mousemove": + case "mouseup": + case "mouseout": + case "mouseover": + case "contextmenu": + k3 = Bd; + break; + case "drag": + case "dragend": + case "dragenter": + case "dragexit": + case "dragleave": + case "dragover": + case "dragstart": + case "drop": + k3 = Dd; + break; + case "touchcancel": + case "touchend": + case "touchmove": + case "touchstart": + k3 = Vd; + break; + case $e: + case af: + case bf: + k3 = Hd; + break; + case cf: + k3 = Xd; + break; + case "scroll": + k3 = vd; + break; + case "wheel": + k3 = Zd; + break; + case "copy": + case "cut": + case "paste": + k3 = Jd; + break; + case "gotpointercapture": + case "lostpointercapture": + case "pointercancel": + case "pointerdown": + case "pointermove": + case "pointerout": + case "pointerover": + case "pointerup": + k3 = Td; + } + var t2 = 0 !== (b2 & 4), J2 = !t2 && "scroll" === a, x2 = t2 ? null !== h3 ? h3 + "Capture" : null : h3; + t2 = []; + for (var w2 = d3, u2; null !== w2; ) { + u2 = w2; + var F2 = u2.stateNode; + 5 === u2.tag && null !== F2 && (u2 = F2, null !== x2 && (F2 = Kb(w2, x2), null != F2 && t2.push(tf(w2, F2, u2)))); + if (J2) + break; + w2 = w2.return; + } + 0 < t2.length && (h3 = new k3(h3, n2, null, c2, e3), g3.push({ event: h3, listeners: t2 })); + } + } + if (0 === (b2 & 7)) { + a: { + h3 = "mouseover" === a || "pointerover" === a; + k3 = "mouseout" === a || "pointerout" === a; + if (h3 && c2 !== wb && (n2 = c2.relatedTarget || c2.fromElement) && (Wc(n2) || n2[uf])) + break a; + if (k3 || h3) { + h3 = e3.window === e3 ? e3 : (h3 = e3.ownerDocument) ? h3.defaultView || h3.parentWindow : window; + if (k3) { + if (n2 = c2.relatedTarget || c2.toElement, k3 = d3, n2 = n2 ? Wc(n2) : null, null !== n2 && (J2 = Vb(n2), n2 !== J2 || 5 !== n2.tag && 6 !== n2.tag)) + n2 = null; + } else + k3 = null, n2 = d3; + if (k3 !== n2) { + t2 = Bd; + F2 = "onMouseLeave"; + x2 = "onMouseEnter"; + w2 = "mouse"; + if ("pointerout" === a || "pointerover" === a) + t2 = Td, F2 = "onPointerLeave", x2 = "onPointerEnter", w2 = "pointer"; + J2 = null == k3 ? h3 : ue(k3); + u2 = null == n2 ? h3 : ue(n2); + h3 = new t2(F2, w2 + "leave", k3, c2, e3); + h3.target = J2; + h3.relatedTarget = u2; + F2 = null; + Wc(e3) === d3 && (t2 = new t2(x2, w2 + "enter", n2, c2, e3), t2.target = u2, t2.relatedTarget = J2, F2 = t2); + J2 = F2; + if (k3 && n2) + b: { + t2 = k3; + x2 = n2; + w2 = 0; + for (u2 = t2; u2; u2 = vf(u2)) + w2++; + u2 = 0; + for (F2 = x2; F2; F2 = vf(F2)) + u2++; + for (; 0 < w2 - u2; ) + t2 = vf(t2), w2--; + for (; 0 < u2 - w2; ) + x2 = vf(x2), u2--; + for (; w2--; ) { + if (t2 === x2 || null !== x2 && t2 === x2.alternate) + break b; + t2 = vf(t2); + x2 = vf(x2); + } + t2 = null; + } + else + t2 = null; + null !== k3 && wf(g3, h3, k3, t2, false); + null !== n2 && null !== J2 && wf(g3, J2, n2, t2, true); + } + } + } + a: { + h3 = d3 ? ue(d3) : window; + k3 = h3.nodeName && h3.nodeName.toLowerCase(); + if ("select" === k3 || "input" === k3 && "file" === h3.type) + var na = ve; + else if (me(h3)) + if (we) + na = Fe; + else { + na = De; + var xa = Ce; + } + else + (k3 = h3.nodeName) && "input" === k3.toLowerCase() && ("checkbox" === h3.type || "radio" === h3.type) && (na = Ee); + if (na && (na = na(a, d3))) { + ne(g3, na, c2, e3); + break a; + } + xa && xa(a, h3, d3); + "focusout" === a && (xa = h3._wrapperState) && xa.controlled && "number" === h3.type && cb(h3, "number", h3.value); + } + xa = d3 ? ue(d3) : window; + switch (a) { + case "focusin": + if (me(xa) || "true" === xa.contentEditable) + Qe = xa, Re = d3, Se = null; + break; + case "focusout": + Se = Re = Qe = null; + break; + case "mousedown": + Te = true; + break; + case "contextmenu": + case "mouseup": + case "dragend": + Te = false; + Ue(g3, c2, e3); + break; + case "selectionchange": + if (Pe) + break; + case "keydown": + case "keyup": + Ue(g3, c2, e3); + } + var $a; + if (ae) + b: { + switch (a) { + case "compositionstart": + var ba = "onCompositionStart"; + break b; + case "compositionend": + ba = "onCompositionEnd"; + break b; + case "compositionupdate": + ba = "onCompositionUpdate"; + break b; + } + ba = void 0; + } + else + ie ? ge(a, c2) && (ba = "onCompositionEnd") : "keydown" === a && 229 === c2.keyCode && (ba = "onCompositionStart"); + ba && (de && "ko" !== c2.locale && (ie || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie && ($a = nd()) : (kd = e3, ld = "value" in kd ? kd.value : kd.textContent, ie = true)), xa = oe(d3, ba), 0 < xa.length && (ba = new Ld(ba, a, null, c2, e3), g3.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he(c2), null !== $a && (ba.data = $a)))); + if ($a = ce ? je(a, c2) : ke(a, c2)) + d3 = oe(d3, "onBeforeInput"), 0 < d3.length && (e3 = new Ld("onBeforeInput", "beforeinput", null, c2, e3), g3.push({ event: e3, listeners: d3 }), e3.data = $a); + } + se(g3, b2); + }); +} +function tf(a, b2, c2) { + return { instance: a, listener: b2, currentTarget: c2 }; +} +function oe(a, b2) { + for (var c2 = b2 + "Capture", d2 = []; null !== a; ) { + var e2 = a, f2 = e2.stateNode; + 5 === e2.tag && null !== f2 && (e2 = f2, f2 = Kb(a, c2), null != f2 && d2.unshift(tf(a, f2, e2)), f2 = Kb(a, b2), null != f2 && d2.push(tf(a, f2, e2))); + a = a.return; + } + return d2; +} +function vf(a) { + if (null === a) + return null; + do + a = a.return; + while (a && 5 !== a.tag); + return a ? a : null; +} +function wf(a, b2, c2, d2, e2) { + for (var f2 = b2._reactName, g2 = []; null !== c2 && c2 !== d2; ) { + var h2 = c2, k2 = h2.alternate, l2 = h2.stateNode; + if (null !== k2 && k2 === d2) + break; + 5 === h2.tag && null !== l2 && (h2 = l2, e2 ? (k2 = Kb(c2, f2), null != k2 && g2.unshift(tf(c2, k2, h2))) : e2 || (k2 = Kb(c2, f2), null != k2 && g2.push(tf(c2, k2, h2)))); + c2 = c2.return; + } + 0 !== g2.length && a.push({ event: b2, listeners: g2 }); +} +var xf = /\r\n?/g, yf = /\u0000|\uFFFD/g; +function zf(a) { + return ("string" === typeof a ? a : "" + a).replace(xf, "\n").replace(yf, ""); +} +function Af(a, b2, c2) { + b2 = zf(b2); + if (zf(a) !== b2 && c2) + throw Error(p$2(425)); +} +function Bf() { +} +var Cf = null, Df = null; +function Ef(a, b2) { + return "textarea" === a || "noscript" === a || "string" === typeof b2.children || "number" === typeof b2.children || "object" === typeof b2.dangerouslySetInnerHTML && null !== b2.dangerouslySetInnerHTML && null != b2.dangerouslySetInnerHTML.__html; +} +var Ff = "function" === typeof setTimeout ? setTimeout : void 0, Gf = "function" === typeof clearTimeout ? clearTimeout : void 0, Hf = "function" === typeof Promise ? Promise : void 0, Jf = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof Hf ? function(a) { + return Hf.resolve(null).then(a).catch(If); +} : Ff; +function If(a) { + setTimeout(function() { + throw a; + }); +} +function Kf(a, b2) { + var c2 = b2, d2 = 0; + do { + var e2 = c2.nextSibling; + a.removeChild(c2); + if (e2 && 8 === e2.nodeType) + if (c2 = e2.data, "/$" === c2) { + if (0 === d2) { + a.removeChild(e2); + bd(b2); + return; + } + d2--; + } else + "$" !== c2 && "$?" !== c2 && "$!" !== c2 || d2++; + c2 = e2; + } while (c2); + bd(b2); +} +function Lf(a) { + for (; null != a; a = a.nextSibling) { + var b2 = a.nodeType; + if (1 === b2 || 3 === b2) + break; + if (8 === b2) { + b2 = a.data; + if ("$" === b2 || "$!" === b2 || "$?" === b2) + break; + if ("/$" === b2) + return null; + } + } + return a; +} +function Mf(a) { + a = a.previousSibling; + for (var b2 = 0; a; ) { + if (8 === a.nodeType) { + var c2 = a.data; + if ("$" === c2 || "$!" === c2 || "$?" === c2) { + if (0 === b2) + return a; + b2--; + } else + "/$" === c2 && b2++; + } + a = a.previousSibling; + } + return null; +} +var Nf = Math.random().toString(36).slice(2), Of = "__reactFiber$" + Nf, Pf = "__reactProps$" + Nf, uf = "__reactContainer$" + Nf, of = "__reactEvents$" + Nf, Qf = "__reactListeners$" + Nf, Rf = "__reactHandles$" + Nf; +function Wc(a) { + var b2 = a[Of]; + if (b2) + return b2; + for (var c2 = a.parentNode; c2; ) { + if (b2 = c2[uf] || c2[Of]) { + c2 = b2.alternate; + if (null !== b2.child || null !== c2 && null !== c2.child) + for (a = Mf(a); null !== a; ) { + if (c2 = a[Of]) + return c2; + a = Mf(a); + } + return b2; + } + a = c2; + c2 = a.parentNode; + } + return null; +} +function Cb(a) { + a = a[Of] || a[uf]; + return !a || 5 !== a.tag && 6 !== a.tag && 13 !== a.tag && 3 !== a.tag ? null : a; +} +function ue(a) { + if (5 === a.tag || 6 === a.tag) + return a.stateNode; + throw Error(p$2(33)); +} +function Db(a) { + return a[Pf] || null; +} +var Sf = [], Tf = -1; +function Uf(a) { + return { current: a }; +} +function E(a) { + 0 > Tf || (a.current = Sf[Tf], Sf[Tf] = null, Tf--); +} +function G(a, b2) { + Tf++; + Sf[Tf] = a.current; + a.current = b2; +} +var Vf = {}, H = Uf(Vf), Wf = Uf(false), Xf = Vf; +function Yf(a, b2) { + var c2 = a.type.contextTypes; + if (!c2) + return Vf; + var d2 = a.stateNode; + if (d2 && d2.__reactInternalMemoizedUnmaskedChildContext === b2) + return d2.__reactInternalMemoizedMaskedChildContext; + var e2 = {}, f2; + for (f2 in c2) + e2[f2] = b2[f2]; + d2 && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b2, a.__reactInternalMemoizedMaskedChildContext = e2); + return e2; +} +function Zf(a) { + a = a.childContextTypes; + return null !== a && void 0 !== a; +} +function $f() { + E(Wf); + E(H); +} +function ag(a, b2, c2) { + if (H.current !== Vf) + throw Error(p$2(168)); + G(H, b2); + G(Wf, c2); +} +function bg(a, b2, c2) { + var d2 = a.stateNode; + b2 = b2.childContextTypes; + if ("function" !== typeof d2.getChildContext) + return c2; + d2 = d2.getChildContext(); + for (var e2 in d2) + if (!(e2 in b2)) + throw Error(p$2(108, Ra(a) || "Unknown", e2)); + return A({}, c2, d2); +} +function cg(a) { + a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Vf; + Xf = H.current; + G(H, a); + G(Wf, Wf.current); + return true; +} +function dg(a, b2, c2) { + var d2 = a.stateNode; + if (!d2) + throw Error(p$2(169)); + c2 ? (a = bg(a, b2, Xf), d2.__reactInternalMemoizedMergedChildContext = a, E(Wf), E(H), G(H, a)) : E(Wf); + G(Wf, c2); +} +var eg = null, fg = false, gg = false; +function hg(a) { + null === eg ? eg = [a] : eg.push(a); +} +function ig(a) { + fg = true; + hg(a); +} +function jg() { + if (!gg && null !== eg) { + gg = true; + var a = 0, b2 = C; + try { + var c2 = eg; + for (C = 1; a < c2.length; a++) { + var d2 = c2[a]; + do + d2 = d2(true); + while (null !== d2); + } + eg = null; + fg = false; + } catch (e2) { + throw null !== eg && (eg = eg.slice(a + 1)), ac(fc, jg), e2; + } finally { + C = b2, gg = false; + } + } + return null; +} +var kg = [], lg = 0, mg = null, ng = 0, og = [], pg = 0, qg = null, rg = 1, sg = ""; +function tg(a, b2) { + kg[lg++] = ng; + kg[lg++] = mg; + mg = a; + ng = b2; +} +function ug(a, b2, c2) { + og[pg++] = rg; + og[pg++] = sg; + og[pg++] = qg; + qg = a; + var d2 = rg; + a = sg; + var e2 = 32 - oc(d2) - 1; + d2 &= ~(1 << e2); + c2 += 1; + var f2 = 32 - oc(b2) + e2; + if (30 < f2) { + var g2 = e2 - e2 % 5; + f2 = (d2 & (1 << g2) - 1).toString(32); + d2 >>= g2; + e2 -= g2; + rg = 1 << 32 - oc(b2) + e2 | c2 << e2 | d2; + sg = f2 + a; + } else + rg = 1 << f2 | c2 << e2 | d2, sg = a; +} +function vg(a) { + null !== a.return && (tg(a, 1), ug(a, 1, 0)); +} +function wg(a) { + for (; a === mg; ) + mg = kg[--lg], kg[lg] = null, ng = kg[--lg], kg[lg] = null; + for (; a === qg; ) + qg = og[--pg], og[pg] = null, sg = og[--pg], og[pg] = null, rg = og[--pg], og[pg] = null; +} +var xg = null, yg = null, I = false, zg = null; +function Ag(a, b2) { + var c2 = Bg(5, null, null, 0); + c2.elementType = "DELETED"; + c2.stateNode = b2; + c2.return = a; + b2 = a.deletions; + null === b2 ? (a.deletions = [c2], a.flags |= 16) : b2.push(c2); +} +function Cg(a, b2) { + switch (a.tag) { + case 5: + var c2 = a.type; + b2 = 1 !== b2.nodeType || c2.toLowerCase() !== b2.nodeName.toLowerCase() ? null : b2; + return null !== b2 ? (a.stateNode = b2, xg = a, yg = Lf(b2.firstChild), true) : false; + case 6: + return b2 = "" === a.pendingProps || 3 !== b2.nodeType ? null : b2, null !== b2 ? (a.stateNode = b2, xg = a, yg = null, true) : false; + case 13: + return b2 = 8 !== b2.nodeType ? null : b2, null !== b2 ? (c2 = null !== qg ? { id: rg, overflow: sg } : null, a.memoizedState = { dehydrated: b2, treeContext: c2, retryLane: 1073741824 }, c2 = Bg(18, null, null, 0), c2.stateNode = b2, c2.return = a, a.child = c2, xg = a, yg = null, true) : false; + default: + return false; + } +} +function Dg(a) { + return 0 !== (a.mode & 1) && 0 === (a.flags & 128); +} +function Eg(a) { + if (I) { + var b2 = yg; + if (b2) { + var c2 = b2; + if (!Cg(a, b2)) { + if (Dg(a)) + throw Error(p$2(418)); + b2 = Lf(c2.nextSibling); + var d2 = xg; + b2 && Cg(a, b2) ? Ag(d2, c2) : (a.flags = a.flags & -4097 | 2, I = false, xg = a); + } + } else { + if (Dg(a)) + throw Error(p$2(418)); + a.flags = a.flags & -4097 | 2; + I = false; + xg = a; + } + } +} +function Fg(a) { + for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag; ) + a = a.return; + xg = a; +} +function Gg(a) { + if (a !== xg) + return false; + if (!I) + return Fg(a), I = true, false; + var b2; + (b2 = 3 !== a.tag) && !(b2 = 5 !== a.tag) && (b2 = a.type, b2 = "head" !== b2 && "body" !== b2 && !Ef(a.type, a.memoizedProps)); + if (b2 && (b2 = yg)) { + if (Dg(a)) + throw Hg(), Error(p$2(418)); + for (; b2; ) + Ag(a, b2), b2 = Lf(b2.nextSibling); + } + Fg(a); + if (13 === a.tag) { + a = a.memoizedState; + a = null !== a ? a.dehydrated : null; + if (!a) + throw Error(p$2(317)); + a: { + a = a.nextSibling; + for (b2 = 0; a; ) { + if (8 === a.nodeType) { + var c2 = a.data; + if ("/$" === c2) { + if (0 === b2) { + yg = Lf(a.nextSibling); + break a; + } + b2--; + } else + "$" !== c2 && "$!" !== c2 && "$?" !== c2 || b2++; + } + a = a.nextSibling; + } + yg = null; + } + } else + yg = xg ? Lf(a.stateNode.nextSibling) : null; + return true; +} +function Hg() { + for (var a = yg; a; ) + a = Lf(a.nextSibling); +} +function Ig() { + yg = xg = null; + I = false; +} +function Jg(a) { + null === zg ? zg = [a] : zg.push(a); +} +var Kg = ua.ReactCurrentBatchConfig; +function Lg(a, b2, c2) { + a = c2.ref; + if (null !== a && "function" !== typeof a && "object" !== typeof a) { + if (c2._owner) { + c2 = c2._owner; + if (c2) { + if (1 !== c2.tag) + throw Error(p$2(309)); + var d2 = c2.stateNode; + } + if (!d2) + throw Error(p$2(147, a)); + var e2 = d2, f2 = "" + a; + if (null !== b2 && null !== b2.ref && "function" === typeof b2.ref && b2.ref._stringRef === f2) + return b2.ref; + b2 = function(a2) { + var b3 = e2.refs; + null === a2 ? delete b3[f2] : b3[f2] = a2; + }; + b2._stringRef = f2; + return b2; + } + if ("string" !== typeof a) + throw Error(p$2(284)); + if (!c2._owner) + throw Error(p$2(290, a)); + } + return a; +} +function Mg(a, b2) { + a = Object.prototype.toString.call(b2); + throw Error(p$2(31, "[object Object]" === a ? "object with keys {" + Object.keys(b2).join(", ") + "}" : a)); +} +function Ng(a) { + var b2 = a._init; + return b2(a._payload); +} +function Og(a) { + function b2(b3, c3) { + if (a) { + var d3 = b3.deletions; + null === d3 ? (b3.deletions = [c3], b3.flags |= 16) : d3.push(c3); + } + } + function c2(c3, d3) { + if (!a) + return null; + for (; null !== d3; ) + b2(c3, d3), d3 = d3.sibling; + return null; + } + function d2(a2, b3) { + for (a2 = /* @__PURE__ */ new Map(); null !== b3; ) + null !== b3.key ? a2.set(b3.key, b3) : a2.set(b3.index, b3), b3 = b3.sibling; + return a2; + } + function e2(a2, b3) { + a2 = Pg(a2, b3); + a2.index = 0; + a2.sibling = null; + return a2; + } + function f2(b3, c3, d3) { + b3.index = d3; + if (!a) + return b3.flags |= 1048576, c3; + d3 = b3.alternate; + if (null !== d3) + return d3 = d3.index, d3 < c3 ? (b3.flags |= 2, c3) : d3; + b3.flags |= 2; + return c3; + } + function g2(b3) { + a && null === b3.alternate && (b3.flags |= 2); + return b3; + } + function h2(a2, b3, c3, d3) { + if (null === b3 || 6 !== b3.tag) + return b3 = Qg(c3, a2.mode, d3), b3.return = a2, b3; + b3 = e2(b3, c3); + b3.return = a2; + return b3; + } + function k2(a2, b3, c3, d3) { + var f3 = c3.type; + if (f3 === ya) + return m2(a2, b3, c3.props.children, d3, c3.key); + if (null !== b3 && (b3.elementType === f3 || "object" === typeof f3 && null !== f3 && f3.$$typeof === Ha && Ng(f3) === b3.type)) + return d3 = e2(b3, c3.props), d3.ref = Lg(a2, b3, c3), d3.return = a2, d3; + d3 = Rg(c3.type, c3.key, c3.props, null, a2.mode, d3); + d3.ref = Lg(a2, b3, c3); + d3.return = a2; + return d3; + } + function l2(a2, b3, c3, d3) { + if (null === b3 || 4 !== b3.tag || b3.stateNode.containerInfo !== c3.containerInfo || b3.stateNode.implementation !== c3.implementation) + return b3 = Sg(c3, a2.mode, d3), b3.return = a2, b3; + b3 = e2(b3, c3.children || []); + b3.return = a2; + return b3; + } + function m2(a2, b3, c3, d3, f3) { + if (null === b3 || 7 !== b3.tag) + return b3 = Tg(c3, a2.mode, d3, f3), b3.return = a2, b3; + b3 = e2(b3, c3); + b3.return = a2; + return b3; + } + function q2(a2, b3, c3) { + if ("string" === typeof b3 && "" !== b3 || "number" === typeof b3) + return b3 = Qg("" + b3, a2.mode, c3), b3.return = a2, b3; + if ("object" === typeof b3 && null !== b3) { + switch (b3.$$typeof) { + case va: + return c3 = Rg(b3.type, b3.key, b3.props, null, a2.mode, c3), c3.ref = Lg(a2, null, b3), c3.return = a2, c3; + case wa: + return b3 = Sg(b3, a2.mode, c3), b3.return = a2, b3; + case Ha: + var d3 = b3._init; + return q2(a2, d3(b3._payload), c3); + } + if (eb(b3) || Ka(b3)) + return b3 = Tg(b3, a2.mode, c3, null), b3.return = a2, b3; + Mg(a2, b3); + } + return null; + } + function r2(a2, b3, c3, d3) { + var e3 = null !== b3 ? b3.key : null; + if ("string" === typeof c3 && "" !== c3 || "number" === typeof c3) + return null !== e3 ? null : h2(a2, b3, "" + c3, d3); + if ("object" === typeof c3 && null !== c3) { + switch (c3.$$typeof) { + case va: + return c3.key === e3 ? k2(a2, b3, c3, d3) : null; + case wa: + return c3.key === e3 ? l2(a2, b3, c3, d3) : null; + case Ha: + return e3 = c3._init, r2( + a2, + b3, + e3(c3._payload), + d3 + ); + } + if (eb(c3) || Ka(c3)) + return null !== e3 ? null : m2(a2, b3, c3, d3, null); + Mg(a2, c3); + } + return null; + } + function y2(a2, b3, c3, d3, e3) { + if ("string" === typeof d3 && "" !== d3 || "number" === typeof d3) + return a2 = a2.get(c3) || null, h2(b3, a2, "" + d3, e3); + if ("object" === typeof d3 && null !== d3) { + switch (d3.$$typeof) { + case va: + return a2 = a2.get(null === d3.key ? c3 : d3.key) || null, k2(b3, a2, d3, e3); + case wa: + return a2 = a2.get(null === d3.key ? c3 : d3.key) || null, l2(b3, a2, d3, e3); + case Ha: + var f3 = d3._init; + return y2(a2, b3, c3, f3(d3._payload), e3); + } + if (eb(d3) || Ka(d3)) + return a2 = a2.get(c3) || null, m2(b3, a2, d3, e3, null); + Mg(b3, d3); + } + return null; + } + function n2(e3, g3, h3, k3) { + for (var l3 = null, m3 = null, u2 = g3, w2 = g3 = 0, x2 = null; null !== u2 && w2 < h3.length; w2++) { + u2.index > w2 ? (x2 = u2, u2 = null) : x2 = u2.sibling; + var n3 = r2(e3, u2, h3[w2], k3); + if (null === n3) { + null === u2 && (u2 = x2); + break; + } + a && u2 && null === n3.alternate && b2(e3, u2); + g3 = f2(n3, g3, w2); + null === m3 ? l3 = n3 : m3.sibling = n3; + m3 = n3; + u2 = x2; + } + if (w2 === h3.length) + return c2(e3, u2), I && tg(e3, w2), l3; + if (null === u2) { + for (; w2 < h3.length; w2++) + u2 = q2(e3, h3[w2], k3), null !== u2 && (g3 = f2(u2, g3, w2), null === m3 ? l3 = u2 : m3.sibling = u2, m3 = u2); + I && tg(e3, w2); + return l3; + } + for (u2 = d2(e3, u2); w2 < h3.length; w2++) + x2 = y2(u2, e3, w2, h3[w2], k3), null !== x2 && (a && null !== x2.alternate && u2.delete(null === x2.key ? w2 : x2.key), g3 = f2(x2, g3, w2), null === m3 ? l3 = x2 : m3.sibling = x2, m3 = x2); + a && u2.forEach(function(a2) { + return b2(e3, a2); + }); + I && tg(e3, w2); + return l3; + } + function t2(e3, g3, h3, k3) { + var l3 = Ka(h3); + if ("function" !== typeof l3) + throw Error(p$2(150)); + h3 = l3.call(h3); + if (null == h3) + throw Error(p$2(151)); + for (var u2 = l3 = null, m3 = g3, w2 = g3 = 0, x2 = null, n3 = h3.next(); null !== m3 && !n3.done; w2++, n3 = h3.next()) { + m3.index > w2 ? (x2 = m3, m3 = null) : x2 = m3.sibling; + var t3 = r2(e3, m3, n3.value, k3); + if (null === t3) { + null === m3 && (m3 = x2); + break; + } + a && m3 && null === t3.alternate && b2(e3, m3); + g3 = f2(t3, g3, w2); + null === u2 ? l3 = t3 : u2.sibling = t3; + u2 = t3; + m3 = x2; + } + if (n3.done) + return c2( + e3, + m3 + ), I && tg(e3, w2), l3; + if (null === m3) { + for (; !n3.done; w2++, n3 = h3.next()) + n3 = q2(e3, n3.value, k3), null !== n3 && (g3 = f2(n3, g3, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3); + I && tg(e3, w2); + return l3; + } + for (m3 = d2(e3, m3); !n3.done; w2++, n3 = h3.next()) + n3 = y2(m3, e3, w2, n3.value, k3), null !== n3 && (a && null !== n3.alternate && m3.delete(null === n3.key ? w2 : n3.key), g3 = f2(n3, g3, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3); + a && m3.forEach(function(a2) { + return b2(e3, a2); + }); + I && tg(e3, w2); + return l3; + } + function J2(a2, d3, f3, h3) { + "object" === typeof f3 && null !== f3 && f3.type === ya && null === f3.key && (f3 = f3.props.children); + if ("object" === typeof f3 && null !== f3) { + switch (f3.$$typeof) { + case va: + a: { + for (var k3 = f3.key, l3 = d3; null !== l3; ) { + if (l3.key === k3) { + k3 = f3.type; + if (k3 === ya) { + if (7 === l3.tag) { + c2(a2, l3.sibling); + d3 = e2(l3, f3.props.children); + d3.return = a2; + a2 = d3; + break a; + } + } else if (l3.elementType === k3 || "object" === typeof k3 && null !== k3 && k3.$$typeof === Ha && Ng(k3) === l3.type) { + c2(a2, l3.sibling); + d3 = e2(l3, f3.props); + d3.ref = Lg(a2, l3, f3); + d3.return = a2; + a2 = d3; + break a; + } + c2(a2, l3); + break; + } else + b2(a2, l3); + l3 = l3.sibling; + } + f3.type === ya ? (d3 = Tg(f3.props.children, a2.mode, h3, f3.key), d3.return = a2, a2 = d3) : (h3 = Rg(f3.type, f3.key, f3.props, null, a2.mode, h3), h3.ref = Lg(a2, d3, f3), h3.return = a2, a2 = h3); + } + return g2(a2); + case wa: + a: { + for (l3 = f3.key; null !== d3; ) { + if (d3.key === l3) + if (4 === d3.tag && d3.stateNode.containerInfo === f3.containerInfo && d3.stateNode.implementation === f3.implementation) { + c2(a2, d3.sibling); + d3 = e2(d3, f3.children || []); + d3.return = a2; + a2 = d3; + break a; + } else { + c2(a2, d3); + break; + } + else + b2(a2, d3); + d3 = d3.sibling; + } + d3 = Sg(f3, a2.mode, h3); + d3.return = a2; + a2 = d3; + } + return g2(a2); + case Ha: + return l3 = f3._init, J2(a2, d3, l3(f3._payload), h3); + } + if (eb(f3)) + return n2(a2, d3, f3, h3); + if (Ka(f3)) + return t2(a2, d3, f3, h3); + Mg(a2, f3); + } + return "string" === typeof f3 && "" !== f3 || "number" === typeof f3 ? (f3 = "" + f3, null !== d3 && 6 === d3.tag ? (c2(a2, d3.sibling), d3 = e2(d3, f3), d3.return = a2, a2 = d3) : (c2(a2, d3), d3 = Qg(f3, a2.mode, h3), d3.return = a2, a2 = d3), g2(a2)) : c2(a2, d3); + } + return J2; +} +var Ug = Og(true), Vg = Og(false), Wg = Uf(null), Xg = null, Yg = null, Zg = null; +function $g() { + Zg = Yg = Xg = null; +} +function ah(a) { + var b2 = Wg.current; + E(Wg); + a._currentValue = b2; +} +function bh(a, b2, c2) { + for (; null !== a; ) { + var d2 = a.alternate; + (a.childLanes & b2) !== b2 ? (a.childLanes |= b2, null !== d2 && (d2.childLanes |= b2)) : null !== d2 && (d2.childLanes & b2) !== b2 && (d2.childLanes |= b2); + if (a === c2) + break; + a = a.return; + } +} +function ch(a, b2) { + Xg = a; + Zg = Yg = null; + a = a.dependencies; + null !== a && null !== a.firstContext && (0 !== (a.lanes & b2) && (dh = true), a.firstContext = null); +} +function eh(a) { + var b2 = a._currentValue; + if (Zg !== a) + if (a = { context: a, memoizedValue: b2, next: null }, null === Yg) { + if (null === Xg) + throw Error(p$2(308)); + Yg = a; + Xg.dependencies = { lanes: 0, firstContext: a }; + } else + Yg = Yg.next = a; + return b2; +} +var fh = null; +function gh(a) { + null === fh ? fh = [a] : fh.push(a); +} +function hh(a, b2, c2, d2) { + var e2 = b2.interleaved; + null === e2 ? (c2.next = c2, gh(b2)) : (c2.next = e2.next, e2.next = c2); + b2.interleaved = c2; + return ih(a, d2); +} +function ih(a, b2) { + a.lanes |= b2; + var c2 = a.alternate; + null !== c2 && (c2.lanes |= b2); + c2 = a; + for (a = a.return; null !== a; ) + a.childLanes |= b2, c2 = a.alternate, null !== c2 && (c2.childLanes |= b2), c2 = a, a = a.return; + return 3 === c2.tag ? c2.stateNode : null; +} +var jh = false; +function kh(a) { + a.updateQueue = { baseState: a.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null }; +} +function lh(a, b2) { + a = a.updateQueue; + b2.updateQueue === a && (b2.updateQueue = { baseState: a.baseState, firstBaseUpdate: a.firstBaseUpdate, lastBaseUpdate: a.lastBaseUpdate, shared: a.shared, effects: a.effects }); +} +function mh(a, b2) { + return { eventTime: a, lane: b2, tag: 0, payload: null, callback: null, next: null }; +} +function nh(a, b2, c2) { + var d2 = a.updateQueue; + if (null === d2) + return null; + d2 = d2.shared; + if (0 !== (K & 2)) { + var e2 = d2.pending; + null === e2 ? b2.next = b2 : (b2.next = e2.next, e2.next = b2); + d2.pending = b2; + return ih(a, c2); + } + e2 = d2.interleaved; + null === e2 ? (b2.next = b2, gh(d2)) : (b2.next = e2.next, e2.next = b2); + d2.interleaved = b2; + return ih(a, c2); +} +function oh(a, b2, c2) { + b2 = b2.updateQueue; + if (null !== b2 && (b2 = b2.shared, 0 !== (c2 & 4194240))) { + var d2 = b2.lanes; + d2 &= a.pendingLanes; + c2 |= d2; + b2.lanes = c2; + Cc(a, c2); + } +} +function ph(a, b2) { + var c2 = a.updateQueue, d2 = a.alternate; + if (null !== d2 && (d2 = d2.updateQueue, c2 === d2)) { + var e2 = null, f2 = null; + c2 = c2.firstBaseUpdate; + if (null !== c2) { + do { + var g2 = { eventTime: c2.eventTime, lane: c2.lane, tag: c2.tag, payload: c2.payload, callback: c2.callback, next: null }; + null === f2 ? e2 = f2 = g2 : f2 = f2.next = g2; + c2 = c2.next; + } while (null !== c2); + null === f2 ? e2 = f2 = b2 : f2 = f2.next = b2; + } else + e2 = f2 = b2; + c2 = { baseState: d2.baseState, firstBaseUpdate: e2, lastBaseUpdate: f2, shared: d2.shared, effects: d2.effects }; + a.updateQueue = c2; + return; + } + a = c2.lastBaseUpdate; + null === a ? c2.firstBaseUpdate = b2 : a.next = b2; + c2.lastBaseUpdate = b2; +} +function qh(a, b2, c2, d2) { + var e2 = a.updateQueue; + jh = false; + var f2 = e2.firstBaseUpdate, g2 = e2.lastBaseUpdate, h2 = e2.shared.pending; + if (null !== h2) { + e2.shared.pending = null; + var k2 = h2, l2 = k2.next; + k2.next = null; + null === g2 ? f2 = l2 : g2.next = l2; + g2 = k2; + var m2 = a.alternate; + null !== m2 && (m2 = m2.updateQueue, h2 = m2.lastBaseUpdate, h2 !== g2 && (null === h2 ? m2.firstBaseUpdate = l2 : h2.next = l2, m2.lastBaseUpdate = k2)); + } + if (null !== f2) { + var q2 = e2.baseState; + g2 = 0; + m2 = l2 = k2 = null; + h2 = f2; + do { + var r2 = h2.lane, y2 = h2.eventTime; + if ((d2 & r2) === r2) { + null !== m2 && (m2 = m2.next = { + eventTime: y2, + lane: 0, + tag: h2.tag, + payload: h2.payload, + callback: h2.callback, + next: null + }); + a: { + var n2 = a, t2 = h2; + r2 = b2; + y2 = c2; + switch (t2.tag) { + case 1: + n2 = t2.payload; + if ("function" === typeof n2) { + q2 = n2.call(y2, q2, r2); + break a; + } + q2 = n2; + break a; + case 3: + n2.flags = n2.flags & -65537 | 128; + case 0: + n2 = t2.payload; + r2 = "function" === typeof n2 ? n2.call(y2, q2, r2) : n2; + if (null === r2 || void 0 === r2) + break a; + q2 = A({}, q2, r2); + break a; + case 2: + jh = true; + } + } + null !== h2.callback && 0 !== h2.lane && (a.flags |= 64, r2 = e2.effects, null === r2 ? e2.effects = [h2] : r2.push(h2)); + } else + y2 = { eventTime: y2, lane: r2, tag: h2.tag, payload: h2.payload, callback: h2.callback, next: null }, null === m2 ? (l2 = m2 = y2, k2 = q2) : m2 = m2.next = y2, g2 |= r2; + h2 = h2.next; + if (null === h2) + if (h2 = e2.shared.pending, null === h2) + break; + else + r2 = h2, h2 = r2.next, r2.next = null, e2.lastBaseUpdate = r2, e2.shared.pending = null; + } while (1); + null === m2 && (k2 = q2); + e2.baseState = k2; + e2.firstBaseUpdate = l2; + e2.lastBaseUpdate = m2; + b2 = e2.shared.interleaved; + if (null !== b2) { + e2 = b2; + do + g2 |= e2.lane, e2 = e2.next; + while (e2 !== b2); + } else + null === f2 && (e2.shared.lanes = 0); + rh |= g2; + a.lanes = g2; + a.memoizedState = q2; + } +} +function sh(a, b2, c2) { + a = b2.effects; + b2.effects = null; + if (null !== a) + for (b2 = 0; b2 < a.length; b2++) { + var d2 = a[b2], e2 = d2.callback; + if (null !== e2) { + d2.callback = null; + d2 = c2; + if ("function" !== typeof e2) + throw Error(p$2(191, e2)); + e2.call(d2); + } + } +} +var th = {}, uh = Uf(th), vh = Uf(th), wh = Uf(th); +function xh(a) { + if (a === th) + throw Error(p$2(174)); + return a; +} +function yh(a, b2) { + G(wh, b2); + G(vh, a); + G(uh, th); + a = b2.nodeType; + switch (a) { + case 9: + case 11: + b2 = (b2 = b2.documentElement) ? b2.namespaceURI : lb(null, ""); + break; + default: + a = 8 === a ? b2.parentNode : b2, b2 = a.namespaceURI || null, a = a.tagName, b2 = lb(b2, a); + } + E(uh); + G(uh, b2); +} +function zh() { + E(uh); + E(vh); + E(wh); +} +function Ah(a) { + xh(wh.current); + var b2 = xh(uh.current); + var c2 = lb(b2, a.type); + b2 !== c2 && (G(vh, a), G(uh, c2)); +} +function Bh(a) { + vh.current === a && (E(uh), E(vh)); +} +var L = Uf(0); +function Ch(a) { + for (var b2 = a; null !== b2; ) { + if (13 === b2.tag) { + var c2 = b2.memoizedState; + if (null !== c2 && (c2 = c2.dehydrated, null === c2 || "$?" === c2.data || "$!" === c2.data)) + return b2; + } else if (19 === b2.tag && void 0 !== b2.memoizedProps.revealOrder) { + if (0 !== (b2.flags & 128)) + return b2; + } else if (null !== b2.child) { + b2.child.return = b2; + b2 = b2.child; + continue; + } + if (b2 === a) + break; + for (; null === b2.sibling; ) { + if (null === b2.return || b2.return === a) + return null; + b2 = b2.return; + } + b2.sibling.return = b2.return; + b2 = b2.sibling; + } + return null; +} +var Dh = []; +function Eh() { + for (var a = 0; a < Dh.length; a++) + Dh[a]._workInProgressVersionPrimary = null; + Dh.length = 0; +} +var Fh = ua.ReactCurrentDispatcher, Gh = ua.ReactCurrentBatchConfig, Hh = 0, M = null, N = null, O = null, Ih = false, Jh = false, Kh = 0, Lh = 0; +function P() { + throw Error(p$2(321)); +} +function Mh(a, b2) { + if (null === b2) + return false; + for (var c2 = 0; c2 < b2.length && c2 < a.length; c2++) + if (!He(a[c2], b2[c2])) + return false; + return true; +} +function Nh(a, b2, c2, d2, e2, f2) { + Hh = f2; + M = b2; + b2.memoizedState = null; + b2.updateQueue = null; + b2.lanes = 0; + Fh.current = null === a || null === a.memoizedState ? Oh : Ph; + a = c2(d2, e2); + if (Jh) { + f2 = 0; + do { + Jh = false; + Kh = 0; + if (25 <= f2) + throw Error(p$2(301)); + f2 += 1; + O = N = null; + b2.updateQueue = null; + Fh.current = Qh; + a = c2(d2, e2); + } while (Jh); + } + Fh.current = Rh; + b2 = null !== N && null !== N.next; + Hh = 0; + O = N = M = null; + Ih = false; + if (b2) + throw Error(p$2(300)); + return a; +} +function Sh() { + var a = 0 !== Kh; + Kh = 0; + return a; +} +function Th() { + var a = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null }; + null === O ? M.memoizedState = O = a : O = O.next = a; + return O; +} +function Uh() { + if (null === N) { + var a = M.alternate; + a = null !== a ? a.memoizedState : null; + } else + a = N.next; + var b2 = null === O ? M.memoizedState : O.next; + if (null !== b2) + O = b2, N = a; + else { + if (null === a) + throw Error(p$2(310)); + N = a; + a = { memoizedState: N.memoizedState, baseState: N.baseState, baseQueue: N.baseQueue, queue: N.queue, next: null }; + null === O ? M.memoizedState = O = a : O = O.next = a; + } + return O; +} +function Vh(a, b2) { + return "function" === typeof b2 ? b2(a) : b2; +} +function Wh(a) { + var b2 = Uh(), c2 = b2.queue; + if (null === c2) + throw Error(p$2(311)); + c2.lastRenderedReducer = a; + var d2 = N, e2 = d2.baseQueue, f2 = c2.pending; + if (null !== f2) { + if (null !== e2) { + var g2 = e2.next; + e2.next = f2.next; + f2.next = g2; + } + d2.baseQueue = e2 = f2; + c2.pending = null; + } + if (null !== e2) { + f2 = e2.next; + d2 = d2.baseState; + var h2 = g2 = null, k2 = null, l2 = f2; + do { + var m2 = l2.lane; + if ((Hh & m2) === m2) + null !== k2 && (k2 = k2.next = { lane: 0, action: l2.action, hasEagerState: l2.hasEagerState, eagerState: l2.eagerState, next: null }), d2 = l2.hasEagerState ? l2.eagerState : a(d2, l2.action); + else { + var q2 = { + lane: m2, + action: l2.action, + hasEagerState: l2.hasEagerState, + eagerState: l2.eagerState, + next: null + }; + null === k2 ? (h2 = k2 = q2, g2 = d2) : k2 = k2.next = q2; + M.lanes |= m2; + rh |= m2; + } + l2 = l2.next; + } while (null !== l2 && l2 !== f2); + null === k2 ? g2 = d2 : k2.next = h2; + He(d2, b2.memoizedState) || (dh = true); + b2.memoizedState = d2; + b2.baseState = g2; + b2.baseQueue = k2; + c2.lastRenderedState = d2; + } + a = c2.interleaved; + if (null !== a) { + e2 = a; + do + f2 = e2.lane, M.lanes |= f2, rh |= f2, e2 = e2.next; + while (e2 !== a); + } else + null === e2 && (c2.lanes = 0); + return [b2.memoizedState, c2.dispatch]; +} +function Xh(a) { + var b2 = Uh(), c2 = b2.queue; + if (null === c2) + throw Error(p$2(311)); + c2.lastRenderedReducer = a; + var d2 = c2.dispatch, e2 = c2.pending, f2 = b2.memoizedState; + if (null !== e2) { + c2.pending = null; + var g2 = e2 = e2.next; + do + f2 = a(f2, g2.action), g2 = g2.next; + while (g2 !== e2); + He(f2, b2.memoizedState) || (dh = true); + b2.memoizedState = f2; + null === b2.baseQueue && (b2.baseState = f2); + c2.lastRenderedState = f2; + } + return [f2, d2]; +} +function Yh() { +} +function Zh(a, b2) { + var c2 = M, d2 = Uh(), e2 = b2(), f2 = !He(d2.memoizedState, e2); + f2 && (d2.memoizedState = e2, dh = true); + d2 = d2.queue; + $h(ai.bind(null, c2, d2, a), [a]); + if (d2.getSnapshot !== b2 || f2 || null !== O && O.memoizedState.tag & 1) { + c2.flags |= 2048; + bi(9, ci.bind(null, c2, d2, e2, b2), void 0, null); + if (null === Q) + throw Error(p$2(349)); + 0 !== (Hh & 30) || di(c2, b2, e2); + } + return e2; +} +function di(a, b2, c2) { + a.flags |= 16384; + a = { getSnapshot: b2, value: c2 }; + b2 = M.updateQueue; + null === b2 ? (b2 = { lastEffect: null, stores: null }, M.updateQueue = b2, b2.stores = [a]) : (c2 = b2.stores, null === c2 ? b2.stores = [a] : c2.push(a)); +} +function ci(a, b2, c2, d2) { + b2.value = c2; + b2.getSnapshot = d2; + ei(b2) && fi(a); +} +function ai(a, b2, c2) { + return c2(function() { + ei(b2) && fi(a); + }); +} +function ei(a) { + var b2 = a.getSnapshot; + a = a.value; + try { + var c2 = b2(); + return !He(a, c2); + } catch (d2) { + return true; + } +} +function fi(a) { + var b2 = ih(a, 1); + null !== b2 && gi(b2, a, 1, -1); +} +function hi(a) { + var b2 = Th(); + "function" === typeof a && (a = a()); + b2.memoizedState = b2.baseState = a; + a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: Vh, lastRenderedState: a }; + b2.queue = a; + a = a.dispatch = ii.bind(null, M, a); + return [b2.memoizedState, a]; +} +function bi(a, b2, c2, d2) { + a = { tag: a, create: b2, destroy: c2, deps: d2, next: null }; + b2 = M.updateQueue; + null === b2 ? (b2 = { lastEffect: null, stores: null }, M.updateQueue = b2, b2.lastEffect = a.next = a) : (c2 = b2.lastEffect, null === c2 ? b2.lastEffect = a.next = a : (d2 = c2.next, c2.next = a, a.next = d2, b2.lastEffect = a)); + return a; +} +function ji() { + return Uh().memoizedState; +} +function ki(a, b2, c2, d2) { + var e2 = Th(); + M.flags |= a; + e2.memoizedState = bi(1 | b2, c2, void 0, void 0 === d2 ? null : d2); +} +function li(a, b2, c2, d2) { + var e2 = Uh(); + d2 = void 0 === d2 ? null : d2; + var f2 = void 0; + if (null !== N) { + var g2 = N.memoizedState; + f2 = g2.destroy; + if (null !== d2 && Mh(d2, g2.deps)) { + e2.memoizedState = bi(b2, c2, f2, d2); + return; + } + } + M.flags |= a; + e2.memoizedState = bi(1 | b2, c2, f2, d2); +} +function mi(a, b2) { + return ki(8390656, 8, a, b2); +} +function $h(a, b2) { + return li(2048, 8, a, b2); +} +function ni(a, b2) { + return li(4, 2, a, b2); +} +function oi(a, b2) { + return li(4, 4, a, b2); +} +function pi(a, b2) { + if ("function" === typeof b2) + return a = a(), b2(a), function() { + b2(null); + }; + if (null !== b2 && void 0 !== b2) + return a = a(), b2.current = a, function() { + b2.current = null; + }; +} +function qi(a, b2, c2) { + c2 = null !== c2 && void 0 !== c2 ? c2.concat([a]) : null; + return li(4, 4, pi.bind(null, b2, a), c2); +} +function ri() { +} +function si(a, b2) { + var c2 = Uh(); + b2 = void 0 === b2 ? null : b2; + var d2 = c2.memoizedState; + if (null !== d2 && null !== b2 && Mh(b2, d2[1])) + return d2[0]; + c2.memoizedState = [a, b2]; + return a; +} +function ti(a, b2) { + var c2 = Uh(); + b2 = void 0 === b2 ? null : b2; + var d2 = c2.memoizedState; + if (null !== d2 && null !== b2 && Mh(b2, d2[1])) + return d2[0]; + a = a(); + c2.memoizedState = [a, b2]; + return a; +} +function ui(a, b2, c2) { + if (0 === (Hh & 21)) + return a.baseState && (a.baseState = false, dh = true), a.memoizedState = c2; + He(c2, b2) || (c2 = yc(), M.lanes |= c2, rh |= c2, a.baseState = true); + return b2; +} +function vi(a, b2) { + var c2 = C; + C = 0 !== c2 && 4 > c2 ? c2 : 4; + a(true); + var d2 = Gh.transition; + Gh.transition = {}; + try { + a(false), b2(); + } finally { + C = c2, Gh.transition = d2; + } +} +function wi() { + return Uh().memoizedState; +} +function xi(a, b2, c2) { + var d2 = yi(a); + c2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null }; + if (zi(a)) + Ai(b2, c2); + else if (c2 = hh(a, b2, c2, d2), null !== c2) { + var e2 = R(); + gi(c2, a, d2, e2); + Bi(c2, b2, d2); + } +} +function ii(a, b2, c2) { + var d2 = yi(a), e2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null }; + if (zi(a)) + Ai(b2, e2); + else { + var f2 = a.alternate; + if (0 === a.lanes && (null === f2 || 0 === f2.lanes) && (f2 = b2.lastRenderedReducer, null !== f2)) + try { + var g2 = b2.lastRenderedState, h2 = f2(g2, c2); + e2.hasEagerState = true; + e2.eagerState = h2; + if (He(h2, g2)) { + var k2 = b2.interleaved; + null === k2 ? (e2.next = e2, gh(b2)) : (e2.next = k2.next, k2.next = e2); + b2.interleaved = e2; + return; + } + } catch (l2) { + } finally { + } + c2 = hh(a, b2, e2, d2); + null !== c2 && (e2 = R(), gi(c2, a, d2, e2), Bi(c2, b2, d2)); + } +} +function zi(a) { + var b2 = a.alternate; + return a === M || null !== b2 && b2 === M; +} +function Ai(a, b2) { + Jh = Ih = true; + var c2 = a.pending; + null === c2 ? b2.next = b2 : (b2.next = c2.next, c2.next = b2); + a.pending = b2; +} +function Bi(a, b2, c2) { + if (0 !== (c2 & 4194240)) { + var d2 = b2.lanes; + d2 &= a.pendingLanes; + c2 |= d2; + b2.lanes = c2; + Cc(a, c2); + } +} +var Rh = { readContext: eh, useCallback: P, useContext: P, useEffect: P, useImperativeHandle: P, useInsertionEffect: P, useLayoutEffect: P, useMemo: P, useReducer: P, useRef: P, useState: P, useDebugValue: P, useDeferredValue: P, useTransition: P, useMutableSource: P, useSyncExternalStore: P, useId: P, unstable_isNewReconciler: false }, Oh = { readContext: eh, useCallback: function(a, b2) { + Th().memoizedState = [a, void 0 === b2 ? null : b2]; + return a; +}, useContext: eh, useEffect: mi, useImperativeHandle: function(a, b2, c2) { + c2 = null !== c2 && void 0 !== c2 ? c2.concat([a]) : null; + return ki( + 4194308, + 4, + pi.bind(null, b2, a), + c2 + ); +}, useLayoutEffect: function(a, b2) { + return ki(4194308, 4, a, b2); +}, useInsertionEffect: function(a, b2) { + return ki(4, 2, a, b2); +}, useMemo: function(a, b2) { + var c2 = Th(); + b2 = void 0 === b2 ? null : b2; + a = a(); + c2.memoizedState = [a, b2]; + return a; +}, useReducer: function(a, b2, c2) { + var d2 = Th(); + b2 = void 0 !== c2 ? c2(b2) : b2; + d2.memoizedState = d2.baseState = b2; + a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a, lastRenderedState: b2 }; + d2.queue = a; + a = a.dispatch = xi.bind(null, M, a); + return [d2.memoizedState, a]; +}, useRef: function(a) { + var b2 = Th(); + a = { current: a }; + return b2.memoizedState = a; +}, useState: hi, useDebugValue: ri, useDeferredValue: function(a) { + return Th().memoizedState = a; +}, useTransition: function() { + var a = hi(false), b2 = a[0]; + a = vi.bind(null, a[1]); + Th().memoizedState = a; + return [b2, a]; +}, useMutableSource: function() { +}, useSyncExternalStore: function(a, b2, c2) { + var d2 = M, e2 = Th(); + if (I) { + if (void 0 === c2) + throw Error(p$2(407)); + c2 = c2(); + } else { + c2 = b2(); + if (null === Q) + throw Error(p$2(349)); + 0 !== (Hh & 30) || di(d2, b2, c2); + } + e2.memoizedState = c2; + var f2 = { value: c2, getSnapshot: b2 }; + e2.queue = f2; + mi(ai.bind( + null, + d2, + f2, + a + ), [a]); + d2.flags |= 2048; + bi(9, ci.bind(null, d2, f2, c2, b2), void 0, null); + return c2; +}, useId: function() { + var a = Th(), b2 = Q.identifierPrefix; + if (I) { + var c2 = sg; + var d2 = rg; + c2 = (d2 & ~(1 << 32 - oc(d2) - 1)).toString(32) + c2; + b2 = ":" + b2 + "R" + c2; + c2 = Kh++; + 0 < c2 && (b2 += "H" + c2.toString(32)); + b2 += ":"; + } else + c2 = Lh++, b2 = ":" + b2 + "r" + c2.toString(32) + ":"; + return a.memoizedState = b2; +}, unstable_isNewReconciler: false }, Ph = { + readContext: eh, + useCallback: si, + useContext: eh, + useEffect: $h, + useImperativeHandle: qi, + useInsertionEffect: ni, + useLayoutEffect: oi, + useMemo: ti, + useReducer: Wh, + useRef: ji, + useState: function() { + return Wh(Vh); + }, + useDebugValue: ri, + useDeferredValue: function(a) { + var b2 = Uh(); + return ui(b2, N.memoizedState, a); + }, + useTransition: function() { + var a = Wh(Vh)[0], b2 = Uh().memoizedState; + return [a, b2]; + }, + useMutableSource: Yh, + useSyncExternalStore: Zh, + useId: wi, + unstable_isNewReconciler: false +}, Qh = { readContext: eh, useCallback: si, useContext: eh, useEffect: $h, useImperativeHandle: qi, useInsertionEffect: ni, useLayoutEffect: oi, useMemo: ti, useReducer: Xh, useRef: ji, useState: function() { + return Xh(Vh); +}, useDebugValue: ri, useDeferredValue: function(a) { + var b2 = Uh(); + return null === N ? b2.memoizedState = a : ui(b2, N.memoizedState, a); +}, useTransition: function() { + var a = Xh(Vh)[0], b2 = Uh().memoizedState; + return [a, b2]; +}, useMutableSource: Yh, useSyncExternalStore: Zh, useId: wi, unstable_isNewReconciler: false }; +function Ci(a, b2) { + if (a && a.defaultProps) { + b2 = A({}, b2); + a = a.defaultProps; + for (var c2 in a) + void 0 === b2[c2] && (b2[c2] = a[c2]); + return b2; + } + return b2; +} +function Di(a, b2, c2, d2) { + b2 = a.memoizedState; + c2 = c2(d2, b2); + c2 = null === c2 || void 0 === c2 ? b2 : A({}, b2, c2); + a.memoizedState = c2; + 0 === a.lanes && (a.updateQueue.baseState = c2); +} +var Ei = { isMounted: function(a) { + return (a = a._reactInternals) ? Vb(a) === a : false; +}, enqueueSetState: function(a, b2, c2) { + a = a._reactInternals; + var d2 = R(), e2 = yi(a), f2 = mh(d2, e2); + f2.payload = b2; + void 0 !== c2 && null !== c2 && (f2.callback = c2); + b2 = nh(a, f2, e2); + null !== b2 && (gi(b2, a, e2, d2), oh(b2, a, e2)); +}, enqueueReplaceState: function(a, b2, c2) { + a = a._reactInternals; + var d2 = R(), e2 = yi(a), f2 = mh(d2, e2); + f2.tag = 1; + f2.payload = b2; + void 0 !== c2 && null !== c2 && (f2.callback = c2); + b2 = nh(a, f2, e2); + null !== b2 && (gi(b2, a, e2, d2), oh(b2, a, e2)); +}, enqueueForceUpdate: function(a, b2) { + a = a._reactInternals; + var c2 = R(), d2 = yi(a), e2 = mh(c2, d2); + e2.tag = 2; + void 0 !== b2 && null !== b2 && (e2.callback = b2); + b2 = nh(a, e2, d2); + null !== b2 && (gi(b2, a, d2, c2), oh(b2, a, d2)); +} }; +function Fi(a, b2, c2, d2, e2, f2, g2) { + a = a.stateNode; + return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d2, f2, g2) : b2.prototype && b2.prototype.isPureReactComponent ? !Ie(c2, d2) || !Ie(e2, f2) : true; +} +function Gi(a, b2, c2) { + var d2 = false, e2 = Vf; + var f2 = b2.contextType; + "object" === typeof f2 && null !== f2 ? f2 = eh(f2) : (e2 = Zf(b2) ? Xf : H.current, d2 = b2.contextTypes, f2 = (d2 = null !== d2 && void 0 !== d2) ? Yf(a, e2) : Vf); + b2 = new b2(c2, f2); + a.memoizedState = null !== b2.state && void 0 !== b2.state ? b2.state : null; + b2.updater = Ei; + a.stateNode = b2; + b2._reactInternals = a; + d2 && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e2, a.__reactInternalMemoizedMaskedChildContext = f2); + return b2; +} +function Hi(a, b2, c2, d2) { + a = b2.state; + "function" === typeof b2.componentWillReceiveProps && b2.componentWillReceiveProps(c2, d2); + "function" === typeof b2.UNSAFE_componentWillReceiveProps && b2.UNSAFE_componentWillReceiveProps(c2, d2); + b2.state !== a && Ei.enqueueReplaceState(b2, b2.state, null); +} +function Ii(a, b2, c2, d2) { + var e2 = a.stateNode; + e2.props = c2; + e2.state = a.memoizedState; + e2.refs = {}; + kh(a); + var f2 = b2.contextType; + "object" === typeof f2 && null !== f2 ? e2.context = eh(f2) : (f2 = Zf(b2) ? Xf : H.current, e2.context = Yf(a, f2)); + e2.state = a.memoizedState; + f2 = b2.getDerivedStateFromProps; + "function" === typeof f2 && (Di(a, b2, f2, c2), e2.state = a.memoizedState); + "function" === typeof b2.getDerivedStateFromProps || "function" === typeof e2.getSnapshotBeforeUpdate || "function" !== typeof e2.UNSAFE_componentWillMount && "function" !== typeof e2.componentWillMount || (b2 = e2.state, "function" === typeof e2.componentWillMount && e2.componentWillMount(), "function" === typeof e2.UNSAFE_componentWillMount && e2.UNSAFE_componentWillMount(), b2 !== e2.state && Ei.enqueueReplaceState(e2, e2.state, null), qh(a, c2, e2, d2), e2.state = a.memoizedState); + "function" === typeof e2.componentDidMount && (a.flags |= 4194308); +} +function Ji(a, b2) { + try { + var c2 = "", d2 = b2; + do + c2 += Pa(d2), d2 = d2.return; + while (d2); + var e2 = c2; + } catch (f2) { + e2 = "\nError generating stack: " + f2.message + "\n" + f2.stack; + } + return { value: a, source: b2, stack: e2, digest: null }; +} +function Ki(a, b2, c2) { + return { value: a, source: null, stack: null != c2 ? c2 : null, digest: null != b2 ? b2 : null }; +} +function Li(a, b2) { + try { + console.error(b2.value); + } catch (c2) { + setTimeout(function() { + throw c2; + }); + } +} +var Mi = "function" === typeof WeakMap ? WeakMap : Map; +function Ni(a, b2, c2) { + c2 = mh(-1, c2); + c2.tag = 3; + c2.payload = { element: null }; + var d2 = b2.value; + c2.callback = function() { + Oi || (Oi = true, Pi = d2); + Li(a, b2); + }; + return c2; +} +function Qi(a, b2, c2) { + c2 = mh(-1, c2); + c2.tag = 3; + var d2 = a.type.getDerivedStateFromError; + if ("function" === typeof d2) { + var e2 = b2.value; + c2.payload = function() { + return d2(e2); + }; + c2.callback = function() { + Li(a, b2); + }; + } + var f2 = a.stateNode; + null !== f2 && "function" === typeof f2.componentDidCatch && (c2.callback = function() { + Li(a, b2); + "function" !== typeof d2 && (null === Ri ? Ri = /* @__PURE__ */ new Set([this]) : Ri.add(this)); + var c3 = b2.stack; + this.componentDidCatch(b2.value, { componentStack: null !== c3 ? c3 : "" }); + }); + return c2; +} +function Si(a, b2, c2) { + var d2 = a.pingCache; + if (null === d2) { + d2 = a.pingCache = new Mi(); + var e2 = /* @__PURE__ */ new Set(); + d2.set(b2, e2); + } else + e2 = d2.get(b2), void 0 === e2 && (e2 = /* @__PURE__ */ new Set(), d2.set(b2, e2)); + e2.has(c2) || (e2.add(c2), a = Ti.bind(null, a, b2, c2), b2.then(a, a)); +} +function Ui(a) { + do { + var b2; + if (b2 = 13 === a.tag) + b2 = a.memoizedState, b2 = null !== b2 ? null !== b2.dehydrated ? true : false : true; + if (b2) + return a; + a = a.return; + } while (null !== a); + return null; +} +function Vi(a, b2, c2, d2, e2) { + if (0 === (a.mode & 1)) + return a === b2 ? a.flags |= 65536 : (a.flags |= 128, c2.flags |= 131072, c2.flags &= -52805, 1 === c2.tag && (null === c2.alternate ? c2.tag = 17 : (b2 = mh(-1, 1), b2.tag = 2, nh(c2, b2, 1))), c2.lanes |= 1), a; + a.flags |= 65536; + a.lanes = e2; + return a; +} +var Wi = ua.ReactCurrentOwner, dh = false; +function Xi(a, b2, c2, d2) { + b2.child = null === a ? Vg(b2, null, c2, d2) : Ug(b2, a.child, c2, d2); +} +function Yi(a, b2, c2, d2, e2) { + c2 = c2.render; + var f2 = b2.ref; + ch(b2, e2); + d2 = Nh(a, b2, c2, d2, f2, e2); + c2 = Sh(); + if (null !== a && !dh) + return b2.updateQueue = a.updateQueue, b2.flags &= -2053, a.lanes &= ~e2, Zi(a, b2, e2); + I && c2 && vg(b2); + b2.flags |= 1; + Xi(a, b2, d2, e2); + return b2.child; +} +function $i(a, b2, c2, d2, e2) { + if (null === a) { + var f2 = c2.type; + if ("function" === typeof f2 && !aj(f2) && void 0 === f2.defaultProps && null === c2.compare && void 0 === c2.defaultProps) + return b2.tag = 15, b2.type = f2, bj(a, b2, f2, d2, e2); + a = Rg(c2.type, null, d2, b2, b2.mode, e2); + a.ref = b2.ref; + a.return = b2; + return b2.child = a; + } + f2 = a.child; + if (0 === (a.lanes & e2)) { + var g2 = f2.memoizedProps; + c2 = c2.compare; + c2 = null !== c2 ? c2 : Ie; + if (c2(g2, d2) && a.ref === b2.ref) + return Zi(a, b2, e2); + } + b2.flags |= 1; + a = Pg(f2, d2); + a.ref = b2.ref; + a.return = b2; + return b2.child = a; +} +function bj(a, b2, c2, d2, e2) { + if (null !== a) { + var f2 = a.memoizedProps; + if (Ie(f2, d2) && a.ref === b2.ref) + if (dh = false, b2.pendingProps = d2 = f2, 0 !== (a.lanes & e2)) + 0 !== (a.flags & 131072) && (dh = true); + else + return b2.lanes = a.lanes, Zi(a, b2, e2); + } + return cj(a, b2, c2, d2, e2); +} +function dj(a, b2, c2) { + var d2 = b2.pendingProps, e2 = d2.children, f2 = null !== a ? a.memoizedState : null; + if ("hidden" === d2.mode) + if (0 === (b2.mode & 1)) + b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G(ej, fj), fj |= c2; + else { + if (0 === (c2 & 1073741824)) + return a = null !== f2 ? f2.baseLanes | c2 : c2, b2.lanes = b2.childLanes = 1073741824, b2.memoizedState = { baseLanes: a, cachePool: null, transitions: null }, b2.updateQueue = null, G(ej, fj), fj |= a, null; + b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }; + d2 = null !== f2 ? f2.baseLanes : c2; + G(ej, fj); + fj |= d2; + } + else + null !== f2 ? (d2 = f2.baseLanes | c2, b2.memoizedState = null) : d2 = c2, G(ej, fj), fj |= d2; + Xi(a, b2, e2, c2); + return b2.child; +} +function gj(a, b2) { + var c2 = b2.ref; + if (null === a && null !== c2 || null !== a && a.ref !== c2) + b2.flags |= 512, b2.flags |= 2097152; +} +function cj(a, b2, c2, d2, e2) { + var f2 = Zf(c2) ? Xf : H.current; + f2 = Yf(b2, f2); + ch(b2, e2); + c2 = Nh(a, b2, c2, d2, f2, e2); + d2 = Sh(); + if (null !== a && !dh) + return b2.updateQueue = a.updateQueue, b2.flags &= -2053, a.lanes &= ~e2, Zi(a, b2, e2); + I && d2 && vg(b2); + b2.flags |= 1; + Xi(a, b2, c2, e2); + return b2.child; +} +function hj(a, b2, c2, d2, e2) { + if (Zf(c2)) { + var f2 = true; + cg(b2); + } else + f2 = false; + ch(b2, e2); + if (null === b2.stateNode) + ij(a, b2), Gi(b2, c2, d2), Ii(b2, c2, d2, e2), d2 = true; + else if (null === a) { + var g2 = b2.stateNode, h2 = b2.memoizedProps; + g2.props = h2; + var k2 = g2.context, l2 = c2.contextType; + "object" === typeof l2 && null !== l2 ? l2 = eh(l2) : (l2 = Zf(c2) ? Xf : H.current, l2 = Yf(b2, l2)); + var m2 = c2.getDerivedStateFromProps, q2 = "function" === typeof m2 || "function" === typeof g2.getSnapshotBeforeUpdate; + q2 || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== d2 || k2 !== l2) && Hi(b2, g2, d2, l2); + jh = false; + var r2 = b2.memoizedState; + g2.state = r2; + qh(b2, d2, g2, e2); + k2 = b2.memoizedState; + h2 !== d2 || r2 !== k2 || Wf.current || jh ? ("function" === typeof m2 && (Di(b2, c2, m2, d2), k2 = b2.memoizedState), (h2 = jh || Fi(b2, c2, h2, d2, r2, k2, l2)) ? (q2 || "function" !== typeof g2.UNSAFE_componentWillMount && "function" !== typeof g2.componentWillMount || ("function" === typeof g2.componentWillMount && g2.componentWillMount(), "function" === typeof g2.UNSAFE_componentWillMount && g2.UNSAFE_componentWillMount()), "function" === typeof g2.componentDidMount && (b2.flags |= 4194308)) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4194308), b2.memoizedProps = d2, b2.memoizedState = k2), g2.props = d2, g2.state = k2, g2.context = l2, d2 = h2) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4194308), d2 = false); + } else { + g2 = b2.stateNode; + lh(a, b2); + h2 = b2.memoizedProps; + l2 = b2.type === b2.elementType ? h2 : Ci(b2.type, h2); + g2.props = l2; + q2 = b2.pendingProps; + r2 = g2.context; + k2 = c2.contextType; + "object" === typeof k2 && null !== k2 ? k2 = eh(k2) : (k2 = Zf(c2) ? Xf : H.current, k2 = Yf(b2, k2)); + var y2 = c2.getDerivedStateFromProps; + (m2 = "function" === typeof y2 || "function" === typeof g2.getSnapshotBeforeUpdate) || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== q2 || r2 !== k2) && Hi(b2, g2, d2, k2); + jh = false; + r2 = b2.memoizedState; + g2.state = r2; + qh(b2, d2, g2, e2); + var n2 = b2.memoizedState; + h2 !== q2 || r2 !== n2 || Wf.current || jh ? ("function" === typeof y2 && (Di(b2, c2, y2, d2), n2 = b2.memoizedState), (l2 = jh || Fi(b2, c2, l2, d2, r2, n2, k2) || false) ? (m2 || "function" !== typeof g2.UNSAFE_componentWillUpdate && "function" !== typeof g2.componentWillUpdate || ("function" === typeof g2.componentWillUpdate && g2.componentWillUpdate(d2, n2, k2), "function" === typeof g2.UNSAFE_componentWillUpdate && g2.UNSAFE_componentWillUpdate(d2, n2, k2)), "function" === typeof g2.componentDidUpdate && (b2.flags |= 4), "function" === typeof g2.getSnapshotBeforeUpdate && (b2.flags |= 1024)) : ("function" !== typeof g2.componentDidUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 1024), b2.memoizedProps = d2, b2.memoizedState = n2), g2.props = d2, g2.state = n2, g2.context = k2, d2 = l2) : ("function" !== typeof g2.componentDidUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 1024), d2 = false); + } + return jj(a, b2, c2, d2, f2, e2); +} +function jj(a, b2, c2, d2, e2, f2) { + gj(a, b2); + var g2 = 0 !== (b2.flags & 128); + if (!d2 && !g2) + return e2 && dg(b2, c2, false), Zi(a, b2, f2); + d2 = b2.stateNode; + Wi.current = b2; + var h2 = g2 && "function" !== typeof c2.getDerivedStateFromError ? null : d2.render(); + b2.flags |= 1; + null !== a && g2 ? (b2.child = Ug(b2, a.child, null, f2), b2.child = Ug(b2, null, h2, f2)) : Xi(a, b2, h2, f2); + b2.memoizedState = d2.state; + e2 && dg(b2, c2, true); + return b2.child; +} +function kj(a) { + var b2 = a.stateNode; + b2.pendingContext ? ag(a, b2.pendingContext, b2.pendingContext !== b2.context) : b2.context && ag(a, b2.context, false); + yh(a, b2.containerInfo); +} +function lj(a, b2, c2, d2, e2) { + Ig(); + Jg(e2); + b2.flags |= 256; + Xi(a, b2, c2, d2); + return b2.child; +} +var mj = { dehydrated: null, treeContext: null, retryLane: 0 }; +function nj(a) { + return { baseLanes: a, cachePool: null, transitions: null }; +} +function oj(a, b2, c2) { + var d2 = b2.pendingProps, e2 = L.current, f2 = false, g2 = 0 !== (b2.flags & 128), h2; + (h2 = g2) || (h2 = null !== a && null === a.memoizedState ? false : 0 !== (e2 & 2)); + if (h2) + f2 = true, b2.flags &= -129; + else if (null === a || null !== a.memoizedState) + e2 |= 1; + G(L, e2 & 1); + if (null === a) { + Eg(b2); + a = b2.memoizedState; + if (null !== a && (a = a.dehydrated, null !== a)) + return 0 === (b2.mode & 1) ? b2.lanes = 1 : "$!" === a.data ? b2.lanes = 8 : b2.lanes = 1073741824, null; + g2 = d2.children; + a = d2.fallback; + return f2 ? (d2 = b2.mode, f2 = b2.child, g2 = { mode: "hidden", children: g2 }, 0 === (d2 & 1) && null !== f2 ? (f2.childLanes = 0, f2.pendingProps = g2) : f2 = pj(g2, d2, 0, null), a = Tg(a, d2, c2, null), f2.return = b2, a.return = b2, f2.sibling = a, b2.child = f2, b2.child.memoizedState = nj(c2), b2.memoizedState = mj, a) : qj(b2, g2); + } + e2 = a.memoizedState; + if (null !== e2 && (h2 = e2.dehydrated, null !== h2)) + return rj(a, b2, g2, d2, h2, e2, c2); + if (f2) { + f2 = d2.fallback; + g2 = b2.mode; + e2 = a.child; + h2 = e2.sibling; + var k2 = { mode: "hidden", children: d2.children }; + 0 === (g2 & 1) && b2.child !== e2 ? (d2 = b2.child, d2.childLanes = 0, d2.pendingProps = k2, b2.deletions = null) : (d2 = Pg(e2, k2), d2.subtreeFlags = e2.subtreeFlags & 14680064); + null !== h2 ? f2 = Pg(h2, f2) : (f2 = Tg(f2, g2, c2, null), f2.flags |= 2); + f2.return = b2; + d2.return = b2; + d2.sibling = f2; + b2.child = d2; + d2 = f2; + f2 = b2.child; + g2 = a.child.memoizedState; + g2 = null === g2 ? nj(c2) : { baseLanes: g2.baseLanes | c2, cachePool: null, transitions: g2.transitions }; + f2.memoizedState = g2; + f2.childLanes = a.childLanes & ~c2; + b2.memoizedState = mj; + return d2; + } + f2 = a.child; + a = f2.sibling; + d2 = Pg(f2, { mode: "visible", children: d2.children }); + 0 === (b2.mode & 1) && (d2.lanes = c2); + d2.return = b2; + d2.sibling = null; + null !== a && (c2 = b2.deletions, null === c2 ? (b2.deletions = [a], b2.flags |= 16) : c2.push(a)); + b2.child = d2; + b2.memoizedState = null; + return d2; +} +function qj(a, b2) { + b2 = pj({ mode: "visible", children: b2 }, a.mode, 0, null); + b2.return = a; + return a.child = b2; +} +function sj(a, b2, c2, d2) { + null !== d2 && Jg(d2); + Ug(b2, a.child, null, c2); + a = qj(b2, b2.pendingProps.children); + a.flags |= 2; + b2.memoizedState = null; + return a; +} +function rj(a, b2, c2, d2, e2, f2, g2) { + if (c2) { + if (b2.flags & 256) + return b2.flags &= -257, d2 = Ki(Error(p$2(422))), sj(a, b2, g2, d2); + if (null !== b2.memoizedState) + return b2.child = a.child, b2.flags |= 128, null; + f2 = d2.fallback; + e2 = b2.mode; + d2 = pj({ mode: "visible", children: d2.children }, e2, 0, null); + f2 = Tg(f2, e2, g2, null); + f2.flags |= 2; + d2.return = b2; + f2.return = b2; + d2.sibling = f2; + b2.child = d2; + 0 !== (b2.mode & 1) && Ug(b2, a.child, null, g2); + b2.child.memoizedState = nj(g2); + b2.memoizedState = mj; + return f2; + } + if (0 === (b2.mode & 1)) + return sj(a, b2, g2, null); + if ("$!" === e2.data) { + d2 = e2.nextSibling && e2.nextSibling.dataset; + if (d2) + var h2 = d2.dgst; + d2 = h2; + f2 = Error(p$2(419)); + d2 = Ki(f2, d2, void 0); + return sj(a, b2, g2, d2); + } + h2 = 0 !== (g2 & a.childLanes); + if (dh || h2) { + d2 = Q; + if (null !== d2) { + switch (g2 & -g2) { + case 4: + e2 = 2; + break; + case 16: + e2 = 8; + break; + case 64: + case 128: + case 256: + case 512: + case 1024: + case 2048: + case 4096: + case 8192: + case 16384: + case 32768: + case 65536: + case 131072: + case 262144: + case 524288: + case 1048576: + case 2097152: + case 4194304: + case 8388608: + case 16777216: + case 33554432: + case 67108864: + e2 = 32; + break; + case 536870912: + e2 = 268435456; + break; + default: + e2 = 0; + } + e2 = 0 !== (e2 & (d2.suspendedLanes | g2)) ? 0 : e2; + 0 !== e2 && e2 !== f2.retryLane && (f2.retryLane = e2, ih(a, e2), gi(d2, a, e2, -1)); + } + tj(); + d2 = Ki(Error(p$2(421))); + return sj(a, b2, g2, d2); + } + if ("$?" === e2.data) + return b2.flags |= 128, b2.child = a.child, b2 = uj.bind(null, a), e2._reactRetry = b2, null; + a = f2.treeContext; + yg = Lf(e2.nextSibling); + xg = b2; + I = true; + zg = null; + null !== a && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a.id, sg = a.overflow, qg = b2); + b2 = qj(b2, d2.children); + b2.flags |= 4096; + return b2; +} +function vj(a, b2, c2) { + a.lanes |= b2; + var d2 = a.alternate; + null !== d2 && (d2.lanes |= b2); + bh(a.return, b2, c2); +} +function wj(a, b2, c2, d2, e2) { + var f2 = a.memoizedState; + null === f2 ? a.memoizedState = { isBackwards: b2, rendering: null, renderingStartTime: 0, last: d2, tail: c2, tailMode: e2 } : (f2.isBackwards = b2, f2.rendering = null, f2.renderingStartTime = 0, f2.last = d2, f2.tail = c2, f2.tailMode = e2); +} +function xj(a, b2, c2) { + var d2 = b2.pendingProps, e2 = d2.revealOrder, f2 = d2.tail; + Xi(a, b2, d2.children, c2); + d2 = L.current; + if (0 !== (d2 & 2)) + d2 = d2 & 1 | 2, b2.flags |= 128; + else { + if (null !== a && 0 !== (a.flags & 128)) + a: + for (a = b2.child; null !== a; ) { + if (13 === a.tag) + null !== a.memoizedState && vj(a, c2, b2); + else if (19 === a.tag) + vj(a, c2, b2); + else if (null !== a.child) { + a.child.return = a; + a = a.child; + continue; + } + if (a === b2) + break a; + for (; null === a.sibling; ) { + if (null === a.return || a.return === b2) + break a; + a = a.return; + } + a.sibling.return = a.return; + a = a.sibling; + } + d2 &= 1; + } + G(L, d2); + if (0 === (b2.mode & 1)) + b2.memoizedState = null; + else + switch (e2) { + case "forwards": + c2 = b2.child; + for (e2 = null; null !== c2; ) + a = c2.alternate, null !== a && null === Ch(a) && (e2 = c2), c2 = c2.sibling; + c2 = e2; + null === c2 ? (e2 = b2.child, b2.child = null) : (e2 = c2.sibling, c2.sibling = null); + wj(b2, false, e2, c2, f2); + break; + case "backwards": + c2 = null; + e2 = b2.child; + for (b2.child = null; null !== e2; ) { + a = e2.alternate; + if (null !== a && null === Ch(a)) { + b2.child = e2; + break; + } + a = e2.sibling; + e2.sibling = c2; + c2 = e2; + e2 = a; + } + wj(b2, true, c2, null, f2); + break; + case "together": + wj(b2, false, null, null, void 0); + break; + default: + b2.memoizedState = null; + } + return b2.child; +} +function ij(a, b2) { + 0 === (b2.mode & 1) && null !== a && (a.alternate = null, b2.alternate = null, b2.flags |= 2); +} +function Zi(a, b2, c2) { + null !== a && (b2.dependencies = a.dependencies); + rh |= b2.lanes; + if (0 === (c2 & b2.childLanes)) + return null; + if (null !== a && b2.child !== a.child) + throw Error(p$2(153)); + if (null !== b2.child) { + a = b2.child; + c2 = Pg(a, a.pendingProps); + b2.child = c2; + for (c2.return = b2; null !== a.sibling; ) + a = a.sibling, c2 = c2.sibling = Pg(a, a.pendingProps), c2.return = b2; + c2.sibling = null; + } + return b2.child; +} +function yj(a, b2, c2) { + switch (b2.tag) { + case 3: + kj(b2); + Ig(); + break; + case 5: + Ah(b2); + break; + case 1: + Zf(b2.type) && cg(b2); + break; + case 4: + yh(b2, b2.stateNode.containerInfo); + break; + case 10: + var d2 = b2.type._context, e2 = b2.memoizedProps.value; + G(Wg, d2._currentValue); + d2._currentValue = e2; + break; + case 13: + d2 = b2.memoizedState; + if (null !== d2) { + if (null !== d2.dehydrated) + return G(L, L.current & 1), b2.flags |= 128, null; + if (0 !== (c2 & b2.child.childLanes)) + return oj(a, b2, c2); + G(L, L.current & 1); + a = Zi(a, b2, c2); + return null !== a ? a.sibling : null; + } + G(L, L.current & 1); + break; + case 19: + d2 = 0 !== (c2 & b2.childLanes); + if (0 !== (a.flags & 128)) { + if (d2) + return xj(a, b2, c2); + b2.flags |= 128; + } + e2 = b2.memoizedState; + null !== e2 && (e2.rendering = null, e2.tail = null, e2.lastEffect = null); + G(L, L.current); + if (d2) + break; + else + return null; + case 22: + case 23: + return b2.lanes = 0, dj(a, b2, c2); + } + return Zi(a, b2, c2); +} +var zj, Aj, Bj, Cj; +zj = function(a, b2) { + for (var c2 = b2.child; null !== c2; ) { + if (5 === c2.tag || 6 === c2.tag) + a.appendChild(c2.stateNode); + else if (4 !== c2.tag && null !== c2.child) { + c2.child.return = c2; + c2 = c2.child; + continue; + } + if (c2 === b2) + break; + for (; null === c2.sibling; ) { + if (null === c2.return || c2.return === b2) + return; + c2 = c2.return; + } + c2.sibling.return = c2.return; + c2 = c2.sibling; + } +}; +Aj = function() { +}; +Bj = function(a, b2, c2, d2) { + var e2 = a.memoizedProps; + if (e2 !== d2) { + a = b2.stateNode; + xh(uh.current); + var f2 = null; + switch (c2) { + case "input": + e2 = Ya(a, e2); + d2 = Ya(a, d2); + f2 = []; + break; + case "select": + e2 = A({}, e2, { value: void 0 }); + d2 = A({}, d2, { value: void 0 }); + f2 = []; + break; + case "textarea": + e2 = gb(a, e2); + d2 = gb(a, d2); + f2 = []; + break; + default: + "function" !== typeof e2.onClick && "function" === typeof d2.onClick && (a.onclick = Bf); + } + ub(c2, d2); + var g2; + c2 = null; + for (l2 in e2) + if (!d2.hasOwnProperty(l2) && e2.hasOwnProperty(l2) && null != e2[l2]) + if ("style" === l2) { + var h2 = e2[l2]; + for (g2 in h2) + h2.hasOwnProperty(g2) && (c2 || (c2 = {}), c2[g2] = ""); + } else + "dangerouslySetInnerHTML" !== l2 && "children" !== l2 && "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && "autoFocus" !== l2 && (ea.hasOwnProperty(l2) ? f2 || (f2 = []) : (f2 = f2 || []).push(l2, null)); + for (l2 in d2) { + var k2 = d2[l2]; + h2 = null != e2 ? e2[l2] : void 0; + if (d2.hasOwnProperty(l2) && k2 !== h2 && (null != k2 || null != h2)) + if ("style" === l2) + if (h2) { + for (g2 in h2) + !h2.hasOwnProperty(g2) || k2 && k2.hasOwnProperty(g2) || (c2 || (c2 = {}), c2[g2] = ""); + for (g2 in k2) + k2.hasOwnProperty(g2) && h2[g2] !== k2[g2] && (c2 || (c2 = {}), c2[g2] = k2[g2]); + } else + c2 || (f2 || (f2 = []), f2.push( + l2, + c2 + )), c2 = k2; + else + "dangerouslySetInnerHTML" === l2 ? (k2 = k2 ? k2.__html : void 0, h2 = h2 ? h2.__html : void 0, null != k2 && h2 !== k2 && (f2 = f2 || []).push(l2, k2)) : "children" === l2 ? "string" !== typeof k2 && "number" !== typeof k2 || (f2 = f2 || []).push(l2, "" + k2) : "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && (ea.hasOwnProperty(l2) ? (null != k2 && "onScroll" === l2 && D("scroll", a), f2 || h2 === k2 || (f2 = [])) : (f2 = f2 || []).push(l2, k2)); + } + c2 && (f2 = f2 || []).push("style", c2); + var l2 = f2; + if (b2.updateQueue = l2) + b2.flags |= 4; + } +}; +Cj = function(a, b2, c2, d2) { + c2 !== d2 && (b2.flags |= 4); +}; +function Dj(a, b2) { + if (!I) + switch (a.tailMode) { + case "hidden": + b2 = a.tail; + for (var c2 = null; null !== b2; ) + null !== b2.alternate && (c2 = b2), b2 = b2.sibling; + null === c2 ? a.tail = null : c2.sibling = null; + break; + case "collapsed": + c2 = a.tail; + for (var d2 = null; null !== c2; ) + null !== c2.alternate && (d2 = c2), c2 = c2.sibling; + null === d2 ? b2 || null === a.tail ? a.tail = null : a.tail.sibling = null : d2.sibling = null; + } +} +function S(a) { + var b2 = null !== a.alternate && a.alternate.child === a.child, c2 = 0, d2 = 0; + if (b2) + for (var e2 = a.child; null !== e2; ) + c2 |= e2.lanes | e2.childLanes, d2 |= e2.subtreeFlags & 14680064, d2 |= e2.flags & 14680064, e2.return = a, e2 = e2.sibling; + else + for (e2 = a.child; null !== e2; ) + c2 |= e2.lanes | e2.childLanes, d2 |= e2.subtreeFlags, d2 |= e2.flags, e2.return = a, e2 = e2.sibling; + a.subtreeFlags |= d2; + a.childLanes = c2; + return b2; +} +function Ej(a, b2, c2) { + var d2 = b2.pendingProps; + wg(b2); + switch (b2.tag) { + case 2: + case 16: + case 15: + case 0: + case 11: + case 7: + case 8: + case 12: + case 9: + case 14: + return S(b2), null; + case 1: + return Zf(b2.type) && $f(), S(b2), null; + case 3: + d2 = b2.stateNode; + zh(); + E(Wf); + E(H); + Eh(); + d2.pendingContext && (d2.context = d2.pendingContext, d2.pendingContext = null); + if (null === a || null === a.child) + Gg(b2) ? b2.flags |= 4 : null === a || a.memoizedState.isDehydrated && 0 === (b2.flags & 256) || (b2.flags |= 1024, null !== zg && (Fj(zg), zg = null)); + Aj(a, b2); + S(b2); + return null; + case 5: + Bh(b2); + var e2 = xh(wh.current); + c2 = b2.type; + if (null !== a && null != b2.stateNode) + Bj(a, b2, c2, d2, e2), a.ref !== b2.ref && (b2.flags |= 512, b2.flags |= 2097152); + else { + if (!d2) { + if (null === b2.stateNode) + throw Error(p$2(166)); + S(b2); + return null; + } + a = xh(uh.current); + if (Gg(b2)) { + d2 = b2.stateNode; + c2 = b2.type; + var f2 = b2.memoizedProps; + d2[Of] = b2; + d2[Pf] = f2; + a = 0 !== (b2.mode & 1); + switch (c2) { + case "dialog": + D("cancel", d2); + D("close", d2); + break; + case "iframe": + case "object": + case "embed": + D("load", d2); + break; + case "video": + case "audio": + for (e2 = 0; e2 < lf.length; e2++) + D(lf[e2], d2); + break; + case "source": + D("error", d2); + break; + case "img": + case "image": + case "link": + D( + "error", + d2 + ); + D("load", d2); + break; + case "details": + D("toggle", d2); + break; + case "input": + Za(d2, f2); + D("invalid", d2); + break; + case "select": + d2._wrapperState = { wasMultiple: !!f2.multiple }; + D("invalid", d2); + break; + case "textarea": + hb(d2, f2), D("invalid", d2); + } + ub(c2, f2); + e2 = null; + for (var g2 in f2) + if (f2.hasOwnProperty(g2)) { + var h2 = f2[g2]; + "children" === g2 ? "string" === typeof h2 ? d2.textContent !== h2 && (true !== f2.suppressHydrationWarning && Af(d2.textContent, h2, a), e2 = ["children", h2]) : "number" === typeof h2 && d2.textContent !== "" + h2 && (true !== f2.suppressHydrationWarning && Af( + d2.textContent, + h2, + a + ), e2 = ["children", "" + h2]) : ea.hasOwnProperty(g2) && null != h2 && "onScroll" === g2 && D("scroll", d2); + } + switch (c2) { + case "input": + Va(d2); + db(d2, f2, true); + break; + case "textarea": + Va(d2); + jb(d2); + break; + case "select": + case "option": + break; + default: + "function" === typeof f2.onClick && (d2.onclick = Bf); + } + d2 = e2; + b2.updateQueue = d2; + null !== d2 && (b2.flags |= 4); + } else { + g2 = 9 === e2.nodeType ? e2 : e2.ownerDocument; + "http://www.w3.org/1999/xhtml" === a && (a = kb(c2)); + "http://www.w3.org/1999/xhtml" === a ? "script" === c2 ? (a = g2.createElement("div"), a.innerHTML = " + + + diff --git a/playground.bundle.js b/playground.bundle.js new file mode 100644 index 0000000..427ddc4 --- /dev/null +++ b/playground.bundle.js @@ -0,0 +1,1376 @@ +/*! For license information please see playground.bundle.js.LICENSE.txt */ +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.mountPlayground=t():e.mountPlayground=t()}(self,(()=>(()=>{var e,t,n={876:(e,t)=>{"use strict";t.__esModule=!0,t.default=function(e){return function t(n){return{value:e[n],next:function(e){return t(e)}.bind(null,n+1)}}(0)}},371:function(e,t,n){(function(){var t,r,o,a;o=n(945),t=n(500),n(676),r=function(e){return e.candidate},a=function(e,t){return t.score-e.score},e.exports=function(e,n,i){var l,u,c,s,f,d,p,h,m,g,v,y,b;for(h=[],c=i.key,f=i.maxResults,s=i.maxInners,v=i.usePathScoring,m=null!=s&&s>0?s:e.length+1,l=null!=c,p=v?t:o,y=0,b=e.length;y0)||(h.push({candidate:u,score:d}),--m));y++);return h.sort(a),e=h.map(r),null!=f&&(e=e.slice(0,f)),e}}).call(this)},111:function(e,t,n){(function(){var t,r,o,a,i,l,u,c;o=n(371),a=n(123),c=n(945),l=n(500),t=n(676),u=null,r="win32"===("undefined"!=typeof process&&null!==process?process.platform:void 0)?"\\":"/",e.exports={filter:function(e,t,n){return null==n&&(n={}),(null!=t?t.length:void 0)&&(null!=e?e.length:void 0)?(n=i(n,t),o(e,t,n)):[]},score:function(e,t,n){return null==n&&(n={}),(null!=e?e.length:void 0)&&(null!=t?t.length:void 0)?(n=i(n,t)).usePathScoring?l.score(e,t,n):c.score(e,t,n):0},match:function(e,t,n){var r;return null==n&&(n={}),e&&t?e===t?function(){r=[];for(var t=0,n=e.length;0<=n?tn;0<=n?t++:t--)r.push(t);return r}.apply(this):(n=i(n,t),a.match(e,t,n)):[]},wrap:function(e,t,n){return null==n&&(n={}),e&&t?(n=i(n,t),a.wrap(e,t,n)):[]},prepareQuery:function(e,t){return null==t&&(t={}),(t=i(t,e)).preparedQuery}},i=function(e,n){return null==e.allowErrors&&(e.allowErrors=!1),null==e.usePathScoring&&(e.usePathScoring=!0),null==e.useExtensionBonus&&(e.useExtensionBonus=!1),null==e.pathSeparator&&(e.pathSeparator=r),null==e.optCharRegEx&&(e.optCharRegEx=null),null==e.wrap&&(e.wrap=null),null==e.preparedQuery&&(e.preparedQuery=u&&u.query===n?u:u=new t(n,e)),e}}).call(this)},123:function(e,t,n){(function(){var e,r,o,a,i,l,u,c,s,f;f=n(945),o=f.isMatch,a=f.isWordStart,s=f.scoreConsecutives,c=f.scoreCharacter,u=f.scoreAcronyms,t.match=i=function(t,n,a){var i,u,c,s,f,d;return i=a.allowErrors,f=a.preparedQuery,s=a.pathSeparator,i||o(t,f.core_lw,f.core_up)?(d=t.toLowerCase(),0===(c=r(t,d,f)).length||t.indexOf(s)>-1&&(u=e(t,d,f,s),c=l(c,u)),c):[]},t.wrap=function(e,t,n){var r,o,a,l,u,c,s,f,d;if(null!=n.wrap&&(c=(d=n.wrap).tagClass,f=d.tagOpen,s=d.tagClose),null==c&&(c="highlight"),null==f&&(f=''),null==s&&(s=""),e===t)return f+e+s;if(0===(a=i(e,0,n)).length)return e;for(l="",r=-1,u=0;++ru&&(l+=e.substring(u,o),u=o);++ru&&(l+=f,l+=e.substring(u,o),l+=s,u=o)}return u<=e.length-1&&(l+=e.substring(u)),l},e=function(e,t,n,o){var a,i,l;for(l=e.length-1;e[l]===o;)l--;if(-1===(a=e.lastIndexOf(o,l)))return[];for(i=n.depth;i-- >0;)if(-1===(a=e.lastIndexOf(o,a-1)))return[];return a++,l++,r(e.slice(a,l),t.slice(a,l),n,a)},l=function(e,t){var n,r,o,a,i,l,u;if(i=e.length,0===(l=t.length))return e.slice();if(0===i)return t.slice();for(o=-1,r=t[a=0],u=[];++o0?f:s(e,t,w,E,h,m,O),i=_+c(h,m,O,o,p)),C=k[m],f=d[m],S>C?y=2:(S=C,y=1),i>S?(S=i,y=3):p=0,k[m]=S,d[m]=p,I[++x]=S>0?y:0;for(x=(h=g-1)*b+(m=b-1),l=!0,v=[];l&&h>=0&&m>=0;)switch(I[x]){case 1:h--,x-=b;break;case 2:m--,x--;break;case 3:v.push(h+r),m--,h--,x-=b+1;break;default:l=!1}return v.reverse(),v}}).call(this)},500:function(e,t,n){(function(){var e,r,o,a,i,l,u;u=n(945),a=u.isMatch,e=u.computeScore,l=u.scoreSize,t.score=function(t,n,r){var o,l,u;return o=r.preparedQuery,r.allowErrors||a(t,o.core_lw,o.core_up)?(u=t.toLowerCase(),l=e(t,u,o),l=i(t,u,l,r),Math.ceil(l)):0},i=function(t,n,a,i){var u,c,s,f,d,p,h,m,g,v;if(0===a)return 0;for(g=i.preparedQuery,v=i.useExtensionBonus,m=i.pathSeparator,d=t.length-1;t[d]===m;)d--;if(h=d-(s=t.lastIndexOf(m,d)),p=1,v&&(a*=p+=o(n,g.ext,s,d,2)),-1===s)return a;for(f=g.depth;s>-1&&f-- >0;)s=t.lastIndexOf(m,s-1);return c=-1===s?a:p*e(t.slice(s+1,d+1),n.slice(s+1,d+1),g),(u=10/(20+r(t,d+1,m)))*c+(1-u)*a*l(0,2.5*h)},t.countDir=r=function(e,t,n){var r,o;if(t<1)return 0;for(r=0,o=-1;++on))return 0;for((i=r-c)<(u=t.length)&&(u=i,i=t.length),c++,l=-1;++l0?.9*o(e,t,n,c-2,a-1):l/i}}).call(this)},676:function(e,t,n){(function(){var t,r,o,a,i,l,u;u=n(500),r=u.countDir,a=u.getExtension,e.exports=function(e,n){var i,u,c;if(i=(c=null!=n?n:{}).optCharRegEx,u=c.pathSeparator,!e||!e.length)return null;this.query=e,this.query_lw=e.toLowerCase(),this.core=t(e,i),this.core_lw=this.core.toLowerCase(),this.core_up=l(this.core),this.depth=r(e,e.length,u),this.ext=a(this.query_lw),this.charCodes=o(this.query_lw)},i=/[ _\-:\/\\]/g,t=function(e,t){return null==t&&(t=i),e.replace(t,"")},l=function(e){var t,n,r;for(t="",n=0,r=e.length;na)return!1;for(r=-1,o=-1;++o-1)return p(e,t,_,k,S,E,b);for(I=new Array(E),l=new Array(E),z=g(E,b),w=x=Math.ceil(.75*E)+5,m=!0,y=-1;++yP&&(P=j),h=0,k[y]===A)if(R=u(v,e,t),h=i>0?i:f(e,t,_,k,v,y,R),(a=O+s(v,y,R,o,h))>P)P=a,w=x;else{if(C&&--w<=0)return Math.max(P,I[E-1])*z;C=!1}O=j,i=l[y],l[y]=h,I[y]=P}return(P=I[E-1])*z},t.isWordStart=u=function(e,t,n){var r,o;return 0===e||(r=t[e],o=t[e-1],i(o)||r!==n[e]&&o===n[e-1])},t.isWordEnd=l=function(e,t,n,r){var o,a;return e===r-1||(o=t[e],a=t[e+1],i(a)||o===n[e]&&a!==n[e+1])},i=function(e){return" "===e||"."===e||"-"===e||"_"===e||"/"===e||"\\"===e},m=function(e){var t;return e<20?100+(t=20-e)*t:Math.max(120-e,0)},t.scoreSize=g=function(e,t){return 150/(150+Math.abs(t-e))},d=function(e,t,n,r){return 2*e*(150*n+m(r))*g(e,t)},t.scorePattern=h=function(e,t,n,r,o){var a,i;return i=e,a=6,n===e&&(a+=2),r&&(a+=3),o&&(a+=1),e===t&&(r&&(i+=n===t?2:1),o&&(a+=1)),n+i*(i+a)},t.scoreCharacter=s=function(e,t,n,r,o){var a;return a=m(e),n?a+150*((r>o?r:o)+10):a+150*o},t.scoreConsecutives=f=function(e,t,n,r,o,a,i){var u,c,s,f,d,p,m;for(u=(s=(c=e.length)-o)<(d=(f=n.length)-a)?s:d,p=0,m=0,n[a]===e[o]&&p++;++m-1&&(m=u(f,e,t))&&(o=f),s=-1,p=0;++s1&&m>1))return r;for(c=0,b=0,x=0,v=0,f=-1,d=-1;++d-1){b++;continue}break}for(;++f12*n.length)return!1;for(a=-1;++ar)return!1;return!0}}).call(this)},281:(e,t,n)=>{"use strict";var r=n(892),o={childContextTypes:!0,contextType:!0,contextTypes:!0,defaultProps:!0,displayName:!0,getDefaultProps:!0,getDerivedStateFromError:!0,getDerivedStateFromProps:!0,mixins:!0,propTypes:!0,type:!0},a={name:!0,length:!0,prototype:!0,caller:!0,callee:!0,arguments:!0,arity:!0},i={$$typeof:!0,compare:!0,defaultProps:!0,displayName:!0,propTypes:!0,type:!0},l={};function u(e){return r.isMemo(e)?i:l[e.$$typeof]||o}l[r.ForwardRef]={$$typeof:!0,render:!0,defaultProps:!0,displayName:!0,propTypes:!0},l[r.Memo]=i;var c=Object.defineProperty,s=Object.getOwnPropertyNames,f=Object.getOwnPropertySymbols,d=Object.getOwnPropertyDescriptor,p=Object.getPrototypeOf,h=Object.prototype;e.exports=function e(t,n,r){if("string"!=typeof n){if(h){var o=p(n);o&&o!==h&&e(t,o,r)}var i=s(n);f&&(i=i.concat(f(n)));for(var l=u(t),m=u(n),g=0;g{"use strict";var n="function"==typeof Symbol&&Symbol.for,r=n?Symbol.for("react.element"):60103,o=n?Symbol.for("react.portal"):60106,a=n?Symbol.for("react.fragment"):60107,i=n?Symbol.for("react.strict_mode"):60108,l=n?Symbol.for("react.profiler"):60114,u=n?Symbol.for("react.provider"):60109,c=n?Symbol.for("react.context"):60110,s=n?Symbol.for("react.async_mode"):60111,f=n?Symbol.for("react.concurrent_mode"):60111,d=n?Symbol.for("react.forward_ref"):60112,p=n?Symbol.for("react.suspense"):60113,h=n?Symbol.for("react.suspense_list"):60120,m=n?Symbol.for("react.memo"):60115,g=n?Symbol.for("react.lazy"):60116,v=n?Symbol.for("react.block"):60121,y=n?Symbol.for("react.fundamental"):60117,b=n?Symbol.for("react.responder"):60118,x=n?Symbol.for("react.scope"):60119;function w(e){if("object"==typeof e&&null!==e){var t=e.$$typeof;switch(t){case r:switch(e=e.type){case s:case f:case a:case l:case i:case p:return e;default:switch(e=e&&e.$$typeof){case c:case d:case g:case m:case u:return e;default:return t}}case o:return t}}}function E(e){return w(e)===f}t.AsyncMode=s,t.ConcurrentMode=f,t.ContextConsumer=c,t.ContextProvider=u,t.Element=r,t.ForwardRef=d,t.Fragment=a,t.Lazy=g,t.Memo=m,t.Portal=o,t.Profiler=l,t.StrictMode=i,t.Suspense=p,t.isAsyncMode=function(e){return E(e)||w(e)===s},t.isConcurrentMode=E,t.isContextConsumer=function(e){return w(e)===c},t.isContextProvider=function(e){return w(e)===u},t.isElement=function(e){return"object"==typeof e&&null!==e&&e.$$typeof===r},t.isForwardRef=function(e){return w(e)===d},t.isFragment=function(e){return w(e)===a},t.isLazy=function(e){return w(e)===g},t.isMemo=function(e){return w(e)===m},t.isPortal=function(e){return w(e)===o},t.isProfiler=function(e){return w(e)===l},t.isStrictMode=function(e){return w(e)===i},t.isSuspense=function(e){return w(e)===p},t.isValidElementType=function(e){return"string"==typeof e||"function"==typeof e||e===a||e===f||e===l||e===i||e===p||e===h||"object"==typeof e&&null!==e&&(e.$$typeof===g||e.$$typeof===m||e.$$typeof===u||e.$$typeof===c||e.$$typeof===d||e.$$typeof===y||e.$$typeof===b||e.$$typeof===x||e.$$typeof===v)},t.typeOf=w},892:(e,t,n)=>{"use strict";e.exports=n(651)},466:(e,t,n)=>{e.exports=function e(t,n,r){function o(i,l){if(!n[i]){if(!t[i]){if(a)return a(i,!0);var u=new Error("Cannot find module '"+i+"'");throw u.code="MODULE_NOT_FOUND",u}var c=n[i]={exports:{}};t[i][0].call(c.exports,(function(e){return o(t[i][1][e]||e)}),c,c.exports,e,t,n,r)}return n[i].exports}for(var a=void 0,i=0;i=43)}})).catch((function(){return!1}))}(e).then((function(e){return d=e}))}function b(e){var t=p[e.name],n={};n.promise=new i((function(e,t){n.resolve=e,n.reject=t})),t.deferredOperations.push(n),t.dbReady?t.dbReady=t.dbReady.then((function(){return n.promise})):t.dbReady=n.promise}function x(e){var t=p[e.name].deferredOperations.pop();if(t)return t.resolve(),t.promise}function w(e,t){var n=p[e.name].deferredOperations.pop();if(n)return n.reject(t),n.promise}function E(e,t){return new i((function(n,r){if(p[e.name]=p[e.name]||{forages:[],db:null,dbReady:null,deferredOperations:[]},e.db){if(!t)return n(e.db);b(e),e.db.close()}var a=[e.name];t&&a.push(e.version);var i=o.open.apply(o,a);t&&(i.onupgradeneeded=function(t){var n=i.result;try{n.createObjectStore(e.storeName),t.oldVersion<=1&&n.createObjectStore(f)}catch(n){if("ConstraintError"!==n.name)throw n;console.warn('The database "'+e.name+'" has been upgraded from version '+t.oldVersion+" to version "+t.newVersion+', but the storage "'+e.storeName+'" already exists.')}}),i.onerror=function(e){e.preventDefault(),r(i.error)},i.onsuccess=function(){var t=i.result;t.onversionchange=function(e){e.target.close()},n(t),x(e)}}))}function S(e){return E(e,!1)}function _(e){return E(e,!0)}function k(e,t){if(!e.db)return!0;var n=!e.db.objectStoreNames.contains(e.storeName),r=e.versione.db.version;if(r&&(e.version!==t&&console.warn('The database "'+e.name+"\" can't be downgraded from version "+e.db.version+" to version "+e.version+"."),e.version=e.db.version),o||n){if(n){var a=e.db.version+1;a>e.version&&(e.version=a)}return!0}return!1}function C(e){return a([v(atob(e.data))],{type:e.type})}function P(e){return e&&e.__local_forage_encoded_blob}function O(e){var t=this,n=t._initReady().then((function(){var e=p[t._dbInfo.name];if(e&&e.dbReady)return e.dbReady}));return u(n,e,e),n}function I(e,t,n,r){void 0===r&&(r=1);try{var o=e.db.transaction(e.storeName,t);n(null,o)}catch(o){if(r>0&&(!e.db||"InvalidStateError"===o.name||"NotFoundError"===o.name))return i.resolve().then((function(){if(!e.db||"NotFoundError"===o.name&&!e.db.objectStoreNames.contains(e.storeName)&&e.version<=e.db.version)return e.db&&(e.version=e.db.version+1),_(e)})).then((function(){return function(e){b(e);for(var t=p[e.name],n=t.forages,r=0;r>4,s[u++]=(15&r)<<4|o>>2,s[u++]=(3&o)<<6|63&a;return c}function Z(e){var t,n=new Uint8Array(e),r="";for(t=0;t>2],r+=A[(3&n[t])<<4|n[t+1]>>4],r+=A[(15&n[t+1])<<2|n[t+2]>>6],r+=A[63&n[t+2]];return n.length%3==2?r=r.substring(0,r.length-1)+"=":n.length%3==1&&(r=r.substring(0,r.length-2)+"=="),r}var G={serialize:function(e,t){var n="";if(e&&(n=H.call(e)),e&&("[object ArrayBuffer]"===n||e.buffer&&"[object ArrayBuffer]"===H.call(e.buffer))){var r,o=z;e instanceof ArrayBuffer?(r=e,o+=N):(r=e.buffer,"[object Int8Array]"===n?o+=F:"[object Uint8Array]"===n?o+=$:"[object Uint8ClampedArray]"===n?o+=T:"[object Int16Array]"===n?o+=L:"[object Uint16Array]"===n?o+=B:"[object Int32Array]"===n?o+=D:"[object Uint32Array]"===n?o+=U:"[object Float32Array]"===n?o+=W:"[object Float64Array]"===n?o+=V:t(new Error("Failed to get type for BinaryArray"))),t(o+Z(r))}else if("[object Blob]"===n){var a=new FileReader;a.onload=function(){var n="~~local_forage_type~"+e.type+"~"+Z(this.result);t(z+M+n)},a.readAsArrayBuffer(e)}else try{t(JSON.stringify(e))}catch(n){console.error("Couldn't convert value into a JSON string: ",e),t(null,n)}},deserialize:function(e){if(e.substring(0,9)!==z)return JSON.parse(e);var t,n=e.substring(13),r=e.substring(9,13);if(r===M&&R.test(n)){var o=n.match(R);t=o[1],n=n.substring(o[0].length)}var i=q(n);switch(r){case N:return i;case M:return a([i],{type:t});case F:return new Int8Array(i);case $:return new Uint8Array(i);case T:return new Uint8ClampedArray(i);case L:return new Int16Array(i);case B:return new Uint16Array(i);case D:return new Int32Array(i);case U:return new Uint32Array(i);case W:return new Float32Array(i);case V:return new Float64Array(i);default:throw new Error("Unkown type: "+r)}},stringToBuffer:q,bufferToString:Z};function Q(e,t,n,r){e.executeSql("CREATE TABLE IF NOT EXISTS "+t.storeName+" (id INTEGER PRIMARY KEY, key unique, value)",[],n,r)}function K(e,t,n,r,o,a){e.executeSql(n,r,o,(function(e,i){i.code===i.SYNTAX_ERR?e.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name = ?",[t.storeName],(function(e,l){l.rows.length?a(e,i):Q(e,t,(function(){e.executeSql(n,r,o,a)}),a)}),a):a(e,i)}),a)}function Y(e,t,n,r){var o=this;e=c(e);var a=new i((function(a,i){o.ready().then((function(){void 0===t&&(t=null);var l=t,u=o._dbInfo;u.serializer.serialize(t,(function(t,c){c?i(c):u.db.transaction((function(n){K(n,u,"INSERT OR REPLACE INTO "+u.storeName+" (key, value) VALUES (?, ?)",[e,t],(function(){a(l)}),(function(e,t){i(t)}))}),(function(t){if(t.code===t.QUOTA_ERR){if(r>0)return void a(Y.apply(o,[e,l,n,r-1]));i(t)}}))}))})).catch(i)}));return l(a,n),a}var X={_driver:"webSQLStorage",_initStorage:function(e){var t=this,n={db:null};if(e)for(var r in e)n[r]="string"!=typeof e[r]?e[r].toString():e[r];var o=new i((function(e,r){try{n.db=openDatabase(n.name,String(n.version),n.description,n.size)}catch(e){return r(e)}n.db.transaction((function(o){Q(o,n,(function(){t._dbInfo=n,e()}),(function(e,t){r(t)}))}),r)}));return n.serializer=G,o},_support:"function"==typeof openDatabase,iterate:function(e,t){var n=this,r=new i((function(t,r){n.ready().then((function(){var o=n._dbInfo;o.db.transaction((function(n){K(n,o,"SELECT * FROM "+o.storeName,[],(function(n,r){for(var a=r.rows,i=a.length,l=0;l '__WebKitDatabaseInfoTable__'",[],(function(n,r){for(var o=[],a=0;a0}var te={_driver:"localStorageWrapper",_initStorage:function(e){var t={};if(e)for(var n in e)t[n]=e[n];return t.keyPrefix=J(e,this._defaultConfig),ee()?(this._dbInfo=t,t.serializer=G,i.resolve()):i.reject()},_support:function(){try{return"undefined"!=typeof localStorage&&"setItem"in localStorage&&!!localStorage.setItem}catch(e){return!1}}(),iterate:function(e,t){var n=this,r=n.ready().then((function(){for(var t=n._dbInfo,r=t.keyPrefix,o=r.length,a=localStorage.length,i=1,l=0;l=0;n--){var r=localStorage.key(n);0===r.indexOf(e)&&localStorage.removeItem(r)}}));return l(n,e),n},length:function(e){var t=this.keys().then((function(e){return e.length}));return l(t,e),t},key:function(e,t){var n=this,r=n.ready().then((function(){var t,r=n._dbInfo;try{t=localStorage.key(e)}catch(e){t=null}return t&&(t=t.substring(r.keyPrefix.length)),t}));return l(r,t),r},keys:function(e){var t=this,n=t.ready().then((function(){for(var e=t._dbInfo,n=localStorage.length,r=[],o=0;o=0;t--){var n=localStorage.key(t);0===n.indexOf(e)&&localStorage.removeItem(n)}})):i.reject("Invalid arguments"),l(r,t),r}},ne=function(e,t){for(var n=e.length,r=0;r"']/g,Z=RegExp(H.source),G=RegExp(q.source),Q=/<%-([\s\S]+?)%>/g,K=/<%([\s\S]+?)%>/g,Y=/<%=([\s\S]+?)%>/g,X=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,J=/^\w*$/,ee=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,te=/[\\^$.*+?()[\]{}|]/g,ne=RegExp(te.source),re=/^\s+/,oe=/\s/,ae=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,ie=/\{\n\/\* \[wrapped with (.+)\] \*/,le=/,? & /,ue=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,ce=/[()=,{}\[\]\/\s]/,se=/\\(\\)?/g,fe=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,de=/\w*$/,pe=/^[-+]0x[0-9a-f]+$/i,he=/^0b[01]+$/i,me=/^\[object .+?Constructor\]$/,ge=/^0o[0-7]+$/i,ve=/^(?:0|[1-9]\d*)$/,ye=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,be=/($^)/,xe=/['\n\r\u2028\u2029\\]/g,we="\\ud800-\\udfff",Ee="\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff",Se="\\u2700-\\u27bf",_e="a-z\\xdf-\\xf6\\xf8-\\xff",ke="A-Z\\xc0-\\xd6\\xd8-\\xde",Ce="\\ufe0e\\ufe0f",Pe="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",Oe="["+we+"]",Ie="["+Pe+"]",je="["+Ee+"]",Ae="\\d+",Re="["+Se+"]",ze="["+_e+"]",Ne="[^"+we+Pe+Ae+Se+_e+ke+"]",Me="\\ud83c[\\udffb-\\udfff]",Fe="[^"+we+"]",$e="(?:\\ud83c[\\udde6-\\uddff]){2}",Te="[\\ud800-\\udbff][\\udc00-\\udfff]",Le="["+ke+"]",De="\\u200d",Be="(?:"+ze+"|"+Ne+")",Ue="(?:"+Le+"|"+Ne+")",We="(?:['’](?:d|ll|m|re|s|t|ve))?",Ve="(?:['’](?:D|LL|M|RE|S|T|VE))?",He="(?:"+je+"|"+Me+")?",qe="["+Ce+"]?",Ze=qe+He+"(?:"+De+"(?:"+[Fe,$e,Te].join("|")+")"+qe+He+")*",Ge="(?:"+[Re,$e,Te].join("|")+")"+Ze,Qe="(?:"+[Fe+je+"?",je,$e,Te,Oe].join("|")+")",Ke=RegExp("['’]","g"),Ye=RegExp(je,"g"),Xe=RegExp(Me+"(?="+Me+")|"+Qe+Ze,"g"),Je=RegExp([Le+"?"+ze+"+"+We+"(?="+[Ie,Le,"$"].join("|")+")",Ue+"+"+Ve+"(?="+[Ie,Le+Be,"$"].join("|")+")",Le+"?"+Be+"+"+We,Le+"+"+Ve,"\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",Ae,Ge].join("|"),"g"),et=RegExp("["+De+we+Ee+Ce+"]"),tt=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,nt=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],rt=-1,ot={};ot[z]=ot[N]=ot[M]=ot[F]=ot[$]=ot[T]=ot[L]=ot[D]=ot[B]=!0,ot[m]=ot[g]=ot[A]=ot[v]=ot[R]=ot[y]=ot[b]=ot[x]=ot[E]=ot[S]=ot[_]=ot[C]=ot[P]=ot[O]=ot[j]=!1;var at={};at[m]=at[g]=at[A]=at[R]=at[v]=at[y]=at[z]=at[N]=at[M]=at[F]=at[$]=at[E]=at[S]=at[_]=at[C]=at[P]=at[O]=at[I]=at[T]=at[L]=at[D]=at[B]=!0,at[b]=at[x]=at[j]=!1;var it={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},lt=parseFloat,ut=parseInt,ct="object"==typeof n.g&&n.g&&n.g.Object===Object&&n.g,st="object"==typeof self&&self&&self.Object===Object&&self,ft=ct||st||Function("return this")(),dt=t&&!t.nodeType&&t,pt=dt&&e&&!e.nodeType&&e,ht=pt&&pt.exports===dt,mt=ht&&ct.process,gt=function(){try{return pt&&pt.require&&pt.require("util").types||mt&&mt.binding&&mt.binding("util")}catch(e){}}(),vt=gt&>.isArrayBuffer,yt=gt&>.isDate,bt=gt&>.isMap,xt=gt&>.isRegExp,wt=gt&>.isSet,Et=gt&>.isTypedArray;function St(e,t,n){switch(n.length){case 0:return e.call(t);case 1:return e.call(t,n[0]);case 2:return e.call(t,n[0],n[1]);case 3:return e.call(t,n[0],n[1],n[2])}return e.apply(t,n)}function _t(e,t,n,r){for(var o=-1,a=null==e?0:e.length;++o-1}function jt(e,t,n){for(var r=-1,o=null==e?0:e.length;++r-1;);return n}function Jt(e,t){for(var n=e.length;n--&&Lt(t,e[n],0)>-1;);return n}var en=Vt({À:"A",Á:"A",Â:"A",Ã:"A",Ä:"A",Å:"A",à:"a",á:"a",â:"a",ã:"a",ä:"a",å:"a",Ç:"C",ç:"c",Ð:"D",ð:"d",È:"E",É:"E",Ê:"E",Ë:"E",è:"e",é:"e",ê:"e",ë:"e",Ì:"I",Í:"I",Î:"I",Ï:"I",ì:"i",í:"i",î:"i",ï:"i",Ñ:"N",ñ:"n",Ò:"O",Ó:"O",Ô:"O",Õ:"O",Ö:"O",Ø:"O",ò:"o",ó:"o",ô:"o",õ:"o",ö:"o",ø:"o",Ù:"U",Ú:"U",Û:"U",Ü:"U",ù:"u",ú:"u",û:"u",ü:"u",Ý:"Y",ý:"y",ÿ:"y",Æ:"Ae",æ:"ae",Þ:"Th",þ:"th",ß:"ss",Ā:"A",Ă:"A",Ą:"A",ā:"a",ă:"a",ą:"a",Ć:"C",Ĉ:"C",Ċ:"C",Č:"C",ć:"c",ĉ:"c",ċ:"c",č:"c",Ď:"D",Đ:"D",ď:"d",đ:"d",Ē:"E",Ĕ:"E",Ė:"E",Ę:"E",Ě:"E",ē:"e",ĕ:"e",ė:"e",ę:"e",ě:"e",Ĝ:"G",Ğ:"G",Ġ:"G",Ģ:"G",ĝ:"g",ğ:"g",ġ:"g",ģ:"g",Ĥ:"H",Ħ:"H",ĥ:"h",ħ:"h",Ĩ:"I",Ī:"I",Ĭ:"I",Į:"I",İ:"I",ĩ:"i",ī:"i",ĭ:"i",į:"i",ı:"i",Ĵ:"J",ĵ:"j",Ķ:"K",ķ:"k",ĸ:"k",Ĺ:"L",Ļ:"L",Ľ:"L",Ŀ:"L",Ł:"L",ĺ:"l",ļ:"l",ľ:"l",ŀ:"l",ł:"l",Ń:"N",Ņ:"N",Ň:"N",Ŋ:"N",ń:"n",ņ:"n",ň:"n",ŋ:"n",Ō:"O",Ŏ:"O",Ő:"O",ō:"o",ŏ:"o",ő:"o",Ŕ:"R",Ŗ:"R",Ř:"R",ŕ:"r",ŗ:"r",ř:"r",Ś:"S",Ŝ:"S",Ş:"S",Š:"S",ś:"s",ŝ:"s",ş:"s",š:"s",Ţ:"T",Ť:"T",Ŧ:"T",ţ:"t",ť:"t",ŧ:"t",Ũ:"U",Ū:"U",Ŭ:"U",Ů:"U",Ű:"U",Ų:"U",ũ:"u",ū:"u",ŭ:"u",ů:"u",ű:"u",ų:"u",Ŵ:"W",ŵ:"w",Ŷ:"Y",ŷ:"y",Ÿ:"Y",Ź:"Z",Ż:"Z",Ž:"Z",ź:"z",ż:"z",ž:"z",IJ:"IJ",ij:"ij",Œ:"Oe",œ:"oe",ʼn:"'n",ſ:"s"}),tn=Vt({"&":"&","<":"<",">":">",'"':""","'":"'"});function nn(e){return"\\"+it[e]}function rn(e){return et.test(e)}function on(e){var t=-1,n=Array(e.size);return e.forEach((function(e,r){n[++t]=[r,e]})),n}function an(e,t){return function(n){return e(t(n))}}function ln(e,t){for(var n=-1,r=e.length,o=0,a=[];++n",""":'"',"'":"'"}),hn=function e(t){var n,r=(t=null==t?ft:hn.defaults(ft.Object(),t,hn.pick(ft,nt))).Array,oe=t.Date,we=t.Error,Ee=t.Function,Se=t.Math,_e=t.Object,ke=t.RegExp,Ce=t.String,Pe=t.TypeError,Oe=r.prototype,Ie=Ee.prototype,je=_e.prototype,Ae=t["__core-js_shared__"],Re=Ie.toString,ze=je.hasOwnProperty,Ne=0,Me=(n=/[^.]+$/.exec(Ae&&Ae.keys&&Ae.keys.IE_PROTO||""))?"Symbol(src)_1."+n:"",Fe=je.toString,$e=Re.call(_e),Te=ft._,Le=ke("^"+Re.call(ze).replace(te,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),De=ht?t.Buffer:o,Be=t.Symbol,Ue=t.Uint8Array,We=De?De.allocUnsafe:o,Ve=an(_e.getPrototypeOf,_e),He=_e.create,qe=je.propertyIsEnumerable,Ze=Oe.splice,Ge=Be?Be.isConcatSpreadable:o,Qe=Be?Be.iterator:o,Xe=Be?Be.toStringTag:o,et=function(){try{var e=ca(_e,"defineProperty");return e({},"",{}),e}catch(e){}}(),it=t.clearTimeout!==ft.clearTimeout&&t.clearTimeout,ct=oe&&oe.now!==ft.Date.now&&oe.now,st=t.setTimeout!==ft.setTimeout&&t.setTimeout,dt=Se.ceil,pt=Se.floor,mt=_e.getOwnPropertySymbols,gt=De?De.isBuffer:o,Ft=t.isFinite,Vt=Oe.join,mn=an(_e.keys,_e),gn=Se.max,vn=Se.min,yn=oe.now,bn=t.parseInt,xn=Se.random,wn=Oe.reverse,En=ca(t,"DataView"),Sn=ca(t,"Map"),_n=ca(t,"Promise"),kn=ca(t,"Set"),Cn=ca(t,"WeakMap"),Pn=ca(_e,"create"),On=Cn&&new Cn,In={},jn=$a(En),An=$a(Sn),Rn=$a(_n),zn=$a(kn),Nn=$a(Cn),Mn=Be?Be.prototype:o,Fn=Mn?Mn.valueOf:o,$n=Mn?Mn.toString:o;function Tn(e){if(el(e)&&!Wi(e)&&!(e instanceof Un)){if(e instanceof Bn)return e;if(ze.call(e,"__wrapped__"))return Ta(e)}return new Bn(e)}var Ln=function(){function e(){}return function(t){if(!Ji(t))return{};if(He)return He(t);e.prototype=t;var n=new e;return e.prototype=o,n}}();function Dn(){}function Bn(e,t){this.__wrapped__=e,this.__actions__=[],this.__chain__=!!t,this.__index__=0,this.__values__=o}function Un(e){this.__wrapped__=e,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=p,this.__views__=[]}function Wn(e){var t=-1,n=null==e?0:e.length;for(this.clear();++t=t?e:t)),e}function ir(e,t,n,r,a,i){var l,u=1&t,c=2&t,s=4&t;if(n&&(l=a?n(e,r,a,i):n(e)),l!==o)return l;if(!Ji(e))return e;var f=Wi(e);if(f){if(l=function(e){var t=e.length,n=new e.constructor(t);return t&&"string"==typeof e[0]&&ze.call(e,"index")&&(n.index=e.index,n.input=e.input),n}(e),!u)return Po(e,l)}else{var d=da(e),p=d==x||d==w;if(Zi(e))return wo(e,u);if(d==_||d==m||p&&!a){if(l=c||p?{}:ha(e),!u)return c?function(e,t){return Oo(e,fa(e),t)}(e,function(e,t){return e&&Oo(t,Al(t),e)}(l,e)):function(e,t){return Oo(e,sa(e),t)}(e,nr(l,e))}else{if(!at[d])return a?e:{};l=function(e,t,n){var r,o=e.constructor;switch(t){case A:return Eo(e);case v:case y:return new o(+e);case R:return function(e,t){var n=t?Eo(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.byteLength)}(e,n);case z:case N:case M:case F:case $:case T:case L:case D:case B:return So(e,n);case E:return new o;case S:case O:return new o(e);case C:return function(e){var t=new e.constructor(e.source,de.exec(e));return t.lastIndex=e.lastIndex,t}(e);case P:return new o;case I:return r=e,Fn?_e(Fn.call(r)):{}}}(e,d,u)}}i||(i=new Zn);var h=i.get(e);if(h)return h;i.set(e,l),al(e)?e.forEach((function(r){l.add(ir(r,t,n,r,e,i))})):tl(e)&&e.forEach((function(r,o){l.set(o,ir(r,t,n,o,e,i))}));var g=f?o:(s?c?na:ta:c?Al:jl)(e);return kt(g||e,(function(r,o){g&&(r=e[o=r]),Jn(l,o,ir(r,t,n,o,e,i))})),l}function lr(e,t,n){var r=n.length;if(null==e)return!r;for(e=_e(e);r--;){var a=n[r],i=t[a],l=e[a];if(l===o&&!(a in e)||!i(l))return!1}return!0}function ur(e,t,n){if("function"!=typeof e)throw new Pe(a);return Oa((function(){e.apply(o,n)}),t)}function cr(e,t,n,r){var o=-1,a=It,i=!0,l=e.length,u=[],c=t.length;if(!l)return u;n&&(t=At(t,Qt(n))),r?(a=jt,i=!1):t.length>=200&&(a=Yt,i=!1,t=new qn(t));e:for(;++o-1},Vn.prototype.set=function(e,t){var n=this.__data__,r=er(n,e);return r<0?(++this.size,n.push([e,t])):n[r][1]=t,this},Hn.prototype.clear=function(){this.size=0,this.__data__={hash:new Wn,map:new(Sn||Vn),string:new Wn}},Hn.prototype.delete=function(e){var t=la(this,e).delete(e);return this.size-=t?1:0,t},Hn.prototype.get=function(e){return la(this,e).get(e)},Hn.prototype.has=function(e){return la(this,e).has(e)},Hn.prototype.set=function(e,t){var n=la(this,e),r=n.size;return n.set(e,t),this.size+=n.size==r?0:1,this},qn.prototype.add=qn.prototype.push=function(e){return this.__data__.set(e,i),this},qn.prototype.has=function(e){return this.__data__.has(e)},Zn.prototype.clear=function(){this.__data__=new Vn,this.size=0},Zn.prototype.delete=function(e){var t=this.__data__,n=t.delete(e);return this.size=t.size,n},Zn.prototype.get=function(e){return this.__data__.get(e)},Zn.prototype.has=function(e){return this.__data__.has(e)},Zn.prototype.set=function(e,t){var n=this.__data__;if(n instanceof Vn){var r=n.__data__;if(!Sn||r.length<199)return r.push([e,t]),this.size=++n.size,this;n=this.__data__=new Hn(r)}return n.set(e,t),this.size=n.size,this};var sr=Ao(yr),fr=Ao(br,!0);function dr(e,t){var n=!0;return sr(e,(function(e,r,o){return n=!!t(e,r,o)})),n}function pr(e,t,n){for(var r=-1,a=e.length;++r0&&n(l)?t>1?mr(l,t-1,n,r,o):Rt(o,l):r||(o[o.length]=l)}return o}var gr=Ro(),vr=Ro(!0);function yr(e,t){return e&&gr(e,t,jl)}function br(e,t){return e&&vr(e,t,jl)}function xr(e,t){return Ot(t,(function(t){return Ki(e[t])}))}function wr(e,t){for(var n=0,r=(t=vo(t,e)).length;null!=e&&nt}function kr(e,t){return null!=e&&ze.call(e,t)}function Cr(e,t){return null!=e&&t in _e(e)}function Pr(e,t,n){for(var a=n?jt:It,i=e[0].length,l=e.length,u=l,c=r(l),s=1/0,f=[];u--;){var d=e[u];u&&t&&(d=At(d,Qt(t))),s=vn(d.length,s),c[u]=!n&&(t||i>=120&&d.length>=120)?new qn(u&&d):o}d=e[0];var p=-1,h=c[0];e:for(;++p=l?u:u*("desc"==n[r]?-1:1)}return e.index-t.index}(e,t,n)}));r--;)e[r]=e[r].value;return e}(o)}function Ur(e,t,n){for(var r=-1,o=t.length,a={};++r-1;)l!==e&&Ze.call(l,u,1),Ze.call(e,u,1);return e}function Vr(e,t){for(var n=e?t.length:0,r=n-1;n--;){var o=t[n];if(n==r||o!==a){var a=o;ga(o)?Ze.call(e,o,1):uo(e,o)}}return e}function Hr(e,t){return e+pt(xn()*(t-e+1))}function qr(e,t){var n="";if(!e||t<1||t>f)return n;do{t%2&&(n+=e),(t=pt(t/2))&&(e+=e)}while(t);return n}function Zr(e,t){return Ia(_a(e,t,nu),e+"")}function Gr(e){return Qn(Ll(e))}function Qr(e,t){var n=Ll(e);return Ra(n,ar(t,0,n.length))}function Kr(e,t,n,r){if(!Ji(e))return e;for(var a=-1,i=(t=vo(t,e)).length,l=i-1,u=e;null!=u&&++aa?0:a+t),(n=n>a?a:n)<0&&(n+=a),a=t>n?0:n-t>>>0,t>>>=0;for(var i=r(a);++o>>1,i=e[a];null!==i&&!ll(i)&&(n?i<=t:i=200){var c=t?null:Zo(e);if(c)return un(c);i=!1,o=Yt,u=new qn}else u=t?[]:l;e:for(;++r=r?e:eo(e,t,n)}var xo=it||function(e){return ft.clearTimeout(e)};function wo(e,t){if(t)return e.slice();var n=e.length,r=We?We(n):new e.constructor(n);return e.copy(r),r}function Eo(e){var t=new e.constructor(e.byteLength);return new Ue(t).set(new Ue(e)),t}function So(e,t){var n=t?Eo(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.length)}function _o(e,t){if(e!==t){var n=e!==o,r=null===e,a=e==e,i=ll(e),l=t!==o,u=null===t,c=t==t,s=ll(t);if(!u&&!s&&!i&&e>t||i&&l&&c&&!u&&!s||r&&l&&c||!n&&c||!a)return 1;if(!r&&!i&&!s&&e1?n[a-1]:o,l=a>2?n[2]:o;for(i=e.length>3&&"function"==typeof i?(a--,i):o,l&&va(n[0],n[1],l)&&(i=a<3?o:i,a=1),t=_e(t);++r-1?a[i?t[l]:l]:o}}function $o(e){return ea((function(t){var n=t.length,r=n,i=Bn.prototype.thru;for(e&&t.reverse();r--;){var l=t[r];if("function"!=typeof l)throw new Pe(a);if(i&&!u&&"wrapper"==oa(l))var u=new Bn([],!0)}for(r=u?r:n;++r1&&x.reverse(),p&&fu))return!1;var s=i.get(e),f=i.get(t);if(s&&f)return s==t&&f==e;var d=-1,p=!0,h=2&n?new qn:o;for(i.set(e,t),i.set(t,e);++d-1&&e%1==0&&e1?"& ":"")+t[r],t=t.join(n>2?", ":" "),e.replace(ae,"{\n/* [wrapped with "+t+"] */\n")}(r,function(e,t){return kt(h,(function(n){var r="_."+n[0];t&n[1]&&!It(e,r)&&e.push(r)})),e.sort()}(function(e){var t=e.match(ie);return t?t[1].split(le):[]}(r),n)))}function Aa(e){var t=0,n=0;return function(){var r=yn(),a=16-(r-n);if(n=r,a>0){if(++t>=800)return arguments[0]}else t=0;return e.apply(o,arguments)}}function Ra(e,t){var n=-1,r=e.length,a=r-1;for(t=t===o?r:t;++n1?e[t-1]:o;return n="function"==typeof n?(e.pop(),n):o,oi(e,n)}));function fi(e){var t=Tn(e);return t.__chain__=!0,t}function di(e,t){return t(e)}var pi=ea((function(e){var t=e.length,n=t?e[0]:0,r=this.__wrapped__,a=function(t){return or(t,e)};return!(t>1||this.__actions__.length)&&r instanceof Un&&ga(n)?((r=r.slice(n,+n+(t?1:0))).__actions__.push({func:di,args:[a],thisArg:o}),new Bn(r,this.__chain__).thru((function(e){return t&&!e.length&&e.push(o),e}))):this.thru(a)})),hi=Io((function(e,t,n){ze.call(e,n)?++e[n]:rr(e,n,1)})),mi=Fo(Ua),gi=Fo(Wa);function vi(e,t){return(Wi(e)?kt:sr)(e,ia(t,3))}function yi(e,t){return(Wi(e)?Ct:fr)(e,ia(t,3))}var bi=Io((function(e,t,n){ze.call(e,n)?e[n].push(t):rr(e,n,[t])})),xi=Zr((function(e,t,n){var o=-1,a="function"==typeof t,i=Hi(e)?r(e.length):[];return sr(e,(function(e){i[++o]=a?St(t,e,n):Or(e,t,n)})),i})),wi=Io((function(e,t,n){rr(e,n,t)}));function Ei(e,t){return(Wi(e)?At:Fr)(e,ia(t,3))}var Si=Io((function(e,t,n){e[n?0:1].push(t)}),(function(){return[[],[]]})),_i=Zr((function(e,t){if(null==e)return[];var n=t.length;return n>1&&va(e,t[0],t[1])?t=[]:n>2&&va(t[0],t[1],t[2])&&(t=[t[0]]),Br(e,mr(t,1),[])})),ki=ct||function(){return ft.Date.now()};function Ci(e,t,n){return t=n?o:t,t=e&&null==t?e.length:t,Qo(e,c,o,o,o,o,t)}function Pi(e,t){var n;if("function"!=typeof t)throw new Pe(a);return e=pl(e),function(){return--e>0&&(n=t.apply(this,arguments)),e<=1&&(t=o),n}}var Oi=Zr((function(e,t,n){var r=1;if(n.length){var o=ln(n,aa(Oi));r|=u}return Qo(e,r,t,n,o)})),Ii=Zr((function(e,t,n){var r=3;if(n.length){var o=ln(n,aa(Ii));r|=u}return Qo(t,r,e,n,o)}));function ji(e,t,n){var r,i,l,u,c,s,f=0,d=!1,p=!1,h=!0;if("function"!=typeof e)throw new Pe(a);function m(t){var n=r,a=i;return r=i=o,f=t,u=e.apply(a,n)}function g(e){var n=e-s;return s===o||n>=t||n<0||p&&e-f>=l}function v(){var e=ki();if(g(e))return y(e);c=Oa(v,function(e){var n=t-(e-s);return p?vn(n,l-(e-f)):n}(e))}function y(e){return c=o,h&&r?m(e):(r=i=o,u)}function b(){var e=ki(),n=g(e);if(r=arguments,i=this,s=e,n){if(c===o)return function(e){return f=e,c=Oa(v,t),d?m(e):u}(s);if(p)return xo(c),c=Oa(v,t),m(s)}return c===o&&(c=Oa(v,t)),u}return t=ml(t)||0,Ji(n)&&(d=!!n.leading,l=(p="maxWait"in n)?gn(ml(n.maxWait)||0,t):l,h="trailing"in n?!!n.trailing:h),b.cancel=function(){c!==o&&xo(c),f=0,r=s=i=c=o},b.flush=function(){return c===o?u:y(ki())},b}var Ai=Zr((function(e,t){return ur(e,1,t)})),Ri=Zr((function(e,t,n){return ur(e,ml(t)||0,n)}));function zi(e,t){if("function"!=typeof e||null!=t&&"function"!=typeof t)throw new Pe(a);var n=function(){var r=arguments,o=t?t.apply(this,r):r[0],a=n.cache;if(a.has(o))return a.get(o);var i=e.apply(this,r);return n.cache=a.set(o,i)||a,i};return n.cache=new(zi.Cache||Hn),n}function Ni(e){if("function"!=typeof e)throw new Pe(a);return function(){var t=arguments;switch(t.length){case 0:return!e.call(this);case 1:return!e.call(this,t[0]);case 2:return!e.call(this,t[0],t[1]);case 3:return!e.call(this,t[0],t[1],t[2])}return!e.apply(this,t)}}zi.Cache=Hn;var Mi=yo((function(e,t){var n=(t=1==t.length&&Wi(t[0])?At(t[0],Qt(ia())):At(mr(t,1),Qt(ia()))).length;return Zr((function(r){for(var o=-1,a=vn(r.length,n);++o=t})),Ui=Ir(function(){return arguments}())?Ir:function(e){return el(e)&&ze.call(e,"callee")&&!qe.call(e,"callee")},Wi=r.isArray,Vi=vt?Qt(vt):function(e){return el(e)&&Sr(e)==A};function Hi(e){return null!=e&&Xi(e.length)&&!Ki(e)}function qi(e){return el(e)&&Hi(e)}var Zi=gt||mu,Gi=yt?Qt(yt):function(e){return el(e)&&Sr(e)==y};function Qi(e){if(!el(e))return!1;var t=Sr(e);return t==b||"[object DOMException]"==t||"string"==typeof e.message&&"string"==typeof e.name&&!rl(e)}function Ki(e){if(!Ji(e))return!1;var t=Sr(e);return t==x||t==w||"[object AsyncFunction]"==t||"[object Proxy]"==t}function Yi(e){return"number"==typeof e&&e==pl(e)}function Xi(e){return"number"==typeof e&&e>-1&&e%1==0&&e<=f}function Ji(e){var t=typeof e;return null!=e&&("object"==t||"function"==t)}function el(e){return null!=e&&"object"==typeof e}var tl=bt?Qt(bt):function(e){return el(e)&&da(e)==E};function nl(e){return"number"==typeof e||el(e)&&Sr(e)==S}function rl(e){if(!el(e)||Sr(e)!=_)return!1;var t=Ve(e);if(null===t)return!0;var n=ze.call(t,"constructor")&&t.constructor;return"function"==typeof n&&n instanceof n&&Re.call(n)==$e}var ol=xt?Qt(xt):function(e){return el(e)&&Sr(e)==C},al=wt?Qt(wt):function(e){return el(e)&&da(e)==P};function il(e){return"string"==typeof e||!Wi(e)&&el(e)&&Sr(e)==O}function ll(e){return"symbol"==typeof e||el(e)&&Sr(e)==I}var ul=Et?Qt(Et):function(e){return el(e)&&Xi(e.length)&&!!ot[Sr(e)]},cl=Vo(Mr),sl=Vo((function(e,t){return e<=t}));function fl(e){if(!e)return[];if(Hi(e))return il(e)?fn(e):Po(e);if(Qe&&e[Qe])return function(e){for(var t,n=[];!(t=e.next()).done;)n.push(t.value);return n}(e[Qe]());var t=da(e);return(t==E?on:t==P?un:Ll)(e)}function dl(e){return e?(e=ml(e))===s||e===-1/0?17976931348623157e292*(e<0?-1:1):e==e?e:0:0===e?e:0}function pl(e){var t=dl(e),n=t%1;return t==t?n?t-n:t:0}function hl(e){return e?ar(pl(e),0,p):0}function ml(e){if("number"==typeof e)return e;if(ll(e))return d;if(Ji(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=Ji(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=Gt(e);var n=he.test(e);return n||ge.test(e)?ut(e.slice(2),n?2:8):pe.test(e)?d:+e}function gl(e){return Oo(e,Al(e))}function vl(e){return null==e?"":io(e)}var yl=jo((function(e,t){if(wa(t)||Hi(t))Oo(t,jl(t),e);else for(var n in t)ze.call(t,n)&&Jn(e,n,t[n])})),bl=jo((function(e,t){Oo(t,Al(t),e)})),xl=jo((function(e,t,n,r){Oo(t,Al(t),e,r)})),wl=jo((function(e,t,n,r){Oo(t,jl(t),e,r)})),El=ea(or),Sl=Zr((function(e,t){e=_e(e);var n=-1,r=t.length,a=r>2?t[2]:o;for(a&&va(t[0],t[1],a)&&(r=1);++n1),t})),Oo(e,na(e),n),r&&(n=ir(n,7,Xo));for(var o=t.length;o--;)uo(n,t[o]);return n})),Ml=ea((function(e,t){return null==e?{}:function(e,t){return Ur(e,t,(function(t,n){return Cl(e,n)}))}(e,t)}));function Fl(e,t){if(null==e)return{};var n=At(na(e),(function(e){return[e]}));return t=ia(t),Ur(e,n,(function(e,n){return t(e,n[0])}))}var $l=Go(jl),Tl=Go(Al);function Ll(e){return null==e?[]:Kt(e,jl(e))}var Dl=No((function(e,t,n){return t=t.toLowerCase(),e+(n?Bl(t):t)}));function Bl(e){return Ql(vl(e).toLowerCase())}function Ul(e){return(e=vl(e))&&e.replace(ye,en).replace(Ye,"")}var Wl=No((function(e,t,n){return e+(n?"-":"")+t.toLowerCase()})),Vl=No((function(e,t,n){return e+(n?" ":"")+t.toLowerCase()})),Hl=zo("toLowerCase"),ql=No((function(e,t,n){return e+(n?"_":"")+t.toLowerCase()})),Zl=No((function(e,t,n){return e+(n?" ":"")+Ql(t)})),Gl=No((function(e,t,n){return e+(n?" ":"")+t.toUpperCase()})),Ql=zo("toUpperCase");function Kl(e,t,n){return e=vl(e),(t=n?o:t)===o?function(e){return tt.test(e)}(e)?function(e){return e.match(Je)||[]}(e):function(e){return e.match(ue)||[]}(e):e.match(t)||[]}var Yl=Zr((function(e,t){try{return St(e,o,t)}catch(e){return Qi(e)?e:new we(e)}})),Xl=ea((function(e,t){return kt(t,(function(t){t=Fa(t),rr(e,t,Oi(e[t],e))})),e}));function Jl(e){return function(){return e}}var eu=$o(),tu=$o(!0);function nu(e){return e}function ru(e){return zr("function"==typeof e?e:ir(e,1))}var ou=Zr((function(e,t){return function(n){return Or(n,e,t)}})),au=Zr((function(e,t){return function(n){return Or(e,n,t)}}));function iu(e,t,n){var r=jl(t),o=xr(t,r);null!=n||Ji(t)&&(o.length||!r.length)||(n=t,t=e,e=this,o=xr(t,jl(t)));var a=!(Ji(n)&&"chain"in n&&!n.chain),i=Ki(e);return kt(o,(function(n){var r=t[n];e[n]=r,i&&(e.prototype[n]=function(){var t=this.__chain__;if(a||t){var n=e(this.__wrapped__);return(n.__actions__=Po(this.__actions__)).push({func:r,args:arguments,thisArg:e}),n.__chain__=t,n}return r.apply(e,Rt([this.value()],arguments))})})),e}function lu(){}var uu=Bo(At),cu=Bo(Pt),su=Bo(Mt);function fu(e){return ya(e)?Wt(Fa(e)):function(e){return function(t){return wr(t,e)}}(e)}var du=Wo(),pu=Wo(!0);function hu(){return[]}function mu(){return!1}var gu,vu=Do((function(e,t){return e+t}),0),yu=qo("ceil"),bu=Do((function(e,t){return e/t}),1),xu=qo("floor"),wu=Do((function(e,t){return e*t}),1),Eu=qo("round"),Su=Do((function(e,t){return e-t}),0);return Tn.after=function(e,t){if("function"!=typeof t)throw new Pe(a);return e=pl(e),function(){if(--e<1)return t.apply(this,arguments)}},Tn.ary=Ci,Tn.assign=yl,Tn.assignIn=bl,Tn.assignInWith=xl,Tn.assignWith=wl,Tn.at=El,Tn.before=Pi,Tn.bind=Oi,Tn.bindAll=Xl,Tn.bindKey=Ii,Tn.castArray=function(){if(!arguments.length)return[];var e=arguments[0];return Wi(e)?e:[e]},Tn.chain=fi,Tn.chunk=function(e,t,n){t=(n?va(e,t,n):t===o)?1:gn(pl(t),0);var a=null==e?0:e.length;if(!a||t<1)return[];for(var i=0,l=0,u=r(dt(a/t));ia?0:a+n),(r=r===o||r>a?a:pl(r))<0&&(r+=a),r=n>r?0:hl(r);n>>0)?(e=vl(e))&&("string"==typeof t||null!=t&&!ol(t))&&!(t=io(t))&&rn(e)?bo(fn(e),0,n):e.split(t,n):[]},Tn.spread=function(e,t){if("function"!=typeof e)throw new Pe(a);return t=null==t?0:gn(pl(t),0),Zr((function(n){var r=n[t],o=bo(n,0,t);return r&&Rt(o,r),St(e,this,o)}))},Tn.tail=function(e){var t=null==e?0:e.length;return t?eo(e,1,t):[]},Tn.take=function(e,t,n){return e&&e.length?eo(e,0,(t=n||t===o?1:pl(t))<0?0:t):[]},Tn.takeRight=function(e,t,n){var r=null==e?0:e.length;return r?eo(e,(t=r-(t=n||t===o?1:pl(t)))<0?0:t,r):[]},Tn.takeRightWhile=function(e,t){return e&&e.length?so(e,ia(t,3),!1,!0):[]},Tn.takeWhile=function(e,t){return e&&e.length?so(e,ia(t,3)):[]},Tn.tap=function(e,t){return t(e),e},Tn.throttle=function(e,t,n){var r=!0,o=!0;if("function"!=typeof e)throw new Pe(a);return Ji(n)&&(r="leading"in n?!!n.leading:r,o="trailing"in n?!!n.trailing:o),ji(e,t,{leading:r,maxWait:t,trailing:o})},Tn.thru=di,Tn.toArray=fl,Tn.toPairs=$l,Tn.toPairsIn=Tl,Tn.toPath=function(e){return Wi(e)?At(e,Fa):ll(e)?[e]:Po(Ma(vl(e)))},Tn.toPlainObject=gl,Tn.transform=function(e,t,n){var r=Wi(e),o=r||Zi(e)||ul(e);if(t=ia(t,4),null==n){var a=e&&e.constructor;n=o?r?new a:[]:Ji(e)&&Ki(a)?Ln(Ve(e)):{}}return(o?kt:yr)(e,(function(e,r,o){return t(n,e,r,o)})),n},Tn.unary=function(e){return Ci(e,1)},Tn.union=ei,Tn.unionBy=ti,Tn.unionWith=ni,Tn.uniq=function(e){return e&&e.length?lo(e):[]},Tn.uniqBy=function(e,t){return e&&e.length?lo(e,ia(t,2)):[]},Tn.uniqWith=function(e,t){return t="function"==typeof t?t:o,e&&e.length?lo(e,o,t):[]},Tn.unset=function(e,t){return null==e||uo(e,t)},Tn.unzip=ri,Tn.unzipWith=oi,Tn.update=function(e,t,n){return null==e?e:co(e,t,go(n))},Tn.updateWith=function(e,t,n,r){return r="function"==typeof r?r:o,null==e?e:co(e,t,go(n),r)},Tn.values=Ll,Tn.valuesIn=function(e){return null==e?[]:Kt(e,Al(e))},Tn.without=ai,Tn.words=Kl,Tn.wrap=function(e,t){return Fi(go(t),e)},Tn.xor=ii,Tn.xorBy=li,Tn.xorWith=ui,Tn.zip=ci,Tn.zipObject=function(e,t){return ho(e||[],t||[],Jn)},Tn.zipObjectDeep=function(e,t){return ho(e||[],t||[],Kr)},Tn.zipWith=si,Tn.entries=$l,Tn.entriesIn=Tl,Tn.extend=bl,Tn.extendWith=xl,iu(Tn,Tn),Tn.add=vu,Tn.attempt=Yl,Tn.camelCase=Dl,Tn.capitalize=Bl,Tn.ceil=yu,Tn.clamp=function(e,t,n){return n===o&&(n=t,t=o),n!==o&&(n=(n=ml(n))==n?n:0),t!==o&&(t=(t=ml(t))==t?t:0),ar(ml(e),t,n)},Tn.clone=function(e){return ir(e,4)},Tn.cloneDeep=function(e){return ir(e,5)},Tn.cloneDeepWith=function(e,t){return ir(e,5,t="function"==typeof t?t:o)},Tn.cloneWith=function(e,t){return ir(e,4,t="function"==typeof t?t:o)},Tn.conformsTo=function(e,t){return null==t||lr(e,t,jl(t))},Tn.deburr=Ul,Tn.defaultTo=function(e,t){return null==e||e!=e?t:e},Tn.divide=bu,Tn.endsWith=function(e,t,n){e=vl(e),t=io(t);var r=e.length,a=n=n===o?r:ar(pl(n),0,r);return(n-=t.length)>=0&&e.slice(n,a)==t},Tn.eq=Li,Tn.escape=function(e){return(e=vl(e))&&G.test(e)?e.replace(q,tn):e},Tn.escapeRegExp=function(e){return(e=vl(e))&&ne.test(e)?e.replace(te,"\\$&"):e},Tn.every=function(e,t,n){var r=Wi(e)?Pt:dr;return n&&va(e,t,n)&&(t=o),r(e,ia(t,3))},Tn.find=mi,Tn.findIndex=Ua,Tn.findKey=function(e,t){return $t(e,ia(t,3),yr)},Tn.findLast=gi,Tn.findLastIndex=Wa,Tn.findLastKey=function(e,t){return $t(e,ia(t,3),br)},Tn.floor=xu,Tn.forEach=vi,Tn.forEachRight=yi,Tn.forIn=function(e,t){return null==e?e:gr(e,ia(t,3),Al)},Tn.forInRight=function(e,t){return null==e?e:vr(e,ia(t,3),Al)},Tn.forOwn=function(e,t){return e&&yr(e,ia(t,3))},Tn.forOwnRight=function(e,t){return e&&br(e,ia(t,3))},Tn.get=kl,Tn.gt=Di,Tn.gte=Bi,Tn.has=function(e,t){return null!=e&&pa(e,t,kr)},Tn.hasIn=Cl,Tn.head=Ha,Tn.identity=nu,Tn.includes=function(e,t,n,r){e=Hi(e)?e:Ll(e),n=n&&!r?pl(n):0;var o=e.length;return n<0&&(n=gn(o+n,0)),il(e)?n<=o&&e.indexOf(t,n)>-1:!!o&&Lt(e,t,n)>-1},Tn.indexOf=function(e,t,n){var r=null==e?0:e.length;if(!r)return-1;var o=null==n?0:pl(n);return o<0&&(o=gn(r+o,0)),Lt(e,t,o)},Tn.inRange=function(e,t,n){return t=dl(t),n===o?(n=t,t=0):n=dl(n),function(e,t,n){return e>=vn(t,n)&&e=-9007199254740991&&e<=f},Tn.isSet=al,Tn.isString=il,Tn.isSymbol=ll,Tn.isTypedArray=ul,Tn.isUndefined=function(e){return e===o},Tn.isWeakMap=function(e){return el(e)&&da(e)==j},Tn.isWeakSet=function(e){return el(e)&&"[object WeakSet]"==Sr(e)},Tn.join=function(e,t){return null==e?"":Vt.call(e,t)},Tn.kebabCase=Wl,Tn.last=Qa,Tn.lastIndexOf=function(e,t,n){var r=null==e?0:e.length;if(!r)return-1;var a=r;return n!==o&&(a=(a=pl(n))<0?gn(r+a,0):vn(a,r-1)),t==t?function(e,t,n){for(var r=n+1;r--;)if(e[r]===t)return r;return r}(e,t,a):Tt(e,Bt,a,!0)},Tn.lowerCase=Vl,Tn.lowerFirst=Hl,Tn.lt=cl,Tn.lte=sl,Tn.max=function(e){return e&&e.length?pr(e,nu,_r):o},Tn.maxBy=function(e,t){return e&&e.length?pr(e,ia(t,2),_r):o},Tn.mean=function(e){return Ut(e,nu)},Tn.meanBy=function(e,t){return Ut(e,ia(t,2))},Tn.min=function(e){return e&&e.length?pr(e,nu,Mr):o},Tn.minBy=function(e,t){return e&&e.length?pr(e,ia(t,2),Mr):o},Tn.stubArray=hu,Tn.stubFalse=mu,Tn.stubObject=function(){return{}},Tn.stubString=function(){return""},Tn.stubTrue=function(){return!0},Tn.multiply=wu,Tn.nth=function(e,t){return e&&e.length?Dr(e,pl(t)):o},Tn.noConflict=function(){return ft._===this&&(ft._=Te),this},Tn.noop=lu,Tn.now=ki,Tn.pad=function(e,t,n){e=vl(e);var r=(t=pl(t))?sn(e):0;if(!t||r>=t)return e;var o=(t-r)/2;return Uo(pt(o),n)+e+Uo(dt(o),n)},Tn.padEnd=function(e,t,n){e=vl(e);var r=(t=pl(t))?sn(e):0;return t&&rt){var r=e;e=t,t=r}if(n||e%1||t%1){var a=xn();return vn(e+a*(t-e+lt("1e-"+((a+"").length-1))),t)}return Hr(e,t)},Tn.reduce=function(e,t,n){var r=Wi(e)?zt:Ht,o=arguments.length<3;return r(e,ia(t,4),n,o,sr)},Tn.reduceRight=function(e,t,n){var r=Wi(e)?Nt:Ht,o=arguments.length<3;return r(e,ia(t,4),n,o,fr)},Tn.repeat=function(e,t,n){return t=(n?va(e,t,n):t===o)?1:pl(t),qr(vl(e),t)},Tn.replace=function(){var e=arguments,t=vl(e[0]);return e.length<3?t:t.replace(e[1],e[2])},Tn.result=function(e,t,n){var r=-1,a=(t=vo(t,e)).length;for(a||(a=1,e=o);++rf)return[];var n=p,r=vn(e,p);t=ia(t),e-=p;for(var o=Zt(r,t);++n=i)return e;var u=n-sn(r);if(u<1)return r;var c=l?bo(l,0,u).join(""):e.slice(0,u);if(a===o)return c+r;if(l&&(u+=c.length-u),ol(a)){if(e.slice(u).search(a)){var s,f=c;for(a.global||(a=ke(a.source,vl(de.exec(a))+"g")),a.lastIndex=0;s=a.exec(f);)var d=s.index;c=c.slice(0,d===o?u:d)}}else if(e.indexOf(io(a),u)!=u){var p=c.lastIndexOf(a);p>-1&&(c=c.slice(0,p))}return c+r},Tn.unescape=function(e){return(e=vl(e))&&Z.test(e)?e.replace(H,pn):e},Tn.uniqueId=function(e){var t=++Ne;return vl(e)+t},Tn.upperCase=Gl,Tn.upperFirst=Ql,Tn.each=vi,Tn.eachRight=yi,Tn.first=Ha,iu(Tn,(gu={},yr(Tn,(function(e,t){ze.call(Tn.prototype,t)||(gu[t]=e)})),gu),{chain:!1}),Tn.VERSION="4.17.21",kt(["bind","bindKey","curry","curryRight","partial","partialRight"],(function(e){Tn[e].placeholder=Tn})),kt(["drop","take"],(function(e,t){Un.prototype[e]=function(n){n=n===o?1:gn(pl(n),0);var r=this.__filtered__&&!t?new Un(this):this.clone();return r.__filtered__?r.__takeCount__=vn(n,r.__takeCount__):r.__views__.push({size:vn(n,p),type:e+(r.__dir__<0?"Right":"")}),r},Un.prototype[e+"Right"]=function(t){return this.reverse()[e](t).reverse()}})),kt(["filter","map","takeWhile"],(function(e,t){var n=t+1,r=1==n||3==n;Un.prototype[e]=function(e){var t=this.clone();return t.__iteratees__.push({iteratee:ia(e,3),type:n}),t.__filtered__=t.__filtered__||r,t}})),kt(["head","last"],(function(e,t){var n="take"+(t?"Right":"");Un.prototype[e]=function(){return this[n](1).value()[0]}})),kt(["initial","tail"],(function(e,t){var n="drop"+(t?"":"Right");Un.prototype[e]=function(){return this.__filtered__?new Un(this):this[n](1)}})),Un.prototype.compact=function(){return this.filter(nu)},Un.prototype.find=function(e){return this.filter(e).head()},Un.prototype.findLast=function(e){return this.reverse().find(e)},Un.prototype.invokeMap=Zr((function(e,t){return"function"==typeof e?new Un(this):this.map((function(n){return Or(n,e,t)}))})),Un.prototype.reject=function(e){return this.filter(Ni(ia(e)))},Un.prototype.slice=function(e,t){e=pl(e);var n=this;return n.__filtered__&&(e>0||t<0)?new Un(n):(e<0?n=n.takeRight(-e):e&&(n=n.drop(e)),t!==o&&(n=(t=pl(t))<0?n.dropRight(-t):n.take(t-e)),n)},Un.prototype.takeRightWhile=function(e){return this.reverse().takeWhile(e).reverse()},Un.prototype.toArray=function(){return this.take(p)},yr(Un.prototype,(function(e,t){var n=/^(?:filter|find|map|reject)|While$/.test(t),r=/^(?:head|last)$/.test(t),a=Tn[r?"take"+("last"==t?"Right":""):t],i=r||/^find/.test(t);a&&(Tn.prototype[t]=function(){var t=this.__wrapped__,l=r?[1]:arguments,u=t instanceof Un,c=l[0],s=u||Wi(t),f=function(e){var t=a.apply(Tn,Rt([e],l));return r&&d?t[0]:t};s&&n&&"function"==typeof c&&1!=c.length&&(u=s=!1);var d=this.__chain__,p=!!this.__actions__.length,h=i&&!d,m=u&&!p;if(!i&&s){t=m?t:new Un(this);var g=e.apply(t,l);return g.__actions__.push({func:di,args:[f],thisArg:o}),new Bn(g,d)}return h&&m?e.apply(this,l):(g=this.thru(f),h?r?g.value()[0]:g.value():g)})})),kt(["pop","push","shift","sort","splice","unshift"],(function(e){var t=Oe[e],n=/^(?:push|sort|unshift)$/.test(e)?"tap":"thru",r=/^(?:pop|shift)$/.test(e);Tn.prototype[e]=function(){var e=arguments;if(r&&!this.__chain__){var o=this.value();return t.apply(Wi(o)?o:[],e)}return this[n]((function(n){return t.apply(Wi(n)?n:[],e)}))}})),yr(Un.prototype,(function(e,t){var n=Tn[t];if(n){var r=n.name+"";ze.call(In,r)||(In[r]=[]),In[r].push({name:t,func:n})}})),In[To(o,2).name]=[{name:"wrapper",func:o}],Un.prototype.clone=function(){var e=new Un(this.__wrapped__);return e.__actions__=Po(this.__actions__),e.__dir__=this.__dir__,e.__filtered__=this.__filtered__,e.__iteratees__=Po(this.__iteratees__),e.__takeCount__=this.__takeCount__,e.__views__=Po(this.__views__),e},Un.prototype.reverse=function(){if(this.__filtered__){var e=new Un(this);e.__dir__=-1,e.__filtered__=!0}else(e=this.clone()).__dir__*=-1;return e},Un.prototype.value=function(){var e=this.__wrapped__.value(),t=this.__dir__,n=Wi(e),r=t<0,o=n?e.length:0,a=function(e,t,n){for(var r=-1,o=n.length;++r=this.__values__.length;return{done:e,value:e?o:this.__values__[this.__index__++]}},Tn.prototype.plant=function(e){for(var t,n=this;n instanceof Dn;){var r=Ta(n);r.__index__=0,r.__values__=o,t?a.__wrapped__=r:t=r;var a=r;n=n.__wrapped__}return a.__wrapped__=e,t},Tn.prototype.reverse=function(){var e=this.__wrapped__;if(e instanceof Un){var t=e;return this.__actions__.length&&(t=new Un(this)),(t=t.reverse()).__actions__.push({func:di,args:[Ja],thisArg:o}),new Bn(t,this.__chain__)}return this.thru(Ja)},Tn.prototype.toJSON=Tn.prototype.valueOf=Tn.prototype.value=function(){return fo(this.__wrapped__,this.__actions__)},Tn.prototype.first=Tn.prototype.head,Qe&&(Tn.prototype[Qe]=function(){return this}),Tn}();ft._=hn,(r=function(){return hn}.call(t,n,t,e))===o||(e.exports=r)}.call(this)},799:(e,t,n)=>{"use strict";var r=n(526),o=n(851);function a(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n