diff --git a/README.md b/README.md index f4e71c65..52354d61 100644 --- a/README.md +++ b/README.md @@ -32,43 +32,11 @@ echo '{"fs": "./foobar", "ports": ["3333"]}' | node js-bazel/myTests/ClassicalReact/ClassicalComponent.esbuild-puppeteer.test.mjs -[ - "./src/app.reduxToolkit.test.ts", - "node", - [] - ], - [ - "./src/app.redux.test.ts", - "node", - [] - ], - [ - "./src/ClassicalComponent/react-test-renderer/web.test.tsx", - "web", - [] - ], - [ - "./src/ClassicalComponent/react-test-renderer/node.test.tsx", - "node", - [] - ], - [ - "./src/ClassicalComponent/react-dom/client.web.test.tsx", - "web", - [] - ], - [ - "./src/ClassicalComponent/react-dom/server.node.test.tsx", - "node", - [] - ], - [ - "./src/ReactStateAndHook.test.tsx", - "node", - [] - ], + + + [ "./src/Rectangle/Rectangle.test.electron.ts", "web", diff --git a/docs/Report.js b/docs/Report.js index fcbaf4d0..a85815c8 100644 --- a/docs/Report.js +++ b/docs/Report.js @@ -37338,7 +37338,7 @@ }, []); (0, import_react44.useEffect)(() => { const importTests = async () => { - const x = await fetch("./tests.json"); + const x = await fetch("./testeranto.json"); const y = await x.json(); console.log("imported tests", y); setTests(y); diff --git a/docs/electron.log b/docs/electron.log new file mode 100644 index 00000000..096e497d --- /dev/null +++ b/docs/electron.log @@ -0,0 +1,112 @@ +$ /Users/adam/Code/kokomoBay/node_modules/.bin/electron node_modules/testeranto/dist/common/electron.js +running all the tests once initially +launchWeb /Users/adam/Code/kokomoBay/docs/web/src/LoginPage/react/web.test.tsx +launchNode /Users/adam/Code/kokomoBay/docs/node/src/LoginPage/react/node.test.mjsx {"scheduled":true,"name":"/Users/adam/Code/kokomoBay/docs/node/src/LoginPage/react/node.test.tsx","ports":[],"fs":"/Users/adam/Code/kokomoBay/docs/node/src/LoginPage/react/node.test.tsx"} +launchWeb /Users/adam/Code/kokomoBay/docs/web/src/LoginPage/react-test-renderer/web.test.tsx +launchNode /Users/adam/Code/kokomoBay/docs/node/src/LoginPage/react-test-renderer/node.test.mjsx {"scheduled":true,"name":"/Users/adam/Code/kokomoBay/docs/node/src/LoginPage/react-test-renderer/node.test.tsx","ports":[],"fs":"/Users/adam/Code/kokomoBay/docs/node/src/LoginPage/react-test-renderer/node.test.tsx"} +launchNode /Users/adam/Code/kokomoBay/docs/node/src/ReactStateAndHook.test.mjsx {"scheduled":true,"name":"/Users/adam/Code/kokomoBay/docs/node/src/ReactStateAndHook.test.tsx","ports":[],"fs":"/Users/adam/Code/kokomoBay/docs/node/src/ReactStateAndHook.test.tsx"} +launchNode /Users/adam/Code/kokomoBay/docs/node/src/app.reduxToolkit.test.mjs {"scheduled":true,"name":"/Users/adam/Code/kokomoBay/docs/node/src/app.reduxToolkit.test.ts","ports":[],"fs":"/Users/adam/Code/kokomoBay/docs/node/src/app.reduxToolkit.test.ts"} +launchNode /Users/adam/Code/kokomoBay/docs/node/src/app.redux.test.mjs {"scheduled":true,"name":"/Users/adam/Code/kokomoBay/docs/node/src/app.redux.test.ts","ports":[],"fs":"/Users/adam/Code/kokomoBay/docs/node/src/app.redux.test.ts"} +launchWeb /Users/adam/Code/kokomoBay/docs/web/src/Rectangle/Rectangle.test.electron.ts +launchNode /Users/adam/Code/kokomoBay/docs/node/src/Rectangle/Rectangle.test.node.mjs {"scheduled":true,"name":"/Users/adam/Code/kokomoBay/docs/node/src/Rectangle/Rectangle.test.node.ts","ports":[],"fs":"/Users/adam/Code/kokomoBay/docs/node/src/Rectangle/Rectangle.test.node.ts"} +ready and watching for changes... /Users/adam/Code/kokomoBay/docs +node process ended with: 1 +node process ended with: 1 +node process ended with: 1 +rename web/src/Rectangle/Rectangle.test.electron.ts +rename web/src/Rectangle/Rectangle.test.electron.ts/tests.json +connected! true +testResourceConfiguration { + "scheduled": true, + "name": "/Users/adam/Code/kokomoBay/docs/node/src/app.reduxToolkit.test.ts", + "ports": [], + "fs": "/Users/adam/Code/kokomoBay/docs/node/src/app.reduxToolkit.test.ts" +} +exiting gracefully with 5 failures. +connected! true +testResourceConfiguration { + "scheduled": true, + "name": "/Users/adam/Code/kokomoBay/docs/node/src/Rectangle/Rectangle.test.node.ts", + "ports": [], + "fs": "/Users/adam/Code/kokomoBay/docs/node/src/Rectangle/Rectangle.test.node.ts" +} +from child /dist/web/src/ClassicalComponent/test.html +launchWebSecondary /Users/adam/Code/kokomoBay/dist/web/src/ClassicalComponent/test.html +exiting gracefully with 4 failures. +rename node/src/app.reduxToolkit.test.ts +rename node/src/app.reduxToolkit.test.ts/tests.json +rename node/src/app.reduxToolkit.test.ts/results.json +rename node/src/app.reduxToolkit.test.ts/log.txt +rename web/src/Rectangle/Rectangle.test.electron.ts/results.json +rename web/src/LoginPage/react/web.test.tsx +rename web/src/Rectangle/Rectangle.test.electron.ts/log.txt +rename web/src/LoginPage/react/web.test.tsx/tests.json +rename web/src/LoginPage/react/web.test.tsx/afterAll4-default +rename web/src/Rectangle/Rectangle.test.electron.ts/afterAll4-Default +rename web/src/Rectangle/Rectangle.test.electron.ts/manifest +rename web/src/Rectangle/Rectangle.test.electron.ts/afterAll4-Default/afterAll.png +rename node/src/Rectangle/Rectangle.test.node.ts +rename node/src/Rectangle/Rectangle.test.node.ts/tests.json +rename node/src/Rectangle/Rectangle.test.node.ts/results.json +rename node/src/Rectangle/Rectangle.test.node.ts/log.txt +connected! true +testResourceConfiguration { + "scheduled": true, + "name": "/Users/adam/Code/kokomoBay/docs/node/src/app.redux.test.ts", + "ports": [], + "fs": "/Users/adam/Code/kokomoBay/docs/node/src/app.redux.test.ts" +} +rename web/src/Rectangle/Rectangle.test.electron.ts/manifest +rename web/src/Rectangle/Rectangle.test.electron.ts/afterAll4-Default/afterAll.png +rename web/src/LoginPage/react-test-renderer/web.test.tsx +rename web/src/LoginPage/react-test-renderer/web.test.tsx/tests.json +rename web/src/LoginPage/react-test-renderer/web.test.tsx/results.json +rename web/src/LoginPage/react-test-renderer/web.test.tsx/log.txt +rename web/src/LoginPage/react/web.test.tsx/results.json +rename web/src/LoginPage/react/web.test.tsx/log.txt +rename web/src/LoginPage/react/web.test.tsx/manifest +rename web/src/LoginPage/react/web.test.tsx/afterAll4-default/utils +rename node/src/app.redux.test.ts +rename node/src/app.redux.test.ts/tests.json +exiting gracefully with 0 failures. +rename node/src/app.redux.test.ts/results.json +rename web/src/LoginPage/react/web.test.tsx/manifest +rename web/src/LoginPage/react/web.test.tsx/afterAll4-default/utils +rename node/src/app.redux.test.ts/log.txt +rename web/src/LoginPage/react/web.test.tsx/log.txt +page CDPPage { + eventsMap: Map(0) {}, + emitter: { + all: Map(0) {}, + on: [Function: on], + off: [Function: off], + emit: [Function: emit] + } +} +page CDPPage { + eventsMap: Map(0) {}, + emitter: { + all: Map(0) {}, + on: [Function: on], + off: [Function: off], + emit: [Function: emit] + } +} +page CDPPage { + eventsMap: Map(0) {}, + emitter: { + all: Map(0) {}, + on: [Function: on], + off: [Function: off], + emit: [Function: emit] + } +} +page CDPPage { + eventsMap: Map(0) {}, + emitter: { + all: Map(0) {}, + on: [Function: on], + off: [Function: off], + emit: [Function: emit] + } +} diff --git a/docs/node/chunk-562JFTRV.mjs b/docs/node/chunk-562JFTRV.mjs new file mode 100644 index 00000000..7d31ca6b --- /dev/null +++ b/docs/node/chunk-562JFTRV.mjs @@ -0,0 +1,6726 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + __commonJS, + __toESM, + init_cjs_shim +} from "./chunk-BJRHXCMP.mjs"; + +// node_modules/immer/dist/immer.cjs.production.min.js +var require_immer_cjs_production_min = __commonJS({ + "node_modules/immer/dist/immer.cjs.production.min.js"(exports) { + init_cjs_shim(); + function n(n2) { + for (var r2 = arguments.length, t2 = Array(r2 > 1 ? r2 - 1 : 0), e2 = 1; e2 < r2; e2++) + t2[e2 - 1] = arguments[e2]; + throw Error("[Immer] minified error nr: " + n2 + (t2.length ? " " + t2.map(function(n3) { + return "'" + n3 + "'"; + }).join(",") : "") + ". Find the full error at: https://bit.ly/3cXEKWf"); + } + function r(n2) { + return !!n2 && !!n2[H]; + } + function t(n2) { + var r2; + return !!n2 && (function(n3) { + if (!n3 || "object" != typeof n3) + return false; + var r3 = Object.getPrototypeOf(n3); + if (null === r3) + return true; + var t2 = Object.hasOwnProperty.call(r3, "constructor") && r3.constructor; + return t2 === Object || "function" == typeof t2 && Function.toString.call(t2) === Q; + }(n2) || Array.isArray(n2) || !!n2[G] || !!(null === (r2 = n2.constructor) || void 0 === r2 ? void 0 : r2[G]) || c(n2) || v(n2)); + } + function e(n2, r2, t2) { + void 0 === t2 && (t2 = false), 0 === i(n2) ? (t2 ? Object.keys : T)(n2).forEach(function(e2) { + t2 && "symbol" == typeof e2 || r2(e2, n2[e2], n2); + }) : n2.forEach(function(t3, e2) { + return r2(e2, t3, n2); + }); + } + function i(n2) { + var r2 = n2[H]; + return r2 ? r2.t > 3 ? r2.t - 4 : r2.t : Array.isArray(n2) ? 1 : c(n2) ? 2 : v(n2) ? 3 : 0; + } + function u(n2, r2) { + return 2 === i(n2) ? n2.has(r2) : Object.prototype.hasOwnProperty.call(n2, r2); + } + function o(n2, r2) { + return 2 === i(n2) ? n2.get(r2) : n2[r2]; + } + function f(n2, r2, t2) { + var e2 = i(n2); + 2 === e2 ? n2.set(r2, t2) : 3 === e2 ? n2.add(t2) : n2[r2] = t2; + } + function a(n2, r2) { + return n2 === r2 ? 0 !== n2 || 1 / n2 == 1 / r2 : n2 != n2 && r2 != r2; + } + function c(n2) { + return W && n2 instanceof Map; + } + function v(n2) { + return X && n2 instanceof Set; + } + function s(n2) { + return n2.i || n2.u; + } + function p(n2) { + if (Array.isArray(n2)) + return Array.prototype.slice.call(n2); + var r2 = U(n2); + delete r2[H]; + for (var t2 = T(r2), e2 = 0; e2 < t2.length; e2++) { + var i2 = t2[e2], u2 = r2[i2]; + false === u2.writable && (u2.writable = true, u2.configurable = true), (u2.get || u2.set) && (r2[i2] = { configurable: true, writable: true, enumerable: u2.enumerable, value: n2[i2] }); + } + return Object.create(Object.getPrototypeOf(n2), r2); + } + function l(n2, u2) { + return void 0 === u2 && (u2 = false), h(n2) || r(n2) || !t(n2) || (i(n2) > 1 && (n2.set = n2.add = n2.clear = n2.delete = d), Object.freeze(n2), u2 && e(n2, function(n3, r2) { + return l(r2, true); + }, true)), n2; + } + function d() { + n(2); + } + function h(n2) { + return null == n2 || "object" != typeof n2 || Object.isFrozen(n2); + } + function y(r2) { + var t2 = V[r2]; + return t2 || n(18, r2), t2; + } + function _(n2, r2) { + V[n2] || (V[n2] = r2); + } + function b() { + return I; + } + function m(n2, r2) { + r2 && (y("Patches"), n2.o = [], n2.v = [], n2.s = r2); + } + function j(n2) { + O(n2), n2.p.forEach(w), n2.p = null; + } + function O(n2) { + n2 === I && (I = n2.l); + } + function x(n2) { + return I = { p: [], l: I, h: n2, _: true, m: 0 }; + } + function w(n2) { + var r2 = n2[H]; + 0 === r2.t || 1 === r2.t ? r2.j() : r2.O = true; + } + function S(r2, e2) { + e2.m = e2.p.length; + var i2 = e2.p[0], u2 = void 0 !== r2 && r2 !== i2; + return e2.h.S || y("ES5").P(e2, r2, u2), u2 ? (i2[H].g && (j(e2), n(4)), t(r2) && (r2 = P(e2, r2), e2.l || M(e2, r2)), e2.o && y("Patches").M(i2[H].u, r2, e2.o, e2.v)) : r2 = P(e2, i2, []), j(e2), e2.o && e2.s(e2.o, e2.v), r2 !== B ? r2 : void 0; + } + function P(n2, r2, t2) { + if (h(r2)) + return r2; + var i2 = r2[H]; + if (!i2) + return e(r2, function(e2, u3) { + return g(n2, i2, r2, e2, u3, t2); + }, true), r2; + if (i2.A !== n2) + return r2; + if (!i2.g) + return M(n2, i2.u, true), i2.u; + if (!i2.R) { + i2.R = true, i2.A.m--; + var u2 = 4 === i2.t || 5 === i2.t ? i2.i = p(i2.k) : i2.i, o2 = u2, f2 = false; + 3 === i2.t && (o2 = new Set(u2), u2.clear(), f2 = true), e(o2, function(r3, e2) { + return g(n2, i2, u2, r3, e2, t2, f2); + }), M(n2, u2, false), t2 && n2.o && y("Patches").F(i2, t2, n2.o, n2.v); + } + return i2.i; + } + function g(n2, e2, i2, o2, a2, c2, v2) { + if (r(a2)) { + var s2 = P(n2, a2, c2 && e2 && 3 !== e2.t && !u(e2.N, o2) ? c2.concat(o2) : void 0); + if (f(i2, o2, s2), !r(s2)) + return; + n2._ = false; + } else + v2 && i2.add(a2); + if (t(a2) && !h(a2)) { + if (!n2.h.D && n2.m < 1) + return; + P(n2, a2), e2 && e2.A.l || M(n2, a2); + } + } + function M(n2, r2, t2) { + void 0 === t2 && (t2 = false), !n2.l && n2.h.D && n2._ && l(r2, t2); + } + function A(n2, r2) { + var t2 = n2[H]; + return (t2 ? s(t2) : n2)[r2]; + } + function z(n2, r2) { + if (r2 in n2) + for (var t2 = Object.getPrototypeOf(n2); t2; ) { + var e2 = Object.getOwnPropertyDescriptor(t2, r2); + if (e2) + return e2; + t2 = Object.getPrototypeOf(t2); + } + } + function E(n2) { + n2.g || (n2.g = true, n2.l && E(n2.l)); + } + function R(n2) { + n2.i || (n2.i = p(n2.u)); + } + function k(n2, r2, t2) { + var e2 = c(r2) ? y("MapSet").K(r2, t2) : v(r2) ? y("MapSet").$(r2, t2) : n2.S ? function(n3, r3) { + var t3 = Array.isArray(n3), e3 = { t: t3 ? 1 : 0, A: r3 ? r3.A : b(), g: false, R: false, N: {}, l: r3, u: n3, k: null, i: null, j: null, C: false }, i2 = e3, u2 = Y; + t3 && (i2 = [e3], u2 = Z); + var o2 = Proxy.revocable(i2, u2), f2 = o2.revoke, a2 = o2.proxy; + return e3.k = a2, e3.j = f2, a2; + }(r2, t2) : y("ES5").I(r2, t2); + return (t2 ? t2.A : b()).p.push(e2), e2; + } + function F(u2) { + return r(u2) || n(22, u2), function n2(r2) { + if (!t(r2)) + return r2; + var u3, a2 = r2[H], c2 = i(r2); + if (a2) { + if (!a2.g && (a2.t < 4 || !y("ES5").J(a2))) + return a2.u; + a2.R = true, u3 = N(r2, c2), a2.R = false; + } else + u3 = N(r2, c2); + return e(u3, function(r3, t2) { + a2 && o(a2.u, r3) === t2 || f(u3, r3, n2(t2)); + }), 3 === c2 ? new Set(u3) : u3; + }(u2); + } + function N(n2, r2) { + switch (r2) { + case 2: + return new Map(n2); + case 3: + return Array.from(n2); + } + return p(n2); + } + function D() { + function n2(n3, r2) { + var t3 = f2[n3]; + return t3 ? t3.enumerable = r2 : f2[n3] = t3 = { configurable: true, enumerable: r2, get: function() { + return Y.get(this[H], n3); + }, set: function(r3) { + Y.set(this[H], n3, r3); + } }, t3; + } + function t2(n3) { + for (var r2 = n3.length - 1; r2 >= 0; r2--) { + var t3 = n3[r2][H]; + if (!t3.g) + switch (t3.t) { + case 5: + o2(t3) && E(t3); + break; + case 4: + i2(t3) && E(t3); + } + } + } + function i2(n3) { + for (var r2 = n3.u, t3 = n3.k, e2 = T(t3), i3 = e2.length - 1; i3 >= 0; i3--) { + var o3 = e2[i3]; + if (o3 !== H) { + var f3 = r2[o3]; + if (void 0 === f3 && !u(r2, o3)) + return true; + var c2 = t3[o3], v2 = c2 && c2[H]; + if (v2 ? v2.u !== f3 : !a(c2, f3)) + return true; + } + } + var s2 = !!r2[H]; + return e2.length !== T(r2).length + (s2 ? 0 : 1); + } + function o2(n3) { + var r2 = n3.k; + if (r2.length !== n3.u.length) + return true; + var t3 = Object.getOwnPropertyDescriptor(r2, r2.length - 1); + if (t3 && !t3.get) + return true; + for (var e2 = 0; e2 < r2.length; e2++) + if (!r2.hasOwnProperty(e2)) + return true; + return false; + } + var f2 = {}; + _("ES5", { I: function(r2, t3) { + var e2 = Array.isArray(r2), i3 = function(r3, t4) { + if (r3) { + for (var e3 = Array(t4.length), i4 = 0; i4 < t4.length; i4++) + Object.defineProperty(e3, "" + i4, n2(i4, true)); + return e3; + } + var u3 = U(t4); + delete u3[H]; + for (var o3 = T(u3), f3 = 0; f3 < o3.length; f3++) { + var a2 = o3[f3]; + u3[a2] = n2(a2, r3 || !!u3[a2].enumerable); + } + return Object.create(Object.getPrototypeOf(t4), u3); + }(e2, r2), u2 = { t: e2 ? 5 : 4, A: t3 ? t3.A : b(), g: false, R: false, N: {}, l: t3, u: r2, k: i3, i: null, O: false, C: false }; + return Object.defineProperty(i3, H, { value: u2, writable: true }), i3; + }, P: function(n3, i3, f3) { + f3 ? r(i3) && i3[H].A === n3 && t2(n3.p) : (n3.o && function n4(r2) { + if (r2 && "object" == typeof r2) { + var t3 = r2[H]; + if (t3) { + var i4 = t3.u, f4 = t3.k, a2 = t3.N, c2 = t3.t; + if (4 === c2) + e(f4, function(r3) { + r3 !== H && (void 0 !== i4[r3] || u(i4, r3) ? a2[r3] || n4(f4[r3]) : (a2[r3] = true, E(t3))); + }), e(i4, function(n5) { + void 0 !== f4[n5] || u(f4, n5) || (a2[n5] = false, E(t3)); + }); + else if (5 === c2) { + if (o2(t3) && (E(t3), a2.length = true), f4.length < i4.length) + for (var v2 = f4.length; v2 < i4.length; v2++) + a2[v2] = false; + else + for (var s2 = i4.length; s2 < f4.length; s2++) + a2[s2] = true; + for (var p2 = Math.min(f4.length, i4.length), l2 = 0; l2 < p2; l2++) + f4.hasOwnProperty(l2) || (a2[l2] = true), void 0 === a2[l2] && n4(f4[l2]); + } + } + } + }(n3.p[0]), t2(n3.p)); + }, J: function(n3) { + return 4 === n3.t ? i2(n3) : o2(n3); + } }); + } + function K() { + function f2(n2) { + if (!t(n2)) + return n2; + if (Array.isArray(n2)) + return n2.map(f2); + if (c(n2)) + return new Map(Array.from(n2.entries()).map(function(n3) { + return [n3[0], f2(n3[1])]; + })); + if (v(n2)) + return new Set(Array.from(n2).map(f2)); + var r2 = Object.create(Object.getPrototypeOf(n2)); + for (var e2 in n2) + r2[e2] = f2(n2[e2]); + return u(n2, G) && (r2[G] = n2[G]), r2; + } + function a2(n2) { + return r(n2) ? f2(n2) : n2; + } + var s2 = "add"; + _("Patches", { W: function(r2, t2) { + return t2.forEach(function(t3) { + for (var e2 = t3.path, u2 = t3.op, a3 = r2, c2 = 0; c2 < e2.length - 1; c2++) { + var v2 = i(a3), p2 = e2[c2]; + "string" != typeof p2 && "number" != typeof p2 && (p2 = "" + p2), 0 !== v2 && 1 !== v2 || "__proto__" !== p2 && "constructor" !== p2 || n(24), "function" == typeof a3 && "prototype" === p2 && n(24), "object" != typeof (a3 = o(a3, p2)) && n(15, e2.join("/")); + } + var l2 = i(a3), d2 = f2(t3.value), h2 = e2[e2.length - 1]; + switch (u2) { + case "replace": + switch (l2) { + case 2: + return a3.set(h2, d2); + case 3: + n(16); + default: + return a3[h2] = d2; + } + case s2: + switch (l2) { + case 1: + return "-" === h2 ? a3.push(d2) : a3.splice(h2, 0, d2); + case 2: + return a3.set(h2, d2); + case 3: + return a3.add(d2); + default: + return a3[h2] = d2; + } + case "remove": + switch (l2) { + case 1: + return a3.splice(h2, 1); + case 2: + return a3.delete(h2); + case 3: + return a3.delete(t3.value); + default: + return delete a3[h2]; + } + default: + n(17, u2); + } + }), r2; + }, F: function(n2, r2, t2, i2) { + switch (n2.t) { + case 0: + case 4: + case 2: + return function(n3, r3, t3, i3) { + var f3 = n3.u, c2 = n3.i; + e(n3.N, function(n4, e2) { + var v2 = o(f3, n4), p2 = o(c2, n4), l2 = e2 ? u(f3, n4) ? "replace" : s2 : "remove"; + if (v2 !== p2 || "replace" !== l2) { + var d2 = r3.concat(n4); + t3.push("remove" === l2 ? { op: l2, path: d2 } : { op: l2, path: d2, value: p2 }), i3.push(l2 === s2 ? { op: "remove", path: d2 } : "remove" === l2 ? { op: s2, path: d2, value: a2(v2) } : { op: "replace", path: d2, value: a2(v2) }); + } + }); + }(n2, r2, t2, i2); + case 5: + case 1: + return function(n3, r3, t3, e2) { + var i3 = n3.u, u2 = n3.N, o2 = n3.i; + if (o2.length < i3.length) { + var f3 = [o2, i3]; + i3 = f3[0], o2 = f3[1]; + var c2 = [e2, t3]; + t3 = c2[0], e2 = c2[1]; + } + for (var v2 = 0; v2 < i3.length; v2++) + if (u2[v2] && o2[v2] !== i3[v2]) { + var p2 = r3.concat([v2]); + t3.push({ op: "replace", path: p2, value: a2(o2[v2]) }), e2.push({ op: "replace", path: p2, value: a2(i3[v2]) }); + } + for (var l2 = i3.length; l2 < o2.length; l2++) { + var d2 = r3.concat([l2]); + t3.push({ op: s2, path: d2, value: a2(o2[l2]) }); + } + i3.length < o2.length && e2.push({ op: "replace", path: r3.concat(["length"]), value: i3.length }); + }(n2, r2, t2, i2); + case 3: + return function(n3, r3, t3, e2) { + var i3 = n3.u, u2 = n3.i, o2 = 0; + i3.forEach(function(n4) { + if (!u2.has(n4)) { + var i4 = r3.concat([o2]); + t3.push({ op: "remove", path: i4, value: n4 }), e2.unshift({ op: s2, path: i4, value: n4 }); + } + o2++; + }), o2 = 0, u2.forEach(function(n4) { + if (!i3.has(n4)) { + var u3 = r3.concat([o2]); + t3.push({ op: s2, path: u3, value: n4 }), e2.unshift({ op: "remove", path: u3, value: n4 }); + } + o2++; + }); + }(n2, r2, t2, i2); + } + }, M: function(n2, r2, t2, e2) { + t2.push({ op: "replace", path: [], value: r2 === B ? void 0 : r2 }), e2.push({ op: "replace", path: [], value: n2 }); + } }); + } + function $() { + function r2(n2, r3) { + function t2() { + this.constructor = n2; + } + f2(n2, r3), n2.prototype = (t2.prototype = r3.prototype, new t2()); + } + function i2(n2) { + n2.i || (n2.N = /* @__PURE__ */ new Map(), n2.i = new Map(n2.u)); + } + function u2(n2) { + n2.i || (n2.i = /* @__PURE__ */ new Set(), n2.u.forEach(function(r3) { + if (t(r3)) { + var e2 = k(n2.A.h, r3, n2); + n2.p.set(r3, e2), n2.i.add(e2); + } else + n2.i.add(r3); + })); + } + function o2(r3) { + r3.O && n(3, JSON.stringify(s(r3))); + } + var f2 = function(n2, r3) { + return (f2 = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(n3, r4) { + n3.__proto__ = r4; + } || function(n3, r4) { + for (var t2 in r4) + r4.hasOwnProperty(t2) && (n3[t2] = r4[t2]); + })(n2, r3); + }, a2 = function() { + function n2(n3, r3) { + return this[H] = { t: 2, l: r3, A: r3 ? r3.A : b(), g: false, R: false, i: void 0, N: void 0, u: n3, k: this, C: false, O: false }, this; + } + r2(n2, Map); + var u3 = n2.prototype; + return Object.defineProperty(u3, "size", { get: function() { + return s(this[H]).size; + } }), u3.has = function(n3) { + return s(this[H]).has(n3); + }, u3.set = function(n3, r3) { + var t2 = this[H]; + return o2(t2), s(t2).has(n3) && s(t2).get(n3) === r3 || (i2(t2), E(t2), t2.N.set(n3, true), t2.i.set(n3, r3), t2.N.set(n3, true)), this; + }, u3.delete = function(n3) { + if (!this.has(n3)) + return false; + var r3 = this[H]; + return o2(r3), i2(r3), E(r3), r3.u.has(n3) ? r3.N.set(n3, false) : r3.N.delete(n3), r3.i.delete(n3), true; + }, u3.clear = function() { + var n3 = this[H]; + o2(n3), s(n3).size && (i2(n3), E(n3), n3.N = /* @__PURE__ */ new Map(), e(n3.u, function(r3) { + n3.N.set(r3, false); + }), n3.i.clear()); + }, u3.forEach = function(n3, r3) { + var t2 = this; + s(this[H]).forEach(function(e2, i3) { + n3.call(r3, t2.get(i3), i3, t2); + }); + }, u3.get = function(n3) { + var r3 = this[H]; + o2(r3); + var e2 = s(r3).get(n3); + if (r3.R || !t(e2)) + return e2; + if (e2 !== r3.u.get(n3)) + return e2; + var u4 = k(r3.A.h, e2, r3); + return i2(r3), r3.i.set(n3, u4), u4; + }, u3.keys = function() { + return s(this[H]).keys(); + }, u3.values = function() { + var n3, r3 = this, t2 = this.keys(); + return (n3 = {})[L] = function() { + return r3.values(); + }, n3.next = function() { + var n4 = t2.next(); + return n4.done ? n4 : { done: false, value: r3.get(n4.value) }; + }, n3; + }, u3.entries = function() { + var n3, r3 = this, t2 = this.keys(); + return (n3 = {})[L] = function() { + return r3.entries(); + }, n3.next = function() { + var n4 = t2.next(); + if (n4.done) + return n4; + var e2 = r3.get(n4.value); + return { done: false, value: [n4.value, e2] }; + }, n3; + }, u3[L] = function() { + return this.entries(); + }, n2; + }(), c2 = function() { + function n2(n3, r3) { + return this[H] = { t: 3, l: r3, A: r3 ? r3.A : b(), g: false, R: false, i: void 0, u: n3, k: this, p: /* @__PURE__ */ new Map(), O: false, C: false }, this; + } + r2(n2, Set); + var t2 = n2.prototype; + return Object.defineProperty(t2, "size", { get: function() { + return s(this[H]).size; + } }), t2.has = function(n3) { + var r3 = this[H]; + return o2(r3), r3.i ? !!r3.i.has(n3) || !(!r3.p.has(n3) || !r3.i.has(r3.p.get(n3))) : r3.u.has(n3); + }, t2.add = function(n3) { + var r3 = this[H]; + return o2(r3), this.has(n3) || (u2(r3), E(r3), r3.i.add(n3)), this; + }, t2.delete = function(n3) { + if (!this.has(n3)) + return false; + var r3 = this[H]; + return o2(r3), u2(r3), E(r3), r3.i.delete(n3) || !!r3.p.has(n3) && r3.i.delete(r3.p.get(n3)); + }, t2.clear = function() { + var n3 = this[H]; + o2(n3), s(n3).size && (u2(n3), E(n3), n3.i.clear()); + }, t2.values = function() { + var n3 = this[H]; + return o2(n3), u2(n3), n3.i.values(); + }, t2.entries = function() { + var n3 = this[H]; + return o2(n3), u2(n3), n3.i.entries(); + }, t2.keys = function() { + return this.values(); + }, t2[L] = function() { + return this.values(); + }, t2.forEach = function(n3, r3) { + for (var t3 = this.values(), e2 = t3.next(); !e2.done; ) + n3.call(r3, e2.value, e2.value, this), e2 = t3.next(); + }, n2; + }(); + _("MapSet", { K: function(n2, r3) { + return new a2(n2, r3); + }, $: function(n2, r3) { + return new c2(n2, r3); + } }); + } + var C; + Object.defineProperty(exports, "__esModule", { value: true }); + var I; + var J = "undefined" != typeof Symbol && "symbol" == typeof Symbol("x"); + var W = "undefined" != typeof Map; + var X = "undefined" != typeof Set; + var q = "undefined" != typeof Proxy && void 0 !== Proxy.revocable && "undefined" != typeof Reflect; + var B = J ? Symbol.for("immer-nothing") : ((C = {})["immer-nothing"] = true, C); + var G = J ? Symbol.for("immer-draftable") : "__$immer_draftable"; + var H = J ? Symbol.for("immer-state") : "__$immer_state"; + var L = "undefined" != typeof Symbol && Symbol.iterator || "@@iterator"; + var Q = "" + Object.prototype.constructor; + var T = "undefined" != typeof Reflect && Reflect.ownKeys ? Reflect.ownKeys : void 0 !== Object.getOwnPropertySymbols ? function(n2) { + return Object.getOwnPropertyNames(n2).concat(Object.getOwnPropertySymbols(n2)); + } : Object.getOwnPropertyNames; + var U = Object.getOwnPropertyDescriptors || function(n2) { + var r2 = {}; + return T(n2).forEach(function(t2) { + r2[t2] = Object.getOwnPropertyDescriptor(n2, t2); + }), r2; + }; + var V = {}; + var Y = { get: function(n2, r2) { + if (r2 === H) + return n2; + var e2 = s(n2); + if (!u(e2, r2)) + return function(n3, r3, t2) { + var e3, i3 = z(r3, t2); + return i3 ? "value" in i3 ? i3.value : null === (e3 = i3.get) || void 0 === e3 ? void 0 : e3.call(n3.k) : void 0; + }(n2, e2, r2); + var i2 = e2[r2]; + return n2.R || !t(i2) ? i2 : i2 === A(n2.u, r2) ? (R(n2), n2.i[r2] = k(n2.A.h, i2, n2)) : i2; + }, has: function(n2, r2) { + return r2 in s(n2); + }, ownKeys: function(n2) { + return Reflect.ownKeys(s(n2)); + }, set: function(n2, r2, t2) { + var e2 = z(s(n2), r2); + if (null == e2 ? void 0 : e2.set) + return e2.set.call(n2.k, t2), true; + if (!n2.g) { + var i2 = A(s(n2), r2), o2 = null == i2 ? void 0 : i2[H]; + if (o2 && o2.u === t2) + return n2.i[r2] = t2, n2.N[r2] = false, true; + if (a(t2, i2) && (void 0 !== t2 || u(n2.u, r2))) + return true; + R(n2), E(n2); + } + return n2.i[r2] === t2 && (void 0 !== t2 || r2 in n2.i) || Number.isNaN(t2) && Number.isNaN(n2.i[r2]) || (n2.i[r2] = t2, n2.N[r2] = true), true; + }, deleteProperty: function(n2, r2) { + return void 0 !== A(n2.u, r2) || r2 in n2.u ? (n2.N[r2] = false, R(n2), E(n2)) : delete n2.N[r2], n2.i && delete n2.i[r2], true; + }, getOwnPropertyDescriptor: function(n2, r2) { + var t2 = s(n2), e2 = Reflect.getOwnPropertyDescriptor(t2, r2); + return e2 ? { writable: true, configurable: 1 !== n2.t || "length" !== r2, enumerable: e2.enumerable, value: t2[r2] } : e2; + }, defineProperty: function() { + n(11); + }, getPrototypeOf: function(n2) { + return Object.getPrototypeOf(n2.u); + }, setPrototypeOf: function() { + n(12); + } }; + var Z = {}; + e(Y, function(n2, r2) { + Z[n2] = function() { + return arguments[0] = arguments[0][0], r2.apply(this, arguments); + }; + }), Z.deleteProperty = function(n2, r2) { + return Z.set.call(this, n2, r2, void 0); + }, Z.set = function(n2, r2, t2) { + return Y.set.call(this, n2[0], r2, t2, n2[0]); + }; + var nn = function() { + function e2(r2) { + var e3 = this; + this.S = q, this.D = true, this.produce = function(r3, i3, u2) { + if ("function" == typeof r3 && "function" != typeof i3) { + var o2 = i3; + i3 = r3; + var f2 = e3; + return function(n2) { + var r4 = this; + void 0 === n2 && (n2 = o2); + for (var t2 = arguments.length, e4 = Array(t2 > 1 ? t2 - 1 : 0), u3 = 1; u3 < t2; u3++) + e4[u3 - 1] = arguments[u3]; + return f2.produce(n2, function(n3) { + var t3; + return (t3 = i3).call.apply(t3, [r4, n3].concat(e4)); + }); + }; + } + var a2; + if ("function" != typeof i3 && n(6), void 0 !== u2 && "function" != typeof u2 && n(7), t(r3)) { + var c2 = x(e3), v2 = k(e3, r3, void 0), s2 = true; + try { + a2 = i3(v2), s2 = false; + } finally { + s2 ? j(c2) : O(c2); + } + return "undefined" != typeof Promise && a2 instanceof Promise ? a2.then(function(n2) { + return m(c2, u2), S(n2, c2); + }, function(n2) { + throw j(c2), n2; + }) : (m(c2, u2), S(a2, c2)); + } + if (!r3 || "object" != typeof r3) { + if (void 0 === (a2 = i3(r3)) && (a2 = r3), a2 === B && (a2 = void 0), e3.D && l(a2, true), u2) { + var p2 = [], d2 = []; + y("Patches").M(r3, a2, p2, d2), u2(p2, d2); + } + return a2; + } + n(21, r3); + }, this.produceWithPatches = function(n2, r3) { + if ("function" == typeof n2) + return function(r4) { + for (var t3 = arguments.length, i4 = Array(t3 > 1 ? t3 - 1 : 0), u3 = 1; u3 < t3; u3++) + i4[u3 - 1] = arguments[u3]; + return e3.produceWithPatches(r4, function(r5) { + return n2.apply(void 0, [r5].concat(i4)); + }); + }; + var t2, i3, u2 = e3.produce(n2, r3, function(n3, r4) { + t2 = n3, i3 = r4; + }); + return "undefined" != typeof Promise && u2 instanceof Promise ? u2.then(function(n3) { + return [n3, t2, i3]; + }) : [u2, t2, i3]; + }, "boolean" == typeof (null == r2 ? void 0 : r2.useProxies) && this.setUseProxies(r2.useProxies), "boolean" == typeof (null == r2 ? void 0 : r2.autoFreeze) && this.setAutoFreeze(r2.autoFreeze); + } + var i2 = e2.prototype; + return i2.createDraft = function(e3) { + t(e3) || n(8), r(e3) && (e3 = F(e3)); + var i3 = x(this), u2 = k(this, e3, void 0); + return u2[H].C = true, O(i3), u2; + }, i2.finishDraft = function(n2, r2) { + var t2 = (n2 && n2[H]).A; + return m(t2, r2), S(void 0, t2); + }, i2.setAutoFreeze = function(n2) { + this.D = n2; + }, i2.setUseProxies = function(r2) { + r2 && !q && n(20), this.S = r2; + }, i2.applyPatches = function(n2, t2) { + var e3; + for (e3 = t2.length - 1; e3 >= 0; e3--) { + var i3 = t2[e3]; + if (0 === i3.path.length && "replace" === i3.op) { + n2 = i3.value; + break; + } + } + e3 > -1 && (t2 = t2.slice(e3 + 1)); + var u2 = y("Patches").W; + return r(n2) ? u2(n2, t2) : this.produce(n2, function(n3) { + return u2(n3, t2); + }); + }, e2; + }(); + var rn = new nn(); + var tn = rn.produce; + var en = rn.produceWithPatches.bind(rn); + var un = rn.setAutoFreeze.bind(rn); + var on = rn.setUseProxies.bind(rn); + var fn = rn.applyPatches.bind(rn); + var an = rn.createDraft.bind(rn); + var cn = rn.finishDraft.bind(rn); + exports.Immer = nn, exports.applyPatches = fn, exports.castDraft = function(n2) { + return n2; + }, exports.castImmutable = function(n2) { + return n2; + }, exports.createDraft = an, exports.current = F, exports.default = tn, exports.enableAllPlugins = function() { + D(), $(), K(); + }, exports.enableES5 = D, exports.enableMapSet = $, exports.enablePatches = K, exports.finishDraft = cn, exports.freeze = l, exports.immerable = G, exports.isDraft = r, exports.isDraftable = t, exports.nothing = B, exports.original = function(t2) { + return r(t2) || n(23, t2), t2[H].u; + }, exports.produce = tn, exports.produceWithPatches = en, exports.setAutoFreeze = un, exports.setUseProxies = on; + } +}); + +// node_modules/immer/dist/immer.cjs.development.js +var require_immer_cjs_development = __commonJS({ + "node_modules/immer/dist/immer.cjs.development.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var _ref; + var hasSymbol = typeof Symbol !== "undefined" && typeof /* @__PURE__ */ Symbol("x") === "symbol"; + var hasMap = typeof Map !== "undefined"; + var hasSet = typeof Set !== "undefined"; + var hasProxies = typeof Proxy !== "undefined" && typeof Proxy.revocable !== "undefined" && typeof Reflect !== "undefined"; + var NOTHING = hasSymbol ? /* @__PURE__ */ Symbol.for("immer-nothing") : (_ref = {}, _ref["immer-nothing"] = true, _ref); + var DRAFTABLE = hasSymbol ? /* @__PURE__ */ Symbol.for("immer-draftable") : "__$immer_draftable"; + var DRAFT_STATE = hasSymbol ? /* @__PURE__ */ Symbol.for("immer-state") : "__$immer_state"; + var iteratorSymbol = typeof Symbol != "undefined" && Symbol.iterator || "@@iterator"; + var errors = { + 0: "Illegal state", + 1: "Immer drafts cannot have computed properties", + 2: "This object has been frozen and should not be mutated", + 3: function _(data) { + return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data; + }, + 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", + 5: "Immer forbids circular references", + 6: "The first or second argument to `produce` must be a function", + 7: "The third argument to `produce` must be a function or undefined", + 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object", + 9: "First argument to `finishDraft` must be a draft returned by `createDraft`", + 10: "The given draft is already finalized", + 11: "Object.defineProperty() cannot be used on an Immer draft", + 12: "Object.setPrototypeOf() cannot be used on an Immer draft", + 13: "Immer only supports deleting array indices", + 14: "Immer only supports setting array indices and the 'length' property", + 15: function _(path) { + return "Cannot apply patch, path doesn't resolve: " + path; + }, + 16: 'Sets cannot have "replace" patches.', + 17: function _(op) { + return "Unsupported patch operation: " + op; + }, + 18: function _(plugin) { + return "The plugin for '" + plugin + "' has not been loaded into Immer. To enable the plugin, import and call `enable" + plugin + "()` when initializing your application."; + }, + 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available", + 21: function _(thing) { + return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '" + thing + "'"; + }, + 22: function _(thing) { + return "'current' expects a draft, got: " + thing; + }, + 23: function _(thing) { + return "'original' expects a draft, got: " + thing; + }, + 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed" + }; + function die(error) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + { + var e = errors[error]; + var msg = !e ? "unknown error nr: " + error : typeof e === "function" ? e.apply(null, args) : e; + throw new Error("[Immer] " + msg); + } + } + function isDraft(value) { + return !!value && !!value[DRAFT_STATE]; + } + function isDraftable(value) { + var _value$constructor; + if (!value) + return false; + return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor[DRAFTABLE]) || isMap(value) || isSet(value); + } + var objectCtorString = /* @__PURE__ */ Object.prototype.constructor.toString(); + function isPlainObject(value) { + if (!value || typeof value !== "object") + return false; + var proto = Object.getPrototypeOf(value); + if (proto === null) { + return true; + } + var Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor; + if (Ctor === Object) + return true; + return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString; + } + function original(value) { + if (!isDraft(value)) + die(23, value); + return value[DRAFT_STATE].base_; + } + var ownKeys = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function(obj) { + return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)); + } : ( + /* istanbul ignore next */ + Object.getOwnPropertyNames + ); + var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(target) { + var res = {}; + ownKeys(target).forEach(function(key) { + res[key] = Object.getOwnPropertyDescriptor(target, key); + }); + return res; + }; + function each(obj, iter, enumerableOnly) { + if (enumerableOnly === void 0) { + enumerableOnly = false; + } + if (getArchtype(obj) === 0) { + (enumerableOnly ? Object.keys : ownKeys)(obj).forEach(function(key) { + if (!enumerableOnly || typeof key !== "symbol") + iter(key, obj[key], obj); + }); + } else { + obj.forEach(function(entry, index) { + return iter(index, entry, obj); + }); + } + } + function getArchtype(thing) { + var state = thing[DRAFT_STATE]; + return state ? state.type_ > 3 ? state.type_ - 4 : state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0; + } + function has(thing, prop) { + return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop); + } + function get(thing, prop) { + return getArchtype(thing) === 2 ? thing.get(prop) : thing[prop]; + } + function set(thing, propOrOldValue, value) { + var t = getArchtype(thing); + if (t === 2) + thing.set(propOrOldValue, value); + else if (t === 3) { + thing.add(value); + } else + thing[propOrOldValue] = value; + } + function is(x, y) { + if (x === y) { + return x !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } + } + function isMap(target) { + return hasMap && target instanceof Map; + } + function isSet(target) { + return hasSet && target instanceof Set; + } + function latest(state) { + return state.copy_ || state.base_; + } + function shallowCopy(base) { + if (Array.isArray(base)) + return Array.prototype.slice.call(base); + var descriptors = getOwnPropertyDescriptors(base); + delete descriptors[DRAFT_STATE]; + var keys = ownKeys(descriptors); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var desc = descriptors[key]; + if (desc.writable === false) { + desc.writable = true; + desc.configurable = true; + } + if (desc.get || desc.set) + descriptors[key] = { + configurable: true, + writable: true, + enumerable: desc.enumerable, + value: base[key] + }; + } + return Object.create(Object.getPrototypeOf(base), descriptors); + } + function freeze(obj, deep) { + if (deep === void 0) { + deep = false; + } + if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) + return obj; + if (getArchtype(obj) > 1) { + obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections; + } + Object.freeze(obj); + if (deep) + each(obj, function(key, value) { + return freeze(value, true); + }, true); + return obj; + } + function dontMutateFrozenCollections() { + die(2); + } + function isFrozen(obj) { + if (obj == null || typeof obj !== "object") + return true; + return Object.isFrozen(obj); + } + var plugins = {}; + function getPlugin(pluginKey) { + var plugin = plugins[pluginKey]; + if (!plugin) { + die(18, pluginKey); + } + return plugin; + } + function loadPlugin(pluginKey, implementation) { + if (!plugins[pluginKey]) + plugins[pluginKey] = implementation; + } + var currentScope; + function getCurrentScope() { + if (!currentScope) + die(0); + return currentScope; + } + function createScope(parent_, immer_) { + return { + drafts_: [], + parent_, + immer_, + // Whenever the modified draft contains a draft from another scope, we + // need to prevent auto-freezing so the unowned draft can be finalized. + canAutoFreeze_: true, + unfinalizedDrafts_: 0 + }; + } + function usePatchesInScope(scope, patchListener) { + if (patchListener) { + getPlugin("Patches"); + scope.patches_ = []; + scope.inversePatches_ = []; + scope.patchListener_ = patchListener; + } + } + function revokeScope(scope) { + leaveScope(scope); + scope.drafts_.forEach(revokeDraft); + scope.drafts_ = null; + } + function leaveScope(scope) { + if (scope === currentScope) { + currentScope = scope.parent_; + } + } + function enterScope(immer2) { + return currentScope = createScope(currentScope, immer2); + } + function revokeDraft(draft) { + var state = draft[DRAFT_STATE]; + if (state.type_ === 0 || state.type_ === 1) + state.revoke_(); + else + state.revoked_ = true; + } + function processResult(result, scope) { + scope.unfinalizedDrafts_ = scope.drafts_.length; + var baseDraft = scope.drafts_[0]; + var isReplaced = result !== void 0 && result !== baseDraft; + if (!scope.immer_.useProxies_) + getPlugin("ES5").willFinalizeES5_(scope, result, isReplaced); + if (isReplaced) { + if (baseDraft[DRAFT_STATE].modified_) { + revokeScope(scope); + die(4); + } + if (isDraftable(result)) { + result = finalize(scope, result); + if (!scope.parent_) + maybeFreeze(scope, result); + } + if (scope.patches_) { + getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_); + } + } else { + result = finalize(scope, baseDraft, []); + } + revokeScope(scope); + if (scope.patches_) { + scope.patchListener_(scope.patches_, scope.inversePatches_); + } + return result !== NOTHING ? result : void 0; + } + function finalize(rootScope, value, path) { + if (isFrozen(value)) + return value; + var state = value[DRAFT_STATE]; + if (!state) { + each( + value, + function(key, childValue) { + return finalizeProperty(rootScope, state, value, key, childValue, path); + }, + true + // See #590, don't recurse into non-enumerable of non drafted objects + ); + return value; + } + if (state.scope_ !== rootScope) + return value; + if (!state.modified_) { + maybeFreeze(rootScope, state.base_, true); + return state.base_; + } + if (!state.finalized_) { + state.finalized_ = true; + state.scope_.unfinalizedDrafts_--; + var result = ( + // For ES5, create a good copy from the draft first, with added keys and without deleted keys. + state.type_ === 4 || state.type_ === 5 ? state.copy_ = shallowCopy(state.draft_) : state.copy_ + ); + var resultEach = result; + var isSet2 = false; + if (state.type_ === 3) { + resultEach = new Set(result); + result.clear(); + isSet2 = true; + } + each(resultEach, function(key, childValue) { + return finalizeProperty(rootScope, state, result, key, childValue, path, isSet2); + }); + maybeFreeze(rootScope, result, false); + if (path && rootScope.patches_) { + getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_); + } + } + return state.copy_; + } + function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) { + if (childValue === targetObject) + die(5); + if (isDraft(childValue)) { + var path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys. + !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0; + var res = finalize(rootScope, childValue, path); + set(targetObject, prop, res); + if (isDraft(res)) { + rootScope.canAutoFreeze_ = false; + } else + return; + } else if (targetIsSet) { + targetObject.add(childValue); + } + if (isDraftable(childValue) && !isFrozen(childValue)) { + if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) { + return; + } + finalize(rootScope, childValue); + if (!parentState || !parentState.scope_.parent_) + maybeFreeze(rootScope, childValue); + } + } + function maybeFreeze(scope, value, deep) { + if (deep === void 0) { + deep = false; + } + if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) { + freeze(value, deep); + } + } + function createProxyProxy(base, parent) { + var isArray = Array.isArray(base); + var state = { + type_: isArray ? 1 : 0, + // Track which produce call this is associated with. + scope_: parent ? parent.scope_ : getCurrentScope(), + // True for both shallow and deep changes. + modified_: false, + // Used during finalization. + finalized_: false, + // Track which properties have been assigned (true) or deleted (false). + assigned_: {}, + // The parent draft state. + parent_: parent, + // The base state. + base_: base, + // The base proxy. + draft_: null, + // The base copy with any updated values. + copy_: null, + // Called by the `produce` function. + revoke_: null, + isManual_: false + }; + var target = state; + var traps = objectTraps; + if (isArray) { + target = [state]; + traps = arrayTraps; + } + var _Proxy$revocable = Proxy.revocable(target, traps), revoke = _Proxy$revocable.revoke, proxy = _Proxy$revocable.proxy; + state.draft_ = proxy; + state.revoke_ = revoke; + return proxy; + } + var objectTraps = { + get: function get2(state, prop) { + if (prop === DRAFT_STATE) + return state; + var source = latest(state); + if (!has(source, prop)) { + return readPropFromProto(state, source, prop); + } + var value = source[prop]; + if (state.finalized_ || !isDraftable(value)) { + return value; + } + if (value === peek(state.base_, prop)) { + prepareCopy(state); + return state.copy_[prop] = createProxy(state.scope_.immer_, value, state); + } + return value; + }, + has: function has2(state, prop) { + return prop in latest(state); + }, + ownKeys: function ownKeys2(state) { + return Reflect.ownKeys(latest(state)); + }, + set: function set2(state, prop, value) { + var desc = getDescriptorFromProto(latest(state), prop); + if (desc === null || desc === void 0 ? void 0 : desc.set) { + desc.set.call(state.draft_, value); + return true; + } + if (!state.modified_) { + var current2 = peek(latest(state), prop); + var currentState = current2 === null || current2 === void 0 ? void 0 : current2[DRAFT_STATE]; + if (currentState && currentState.base_ === value) { + state.copy_[prop] = value; + state.assigned_[prop] = false; + return true; + } + if (is(value, current2) && (value !== void 0 || has(state.base_, prop))) + return true; + prepareCopy(state); + markChanged(state); + } + if (state.copy_[prop] === value && // special case: handle new props with value 'undefined' + (value !== void 0 || prop in state.copy_) || // special case: NaN + Number.isNaN(value) && Number.isNaN(state.copy_[prop])) + return true; + state.copy_[prop] = value; + state.assigned_[prop] = true; + return true; + }, + deleteProperty: function deleteProperty(state, prop) { + if (peek(state.base_, prop) !== void 0 || prop in state.base_) { + state.assigned_[prop] = false; + prepareCopy(state); + markChanged(state); + } else { + delete state.assigned_[prop]; + } + if (state.copy_) + delete state.copy_[prop]; + return true; + }, + // Note: We never coerce `desc.value` into an Immer draft, because we can't make + // the same guarantee in ES5 mode. + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(state, prop) { + var owner = latest(state); + var desc = Reflect.getOwnPropertyDescriptor(owner, prop); + if (!desc) + return desc; + return { + writable: true, + configurable: state.type_ !== 1 || prop !== "length", + enumerable: desc.enumerable, + value: owner[prop] + }; + }, + defineProperty: function defineProperty() { + die(11); + }, + getPrototypeOf: function getPrototypeOf(state) { + return Object.getPrototypeOf(state.base_); + }, + setPrototypeOf: function setPrototypeOf() { + die(12); + } + }; + var arrayTraps = {}; + each(objectTraps, function(key, fn) { + arrayTraps[key] = function() { + arguments[0] = arguments[0][0]; + return fn.apply(this, arguments); + }; + }); + arrayTraps.deleteProperty = function(state, prop) { + if (isNaN(parseInt(prop))) + die(13); + return arrayTraps.set.call(this, state, prop, void 0); + }; + arrayTraps.set = function(state, prop, value) { + if (prop !== "length" && isNaN(parseInt(prop))) + die(14); + return objectTraps.set.call(this, state[0], prop, value, state[0]); + }; + function peek(draft, prop) { + var state = draft[DRAFT_STATE]; + var source = state ? latest(state) : draft; + return source[prop]; + } + function readPropFromProto(state, source, prop) { + var _desc$get; + var desc = getDescriptorFromProto(source, prop); + return desc ? "value" in desc ? desc.value : ( + // This is a very special case, if the prop is a getter defined by the + // prototype, we should invoke it with the draft as context! + (_desc$get = desc.get) === null || _desc$get === void 0 ? void 0 : _desc$get.call(state.draft_) + ) : void 0; + } + function getDescriptorFromProto(source, prop) { + if (!(prop in source)) + return void 0; + var proto = Object.getPrototypeOf(source); + while (proto) { + var desc = Object.getOwnPropertyDescriptor(proto, prop); + if (desc) + return desc; + proto = Object.getPrototypeOf(proto); + } + return void 0; + } + function markChanged(state) { + if (!state.modified_) { + state.modified_ = true; + if (state.parent_) { + markChanged(state.parent_); + } + } + } + function prepareCopy(state) { + if (!state.copy_) { + state.copy_ = shallowCopy(state.base_); + } + } + var Immer = /* @__PURE__ */ function() { + function Immer2(config) { + var _this = this; + this.useProxies_ = hasProxies; + this.autoFreeze_ = true; + this.produce = function(base, recipe, patchListener) { + if (typeof base === "function" && typeof recipe !== "function") { + var defaultBase = recipe; + recipe = base; + var self = _this; + return function curriedProduce(base2) { + var _this2 = this; + if (base2 === void 0) { + base2 = defaultBase; + } + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + return self.produce(base2, function(draft) { + var _recipe; + return (_recipe = recipe).call.apply(_recipe, [_this2, draft].concat(args)); + }); + }; + } + if (typeof recipe !== "function") + die(6); + if (patchListener !== void 0 && typeof patchListener !== "function") + die(7); + var result; + if (isDraftable(base)) { + var scope = enterScope(_this); + var proxy = createProxy(_this, base, void 0); + var hasError = true; + try { + result = recipe(proxy); + hasError = false; + } finally { + if (hasError) + revokeScope(scope); + else + leaveScope(scope); + } + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function(result2) { + usePatchesInScope(scope, patchListener); + return processResult(result2, scope); + }, function(error) { + revokeScope(scope); + throw error; + }); + } + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + } else if (!base || typeof base !== "object") { + result = recipe(base); + if (result === void 0) + result = base; + if (result === NOTHING) + result = void 0; + if (_this.autoFreeze_) + freeze(result, true); + if (patchListener) { + var p = []; + var ip = []; + getPlugin("Patches").generateReplacementPatches_(base, result, p, ip); + patchListener(p, ip); + } + return result; + } else + die(21, base); + }; + this.produceWithPatches = function(base, recipe) { + if (typeof base === "function") { + return function(state) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + return _this.produceWithPatches(state, function(draft) { + return base.apply(void 0, [draft].concat(args)); + }); + }; + } + var patches, inversePatches; + var result = _this.produce(base, recipe, function(p, ip) { + patches = p; + inversePatches = ip; + }); + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function(nextState) { + return [nextState, patches, inversePatches]; + }); + } + return [result, patches, inversePatches]; + }; + if (typeof (config === null || config === void 0 ? void 0 : config.useProxies) === "boolean") + this.setUseProxies(config.useProxies); + if (typeof (config === null || config === void 0 ? void 0 : config.autoFreeze) === "boolean") + this.setAutoFreeze(config.autoFreeze); + } + var _proto = Immer2.prototype; + _proto.createDraft = function createDraft2(base) { + if (!isDraftable(base)) + die(8); + if (isDraft(base)) + base = current(base); + var scope = enterScope(this); + var proxy = createProxy(this, base, void 0); + proxy[DRAFT_STATE].isManual_ = true; + leaveScope(scope); + return proxy; + }; + _proto.finishDraft = function finishDraft2(draft, patchListener) { + var state = draft && draft[DRAFT_STATE]; + { + if (!state || !state.isManual_) + die(9); + if (state.finalized_) + die(10); + } + var scope = state.scope_; + usePatchesInScope(scope, patchListener); + return processResult(void 0, scope); + }; + _proto.setAutoFreeze = function setAutoFreeze2(value) { + this.autoFreeze_ = value; + }; + _proto.setUseProxies = function setUseProxies2(value) { + if (value && !hasProxies) { + die(20); + } + this.useProxies_ = value; + }; + _proto.applyPatches = function applyPatches2(base, patches) { + var i; + for (i = patches.length - 1; i >= 0; i--) { + var patch = patches[i]; + if (patch.path.length === 0 && patch.op === "replace") { + base = patch.value; + break; + } + } + if (i > -1) { + patches = patches.slice(i + 1); + } + var applyPatchesImpl = getPlugin("Patches").applyPatches_; + if (isDraft(base)) { + return applyPatchesImpl(base, patches); + } + return this.produce(base, function(draft) { + return applyPatchesImpl(draft, patches); + }); + }; + return Immer2; + }(); + function createProxy(immer2, value, parent) { + var draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : immer2.useProxies_ ? createProxyProxy(value, parent) : getPlugin("ES5").createES5Proxy_(value, parent); + var scope = parent ? parent.scope_ : getCurrentScope(); + scope.drafts_.push(draft); + return draft; + } + function current(value) { + if (!isDraft(value)) + die(22, value); + return currentImpl(value); + } + function currentImpl(value) { + if (!isDraftable(value)) + return value; + var state = value[DRAFT_STATE]; + var copy; + var archType = getArchtype(value); + if (state) { + if (!state.modified_ && (state.type_ < 4 || !getPlugin("ES5").hasChanges_(state))) + return state.base_; + state.finalized_ = true; + copy = copyHelper(value, archType); + state.finalized_ = false; + } else { + copy = copyHelper(value, archType); + } + each(copy, function(key, childValue) { + if (state && get(state.base_, key) === childValue) + return; + set(copy, key, currentImpl(childValue)); + }); + return archType === 3 ? new Set(copy) : copy; + } + function copyHelper(value, archType) { + switch (archType) { + case 2: + return new Map(value); + case 3: + return Array.from(value); + } + return shallowCopy(value); + } + function enableES5() { + function willFinalizeES5_(scope, result, isReplaced) { + if (!isReplaced) { + if (scope.patches_) { + markChangesRecursively(scope.drafts_[0]); + } + markChangesSweep(scope.drafts_); + } else if (isDraft(result) && result[DRAFT_STATE].scope_ === scope) { + markChangesSweep(scope.drafts_); + } + } + function createES5Draft(isArray, base) { + if (isArray) { + var draft = new Array(base.length); + for (var i = 0; i < base.length; i++) { + Object.defineProperty(draft, "" + i, proxyProperty(i, true)); + } + return draft; + } else { + var _descriptors = getOwnPropertyDescriptors(base); + delete _descriptors[DRAFT_STATE]; + var keys = ownKeys(_descriptors); + for (var _i = 0; _i < keys.length; _i++) { + var key = keys[_i]; + _descriptors[key] = proxyProperty(key, isArray || !!_descriptors[key].enumerable); + } + return Object.create(Object.getPrototypeOf(base), _descriptors); + } + } + function createES5Proxy_(base, parent) { + var isArray = Array.isArray(base); + var draft = createES5Draft(isArray, base); + var state = { + type_: isArray ? 5 : 4, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + assigned_: {}, + parent_: parent, + // base is the object we are drafting + base_: base, + // draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified) + draft_: draft, + copy_: null, + revoked_: false, + isManual_: false + }; + Object.defineProperty(draft, DRAFT_STATE, { + value: state, + // enumerable: false <- the default + writable: true + }); + return draft; + } + var descriptors = {}; + function proxyProperty(prop, enumerable) { + var desc = descriptors[prop]; + if (desc) { + desc.enumerable = enumerable; + } else { + descriptors[prop] = desc = { + configurable: true, + enumerable, + get: function get2() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + return objectTraps.get(state, prop); + }, + set: function set2(value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + objectTraps.set(state, prop, value); + } + }; + } + return desc; + } + function markChangesSweep(drafts) { + for (var i = drafts.length - 1; i >= 0; i--) { + var state = drafts[i][DRAFT_STATE]; + if (!state.modified_) { + switch (state.type_) { + case 5: + if (hasArrayChanges(state)) + markChanged(state); + break; + case 4: + if (hasObjectChanges(state)) + markChanged(state); + break; + } + } + } + } + function markChangesRecursively(object) { + if (!object || typeof object !== "object") + return; + var state = object[DRAFT_STATE]; + if (!state) + return; + var base_ = state.base_, draft_ = state.draft_, assigned_ = state.assigned_, type_ = state.type_; + if (type_ === 4) { + each(draft_, function(key) { + if (key === DRAFT_STATE) + return; + if (base_[key] === void 0 && !has(base_, key)) { + assigned_[key] = true; + markChanged(state); + } else if (!assigned_[key]) { + markChangesRecursively(draft_[key]); + } + }); + each(base_, function(key) { + if (draft_[key] === void 0 && !has(draft_, key)) { + assigned_[key] = false; + markChanged(state); + } + }); + } else if (type_ === 5) { + if (hasArrayChanges(state)) { + markChanged(state); + assigned_.length = true; + } + if (draft_.length < base_.length) { + for (var i = draft_.length; i < base_.length; i++) { + assigned_[i] = false; + } + } else { + for (var _i2 = base_.length; _i2 < draft_.length; _i2++) { + assigned_[_i2] = true; + } + } + var min = Math.min(draft_.length, base_.length); + for (var _i3 = 0; _i3 < min; _i3++) { + if (!draft_.hasOwnProperty(_i3)) { + assigned_[_i3] = true; + } + if (assigned_[_i3] === void 0) + markChangesRecursively(draft_[_i3]); + } + } + } + function hasObjectChanges(state) { + var base_ = state.base_, draft_ = state.draft_; + var keys = ownKeys(draft_); + for (var i = keys.length - 1; i >= 0; i--) { + var key = keys[i]; + if (key === DRAFT_STATE) + continue; + var baseValue = base_[key]; + if (baseValue === void 0 && !has(base_, key)) { + return true; + } else { + var value = draft_[key]; + var _state = value && value[DRAFT_STATE]; + if (_state ? _state.base_ !== baseValue : !is(value, baseValue)) { + return true; + } + } + } + var baseIsDraft = !!base_[DRAFT_STATE]; + return keys.length !== ownKeys(base_).length + (baseIsDraft ? 0 : 1); + } + function hasArrayChanges(state) { + var draft_ = state.draft_; + if (draft_.length !== state.base_.length) + return true; + var descriptor = Object.getOwnPropertyDescriptor(draft_, draft_.length - 1); + if (descriptor && !descriptor.get) + return true; + for (var i = 0; i < draft_.length; i++) { + if (!draft_.hasOwnProperty(i)) + return true; + } + return false; + } + function hasChanges_(state) { + return state.type_ === 4 ? hasObjectChanges(state) : hasArrayChanges(state); + } + function assertUnrevoked(state) { + if (state.revoked_) + die(3, JSON.stringify(latest(state))); + } + loadPlugin("ES5", { + createES5Proxy_, + willFinalizeES5_, + hasChanges_ + }); + } + function enablePatches() { + var REPLACE = "replace"; + var ADD = "add"; + var REMOVE = "remove"; + function generatePatches_(state, basePath, patches, inversePatches) { + switch (state.type_) { + case 0: + case 4: + case 2: + return generatePatchesFromAssigned(state, basePath, patches, inversePatches); + case 5: + case 1: + return generateArrayPatches(state, basePath, patches, inversePatches); + case 3: + return generateSetPatches(state, basePath, patches, inversePatches); + } + } + function generateArrayPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, assigned_ = state.assigned_; + var copy_ = state.copy_; + if (copy_.length < base_.length) { + var _ref2 = [copy_, base_]; + base_ = _ref2[0]; + copy_ = _ref2[1]; + var _ref22 = [inversePatches, patches]; + patches = _ref22[0]; + inversePatches = _ref22[1]; + } + for (var i = 0; i < base_.length; i++) { + if (assigned_[i] && copy_[i] !== base_[i]) { + var path = basePath.concat([i]); + patches.push({ + op: REPLACE, + path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[i]) + }); + inversePatches.push({ + op: REPLACE, + path, + value: clonePatchValueIfNeeded(base_[i]) + }); + } + } + for (var _i = base_.length; _i < copy_.length; _i++) { + var _path = basePath.concat([_i]); + patches.push({ + op: ADD, + path: _path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[_i]) + }); + } + if (base_.length < copy_.length) { + inversePatches.push({ + op: REPLACE, + path: basePath.concat(["length"]), + value: base_.length + }); + } + } + function generatePatchesFromAssigned(state, basePath, patches, inversePatches) { + var base_ = state.base_, copy_ = state.copy_; + each(state.assigned_, function(key, assignedValue) { + var origValue = get(base_, key); + var value = get(copy_, key); + var op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD; + if (origValue === value && op === REPLACE) + return; + var path = basePath.concat(key); + patches.push(op === REMOVE ? { + op, + path + } : { + op, + path, + value + }); + inversePatches.push(op === ADD ? { + op: REMOVE, + path + } : op === REMOVE ? { + op: ADD, + path, + value: clonePatchValueIfNeeded(origValue) + } : { + op: REPLACE, + path, + value: clonePatchValueIfNeeded(origValue) + }); + }); + } + function generateSetPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, copy_ = state.copy_; + var i = 0; + base_.forEach(function(value) { + if (!copy_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: REMOVE, + path, + value + }); + inversePatches.unshift({ + op: ADD, + path, + value + }); + } + i++; + }); + i = 0; + copy_.forEach(function(value) { + if (!base_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: ADD, + path, + value + }); + inversePatches.unshift({ + op: REMOVE, + path, + value + }); + } + i++; + }); + } + function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) { + patches.push({ + op: REPLACE, + path: [], + value: replacement === NOTHING ? void 0 : replacement + }); + inversePatches.push({ + op: REPLACE, + path: [], + value: baseValue + }); + } + function applyPatches_(draft, patches) { + patches.forEach(function(patch) { + var path = patch.path, op = patch.op; + var base = draft; + for (var i = 0; i < path.length - 1; i++) { + var parentType = getArchtype(base); + var p = path[i]; + if (typeof p !== "string" && typeof p !== "number") { + p = "" + p; + } + if ((parentType === 0 || parentType === 1) && (p === "__proto__" || p === "constructor")) + die(24); + if (typeof base === "function" && p === "prototype") + die(24); + base = get(base, p); + if (typeof base !== "object") + die(15, path.join("/")); + } + var type = getArchtype(base); + var value = deepClonePatchValue(patch.value); + var key = path[path.length - 1]; + switch (op) { + case REPLACE: + switch (type) { + case 2: + return base.set(key, value); + case 3: + die(16); + default: + return base[key] = value; + } + case ADD: + switch (type) { + case 1: + return key === "-" ? base.push(value) : base.splice(key, 0, value); + case 2: + return base.set(key, value); + case 3: + return base.add(value); + default: + return base[key] = value; + } + case REMOVE: + switch (type) { + case 1: + return base.splice(key, 1); + case 2: + return base.delete(key); + case 3: + return base.delete(patch.value); + default: + return delete base[key]; + } + default: + die(17, op); + } + }); + return draft; + } + function deepClonePatchValue(obj) { + if (!isDraftable(obj)) + return obj; + if (Array.isArray(obj)) + return obj.map(deepClonePatchValue); + if (isMap(obj)) + return new Map(Array.from(obj.entries()).map(function(_ref3) { + var k = _ref3[0], v = _ref3[1]; + return [k, deepClonePatchValue(v)]; + })); + if (isSet(obj)) + return new Set(Array.from(obj).map(deepClonePatchValue)); + var cloned = Object.create(Object.getPrototypeOf(obj)); + for (var key in obj) { + cloned[key] = deepClonePatchValue(obj[key]); + } + if (has(obj, DRAFTABLE)) + cloned[DRAFTABLE] = obj[DRAFTABLE]; + return cloned; + } + function clonePatchValueIfNeeded(obj) { + if (isDraft(obj)) { + return deepClonePatchValue(obj); + } else + return obj; + } + loadPlugin("Patches", { + applyPatches_, + generatePatches_, + generateReplacementPatches_ + }); + } + function enableMapSet() { + var _extendStatics = function extendStatics(d, b) { + _extendStatics = Object.setPrototypeOf || { + __proto__: [] + } instanceof Array && function(d2, b2) { + d2.__proto__ = b2; + } || function(d2, b2) { + for (var p in b2) { + if (b2.hasOwnProperty(p)) + d2[p] = b2[p]; + } + }; + return _extendStatics(d, b); + }; + function __extends(d, b) { + _extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = // @ts-ignore + (__.prototype = b.prototype, new __()); + } + var DraftMap = function(_super) { + __extends(DraftMap2, _super); + function DraftMap2(target, parent) { + this[DRAFT_STATE] = { + type_: 2, + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: void 0, + assigned_: void 0, + base_: target, + draft_: this, + isManual_: false, + revoked_: false + }; + return this; + } + var p = DraftMap2.prototype; + Object.defineProperty(p, "size", { + get: function get2() { + return latest(this[DRAFT_STATE]).size; + } + // enumerable: false, + // configurable: true + }); + p.has = function(key) { + return latest(this[DRAFT_STATE]).has(key); + }; + p.set = function(key, value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + if (!latest(state).has(key) || latest(state).get(key) !== value) { + prepareMapCopy(state); + markChanged(state); + state.assigned_.set(key, true); + state.copy_.set(key, value); + state.assigned_.set(key, true); + } + return this; + }; + p.delete = function(key) { + if (!this.has(key)) { + return false; + } + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareMapCopy(state); + markChanged(state); + if (state.base_.has(key)) { + state.assigned_.set(key, false); + } else { + state.assigned_.delete(key); + } + state.copy_.delete(key); + return true; + }; + p.clear = function() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + if (latest(state).size) { + prepareMapCopy(state); + markChanged(state); + state.assigned_ = /* @__PURE__ */ new Map(); + each(state.base_, function(key) { + state.assigned_.set(key, false); + }); + state.copy_.clear(); + } + }; + p.forEach = function(cb, thisArg) { + var _this = this; + var state = this[DRAFT_STATE]; + latest(state).forEach(function(_value, key, _map) { + cb.call(thisArg, _this.get(key), key, _this); + }); + }; + p.get = function(key) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + var value = latest(state).get(key); + if (state.finalized_ || !isDraftable(value)) { + return value; + } + if (value !== state.base_.get(key)) { + return value; + } + var draft = createProxy(state.scope_.immer_, value, state); + prepareMapCopy(state); + state.copy_.set(key, draft); + return draft; + }; + p.keys = function() { + return latest(this[DRAFT_STATE]).keys(); + }; + p.values = function() { + var _this2 = this, _ref2; + var iterator = this.keys(); + return _ref2 = {}, _ref2[iteratorSymbol] = function() { + return _this2.values(); + }, _ref2.next = function next() { + var r = iterator.next(); + if (r.done) + return r; + var value = _this2.get(r.value); + return { + done: false, + value + }; + }, _ref2; + }; + p.entries = function() { + var _this3 = this, _ref2; + var iterator = this.keys(); + return _ref2 = {}, _ref2[iteratorSymbol] = function() { + return _this3.entries(); + }, _ref2.next = function next() { + var r = iterator.next(); + if (r.done) + return r; + var value = _this3.get(r.value); + return { + done: false, + value: [r.value, value] + }; + }, _ref2; + }; + p[iteratorSymbol] = function() { + return this.entries(); + }; + return DraftMap2; + }(Map); + function proxyMap_(target, parent) { + return new DraftMap(target, parent); + } + function prepareMapCopy(state) { + if (!state.copy_) { + state.assigned_ = /* @__PURE__ */ new Map(); + state.copy_ = new Map(state.base_); + } + } + var DraftSet = function(_super) { + __extends(DraftSet2, _super); + function DraftSet2(target, parent) { + this[DRAFT_STATE] = { + type_: 3, + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: void 0, + base_: target, + draft_: this, + drafts_: /* @__PURE__ */ new Map(), + revoked_: false, + isManual_: false + }; + return this; + } + var p = DraftSet2.prototype; + Object.defineProperty(p, "size", { + get: function get2() { + return latest(this[DRAFT_STATE]).size; + } + // enumerable: true, + }); + p.has = function(value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + if (!state.copy_) { + return state.base_.has(value); + } + if (state.copy_.has(value)) + return true; + if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) + return true; + return false; + }; + p.add = function(value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + if (!this.has(value)) { + prepareSetCopy(state); + markChanged(state); + state.copy_.add(value); + } + return this; + }; + p.delete = function(value) { + if (!this.has(value)) { + return false; + } + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + markChanged(state); + return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : ( + /* istanbul ignore next */ + false + )); + }; + p.clear = function() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + if (latest(state).size) { + prepareSetCopy(state); + markChanged(state); + state.copy_.clear(); + } + }; + p.values = function() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.values(); + }; + p.entries = function entries() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.entries(); + }; + p.keys = function() { + return this.values(); + }; + p[iteratorSymbol] = function() { + return this.values(); + }; + p.forEach = function forEach(cb, thisArg) { + var iterator = this.values(); + var result = iterator.next(); + while (!result.done) { + cb.call(thisArg, result.value, result.value, this); + result = iterator.next(); + } + }; + return DraftSet2; + }(Set); + function proxySet_(target, parent) { + return new DraftSet(target, parent); + } + function prepareSetCopy(state) { + if (!state.copy_) { + state.copy_ = /* @__PURE__ */ new Set(); + state.base_.forEach(function(value) { + if (isDraftable(value)) { + var draft = createProxy(state.scope_.immer_, value, state); + state.drafts_.set(value, draft); + state.copy_.add(draft); + } else { + state.copy_.add(value); + } + }); + } + } + function assertUnrevoked(state) { + if (state.revoked_) + die(3, JSON.stringify(latest(state))); + } + loadPlugin("MapSet", { + proxyMap_, + proxySet_ + }); + } + function enableAllPlugins() { + enableES5(); + enableMapSet(); + enablePatches(); + } + var immer = /* @__PURE__ */ new Immer(); + var produce = immer.produce; + var produceWithPatches = /* @__PURE__ */ immer.produceWithPatches.bind(immer); + var setAutoFreeze = /* @__PURE__ */ immer.setAutoFreeze.bind(immer); + var setUseProxies = /* @__PURE__ */ immer.setUseProxies.bind(immer); + var applyPatches = /* @__PURE__ */ immer.applyPatches.bind(immer); + var createDraft = /* @__PURE__ */ immer.createDraft.bind(immer); + var finishDraft = /* @__PURE__ */ immer.finishDraft.bind(immer); + function castDraft(value) { + return value; + } + function castImmutable(value) { + return value; + } + exports.Immer = Immer; + exports.applyPatches = applyPatches; + exports.castDraft = castDraft; + exports.castImmutable = castImmutable; + exports.createDraft = createDraft; + exports.current = current; + exports.default = produce; + exports.enableAllPlugins = enableAllPlugins; + exports.enableES5 = enableES5; + exports.enableMapSet = enableMapSet; + exports.enablePatches = enablePatches; + exports.finishDraft = finishDraft; + exports.freeze = freeze; + exports.immerable = DRAFTABLE; + exports.isDraft = isDraft; + exports.isDraftable = isDraftable; + exports.nothing = NOTHING; + exports.original = original; + exports.produce = produce; + exports.produceWithPatches = produceWithPatches; + exports.setAutoFreeze = setAutoFreeze; + exports.setUseProxies = setUseProxies; + } +}); + +// node_modules/immer/dist/index.js +var require_dist = __commonJS({ + "node_modules/immer/dist/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV === "production") { + module.exports = require_immer_cjs_production_min(); + } else { + module.exports = require_immer_cjs_development(); + } + } +}); + +// node_modules/@babel/runtime/helpers/typeof.js +var require_typeof = __commonJS({ + "node_modules/@babel/runtime/helpers/typeof.js"(exports, module) { + init_cjs_shim(); + function _typeof(o) { + "@babel/helpers - typeof"; + return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) { + return typeof o2; + } : function(o2) { + return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2; + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o); + } + module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; + } +}); + +// node_modules/@babel/runtime/helpers/toPrimitive.js +var require_toPrimitive = __commonJS({ + "node_modules/@babel/runtime/helpers/toPrimitive.js"(exports, module) { + init_cjs_shim(); + var _typeof = require_typeof()["default"]; + function toPrimitive(t, r) { + if ("object" != _typeof(t) || !t) + return t; + var e = t[Symbol.toPrimitive]; + if (void 0 !== e) { + var i = e.call(t, r || "default"); + if ("object" != _typeof(i)) + return i; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return ("string" === r ? String : Number)(t); + } + module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports; + } +}); + +// node_modules/@babel/runtime/helpers/toPropertyKey.js +var require_toPropertyKey = __commonJS({ + "node_modules/@babel/runtime/helpers/toPropertyKey.js"(exports, module) { + init_cjs_shim(); + var _typeof = require_typeof()["default"]; + var toPrimitive = require_toPrimitive(); + function toPropertyKey(t) { + var i = toPrimitive(t, "string"); + return "symbol" == _typeof(i) ? i : i + ""; + } + module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports; + } +}); + +// node_modules/@babel/runtime/helpers/defineProperty.js +var require_defineProperty = __commonJS({ + "node_modules/@babel/runtime/helpers/defineProperty.js"(exports, module) { + init_cjs_shim(); + var toPropertyKey = require_toPropertyKey(); + function _defineProperty(e, r, t) { + return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, { + value: t, + enumerable: true, + configurable: true, + writable: true + }) : e[r] = t, e; + } + module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports; + } +}); + +// node_modules/@babel/runtime/helpers/objectSpread2.js +var require_objectSpread2 = __commonJS({ + "node_modules/@babel/runtime/helpers/objectSpread2.js"(exports, module) { + init_cjs_shim(); + var defineProperty = require_defineProperty(); + function ownKeys(e, r) { + var t = Object.keys(e); + if (Object.getOwnPropertySymbols) { + var o = Object.getOwnPropertySymbols(e); + r && (o = o.filter(function(r2) { + return Object.getOwnPropertyDescriptor(e, r2).enumerable; + })), t.push.apply(t, o); + } + return t; + } + function _objectSpread2(e) { + for (var r = 1; r < arguments.length; r++) { + var t = null != arguments[r] ? arguments[r] : {}; + r % 2 ? ownKeys(Object(t), true).forEach(function(r2) { + defineProperty(e, r2, t[r2]); + }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) { + Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2)); + }); + } + return e; + } + module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports; + } +}); + +// node_modules/redux/lib/redux.js +var require_redux = __commonJS({ + "node_modules/redux/lib/redux.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var _objectSpread = require_objectSpread2(); + function _interopDefaultLegacy(e) { + return e && typeof e === "object" && "default" in e ? e : { "default": e }; + } + var _objectSpread__default = /* @__PURE__ */ _interopDefaultLegacy(_objectSpread); + function formatProdErrorMessage(code) { + return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?code=" + code + " for the full message or use the non-minified dev environment for full errors. "; + } + var $$observable = function() { + return typeof Symbol === "function" && Symbol.observable || "@@observable"; + }(); + var randomString = function randomString2() { + return Math.random().toString(36).substring(7).split("").join("."); + }; + var ActionTypes = { + INIT: "@@redux/INIT" + randomString(), + REPLACE: "@@redux/REPLACE" + randomString(), + PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() { + return "@@redux/PROBE_UNKNOWN_ACTION" + randomString(); + } + }; + function isPlainObject(obj) { + if (typeof obj !== "object" || obj === null) + return false; + var proto = obj; + while (Object.getPrototypeOf(proto) !== null) { + proto = Object.getPrototypeOf(proto); + } + return Object.getPrototypeOf(obj) === proto; + } + function miniKindOf(val) { + if (val === void 0) + return "undefined"; + if (val === null) + return "null"; + var type = typeof val; + switch (type) { + case "boolean": + case "string": + case "number": + case "symbol": + case "function": { + return type; + } + } + if (Array.isArray(val)) + return "array"; + if (isDate(val)) + return "date"; + if (isError(val)) + return "error"; + var constructorName = ctorName(val); + switch (constructorName) { + case "Symbol": + case "Promise": + case "WeakMap": + case "WeakSet": + case "Map": + case "Set": + return constructorName; + } + return type.slice(8, -1).toLowerCase().replace(/\s/g, ""); + } + function ctorName(val) { + return typeof val.constructor === "function" ? val.constructor.name : null; + } + function isError(val) { + return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number"; + } + function isDate(val) { + if (val instanceof Date) + return true; + return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function"; + } + function kindOf(val) { + var typeOfVal = typeof val; + if (process.env.NODE_ENV !== "production") { + typeOfVal = miniKindOf(val); + } + return typeOfVal; + } + function createStore2(reducer, preloadedState, enhancer) { + var _ref2; + if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example."); + } + if (typeof preloadedState === "function" && typeof enhancer === "undefined") { + enhancer = preloadedState; + preloadedState = void 0; + } + if (typeof enhancer !== "undefined") { + if (typeof enhancer !== "function") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(1) : "Expected the enhancer to be a function. Instead, received: '" + kindOf(enhancer) + "'"); + } + return enhancer(createStore2)(reducer, preloadedState); + } + if (typeof reducer !== "function") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : "Expected the root reducer to be a function. Instead, received: '" + kindOf(reducer) + "'"); + } + var currentReducer = reducer; + var currentState = preloadedState; + var currentListeners = []; + var nextListeners = currentListeners; + var isDispatching = false; + function ensureCanMutateNextListeners() { + if (nextListeners === currentListeners) { + nextListeners = currentListeners.slice(); + } + } + function getState() { + if (isDispatching) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(3) : "You may not call store.getState() while the reducer is executing. The reducer has already received the state as an argument. Pass it down from the top reducer instead of reading it from the store."); + } + return currentState; + } + function subscribe(listener) { + if (typeof listener !== "function") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(4) : "Expected the listener to be a function. Instead, received: '" + kindOf(listener) + "'"); + } + if (isDispatching) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(5) : "You may not call store.subscribe() while the reducer is executing. If you would like to be notified after the store has been updated, subscribe from a component and invoke store.getState() in the callback to access the latest state. See https://redux.js.org/api/store#subscribelistener for more details."); + } + var isSubscribed = true; + ensureCanMutateNextListeners(); + nextListeners.push(listener); + return function unsubscribe() { + if (!isSubscribed) { + return; + } + if (isDispatching) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(6) : "You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api/store#subscribelistener for more details."); + } + isSubscribed = false; + ensureCanMutateNextListeners(); + var index = nextListeners.indexOf(listener); + nextListeners.splice(index, 1); + currentListeners = null; + }; + } + function dispatch(action) { + if (!isPlainObject(action)) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(7) : "Actions must be plain objects. Instead, the actual type was: '" + kindOf(action) + "'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples."); + } + if (typeof action.type === "undefined") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : 'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.'); + } + if (isDispatching) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(9) : "Reducers may not dispatch actions."); + } + try { + isDispatching = true; + currentState = currentReducer(currentState, action); + } finally { + isDispatching = false; + } + var listeners = currentListeners = nextListeners; + for (var i = 0; i < listeners.length; i++) { + var listener = listeners[i]; + listener(); + } + return action; + } + function replaceReducer(nextReducer) { + if (typeof nextReducer !== "function") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(10) : "Expected the nextReducer to be a function. Instead, received: '" + kindOf(nextReducer)); + } + currentReducer = nextReducer; + dispatch({ + type: ActionTypes.REPLACE + }); + } + function observable() { + var _ref; + var outerSubscribe = subscribe; + return _ref = { + /** + * The minimal observable subscription method. + * @param {Object} observer Any object that can be used as an observer. + * The observer object should have a `next` method. + * @returns {subscription} An object with an `unsubscribe` method that can + * be used to unsubscribe the observable from the store, and prevent further + * emission of values from the observable. + */ + subscribe: function subscribe2(observer) { + if (typeof observer !== "object" || observer === null) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "Expected the observer to be an object. Instead, received: '" + kindOf(observer) + "'"); + } + function observeState() { + if (observer.next) { + observer.next(getState()); + } + } + observeState(); + var unsubscribe = outerSubscribe(observeState); + return { + unsubscribe + }; + } + }, _ref[$$observable] = function() { + return this; + }, _ref; + } + dispatch({ + type: ActionTypes.INIT + }); + return _ref2 = { + dispatch, + subscribe, + getState, + replaceReducer + }, _ref2[$$observable] = observable, _ref2; + } + var legacy_createStore = createStore2; + function warning(message) { + if (typeof console !== "undefined" && typeof console.error === "function") { + console.error(message); + } + try { + throw new Error(message); + } catch (e) { + } + } + function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) { + var reducerKeys = Object.keys(reducers); + var argumentName = action && action.type === ActionTypes.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer"; + if (reducerKeys.length === 0) { + return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers."; + } + if (!isPlainObject(inputState)) { + return "The " + argumentName + ' has unexpected type of "' + kindOf(inputState) + '". Expected argument to be an object with the following ' + ('keys: "' + reducerKeys.join('", "') + '"'); + } + var unexpectedKeys = Object.keys(inputState).filter(function(key) { + return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]; + }); + unexpectedKeys.forEach(function(key) { + unexpectedKeyCache[key] = true; + }); + if (action && action.type === ActionTypes.REPLACE) + return; + if (unexpectedKeys.length > 0) { + return "Unexpected " + (unexpectedKeys.length > 1 ? "keys" : "key") + " " + ('"' + unexpectedKeys.join('", "') + '" found in ' + argumentName + ". ") + "Expected to find one of the known reducer keys instead: " + ('"' + reducerKeys.join('", "') + '". Unexpected keys will be ignored.'); + } + } + function assertReducerShape(reducers) { + Object.keys(reducers).forEach(function(key) { + var reducer = reducers[key]; + var initialState2 = reducer(void 0, { + type: ActionTypes.INIT + }); + if (typeof initialState2 === "undefined") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : 'The slice reducer for key "' + key + `" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`); + } + if (typeof reducer(void 0, { + type: ActionTypes.PROBE_UNKNOWN_ACTION() + }) === "undefined") { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : 'The slice reducer for key "' + key + '" returned undefined when probed with a random type. ' + ("Don't try to handle '" + ActionTypes.INIT + `' or other actions in "redux/*" `) + "namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null."); + } + }); + } + function combineReducers(reducers) { + var reducerKeys = Object.keys(reducers); + var finalReducers = {}; + for (var i = 0; i < reducerKeys.length; i++) { + var key = reducerKeys[i]; + if (process.env.NODE_ENV !== "production") { + if (typeof reducers[key] === "undefined") { + warning('No reducer provided for key "' + key + '"'); + } + } + if (typeof reducers[key] === "function") { + finalReducers[key] = reducers[key]; + } + } + var finalReducerKeys = Object.keys(finalReducers); + var unexpectedKeyCache; + if (process.env.NODE_ENV !== "production") { + unexpectedKeyCache = {}; + } + var shapeAssertionError; + try { + assertReducerShape(finalReducers); + } catch (e) { + shapeAssertionError = e; + } + return function combination(state, action) { + if (state === void 0) { + state = {}; + } + if (shapeAssertionError) { + throw shapeAssertionError; + } + if (process.env.NODE_ENV !== "production") { + var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache); + if (warningMessage) { + warning(warningMessage); + } + } + var hasChanged = false; + var nextState = {}; + for (var _i = 0; _i < finalReducerKeys.length; _i++) { + var _key = finalReducerKeys[_i]; + var reducer = finalReducers[_key]; + var previousStateForKey = state[_key]; + var nextStateForKey = reducer(previousStateForKey, action); + if (typeof nextStateForKey === "undefined") { + var actionType = action && action.type; + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "When called with an action of type " + (actionType ? '"' + String(actionType) + '"' : "(unknown type)") + ', the slice reducer for key "' + _key + '" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.'); + } + nextState[_key] = nextStateForKey; + hasChanged = hasChanged || nextStateForKey !== previousStateForKey; + } + hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length; + return hasChanged ? nextState : state; + }; + } + function bindActionCreator(actionCreator, dispatch) { + return function() { + return dispatch(actionCreator.apply(this, arguments)); + }; + } + function bindActionCreators(actionCreators, dispatch) { + if (typeof actionCreators === "function") { + return bindActionCreator(actionCreators, dispatch); + } + if (typeof actionCreators !== "object" || actionCreators === null) { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "bindActionCreators expected an object or a function, but instead received: '" + kindOf(actionCreators) + `'. Did you write "import ActionCreators from" instead of "import * as ActionCreators from"?`); + } + var boundActionCreators = {}; + for (var key in actionCreators) { + var actionCreator = actionCreators[key]; + if (typeof actionCreator === "function") { + boundActionCreators[key] = bindActionCreator(actionCreator, dispatch); + } + } + return boundActionCreators; + } + function compose() { + for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) { + funcs[_key] = arguments[_key]; + } + if (funcs.length === 0) { + return function(arg) { + return arg; + }; + } + if (funcs.length === 1) { + return funcs[0]; + } + return funcs.reduce(function(a, b) { + return function() { + return a(b.apply(void 0, arguments)); + }; + }); + } + function applyMiddleware() { + for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) { + middlewares[_key] = arguments[_key]; + } + return function(createStore3) { + return function() { + var store = createStore3.apply(void 0, arguments); + var _dispatch = function dispatch() { + throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch."); + }; + var middlewareAPI = { + getState: store.getState, + dispatch: function dispatch() { + return _dispatch.apply(void 0, arguments); + } + }; + var chain = middlewares.map(function(middleware) { + return middleware(middlewareAPI); + }); + _dispatch = compose.apply(void 0, chain)(store.dispatch); + return _objectSpread__default["default"](_objectSpread__default["default"]({}, store), {}, { + dispatch: _dispatch + }); + }; + }; + } + exports.__DO_NOT_USE__ActionTypes = ActionTypes; + exports.applyMiddleware = applyMiddleware; + exports.bindActionCreators = bindActionCreators; + exports.combineReducers = combineReducers; + exports.compose = compose; + exports.createStore = createStore2; + exports.legacy_createStore = legacy_createStore; + } +}); + +// node_modules/reselect/lib/defaultMemoize.js +var require_defaultMemoize = __commonJS({ + "node_modules/reselect/lib/defaultMemoize.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.createCacheKeyComparator = createCacheKeyComparator; + exports.defaultEqualityCheck = void 0; + exports.defaultMemoize = defaultMemoize; + var NOT_FOUND = "NOT_FOUND"; + function createSingletonCache(equals) { + var entry; + return { + get: function get(key) { + if (entry && equals(entry.key, key)) { + return entry.value; + } + return NOT_FOUND; + }, + put: function put(key, value) { + entry = { + key, + value + }; + }, + getEntries: function getEntries() { + return entry ? [entry] : []; + }, + clear: function clear() { + entry = void 0; + } + }; + } + function createLruCache(maxSize, equals) { + var entries = []; + function get(key) { + var cacheIndex = entries.findIndex(function(entry2) { + return equals(key, entry2.key); + }); + if (cacheIndex > -1) { + var entry = entries[cacheIndex]; + if (cacheIndex > 0) { + entries.splice(cacheIndex, 1); + entries.unshift(entry); + } + return entry.value; + } + return NOT_FOUND; + } + function put(key, value) { + if (get(key) === NOT_FOUND) { + entries.unshift({ + key, + value + }); + if (entries.length > maxSize) { + entries.pop(); + } + } + } + function getEntries() { + return entries; + } + function clear() { + entries = []; + } + return { + get, + put, + getEntries, + clear + }; + } + var defaultEqualityCheck = function defaultEqualityCheck2(a, b) { + return a === b; + }; + exports.defaultEqualityCheck = defaultEqualityCheck; + function createCacheKeyComparator(equalityCheck) { + return function areArgumentsShallowlyEqual(prev, next) { + if (prev === null || next === null || prev.length !== next.length) { + return false; + } + var length = prev.length; + for (var i = 0; i < length; i++) { + if (!equalityCheck(prev[i], next[i])) { + return false; + } + } + return true; + }; + } + function defaultMemoize(func, equalityCheckOrOptions) { + var providedOptions = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : { + equalityCheck: equalityCheckOrOptions + }; + var _providedOptions$equa = providedOptions.equalityCheck, equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa, _providedOptions$maxS = providedOptions.maxSize, maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS, resultEqualityCheck = providedOptions.resultEqualityCheck; + var comparator = createCacheKeyComparator(equalityCheck); + var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator); + function memoized() { + var value = cache.get(arguments); + if (value === NOT_FOUND) { + value = func.apply(null, arguments); + if (resultEqualityCheck) { + var entries = cache.getEntries(); + var matchingEntry = entries.find(function(entry) { + return resultEqualityCheck(entry.value, value); + }); + if (matchingEntry) { + value = matchingEntry.value; + } + } + cache.put(arguments, value); + } + return value; + } + memoized.clearCache = function() { + return cache.clear(); + }; + return memoized; + } + } +}); + +// node_modules/reselect/lib/index.js +var require_lib = __commonJS({ + "node_modules/reselect/lib/index.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.createSelector = void 0; + exports.createSelectorCreator = createSelectorCreator; + exports.createStructuredSelector = void 0; + Object.defineProperty(exports, "defaultEqualityCheck", { + enumerable: true, + get: function get() { + return _defaultMemoize.defaultEqualityCheck; + } + }); + Object.defineProperty(exports, "defaultMemoize", { + enumerable: true, + get: function get() { + return _defaultMemoize.defaultMemoize; + } + }); + var _defaultMemoize = require_defaultMemoize(); + function getDependencies(funcs) { + var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs; + if (!dependencies.every(function(dep) { + return typeof dep === "function"; + })) { + var dependencyTypes = dependencies.map(function(dep) { + return typeof dep === "function" ? "function " + (dep.name || "unnamed") + "()" : typeof dep; + }).join(", "); + throw new Error("createSelector expects all input-selectors to be functions, but received the following types: [" + dependencyTypes + "]"); + } + return dependencies; + } + function createSelectorCreator(memoize) { + for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + memoizeOptionsFromArgs[_key - 1] = arguments[_key]; + } + var createSelector3 = function createSelector4() { + for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + funcs[_key2] = arguments[_key2]; + } + var _recomputations = 0; + var _lastResult; + var directlyPassedOptions = { + memoizeOptions: void 0 + }; + var resultFunc = funcs.pop(); + if (typeof resultFunc === "object") { + directlyPassedOptions = resultFunc; + resultFunc = funcs.pop(); + } + if (typeof resultFunc !== "function") { + throw new Error("createSelector expects an output function after the inputs, but received: [" + typeof resultFunc + "]"); + } + var _directlyPassedOption = directlyPassedOptions, _directlyPassedOption2 = _directlyPassedOption.memoizeOptions, memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2; + var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions]; + var dependencies = getDependencies(funcs); + var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() { + _recomputations++; + return resultFunc.apply(null, arguments); + }].concat(finalMemoizeOptions)); + var selector = memoize(function dependenciesChecker() { + var params = []; + var length = dependencies.length; + for (var i = 0; i < length; i++) { + params.push(dependencies[i].apply(null, arguments)); + } + _lastResult = memoizedResultFunc.apply(null, params); + return _lastResult; + }); + Object.assign(selector, { + resultFunc, + memoizedResultFunc, + dependencies, + lastResult: function lastResult() { + return _lastResult; + }, + recomputations: function recomputations() { + return _recomputations; + }, + resetRecomputations: function resetRecomputations() { + return _recomputations = 0; + } + }); + return selector; + }; + return createSelector3; + } + var createSelector2 = /* @__PURE__ */ createSelectorCreator(_defaultMemoize.defaultMemoize); + exports.createSelector = createSelector2; + var createStructuredSelector = function createStructuredSelector2(selectors, selectorCreator) { + if (selectorCreator === void 0) { + selectorCreator = createSelector2; + } + if (typeof selectors !== "object") { + throw new Error("createStructuredSelector expects first argument to be an object " + ("where each property is a selector, instead received a " + typeof selectors)); + } + var objectKeys = Object.keys(selectors); + var resultSelector = selectorCreator( + // @ts-ignore + objectKeys.map(function(key) { + return selectors[key]; + }), + function() { + for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + values[_key3] = arguments[_key3]; + } + return values.reduce(function(composition, value, index) { + composition[objectKeys[index]] = value; + return composition; + }, {}); + } + ); + return resultSelector; + }; + exports.createStructuredSelector = createStructuredSelector; + } +}); + +// node_modules/redux-thunk/lib/index.js +var require_lib2 = __commonJS({ + "node_modules/redux-thunk/lib/index.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = void 0; + function createThunkMiddleware(extraArgument) { + var middleware = function middleware2(_ref) { + var dispatch = _ref.dispatch, getState = _ref.getState; + return function(next) { + return function(action) { + if (typeof action === "function") { + return action(dispatch, getState, extraArgument); + } + return next(action); + }; + }; + }; + return middleware; + } + var thunk = createThunkMiddleware(); + thunk.withExtraArgument = createThunkMiddleware; + var _default = thunk; + exports.default = _default; + } +}); + +// node_modules/@reduxjs/toolkit/dist/redux-toolkit.cjs.production.min.js +var require_redux_toolkit_cjs_production_min = __commonJS({ + "node_modules/@reduxjs/toolkit/dist/redux-toolkit.cjs.production.min.js"(exports) { + init_cjs_shim(); + var e; + var n = exports && exports.__extends || (e = function(n2, t2) { + return e = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e2, n3) { + e2.__proto__ = n3; + } || function(e2, n3) { + for (var t3 in n3) + Object.prototype.hasOwnProperty.call(n3, t3) && (e2[t3] = n3[t3]); + }, e(n2, t2); + }, function(n2, t2) { + if ("function" != typeof t2 && null !== t2) + throw new TypeError("Class extends value " + String(t2) + " is not a constructor or null"); + function r2() { + this.constructor = n2; + } + e(n2, t2), n2.prototype = null === t2 ? Object.create(t2) : (r2.prototype = t2.prototype, new r2()); + }); + var t = exports && exports.__generator || function(e2, n2) { + var t2, r2, i2, o2, u2 = { label: 0, sent: function() { + if (1 & i2[0]) + throw i2[1]; + return i2[1]; + }, trys: [], ops: [] }; + return o2 = { next: a2(0), throw: a2(1), return: a2(2) }, "function" == typeof Symbol && (o2[Symbol.iterator] = function() { + return this; + }), o2; + function a2(o3) { + return function(a3) { + return function(o4) { + if (t2) + throw new TypeError("Generator is already executing."); + for (; u2; ) + try { + if (t2 = 1, r2 && (i2 = 2 & o4[0] ? r2.return : o4[0] ? r2.throw || ((i2 = r2.return) && i2.call(r2), 0) : r2.next) && !(i2 = i2.call(r2, o4[1])).done) + return i2; + switch (r2 = 0, i2 && (o4 = [2 & o4[0], i2.value]), o4[0]) { + case 0: + case 1: + i2 = o4; + break; + case 4: + return u2.label++, { value: o4[1], done: false }; + case 5: + u2.label++, r2 = o4[1], o4 = [0]; + continue; + case 7: + o4 = u2.ops.pop(), u2.trys.pop(); + continue; + default: + if (!((i2 = (i2 = u2.trys).length > 0 && i2[i2.length - 1]) || 6 !== o4[0] && 2 !== o4[0])) { + u2 = 0; + continue; + } + if (3 === o4[0] && (!i2 || o4[1] > i2[0] && o4[1] < i2[3])) { + u2.label = o4[1]; + break; + } + if (6 === o4[0] && u2.label < i2[1]) { + u2.label = i2[1], i2 = o4; + break; + } + if (i2 && u2.label < i2[2]) { + u2.label = i2[2], u2.ops.push(o4); + break; + } + i2[2] && u2.ops.pop(), u2.trys.pop(); + continue; + } + o4 = n2.call(e2, u2); + } catch (e3) { + o4 = [6, e3], r2 = 0; + } finally { + t2 = i2 = 0; + } + if (5 & o4[0]) + throw o4[1]; + return { value: o4[0] ? o4[1] : void 0, done: true }; + }([o3, a3]); + }; + } + }; + var r = exports && exports.__spreadArray || function(e2, n2) { + for (var t2 = 0, r2 = n2.length, i2 = e2.length; t2 < r2; t2++, i2++) + e2[i2] = n2[t2]; + return e2; + }; + var i = Object.create; + var o = Object.defineProperty; + var u = Object.defineProperties; + var a = Object.getOwnPropertyDescriptor; + var c = Object.getOwnPropertyDescriptors; + var f = Object.getOwnPropertyNames; + var l = Object.getOwnPropertySymbols; + var s = Object.getPrototypeOf; + var d = Object.prototype.hasOwnProperty; + var p = Object.prototype.propertyIsEnumerable; + var v = function(e2, n2, t2) { + return n2 in e2 ? o(e2, n2, { enumerable: true, configurable: true, writable: true, value: t2 }) : e2[n2] = t2; + }; + var y = function(e2, n2) { + for (var t2 in n2 || (n2 = {})) + d.call(n2, t2) && v(e2, t2, n2[t2]); + if (l) + for (var r2 = 0, i2 = l(n2); r2 < i2.length; r2++) + p.call(n2, t2 = i2[r2]) && v(e2, t2, n2[t2]); + return e2; + }; + var h = function(e2, n2) { + return u(e2, c(n2)); + }; + var g = function(e2) { + return o(e2, "__esModule", { value: true }); + }; + var b = function(e2, n2, t2) { + if (n2 && "object" == typeof n2 || "function" == typeof n2) + for (var r2 = function(r3) { + d.call(e2, r3) || "default" === r3 || o(e2, r3, { get: function() { + return n2[r3]; + }, enumerable: !(t2 = a(n2, r3)) || t2.enumerable }); + }, i2 = 0, u2 = f(n2); i2 < u2.length; i2++) + r2(u2[i2]); + return e2; + }; + var m = function(e2) { + return b(g(o(null != e2 ? i(s(e2)) : {}, "default", e2 && e2.__esModule && "default" in e2 ? { get: function() { + return e2.default; + }, enumerable: true } : { value: e2, enumerable: true })), e2); + }; + var w = function(e2, n2, t2) { + return new Promise(function(r2, i2) { + var o2 = function(e3) { + try { + a2(t2.next(e3)); + } catch (e4) { + i2(e4); + } + }, u2 = function(e3) { + try { + a2(t2.throw(e3)); + } catch (e4) { + i2(e4); + } + }, a2 = function(e3) { + return e3.done ? r2(e3.value) : Promise.resolve(e3.value).then(o2, u2); + }; + a2((t2 = t2.apply(e2, n2)).next()); + }); + }; + g(exports), function(e2, n2) { + for (var t2 in n2) + o(e2, t2, { get: n2[t2], enumerable: true }); + }(exports, { EnhancerArray: function() { + return F; + }, MiddlewareArray: function() { + return B; + }, SHOULD_AUTOBATCH: function() { + return Je; + }, TaskAbortError: function() { + return ke; + }, addListener: function() { + return Fe; + }, autoBatchEnhancer: function() { + return $e; + }, clearAllListeners: function() { + return Ue; + }, configureStore: function() { + return Y; + }, createAction: function() { + return T; + }, createActionCreatorInvariantMiddleware: function() { + return N; + }, createAsyncThunk: function() { + return ve; + }, createDraftSafeSelector: function() { + return P; + }, createEntityAdapter: function() { + return ce; + }, createImmutableStateInvariantMiddleware: function() { + return X; + }, createListenerMiddleware: function() { + return Ge; + }, createNextState: function() { + return j.default; + }, createReducer: function() { + return ee; + }, createSelector: function() { + return A.createSelector; + }, createSerializableStateInvariantMiddleware: function() { + return K; + }, createSlice: function() { + return ne; + }, current: function() { + return j.current; + }, findNonSerializableValue: function() { + return H; + }, freeze: function() { + return j.freeze; + }, getDefaultMiddleware: function() { + return Q; + }, getType: function() { + return z; + }, isAction: function() { + return C; + }, isActionCreator: function() { + return D; + }, isAllOf: function() { + return be; + }, isAnyOf: function() { + return ge; + }, isAsyncThunkAction: function() { + return Se; + }, isDraft: function() { + return j.isDraft; + }, isFluxStandardAction: function() { + return L; + }, isFulfilled: function() { + return Ee; + }, isImmutableDefault: function() { + return W; + }, isPending: function() { + return Oe; + }, isPlain: function() { + return G; + }, isPlainObject: function() { + return M; + }, isRejected: function() { + return je; + }, isRejectedWithValue: function() { + return Ae; + }, miniSerializeError: function() { + return pe; + }, nanoid: function() { + return fe; + }, original: function() { + return j.original; + }, prepareAutoBatched: function() { + return Ke; + }, removeListener: function() { + return We; + }, unwrapResult: function() { + return ye; + } }); + var O = m(require_dist()); + b(exports, m(require_redux())); + var j = m(require_dist()); + var A = m(require_lib()); + var E = m(require_dist()); + var S = m(require_lib()); + var P = function() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + var t2 = S.createSelector.apply(void 0, e2), i2 = function(e3) { + for (var n3 = [], i3 = 1; i3 < arguments.length; i3++) + n3[i3 - 1] = arguments[i3]; + return t2.apply(void 0, r([(0, E.isDraft)(e3) ? (0, E.current)(e3) : e3], n3)); + }; + return i2; + }; + var _ = m(require_redux()); + var q = m(require_redux()); + var x = "undefined" != typeof window && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() { + if (0 !== arguments.length) + return "object" == typeof arguments[0] ? q.compose : q.compose.apply(null, arguments); + }; + function M(e2) { + if ("object" != typeof e2 || null === e2) + return false; + var n2 = Object.getPrototypeOf(e2); + if (null === n2) + return true; + for (var t2 = n2; null !== Object.getPrototypeOf(t2); ) + t2 = Object.getPrototypeOf(t2); + return n2 === t2; + } + "undefined" != typeof window && window.__REDUX_DEVTOOLS_EXTENSION__ && window; + var k = m(require_lib2()); + var I = function(e2) { + return e2 && "function" == typeof e2.match; + }; + function T(e2, n2) { + function t2() { + for (var t3 = [], r2 = 0; r2 < arguments.length; r2++) + t3[r2] = arguments[r2]; + if (n2) { + var i2 = n2.apply(void 0, t3); + if (!i2) + throw new Error("prepareAction did not return an object"); + return y(y({ type: e2, payload: i2.payload }, "meta" in i2 && { meta: i2.meta }), "error" in i2 && { error: i2.error }); + } + return { type: e2, payload: t3[0] }; + } + return t2.toString = function() { + return "" + e2; + }, t2.type = e2, t2.match = function(n3) { + return n3.type === e2; + }, t2; + } + function C(e2) { + return M(e2) && "type" in e2; + } + function D(e2) { + return "function" == typeof e2 && "type" in e2 && I(e2); + } + function L(e2) { + return C(e2) && "string" == typeof e2.type && Object.keys(e2).every(R); + } + function R(e2) { + return ["type", "payload", "error", "meta"].indexOf(e2) > -1; + } + function z(e2) { + return "" + e2; + } + function N(e2) { + return void 0 === e2 && (e2 = {}), function() { + return function(e3) { + return function(n2) { + return e3(n2); + }; + }; + }; + } + var V = m(require_dist()); + var B = function(e2) { + function t2() { + for (var n2 = [], r2 = 0; r2 < arguments.length; r2++) + n2[r2] = arguments[r2]; + var i2 = e2.apply(this, n2) || this; + return Object.setPrototypeOf(i2, t2.prototype), i2; + } + return n(t2, e2), Object.defineProperty(t2, Symbol.species, { get: function() { + return t2; + }, enumerable: false, configurable: true }), t2.prototype.concat = function() { + for (var n2 = [], t3 = 0; t3 < arguments.length; t3++) + n2[t3] = arguments[t3]; + return e2.prototype.concat.apply(this, n2); + }, t2.prototype.prepend = function() { + for (var e3 = [], n2 = 0; n2 < arguments.length; n2++) + e3[n2] = arguments[n2]; + return 1 === e3.length && Array.isArray(e3[0]) ? new (t2.bind.apply(t2, r([void 0], e3[0].concat(this))))() : new (t2.bind.apply(t2, r([void 0], e3.concat(this))))(); + }, t2; + }(Array); + var F = function(e2) { + function t2() { + for (var n2 = [], r2 = 0; r2 < arguments.length; r2++) + n2[r2] = arguments[r2]; + var i2 = e2.apply(this, n2) || this; + return Object.setPrototypeOf(i2, t2.prototype), i2; + } + return n(t2, e2), Object.defineProperty(t2, Symbol.species, { get: function() { + return t2; + }, enumerable: false, configurable: true }), t2.prototype.concat = function() { + for (var n2 = [], t3 = 0; t3 < arguments.length; t3++) + n2[t3] = arguments[t3]; + return e2.prototype.concat.apply(this, n2); + }, t2.prototype.prepend = function() { + for (var e3 = [], n2 = 0; n2 < arguments.length; n2++) + e3[n2] = arguments[n2]; + return 1 === e3.length && Array.isArray(e3[0]) ? new (t2.bind.apply(t2, r([void 0], e3[0].concat(this))))() : new (t2.bind.apply(t2, r([void 0], e3.concat(this))))(); + }, t2; + }(Array); + function U(e2) { + return (0, V.isDraftable)(e2) ? (0, V.default)(e2, function() { + }) : e2; + } + function W(e2) { + return "object" != typeof e2 || null == e2 || Object.isFrozen(e2); + } + function X(e2) { + return void 0 === e2 && (e2 = {}), function() { + return function(e3) { + return function(n2) { + return e3(n2); + }; + }; + }; + } + function G(e2) { + var n2 = typeof e2; + return null == e2 || "string" === n2 || "boolean" === n2 || "number" === n2 || Array.isArray(e2) || M(e2); + } + function H(e2, n2, t2, r2, i2, o2) { + var u2; + if (void 0 === n2 && (n2 = ""), void 0 === t2 && (t2 = G), void 0 === i2 && (i2 = []), !t2(e2)) + return { keyPath: n2 || "", value: e2 }; + if ("object" != typeof e2 || null === e2) + return false; + if (null == o2 ? void 0 : o2.has(e2)) + return false; + for (var a2 = null != r2 ? r2(e2) : Object.entries(e2), c2 = i2.length > 0, f2 = function(e3, a3) { + var f3 = n2 ? n2 + "." + e3 : e3; + return c2 && i2.some(function(e4) { + return e4 instanceof RegExp ? e4.test(f3) : f3 === e4; + }) ? "continue" : t2(a3) ? "object" == typeof a3 && (u2 = H(a3, f3, t2, r2, i2, o2)) ? { value: u2 } : void 0 : { value: { keyPath: f3, value: a3 } }; + }, l2 = 0, s2 = a2; l2 < s2.length; l2++) { + var d2 = s2[l2], p2 = f2(d2[0], d2[1]); + if ("object" == typeof p2) + return p2.value; + } + return o2 && J(e2) && o2.add(e2), false; + } + function J(e2) { + if (!Object.isFrozen(e2)) + return false; + for (var n2 = 0, t2 = Object.values(e2); n2 < t2.length; n2++) { + var r2 = t2[n2]; + if ("object" == typeof r2 && null !== r2 && !J(r2)) + return false; + } + return true; + } + function K(e2) { + return void 0 === e2 && (e2 = {}), function() { + return function(e3) { + return function(n2) { + return e3(n2); + }; + }; + }; + } + function Q(e2) { + void 0 === e2 && (e2 = {}); + var n2 = e2.thunk, t2 = void 0 === n2 || n2, r2 = new B(); + return t2 && r2.push("boolean" == typeof t2 ? k.default : k.default.withExtraArgument(t2.extraArgument)), r2; + } + function Y(e2) { + var n2, t2 = function(e3) { + return Q(e3); + }, i2 = e2 || {}, o2 = i2.reducer, u2 = void 0 === o2 ? void 0 : o2, a2 = i2.middleware, c2 = void 0 === a2 ? t2() : a2, f2 = i2.devTools, l2 = void 0 === f2 || f2, s2 = i2.preloadedState, d2 = void 0 === s2 ? void 0 : s2, p2 = i2.enhancers, v2 = void 0 === p2 ? void 0 : p2; + if ("function" == typeof u2) + n2 = u2; + else { + if (!M(u2)) + throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers'); + n2 = (0, _.combineReducers)(u2); + } + var h2 = c2; + "function" == typeof h2 && (h2 = h2(t2)); + var g2 = _.applyMiddleware.apply(void 0, h2), b2 = _.compose; + l2 && (b2 = x(y({ trace: false }, "object" == typeof l2 && l2))); + var m2 = new F(g2), w2 = m2; + Array.isArray(v2) ? w2 = r([g2], v2) : "function" == typeof v2 && (w2 = v2(m2)); + var O2 = b2.apply(void 0, w2); + return (0, _.createStore)(n2, d2, O2); + } + var Z = m(require_dist()); + function $(e2) { + var n2, t2 = {}, r2 = [], i2 = { addCase: function(e3, n3) { + var r3 = "string" == typeof e3 ? e3 : e3.type; + if (!r3) + throw new Error("`builder.addCase` cannot be called with an empty action type"); + if (r3 in t2) + throw new Error("`builder.addCase` cannot be called with two reducers for the same action type"); + return t2[r3] = n3, i2; + }, addMatcher: function(e3, n3) { + return r2.push({ matcher: e3, reducer: n3 }), i2; + }, addDefaultCase: function(e3) { + return n2 = e3, i2; + } }; + return e2(i2), [t2, r2, n2]; + } + function ee(e2, n2, t2, i2) { + void 0 === t2 && (t2 = []); + var o2, u2 = "function" == typeof n2 ? $(n2) : [n2, t2, i2], a2 = u2[0], c2 = u2[1], f2 = u2[2]; + if ("function" == typeof e2) + o2 = function() { + return U(e2()); + }; + else { + var l2 = U(e2); + o2 = function() { + return l2; + }; + } + function s2(e3, n3) { + void 0 === e3 && (e3 = o2()); + var t3 = r([a2[n3.type]], c2.filter(function(e4) { + return (0, e4.matcher)(n3); + }).map(function(e4) { + return e4.reducer; + })); + return 0 === t3.filter(function(e4) { + return !!e4; + }).length && (t3 = [f2]), t3.reduce(function(e4, t4) { + if (t4) { + var r2; + if ((0, Z.isDraft)(e4)) + return void 0 === (r2 = t4(e4, n3)) ? e4 : r2; + if ((0, Z.isDraftable)(e4)) + return (0, Z.default)(e4, function(e5) { + return t4(e5, n3); + }); + if (void 0 === (r2 = t4(e4, n3))) { + if (null === e4) + return e4; + throw Error("A case reducer on a non-draftable value must not return undefined"); + } + return r2; + } + return e4; + }, e3); + } + return s2.getInitialState = o2, s2; + } + function ne(e2) { + var n2 = e2.name; + if (!n2) + throw new Error("`name` is a required option for createSlice"); + var t2, r2 = "function" == typeof e2.initialState ? e2.initialState : U(e2.initialState), i2 = e2.reducers || {}, o2 = Object.keys(i2), u2 = {}, a2 = {}, c2 = {}; + function f2() { + var n3 = "function" == typeof e2.extraReducers ? $(e2.extraReducers) : [e2.extraReducers], t3 = n3[0], i3 = n3[1], o3 = void 0 === i3 ? [] : i3, u3 = n3[2], c3 = void 0 === u3 ? void 0 : u3, f3 = y(y({}, void 0 === t3 ? {} : t3), a2); + return ee(r2, function(e3) { + for (var n4 in f3) + e3.addCase(n4, f3[n4]); + for (var t4 = 0, r3 = o3; t4 < r3.length; t4++) { + var i4 = r3[t4]; + e3.addMatcher(i4.matcher, i4.reducer); + } + c3 && e3.addDefaultCase(c3); + }); + } + return o2.forEach(function(e3) { + var t3, r3, o3 = i2[e3], f3 = n2 + "/" + e3; + "reducer" in o3 ? (t3 = o3.reducer, r3 = o3.prepare) : t3 = o3, u2[e3] = t3, a2[f3] = t3, c2[e3] = r3 ? T(f3, r3) : T(f3); + }), { name: n2, reducer: function(e3, n3) { + return t2 || (t2 = f2()), t2(e3, n3); + }, actions: c2, caseReducers: u2, getInitialState: function() { + return t2 || (t2 = f2()), t2.getInitialState(); + } }; + } + var te = m(require_dist()); + function re(e2) { + return function(n2, t2) { + var r2 = function(n3) { + L(t2) ? e2(t2.payload, n3) : e2(t2, n3); + }; + return (0, te.isDraft)(n2) ? (r2(n2), n2) : (0, te.default)(n2, r2); + }; + } + function ie(e2, n2) { + return n2(e2); + } + function oe(e2) { + return Array.isArray(e2) || (e2 = Object.values(e2)), e2; + } + function ue(e2, n2, t2) { + for (var r2 = [], i2 = [], o2 = 0, u2 = e2 = oe(e2); o2 < u2.length; o2++) { + var a2 = u2[o2], c2 = ie(a2, n2); + c2 in t2.entities ? i2.push({ id: c2, changes: a2 }) : r2.push(a2); + } + return [r2, i2]; + } + function ae(e2) { + function n2(n3, t3) { + var r3 = ie(n3, e2); + r3 in t3.entities || (t3.ids.push(r3), t3.entities[r3] = n3); + } + function t2(e3, t3) { + for (var r3 = 0, i3 = e3 = oe(e3); r3 < i3.length; r3++) + n2(i3[r3], t3); + } + function r2(n3, t3) { + var r3 = ie(n3, e2); + r3 in t3.entities || t3.ids.push(r3), t3.entities[r3] = n3; + } + function i2(e3, n3) { + var t3 = false; + e3.forEach(function(e4) { + e4 in n3.entities && (delete n3.entities[e4], t3 = true); + }), t3 && (n3.ids = n3.ids.filter(function(e4) { + return e4 in n3.entities; + })); + } + function o2(n3, t3) { + var r3 = {}, i3 = {}; + if (n3.forEach(function(e3) { + e3.id in t3.entities && (i3[e3.id] = { id: e3.id, changes: y(y({}, i3[e3.id] ? i3[e3.id].changes : null), e3.changes) }); + }), (n3 = Object.values(i3)).length > 0) { + var o3 = n3.filter(function(n4) { + return function(n5, t4, r4) { + var i4 = Object.assign({}, r4.entities[t4.id], t4.changes), o4 = ie(i4, e2), u3 = o4 !== t4.id; + return u3 && (n5[t4.id] = o4, delete r4.entities[t4.id]), r4.entities[o4] = i4, u3; + }(r3, n4, t3); + }).length > 0; + o3 && (t3.ids = Object.keys(t3.entities)); + } + } + function u2(n3, r3) { + var i3 = ue(n3, e2, r3), u3 = i3[0]; + o2(i3[1], r3), t2(u3, r3); + } + return { removeAll: (a2 = function(e3) { + Object.assign(e3, { ids: [], entities: {} }); + }, c2 = re(function(e3, n3) { + return a2(n3); + }), function(e3) { + return c2(e3, void 0); + }), addOne: re(n2), addMany: re(t2), setOne: re(r2), setMany: re(function(e3, n3) { + for (var t3 = 0, i3 = e3 = oe(e3); t3 < i3.length; t3++) + r2(i3[t3], n3); + }), setAll: re(function(e3, n3) { + e3 = oe(e3), n3.ids = [], n3.entities = {}, t2(e3, n3); + }), updateOne: re(function(e3, n3) { + return o2([e3], n3); + }), updateMany: re(o2), upsertOne: re(function(e3, n3) { + return u2([e3], n3); + }), upsertMany: re(u2), removeOne: re(function(e3, n3) { + return i2([e3], n3); + }), removeMany: re(i2) }; + var a2, c2; + } + function ce(e2) { + void 0 === e2 && (e2 = {}); + var n2 = y({ sortComparer: false, selectId: function(e3) { + return e3.id; + } }, e2), t2 = n2.selectId, r2 = n2.sortComparer, i2 = { getInitialState: function(e3) { + return void 0 === e3 && (e3 = {}), Object.assign({ ids: [], entities: {} }, e3); + } }, o2 = { getSelectors: function(e3) { + var n3 = function(e4) { + return e4.ids; + }, t3 = function(e4) { + return e4.entities; + }, r3 = P(n3, t3, function(e4, n4) { + return e4.map(function(e5) { + return n4[e5]; + }); + }), i3 = function(e4, n4) { + return n4; + }, o3 = function(e4, n4) { + return e4[n4]; + }, u3 = P(n3, function(e4) { + return e4.length; + }); + if (!e3) + return { selectIds: n3, selectEntities: t3, selectAll: r3, selectTotal: u3, selectById: P(t3, i3, o3) }; + var a2 = P(e3, t3); + return { selectIds: P(e3, n3), selectEntities: a2, selectAll: P(e3, r3), selectTotal: P(e3, u3), selectById: P(a2, i3, o3) }; + } }, u2 = r2 ? function(e3, n3) { + var t3 = ae(e3); + function r3(n4, t4) { + var r4 = (n4 = oe(n4)).filter(function(n5) { + return !(ie(n5, e3) in t4.entities); + }); + 0 !== r4.length && a2(r4, t4); + } + function i3(e4, n4) { + 0 !== (e4 = oe(e4)).length && a2(e4, n4); + } + function o3(n4, t4) { + for (var r4 = false, i4 = 0, o4 = n4; i4 < o4.length; i4++) { + var u4 = o4[i4], a3 = t4.entities[u4.id]; + if (a3) { + r4 = true, Object.assign(a3, u4.changes); + var f2 = e3(a3); + u4.id !== f2 && (delete t4.entities[u4.id], t4.entities[f2] = a3); + } + } + r4 && c2(t4); + } + function u3(n4, t4) { + var i4 = ue(n4, e3, t4), u4 = i4[0]; + o3(i4[1], t4), r3(u4, t4); + } + function a2(n4, t4) { + n4.forEach(function(n5) { + t4.entities[e3(n5)] = n5; + }), c2(t4); + } + function c2(t4) { + var r4 = Object.values(t4.entities); + r4.sort(n3); + var i4 = r4.map(e3); + (function(e4, n4) { + if (e4.length !== n4.length) + return false; + for (var t5 = 0; t5 < e4.length && t5 < n4.length; t5++) + if (e4[t5] !== n4[t5]) + return false; + return true; + })(t4.ids, i4) || (t4.ids = i4); + } + return { removeOne: t3.removeOne, removeMany: t3.removeMany, removeAll: t3.removeAll, addOne: re(function(e4, n4) { + return r3([e4], n4); + }), updateOne: re(function(e4, n4) { + return o3([e4], n4); + }), upsertOne: re(function(e4, n4) { + return u3([e4], n4); + }), setOne: re(function(e4, n4) { + return i3([e4], n4); + }), setMany: re(i3), setAll: re(function(e4, n4) { + e4 = oe(e4), n4.entities = {}, n4.ids = [], r3(e4, n4); + }), addMany: re(r3), updateMany: re(o3), upsertMany: re(u3) }; + }(t2, r2) : ae(t2); + return y(y(y({ selectId: t2, sortComparer: r2 }, i2), o2), u2); + } + var fe = function(e2) { + void 0 === e2 && (e2 = 21); + for (var n2 = "", t2 = e2; t2--; ) + n2 += "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW"[64 * Math.random() | 0]; + return n2; + }; + var le = ["name", "message", "stack", "code"]; + var se = function(e2, n2) { + this.payload = e2, this.meta = n2; + }; + var de = function(e2, n2) { + this.payload = e2, this.meta = n2; + }; + var pe = function(e2) { + if ("object" == typeof e2 && null !== e2) { + for (var n2 = {}, t2 = 0, r2 = le; t2 < r2.length; t2++) { + var i2 = r2[t2]; + "string" == typeof e2[i2] && (n2[i2] = e2[i2]); + } + return n2; + } + return { message: String(e2) }; + }; + var ve = function() { + function e2(e3, n2, r2) { + var i2 = T(e3 + "/fulfilled", function(e4, n3, t2, r3) { + return { payload: e4, meta: h(y({}, r3 || {}), { arg: t2, requestId: n3, requestStatus: "fulfilled" }) }; + }), o2 = T(e3 + "/pending", function(e4, n3, t2) { + return { payload: void 0, meta: h(y({}, t2 || {}), { arg: n3, requestId: e4, requestStatus: "pending" }) }; + }), u2 = T(e3 + "/rejected", function(e4, n3, t2, i3, o3) { + return { payload: i3, error: (r2 && r2.serializeError || pe)(e4 || "Rejected"), meta: h(y({}, o3 || {}), { arg: t2, requestId: n3, rejectedWithValue: !!i3, requestStatus: "rejected", aborted: "AbortError" === (null == e4 ? void 0 : e4.name), condition: "ConditionError" === (null == e4 ? void 0 : e4.name) }) }; + }), a2 = "undefined" != typeof AbortController ? AbortController : function() { + function e4() { + this.signal = { aborted: false, addEventListener: function() { + }, dispatchEvent: function() { + return false; + }, onabort: function() { + }, removeEventListener: function() { + }, reason: void 0, throwIfAborted: function() { + } }; + } + return e4.prototype.abort = function() { + }, e4; + }(); + return Object.assign(function(e4) { + return function(c2, f2, l2) { + var s2, d2 = (null == r2 ? void 0 : r2.idGenerator) ? r2.idGenerator(e4) : fe(), p2 = new a2(); + function v2(e5) { + s2 = e5, p2.abort(); + } + var y2 = function() { + return w(this, null, function() { + var a3, y3, h2, g2, b2, m2; + return t(this, function(t2) { + switch (t2.label) { + case 0: + return t2.trys.push([0, 4, , 5]), null === (w2 = g2 = null == (a3 = null == r2 ? void 0 : r2.condition) ? void 0 : a3.call(r2, e4, { getState: f2, extra: l2 })) || "object" != typeof w2 || "function" != typeof w2.then ? [3, 2] : [4, g2]; + case 1: + g2 = t2.sent(), t2.label = 2; + case 2: + if (false === g2 || p2.signal.aborted) + throw { name: "ConditionError", message: "Aborted due to condition callback returning false." }; + return b2 = new Promise(function(e5, n3) { + return p2.signal.addEventListener("abort", function() { + return n3({ name: "AbortError", message: s2 || "Aborted" }); + }); + }), c2(o2(d2, e4, null == (y3 = null == r2 ? void 0 : r2.getPendingMeta) ? void 0 : y3.call(r2, { requestId: d2, arg: e4 }, { getState: f2, extra: l2 }))), [4, Promise.race([b2, Promise.resolve(n2(e4, { dispatch: c2, getState: f2, extra: l2, requestId: d2, signal: p2.signal, abort: v2, rejectWithValue: function(e5, n3) { + return new se(e5, n3); + }, fulfillWithValue: function(e5, n3) { + return new de(e5, n3); + } })).then(function(n3) { + if (n3 instanceof se) + throw n3; + return n3 instanceof de ? i2(n3.payload, d2, e4, n3.meta) : i2(n3, d2, e4); + })])]; + case 3: + return h2 = t2.sent(), [3, 5]; + case 4: + return m2 = t2.sent(), h2 = m2 instanceof se ? u2(null, d2, e4, m2.payload, m2.meta) : u2(m2, d2, e4), [3, 5]; + case 5: + return r2 && !r2.dispatchConditionRejection && u2.match(h2) && h2.meta.condition || c2(h2), [2, h2]; + } + var w2; + }); + }); + }(); + return Object.assign(y2, { abort: v2, requestId: d2, arg: e4, unwrap: function() { + return y2.then(ye); + } }); + }; + }, { pending: o2, rejected: u2, fulfilled: i2, typePrefix: e3 }); + } + return e2.withTypes = function() { + return e2; + }, e2; + }(); + function ye(e2) { + if (e2.meta && e2.meta.rejectedWithValue) + throw e2.payload; + if (e2.error) + throw e2.error; + return e2.payload; + } + var he = function(e2, n2) { + return I(e2) ? e2.match(n2) : e2(n2); + }; + function ge() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + return function(n3) { + return e2.some(function(e3) { + return he(e3, n3); + }); + }; + } + function be() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + return function(n3) { + return e2.every(function(e3) { + return he(e3, n3); + }); + }; + } + function me(e2, n2) { + if (!e2 || !e2.meta) + return false; + var t2 = "string" == typeof e2.meta.requestId, r2 = n2.indexOf(e2.meta.requestStatus) > -1; + return t2 && r2; + } + function we(e2) { + return "function" == typeof e2[0] && "pending" in e2[0] && "fulfilled" in e2[0] && "rejected" in e2[0]; + } + function Oe() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + return 0 === e2.length ? function(e3) { + return me(e3, ["pending"]); + } : we(e2) ? function(n3) { + var t2 = e2.map(function(e3) { + return e3.pending; + }); + return ge.apply(void 0, t2)(n3); + } : Oe()(e2[0]); + } + function je() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + return 0 === e2.length ? function(e3) { + return me(e3, ["rejected"]); + } : we(e2) ? function(n3) { + var t2 = e2.map(function(e3) { + return e3.rejected; + }); + return ge.apply(void 0, t2)(n3); + } : je()(e2[0]); + } + function Ae() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + var t2 = function(e3) { + return e3 && e3.meta && e3.meta.rejectedWithValue; + }; + return 0 === e2.length || we(e2) ? function(n3) { + return be(je.apply(void 0, e2), t2)(n3); + } : Ae()(e2[0]); + } + function Ee() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + return 0 === e2.length ? function(e3) { + return me(e3, ["fulfilled"]); + } : we(e2) ? function(n3) { + var t2 = e2.map(function(e3) { + return e3.fulfilled; + }); + return ge.apply(void 0, t2)(n3); + } : Ee()(e2[0]); + } + function Se() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + return 0 === e2.length ? function(e3) { + return me(e3, ["pending", "fulfilled", "rejected"]); + } : we(e2) ? function(n3) { + for (var t2 = [], r2 = 0, i2 = e2; r2 < i2.length; r2++) { + var o2 = i2[r2]; + t2.push(o2.pending, o2.rejected, o2.fulfilled); + } + return ge.apply(void 0, t2)(n3); + } : Se()(e2[0]); + } + var Pe = function(e2, n2) { + if ("function" != typeof e2) + throw new TypeError(n2 + " is not a function"); + }; + var _e = function() { + }; + var qe = function(e2, n2) { + return void 0 === n2 && (n2 = _e), e2.catch(n2), e2; + }; + var xe = function(e2, n2) { + return e2.addEventListener("abort", n2, { once: true }), function() { + return e2.removeEventListener("abort", n2); + }; + }; + var Me = function(e2, n2) { + var t2 = e2.signal; + t2.aborted || ("reason" in t2 || Object.defineProperty(t2, "reason", { enumerable: true, value: n2, configurable: true, writable: true }), e2.abort(n2)); + }; + var ke = function(e2) { + this.code = e2, this.name = "TaskAbortError", this.message = "task cancelled (reason: " + e2 + ")"; + }; + var Ie = function(e2) { + if (e2.aborted) + throw new ke(e2.reason); + }; + function Te(e2, n2) { + var t2 = _e; + return new Promise(function(r2, i2) { + var o2 = function() { + return i2(new ke(e2.reason)); + }; + e2.aborted ? o2() : (t2 = xe(e2, o2), n2.finally(function() { + return t2(); + }).then(r2, i2)); + }).finally(function() { + t2 = _e; + }); + } + var Ce = function(e2) { + return function(n2) { + return qe(Te(e2, n2).then(function(n3) { + return Ie(e2), n3; + })); + }; + }; + var De = function(e2) { + var n2 = Ce(e2); + return function(e3) { + return n2(new Promise(function(n3) { + return setTimeout(n3, e3); + })); + }; + }; + var Le = Object.assign; + var Re = {}; + var ze = "listenerMiddleware"; + var Ne = function(e2) { + var n2 = e2.type, t2 = e2.actionCreator, r2 = e2.matcher, i2 = e2.predicate, o2 = e2.effect; + if (n2) + i2 = T(n2).match; + else if (t2) + n2 = t2.type, i2 = t2.match; + else if (r2) + i2 = r2; + else if (!i2) + throw new Error("Creating or removing a listener requires one of the known fields for matching an action"); + return Pe(o2, "options.listener"), { predicate: i2, type: n2, effect: o2 }; + }; + var Ve = function(e2) { + e2.pending.forEach(function(e3) { + Me(e3, "listener-cancelled"); + }); + }; + var Be = function(e2, n2, t2) { + try { + e2(n2, t2); + } catch (e3) { + setTimeout(function() { + throw e3; + }, 0); + } + }; + var Fe = T(ze + "/add"); + var Ue = T(ze + "/removeAll"); + var We = T(ze + "/remove"); + var Xe = function() { + for (var e2 = [], n2 = 0; n2 < arguments.length; n2++) + e2[n2] = arguments[n2]; + console.error.apply(console, r([ze + "/error"], e2)); + }; + function Ge(e2) { + var n2 = this; + void 0 === e2 && (e2 = {}); + var r2 = /* @__PURE__ */ new Map(), i2 = e2.extra, o2 = e2.onError, u2 = void 0 === o2 ? Xe : o2; + Pe(u2, "onError"); + var a2 = function(e3) { + for (var n3 = 0, t2 = Array.from(r2.values()); n3 < t2.length; n3++) { + var i3 = t2[n3]; + if (e3(i3)) + return i3; + } + }, c2 = function(e3) { + var n3 = a2(function(n4) { + return n4.effect === e3.effect; + }); + return n3 || (n3 = function(e4) { + var n4 = Ne(e4), t2 = n4.type, r3 = n4.predicate, i3 = n4.effect; + return { id: fe(), effect: i3, type: t2, predicate: r3, pending: /* @__PURE__ */ new Set(), unsubscribe: function() { + throw new Error("Unsubscribe not initialized"); + } }; + }(e3)), function(e4) { + return e4.unsubscribe = function() { + return r2.delete(e4.id); + }, r2.set(e4.id, e4), function(n4) { + e4.unsubscribe(), (null == n4 ? void 0 : n4.cancelActive) && Ve(e4); + }; + }(n3); + }, f2 = function(e3) { + var n3 = Ne(e3), t2 = n3.type, r3 = n3.effect, i3 = n3.predicate, o3 = a2(function(e4) { + return ("string" == typeof t2 ? e4.type === t2 : e4.predicate === i3) && e4.effect === r3; + }); + return o3 && (o3.unsubscribe(), e3.cancelActive && Ve(o3)), !!o3; + }, l2 = function(e3, o3, a3, f3) { + return w(n2, null, function() { + var n3, l3, s3, d2; + return t(this, function(p2) { + switch (p2.label) { + case 0: + n3 = new AbortController(), l3 = function(e4, n4) { + return function(r3, i3) { + return qe(function(r4, i4) { + return w(void 0, null, function() { + var o4, u3, a4, c3; + return t(this, function(t2) { + switch (t2.label) { + case 0: + Ie(n4), o4 = function() { + }, u3 = new Promise(function(n5, t3) { + var i5 = e4({ predicate: r4, effect: function(e5, t4) { + t4.unsubscribe(), n5([e5, t4.getState(), t4.getOriginalState()]); + } }); + o4 = function() { + i5(), t3(); + }; + }), a4 = [u3], null != i4 && a4.push(new Promise(function(e5) { + return setTimeout(e5, i4, null); + })), t2.label = 1; + case 1: + return t2.trys.push([1, , 3, 4]), [4, Te(n4, Promise.race(a4))]; + case 2: + return c3 = t2.sent(), Ie(n4), [2, c3]; + case 3: + return o4(), [7]; + case 4: + return [2]; + } + }); + }); + }(r3, i3)); + }; + }(c2, n3.signal), s3 = [], p2.label = 1; + case 1: + return p2.trys.push([1, 3, 4, 6]), e3.pending.add(n3), [4, Promise.resolve(e3.effect(o3, Le({}, a3, { getOriginalState: f3, condition: function(e4, n4) { + return l3(e4, n4).then(Boolean); + }, take: l3, delay: De(n3.signal), pause: Ce(n3.signal), extra: i2, signal: n3.signal, fork: (v2 = n3.signal, y2 = s3, function(e4, n4) { + Pe(e4, "taskExecutor"); + var r3, i3 = new AbortController(); + r3 = i3, xe(v2, function() { + return Me(r3, v2.reason); + }); + var o4, u3, a4 = (o4 = function() { + return w(void 0, null, function() { + var n5; + return t(this, function(t2) { + switch (t2.label) { + case 0: + return Ie(v2), Ie(i3.signal), [4, e4({ pause: Ce(i3.signal), delay: De(i3.signal), signal: i3.signal })]; + case 1: + return n5 = t2.sent(), Ie(i3.signal), [2, n5]; + } + }); + }); + }, u3 = function() { + return Me(i3, "task-completed"); + }, w(void 0, null, function() { + var e5; + return t(this, function(n5) { + switch (n5.label) { + case 0: + return n5.trys.push([0, 3, 4, 5]), [4, Promise.resolve()]; + case 1: + return n5.sent(), [4, o4()]; + case 2: + return [2, { status: "ok", value: n5.sent() }]; + case 3: + return [2, { status: (e5 = n5.sent()) instanceof ke ? "cancelled" : "rejected", error: e5 }]; + case 4: + return null == u3 || u3(), [7]; + case 5: + return [2]; + } + }); + })); + return (null == n4 ? void 0 : n4.autoJoin) && y2.push(a4), { result: Ce(v2)(a4), cancel: function() { + Me(i3, "task-cancelled"); + } }; + }), unsubscribe: e3.unsubscribe, subscribe: function() { + r2.set(e3.id, e3); + }, cancelActiveListeners: function() { + e3.pending.forEach(function(e4, t2, r3) { + e4 !== n3 && (Me(e4, "listener-cancelled"), r3.delete(e4)); + }); + } })))]; + case 2: + return p2.sent(), [3, 6]; + case 3: + return (d2 = p2.sent()) instanceof ke || Be(u2, d2, { raisedBy: "effect" }), [3, 6]; + case 4: + return [4, Promise.allSettled(s3)]; + case 5: + return p2.sent(), Me(n3, "listener-completed"), e3.pending.delete(n3), [7]; + case 6: + return [2]; + } + var v2, y2; + }); + }); + }, s2 = function(e3) { + return function() { + e3.forEach(Ve), e3.clear(); + }; + }(r2); + return { middleware: function(e3) { + return function(n3) { + return function(t2) { + if (!C(t2)) + return n3(t2); + if (Fe.match(t2)) + return c2(t2.payload); + if (!Ue.match(t2)) { + if (We.match(t2)) + return f2(t2.payload); + var i3, o3 = e3.getState(), a3 = function() { + if (o3 === Re) + throw new Error(ze + ": getOriginalState can only be called synchronously"); + return o3; + }; + try { + if (i3 = n3(t2), r2.size > 0) + for (var d2 = e3.getState(), p2 = Array.from(r2.values()), v2 = 0, y2 = p2; v2 < y2.length; v2++) { + var h2 = y2[v2], g2 = false; + try { + g2 = h2.predicate(t2, d2, o3); + } catch (e4) { + g2 = false, Be(u2, e4, { raisedBy: "predicate" }); + } + g2 && l2(h2, t2, e3, a3); + } + } finally { + o3 = Re; + } + return i3; + } + s2(); + }; + }; + }, startListening: c2, stopListening: f2, clearListeners: s2 }; + } + var He; + var Je = "RTK_autoBatch"; + var Ke = function() { + return function(e2) { + var n2; + return { payload: e2, meta: (n2 = {}, n2[Je] = true, n2) }; + }; + }; + var Qe = "function" == typeof queueMicrotask ? queueMicrotask.bind("undefined" != typeof window ? window : "undefined" != typeof global ? global : globalThis) : function(e2) { + return (He || (He = Promise.resolve())).then(e2).catch(function(e3) { + return setTimeout(function() { + throw e3; + }, 0); + }); + }; + var Ye = function(e2) { + return function(n2) { + setTimeout(n2, e2); + }; + }; + var Ze = "undefined" != typeof window && window.requestAnimationFrame ? window.requestAnimationFrame : Ye(10); + var $e = function(e2) { + return void 0 === e2 && (e2 = { type: "raf" }), function(n2) { + return function() { + for (var t2 = [], r2 = 0; r2 < arguments.length; r2++) + t2[r2] = arguments[r2]; + var i2 = n2.apply(void 0, t2), o2 = true, u2 = false, a2 = false, c2 = /* @__PURE__ */ new Set(), f2 = "tick" === e2.type ? Qe : "raf" === e2.type ? Ze : "callback" === e2.type ? e2.queueNotification : Ye(e2.timeout), l2 = function() { + a2 = false, u2 && (u2 = false, c2.forEach(function(e3) { + return e3(); + })); + }; + return Object.assign({}, i2, { subscribe: function(e3) { + var n3 = i2.subscribe(function() { + return o2 && e3(); + }); + return c2.add(e3), function() { + n3(), c2.delete(e3); + }; + }, dispatch: function(e3) { + var n3; + try { + return o2 = !(null == (n3 = null == e3 ? void 0 : e3.meta) ? void 0 : n3[Je]), (u2 = !o2) && (a2 || (a2 = true, f2(l2))), i2.dispatch(e3); + } finally { + o2 = true; + } + } }); + }; + }; + }; + (0, O.enableES5)(); + } +}); + +// node_modules/@reduxjs/toolkit/dist/redux-toolkit.cjs.development.js +var require_redux_toolkit_cjs_development = __commonJS({ + "node_modules/@reduxjs/toolkit/dist/redux-toolkit.cjs.development.js"(exports) { + init_cjs_shim(); + var __extends = exports && exports.__extends || function() { + var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { + d2.__proto__ = b2; + } || function(d2, b2) { + for (var p in b2) + if (Object.prototype.hasOwnProperty.call(b2, p)) + d2[p] = b2[p]; + }; + return extendStatics(d, b); + }; + return function(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + }(); + var __generator = exports && exports.__generator || function(thisArg, body) { + var _ = { label: 0, sent: function() { + if (t[0] & 1) + throw t[1]; + return t[1]; + }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { + return this; + }), g; + function verb(n) { + return function(v) { + return step([n, v]); + }; + } + function step(op) { + if (f) + throw new TypeError("Generator is already executing."); + while (_) + try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) + return t; + if (y = 0, t) + op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: + case 1: + t = op; + break; + case 4: + _.label++; + return { value: op[1], done: false }; + case 5: + _.label++; + y = op[1]; + op = [0]; + continue; + case 7: + op = _.ops.pop(); + _.trys.pop(); + continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { + _ = 0; + continue; + } + if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { + _.label = op[1]; + break; + } + if (op[0] === 6 && _.label < t[1]) { + _.label = t[1]; + t = op; + break; + } + if (t && _.label < t[2]) { + _.label = t[2]; + _.ops.push(op); + break; + } + if (t[2]) + _.ops.pop(); + _.trys.pop(); + continue; + } + op = body.call(thisArg, _); + } catch (e) { + op = [6, e]; + y = 0; + } finally { + f = t = 0; + } + if (op[0] & 5) + throw op[1]; + return { value: op[0] ? op[1] : void 0, done: true }; + } + }; + var __spreadArray = exports && exports.__spreadArray || function(to, from) { + for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) + to[j] = from[i]; + return to; + }; + var __create = Object.create; + var __defProp = Object.defineProperty; + var __defProps = Object.defineProperties; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropDescs = Object.getOwnPropertyDescriptors; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getOwnPropSymbols = Object.getOwnPropertySymbols; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __propIsEnum = Object.prototype.propertyIsEnumerable; + var __defNormalProp = function(obj, key, value) { + return key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; + }; + var __spreadValues = function(a, b) { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var _i = 0, _c = __getOwnPropSymbols(b); _i < _c.length; _i++) { + var prop = _c[_i]; + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; + }; + var __spreadProps = function(a, b) { + return __defProps(a, __getOwnPropDescs(b)); + }; + var __markAsModule = function(target) { + return __defProp(target, "__esModule", { value: true }); + }; + var __export = function(target, all) { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __reExport = function(target, module2, desc) { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + var _loop_1 = function(key2) { + if (!__hasOwnProp.call(target, key2) && key2 !== "default") + __defProp(target, key2, { get: function() { + return module2[key2]; + }, enumerable: !(desc = __getOwnPropDesc(module2, key2)) || desc.enumerable }); + }; + for (var _i = 0, _c = __getOwnPropNames(module2); _i < _c.length; _i++) { + var key = _c[_i]; + _loop_1(key); + } + } + return target; + }; + var __toModule = function(module2) { + return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: function() { + return module2.default; + }, enumerable: true } : { value: module2, enumerable: true })), module2); + }; + var __async = function(__this, __arguments, generator) { + return new Promise(function(resolve, reject) { + var fulfilled = function(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = function(value) { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = function(x) { + return x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + }; + step((generator = generator.apply(__this, __arguments)).next()); + }); + }; + __markAsModule(exports); + __export(exports, { + EnhancerArray: function() { + return EnhancerArray; + }, + MiddlewareArray: function() { + return MiddlewareArray; + }, + SHOULD_AUTOBATCH: function() { + return SHOULD_AUTOBATCH; + }, + TaskAbortError: function() { + return TaskAbortError; + }, + addListener: function() { + return addListener; + }, + autoBatchEnhancer: function() { + return autoBatchEnhancer; + }, + clearAllListeners: function() { + return clearAllListeners; + }, + configureStore: function() { + return configureStore; + }, + createAction: function() { + return createAction; + }, + createActionCreatorInvariantMiddleware: function() { + return createActionCreatorInvariantMiddleware; + }, + createAsyncThunk: function() { + return createAsyncThunk; + }, + createDraftSafeSelector: function() { + return createDraftSafeSelector; + }, + createEntityAdapter: function() { + return createEntityAdapter; + }, + createImmutableStateInvariantMiddleware: function() { + return createImmutableStateInvariantMiddleware; + }, + createListenerMiddleware: function() { + return createListenerMiddleware; + }, + createNextState: function() { + return import_immer6.default; + }, + createReducer: function() { + return createReducer; + }, + createSelector: function() { + return import_reselect2.createSelector; + }, + createSerializableStateInvariantMiddleware: function() { + return createSerializableStateInvariantMiddleware; + }, + createSlice: function() { + return createSlice2; + }, + current: function() { + return import_immer6.current; + }, + findNonSerializableValue: function() { + return findNonSerializableValue; + }, + freeze: function() { + return import_immer6.freeze; + }, + getDefaultMiddleware: function() { + return getDefaultMiddleware; + }, + getType: function() { + return getType; + }, + isAction: function() { + return isAction; + }, + isActionCreator: function() { + return isActionCreator; + }, + isAllOf: function() { + return isAllOf; + }, + isAnyOf: function() { + return isAnyOf; + }, + isAsyncThunkAction: function() { + return isAsyncThunkAction; + }, + isDraft: function() { + return import_immer6.isDraft; + }, + isFluxStandardAction: function() { + return isFSA; + }, + isFulfilled: function() { + return isFulfilled; + }, + isImmutableDefault: function() { + return isImmutableDefault; + }, + isPending: function() { + return isPending; + }, + isPlain: function() { + return isPlain; + }, + isPlainObject: function() { + return isPlainObject; + }, + isRejected: function() { + return isRejected; + }, + isRejectedWithValue: function() { + return isRejectedWithValue; + }, + miniSerializeError: function() { + return miniSerializeError; + }, + nanoid: function() { + return nanoid; + }, + original: function() { + return import_immer6.original; + }, + prepareAutoBatched: function() { + return prepareAutoBatched; + }, + removeListener: function() { + return removeListener; + }, + unwrapResult: function() { + return unwrapResult; + } + }); + var import_immer5 = __toModule(require_dist()); + __reExport(exports, __toModule(require_redux())); + var import_immer6 = __toModule(require_dist()); + var import_reselect2 = __toModule(require_lib()); + var import_immer = __toModule(require_dist()); + var import_reselect = __toModule(require_lib()); + var createDraftSafeSelector = function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var selector = (0, import_reselect.createSelector).apply(void 0, args); + var wrappedSelector = function(value) { + var rest = []; + for (var _i2 = 1; _i2 < arguments.length; _i2++) { + rest[_i2 - 1] = arguments[_i2]; + } + return selector.apply(void 0, __spreadArray([(0, import_immer.isDraft)(value) ? (0, import_immer.current)(value) : value], rest)); + }; + return wrappedSelector; + }; + var import_redux2 = __toModule(require_redux()); + var import_redux = __toModule(require_redux()); + var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() { + if (arguments.length === 0) + return void 0; + if (typeof arguments[0] === "object") + return import_redux.compose; + return import_redux.compose.apply(null, arguments); + }; + var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() { + return function(noop2) { + return noop2; + }; + }; + function isPlainObject(value) { + if (typeof value !== "object" || value === null) + return false; + var proto = Object.getPrototypeOf(value); + if (proto === null) + return true; + var baseProto = proto; + while (Object.getPrototypeOf(baseProto) !== null) { + baseProto = Object.getPrototypeOf(baseProto); + } + return proto === baseProto; + } + var import_redux_thunk = __toModule(require_lib2()); + var hasMatchFunction = function(v) { + return v && typeof v.match === "function"; + }; + function createAction(type, prepareAction) { + function actionCreator() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + if (prepareAction) { + var prepared = prepareAction.apply(void 0, args); + if (!prepared) { + throw new Error("prepareAction did not return an object"); + } + return __spreadValues(__spreadValues({ + type, + payload: prepared.payload + }, "meta" in prepared && { meta: prepared.meta }), "error" in prepared && { error: prepared.error }); + } + return { type, payload: args[0] }; + } + actionCreator.toString = function() { + return "" + type; + }; + actionCreator.type = type; + actionCreator.match = function(action) { + return action.type === type; + }; + return actionCreator; + } + function isAction(action) { + return isPlainObject(action) && "type" in action; + } + function isActionCreator(action) { + return typeof action === "function" && "type" in action && hasMatchFunction(action); + } + function isFSA(action) { + return isAction(action) && typeof action.type === "string" && Object.keys(action).every(isValidKey); + } + function isValidKey(key) { + return ["type", "payload", "error", "meta"].indexOf(key) > -1; + } + function getType(actionCreator) { + return "" + actionCreator; + } + function getMessage(type) { + var splitType = type ? ("" + type).split("/") : []; + var actionName = splitType[splitType.length - 1] || "actionCreator"; + return 'Detected an action creator with type "' + (type || "unknown") + "\" being dispatched. \nMake sure you're calling the action creator before dispatching, i.e. `dispatch(" + actionName + "())` instead of `dispatch(" + actionName + ")`. This is necessary even if the action has no payload."; + } + function createActionCreatorInvariantMiddleware(options) { + if (options === void 0) { + options = {}; + } + if (false) { + return function() { + return function(next) { + return function(action) { + return next(action); + }; + }; + }; + } + var _c = options.isActionCreator, isActionCreator2 = _c === void 0 ? isActionCreator : _c; + return function() { + return function(next) { + return function(action) { + if (isActionCreator2(action)) { + console.warn(getMessage(action.type)); + } + return next(action); + }; + }; + }; + } + var import_immer2 = __toModule(require_dist()); + function getTimeMeasureUtils(maxDelay, fnName) { + var elapsed = 0; + return { + measureTime: function(fn) { + var started = Date.now(); + try { + return fn(); + } finally { + var finished = Date.now(); + elapsed += finished - started; + } + }, + warnIfExceeded: function() { + if (elapsed > maxDelay) { + console.warn(fnName + " took " + elapsed + "ms, which is more than the warning threshold of " + maxDelay + "ms. \nIf your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.\nIt is disabled in production builds, so you don't need to worry about that."); + } + } + }; + } + var MiddlewareArray = ( + /** @class */ + function(_super) { + __extends(MiddlewareArray2, _super); + function MiddlewareArray2() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var _this = _super.apply(this, args) || this; + Object.setPrototypeOf(_this, MiddlewareArray2.prototype); + return _this; + } + Object.defineProperty(MiddlewareArray2, Symbol.species, { + get: function() { + return MiddlewareArray2; + }, + enumerable: false, + configurable: true + }); + MiddlewareArray2.prototype.concat = function() { + var arr = []; + for (var _i = 0; _i < arguments.length; _i++) { + arr[_i] = arguments[_i]; + } + return _super.prototype.concat.apply(this, arr); + }; + MiddlewareArray2.prototype.prepend = function() { + var arr = []; + for (var _i = 0; _i < arguments.length; _i++) { + arr[_i] = arguments[_i]; + } + if (arr.length === 1 && Array.isArray(arr[0])) { + return new (MiddlewareArray2.bind.apply(MiddlewareArray2, __spreadArray([void 0], arr[0].concat(this))))(); + } + return new (MiddlewareArray2.bind.apply(MiddlewareArray2, __spreadArray([void 0], arr.concat(this))))(); + }; + return MiddlewareArray2; + }(Array) + ); + var EnhancerArray = ( + /** @class */ + function(_super) { + __extends(EnhancerArray2, _super); + function EnhancerArray2() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var _this = _super.apply(this, args) || this; + Object.setPrototypeOf(_this, EnhancerArray2.prototype); + return _this; + } + Object.defineProperty(EnhancerArray2, Symbol.species, { + get: function() { + return EnhancerArray2; + }, + enumerable: false, + configurable: true + }); + EnhancerArray2.prototype.concat = function() { + var arr = []; + for (var _i = 0; _i < arguments.length; _i++) { + arr[_i] = arguments[_i]; + } + return _super.prototype.concat.apply(this, arr); + }; + EnhancerArray2.prototype.prepend = function() { + var arr = []; + for (var _i = 0; _i < arguments.length; _i++) { + arr[_i] = arguments[_i]; + } + if (arr.length === 1 && Array.isArray(arr[0])) { + return new (EnhancerArray2.bind.apply(EnhancerArray2, __spreadArray([void 0], arr[0].concat(this))))(); + } + return new (EnhancerArray2.bind.apply(EnhancerArray2, __spreadArray([void 0], arr.concat(this))))(); + }; + return EnhancerArray2; + }(Array) + ); + function freezeDraftable(val) { + return (0, import_immer2.isDraftable)(val) ? (0, import_immer2.default)(val, function() { + }) : val; + } + var isProduction = false; + var prefix = "Invariant failed"; + function invariant(condition, message) { + if (condition) { + return; + } + if (isProduction) { + throw new Error(prefix); + } + throw new Error(prefix + ": " + (message || "")); + } + function stringify(obj, serializer, indent, decycler) { + return JSON.stringify(obj, getSerialize(serializer, decycler), indent); + } + function getSerialize(serializer, decycler) { + var stack = [], keys = []; + if (!decycler) + decycler = function(_, value) { + if (stack[0] === value) + return "[Circular ~]"; + return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]"; + }; + return function(key, value) { + if (stack.length > 0) { + var thisPos = stack.indexOf(this); + ~thisPos ? stack.splice(thisPos + 1) : stack.push(this); + ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key); + if (~stack.indexOf(value)) + value = decycler.call(this, key, value); + } else + stack.push(value); + return serializer == null ? value : serializer.call(this, key, value); + }; + } + function isImmutableDefault(value) { + return typeof value !== "object" || value == null || Object.isFrozen(value); + } + function trackForMutations(isImmutable, ignorePaths, obj) { + var trackedProperties = trackProperties(isImmutable, ignorePaths, obj); + return { + detectMutations: function() { + return detectMutations(isImmutable, ignorePaths, trackedProperties, obj); + } + }; + } + function trackProperties(isImmutable, ignorePaths, obj, path, checkedObjects) { + if (ignorePaths === void 0) { + ignorePaths = []; + } + if (path === void 0) { + path = ""; + } + if (checkedObjects === void 0) { + checkedObjects = /* @__PURE__ */ new Set(); + } + var tracked = { value: obj }; + if (!isImmutable(obj) && !checkedObjects.has(obj)) { + checkedObjects.add(obj); + tracked.children = {}; + for (var key in obj) { + var childPath = path ? path + "." + key : key; + if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) { + continue; + } + tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath); + } + } + return tracked; + } + function detectMutations(isImmutable, ignoredPaths, trackedProperty, obj, sameParentRef, path) { + if (ignoredPaths === void 0) { + ignoredPaths = []; + } + if (sameParentRef === void 0) { + sameParentRef = false; + } + if (path === void 0) { + path = ""; + } + var prevObj = trackedProperty ? trackedProperty.value : void 0; + var sameRef = prevObj === obj; + if (sameParentRef && !sameRef && !Number.isNaN(obj)) { + return { wasMutated: true, path }; + } + if (isImmutable(prevObj) || isImmutable(obj)) { + return { wasMutated: false }; + } + var keysToDetect = {}; + for (var key in trackedProperty.children) { + keysToDetect[key] = true; + } + for (var key in obj) { + keysToDetect[key] = true; + } + var hasIgnoredPaths = ignoredPaths.length > 0; + var _loop_2 = function(key2) { + var nestedPath = path ? path + "." + key2 : key2; + if (hasIgnoredPaths) { + var hasMatches = ignoredPaths.some(function(ignored) { + if (ignored instanceof RegExp) { + return ignored.test(nestedPath); + } + return nestedPath === ignored; + }); + if (hasMatches) { + return "continue"; + } + } + var result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key2], obj[key2], sameRef, nestedPath); + if (result.wasMutated) { + return { value: result }; + } + }; + for (var key in keysToDetect) { + var state_1 = _loop_2(key); + if (typeof state_1 === "object") + return state_1.value; + } + return { wasMutated: false }; + } + function createImmutableStateInvariantMiddleware(options) { + if (options === void 0) { + options = {}; + } + if (false) { + return function() { + return function(next) { + return function(action) { + return next(action); + }; + }; + }; + } + var _c = options.isImmutable, isImmutable = _c === void 0 ? isImmutableDefault : _c, ignoredPaths = options.ignoredPaths, _d = options.warnAfter, warnAfter = _d === void 0 ? 32 : _d, ignore = options.ignore; + ignoredPaths = ignoredPaths || ignore; + var track = trackForMutations.bind(null, isImmutable, ignoredPaths); + return function(_c2) { + var getState = _c2.getState; + var state = getState(); + var tracker = track(state); + var result; + return function(next) { + return function(action) { + var measureUtils = getTimeMeasureUtils(warnAfter, "ImmutableStateInvariantMiddleware"); + measureUtils.measureTime(function() { + state = getState(); + result = tracker.detectMutations(); + tracker = track(state); + invariant(!result.wasMutated, "A state mutation was detected between dispatches, in the path '" + (result.path || "") + "'. This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)"); + }); + var dispatchedAction = next(action); + measureUtils.measureTime(function() { + state = getState(); + result = tracker.detectMutations(); + tracker = track(state); + result.wasMutated && invariant(!result.wasMutated, "A state mutation was detected inside a dispatch, in the path: " + (result.path || "") + ". Take a look at the reducer(s) handling the action " + stringify(action) + ". (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)"); + }); + measureUtils.warnIfExceeded(); + return dispatchedAction; + }; + }; + }; + } + function isPlain(val) { + var type = typeof val; + return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || isPlainObject(val); + } + function findNonSerializableValue(value, path, isSerializable, getEntries, ignoredPaths, cache) { + if (path === void 0) { + path = ""; + } + if (isSerializable === void 0) { + isSerializable = isPlain; + } + if (ignoredPaths === void 0) { + ignoredPaths = []; + } + var foundNestedSerializable; + if (!isSerializable(value)) { + return { + keyPath: path || "", + value + }; + } + if (typeof value !== "object" || value === null) { + return false; + } + if (cache == null ? void 0 : cache.has(value)) + return false; + var entries = getEntries != null ? getEntries(value) : Object.entries(value); + var hasIgnoredPaths = ignoredPaths.length > 0; + var _loop_3 = function(key2, nestedValue2) { + var nestedPath = path ? path + "." + key2 : key2; + if (hasIgnoredPaths) { + var hasMatches = ignoredPaths.some(function(ignored) { + if (ignored instanceof RegExp) { + return ignored.test(nestedPath); + } + return nestedPath === ignored; + }); + if (hasMatches) { + return "continue"; + } + } + if (!isSerializable(nestedValue2)) { + return { value: { + keyPath: nestedPath, + value: nestedValue2 + } }; + } + if (typeof nestedValue2 === "object") { + foundNestedSerializable = findNonSerializableValue(nestedValue2, nestedPath, isSerializable, getEntries, ignoredPaths, cache); + if (foundNestedSerializable) { + return { value: foundNestedSerializable }; + } + } + }; + for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) { + var _c = entries_1[_i], key = _c[0], nestedValue = _c[1]; + var state_2 = _loop_3(key, nestedValue); + if (typeof state_2 === "object") + return state_2.value; + } + if (cache && isNestedFrozen(value)) + cache.add(value); + return false; + } + function isNestedFrozen(value) { + if (!Object.isFrozen(value)) + return false; + for (var _i = 0, _c = Object.values(value); _i < _c.length; _i++) { + var nestedValue = _c[_i]; + if (typeof nestedValue !== "object" || nestedValue === null) + continue; + if (!isNestedFrozen(nestedValue)) + return false; + } + return true; + } + function createSerializableStateInvariantMiddleware(options) { + if (options === void 0) { + options = {}; + } + if (false) { + return function() { + return function(next) { + return function(action) { + return next(action); + }; + }; + }; + } + var _c = options.isSerializable, isSerializable = _c === void 0 ? isPlain : _c, getEntries = options.getEntries, _d = options.ignoredActions, ignoredActions = _d === void 0 ? [] : _d, _e = options.ignoredActionPaths, ignoredActionPaths = _e === void 0 ? ["meta.arg", "meta.baseQueryMeta"] : _e, _f = options.ignoredPaths, ignoredPaths = _f === void 0 ? [] : _f, _g = options.warnAfter, warnAfter = _g === void 0 ? 32 : _g, _h = options.ignoreState, ignoreState = _h === void 0 ? false : _h, _j = options.ignoreActions, ignoreActions = _j === void 0 ? false : _j, _k = options.disableCache, disableCache = _k === void 0 ? false : _k; + var cache = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0; + return function(storeAPI) { + return function(next) { + return function(action) { + var result = next(action); + var measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware"); + if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) { + measureUtils.measureTime(function() { + var foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache); + if (foundActionNonSerializableValue) { + var keyPath = foundActionNonSerializableValue.keyPath, value = foundActionNonSerializableValue.value; + console.error("A non-serializable value was detected in an action, in the path: `" + keyPath + "`. Value:", value, "\nTake a look at the logic that dispatched this action: ", action, "\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)", "\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)"); + } + }); + } + if (!ignoreState) { + measureUtils.measureTime(function() { + var state = storeAPI.getState(); + var foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache); + if (foundStateNonSerializableValue) { + var keyPath = foundStateNonSerializableValue.keyPath, value = foundStateNonSerializableValue.value; + console.error("A non-serializable value was detected in the state, in the path: `" + keyPath + "`. Value:", value, "\nTake a look at the reducer(s) handling this action type: " + action.type + ".\n(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)"); + } + }); + measureUtils.warnIfExceeded(); + } + return result; + }; + }; + }; + } + function isBoolean(x) { + return typeof x === "boolean"; + } + function curryGetDefaultMiddleware() { + return function curriedGetDefaultMiddleware(options) { + return getDefaultMiddleware(options); + }; + } + function getDefaultMiddleware(options) { + if (options === void 0) { + options = {}; + } + var _c = options.thunk, thunk = _c === void 0 ? true : _c, _d = options.immutableCheck, immutableCheck = _d === void 0 ? true : _d, _e = options.serializableCheck, serializableCheck = _e === void 0 ? true : _e, _f = options.actionCreatorCheck, actionCreatorCheck = _f === void 0 ? true : _f; + var middlewareArray = new MiddlewareArray(); + if (thunk) { + if (isBoolean(thunk)) { + middlewareArray.push(import_redux_thunk.default); + } else { + middlewareArray.push(import_redux_thunk.default.withExtraArgument(thunk.extraArgument)); + } + } + if (true) { + if (immutableCheck) { + var immutableOptions = {}; + if (!isBoolean(immutableCheck)) { + immutableOptions = immutableCheck; + } + middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions)); + } + if (serializableCheck) { + var serializableOptions = {}; + if (!isBoolean(serializableCheck)) { + serializableOptions = serializableCheck; + } + middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions)); + } + if (actionCreatorCheck) { + var actionCreatorOptions = {}; + if (!isBoolean(actionCreatorCheck)) { + actionCreatorOptions = actionCreatorCheck; + } + middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions)); + } + } + return middlewareArray; + } + var IS_PRODUCTION = false; + function configureStore(options) { + var curriedGetDefaultMiddleware = curryGetDefaultMiddleware(); + var _c = options || {}, _d = _c.reducer, reducer = _d === void 0 ? void 0 : _d, _e = _c.middleware, middleware = _e === void 0 ? curriedGetDefaultMiddleware() : _e, _f = _c.devTools, devTools = _f === void 0 ? true : _f, _g = _c.preloadedState, preloadedState = _g === void 0 ? void 0 : _g, _h = _c.enhancers, enhancers = _h === void 0 ? void 0 : _h; + var rootReducer; + if (typeof reducer === "function") { + rootReducer = reducer; + } else if (isPlainObject(reducer)) { + rootReducer = (0, import_redux2.combineReducers)(reducer); + } else { + throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers'); + } + var finalMiddleware = middleware; + if (typeof finalMiddleware === "function") { + finalMiddleware = finalMiddleware(curriedGetDefaultMiddleware); + if (!IS_PRODUCTION && !Array.isArray(finalMiddleware)) { + throw new Error("when using a middleware builder function, an array of middleware must be returned"); + } + } + if (!IS_PRODUCTION && finalMiddleware.some(function(item) { + return typeof item !== "function"; + })) { + throw new Error("each middleware provided to configureStore must be a function"); + } + var middlewareEnhancer = (0, import_redux2.applyMiddleware).apply(void 0, finalMiddleware); + var finalCompose = import_redux2.compose; + if (devTools) { + finalCompose = composeWithDevTools(__spreadValues({ + trace: !IS_PRODUCTION + }, typeof devTools === "object" && devTools)); + } + var defaultEnhancers = new EnhancerArray(middlewareEnhancer); + var storeEnhancers = defaultEnhancers; + if (Array.isArray(enhancers)) { + storeEnhancers = __spreadArray([middlewareEnhancer], enhancers); + } else if (typeof enhancers === "function") { + storeEnhancers = enhancers(defaultEnhancers); + } + var composedEnhancer = finalCompose.apply(void 0, storeEnhancers); + return (0, import_redux2.createStore)(rootReducer, preloadedState, composedEnhancer); + } + var import_immer3 = __toModule(require_dist()); + function executeReducerBuilderCallback(builderCallback) { + var actionsMap = {}; + var actionMatchers = []; + var defaultCaseReducer; + var builder = { + addCase: function(typeOrActionCreator, reducer) { + if (true) { + if (actionMatchers.length > 0) { + throw new Error("`builder.addCase` should only be called before calling `builder.addMatcher`"); + } + if (defaultCaseReducer) { + throw new Error("`builder.addCase` should only be called before calling `builder.addDefaultCase`"); + } + } + var type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type; + if (!type) { + throw new Error("`builder.addCase` cannot be called with an empty action type"); + } + if (type in actionsMap) { + throw new Error("`builder.addCase` cannot be called with two reducers for the same action type"); + } + actionsMap[type] = reducer; + return builder; + }, + addMatcher: function(matcher, reducer) { + if (true) { + if (defaultCaseReducer) { + throw new Error("`builder.addMatcher` should only be called before calling `builder.addDefaultCase`"); + } + } + actionMatchers.push({ matcher, reducer }); + return builder; + }, + addDefaultCase: function(reducer) { + if (true) { + if (defaultCaseReducer) { + throw new Error("`builder.addDefaultCase` can only be called once"); + } + } + defaultCaseReducer = reducer; + return builder; + } + }; + builderCallback(builder); + return [actionsMap, actionMatchers, defaultCaseReducer]; + } + function isStateFunction(x) { + return typeof x === "function"; + } + var hasWarnedAboutObjectNotation = false; + function createReducer(initialState2, mapOrBuilderCallback, actionMatchers, defaultCaseReducer) { + if (actionMatchers === void 0) { + actionMatchers = []; + } + if (true) { + if (typeof mapOrBuilderCallback === "object") { + if (!hasWarnedAboutObjectNotation) { + hasWarnedAboutObjectNotation = true; + console.warn("The object notation for `createReducer` is deprecated, and will be removed in RTK 2.0. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer"); + } + } + } + var _c = typeof mapOrBuilderCallback === "function" ? executeReducerBuilderCallback(mapOrBuilderCallback) : [mapOrBuilderCallback, actionMatchers, defaultCaseReducer], actionsMap = _c[0], finalActionMatchers = _c[1], finalDefaultCaseReducer = _c[2]; + var getInitialState; + if (isStateFunction(initialState2)) { + getInitialState = function() { + return freezeDraftable(initialState2()); + }; + } else { + var frozenInitialState_1 = freezeDraftable(initialState2); + getInitialState = function() { + return frozenInitialState_1; + }; + } + function reducer(state, action) { + if (state === void 0) { + state = getInitialState(); + } + var caseReducers = __spreadArray([ + actionsMap[action.type] + ], finalActionMatchers.filter(function(_c2) { + var matcher = _c2.matcher; + return matcher(action); + }).map(function(_c2) { + var reducer2 = _c2.reducer; + return reducer2; + })); + if (caseReducers.filter(function(cr) { + return !!cr; + }).length === 0) { + caseReducers = [finalDefaultCaseReducer]; + } + return caseReducers.reduce(function(previousState, caseReducer) { + if (caseReducer) { + if ((0, import_immer3.isDraft)(previousState)) { + var draft = previousState; + var result = caseReducer(draft, action); + if (result === void 0) { + return previousState; + } + return result; + } else if (!(0, import_immer3.isDraftable)(previousState)) { + var result = caseReducer(previousState, action); + if (result === void 0) { + if (previousState === null) { + return previousState; + } + throw Error("A case reducer on a non-draftable value must not return undefined"); + } + return result; + } else { + return (0, import_immer3.default)(previousState, function(draft2) { + return caseReducer(draft2, action); + }); + } + } + return previousState; + }, state); + } + reducer.getInitialState = getInitialState; + return reducer; + } + var hasWarnedAboutObjectNotation2 = false; + function getType2(slice, actionKey) { + return slice + "/" + actionKey; + } + function createSlice2(options) { + var name = options.name; + if (!name) { + throw new Error("`name` is a required option for createSlice"); + } + if (typeof process !== "undefined" && true) { + if (options.initialState === void 0) { + console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`"); + } + } + var initialState2 = typeof options.initialState == "function" ? options.initialState : freezeDraftable(options.initialState); + var reducers = options.reducers || {}; + var reducerNames = Object.keys(reducers); + var sliceCaseReducersByName = {}; + var sliceCaseReducersByType = {}; + var actionCreators = {}; + reducerNames.forEach(function(reducerName) { + var maybeReducerWithPrepare = reducers[reducerName]; + var type = getType2(name, reducerName); + var caseReducer; + var prepareCallback; + if ("reducer" in maybeReducerWithPrepare) { + caseReducer = maybeReducerWithPrepare.reducer; + prepareCallback = maybeReducerWithPrepare.prepare; + } else { + caseReducer = maybeReducerWithPrepare; + } + sliceCaseReducersByName[reducerName] = caseReducer; + sliceCaseReducersByType[type] = caseReducer; + actionCreators[reducerName] = prepareCallback ? createAction(type, prepareCallback) : createAction(type); + }); + function buildReducer() { + if (true) { + if (typeof options.extraReducers === "object") { + if (!hasWarnedAboutObjectNotation2) { + hasWarnedAboutObjectNotation2 = true; + console.warn("The object notation for `createSlice.extraReducers` is deprecated, and will be removed in RTK 2.0. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice"); + } + } + } + var _c = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers], _d = _c[0], extraReducers = _d === void 0 ? {} : _d, _e = _c[1], actionMatchers = _e === void 0 ? [] : _e, _f = _c[2], defaultCaseReducer = _f === void 0 ? void 0 : _f; + var finalCaseReducers = __spreadValues(__spreadValues({}, extraReducers), sliceCaseReducersByType); + return createReducer(initialState2, function(builder) { + for (var key in finalCaseReducers) { + builder.addCase(key, finalCaseReducers[key]); + } + for (var _i = 0, actionMatchers_1 = actionMatchers; _i < actionMatchers_1.length; _i++) { + var m = actionMatchers_1[_i]; + builder.addMatcher(m.matcher, m.reducer); + } + if (defaultCaseReducer) { + builder.addDefaultCase(defaultCaseReducer); + } + }); + } + var _reducer; + return { + name, + reducer: function(state, action) { + if (!_reducer) + _reducer = buildReducer(); + return _reducer(state, action); + }, + actions: actionCreators, + caseReducers: sliceCaseReducersByName, + getInitialState: function() { + if (!_reducer) + _reducer = buildReducer(); + return _reducer.getInitialState(); + } + }; + } + function getInitialEntityState() { + return { + ids: [], + entities: {} + }; + } + function createInitialStateFactory() { + function getInitialState(additionalState) { + if (additionalState === void 0) { + additionalState = {}; + } + return Object.assign(getInitialEntityState(), additionalState); + } + return { getInitialState }; + } + function createSelectorsFactory() { + function getSelectors(selectState) { + var selectIds = function(state) { + return state.ids; + }; + var selectEntities = function(state) { + return state.entities; + }; + var selectAll = createDraftSafeSelector(selectIds, selectEntities, function(ids, entities) { + return ids.map(function(id) { + return entities[id]; + }); + }); + var selectId = function(_, id) { + return id; + }; + var selectById = function(entities, id) { + return entities[id]; + }; + var selectTotal = createDraftSafeSelector(selectIds, function(ids) { + return ids.length; + }); + if (!selectState) { + return { + selectIds, + selectEntities, + selectAll, + selectTotal, + selectById: createDraftSafeSelector(selectEntities, selectId, selectById) + }; + } + var selectGlobalizedEntities = createDraftSafeSelector(selectState, selectEntities); + return { + selectIds: createDraftSafeSelector(selectState, selectIds), + selectEntities: selectGlobalizedEntities, + selectAll: createDraftSafeSelector(selectState, selectAll), + selectTotal: createDraftSafeSelector(selectState, selectTotal), + selectById: createDraftSafeSelector(selectGlobalizedEntities, selectId, selectById) + }; + } + return { getSelectors }; + } + var import_immer4 = __toModule(require_dist()); + function createSingleArgumentStateOperator(mutator) { + var operator = createStateOperator(function(_, state) { + return mutator(state); + }); + return function operation(state) { + return operator(state, void 0); + }; + } + function createStateOperator(mutator) { + return function operation(state, arg) { + function isPayloadActionArgument(arg2) { + return isFSA(arg2); + } + var runMutator = function(draft) { + if (isPayloadActionArgument(arg)) { + mutator(arg.payload, draft); + } else { + mutator(arg, draft); + } + }; + if ((0, import_immer4.isDraft)(state)) { + runMutator(state); + return state; + } else { + return (0, import_immer4.default)(state, runMutator); + } + }; + } + function selectIdValue(entity, selectId) { + var key = selectId(entity); + if (key === void 0) { + console.warn("The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString()); + } + return key; + } + function ensureEntitiesArray(entities) { + if (!Array.isArray(entities)) { + entities = Object.values(entities); + } + return entities; + } + function splitAddedUpdatedEntities(newEntities, selectId, state) { + newEntities = ensureEntitiesArray(newEntities); + var added = []; + var updated = []; + for (var _i = 0, newEntities_1 = newEntities; _i < newEntities_1.length; _i++) { + var entity = newEntities_1[_i]; + var id = selectIdValue(entity, selectId); + if (id in state.entities) { + updated.push({ id, changes: entity }); + } else { + added.push(entity); + } + } + return [added, updated]; + } + function createUnsortedStateAdapter(selectId) { + function addOneMutably(entity, state) { + var key = selectIdValue(entity, selectId); + if (key in state.entities) { + return; + } + state.ids.push(key); + state.entities[key] = entity; + } + function addManyMutably(newEntities, state) { + newEntities = ensureEntitiesArray(newEntities); + for (var _i = 0, newEntities_2 = newEntities; _i < newEntities_2.length; _i++) { + var entity = newEntities_2[_i]; + addOneMutably(entity, state); + } + } + function setOneMutably(entity, state) { + var key = selectIdValue(entity, selectId); + if (!(key in state.entities)) { + state.ids.push(key); + } + state.entities[key] = entity; + } + function setManyMutably(newEntities, state) { + newEntities = ensureEntitiesArray(newEntities); + for (var _i = 0, newEntities_3 = newEntities; _i < newEntities_3.length; _i++) { + var entity = newEntities_3[_i]; + setOneMutably(entity, state); + } + } + function setAllMutably(newEntities, state) { + newEntities = ensureEntitiesArray(newEntities); + state.ids = []; + state.entities = {}; + addManyMutably(newEntities, state); + } + function removeOneMutably(key, state) { + return removeManyMutably([key], state); + } + function removeManyMutably(keys, state) { + var didMutate = false; + keys.forEach(function(key) { + if (key in state.entities) { + delete state.entities[key]; + didMutate = true; + } + }); + if (didMutate) { + state.ids = state.ids.filter(function(id) { + return id in state.entities; + }); + } + } + function removeAllMutably(state) { + Object.assign(state, { + ids: [], + entities: {} + }); + } + function takeNewKey(keys, update, state) { + var original2 = state.entities[update.id]; + var updated = Object.assign({}, original2, update.changes); + var newKey = selectIdValue(updated, selectId); + var hasNewKey = newKey !== update.id; + if (hasNewKey) { + keys[update.id] = newKey; + delete state.entities[update.id]; + } + state.entities[newKey] = updated; + return hasNewKey; + } + function updateOneMutably(update, state) { + return updateManyMutably([update], state); + } + function updateManyMutably(updates, state) { + var newKeys = {}; + var updatesPerEntity = {}; + updates.forEach(function(update) { + if (update.id in state.entities) { + updatesPerEntity[update.id] = { + id: update.id, + changes: __spreadValues(__spreadValues({}, updatesPerEntity[update.id] ? updatesPerEntity[update.id].changes : null), update.changes) + }; + } + }); + updates = Object.values(updatesPerEntity); + var didMutateEntities = updates.length > 0; + if (didMutateEntities) { + var didMutateIds = updates.filter(function(update) { + return takeNewKey(newKeys, update, state); + }).length > 0; + if (didMutateIds) { + state.ids = Object.keys(state.entities); + } + } + } + function upsertOneMutably(entity, state) { + return upsertManyMutably([entity], state); + } + function upsertManyMutably(newEntities, state) { + var _c = splitAddedUpdatedEntities(newEntities, selectId, state), added = _c[0], updated = _c[1]; + updateManyMutably(updated, state); + addManyMutably(added, state); + } + return { + removeAll: createSingleArgumentStateOperator(removeAllMutably), + addOne: createStateOperator(addOneMutably), + addMany: createStateOperator(addManyMutably), + setOne: createStateOperator(setOneMutably), + setMany: createStateOperator(setManyMutably), + setAll: createStateOperator(setAllMutably), + updateOne: createStateOperator(updateOneMutably), + updateMany: createStateOperator(updateManyMutably), + upsertOne: createStateOperator(upsertOneMutably), + upsertMany: createStateOperator(upsertManyMutably), + removeOne: createStateOperator(removeOneMutably), + removeMany: createStateOperator(removeManyMutably) + }; + } + function createSortedStateAdapter(selectId, sort) { + var _c = createUnsortedStateAdapter(selectId), removeOne = _c.removeOne, removeMany = _c.removeMany, removeAll = _c.removeAll; + function addOneMutably(entity, state) { + return addManyMutably([entity], state); + } + function addManyMutably(newEntities, state) { + newEntities = ensureEntitiesArray(newEntities); + var models = newEntities.filter(function(model) { + return !(selectIdValue(model, selectId) in state.entities); + }); + if (models.length !== 0) { + merge(models, state); + } + } + function setOneMutably(entity, state) { + return setManyMutably([entity], state); + } + function setManyMutably(newEntities, state) { + newEntities = ensureEntitiesArray(newEntities); + if (newEntities.length !== 0) { + merge(newEntities, state); + } + } + function setAllMutably(newEntities, state) { + newEntities = ensureEntitiesArray(newEntities); + state.entities = {}; + state.ids = []; + addManyMutably(newEntities, state); + } + function updateOneMutably(update, state) { + return updateManyMutably([update], state); + } + function updateManyMutably(updates, state) { + var appliedUpdates = false; + for (var _i = 0, updates_1 = updates; _i < updates_1.length; _i++) { + var update = updates_1[_i]; + var entity = state.entities[update.id]; + if (!entity) { + continue; + } + appliedUpdates = true; + Object.assign(entity, update.changes); + var newId = selectId(entity); + if (update.id !== newId) { + delete state.entities[update.id]; + state.entities[newId] = entity; + } + } + if (appliedUpdates) { + resortEntities(state); + } + } + function upsertOneMutably(entity, state) { + return upsertManyMutably([entity], state); + } + function upsertManyMutably(newEntities, state) { + var _c2 = splitAddedUpdatedEntities(newEntities, selectId, state), added = _c2[0], updated = _c2[1]; + updateManyMutably(updated, state); + addManyMutably(added, state); + } + function areArraysEqual(a, b) { + if (a.length !== b.length) { + return false; + } + for (var i = 0; i < a.length && i < b.length; i++) { + if (a[i] === b[i]) { + continue; + } + return false; + } + return true; + } + function merge(models, state) { + models.forEach(function(model) { + state.entities[selectId(model)] = model; + }); + resortEntities(state); + } + function resortEntities(state) { + var allEntities = Object.values(state.entities); + allEntities.sort(sort); + var newSortedIds = allEntities.map(selectId); + var ids = state.ids; + if (!areArraysEqual(ids, newSortedIds)) { + state.ids = newSortedIds; + } + } + return { + removeOne, + removeMany, + removeAll, + addOne: createStateOperator(addOneMutably), + updateOne: createStateOperator(updateOneMutably), + upsertOne: createStateOperator(upsertOneMutably), + setOne: createStateOperator(setOneMutably), + setMany: createStateOperator(setManyMutably), + setAll: createStateOperator(setAllMutably), + addMany: createStateOperator(addManyMutably), + updateMany: createStateOperator(updateManyMutably), + upsertMany: createStateOperator(upsertManyMutably) + }; + } + function createEntityAdapter(options) { + if (options === void 0) { + options = {}; + } + var _c = __spreadValues({ + sortComparer: false, + selectId: function(instance) { + return instance.id; + } + }, options), selectId = _c.selectId, sortComparer = _c.sortComparer; + var stateFactory = createInitialStateFactory(); + var selectorsFactory = createSelectorsFactory(); + var stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId); + return __spreadValues(__spreadValues(__spreadValues({ + selectId, + sortComparer + }, stateFactory), selectorsFactory), stateAdapter); + } + var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW"; + var nanoid = function(size) { + if (size === void 0) { + size = 21; + } + var id = ""; + var i = size; + while (i--) { + id += urlAlphabet[Math.random() * 64 | 0]; + } + return id; + }; + var commonProperties = [ + "name", + "message", + "stack", + "code" + ]; + var RejectWithValue = ( + /** @class */ + function() { + function RejectWithValue2(payload, meta) { + this.payload = payload; + this.meta = meta; + } + return RejectWithValue2; + }() + ); + var FulfillWithMeta = ( + /** @class */ + function() { + function FulfillWithMeta2(payload, meta) { + this.payload = payload; + this.meta = meta; + } + return FulfillWithMeta2; + }() + ); + var miniSerializeError = function(value) { + if (typeof value === "object" && value !== null) { + var simpleError = {}; + for (var _i = 0, commonProperties_1 = commonProperties; _i < commonProperties_1.length; _i++) { + var property = commonProperties_1[_i]; + if (typeof value[property] === "string") { + simpleError[property] = value[property]; + } + } + return simpleError; + } + return { message: String(value) }; + }; + var createAsyncThunk = function() { + function createAsyncThunk2(typePrefix, payloadCreator, options) { + var fulfilled = createAction(typePrefix + "/fulfilled", function(payload, requestId, arg, meta) { + return { + payload, + meta: __spreadProps(__spreadValues({}, meta || {}), { + arg, + requestId, + requestStatus: "fulfilled" + }) + }; + }); + var pending = createAction(typePrefix + "/pending", function(requestId, arg, meta) { + return { + payload: void 0, + meta: __spreadProps(__spreadValues({}, meta || {}), { + arg, + requestId, + requestStatus: "pending" + }) + }; + }); + var rejected = createAction(typePrefix + "/rejected", function(error, requestId, arg, payload, meta) { + return { + payload, + error: (options && options.serializeError || miniSerializeError)(error || "Rejected"), + meta: __spreadProps(__spreadValues({}, meta || {}), { + arg, + requestId, + rejectedWithValue: !!payload, + requestStatus: "rejected", + aborted: (error == null ? void 0 : error.name) === "AbortError", + condition: (error == null ? void 0 : error.name) === "ConditionError" + }) + }; + }); + var displayedWarning = false; + var AC = typeof AbortController !== "undefined" ? AbortController : ( + /** @class */ + function() { + function class_1() { + this.signal = { + aborted: false, + addEventListener: function() { + }, + dispatchEvent: function() { + return false; + }, + onabort: function() { + }, + removeEventListener: function() { + }, + reason: void 0, + throwIfAborted: function() { + } + }; + } + class_1.prototype.abort = function() { + if (true) { + if (!displayedWarning) { + displayedWarning = true; + console.info("This platform does not implement AbortController. \nIf you want to use the AbortController to react to `abort` events, please consider importing a polyfill like 'abortcontroller-polyfill/dist/abortcontroller-polyfill-only'."); + } + } + }; + return class_1; + }() + ); + function actionCreator(arg) { + return function(dispatch, getState, extra) { + var requestId = (options == null ? void 0 : options.idGenerator) ? options.idGenerator(arg) : nanoid(); + var abortController = new AC(); + var abortReason; + var started = false; + function abort(reason) { + abortReason = reason; + abortController.abort(); + } + var promise2 = function() { + return __async(this, null, function() { + var _a, _b, finalAction, conditionResult, abortedPromise, err_1, skipDispatch; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + _c.trys.push([0, 4, , 5]); + conditionResult = (_a = options == null ? void 0 : options.condition) == null ? void 0 : _a.call(options, arg, { getState, extra }); + if (!isThenable(conditionResult)) + return [3, 2]; + return [4, conditionResult]; + case 1: + conditionResult = _c.sent(); + _c.label = 2; + case 2: + if (conditionResult === false || abortController.signal.aborted) { + throw { + name: "ConditionError", + message: "Aborted due to condition callback returning false." + }; + } + started = true; + abortedPromise = new Promise(function(_, reject) { + return abortController.signal.addEventListener("abort", function() { + return reject({ + name: "AbortError", + message: abortReason || "Aborted" + }); + }); + }); + dispatch(pending(requestId, arg, (_b = options == null ? void 0 : options.getPendingMeta) == null ? void 0 : _b.call(options, { requestId, arg }, { getState, extra }))); + return [4, Promise.race([ + abortedPromise, + Promise.resolve(payloadCreator(arg, { + dispatch, + getState, + extra, + requestId, + signal: abortController.signal, + abort, + rejectWithValue: function(value, meta) { + return new RejectWithValue(value, meta); + }, + fulfillWithValue: function(value, meta) { + return new FulfillWithMeta(value, meta); + } + })).then(function(result) { + if (result instanceof RejectWithValue) { + throw result; + } + if (result instanceof FulfillWithMeta) { + return fulfilled(result.payload, requestId, arg, result.meta); + } + return fulfilled(result, requestId, arg); + }) + ])]; + case 3: + finalAction = _c.sent(); + return [3, 5]; + case 4: + err_1 = _c.sent(); + finalAction = err_1 instanceof RejectWithValue ? rejected(null, requestId, arg, err_1.payload, err_1.meta) : rejected(err_1, requestId, arg); + return [3, 5]; + case 5: + skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition; + if (!skipDispatch) { + dispatch(finalAction); + } + return [2, finalAction]; + } + }); + }); + }(); + return Object.assign(promise2, { + abort, + requestId, + arg, + unwrap: function() { + return promise2.then(unwrapResult); + } + }); + }; + } + return Object.assign(actionCreator, { + pending, + rejected, + fulfilled, + typePrefix + }); + } + createAsyncThunk2.withTypes = function() { + return createAsyncThunk2; + }; + return createAsyncThunk2; + }(); + function unwrapResult(action) { + if (action.meta && action.meta.rejectedWithValue) { + throw action.payload; + } + if (action.error) { + throw action.error; + } + return action.payload; + } + function isThenable(value) { + return value !== null && typeof value === "object" && typeof value.then === "function"; + } + var matches = function(matcher, action) { + if (hasMatchFunction(matcher)) { + return matcher.match(action); + } else { + return matcher(action); + } + }; + function isAnyOf() { + var matchers = []; + for (var _i = 0; _i < arguments.length; _i++) { + matchers[_i] = arguments[_i]; + } + return function(action) { + return matchers.some(function(matcher) { + return matches(matcher, action); + }); + }; + } + function isAllOf() { + var matchers = []; + for (var _i = 0; _i < arguments.length; _i++) { + matchers[_i] = arguments[_i]; + } + return function(action) { + return matchers.every(function(matcher) { + return matches(matcher, action); + }); + }; + } + function hasExpectedRequestMetadata(action, validStatus) { + if (!action || !action.meta) + return false; + var hasValidRequestId = typeof action.meta.requestId === "string"; + var hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1; + return hasValidRequestId && hasValidRequestStatus; + } + function isAsyncThunkArray(a) { + return typeof a[0] === "function" && "pending" in a[0] && "fulfilled" in a[0] && "rejected" in a[0]; + } + function isPending() { + var asyncThunks = []; + for (var _i = 0; _i < arguments.length; _i++) { + asyncThunks[_i] = arguments[_i]; + } + if (asyncThunks.length === 0) { + return function(action) { + return hasExpectedRequestMetadata(action, ["pending"]); + }; + } + if (!isAsyncThunkArray(asyncThunks)) { + return isPending()(asyncThunks[0]); + } + return function(action) { + var matchers = asyncThunks.map(function(asyncThunk) { + return asyncThunk.pending; + }); + var combinedMatcher = isAnyOf.apply(void 0, matchers); + return combinedMatcher(action); + }; + } + function isRejected() { + var asyncThunks = []; + for (var _i = 0; _i < arguments.length; _i++) { + asyncThunks[_i] = arguments[_i]; + } + if (asyncThunks.length === 0) { + return function(action) { + return hasExpectedRequestMetadata(action, ["rejected"]); + }; + } + if (!isAsyncThunkArray(asyncThunks)) { + return isRejected()(asyncThunks[0]); + } + return function(action) { + var matchers = asyncThunks.map(function(asyncThunk) { + return asyncThunk.rejected; + }); + var combinedMatcher = isAnyOf.apply(void 0, matchers); + return combinedMatcher(action); + }; + } + function isRejectedWithValue() { + var asyncThunks = []; + for (var _i = 0; _i < arguments.length; _i++) { + asyncThunks[_i] = arguments[_i]; + } + var hasFlag = function(action) { + return action && action.meta && action.meta.rejectedWithValue; + }; + if (asyncThunks.length === 0) { + return function(action) { + var combinedMatcher = isAllOf(isRejected.apply(void 0, asyncThunks), hasFlag); + return combinedMatcher(action); + }; + } + if (!isAsyncThunkArray(asyncThunks)) { + return isRejectedWithValue()(asyncThunks[0]); + } + return function(action) { + var combinedMatcher = isAllOf(isRejected.apply(void 0, asyncThunks), hasFlag); + return combinedMatcher(action); + }; + } + function isFulfilled() { + var asyncThunks = []; + for (var _i = 0; _i < arguments.length; _i++) { + asyncThunks[_i] = arguments[_i]; + } + if (asyncThunks.length === 0) { + return function(action) { + return hasExpectedRequestMetadata(action, ["fulfilled"]); + }; + } + if (!isAsyncThunkArray(asyncThunks)) { + return isFulfilled()(asyncThunks[0]); + } + return function(action) { + var matchers = asyncThunks.map(function(asyncThunk) { + return asyncThunk.fulfilled; + }); + var combinedMatcher = isAnyOf.apply(void 0, matchers); + return combinedMatcher(action); + }; + } + function isAsyncThunkAction() { + var asyncThunks = []; + for (var _i = 0; _i < arguments.length; _i++) { + asyncThunks[_i] = arguments[_i]; + } + if (asyncThunks.length === 0) { + return function(action) { + return hasExpectedRequestMetadata(action, ["pending", "fulfilled", "rejected"]); + }; + } + if (!isAsyncThunkArray(asyncThunks)) { + return isAsyncThunkAction()(asyncThunks[0]); + } + return function(action) { + var matchers = []; + for (var _i2 = 0, asyncThunks_1 = asyncThunks; _i2 < asyncThunks_1.length; _i2++) { + var asyncThunk = asyncThunks_1[_i2]; + matchers.push(asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled); + } + var combinedMatcher = isAnyOf.apply(void 0, matchers); + return combinedMatcher(action); + }; + } + var assertFunction = function(func, expected) { + if (typeof func !== "function") { + throw new TypeError(expected + " is not a function"); + } + }; + var noop = function() { + }; + var catchRejection = function(promise2, onError) { + if (onError === void 0) { + onError = noop; + } + promise2.catch(onError); + return promise2; + }; + var addAbortSignalListener = function(abortSignal, callback) { + abortSignal.addEventListener("abort", callback, { once: true }); + return function() { + return abortSignal.removeEventListener("abort", callback); + }; + }; + var abortControllerWithReason = function(abortController, reason) { + var signal = abortController.signal; + if (signal.aborted) { + return; + } + if (!("reason" in signal)) { + Object.defineProperty(signal, "reason", { + enumerable: true, + value: reason, + configurable: true, + writable: true + }); + } + ; + abortController.abort(reason); + }; + var task = "task"; + var listener = "listener"; + var completed = "completed"; + var cancelled = "cancelled"; + var taskCancelled = "task-" + cancelled; + var taskCompleted = "task-" + completed; + var listenerCancelled = listener + "-" + cancelled; + var listenerCompleted = listener + "-" + completed; + var TaskAbortError = ( + /** @class */ + function() { + function TaskAbortError2(code) { + this.code = code; + this.name = "TaskAbortError"; + this.message = task + " " + cancelled + " (reason: " + code + ")"; + } + return TaskAbortError2; + }() + ); + var validateActive = function(signal) { + if (signal.aborted) { + throw new TaskAbortError(signal.reason); + } + }; + function raceWithSignal(signal, promise2) { + var cleanup = noop; + return new Promise(function(resolve, reject) { + var notifyRejection = function() { + return reject(new TaskAbortError(signal.reason)); + }; + if (signal.aborted) { + notifyRejection(); + return; + } + cleanup = addAbortSignalListener(signal, notifyRejection); + promise2.finally(function() { + return cleanup(); + }).then(resolve, reject); + }).finally(function() { + cleanup = noop; + }); + } + var runTask = function(task2, cleanUp) { + return __async(void 0, null, function() { + var value, error_1; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + _c.trys.push([0, 3, 4, 5]); + return [4, Promise.resolve()]; + case 1: + _c.sent(); + return [4, task2()]; + case 2: + value = _c.sent(); + return [2, { + status: "ok", + value + }]; + case 3: + error_1 = _c.sent(); + return [2, { + status: error_1 instanceof TaskAbortError ? "cancelled" : "rejected", + error: error_1 + }]; + case 4: + cleanUp == null ? void 0 : cleanUp(); + return [ + 7 + /*endfinally*/ + ]; + case 5: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + var createPause = function(signal) { + return function(promise2) { + return catchRejection(raceWithSignal(signal, promise2).then(function(output) { + validateActive(signal); + return output; + })); + }; + }; + var createDelay = function(signal) { + var pause = createPause(signal); + return function(timeoutMs) { + return pause(new Promise(function(resolve) { + return setTimeout(resolve, timeoutMs); + })); + }; + }; + var assign = Object.assign; + var INTERNAL_NIL_TOKEN = {}; + var alm = "listenerMiddleware"; + var createFork = function(parentAbortSignal, parentBlockingPromises) { + var linkControllers = function(controller) { + return addAbortSignalListener(parentAbortSignal, function() { + return abortControllerWithReason(controller, parentAbortSignal.reason); + }); + }; + return function(taskExecutor, opts) { + assertFunction(taskExecutor, "taskExecutor"); + var childAbortController = new AbortController(); + linkControllers(childAbortController); + var result = runTask(function() { + return __async(void 0, null, function() { + var result2; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + validateActive(parentAbortSignal); + validateActive(childAbortController.signal); + return [4, taskExecutor({ + pause: createPause(childAbortController.signal), + delay: createDelay(childAbortController.signal), + signal: childAbortController.signal + })]; + case 1: + result2 = _c.sent(); + validateActive(childAbortController.signal); + return [2, result2]; + } + }); + }); + }, function() { + return abortControllerWithReason(childAbortController, taskCompleted); + }); + if (opts == null ? void 0 : opts.autoJoin) { + parentBlockingPromises.push(result); + } + return { + result: createPause(parentAbortSignal)(result), + cancel: function() { + abortControllerWithReason(childAbortController, taskCancelled); + } + }; + }; + }; + var createTakePattern = function(startListening, signal) { + var take = function(predicate, timeout) { + return __async(void 0, null, function() { + var unsubscribe, tuplePromise, promises, output; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + validateActive(signal); + unsubscribe = function() { + }; + tuplePromise = new Promise(function(resolve, reject) { + var stopListening = startListening({ + predicate, + effect: function(action, listenerApi) { + listenerApi.unsubscribe(); + resolve([ + action, + listenerApi.getState(), + listenerApi.getOriginalState() + ]); + } + }); + unsubscribe = function() { + stopListening(); + reject(); + }; + }); + promises = [ + tuplePromise + ]; + if (timeout != null) { + promises.push(new Promise(function(resolve) { + return setTimeout(resolve, timeout, null); + })); + } + _c.label = 1; + case 1: + _c.trys.push([1, , 3, 4]); + return [4, raceWithSignal(signal, Promise.race(promises))]; + case 2: + output = _c.sent(); + validateActive(signal); + return [2, output]; + case 3: + unsubscribe(); + return [ + 7 + /*endfinally*/ + ]; + case 4: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + return function(predicate, timeout) { + return catchRejection(take(predicate, timeout)); + }; + }; + var getListenerEntryPropsFrom = function(options) { + var type = options.type, actionCreator = options.actionCreator, matcher = options.matcher, predicate = options.predicate, effect = options.effect; + if (type) { + predicate = createAction(type).match; + } else if (actionCreator) { + type = actionCreator.type; + predicate = actionCreator.match; + } else if (matcher) { + predicate = matcher; + } else if (predicate) { + } else { + throw new Error("Creating or removing a listener requires one of the known fields for matching an action"); + } + assertFunction(effect, "options.listener"); + return { predicate, type, effect }; + }; + var createListenerEntry = function(options) { + var _c = getListenerEntryPropsFrom(options), type = _c.type, predicate = _c.predicate, effect = _c.effect; + var id = nanoid(); + var entry = { + id, + effect, + type, + predicate, + pending: /* @__PURE__ */ new Set(), + unsubscribe: function() { + throw new Error("Unsubscribe not initialized"); + } + }; + return entry; + }; + var cancelActiveListeners = function(entry) { + entry.pending.forEach(function(controller) { + abortControllerWithReason(controller, listenerCancelled); + }); + }; + var createClearListenerMiddleware = function(listenerMap) { + return function() { + listenerMap.forEach(cancelActiveListeners); + listenerMap.clear(); + }; + }; + var safelyNotifyError = function(errorHandler, errorToNotify, errorInfo) { + try { + errorHandler(errorToNotify, errorInfo); + } catch (errorHandlerError) { + setTimeout(function() { + throw errorHandlerError; + }, 0); + } + }; + var addListener = createAction(alm + "/add"); + var clearAllListeners = createAction(alm + "/removeAll"); + var removeListener = createAction(alm + "/remove"); + var defaultErrorHandler = function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + console.error.apply(console, __spreadArray([alm + "/error"], args)); + }; + function createListenerMiddleware(middlewareOptions) { + var _this = this; + if (middlewareOptions === void 0) { + middlewareOptions = {}; + } + var listenerMap = /* @__PURE__ */ new Map(); + var extra = middlewareOptions.extra, _c = middlewareOptions.onError, onError = _c === void 0 ? defaultErrorHandler : _c; + assertFunction(onError, "onError"); + var insertEntry = function(entry) { + entry.unsubscribe = function() { + return listenerMap.delete(entry.id); + }; + listenerMap.set(entry.id, entry); + return function(cancelOptions) { + entry.unsubscribe(); + if (cancelOptions == null ? void 0 : cancelOptions.cancelActive) { + cancelActiveListeners(entry); + } + }; + }; + var findListenerEntry = function(comparator) { + for (var _i = 0, _c2 = Array.from(listenerMap.values()); _i < _c2.length; _i++) { + var entry = _c2[_i]; + if (comparator(entry)) { + return entry; + } + } + return void 0; + }; + var startListening = function(options) { + var entry = findListenerEntry(function(existingEntry) { + return existingEntry.effect === options.effect; + }); + if (!entry) { + entry = createListenerEntry(options); + } + return insertEntry(entry); + }; + var stopListening = function(options) { + var _c2 = getListenerEntryPropsFrom(options), type = _c2.type, effect = _c2.effect, predicate = _c2.predicate; + var entry = findListenerEntry(function(entry2) { + var matchPredicateOrType = typeof type === "string" ? entry2.type === type : entry2.predicate === predicate; + return matchPredicateOrType && entry2.effect === effect; + }); + if (entry) { + entry.unsubscribe(); + if (options.cancelActive) { + cancelActiveListeners(entry); + } + } + return !!entry; + }; + var notifyListener = function(entry, action, api, getOriginalState) { + return __async(_this, null, function() { + var internalTaskController, take, autoJoinPromises, listenerError_1; + return __generator(this, function(_c2) { + switch (_c2.label) { + case 0: + internalTaskController = new AbortController(); + take = createTakePattern(startListening, internalTaskController.signal); + autoJoinPromises = []; + _c2.label = 1; + case 1: + _c2.trys.push([1, 3, 4, 6]); + entry.pending.add(internalTaskController); + return [4, Promise.resolve(entry.effect(action, assign({}, api, { + getOriginalState, + condition: function(predicate, timeout) { + return take(predicate, timeout).then(Boolean); + }, + take, + delay: createDelay(internalTaskController.signal), + pause: createPause(internalTaskController.signal), + extra, + signal: internalTaskController.signal, + fork: createFork(internalTaskController.signal, autoJoinPromises), + unsubscribe: entry.unsubscribe, + subscribe: function() { + listenerMap.set(entry.id, entry); + }, + cancelActiveListeners: function() { + entry.pending.forEach(function(controller, _, set) { + if (controller !== internalTaskController) { + abortControllerWithReason(controller, listenerCancelled); + set.delete(controller); + } + }); + } + })))]; + case 2: + _c2.sent(); + return [3, 6]; + case 3: + listenerError_1 = _c2.sent(); + if (!(listenerError_1 instanceof TaskAbortError)) { + safelyNotifyError(onError, listenerError_1, { + raisedBy: "effect" + }); + } + return [3, 6]; + case 4: + return [4, Promise.allSettled(autoJoinPromises)]; + case 5: + _c2.sent(); + abortControllerWithReason(internalTaskController, listenerCompleted); + entry.pending.delete(internalTaskController); + return [ + 7 + /*endfinally*/ + ]; + case 6: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + var clearListenerMiddleware = createClearListenerMiddleware(listenerMap); + var middleware = function(api) { + return function(next) { + return function(action) { + if (!isAction(action)) { + return next(action); + } + if (addListener.match(action)) { + return startListening(action.payload); + } + if (clearAllListeners.match(action)) { + clearListenerMiddleware(); + return; + } + if (removeListener.match(action)) { + return stopListening(action.payload); + } + var originalState = api.getState(); + var getOriginalState = function() { + if (originalState === INTERNAL_NIL_TOKEN) { + throw new Error(alm + ": getOriginalState can only be called synchronously"); + } + return originalState; + }; + var result; + try { + result = next(action); + if (listenerMap.size > 0) { + var currentState = api.getState(); + var listenerEntries = Array.from(listenerMap.values()); + for (var _i = 0, listenerEntries_1 = listenerEntries; _i < listenerEntries_1.length; _i++) { + var entry = listenerEntries_1[_i]; + var runListener = false; + try { + runListener = entry.predicate(action, currentState, originalState); + } catch (predicateError) { + runListener = false; + safelyNotifyError(onError, predicateError, { + raisedBy: "predicate" + }); + } + if (!runListener) { + continue; + } + notifyListener(entry, action, api, getOriginalState); + } + } + } finally { + originalState = INTERNAL_NIL_TOKEN; + } + return result; + }; + }; + }; + return { + middleware, + startListening, + stopListening, + clearListeners: clearListenerMiddleware + }; + } + var SHOULD_AUTOBATCH = "RTK_autoBatch"; + var prepareAutoBatched = function() { + return function(payload) { + var _c; + return { + payload, + meta: (_c = {}, _c[SHOULD_AUTOBATCH] = true, _c) + }; + }; + }; + var promise; + var queueMicrotaskShim = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : globalThis) : function(cb) { + return (promise || (promise = Promise.resolve())).then(cb).catch(function(err) { + return setTimeout(function() { + throw err; + }, 0); + }); + }; + var createQueueWithTimer = function(timeout) { + return function(notify) { + setTimeout(notify, timeout); + }; + }; + var rAF = typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10); + var autoBatchEnhancer = function(options) { + if (options === void 0) { + options = { type: "raf" }; + } + return function(next) { + return function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var store = next.apply(void 0, args); + var notifying = true; + var shouldNotifyAtEndOfTick = false; + var notificationQueued = false; + var listeners = /* @__PURE__ */ new Set(); + var queueCallback = options.type === "tick" ? queueMicrotaskShim : options.type === "raf" ? rAF : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout); + var notifyListeners = function() { + notificationQueued = false; + if (shouldNotifyAtEndOfTick) { + shouldNotifyAtEndOfTick = false; + listeners.forEach(function(l) { + return l(); + }); + } + }; + return Object.assign({}, store, { + subscribe: function(listener2) { + var wrappedListener = function() { + return notifying && listener2(); + }; + var unsubscribe = store.subscribe(wrappedListener); + listeners.add(listener2); + return function() { + unsubscribe(); + listeners.delete(listener2); + }; + }, + dispatch: function(action) { + var _a; + try { + notifying = !((_a = action == null ? void 0 : action.meta) == null ? void 0 : _a[SHOULD_AUTOBATCH]); + shouldNotifyAtEndOfTick = !notifying; + if (shouldNotifyAtEndOfTick) { + if (!notificationQueued) { + notificationQueued = true; + queueCallback(notifyListeners); + } + } + return store.dispatch(action); + } finally { + notifying = true; + } + } + }); + }; + }; + }; + (0, import_immer5.enableES5)(); + } +}); + +// node_modules/@reduxjs/toolkit/dist/index.js +var require_dist2 = __commonJS({ + "node_modules/@reduxjs/toolkit/dist/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV === "production") { + module.exports = require_redux_toolkit_cjs_production_min(); + } else { + module.exports = require_redux_toolkit_cjs_development(); + } + } +}); + +// src/app.ts +init_cjs_shim(); +var import_toolkit = __toESM(require_dist2(), 1); +var initialState = { + password: "", + email: "", + error: "no_error" +}; +var loginApp = (0, import_toolkit.createSlice)({ + name: "my login app", + initialState, + reducers: { + reset: (state) => { + state.password = initialState.password; + state.email = initialState.email; + state.error = initialState.error; + }, + setPassword: (state, action) => { + state.password = action.payload; + }, + setEmail: (state, action) => { + state.email = action.payload; + }, + signIn: (state) => { + state.error = checkForErrors(state); + } + } +}); +var selectRoot = (storeState) => { + return storeState; +}; +var validateEmail = (email) => { + return email.match( + // eslint-disable-next-line no-useless-escape + /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/ + ); +}; +var checkForErrors = (storeState) => { + if (!validateEmail(storeState.email)) { + return "invalidEmail"; + } + if (storeState.password !== "password" && storeState.email !== "adam@email.com") { + return "credentialFail"; + } + return "no_error"; +}; +var loginPageSelection = (0, import_toolkit.createSelector)([selectRoot], (root) => { + return { + ...root, + disableSubmit: root.email == "" || root.password == "" + }; +}); +var app_default = () => { + const store = (0, import_toolkit.createStore)(loginApp.reducer); + return { + app: loginApp, + select: { + loginPageSelection + }, + store + }; +}; + +export { + require_redux, + loginApp, + app_default +}; diff --git a/docs/node/chunk-AE5HW5IP.mjs b/docs/node/chunk-AE5HW5IP.mjs new file mode 100644 index 00000000..08d89bbc --- /dev/null +++ b/docs/node/chunk-AE5HW5IP.mjs @@ -0,0 +1,31776 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + app_default +} from "./chunk-562JFTRV.mjs"; +import { + __commonJS, + __require, + __toESM, + init_cjs_shim +} from "./chunk-BJRHXCMP.mjs"; + +// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js +var require_use_sync_external_store_shim_production_min = __commonJS({ + "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js"(exports) { + "use strict"; + init_cjs_shim(); + var e = __require("react"); + function h(a, b) { + return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b; + } + var k = "function" === typeof Object.is ? Object.is : h; + var l = e.useState; + var m = e.useEffect; + var n = e.useLayoutEffect; + var p = e.useDebugValue; + function q(a, b) { + var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1]; + n(function() { + c.value = d; + c.getSnapshot = b; + r(c) && g({ inst: c }); + }, [a, d, b]); + m(function() { + r(c) && g({ inst: c }); + return a(function() { + r(c) && g({ inst: c }); + }); + }, [a]); + p(d); + return d; + } + function r(a) { + var b = a.getSnapshot; + a = a.value; + try { + var d = b(); + return !k(a, d); + } catch (f) { + return true; + } + } + function t(a, b) { + return b(); + } + var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q; + exports.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u; + } +}); + +// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js +var require_use_sync_external_store_shim_development = __commonJS({ + "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV !== "production") { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var React2 = __require("react"); + var ReactSharedInternals = React2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + function error(format) { + { + { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + printWarning("error", format, args); + } + } + } + function printWarning(level, format, args) { + { + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame.getStackAddendum(); + if (stack !== "") { + format += "%s"; + args = args.concat([stack]); + } + var argsWithFormat = args.map(function(item) { + return String(item); + }); + argsWithFormat.unshift("Warning: " + format); + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + } + function is(x, y) { + return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y; + } + var objectIs = typeof Object.is === "function" ? Object.is : is; + var useState = React2.useState, useEffect = React2.useEffect, useLayoutEffect = React2.useLayoutEffect, useDebugValue = React2.useDebugValue; + var didWarnOld18Alpha = false; + var didWarnUncachedGetSnapshot = false; + function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) { + { + if (!didWarnOld18Alpha) { + if (React2.startTransition !== void 0) { + didWarnOld18Alpha = true; + error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."); + } + } + } + var value = getSnapshot(); + { + if (!didWarnUncachedGetSnapshot) { + var cachedValue = getSnapshot(); + if (!objectIs(value, cachedValue)) { + error("The result of getSnapshot should be cached to avoid an infinite loop"); + didWarnUncachedGetSnapshot = true; + } + } + } + var _useState = useState({ + inst: { + value, + getSnapshot + } + }), inst = _useState[0].inst, forceUpdate = _useState[1]; + useLayoutEffect(function() { + inst.value = value; + inst.getSnapshot = getSnapshot; + if (checkIfSnapshotChanged(inst)) { + forceUpdate({ + inst + }); + } + }, [subscribe, value, getSnapshot]); + useEffect(function() { + if (checkIfSnapshotChanged(inst)) { + forceUpdate({ + inst + }); + } + var handleStoreChange = function() { + if (checkIfSnapshotChanged(inst)) { + forceUpdate({ + inst + }); + } + }; + return subscribe(handleStoreChange); + }, [subscribe]); + useDebugValue(value); + return value; + } + function checkIfSnapshotChanged(inst) { + var latestGetSnapshot = inst.getSnapshot; + var prevValue = inst.value; + try { + var nextValue = latestGetSnapshot(); + return !objectIs(prevValue, nextValue); + } catch (error2) { + return true; + } + } + function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) { + return getSnapshot(); + } + var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"); + var isServerEnvironment = !canUseDOM; + var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore; + var useSyncExternalStore$2 = React2.useSyncExternalStore !== void 0 ? React2.useSyncExternalStore : shim; + exports.useSyncExternalStore = useSyncExternalStore$2; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); + } + })(); + } + } +}); + +// node_modules/use-sync-external-store/shim/index.js +var require_shim = __commonJS({ + "node_modules/use-sync-external-store/shim/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV === "production") { + module.exports = require_use_sync_external_store_shim_production_min(); + } else { + module.exports = require_use_sync_external_store_shim_development(); + } + } +}); + +// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.min.js +var require_with_selector_production_min = __commonJS({ + "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.min.js"(exports) { + "use strict"; + init_cjs_shim(); + var h = __require("react"); + var n = require_shim(); + function p(a, b) { + return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b; + } + var q = "function" === typeof Object.is ? Object.is : p; + var r = n.useSyncExternalStore; + var t = h.useRef; + var u = h.useEffect; + var v = h.useMemo; + var w = h.useDebugValue; + exports.useSyncExternalStoreWithSelector = function(a, b, e, l, g) { + var c = t(null); + if (null === c.current) { + var f = { hasValue: false, value: null }; + c.current = f; + } else + f = c.current; + c = v(function() { + function a2(a3) { + if (!c2) { + c2 = true; + d2 = a3; + a3 = l(a3); + if (void 0 !== g && f.hasValue) { + var b2 = f.value; + if (g(b2, a3)) + return k = b2; + } + return k = a3; + } + b2 = k; + if (q(d2, a3)) + return b2; + var e2 = l(a3); + if (void 0 !== g && g(b2, e2)) + return b2; + d2 = a3; + return k = e2; + } + var c2 = false, d2, k, m = void 0 === e ? null : e; + return [function() { + return a2(b()); + }, null === m ? void 0 : function() { + return a2(m()); + }]; + }, [b, e, l, g]); + var d = r(a, c[0], c[1]); + u(function() { + f.hasValue = true; + f.value = d; + }, [d]); + w(d); + return d; + }; + } +}); + +// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js +var require_with_selector_development = __commonJS({ + "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV !== "production") { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var React2 = __require("react"); + var shim = require_shim(); + function is(x, y) { + return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y; + } + var objectIs = typeof Object.is === "function" ? Object.is : is; + var useSyncExternalStore = shim.useSyncExternalStore; + var useRef = React2.useRef, useEffect = React2.useEffect, useMemo = React2.useMemo, useDebugValue = React2.useDebugValue; + function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector2, isEqual) { + var instRef = useRef(null); + var inst; + if (instRef.current === null) { + inst = { + hasValue: false, + value: null + }; + instRef.current = inst; + } else { + inst = instRef.current; + } + var _useMemo = useMemo(function() { + var hasMemo = false; + var memoizedSnapshot; + var memoizedSelection; + var memoizedSelector = function(nextSnapshot) { + if (!hasMemo) { + hasMemo = true; + memoizedSnapshot = nextSnapshot; + var _nextSelection = selector2(nextSnapshot); + if (isEqual !== void 0) { + if (inst.hasValue) { + var currentSelection = inst.value; + if (isEqual(currentSelection, _nextSelection)) { + memoizedSelection = currentSelection; + return currentSelection; + } + } + } + memoizedSelection = _nextSelection; + return _nextSelection; + } + var prevSnapshot = memoizedSnapshot; + var prevSelection = memoizedSelection; + if (objectIs(prevSnapshot, nextSnapshot)) { + return prevSelection; + } + var nextSelection = selector2(nextSnapshot); + if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) { + return prevSelection; + } + memoizedSnapshot = nextSnapshot; + memoizedSelection = nextSelection; + return nextSelection; + }; + var maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot; + var getSnapshotWithSelector = function() { + return memoizedSelector(getSnapshot()); + }; + var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : function() { + return memoizedSelector(maybeGetServerSnapshot()); + }; + return [getSnapshotWithSelector, getServerSnapshotWithSelector]; + }, [getSnapshot, getServerSnapshot, selector2, isEqual]), getSelection = _useMemo[0], getServerSelection = _useMemo[1]; + var value = useSyncExternalStore(subscribe, getSelection, getServerSelection); + useEffect(function() { + inst.hasValue = true; + inst.value = value; + }, [value]); + useDebugValue(value); + return value; + } + exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); + } + })(); + } + } +}); + +// node_modules/use-sync-external-store/shim/with-selector.js +var require_with_selector = __commonJS({ + "node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV === "production") { + module.exports = require_with_selector_production_min(); + } else { + module.exports = require_with_selector_development(); + } + } +}); + +// node_modules/scheduler/cjs/scheduler.production.min.js +var require_scheduler_production_min = __commonJS({ + "node_modules/scheduler/cjs/scheduler.production.min.js"(exports) { + "use strict"; + init_cjs_shim(); + function f(a, b) { + var c = a.length; + a.push(b); + a: + for (; 0 < c; ) { + var d = c - 1 >>> 1, e = a[d]; + if (0 < g(e, b)) + a[d] = b, a[c] = e, c = d; + else + break a; + } + } + function h(a) { + return 0 === a.length ? null : a[0]; + } + function k(a) { + if (0 === a.length) + return null; + var b = a[0], c = a.pop(); + if (c !== b) { + a[0] = c; + a: + for (var d = 0, e = a.length, w = e >>> 1; d < w; ) { + var m = 2 * (d + 1) - 1, C = a[m], n = m + 1, x = a[n]; + if (0 > g(C, c)) + n < e && 0 > g(x, C) ? (a[d] = x, a[n] = c, d = n) : (a[d] = C, a[m] = c, d = m); + else if (n < e && 0 > g(x, c)) + a[d] = x, a[n] = c, d = n; + else + break a; + } + } + return b; + } + function g(a, b) { + var c = a.sortIndex - b.sortIndex; + return 0 !== c ? c : a.id - b.id; + } + if ("object" === typeof performance && "function" === typeof performance.now) { + l = performance; + exports.unstable_now = function() { + return l.now(); + }; + } else { + p = Date, q = p.now(); + exports.unstable_now = function() { + return p.now() - q; + }; + } + var l; + var p; + var q; + var r = []; + var t = []; + var u = 1; + var v = null; + var y = 3; + var z = false; + var A = false; + var B = false; + var D = "function" === typeof setTimeout ? setTimeout : null; + var E = "function" === typeof clearTimeout ? clearTimeout : null; + var F = "undefined" !== typeof setImmediate ? setImmediate : null; + "undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling); + function G(a) { + for (var b = h(t); null !== b; ) { + if (null === b.callback) + k(t); + else if (b.startTime <= a) + k(t), b.sortIndex = b.expirationTime, f(r, b); + else + break; + b = h(t); + } + } + function H(a) { + B = false; + G(a); + if (!A) + if (null !== h(r)) + A = true, I(J); + else { + var b = h(t); + null !== b && K(H, b.startTime - a); + } + } + function J(a, b) { + A = false; + B && (B = false, E(L), L = -1); + z = true; + var c = y; + try { + G(b); + for (v = h(r); null !== v && (!(v.expirationTime > b) || a && !M()); ) { + var d = v.callback; + if ("function" === typeof d) { + v.callback = null; + y = v.priorityLevel; + var e = d(v.expirationTime <= b); + b = exports.unstable_now(); + "function" === typeof e ? v.callback = e : v === h(r) && k(r); + G(b); + } else + k(r); + v = h(r); + } + if (null !== v) + var w = true; + else { + var m = h(t); + null !== m && K(H, m.startTime - b); + w = false; + } + return w; + } finally { + v = null, y = c, z = false; + } + } + var N = false; + var O = null; + var L = -1; + var P = 5; + var Q = -1; + function M() { + return exports.unstable_now() - Q < P ? false : true; + } + function R() { + if (null !== O) { + var a = exports.unstable_now(); + Q = a; + var b = true; + try { + b = O(true, a); + } finally { + b ? S() : (N = false, O = null); + } + } else + N = false; + } + var S; + if ("function" === typeof F) + S = function() { + F(R); + }; + else if ("undefined" !== typeof MessageChannel) { + T = new MessageChannel(), U = T.port2; + T.port1.onmessage = R; + S = function() { + U.postMessage(null); + }; + } else + S = function() { + D(R, 0); + }; + var T; + var U; + function I(a) { + O = a; + N || (N = true, S()); + } + function K(a, b) { + L = D(function() { + a(exports.unstable_now()); + }, b); + } + exports.unstable_IdlePriority = 5; + exports.unstable_ImmediatePriority = 1; + exports.unstable_LowPriority = 4; + exports.unstable_NormalPriority = 3; + exports.unstable_Profiling = null; + exports.unstable_UserBlockingPriority = 2; + exports.unstable_cancelCallback = function(a) { + a.callback = null; + }; + exports.unstable_continueExecution = function() { + A || z || (A = true, I(J)); + }; + exports.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") : P = 0 < a ? Math.floor(1e3 / a) : 5; + }; + exports.unstable_getCurrentPriorityLevel = function() { + return y; + }; + exports.unstable_getFirstCallbackNode = function() { + return h(r); + }; + exports.unstable_next = function(a) { + switch (y) { + case 1: + case 2: + case 3: + var b = 3; + break; + default: + b = y; + } + var c = y; + y = b; + try { + return a(); + } finally { + y = c; + } + }; + exports.unstable_pauseExecution = function() { + }; + exports.unstable_requestPaint = function() { + }; + exports.unstable_runWithPriority = function(a, b) { + switch (a) { + case 1: + case 2: + case 3: + case 4: + case 5: + break; + default: + a = 3; + } + var c = y; + y = a; + try { + return b(); + } finally { + y = c; + } + }; + exports.unstable_scheduleCallback = function(a, b, c) { + var d = exports.unstable_now(); + "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d; + switch (a) { + case 1: + var e = -1; + break; + case 2: + e = 250; + break; + case 5: + e = 1073741823; + break; + case 4: + e = 1e4; + break; + default: + e = 5e3; + } + e = c + e; + a = { id: u++, callback: b, priorityLevel: a, startTime: c, expirationTime: e, sortIndex: -1 }; + c > d ? (a.sortIndex = c, f(t, a), null === h(r) && a === h(t) && (B ? (E(L), L = -1) : B = true, K(H, c - d))) : (a.sortIndex = e, f(r, a), A || z || (A = true, I(J))); + return a; + }; + exports.unstable_shouldYield = M; + exports.unstable_wrapCallback = function(a) { + var b = y; + return function() { + var c = y; + y = b; + try { + return a.apply(this, arguments); + } finally { + y = c; + } + }; + }; + } +}); + +// node_modules/scheduler/cjs/scheduler.development.js +var require_scheduler_development = __commonJS({ + "node_modules/scheduler/cjs/scheduler.development.js"(exports) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV !== "production") { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var enableSchedulerDebugging = false; + var enableProfiling = false; + var frameYieldMs = 5; + function push(heap, node) { + var index = heap.length; + heap.push(node); + siftUp(heap, node, index); + } + function peek(heap) { + return heap.length === 0 ? null : heap[0]; + } + function pop(heap) { + if (heap.length === 0) { + return null; + } + var first = heap[0]; + var last = heap.pop(); + if (last !== first) { + heap[0] = last; + siftDown(heap, last, 0); + } + return first; + } + function siftUp(heap, node, i) { + var index = i; + while (index > 0) { + var parentIndex = index - 1 >>> 1; + var parent = heap[parentIndex]; + if (compare(parent, node) > 0) { + heap[parentIndex] = node; + heap[index] = parent; + index = parentIndex; + } else { + return; + } + } + } + function siftDown(heap, node, i) { + var index = i; + var length = heap.length; + var halfLength = length >>> 1; + while (index < halfLength) { + var leftIndex = (index + 1) * 2 - 1; + var left = heap[leftIndex]; + var rightIndex = leftIndex + 1; + var right = heap[rightIndex]; + if (compare(left, node) < 0) { + if (rightIndex < length && compare(right, left) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + heap[index] = left; + heap[leftIndex] = node; + index = leftIndex; + } + } else if (rightIndex < length && compare(right, node) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + return; + } + } + } + function compare(a, b) { + var diff = a.sortIndex - b.sortIndex; + return diff !== 0 ? diff : a.id - b.id; + } + var ImmediatePriority = 1; + var UserBlockingPriority = 2; + var NormalPriority = 3; + var LowPriority = 4; + var IdlePriority = 5; + function markTaskErrored(task, ms) { + } + var hasPerformanceNow = typeof performance === "object" && typeof performance.now === "function"; + if (hasPerformanceNow) { + var localPerformance = performance; + exports.unstable_now = function() { + return localPerformance.now(); + }; + } else { + var localDate = Date; + var initialTime = localDate.now(); + exports.unstable_now = function() { + return localDate.now() - initialTime; + }; + } + var maxSigned31BitInt = 1073741823; + var IMMEDIATE_PRIORITY_TIMEOUT = -1; + var USER_BLOCKING_PRIORITY_TIMEOUT = 250; + var NORMAL_PRIORITY_TIMEOUT = 5e3; + var LOW_PRIORITY_TIMEOUT = 1e4; + var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; + var taskQueue = []; + var timerQueue = []; + var taskIdCounter = 1; + var currentTask = null; + var currentPriorityLevel = NormalPriority; + var isPerformingWork = false; + var isHostCallbackScheduled = false; + var isHostTimeoutScheduled = false; + var localSetTimeout = typeof setTimeout === "function" ? setTimeout : null; + var localClearTimeout = typeof clearTimeout === "function" ? clearTimeout : null; + var localSetImmediate = typeof setImmediate !== "undefined" ? setImmediate : null; + var isInputPending = typeof navigator !== "undefined" && navigator.scheduling !== void 0 && navigator.scheduling.isInputPending !== void 0 ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null; + function advanceTimers(currentTime) { + var timer = peek(timerQueue); + while (timer !== null) { + if (timer.callback === null) { + pop(timerQueue); + } else if (timer.startTime <= currentTime) { + pop(timerQueue); + timer.sortIndex = timer.expirationTime; + push(taskQueue, timer); + } else { + return; + } + timer = peek(timerQueue); + } + } + function handleTimeout(currentTime) { + isHostTimeoutScheduled = false; + advanceTimers(currentTime); + if (!isHostCallbackScheduled) { + if (peek(taskQueue) !== null) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } else { + var firstTimer = peek(timerQueue); + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + } + } + } + function flushWork(hasTimeRemaining, initialTime2) { + isHostCallbackScheduled = false; + if (isHostTimeoutScheduled) { + isHostTimeoutScheduled = false; + cancelHostTimeout(); + } + isPerformingWork = true; + var previousPriorityLevel = currentPriorityLevel; + try { + if (enableProfiling) { + try { + return workLoop(hasTimeRemaining, initialTime2); + } catch (error) { + if (currentTask !== null) { + var currentTime = exports.unstable_now(); + markTaskErrored(currentTask, currentTime); + currentTask.isQueued = false; + } + throw error; + } + } else { + return workLoop(hasTimeRemaining, initialTime2); + } + } finally { + currentTask = null; + currentPriorityLevel = previousPriorityLevel; + isPerformingWork = false; + } + } + function workLoop(hasTimeRemaining, initialTime2) { + var currentTime = initialTime2; + advanceTimers(currentTime); + currentTask = peek(taskQueue); + while (currentTask !== null && !enableSchedulerDebugging) { + if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) { + break; + } + var callback = currentTask.callback; + if (typeof callback === "function") { + currentTask.callback = null; + currentPriorityLevel = currentTask.priorityLevel; + var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; + var continuationCallback = callback(didUserCallbackTimeout); + currentTime = exports.unstable_now(); + if (typeof continuationCallback === "function") { + currentTask.callback = continuationCallback; + } else { + if (currentTask === peek(taskQueue)) { + pop(taskQueue); + } + } + advanceTimers(currentTime); + } else { + pop(taskQueue); + } + currentTask = peek(taskQueue); + } + if (currentTask !== null) { + return true; + } else { + var firstTimer = peek(timerQueue); + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + return false; + } + } + function unstable_runWithPriority(priorityLevel, eventHandler) { + switch (priorityLevel) { + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + case LowPriority: + case IdlePriority: + break; + default: + priorityLevel = NormalPriority; + } + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + try { + return eventHandler(); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + } + function unstable_next(eventHandler) { + var priorityLevel; + switch (currentPriorityLevel) { + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + priorityLevel = NormalPriority; + break; + default: + priorityLevel = currentPriorityLevel; + break; + } + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + try { + return eventHandler(); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + } + function unstable_wrapCallback(callback) { + var parentPriorityLevel = currentPriorityLevel; + return function() { + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = parentPriorityLevel; + try { + return callback.apply(this, arguments); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + }; + } + function unstable_scheduleCallback(priorityLevel, callback, options) { + var currentTime = exports.unstable_now(); + var startTime2; + if (typeof options === "object" && options !== null) { + var delay = options.delay; + if (typeof delay === "number" && delay > 0) { + startTime2 = currentTime + delay; + } else { + startTime2 = currentTime; + } + } else { + startTime2 = currentTime; + } + var timeout; + switch (priorityLevel) { + case ImmediatePriority: + timeout = IMMEDIATE_PRIORITY_TIMEOUT; + break; + case UserBlockingPriority: + timeout = USER_BLOCKING_PRIORITY_TIMEOUT; + break; + case IdlePriority: + timeout = IDLE_PRIORITY_TIMEOUT; + break; + case LowPriority: + timeout = LOW_PRIORITY_TIMEOUT; + break; + case NormalPriority: + default: + timeout = NORMAL_PRIORITY_TIMEOUT; + break; + } + var expirationTime = startTime2 + timeout; + var newTask = { + id: taskIdCounter++, + callback, + priorityLevel, + startTime: startTime2, + expirationTime, + sortIndex: -1 + }; + if (startTime2 > currentTime) { + newTask.sortIndex = startTime2; + push(timerQueue, newTask); + if (peek(taskQueue) === null && newTask === peek(timerQueue)) { + if (isHostTimeoutScheduled) { + cancelHostTimeout(); + } else { + isHostTimeoutScheduled = true; + } + requestHostTimeout(handleTimeout, startTime2 - currentTime); + } + } else { + newTask.sortIndex = expirationTime; + push(taskQueue, newTask); + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + return newTask; + } + function unstable_pauseExecution() { + } + function unstable_continueExecution() { + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + function unstable_getFirstCallbackNode() { + return peek(taskQueue); + } + function unstable_cancelCallback(task) { + task.callback = null; + } + function unstable_getCurrentPriorityLevel() { + return currentPriorityLevel; + } + var isMessageLoopRunning = false; + var scheduledHostCallback = null; + var taskTimeoutID = -1; + var frameInterval = frameYieldMs; + var startTime = -1; + function shouldYieldToHost() { + var timeElapsed = exports.unstable_now() - startTime; + if (timeElapsed < frameInterval) { + return false; + } + return true; + } + function requestPaint() { + } + function forceFrameRate(fps) { + if (fps < 0 || fps > 125) { + console["error"]("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"); + return; + } + if (fps > 0) { + frameInterval = Math.floor(1e3 / fps); + } else { + frameInterval = frameYieldMs; + } + } + var performWorkUntilDeadline = function() { + if (scheduledHostCallback !== null) { + var currentTime = exports.unstable_now(); + startTime = currentTime; + var hasTimeRemaining = true; + var hasMoreWork = true; + try { + hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime); + } finally { + if (hasMoreWork) { + schedulePerformWorkUntilDeadline(); + } else { + isMessageLoopRunning = false; + scheduledHostCallback = null; + } + } + } else { + isMessageLoopRunning = false; + } + }; + var schedulePerformWorkUntilDeadline; + if (typeof localSetImmediate === "function") { + schedulePerformWorkUntilDeadline = function() { + localSetImmediate(performWorkUntilDeadline); + }; + } else if (typeof MessageChannel !== "undefined") { + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = performWorkUntilDeadline; + schedulePerformWorkUntilDeadline = function() { + port.postMessage(null); + }; + } else { + schedulePerformWorkUntilDeadline = function() { + localSetTimeout(performWorkUntilDeadline, 0); + }; + } + function requestHostCallback(callback) { + scheduledHostCallback = callback; + if (!isMessageLoopRunning) { + isMessageLoopRunning = true; + schedulePerformWorkUntilDeadline(); + } + } + function requestHostTimeout(callback, ms) { + taskTimeoutID = localSetTimeout(function() { + callback(exports.unstable_now()); + }, ms); + } + function cancelHostTimeout() { + localClearTimeout(taskTimeoutID); + taskTimeoutID = -1; + } + var unstable_requestPaint = requestPaint; + var unstable_Profiling = null; + exports.unstable_IdlePriority = IdlePriority; + exports.unstable_ImmediatePriority = ImmediatePriority; + exports.unstable_LowPriority = LowPriority; + exports.unstable_NormalPriority = NormalPriority; + exports.unstable_Profiling = unstable_Profiling; + exports.unstable_UserBlockingPriority = UserBlockingPriority; + exports.unstable_cancelCallback = unstable_cancelCallback; + exports.unstable_continueExecution = unstable_continueExecution; + exports.unstable_forceFrameRate = forceFrameRate; + exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; + exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; + exports.unstable_next = unstable_next; + exports.unstable_pauseExecution = unstable_pauseExecution; + exports.unstable_requestPaint = unstable_requestPaint; + exports.unstable_runWithPriority = unstable_runWithPriority; + exports.unstable_scheduleCallback = unstable_scheduleCallback; + exports.unstable_shouldYield = shouldYieldToHost; + exports.unstable_wrapCallback = unstable_wrapCallback; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); + } + })(); + } + } +}); + +// node_modules/scheduler/index.js +var require_scheduler = __commonJS({ + "node_modules/scheduler/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV === "production") { + module.exports = require_scheduler_production_min(); + } else { + module.exports = require_scheduler_development(); + } + } +}); + +// node_modules/react-dom/cjs/react-dom.production.min.js +var require_react_dom_production_min = __commonJS({ + "node_modules/react-dom/cjs/react-dom.production.min.js"(exports) { + "use strict"; + init_cjs_shim(); + var aa = __require("react"); + var ca = require_scheduler(); + function p(a) { + for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++) + b += "&args[]=" + encodeURIComponent(arguments[c]); + return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; + } + var da = /* @__PURE__ */ new Set(); + var ea = {}; + function fa(a, b) { + ha(a, b); + ha(a + "Capture", b); + } + function ha(a, b) { + ea[a] = b; + for (a = 0; a < b.length; a++) + da.add(b[a]); + } + var ia = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement); + var ja = Object.prototype.hasOwnProperty; + var 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]*$/; + var la = {}; + var 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, b, c, d) { + if (null !== c && 0 === c.type) + return false; + switch (typeof b) { + case "function": + case "symbol": + return true; + case "boolean": + if (d) + return false; + if (null !== c) + return !c.acceptsBooleans; + a = a.toLowerCase().slice(0, 5); + return "data-" !== a && "aria-" !== a; + default: + return false; + } + } + function qa(a, b, c, d) { + if (null === b || "undefined" === typeof b || pa(a, b, c, d)) + return true; + if (d) + return false; + if (null !== c) + switch (c.type) { + case 3: + return !b; + case 4: + return false === b; + case 5: + return isNaN(b); + case 6: + return isNaN(b) || 1 > b; + } + return false; + } + function v(a, b, c, d, e, f, g) { + this.acceptsBooleans = 2 === b || 3 === b || 4 === b; + this.attributeName = d; + this.attributeNamespace = e; + this.mustUseProperty = c; + this.propertyName = a; + this.type = b; + this.sanitizeURL = f; + this.removeEmptyString = g; + } + var z = {}; + "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a) { + z[a] = new v(a, 0, false, a, null, false, false); + }); + [["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a) { + var b = a[0]; + z[b] = new v(b, 1, false, a[1], null, false, false); + }); + ["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a) { + z[a] = new v(a, 2, false, a.toLowerCase(), null, false, false); + }); + ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a) { + z[a] = new v(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(a, 3, false, a.toLowerCase(), null, false, false); + }); + ["checked", "multiple", "muted", "selected"].forEach(function(a) { + z[a] = new v(a, 3, true, a, null, false, false); + }); + ["capture", "download"].forEach(function(a) { + z[a] = new v(a, 4, false, a, null, false, false); + }); + ["cols", "rows", "size", "span"].forEach(function(a) { + z[a] = new v(a, 6, false, a, null, false, false); + }); + ["rowSpan", "start"].forEach(function(a) { + z[a] = new v(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 b = a.replace( + ra, + sa + ); + z[b] = new v(b, 1, false, a, null, false, false); + }); + "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a) { + var b = a.replace(ra, sa); + z[b] = new v(b, 1, false, a, "http://www.w3.org/1999/xlink", false, false); + }); + ["xml:base", "xml:lang", "xml:space"].forEach(function(a) { + var b = a.replace(ra, sa); + z[b] = new v(b, 1, false, a, "http://www.w3.org/XML/1998/namespace", false, false); + }); + ["tabIndex", "crossOrigin"].forEach(function(a) { + z[a] = new v(a, 1, false, a.toLowerCase(), null, false, false); + }); + z.xlinkHref = new v("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false); + ["src", "href", "action", "formAction"].forEach(function(a) { + z[a] = new v(a, 1, false, a.toLowerCase(), null, true, true); + }); + function ta(a, b, c, d) { + var e = z.hasOwnProperty(b) ? z[b] : null; + if (null !== e ? 0 !== e.type : d || !(2 < b.length) || "o" !== b[0] && "O" !== b[0] || "n" !== b[1] && "N" !== b[1]) + qa(b, c, e, d) && (c = null), d || null === e ? oa(b) && (null === c ? a.removeAttribute(b) : a.setAttribute(b, "" + c)) : e.mustUseProperty ? a[e.propertyName] = null === c ? 3 === e.type ? false : "" : c : (b = e.attributeName, d = e.attributeNamespace, null === c ? a.removeAttribute(b) : (e = e.type, c = 3 === e || 4 === e && true === c ? "" : "" + c, d ? a.setAttributeNS(d, b, c) : a.setAttribute(b, c))); + } + var ua = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + var va = Symbol.for("react.element"); + var wa = Symbol.for("react.portal"); + var ya = Symbol.for("react.fragment"); + var za = Symbol.for("react.strict_mode"); + var Aa = Symbol.for("react.profiler"); + var Ba = Symbol.for("react.provider"); + var Ca = Symbol.for("react.context"); + var Da = Symbol.for("react.forward_ref"); + var Ea = Symbol.for("react.suspense"); + var Fa = Symbol.for("react.suspense_list"); + var Ga = Symbol.for("react.memo"); + var Ha = Symbol.for("react.lazy"); + Symbol.for("react.scope"); + Symbol.for("react.debug_trace_mode"); + var Ia = Symbol.for("react.offscreen"); + Symbol.for("react.legacy_hidden"); + Symbol.for("react.cache"); + Symbol.for("react.tracing_marker"); + 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; + var La; + function Ma(a) { + if (void 0 === La) + try { + throw Error(); + } catch (c) { + var b = c.stack.trim().match(/\n( *(at )?)/); + La = b && b[1] || ""; + } + return "\n" + La + a; + } + var Na = false; + function Oa(a, b) { + if (!a || Na) + return ""; + Na = true; + var c = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + try { + if (b) + if (b = function() { + throw Error(); + }, Object.defineProperty(b.prototype, "props", { set: function() { + throw Error(); + } }), "object" === typeof Reflect && Reflect.construct) { + try { + Reflect.construct(b, []); + } catch (l) { + var d = l; + } + Reflect.construct(a, [], b); + } else { + try { + b.call(); + } catch (l) { + d = l; + } + a.call(b.prototype); + } + else { + try { + throw Error(); + } catch (l) { + d = l; + } + a(); + } + } catch (l) { + if (l && d && "string" === typeof l.stack) { + for (var e = l.stack.split("\n"), f = d.stack.split("\n"), g = e.length - 1, h = f.length - 1; 1 <= g && 0 <= h && e[g] !== f[h]; ) + h--; + for (; 1 <= g && 0 <= h; g--, h--) + if (e[g] !== f[h]) { + if (1 !== g || 1 !== h) { + do + if (g--, h--, 0 > h || e[g] !== f[h]) { + var k = "\n" + e[g].replace(" at new ", " at "); + a.displayName && k.includes("") && (k = k.replace("", a.displayName)); + return k; + } + while (1 <= g && 0 <= h); + } + break; + } + } + } finally { + Na = false, Error.prepareStackTrace = c; + } + 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 b = a.render; + a = a.displayName; + a || (a = b.displayName || b.name || "", a = "" !== a ? "ForwardRef(" + a + ")" : "ForwardRef"); + return a; + case Ga: + return b = a.displayName || null, null !== b ? b : Qa(a.type) || "Memo"; + case Ha: + b = a._payload; + a = a._init; + try { + return Qa(a(b)); + } catch (c) { + } + } + return null; + } + function Ra(a) { + var b = a.type; + switch (a.tag) { + case 24: + return "Cache"; + case 9: + return (b.displayName || "Context") + ".Consumer"; + case 10: + return (b._context.displayName || "Context") + ".Provider"; + case 18: + return "DehydratedFragment"; + case 11: + return a = b.render, a = a.displayName || a.name || "", b.displayName || ("" !== a ? "ForwardRef(" + a + ")" : "ForwardRef"); + case 7: + return "Fragment"; + case 5: + return b; + case 4: + return "Portal"; + case 3: + return "Root"; + case 6: + return "Text"; + case 16: + return Qa(b); + case 8: + return b === 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 b) + return b.displayName || b.name || null; + if ("string" === typeof b) + return b; + } + 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 b = a.type; + return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b || "radio" === b); + } + function Ua(a) { + var b = Ta(a) ? "checked" : "value", c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b), d = "" + a[b]; + if (!a.hasOwnProperty(b) && "undefined" !== typeof c && "function" === typeof c.get && "function" === typeof c.set) { + var e = c.get, f = c.set; + Object.defineProperty(a, b, { configurable: true, get: function() { + return e.call(this); + }, set: function(a2) { + d = "" + a2; + f.call(this, a2); + } }); + Object.defineProperty(a, b, { enumerable: c.enumerable }); + return { getValue: function() { + return d; + }, setValue: function(a2) { + d = "" + a2; + }, stopTracking: function() { + a._valueTracker = null; + delete a[b]; + } }; + } + } + function Va(a) { + a._valueTracker || (a._valueTracker = Ua(a)); + } + function Wa(a) { + if (!a) + return false; + var b = a._valueTracker; + if (!b) + return true; + var c = b.getValue(); + var d = ""; + a && (d = Ta(a) ? a.checked ? "true" : "false" : a.value); + a = d; + return a !== c ? (b.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 (b) { + return a.body; + } + } + function Ya(a, b) { + var c = b.checked; + return A({}, b, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: null != c ? c : a._wrapperState.initialChecked }); + } + function Za(a, b) { + var c = null == b.defaultValue ? "" : b.defaultValue, d = null != b.checked ? b.checked : b.defaultChecked; + c = Sa(null != b.value ? b.value : c); + a._wrapperState = { initialChecked: d, initialValue: c, controlled: "checkbox" === b.type || "radio" === b.type ? null != b.checked : null != b.value }; + } + function ab(a, b) { + b = b.checked; + null != b && ta(a, "checked", b, false); + } + function bb(a, b) { + ab(a, b); + var c = Sa(b.value), d = b.type; + if (null != c) + if ("number" === d) { + if (0 === c && "" === a.value || a.value != c) + a.value = "" + c; + } else + a.value !== "" + c && (a.value = "" + c); + else if ("submit" === d || "reset" === d) { + a.removeAttribute("value"); + return; + } + b.hasOwnProperty("value") ? cb(a, b.type, c) : b.hasOwnProperty("defaultValue") && cb(a, b.type, Sa(b.defaultValue)); + null == b.checked && null != b.defaultChecked && (a.defaultChecked = !!b.defaultChecked); + } + function db(a, b, c) { + if (b.hasOwnProperty("value") || b.hasOwnProperty("defaultValue")) { + var d = b.type; + if (!("submit" !== d && "reset" !== d || void 0 !== b.value && null !== b.value)) + return; + b = "" + a._wrapperState.initialValue; + c || b === a.value || (a.value = b); + a.defaultValue = b; + } + c = a.name; + "" !== c && (a.name = ""); + a.defaultChecked = !!a._wrapperState.initialChecked; + "" !== c && (a.name = c); + } + function cb(a, b, c) { + if ("number" !== b || Xa(a.ownerDocument) !== a) + null == c ? a.defaultValue = "" + a._wrapperState.initialValue : a.defaultValue !== "" + c && (a.defaultValue = "" + c); + } + var eb = Array.isArray; + function fb(a, b, c, d) { + a = a.options; + if (b) { + b = {}; + for (var e = 0; e < c.length; e++) + b["$" + c[e]] = true; + for (c = 0; c < a.length; c++) + e = b.hasOwnProperty("$" + a[c].value), a[c].selected !== e && (a[c].selected = e), e && d && (a[c].defaultSelected = true); + } else { + c = "" + Sa(c); + b = null; + for (e = 0; e < a.length; e++) { + if (a[e].value === c) { + a[e].selected = true; + d && (a[e].defaultSelected = true); + return; + } + null !== b || a[e].disabled || (b = a[e]); + } + null !== b && (b.selected = true); + } + } + function gb(a, b) { + if (null != b.dangerouslySetInnerHTML) + throw Error(p(91)); + return A({}, b, { value: void 0, defaultValue: void 0, children: "" + a._wrapperState.initialValue }); + } + function hb(a, b) { + var c = b.value; + if (null == c) { + c = b.children; + b = b.defaultValue; + if (null != c) { + if (null != b) + throw Error(p(92)); + if (eb(c)) { + if (1 < c.length) + throw Error(p(93)); + c = c[0]; + } + b = c; + } + null == b && (b = ""); + c = b; + } + a._wrapperState = { initialValue: Sa(c) }; + } + function ib(a, b) { + var c = Sa(b.value), d = Sa(b.defaultValue); + null != c && (c = "" + c, c !== a.value && (a.value = c), null == b.defaultValue && a.defaultValue !== c && (a.defaultValue = c)); + null != d && (a.defaultValue = "" + d); + } + function jb(a) { + var b = a.textContent; + b === a._wrapperState.initialValue && "" !== b && null !== b && (a.value = b); + } + 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, b) { + return null == a || "http://www.w3.org/1999/xhtml" === a ? kb(b) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b ? "http://www.w3.org/1999/xhtml" : a; + } + var mb; + var nb = function(a) { + return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b, c, d, e) { + MSApp.execUnsafeLocalFunction(function() { + return a(b, c, d, e); + }); + } : a; + }(function(a, b) { + if ("http://www.w3.org/2000/svg" !== a.namespaceURI || "innerHTML" in a) + a.innerHTML = b; + else { + mb = mb || document.createElement("div"); + mb.innerHTML = "" + b.valueOf().toString() + ""; + for (b = mb.firstChild; a.firstChild; ) + a.removeChild(a.firstChild); + for (; b.firstChild; ) + a.appendChild(b.firstChild); + } + }); + function ob(a, b) { + if (b) { + var c = a.firstChild; + if (c && c === a.lastChild && 3 === c.nodeType) { + c.nodeValue = b; + return; + } + } + a.textContent = b; + } + 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 + }; + var qb = ["Webkit", "ms", "Moz", "O"]; + Object.keys(pb).forEach(function(a) { + qb.forEach(function(b) { + b = b + a.charAt(0).toUpperCase() + a.substring(1); + pb[b] = pb[a]; + }); + }); + function rb(a, b, c) { + return null == b || "boolean" === typeof b || "" === b ? "" : c || "number" !== typeof b || 0 === b || pb.hasOwnProperty(a) && pb[a] ? ("" + b).trim() : b + "px"; + } + function sb(a, b) { + a = a.style; + for (var c in b) + if (b.hasOwnProperty(c)) { + var d = 0 === c.indexOf("--"), e = rb(c, b[c], d); + "float" === c && (c = "cssFloat"); + d ? a.setProperty(c, e) : a[c] = e; + } + } + 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, b) { + if (b) { + if (tb[a] && (null != b.children || null != b.dangerouslySetInnerHTML)) + throw Error(p(137, a)); + if (null != b.dangerouslySetInnerHTML) { + if (null != b.children) + throw Error(p(60)); + if ("object" !== typeof b.dangerouslySetInnerHTML || !("__html" in b.dangerouslySetInnerHTML)) + throw Error(p(61)); + } + if (null != b.style && "object" !== typeof b.style) + throw Error(p(62)); + } + } + function vb(a, b) { + if (-1 === a.indexOf("-")) + return "string" === typeof b.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; + var zb = null; + var Ab = null; + function Bb(a) { + if (a = Cb(a)) { + if ("function" !== typeof yb) + throw Error(p(280)); + var b = a.stateNode; + b && (b = Db(b), yb(a.stateNode, a.type, b)); + } + } + function Eb(a) { + zb ? Ab ? Ab.push(a) : Ab = [a] : zb = a; + } + function Fb() { + if (zb) { + var a = zb, b = Ab; + Ab = zb = null; + Bb(a); + if (b) + for (a = 0; a < b.length; a++) + Bb(b[a]); + } + } + function Gb(a, b) { + return a(b); + } + function Hb() { + } + var Ib = false; + function Jb(a, b, c) { + if (Ib) + return a(b, c); + Ib = true; + try { + return Gb(a, b, c); + } finally { + if (Ib = false, null !== zb || null !== Ab) + Hb(), Fb(); + } + } + function Kb(a, b) { + var c = a.stateNode; + if (null === c) + return null; + var d = Db(c); + if (null === d) + return null; + c = d[b]; + a: + switch (b) { + case "onClick": + case "onClickCapture": + case "onDoubleClick": + case "onDoubleClickCapture": + case "onMouseDown": + case "onMouseDownCapture": + case "onMouseMove": + case "onMouseMoveCapture": + case "onMouseUp": + case "onMouseUpCapture": + case "onMouseEnter": + (d = !d.disabled) || (a = a.type, d = !("button" === a || "input" === a || "select" === a || "textarea" === a)); + a = !d; + break a; + default: + a = false; + } + if (a) + return null; + if (c && "function" !== typeof c) + throw Error(p(231, b, typeof c)); + return c; + } + var Lb = false; + if (ia) + try { + Mb = {}; + Object.defineProperty(Mb, "passive", { get: function() { + Lb = true; + } }); + window.addEventListener("test", Mb, Mb); + window.removeEventListener("test", Mb, Mb); + } catch (a) { + Lb = false; + } + var Mb; + function Nb(a, b, c, d, e, f, g, h, k) { + var l = Array.prototype.slice.call(arguments, 3); + try { + b.apply(c, l); + } catch (m) { + this.onError(m); + } + } + var Ob = false; + var Pb = null; + var Qb = false; + var Rb = null; + var Sb = { onError: function(a) { + Ob = true; + Pb = a; + } }; + function Tb(a, b, c, d, e, f, g, h, k) { + Ob = false; + Pb = null; + Nb.apply(Sb, arguments); + } + function Ub(a, b, c, d, e, f, g, h, k) { + Tb.apply(this, arguments); + if (Ob) { + if (Ob) { + var l = Pb; + Ob = false; + Pb = null; + } else + throw Error(p(198)); + Qb || (Qb = true, Rb = l); + } + } + function Vb(a) { + var b = a, c = a; + if (a.alternate) + for (; b.return; ) + b = b.return; + else { + a = b; + do + b = a, 0 !== (b.flags & 4098) && (c = b.return), a = b.return; + while (a); + } + return 3 === b.tag ? c : null; + } + function Wb(a) { + if (13 === a.tag) { + var b = a.memoizedState; + null === b && (a = a.alternate, null !== a && (b = a.memoizedState)); + if (null !== b) + return b.dehydrated; + } + return null; + } + function Xb(a) { + if (Vb(a) !== a) + throw Error(p(188)); + } + function Yb(a) { + var b = a.alternate; + if (!b) { + b = Vb(a); + if (null === b) + throw Error(p(188)); + return b !== a ? null : a; + } + for (var c = a, d = b; ; ) { + var e = c.return; + if (null === e) + break; + var f = e.alternate; + if (null === f) { + d = e.return; + if (null !== d) { + c = d; + continue; + } + break; + } + if (e.child === f.child) { + for (f = e.child; f; ) { + if (f === c) + return Xb(e), a; + if (f === d) + return Xb(e), b; + f = f.sibling; + } + throw Error(p(188)); + } + if (c.return !== d.return) + c = e, d = f; + else { + for (var g = false, h = e.child; h; ) { + if (h === c) { + g = true; + c = e; + d = f; + break; + } + if (h === d) { + g = true; + d = e; + c = f; + break; + } + h = h.sibling; + } + if (!g) { + for (h = f.child; h; ) { + if (h === c) { + g = true; + c = f; + d = e; + break; + } + if (h === d) { + g = true; + d = f; + c = e; + break; + } + h = h.sibling; + } + if (!g) + throw Error(p(189)); + } + } + if (c.alternate !== d) + throw Error(p(190)); + } + if (3 !== c.tag) + throw Error(p(188)); + return c.stateNode.current === c ? a : b; + } + 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 b = $b(a); + if (null !== b) + return b; + a = a.sibling; + } + return null; + } + var ac = ca.unstable_scheduleCallback; + var bc = ca.unstable_cancelCallback; + var cc = ca.unstable_shouldYield; + var dc = ca.unstable_requestPaint; + var B = ca.unstable_now; + var ec = ca.unstable_getCurrentPriorityLevel; + var fc = ca.unstable_ImmediatePriority; + var gc = ca.unstable_UserBlockingPriority; + var hc = ca.unstable_NormalPriority; + var ic = ca.unstable_LowPriority; + var jc = ca.unstable_IdlePriority; + var kc = null; + var lc = null; + function mc(a) { + if (lc && "function" === typeof lc.onCommitFiberRoot) + try { + lc.onCommitFiberRoot(kc, a, void 0, 128 === (a.current.flags & 128)); + } catch (b) { + } + } + var oc = Math.clz32 ? Math.clz32 : nc; + var pc = Math.log; + var qc = Math.LN2; + function nc(a) { + a >>>= 0; + return 0 === a ? 32 : 31 - (pc(a) / qc | 0) | 0; + } + var rc = 64; + var 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, b) { + var c = a.pendingLanes; + if (0 === c) + return 0; + var d = 0, e = a.suspendedLanes, f = a.pingedLanes, g = c & 268435455; + if (0 !== g) { + var h = g & ~e; + 0 !== h ? d = tc(h) : (f &= g, 0 !== f && (d = tc(f))); + } else + g = c & ~e, 0 !== g ? d = tc(g) : 0 !== f && (d = tc(f)); + if (0 === d) + return 0; + if (0 !== b && b !== d && 0 === (b & e) && (e = d & -d, f = b & -b, e >= f || 16 === e && 0 !== (f & 4194240))) + return b; + 0 !== (d & 4) && (d |= c & 16); + b = a.entangledLanes; + if (0 !== b) + for (a = a.entanglements, b &= d; 0 < b; ) + c = 31 - oc(b), e = 1 << c, d |= a[c], b &= ~e; + return d; + } + function vc(a, b) { + switch (a) { + case 1: + case 2: + case 4: + return b + 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 b + 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, b) { + for (var c = a.suspendedLanes, d = a.pingedLanes, e = a.expirationTimes, f = a.pendingLanes; 0 < f; ) { + var g = 31 - oc(f), h = 1 << g, k = e[g]; + if (-1 === k) { + if (0 === (h & c) || 0 !== (h & d)) + e[g] = vc(h, b); + } else + k <= b && (a.expiredLanes |= h); + f &= ~h; + } + } + 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 b = [], c = 0; 31 > c; c++) + b.push(a); + return b; + } + function Ac(a, b, c) { + a.pendingLanes |= b; + 536870912 !== b && (a.suspendedLanes = 0, a.pingedLanes = 0); + a = a.eventTimes; + b = 31 - oc(b); + a[b] = c; + } + function Bc(a, b) { + var c = a.pendingLanes & ~b; + a.pendingLanes = b; + a.suspendedLanes = 0; + a.pingedLanes = 0; + a.expiredLanes &= b; + a.mutableReadLanes &= b; + a.entangledLanes &= b; + b = a.entanglements; + var d = a.eventTimes; + for (a = a.expirationTimes; 0 < c; ) { + var e = 31 - oc(c), f = 1 << e; + b[e] = 0; + d[e] = -1; + a[e] = -1; + c &= ~f; + } + } + function Cc(a, b) { + var c = a.entangledLanes |= b; + for (a = a.entanglements; c; ) { + var d = 31 - oc(c), e = 1 << d; + e & b | a[d] & b && (a[d] |= b); + c &= ~e; + } + } + var C = 0; + function Dc(a) { + a &= -a; + return 1 < a ? 4 < a ? 0 !== (a & 268435455) ? 16 : 536870912 : 4 : 1; + } + var Ec; + var Fc; + var Gc; + var Hc; + var Ic; + var Jc = false; + var Kc = []; + var Lc = null; + var Mc = null; + var Nc = null; + var Oc = /* @__PURE__ */ new Map(); + var Pc = /* @__PURE__ */ new Map(); + var Qc = []; + var 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, b) { + 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(b.pointerId); + break; + case "gotpointercapture": + case "lostpointercapture": + Pc.delete(b.pointerId); + } + } + function Tc(a, b, c, d, e, f) { + if (null === a || a.nativeEvent !== f) + return a = { blockedOn: b, domEventName: c, eventSystemFlags: d, nativeEvent: f, targetContainers: [e] }, null !== b && (b = Cb(b), null !== b && Fc(b)), a; + a.eventSystemFlags |= d; + b = a.targetContainers; + null !== e && -1 === b.indexOf(e) && b.push(e); + return a; + } + function Uc(a, b, c, d, e) { + switch (b) { + case "focusin": + return Lc = Tc(Lc, a, b, c, d, e), true; + case "dragenter": + return Mc = Tc(Mc, a, b, c, d, e), true; + case "mouseover": + return Nc = Tc(Nc, a, b, c, d, e), true; + case "pointerover": + var f = e.pointerId; + Oc.set(f, Tc(Oc.get(f) || null, a, b, c, d, e)); + return true; + case "gotpointercapture": + return f = e.pointerId, Pc.set(f, Tc(Pc.get(f) || null, a, b, c, d, e)), true; + } + return false; + } + function Vc(a) { + var b = Wc(a.target); + if (null !== b) { + var c = Vb(b); + if (null !== c) { + if (b = c.tag, 13 === b) { + if (b = Wb(c), null !== b) { + a.blockedOn = b; + Ic(a.priority, function() { + Gc(c); + }); + return; + } + } else if (3 === b && c.stateNode.current.memoizedState.isDehydrated) { + a.blockedOn = 3 === c.tag ? c.stateNode.containerInfo : null; + return; + } + } + } + a.blockedOn = null; + } + function Xc(a) { + if (null !== a.blockedOn) + return false; + for (var b = a.targetContainers; 0 < b.length; ) { + var c = Yc(a.domEventName, a.eventSystemFlags, b[0], a.nativeEvent); + if (null === c) { + c = a.nativeEvent; + var d = new c.constructor(c.type, c); + wb = d; + c.target.dispatchEvent(d); + wb = null; + } else + return b = Cb(c), null !== b && Fc(b), a.blockedOn = c, false; + b.shift(); + } + return true; + } + function Zc(a, b, c) { + Xc(a) && c.delete(b); + } + 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, b) { + a.blockedOn === b && (a.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c))); + } + function bd(a) { + function b(b2) { + return ad(b2, a); + } + if (0 < Kc.length) { + ad(Kc[0], a); + for (var c = 1; c < Kc.length; c++) { + var d = Kc[c]; + d.blockedOn === a && (d.blockedOn = null); + } + } + null !== Lc && ad(Lc, a); + null !== Mc && ad(Mc, a); + null !== Nc && ad(Nc, a); + Oc.forEach(b); + Pc.forEach(b); + for (c = 0; c < Qc.length; c++) + d = Qc[c], d.blockedOn === a && (d.blockedOn = null); + for (; 0 < Qc.length && (c = Qc[0], null === c.blockedOn); ) + Vc(c), null === c.blockedOn && Qc.shift(); + } + var cd = ua.ReactCurrentBatchConfig; + var dd = true; + function ed(a, b, c, d) { + var e = C, f = cd.transition; + cd.transition = null; + try { + C = 1, fd(a, b, c, d); + } finally { + C = e, cd.transition = f; + } + } + function gd(a, b, c, d) { + var e = C, f = cd.transition; + cd.transition = null; + try { + C = 4, fd(a, b, c, d); + } finally { + C = e, cd.transition = f; + } + } + function fd(a, b, c, d) { + if (dd) { + var e = Yc(a, b, c, d); + if (null === e) + hd(a, b, d, id, c), Sc(a, d); + else if (Uc(e, a, b, c, d)) + d.stopPropagation(); + else if (Sc(a, d), b & 4 && -1 < Rc.indexOf(a)) { + for (; null !== e; ) { + var f = Cb(e); + null !== f && Ec(f); + f = Yc(a, b, c, d); + null === f && hd(a, b, d, id, c); + if (f === e) + break; + e = f; + } + null !== e && d.stopPropagation(); + } else + hd(a, b, d, null, c); + } + } + var id = null; + function Yc(a, b, c, d) { + id = null; + a = xb(d); + a = Wc(a); + if (null !== a) + if (b = Vb(a), null === b) + a = null; + else if (c = b.tag, 13 === c) { + a = Wb(b); + if (null !== a) + return a; + a = null; + } else if (3 === c) { + if (b.stateNode.current.memoizedState.isDehydrated) + return 3 === b.tag ? b.stateNode.containerInfo : null; + a = null; + } else + b !== 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; + var ld = null; + var md = null; + function nd() { + if (md) + return md; + var a, b = ld, c = b.length, d, e = "value" in kd ? kd.value : kd.textContent, f = e.length; + for (a = 0; a < c && b[a] === e[a]; a++) + ; + var g = c - a; + for (d = 1; d <= g && b[c - d] === e[f - d]; d++) + ; + return md = e.slice(a, 1 < d ? 1 - d : void 0); + } + function od(a) { + var b = a.keyCode; + "charCode" in a ? (a = a.charCode, 0 === a && 13 === b && (a = 13)) : a = b; + 10 === a && (a = 13); + return 32 <= a || 13 === a ? a : 0; + } + function pd() { + return true; + } + function qd() { + return false; + } + function rd(a) { + function b(b2, d, e, f, g) { + this._reactName = b2; + this._targetInst = e; + this.type = d; + this.nativeEvent = f; + this.target = g; + this.currentTarget = null; + for (var c in a) + a.hasOwnProperty(c) && (b2 = a[c], this[c] = b2 ? b2(f) : f[c]); + this.isDefaultPrevented = (null != f.defaultPrevented ? f.defaultPrevented : false === f.returnValue) ? pd : qd; + this.isPropagationStopped = qd; + return this; + } + A(b.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 b; + } + var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a) { + return a.timeStamp || Date.now(); + }, defaultPrevented: 0, isTrusted: 0 }; + var td = rd(sd); + var ud = A({}, sd, { view: 0, detail: 0 }); + var vd = rd(ud); + var wd; + var xd; + var yd; + var 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; + } }); + var Bd = rd(Ad); + var Cd = A({}, Ad, { dataTransfer: 0 }); + var Dd = rd(Cd); + var Ed = A({}, ud, { relatedTarget: 0 }); + var Fd = rd(Ed); + var Gd = A({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }); + var Hd = rd(Gd); + var Id = A({}, sd, { clipboardData: function(a) { + return "clipboardData" in a ? a.clipboardData : window.clipboardData; + } }); + var Jd = rd(Id); + var Kd = A({}, sd, { data: 0 }); + var Ld = rd(Kd); + var Md = { + Esc: "Escape", + Spacebar: " ", + Left: "ArrowLeft", + Up: "ArrowUp", + Right: "ArrowRight", + Down: "ArrowDown", + Del: "Delete", + Win: "OS", + Menu: "ContextMenu", + Apps: "ContextMenu", + Scroll: "ScrollLock", + MozPrintableKey: "Unidentified" + }; + var 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" + }; + var Od = { Alt: "altKey", Control: "ctrlKey", Meta: "metaKey", Shift: "shiftKey" }; + function Pd(a) { + var b = this.nativeEvent; + return b.getModifierState ? b.getModifierState(a) : (a = Od[a]) ? !!b[a] : false; + } + function zd() { + return Pd; + } + var Qd = A({}, ud, { key: function(a) { + if (a.key) { + var b = Md[a.key] || a.key; + if ("Unidentified" !== b) + return b; + } + 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; + } }); + var Rd = rd(Qd); + var Sd = A({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 }); + var Td = rd(Sd); + var Ud = A({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd }); + var Vd = rd(Ud); + var Wd = A({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }); + var Xd = rd(Wd); + var 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 + }); + var Zd = rd(Yd); + var $d = [9, 13, 27, 32]; + var ae = ia && "CompositionEvent" in window; + var be = null; + ia && "documentMode" in document && (be = document.documentMode); + var ce = ia && "TextEvent" in window && !be; + var de = ia && (!ae || be && 8 < be && 11 >= be); + var ee = String.fromCharCode(32); + var fe = false; + function ge(a, b) { + switch (a) { + case "keyup": + return -1 !== $d.indexOf(b.keyCode); + case "keydown": + return 229 !== b.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, b) { + switch (a) { + case "compositionend": + return he(b); + case "keypress": + if (32 !== b.which) + return null; + fe = true; + return ee; + case "textInput": + return a = b.data, a === ee && fe ? null : a; + default: + return null; + } + } + function ke(a, b) { + if (ie) + return "compositionend" === a || !ae && ge(a, b) ? (a = nd(), md = ld = kd = null, ie = false, a) : null; + switch (a) { + case "paste": + return null; + case "keypress": + if (!(b.ctrlKey || b.altKey || b.metaKey) || b.ctrlKey && b.altKey) { + if (b.char && 1 < b.char.length) + return b.char; + if (b.which) + return String.fromCharCode(b.which); + } + return null; + case "compositionend": + return de && "ko" !== b.locale ? null : b.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 b = a && a.nodeName && a.nodeName.toLowerCase(); + return "input" === b ? !!le[a.type] : "textarea" === b ? true : false; + } + function ne(a, b, c, d) { + Eb(d); + b = oe(b, "onChange"); + 0 < b.length && (c = new td("onChange", "change", null, c, d), a.push({ event: c, listeners: b })); + } + var pe = null; + var qe = null; + function re(a) { + se(a, 0); + } + function te(a) { + var b = ue(a); + if (Wa(b)) + return a; + } + function ve(a, b) { + if ("change" === a) + return b; + } + var we = false; + if (ia) { + if (ia) { + ye = "oninput" in document; + if (!ye) { + 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); + } + var xe; + var ye; + var ze; + function Ae() { + pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null); + } + function Be(a) { + if ("value" === a.propertyName && te(qe)) { + var b = []; + ne(b, qe, a, xb(a)); + Jb(re, b); + } + } + function Ce(a, b, c) { + "focusin" === a ? (Ae(), pe = b, qe = c, pe.attachEvent("onpropertychange", Be)) : "focusout" === a && Ae(); + } + function De(a) { + if ("selectionchange" === a || "keyup" === a || "keydown" === a) + return te(qe); + } + function Ee(a, b) { + if ("click" === a) + return te(b); + } + function Fe(a, b) { + if ("input" === a || "change" === a) + return te(b); + } + function Ge(a, b) { + return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b; + } + var He = "function" === typeof Object.is ? Object.is : Ge; + function Ie(a, b) { + if (He(a, b)) + return true; + if ("object" !== typeof a || null === a || "object" !== typeof b || null === b) + return false; + var c = Object.keys(a), d = Object.keys(b); + if (c.length !== d.length) + return false; + for (d = 0; d < c.length; d++) { + var e = c[d]; + if (!ja.call(b, e) || !He(a[e], b[e])) + return false; + } + return true; + } + function Je(a) { + for (; a && a.firstChild; ) + a = a.firstChild; + return a; + } + function Ke(a, b) { + var c = Je(a); + a = 0; + for (var d; c; ) { + if (3 === c.nodeType) { + d = a + c.textContent.length; + if (a <= b && d >= b) + return { node: c, offset: b - a }; + a = d; + } + a: { + for (; c; ) { + if (c.nextSibling) { + c = c.nextSibling; + break a; + } + c = c.parentNode; + } + c = void 0; + } + c = Je(c); + } + } + function Le(a, b) { + return a && b ? a === b ? true : a && 3 === a.nodeType ? false : b && 3 === b.nodeType ? Le(a, b.parentNode) : "contains" in a ? a.contains(b) : a.compareDocumentPosition ? !!(a.compareDocumentPosition(b) & 16) : false : false; + } + function Me() { + for (var a = window, b = Xa(); b instanceof a.HTMLIFrameElement; ) { + try { + var c = "string" === typeof b.contentWindow.location.href; + } catch (d) { + c = false; + } + if (c) + a = b.contentWindow; + else + break; + b = Xa(a.document); + } + return b; + } + function Ne(a) { + var b = a && a.nodeName && a.nodeName.toLowerCase(); + return b && ("input" === b && ("text" === a.type || "search" === a.type || "tel" === a.type || "url" === a.type || "password" === a.type) || "textarea" === b || "true" === a.contentEditable); + } + function Oe(a) { + var b = Me(), c = a.focusedElem, d = a.selectionRange; + if (b !== c && c && c.ownerDocument && Le(c.ownerDocument.documentElement, c)) { + if (null !== d && Ne(c)) { + if (b = d.start, a = d.end, void 0 === a && (a = b), "selectionStart" in c) + c.selectionStart = b, c.selectionEnd = Math.min(a, c.value.length); + else if (a = (b = c.ownerDocument || document) && b.defaultView || window, a.getSelection) { + a = a.getSelection(); + var e = c.textContent.length, f = Math.min(d.start, e); + d = void 0 === d.end ? f : Math.min(d.end, e); + !a.extend && f > d && (e = d, d = f, f = e); + e = Ke(c, f); + var g = Ke( + c, + d + ); + e && g && (1 !== a.rangeCount || a.anchorNode !== e.node || a.anchorOffset !== e.offset || a.focusNode !== g.node || a.focusOffset !== g.offset) && (b = b.createRange(), b.setStart(e.node, e.offset), a.removeAllRanges(), f > d ? (a.addRange(b), a.extend(g.node, g.offset)) : (b.setEnd(g.node, g.offset), a.addRange(b))); + } + } + b = []; + for (a = c; a = a.parentNode; ) + 1 === a.nodeType && b.push({ element: a, left: a.scrollLeft, top: a.scrollTop }); + "function" === typeof c.focus && c.focus(); + for (c = 0; c < b.length; c++) + a = b[c], a.element.scrollLeft = a.left, a.element.scrollTop = a.top; + } + } + var Pe = ia && "documentMode" in document && 11 >= document.documentMode; + var Qe = null; + var Re = null; + var Se = null; + var Te = false; + function Ue(a, b, c) { + var d = c.window === c ? c.document : 9 === c.nodeType ? c : c.ownerDocument; + Te || null == Qe || Qe !== Xa(d) || (d = Qe, "selectionStart" in d && Ne(d) ? d = { start: d.selectionStart, end: d.selectionEnd } : (d = (d.ownerDocument && d.ownerDocument.defaultView || window).getSelection(), d = { anchorNode: d.anchorNode, anchorOffset: d.anchorOffset, focusNode: d.focusNode, focusOffset: d.focusOffset }), Se && Ie(Se, d) || (Se = d, d = oe(Re, "onSelect"), 0 < d.length && (b = new td("onSelect", "select", null, b, c), a.push({ event: b, listeners: d }), b.target = Qe))); + } + function Ve(a, b) { + var c = {}; + c[a.toLowerCase()] = b.toLowerCase(); + c["Webkit" + a] = "webkit" + b; + c["Moz" + a] = "moz" + b; + return c; + } + var We = { animationend: Ve("Animation", "AnimationEnd"), animationiteration: Ve("Animation", "AnimationIteration"), animationstart: Ve("Animation", "AnimationStart"), transitionend: Ve("Transition", "TransitionEnd") }; + var Xe = {}; + var 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 b = We[a], c; + for (c in b) + if (b.hasOwnProperty(c) && c in Ye) + return Xe[a] = b[c]; + return a; + } + var $e = Ze("animationend"); + var af = Ze("animationiteration"); + var bf = Ze("animationstart"); + var cf = Ze("transitionend"); + var df = /* @__PURE__ */ new Map(); + var 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, b) { + df.set(a, b); + fa(b, [a]); + } + for (gf = 0; gf < ef.length; gf++) { + hf = ef[gf], jf = hf.toLowerCase(), kf = hf[0].toUpperCase() + hf.slice(1); + ff(jf, "on" + kf); + } + var hf; + var jf; + var kf; + var gf; + 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(" "); + var mf = new Set("cancel close invalid load scroll toggle".split(" ").concat(lf)); + function nf(a, b, c) { + var d = a.type || "unknown-event"; + a.currentTarget = c; + Ub(d, b, void 0, a); + a.currentTarget = null; + } + function se(a, b) { + b = 0 !== (b & 4); + for (var c = 0; c < a.length; c++) { + var d = a[c], e = d.event; + d = d.listeners; + a: { + var f = void 0; + if (b) + for (var g = d.length - 1; 0 <= g; g--) { + var h = d[g], k = h.instance, l = h.currentTarget; + h = h.listener; + if (k !== f && e.isPropagationStopped()) + break a; + nf(e, h, l); + f = k; + } + else + for (g = 0; g < d.length; g++) { + h = d[g]; + k = h.instance; + l = h.currentTarget; + h = h.listener; + if (k !== f && e.isPropagationStopped()) + break a; + nf(e, h, l); + f = k; + } + } + } + if (Qb) + throw a = Rb, Qb = false, Rb = null, a; + } + function D(a, b) { + var c = b[of]; + void 0 === c && (c = b[of] = /* @__PURE__ */ new Set()); + var d = a + "__bubble"; + c.has(d) || (pf(b, a, 2, false), c.add(d)); + } + function qf(a, b, c) { + var d = 0; + b && (d |= 4); + pf(c, a, d, b); + } + var rf = "_reactListening" + Math.random().toString(36).slice(2); + function sf(a) { + if (!a[rf]) { + a[rf] = true; + da.forEach(function(b2) { + "selectionchange" !== b2 && (mf.has(b2) || qf(b2, false, a), qf(b2, true, a)); + }); + var b = 9 === a.nodeType ? a : a.ownerDocument; + null === b || b[rf] || (b[rf] = true, qf("selectionchange", false, b)); + } + } + function pf(a, b, c, d) { + switch (jd(b)) { + case 1: + var e = ed; + break; + case 4: + e = gd; + break; + default: + e = fd; + } + c = e.bind(null, b, c, a); + e = void 0; + !Lb || "touchstart" !== b && "touchmove" !== b && "wheel" !== b || (e = true); + d ? void 0 !== e ? a.addEventListener(b, c, { capture: true, passive: e }) : a.addEventListener(b, c, true) : void 0 !== e ? a.addEventListener(b, c, { passive: e }) : a.addEventListener(b, c, false); + } + function hd(a, b, c, d, e) { + var f = d; + if (0 === (b & 1) && 0 === (b & 2) && null !== d) + a: + for (; ; ) { + if (null === d) + return; + var g = d.tag; + if (3 === g || 4 === g) { + var h = d.stateNode.containerInfo; + if (h === e || 8 === h.nodeType && h.parentNode === e) + break; + if (4 === g) + for (g = d.return; null !== g; ) { + var k = g.tag; + if (3 === k || 4 === k) { + if (k = g.stateNode.containerInfo, k === e || 8 === k.nodeType && k.parentNode === e) + return; + } + g = g.return; + } + for (; null !== h; ) { + g = Wc(h); + if (null === g) + return; + k = g.tag; + if (5 === k || 6 === k) { + d = f = g; + continue a; + } + h = h.parentNode; + } + } + d = d.return; + } + Jb(function() { + var d2 = f, e2 = xb(c), g2 = []; + a: { + var h2 = df.get(a); + if (void 0 !== h2) { + var k2 = td, n = a; + switch (a) { + case "keypress": + if (0 === od(c)) + break a; + case "keydown": + case "keyup": + k2 = Rd; + break; + case "focusin": + n = "focus"; + k2 = Fd; + break; + case "focusout": + n = "blur"; + k2 = Fd; + break; + case "beforeblur": + case "afterblur": + k2 = Fd; + break; + case "click": + if (2 === c.button) + break a; + case "auxclick": + case "dblclick": + case "mousedown": + case "mousemove": + case "mouseup": + case "mouseout": + case "mouseover": + case "contextmenu": + k2 = Bd; + break; + case "drag": + case "dragend": + case "dragenter": + case "dragexit": + case "dragleave": + case "dragover": + case "dragstart": + case "drop": + k2 = Dd; + break; + case "touchcancel": + case "touchend": + case "touchmove": + case "touchstart": + k2 = Vd; + break; + case $e: + case af: + case bf: + k2 = Hd; + break; + case cf: + k2 = Xd; + break; + case "scroll": + k2 = vd; + break; + case "wheel": + k2 = Zd; + break; + case "copy": + case "cut": + case "paste": + k2 = Jd; + break; + case "gotpointercapture": + case "lostpointercapture": + case "pointercancel": + case "pointerdown": + case "pointermove": + case "pointerout": + case "pointerover": + case "pointerup": + k2 = Td; + } + var t = 0 !== (b & 4), J = !t && "scroll" === a, x = t ? null !== h2 ? h2 + "Capture" : null : h2; + t = []; + for (var w = d2, u; null !== w; ) { + u = w; + var F = u.stateNode; + 5 === u.tag && null !== F && (u = F, null !== x && (F = Kb(w, x), null != F && t.push(tf(w, F, u)))); + if (J) + break; + w = w.return; + } + 0 < t.length && (h2 = new k2(h2, n, null, c, e2), g2.push({ event: h2, listeners: t })); + } + } + if (0 === (b & 7)) { + a: { + h2 = "mouseover" === a || "pointerover" === a; + k2 = "mouseout" === a || "pointerout" === a; + if (h2 && c !== wb && (n = c.relatedTarget || c.fromElement) && (Wc(n) || n[uf])) + break a; + if (k2 || h2) { + h2 = e2.window === e2 ? e2 : (h2 = e2.ownerDocument) ? h2.defaultView || h2.parentWindow : window; + if (k2) { + if (n = c.relatedTarget || c.toElement, k2 = d2, n = n ? Wc(n) : null, null !== n && (J = Vb(n), n !== J || 5 !== n.tag && 6 !== n.tag)) + n = null; + } else + k2 = null, n = d2; + if (k2 !== n) { + t = Bd; + F = "onMouseLeave"; + x = "onMouseEnter"; + w = "mouse"; + if ("pointerout" === a || "pointerover" === a) + t = Td, F = "onPointerLeave", x = "onPointerEnter", w = "pointer"; + J = null == k2 ? h2 : ue(k2); + u = null == n ? h2 : ue(n); + h2 = new t(F, w + "leave", k2, c, e2); + h2.target = J; + h2.relatedTarget = u; + F = null; + Wc(e2) === d2 && (t = new t(x, w + "enter", n, c, e2), t.target = u, t.relatedTarget = J, F = t); + J = F; + if (k2 && n) + b: { + t = k2; + x = n; + w = 0; + for (u = t; u; u = vf(u)) + w++; + u = 0; + for (F = x; F; F = vf(F)) + u++; + for (; 0 < w - u; ) + t = vf(t), w--; + for (; 0 < u - w; ) + x = vf(x), u--; + for (; w--; ) { + if (t === x || null !== x && t === x.alternate) + break b; + t = vf(t); + x = vf(x); + } + t = null; + } + else + t = null; + null !== k2 && wf(g2, h2, k2, t, false); + null !== n && null !== J && wf(g2, J, n, t, true); + } + } + } + a: { + h2 = d2 ? ue(d2) : window; + k2 = h2.nodeName && h2.nodeName.toLowerCase(); + if ("select" === k2 || "input" === k2 && "file" === h2.type) + var na = ve; + else if (me(h2)) + if (we) + na = Fe; + else { + na = De; + var xa = Ce; + } + else + (k2 = h2.nodeName) && "input" === k2.toLowerCase() && ("checkbox" === h2.type || "radio" === h2.type) && (na = Ee); + if (na && (na = na(a, d2))) { + ne(g2, na, c, e2); + break a; + } + xa && xa(a, h2, d2); + "focusout" === a && (xa = h2._wrapperState) && xa.controlled && "number" === h2.type && cb(h2, "number", h2.value); + } + xa = d2 ? ue(d2) : window; + switch (a) { + case "focusin": + if (me(xa) || "true" === xa.contentEditable) + Qe = xa, Re = d2, Se = null; + break; + case "focusout": + Se = Re = Qe = null; + break; + case "mousedown": + Te = true; + break; + case "contextmenu": + case "mouseup": + case "dragend": + Te = false; + Ue(g2, c, e2); + break; + case "selectionchange": + if (Pe) + break; + case "keydown": + case "keyup": + Ue(g2, c, e2); + } + 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, c) && (ba = "onCompositionEnd") : "keydown" === a && 229 === c.keyCode && (ba = "onCompositionStart"); + ba && (de && "ko" !== c.locale && (ie || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie && ($a = nd()) : (kd = e2, ld = "value" in kd ? kd.value : kd.textContent, ie = true)), xa = oe(d2, ba), 0 < xa.length && (ba = new Ld(ba, a, null, c, e2), g2.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he(c), null !== $a && (ba.data = $a)))); + if ($a = ce ? je(a, c) : ke(a, c)) + d2 = oe(d2, "onBeforeInput"), 0 < d2.length && (e2 = new Ld("onBeforeInput", "beforeinput", null, c, e2), g2.push({ event: e2, listeners: d2 }), e2.data = $a); + } + se(g2, b); + }); + } + function tf(a, b, c) { + return { instance: a, listener: b, currentTarget: c }; + } + function oe(a, b) { + for (var c = b + "Capture", d = []; null !== a; ) { + var e = a, f = e.stateNode; + 5 === e.tag && null !== f && (e = f, f = Kb(a, c), null != f && d.unshift(tf(a, f, e)), f = Kb(a, b), null != f && d.push(tf(a, f, e))); + a = a.return; + } + return d; + } + function vf(a) { + if (null === a) + return null; + do + a = a.return; + while (a && 5 !== a.tag); + return a ? a : null; + } + function wf(a, b, c, d, e) { + for (var f = b._reactName, g = []; null !== c && c !== d; ) { + var h = c, k = h.alternate, l = h.stateNode; + if (null !== k && k === d) + break; + 5 === h.tag && null !== l && (h = l, e ? (k = Kb(c, f), null != k && g.unshift(tf(c, k, h))) : e || (k = Kb(c, f), null != k && g.push(tf(c, k, h)))); + c = c.return; + } + 0 !== g.length && a.push({ event: b, listeners: g }); + } + var xf = /\r\n?/g; + var yf = /\u0000|\uFFFD/g; + function zf(a) { + return ("string" === typeof a ? a : "" + a).replace(xf, "\n").replace(yf, ""); + } + function Af(a, b, c) { + b = zf(b); + if (zf(a) !== b && c) + throw Error(p(425)); + } + function Bf() { + } + var Cf = null; + var Df = null; + function Ef(a, b) { + return "textarea" === a || "noscript" === a || "string" === typeof b.children || "number" === typeof b.children || "object" === typeof b.dangerouslySetInnerHTML && null !== b.dangerouslySetInnerHTML && null != b.dangerouslySetInnerHTML.__html; + } + var Ff = "function" === typeof setTimeout ? setTimeout : void 0; + var Gf = "function" === typeof clearTimeout ? clearTimeout : void 0; + var Hf = "function" === typeof Promise ? Promise : void 0; + var 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, b) { + var c = b, d = 0; + do { + var e = c.nextSibling; + a.removeChild(c); + if (e && 8 === e.nodeType) + if (c = e.data, "/$" === c) { + if (0 === d) { + a.removeChild(e); + bd(b); + return; + } + d--; + } else + "$" !== c && "$?" !== c && "$!" !== c || d++; + c = e; + } while (c); + bd(b); + } + function Lf(a) { + for (; null != a; a = a.nextSibling) { + var b = a.nodeType; + if (1 === b || 3 === b) + break; + if (8 === b) { + b = a.data; + if ("$" === b || "$!" === b || "$?" === b) + break; + if ("/$" === b) + return null; + } + } + return a; + } + function Mf(a) { + a = a.previousSibling; + for (var b = 0; a; ) { + if (8 === a.nodeType) { + var c = a.data; + if ("$" === c || "$!" === c || "$?" === c) { + if (0 === b) + return a; + b--; + } else + "/$" === c && b++; + } + a = a.previousSibling; + } + return null; + } + var Nf = Math.random().toString(36).slice(2); + var Of = "__reactFiber$" + Nf; + var Pf = "__reactProps$" + Nf; + var uf = "__reactContainer$" + Nf; + var of = "__reactEvents$" + Nf; + var Qf = "__reactListeners$" + Nf; + var Rf = "__reactHandles$" + Nf; + function Wc(a) { + var b = a[Of]; + if (b) + return b; + for (var c = a.parentNode; c; ) { + if (b = c[uf] || c[Of]) { + c = b.alternate; + if (null !== b.child || null !== c && null !== c.child) + for (a = Mf(a); null !== a; ) { + if (c = a[Of]) + return c; + a = Mf(a); + } + return b; + } + a = c; + c = 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(33)); + } + function Db(a) { + return a[Pf] || null; + } + var Sf = []; + var Tf = -1; + function Uf(a) { + return { current: a }; + } + function E(a) { + 0 > Tf || (a.current = Sf[Tf], Sf[Tf] = null, Tf--); + } + function G(a, b) { + Tf++; + Sf[Tf] = a.current; + a.current = b; + } + var Vf = {}; + var H = Uf(Vf); + var Wf = Uf(false); + var Xf = Vf; + function Yf(a, b) { + var c = a.type.contextTypes; + if (!c) + return Vf; + var d = a.stateNode; + if (d && d.__reactInternalMemoizedUnmaskedChildContext === b) + return d.__reactInternalMemoizedMaskedChildContext; + var e = {}, f; + for (f in c) + e[f] = b[f]; + d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b, a.__reactInternalMemoizedMaskedChildContext = e); + return e; + } + function Zf(a) { + a = a.childContextTypes; + return null !== a && void 0 !== a; + } + function $f() { + E(Wf); + E(H); + } + function ag(a, b, c) { + if (H.current !== Vf) + throw Error(p(168)); + G(H, b); + G(Wf, c); + } + function bg(a, b, c) { + var d = a.stateNode; + b = b.childContextTypes; + if ("function" !== typeof d.getChildContext) + return c; + d = d.getChildContext(); + for (var e in d) + if (!(e in b)) + throw Error(p(108, Ra(a) || "Unknown", e)); + return A({}, c, d); + } + 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, b, c) { + var d = a.stateNode; + if (!d) + throw Error(p(169)); + c ? (a = bg(a, b, Xf), d.__reactInternalMemoizedMergedChildContext = a, E(Wf), E(H), G(H, a)) : E(Wf); + G(Wf, c); + } + var eg = null; + var fg = false; + var 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, b = C; + try { + var c = eg; + for (C = 1; a < c.length; a++) { + var d = c[a]; + do + d = d(true); + while (null !== d); + } + eg = null; + fg = false; + } catch (e) { + throw null !== eg && (eg = eg.slice(a + 1)), ac(fc, jg), e; + } finally { + C = b, gg = false; + } + } + return null; + } + var kg = []; + var lg = 0; + var mg = null; + var ng = 0; + var og = []; + var pg = 0; + var qg = null; + var rg = 1; + var sg = ""; + function tg(a, b) { + kg[lg++] = ng; + kg[lg++] = mg; + mg = a; + ng = b; + } + function ug(a, b, c) { + og[pg++] = rg; + og[pg++] = sg; + og[pg++] = qg; + qg = a; + var d = rg; + a = sg; + var e = 32 - oc(d) - 1; + d &= ~(1 << e); + c += 1; + var f = 32 - oc(b) + e; + if (30 < f) { + var g = e - e % 5; + f = (d & (1 << g) - 1).toString(32); + d >>= g; + e -= g; + rg = 1 << 32 - oc(b) + e | c << e | d; + sg = f + a; + } else + rg = 1 << f | c << e | d, 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; + var yg = null; + var I = false; + var zg = null; + function Ag(a, b) { + var c = Bg(5, null, null, 0); + c.elementType = "DELETED"; + c.stateNode = b; + c.return = a; + b = a.deletions; + null === b ? (a.deletions = [c], a.flags |= 16) : b.push(c); + } + function Cg(a, b) { + switch (a.tag) { + case 5: + var c = a.type; + b = 1 !== b.nodeType || c.toLowerCase() !== b.nodeName.toLowerCase() ? null : b; + return null !== b ? (a.stateNode = b, xg = a, yg = Lf(b.firstChild), true) : false; + case 6: + return b = "" === a.pendingProps || 3 !== b.nodeType ? null : b, null !== b ? (a.stateNode = b, xg = a, yg = null, true) : false; + case 13: + return b = 8 !== b.nodeType ? null : b, null !== b ? (c = null !== qg ? { id: rg, overflow: sg } : null, a.memoizedState = { dehydrated: b, treeContext: c, retryLane: 1073741824 }, c = Bg(18, null, null, 0), c.stateNode = b, c.return = a, a.child = c, 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 b = yg; + if (b) { + var c = b; + if (!Cg(a, b)) { + if (Dg(a)) + throw Error(p(418)); + b = Lf(c.nextSibling); + var d = xg; + b && Cg(a, b) ? Ag(d, c) : (a.flags = a.flags & -4097 | 2, I = false, xg = a); + } + } else { + if (Dg(a)) + throw Error(p(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 b; + (b = 3 !== a.tag) && !(b = 5 !== a.tag) && (b = a.type, b = "head" !== b && "body" !== b && !Ef(a.type, a.memoizedProps)); + if (b && (b = yg)) { + if (Dg(a)) + throw Hg(), Error(p(418)); + for (; b; ) + Ag(a, b), b = Lf(b.nextSibling); + } + Fg(a); + if (13 === a.tag) { + a = a.memoizedState; + a = null !== a ? a.dehydrated : null; + if (!a) + throw Error(p(317)); + a: { + a = a.nextSibling; + for (b = 0; a; ) { + if (8 === a.nodeType) { + var c = a.data; + if ("/$" === c) { + if (0 === b) { + yg = Lf(a.nextSibling); + break a; + } + b--; + } else + "$" !== c && "$!" !== c && "$?" !== c || b++; + } + 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, b) { + if (a && a.defaultProps) { + b = A({}, b); + a = a.defaultProps; + for (var c in a) + void 0 === b[c] && (b[c] = a[c]); + return b; + } + return b; + } + var Mg = Uf(null); + var Ng = null; + var Og = null; + var Pg = null; + function Qg() { + Pg = Og = Ng = null; + } + function Rg(a) { + var b = Mg.current; + E(Mg); + a._currentValue = b; + } + function Sg(a, b, c) { + for (; null !== a; ) { + var d = a.alternate; + (a.childLanes & b) !== b ? (a.childLanes |= b, null !== d && (d.childLanes |= b)) : null !== d && (d.childLanes & b) !== b && (d.childLanes |= b); + if (a === c) + break; + a = a.return; + } + } + function Tg(a, b) { + Ng = a; + Pg = Og = null; + a = a.dependencies; + null !== a && null !== a.firstContext && (0 !== (a.lanes & b) && (Ug = true), a.firstContext = null); + } + function Vg(a) { + var b = a._currentValue; + if (Pg !== a) + if (a = { context: a, memoizedValue: b, next: null }, null === Og) { + if (null === Ng) + throw Error(p(308)); + Og = a; + Ng.dependencies = { lanes: 0, firstContext: a }; + } else + Og = Og.next = a; + return b; + } + var Wg = null; + function Xg(a) { + null === Wg ? Wg = [a] : Wg.push(a); + } + function Yg(a, b, c, d) { + var e = b.interleaved; + null === e ? (c.next = c, Xg(b)) : (c.next = e.next, e.next = c); + b.interleaved = c; + return Zg(a, d); + } + function Zg(a, b) { + a.lanes |= b; + var c = a.alternate; + null !== c && (c.lanes |= b); + c = a; + for (a = a.return; null !== a; ) + a.childLanes |= b, c = a.alternate, null !== c && (c.childLanes |= b), c = a, a = a.return; + return 3 === c.tag ? c.stateNode : null; + } + var $g = false; + function ah(a) { + a.updateQueue = { baseState: a.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null }; + } + function bh(a, b) { + a = a.updateQueue; + b.updateQueue === a && (b.updateQueue = { baseState: a.baseState, firstBaseUpdate: a.firstBaseUpdate, lastBaseUpdate: a.lastBaseUpdate, shared: a.shared, effects: a.effects }); + } + function ch(a, b) { + return { eventTime: a, lane: b, tag: 0, payload: null, callback: null, next: null }; + } + function dh(a, b, c) { + var d = a.updateQueue; + if (null === d) + return null; + d = d.shared; + if (0 !== (K & 2)) { + var e = d.pending; + null === e ? b.next = b : (b.next = e.next, e.next = b); + d.pending = b; + return Zg(a, c); + } + e = d.interleaved; + null === e ? (b.next = b, Xg(d)) : (b.next = e.next, e.next = b); + d.interleaved = b; + return Zg(a, c); + } + function eh(a, b, c) { + b = b.updateQueue; + if (null !== b && (b = b.shared, 0 !== (c & 4194240))) { + var d = b.lanes; + d &= a.pendingLanes; + c |= d; + b.lanes = c; + Cc(a, c); + } + } + function fh(a, b) { + var c = a.updateQueue, d = a.alternate; + if (null !== d && (d = d.updateQueue, c === d)) { + var e = null, f = null; + c = c.firstBaseUpdate; + if (null !== c) { + do { + var g = { eventTime: c.eventTime, lane: c.lane, tag: c.tag, payload: c.payload, callback: c.callback, next: null }; + null === f ? e = f = g : f = f.next = g; + c = c.next; + } while (null !== c); + null === f ? e = f = b : f = f.next = b; + } else + e = f = b; + c = { baseState: d.baseState, firstBaseUpdate: e, lastBaseUpdate: f, shared: d.shared, effects: d.effects }; + a.updateQueue = c; + return; + } + a = c.lastBaseUpdate; + null === a ? c.firstBaseUpdate = b : a.next = b; + c.lastBaseUpdate = b; + } + function gh(a, b, c, d) { + var e = a.updateQueue; + $g = false; + var f = e.firstBaseUpdate, g = e.lastBaseUpdate, h = e.shared.pending; + if (null !== h) { + e.shared.pending = null; + var k = h, l = k.next; + k.next = null; + null === g ? f = l : g.next = l; + g = k; + var m = a.alternate; + null !== m && (m = m.updateQueue, h = m.lastBaseUpdate, h !== g && (null === h ? m.firstBaseUpdate = l : h.next = l, m.lastBaseUpdate = k)); + } + if (null !== f) { + var q = e.baseState; + g = 0; + m = l = k = null; + h = f; + do { + var r = h.lane, y = h.eventTime; + if ((d & r) === r) { + null !== m && (m = m.next = { + eventTime: y, + lane: 0, + tag: h.tag, + payload: h.payload, + callback: h.callback, + next: null + }); + a: { + var n = a, t = h; + r = b; + y = c; + switch (t.tag) { + case 1: + n = t.payload; + if ("function" === typeof n) { + q = n.call(y, q, r); + break a; + } + q = n; + break a; + case 3: + n.flags = n.flags & -65537 | 128; + case 0: + n = t.payload; + r = "function" === typeof n ? n.call(y, q, r) : n; + if (null === r || void 0 === r) + break a; + q = A({}, q, r); + break a; + case 2: + $g = true; + } + } + null !== h.callback && 0 !== h.lane && (a.flags |= 64, r = e.effects, null === r ? e.effects = [h] : r.push(h)); + } else + y = { eventTime: y, lane: r, tag: h.tag, payload: h.payload, callback: h.callback, next: null }, null === m ? (l = m = y, k = q) : m = m.next = y, g |= r; + h = h.next; + if (null === h) + if (h = e.shared.pending, null === h) + break; + else + r = h, h = r.next, r.next = null, e.lastBaseUpdate = r, e.shared.pending = null; + } while (1); + null === m && (k = q); + e.baseState = k; + e.firstBaseUpdate = l; + e.lastBaseUpdate = m; + b = e.shared.interleaved; + if (null !== b) { + e = b; + do + g |= e.lane, e = e.next; + while (e !== b); + } else + null === f && (e.shared.lanes = 0); + hh |= g; + a.lanes = g; + a.memoizedState = q; + } + } + function ih(a, b, c) { + a = b.effects; + b.effects = null; + if (null !== a) + for (b = 0; b < a.length; b++) { + var d = a[b], e = d.callback; + if (null !== e) { + d.callback = null; + d = c; + if ("function" !== typeof e) + throw Error(p(191, e)); + e.call(d); + } + } + } + var jh = new aa.Component().refs; + function kh(a, b, c, d) { + b = a.memoizedState; + c = c(d, b); + c = null === c || void 0 === c ? b : A({}, b, c); + a.memoizedState = c; + 0 === a.lanes && (a.updateQueue.baseState = c); + } + var nh = { isMounted: function(a) { + return (a = a._reactInternals) ? Vb(a) === a : false; + }, enqueueSetState: function(a, b, c) { + a = a._reactInternals; + var d = L(), e = lh(a), f = ch(d, e); + f.payload = b; + void 0 !== c && null !== c && (f.callback = c); + b = dh(a, f, e); + null !== b && (mh(b, a, e, d), eh(b, a, e)); + }, enqueueReplaceState: function(a, b, c) { + a = a._reactInternals; + var d = L(), e = lh(a), f = ch(d, e); + f.tag = 1; + f.payload = b; + void 0 !== c && null !== c && (f.callback = c); + b = dh(a, f, e); + null !== b && (mh(b, a, e, d), eh(b, a, e)); + }, enqueueForceUpdate: function(a, b) { + a = a._reactInternals; + var c = L(), d = lh(a), e = ch(c, d); + e.tag = 2; + void 0 !== b && null !== b && (e.callback = b); + b = dh(a, e, d); + null !== b && (mh(b, a, d, c), eh(b, a, d)); + } }; + function oh(a, b, c, d, e, f, g) { + a = a.stateNode; + return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d, f, g) : b.prototype && b.prototype.isPureReactComponent ? !Ie(c, d) || !Ie(e, f) : true; + } + function ph(a, b, c) { + var d = false, e = Vf; + var f = b.contextType; + "object" === typeof f && null !== f ? f = Vg(f) : (e = Zf(b) ? Xf : H.current, d = b.contextTypes, f = (d = null !== d && void 0 !== d) ? Yf(a, e) : Vf); + b = new b(c, f); + a.memoizedState = null !== b.state && void 0 !== b.state ? b.state : null; + b.updater = nh; + a.stateNode = b; + b._reactInternals = a; + d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e, a.__reactInternalMemoizedMaskedChildContext = f); + return b; + } + function qh(a, b, c, d) { + a = b.state; + "function" === typeof b.componentWillReceiveProps && b.componentWillReceiveProps(c, d); + "function" === typeof b.UNSAFE_componentWillReceiveProps && b.UNSAFE_componentWillReceiveProps(c, d); + b.state !== a && nh.enqueueReplaceState(b, b.state, null); + } + function rh(a, b, c, d) { + var e = a.stateNode; + e.props = c; + e.state = a.memoizedState; + e.refs = jh; + ah(a); + var f = b.contextType; + "object" === typeof f && null !== f ? e.context = Vg(f) : (f = Zf(b) ? Xf : H.current, e.context = Yf(a, f)); + e.state = a.memoizedState; + f = b.getDerivedStateFromProps; + "function" === typeof f && (kh(a, b, f, c), e.state = a.memoizedState); + "function" === typeof b.getDerivedStateFromProps || "function" === typeof e.getSnapshotBeforeUpdate || "function" !== typeof e.UNSAFE_componentWillMount && "function" !== typeof e.componentWillMount || (b = e.state, "function" === typeof e.componentWillMount && e.componentWillMount(), "function" === typeof e.UNSAFE_componentWillMount && e.UNSAFE_componentWillMount(), b !== e.state && nh.enqueueReplaceState(e, e.state, null), gh(a, c, e, d), e.state = a.memoizedState); + "function" === typeof e.componentDidMount && (a.flags |= 4194308); + } + function sh(a, b, c) { + a = c.ref; + if (null !== a && "function" !== typeof a && "object" !== typeof a) { + if (c._owner) { + c = c._owner; + if (c) { + if (1 !== c.tag) + throw Error(p(309)); + var d = c.stateNode; + } + if (!d) + throw Error(p(147, a)); + var e = d, f = "" + a; + if (null !== b && null !== b.ref && "function" === typeof b.ref && b.ref._stringRef === f) + return b.ref; + b = function(a2) { + var b2 = e.refs; + b2 === jh && (b2 = e.refs = {}); + null === a2 ? delete b2[f] : b2[f] = a2; + }; + b._stringRef = f; + return b; + } + if ("string" !== typeof a) + throw Error(p(284)); + if (!c._owner) + throw Error(p(290, a)); + } + return a; + } + function th(a, b) { + a = Object.prototype.toString.call(b); + throw Error(p(31, "[object Object]" === a ? "object with keys {" + Object.keys(b).join(", ") + "}" : a)); + } + function uh(a) { + var b = a._init; + return b(a._payload); + } + function vh(a) { + function b(b2, c2) { + if (a) { + var d2 = b2.deletions; + null === d2 ? (b2.deletions = [c2], b2.flags |= 16) : d2.push(c2); + } + } + function c(c2, d2) { + if (!a) + return null; + for (; null !== d2; ) + b(c2, d2), d2 = d2.sibling; + return null; + } + function d(a2, b2) { + for (a2 = /* @__PURE__ */ new Map(); null !== b2; ) + null !== b2.key ? a2.set(b2.key, b2) : a2.set(b2.index, b2), b2 = b2.sibling; + return a2; + } + function e(a2, b2) { + a2 = wh(a2, b2); + a2.index = 0; + a2.sibling = null; + return a2; + } + function f(b2, c2, d2) { + b2.index = d2; + if (!a) + return b2.flags |= 1048576, c2; + d2 = b2.alternate; + if (null !== d2) + return d2 = d2.index, d2 < c2 ? (b2.flags |= 2, c2) : d2; + b2.flags |= 2; + return c2; + } + function g(b2) { + a && null === b2.alternate && (b2.flags |= 2); + return b2; + } + function h(a2, b2, c2, d2) { + if (null === b2 || 6 !== b2.tag) + return b2 = xh(c2, a2.mode, d2), b2.return = a2, b2; + b2 = e(b2, c2); + b2.return = a2; + return b2; + } + function k(a2, b2, c2, d2) { + var f2 = c2.type; + if (f2 === ya) + return m(a2, b2, c2.props.children, d2, c2.key); + if (null !== b2 && (b2.elementType === f2 || "object" === typeof f2 && null !== f2 && f2.$$typeof === Ha && uh(f2) === b2.type)) + return d2 = e(b2, c2.props), d2.ref = sh(a2, b2, c2), d2.return = a2, d2; + d2 = yh(c2.type, c2.key, c2.props, null, a2.mode, d2); + d2.ref = sh(a2, b2, c2); + d2.return = a2; + return d2; + } + function l(a2, b2, c2, d2) { + if (null === b2 || 4 !== b2.tag || b2.stateNode.containerInfo !== c2.containerInfo || b2.stateNode.implementation !== c2.implementation) + return b2 = zh(c2, a2.mode, d2), b2.return = a2, b2; + b2 = e(b2, c2.children || []); + b2.return = a2; + return b2; + } + function m(a2, b2, c2, d2, f2) { + if (null === b2 || 7 !== b2.tag) + return b2 = Ah(c2, a2.mode, d2, f2), b2.return = a2, b2; + b2 = e(b2, c2); + b2.return = a2; + return b2; + } + function q(a2, b2, c2) { + if ("string" === typeof b2 && "" !== b2 || "number" === typeof b2) + return b2 = xh("" + b2, a2.mode, c2), b2.return = a2, b2; + if ("object" === typeof b2 && null !== b2) { + switch (b2.$$typeof) { + case va: + return c2 = yh(b2.type, b2.key, b2.props, null, a2.mode, c2), c2.ref = sh(a2, null, b2), c2.return = a2, c2; + case wa: + return b2 = zh(b2, a2.mode, c2), b2.return = a2, b2; + case Ha: + var d2 = b2._init; + return q(a2, d2(b2._payload), c2); + } + if (eb(b2) || Ka(b2)) + return b2 = Ah(b2, a2.mode, c2, null), b2.return = a2, b2; + th(a2, b2); + } + return null; + } + function r(a2, b2, c2, d2) { + var e2 = null !== b2 ? b2.key : null; + if ("string" === typeof c2 && "" !== c2 || "number" === typeof c2) + return null !== e2 ? null : h(a2, b2, "" + c2, d2); + if ("object" === typeof c2 && null !== c2) { + switch (c2.$$typeof) { + case va: + return c2.key === e2 ? k(a2, b2, c2, d2) : null; + case wa: + return c2.key === e2 ? l(a2, b2, c2, d2) : null; + case Ha: + return e2 = c2._init, r( + a2, + b2, + e2(c2._payload), + d2 + ); + } + if (eb(c2) || Ka(c2)) + return null !== e2 ? null : m(a2, b2, c2, d2, null); + th(a2, c2); + } + return null; + } + function y(a2, b2, c2, d2, e2) { + if ("string" === typeof d2 && "" !== d2 || "number" === typeof d2) + return a2 = a2.get(c2) || null, h(b2, a2, "" + d2, e2); + if ("object" === typeof d2 && null !== d2) { + switch (d2.$$typeof) { + case va: + return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, k(b2, a2, d2, e2); + case wa: + return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, l(b2, a2, d2, e2); + case Ha: + var f2 = d2._init; + return y(a2, b2, c2, f2(d2._payload), e2); + } + if (eb(d2) || Ka(d2)) + return a2 = a2.get(c2) || null, m(b2, a2, d2, e2, null); + th(b2, d2); + } + return null; + } + function n(e2, g2, h2, k2) { + for (var l2 = null, m2 = null, u = g2, w = g2 = 0, x = null; null !== u && w < h2.length; w++) { + u.index > w ? (x = u, u = null) : x = u.sibling; + var n2 = r(e2, u, h2[w], k2); + if (null === n2) { + null === u && (u = x); + break; + } + a && u && null === n2.alternate && b(e2, u); + g2 = f(n2, g2, w); + null === m2 ? l2 = n2 : m2.sibling = n2; + m2 = n2; + u = x; + } + if (w === h2.length) + return c(e2, u), I && tg(e2, w), l2; + if (null === u) { + for (; w < h2.length; w++) + u = q(e2, h2[w], k2), null !== u && (g2 = f(u, g2, w), null === m2 ? l2 = u : m2.sibling = u, m2 = u); + I && tg(e2, w); + return l2; + } + for (u = d(e2, u); w < h2.length; w++) + x = y(u, e2, w, h2[w], k2), null !== x && (a && null !== x.alternate && u.delete(null === x.key ? w : x.key), g2 = f(x, g2, w), null === m2 ? l2 = x : m2.sibling = x, m2 = x); + a && u.forEach(function(a2) { + return b(e2, a2); + }); + I && tg(e2, w); + return l2; + } + function t(e2, g2, h2, k2) { + var l2 = Ka(h2); + if ("function" !== typeof l2) + throw Error(p(150)); + h2 = l2.call(h2); + if (null == h2) + throw Error(p(151)); + for (var u = l2 = null, m2 = g2, w = g2 = 0, x = null, n2 = h2.next(); null !== m2 && !n2.done; w++, n2 = h2.next()) { + m2.index > w ? (x = m2, m2 = null) : x = m2.sibling; + var t2 = r(e2, m2, n2.value, k2); + if (null === t2) { + null === m2 && (m2 = x); + break; + } + a && m2 && null === t2.alternate && b(e2, m2); + g2 = f(t2, g2, w); + null === u ? l2 = t2 : u.sibling = t2; + u = t2; + m2 = x; + } + if (n2.done) + return c( + e2, + m2 + ), I && tg(e2, w), l2; + if (null === m2) { + for (; !n2.done; w++, n2 = h2.next()) + n2 = q(e2, n2.value, k2), null !== n2 && (g2 = f(n2, g2, w), null === u ? l2 = n2 : u.sibling = n2, u = n2); + I && tg(e2, w); + return l2; + } + for (m2 = d(e2, m2); !n2.done; w++, n2 = h2.next()) + n2 = y(m2, e2, w, n2.value, k2), null !== n2 && (a && null !== n2.alternate && m2.delete(null === n2.key ? w : n2.key), g2 = f(n2, g2, w), null === u ? l2 = n2 : u.sibling = n2, u = n2); + a && m2.forEach(function(a2) { + return b(e2, a2); + }); + I && tg(e2, w); + return l2; + } + function J(a2, d2, f2, h2) { + "object" === typeof f2 && null !== f2 && f2.type === ya && null === f2.key && (f2 = f2.props.children); + if ("object" === typeof f2 && null !== f2) { + switch (f2.$$typeof) { + case va: + a: { + for (var k2 = f2.key, l2 = d2; null !== l2; ) { + if (l2.key === k2) { + k2 = f2.type; + if (k2 === ya) { + if (7 === l2.tag) { + c(a2, l2.sibling); + d2 = e(l2, f2.props.children); + d2.return = a2; + a2 = d2; + break a; + } + } else if (l2.elementType === k2 || "object" === typeof k2 && null !== k2 && k2.$$typeof === Ha && uh(k2) === l2.type) { + c(a2, l2.sibling); + d2 = e(l2, f2.props); + d2.ref = sh(a2, l2, f2); + d2.return = a2; + a2 = d2; + break a; + } + c(a2, l2); + break; + } else + b(a2, l2); + l2 = l2.sibling; + } + f2.type === ya ? (d2 = Ah(f2.props.children, a2.mode, h2, f2.key), d2.return = a2, a2 = d2) : (h2 = yh(f2.type, f2.key, f2.props, null, a2.mode, h2), h2.ref = sh(a2, d2, f2), h2.return = a2, a2 = h2); + } + return g(a2); + case wa: + a: { + for (l2 = f2.key; null !== d2; ) { + if (d2.key === l2) + if (4 === d2.tag && d2.stateNode.containerInfo === f2.containerInfo && d2.stateNode.implementation === f2.implementation) { + c(a2, d2.sibling); + d2 = e(d2, f2.children || []); + d2.return = a2; + a2 = d2; + break a; + } else { + c(a2, d2); + break; + } + else + b(a2, d2); + d2 = d2.sibling; + } + d2 = zh(f2, a2.mode, h2); + d2.return = a2; + a2 = d2; + } + return g(a2); + case Ha: + return l2 = f2._init, J(a2, d2, l2(f2._payload), h2); + } + if (eb(f2)) + return n(a2, d2, f2, h2); + if (Ka(f2)) + return t(a2, d2, f2, h2); + th(a2, f2); + } + return "string" === typeof f2 && "" !== f2 || "number" === typeof f2 ? (f2 = "" + f2, null !== d2 && 6 === d2.tag ? (c(a2, d2.sibling), d2 = e(d2, f2), d2.return = a2, a2 = d2) : (c(a2, d2), d2 = xh(f2, a2.mode, h2), d2.return = a2, a2 = d2), g(a2)) : c(a2, d2); + } + return J; + } + var Bh = vh(true); + var Ch = vh(false); + var Dh = {}; + var Eh = Uf(Dh); + var Fh = Uf(Dh); + var Gh = Uf(Dh); + function Hh(a) { + if (a === Dh) + throw Error(p(174)); + return a; + } + function Ih(a, b) { + G(Gh, b); + G(Fh, a); + G(Eh, Dh); + a = b.nodeType; + switch (a) { + case 9: + case 11: + b = (b = b.documentElement) ? b.namespaceURI : lb(null, ""); + break; + default: + a = 8 === a ? b.parentNode : b, b = a.namespaceURI || null, a = a.tagName, b = lb(b, a); + } + E(Eh); + G(Eh, b); + } + function Jh() { + E(Eh); + E(Fh); + E(Gh); + } + function Kh(a) { + Hh(Gh.current); + var b = Hh(Eh.current); + var c = lb(b, a.type); + b !== c && (G(Fh, a), G(Eh, c)); + } + function Lh(a) { + Fh.current === a && (E(Eh), E(Fh)); + } + var M = Uf(0); + function Mh(a) { + for (var b = a; null !== b; ) { + if (13 === b.tag) { + var c = b.memoizedState; + if (null !== c && (c = c.dehydrated, null === c || "$?" === c.data || "$!" === c.data)) + return b; + } else if (19 === b.tag && void 0 !== b.memoizedProps.revealOrder) { + if (0 !== (b.flags & 128)) + return b; + } else if (null !== b.child) { + b.child.return = b; + b = b.child; + continue; + } + if (b === a) + break; + for (; null === b.sibling; ) { + if (null === b.return || b.return === a) + return null; + b = b.return; + } + b.sibling.return = b.return; + b = b.sibling; + } + return null; + } + var Nh = []; + function Oh() { + for (var a = 0; a < Nh.length; a++) + Nh[a]._workInProgressVersionPrimary = null; + Nh.length = 0; + } + var Ph = ua.ReactCurrentDispatcher; + var Qh = ua.ReactCurrentBatchConfig; + var Rh = 0; + var N = null; + var O = null; + var P = null; + var Sh = false; + var Th = false; + var Uh = 0; + var Vh = 0; + function Q() { + throw Error(p(321)); + } + function Wh(a, b) { + if (null === b) + return false; + for (var c = 0; c < b.length && c < a.length; c++) + if (!He(a[c], b[c])) + return false; + return true; + } + function Xh(a, b, c, d, e, f) { + Rh = f; + N = b; + b.memoizedState = null; + b.updateQueue = null; + b.lanes = 0; + Ph.current = null === a || null === a.memoizedState ? Yh : Zh; + a = c(d, e); + if (Th) { + f = 0; + do { + Th = false; + Uh = 0; + if (25 <= f) + throw Error(p(301)); + f += 1; + P = O = null; + b.updateQueue = null; + Ph.current = $h; + a = c(d, e); + } while (Th); + } + Ph.current = ai; + b = null !== O && null !== O.next; + Rh = 0; + P = O = N = null; + Sh = false; + if (b) + throw Error(p(300)); + return a; + } + function bi() { + var a = 0 !== Uh; + Uh = 0; + return a; + } + function ci() { + var a = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null }; + null === P ? N.memoizedState = P = a : P = P.next = a; + return P; + } + function di() { + if (null === O) { + var a = N.alternate; + a = null !== a ? a.memoizedState : null; + } else + a = O.next; + var b = null === P ? N.memoizedState : P.next; + if (null !== b) + P = b, O = a; + else { + if (null === a) + throw Error(p(310)); + O = a; + a = { memoizedState: O.memoizedState, baseState: O.baseState, baseQueue: O.baseQueue, queue: O.queue, next: null }; + null === P ? N.memoizedState = P = a : P = P.next = a; + } + return P; + } + function ei(a, b) { + return "function" === typeof b ? b(a) : b; + } + function fi(a) { + var b = di(), c = b.queue; + if (null === c) + throw Error(p(311)); + c.lastRenderedReducer = a; + var d = O, e = d.baseQueue, f = c.pending; + if (null !== f) { + if (null !== e) { + var g = e.next; + e.next = f.next; + f.next = g; + } + d.baseQueue = e = f; + c.pending = null; + } + if (null !== e) { + f = e.next; + d = d.baseState; + var h = g = null, k = null, l = f; + do { + var m = l.lane; + if ((Rh & m) === m) + null !== k && (k = k.next = { lane: 0, action: l.action, hasEagerState: l.hasEagerState, eagerState: l.eagerState, next: null }), d = l.hasEagerState ? l.eagerState : a(d, l.action); + else { + var q = { + lane: m, + action: l.action, + hasEagerState: l.hasEagerState, + eagerState: l.eagerState, + next: null + }; + null === k ? (h = k = q, g = d) : k = k.next = q; + N.lanes |= m; + hh |= m; + } + l = l.next; + } while (null !== l && l !== f); + null === k ? g = d : k.next = h; + He(d, b.memoizedState) || (Ug = true); + b.memoizedState = d; + b.baseState = g; + b.baseQueue = k; + c.lastRenderedState = d; + } + a = c.interleaved; + if (null !== a) { + e = a; + do + f = e.lane, N.lanes |= f, hh |= f, e = e.next; + while (e !== a); + } else + null === e && (c.lanes = 0); + return [b.memoizedState, c.dispatch]; + } + function gi(a) { + var b = di(), c = b.queue; + if (null === c) + throw Error(p(311)); + c.lastRenderedReducer = a; + var d = c.dispatch, e = c.pending, f = b.memoizedState; + if (null !== e) { + c.pending = null; + var g = e = e.next; + do + f = a(f, g.action), g = g.next; + while (g !== e); + He(f, b.memoizedState) || (Ug = true); + b.memoizedState = f; + null === b.baseQueue && (b.baseState = f); + c.lastRenderedState = f; + } + return [f, d]; + } + function hi() { + } + function ii(a, b) { + var c = N, d = di(), e = b(), f = !He(d.memoizedState, e); + f && (d.memoizedState = e, Ug = true); + d = d.queue; + ji(ki.bind(null, c, d, a), [a]); + if (d.getSnapshot !== b || f || null !== P && P.memoizedState.tag & 1) { + c.flags |= 2048; + li(9, mi.bind(null, c, d, e, b), void 0, null); + if (null === R) + throw Error(p(349)); + 0 !== (Rh & 30) || ni(c, b, e); + } + return e; + } + function ni(a, b, c) { + a.flags |= 16384; + a = { getSnapshot: b, value: c }; + b = N.updateQueue; + null === b ? (b = { lastEffect: null, stores: null }, N.updateQueue = b, b.stores = [a]) : (c = b.stores, null === c ? b.stores = [a] : c.push(a)); + } + function mi(a, b, c, d) { + b.value = c; + b.getSnapshot = d; + oi(b) && pi(a); + } + function ki(a, b, c) { + return c(function() { + oi(b) && pi(a); + }); + } + function oi(a) { + var b = a.getSnapshot; + a = a.value; + try { + var c = b(); + return !He(a, c); + } catch (d) { + return true; + } + } + function pi(a) { + var b = Zg(a, 1); + null !== b && mh(b, a, 1, -1); + } + function qi(a) { + var b = ci(); + "function" === typeof a && (a = a()); + b.memoizedState = b.baseState = a; + a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: ei, lastRenderedState: a }; + b.queue = a; + a = a.dispatch = ri.bind(null, N, a); + return [b.memoizedState, a]; + } + function li(a, b, c, d) { + a = { tag: a, create: b, destroy: c, deps: d, next: null }; + b = N.updateQueue; + null === b ? (b = { lastEffect: null, stores: null }, N.updateQueue = b, b.lastEffect = a.next = a) : (c = b.lastEffect, null === c ? b.lastEffect = a.next = a : (d = c.next, c.next = a, a.next = d, b.lastEffect = a)); + return a; + } + function si() { + return di().memoizedState; + } + function ti(a, b, c, d) { + var e = ci(); + N.flags |= a; + e.memoizedState = li(1 | b, c, void 0, void 0 === d ? null : d); + } + function ui(a, b, c, d) { + var e = di(); + d = void 0 === d ? null : d; + var f = void 0; + if (null !== O) { + var g = O.memoizedState; + f = g.destroy; + if (null !== d && Wh(d, g.deps)) { + e.memoizedState = li(b, c, f, d); + return; + } + } + N.flags |= a; + e.memoizedState = li(1 | b, c, f, d); + } + function vi(a, b) { + return ti(8390656, 8, a, b); + } + function ji(a, b) { + return ui(2048, 8, a, b); + } + function wi(a, b) { + return ui(4, 2, a, b); + } + function xi(a, b) { + return ui(4, 4, a, b); + } + function yi(a, b) { + if ("function" === typeof b) + return a = a(), b(a), function() { + b(null); + }; + if (null !== b && void 0 !== b) + return a = a(), b.current = a, function() { + b.current = null; + }; + } + function zi(a, b, c) { + c = null !== c && void 0 !== c ? c.concat([a]) : null; + return ui(4, 4, yi.bind(null, b, a), c); + } + function Ai() { + } + function Bi(a, b) { + var c = di(); + b = void 0 === b ? null : b; + var d = c.memoizedState; + if (null !== d && null !== b && Wh(b, d[1])) + return d[0]; + c.memoizedState = [a, b]; + return a; + } + function Ci(a, b) { + var c = di(); + b = void 0 === b ? null : b; + var d = c.memoizedState; + if (null !== d && null !== b && Wh(b, d[1])) + return d[0]; + a = a(); + c.memoizedState = [a, b]; + return a; + } + function Di(a, b, c) { + if (0 === (Rh & 21)) + return a.baseState && (a.baseState = false, Ug = true), a.memoizedState = c; + He(c, b) || (c = yc(), N.lanes |= c, hh |= c, a.baseState = true); + return b; + } + function Ei(a, b) { + var c = C; + C = 0 !== c && 4 > c ? c : 4; + a(true); + var d = Qh.transition; + Qh.transition = {}; + try { + a(false), b(); + } finally { + C = c, Qh.transition = d; + } + } + function Fi() { + return di().memoizedState; + } + function Gi(a, b, c) { + var d = lh(a); + c = { lane: d, action: c, hasEagerState: false, eagerState: null, next: null }; + if (Hi(a)) + Ii(b, c); + else if (c = Yg(a, b, c, d), null !== c) { + var e = L(); + mh(c, a, d, e); + Ji(c, b, d); + } + } + function ri(a, b, c) { + var d = lh(a), e = { lane: d, action: c, hasEagerState: false, eagerState: null, next: null }; + if (Hi(a)) + Ii(b, e); + else { + var f = a.alternate; + if (0 === a.lanes && (null === f || 0 === f.lanes) && (f = b.lastRenderedReducer, null !== f)) + try { + var g = b.lastRenderedState, h = f(g, c); + e.hasEagerState = true; + e.eagerState = h; + if (He(h, g)) { + var k = b.interleaved; + null === k ? (e.next = e, Xg(b)) : (e.next = k.next, k.next = e); + b.interleaved = e; + return; + } + } catch (l) { + } finally { + } + c = Yg(a, b, e, d); + null !== c && (e = L(), mh(c, a, d, e), Ji(c, b, d)); + } + } + function Hi(a) { + var b = a.alternate; + return a === N || null !== b && b === N; + } + function Ii(a, b) { + Th = Sh = true; + var c = a.pending; + null === c ? b.next = b : (b.next = c.next, c.next = b); + a.pending = b; + } + function Ji(a, b, c) { + if (0 !== (c & 4194240)) { + var d = b.lanes; + d &= a.pendingLanes; + c |= d; + b.lanes = c; + Cc(a, c); + } + } + var ai = { readContext: Vg, useCallback: Q, useContext: Q, useEffect: Q, useImperativeHandle: Q, useInsertionEffect: Q, useLayoutEffect: Q, useMemo: Q, useReducer: Q, useRef: Q, useState: Q, useDebugValue: Q, useDeferredValue: Q, useTransition: Q, useMutableSource: Q, useSyncExternalStore: Q, useId: Q, unstable_isNewReconciler: false }; + var Yh = { readContext: Vg, useCallback: function(a, b) { + ci().memoizedState = [a, void 0 === b ? null : b]; + return a; + }, useContext: Vg, useEffect: vi, useImperativeHandle: function(a, b, c) { + c = null !== c && void 0 !== c ? c.concat([a]) : null; + return ti( + 4194308, + 4, + yi.bind(null, b, a), + c + ); + }, useLayoutEffect: function(a, b) { + return ti(4194308, 4, a, b); + }, useInsertionEffect: function(a, b) { + return ti(4, 2, a, b); + }, useMemo: function(a, b) { + var c = ci(); + b = void 0 === b ? null : b; + a = a(); + c.memoizedState = [a, b]; + return a; + }, useReducer: function(a, b, c) { + var d = ci(); + b = void 0 !== c ? c(b) : b; + d.memoizedState = d.baseState = b; + a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a, lastRenderedState: b }; + d.queue = a; + a = a.dispatch = Gi.bind(null, N, a); + return [d.memoizedState, a]; + }, useRef: function(a) { + var b = ci(); + a = { current: a }; + return b.memoizedState = a; + }, useState: qi, useDebugValue: Ai, useDeferredValue: function(a) { + return ci().memoizedState = a; + }, useTransition: function() { + var a = qi(false), b = a[0]; + a = Ei.bind(null, a[1]); + ci().memoizedState = a; + return [b, a]; + }, useMutableSource: function() { + }, useSyncExternalStore: function(a, b, c) { + var d = N, e = ci(); + if (I) { + if (void 0 === c) + throw Error(p(407)); + c = c(); + } else { + c = b(); + if (null === R) + throw Error(p(349)); + 0 !== (Rh & 30) || ni(d, b, c); + } + e.memoizedState = c; + var f = { value: c, getSnapshot: b }; + e.queue = f; + vi(ki.bind( + null, + d, + f, + a + ), [a]); + d.flags |= 2048; + li(9, mi.bind(null, d, f, c, b), void 0, null); + return c; + }, useId: function() { + var a = ci(), b = R.identifierPrefix; + if (I) { + var c = sg; + var d = rg; + c = (d & ~(1 << 32 - oc(d) - 1)).toString(32) + c; + b = ":" + b + "R" + c; + c = Uh++; + 0 < c && (b += "H" + c.toString(32)); + b += ":"; + } else + c = Vh++, b = ":" + b + "r" + c.toString(32) + ":"; + return a.memoizedState = b; + }, unstable_isNewReconciler: false }; + var Zh = { + readContext: Vg, + useCallback: Bi, + useContext: Vg, + useEffect: ji, + useImperativeHandle: zi, + useInsertionEffect: wi, + useLayoutEffect: xi, + useMemo: Ci, + useReducer: fi, + useRef: si, + useState: function() { + return fi(ei); + }, + useDebugValue: Ai, + useDeferredValue: function(a) { + var b = di(); + return Di(b, O.memoizedState, a); + }, + useTransition: function() { + var a = fi(ei)[0], b = di().memoizedState; + return [a, b]; + }, + useMutableSource: hi, + useSyncExternalStore: ii, + useId: Fi, + unstable_isNewReconciler: false + }; + var $h = { readContext: Vg, useCallback: Bi, useContext: Vg, useEffect: ji, useImperativeHandle: zi, useInsertionEffect: wi, useLayoutEffect: xi, useMemo: Ci, useReducer: gi, useRef: si, useState: function() { + return gi(ei); + }, useDebugValue: Ai, useDeferredValue: function(a) { + var b = di(); + return null === O ? b.memoizedState = a : Di(b, O.memoizedState, a); + }, useTransition: function() { + var a = gi(ei)[0], b = di().memoizedState; + return [a, b]; + }, useMutableSource: hi, useSyncExternalStore: ii, useId: Fi, unstable_isNewReconciler: false }; + function Ki(a, b) { + try { + var c = "", d = b; + do + c += Pa(d), d = d.return; + while (d); + var e = c; + } catch (f) { + e = "\nError generating stack: " + f.message + "\n" + f.stack; + } + return { value: a, source: b, stack: e, digest: null }; + } + function Li(a, b, c) { + return { value: a, source: null, stack: null != c ? c : null, digest: null != b ? b : null }; + } + function Mi(a, b) { + try { + console.error(b.value); + } catch (c) { + setTimeout(function() { + throw c; + }); + } + } + var Ni = "function" === typeof WeakMap ? WeakMap : Map; + function Oi(a, b, c) { + c = ch(-1, c); + c.tag = 3; + c.payload = { element: null }; + var d = b.value; + c.callback = function() { + Pi || (Pi = true, Qi = d); + Mi(a, b); + }; + return c; + } + function Ri(a, b, c) { + c = ch(-1, c); + c.tag = 3; + var d = a.type.getDerivedStateFromError; + if ("function" === typeof d) { + var e = b.value; + c.payload = function() { + return d(e); + }; + c.callback = function() { + Mi(a, b); + }; + } + var f = a.stateNode; + null !== f && "function" === typeof f.componentDidCatch && (c.callback = function() { + Mi(a, b); + "function" !== typeof d && (null === Si ? Si = /* @__PURE__ */ new Set([this]) : Si.add(this)); + var c2 = b.stack; + this.componentDidCatch(b.value, { componentStack: null !== c2 ? c2 : "" }); + }); + return c; + } + function Ti(a, b, c) { + var d = a.pingCache; + if (null === d) { + d = a.pingCache = new Ni(); + var e = /* @__PURE__ */ new Set(); + d.set(b, e); + } else + e = d.get(b), void 0 === e && (e = /* @__PURE__ */ new Set(), d.set(b, e)); + e.has(c) || (e.add(c), a = Ui.bind(null, a, b, c), b.then(a, a)); + } + function Vi(a) { + do { + var b; + if (b = 13 === a.tag) + b = a.memoizedState, b = null !== b ? null !== b.dehydrated ? true : false : true; + if (b) + return a; + a = a.return; + } while (null !== a); + return null; + } + function Wi(a, b, c, d, e) { + if (0 === (a.mode & 1)) + return a === b ? a.flags |= 65536 : (a.flags |= 128, c.flags |= 131072, c.flags &= -52805, 1 === c.tag && (null === c.alternate ? c.tag = 17 : (b = ch(-1, 1), b.tag = 2, dh(c, b, 1))), c.lanes |= 1), a; + a.flags |= 65536; + a.lanes = e; + return a; + } + var Xi = ua.ReactCurrentOwner; + var Ug = false; + function Yi(a, b, c, d) { + b.child = null === a ? Ch(b, null, c, d) : Bh(b, a.child, c, d); + } + function Zi(a, b, c, d, e) { + c = c.render; + var f = b.ref; + Tg(b, e); + d = Xh(a, b, c, d, f, e); + c = bi(); + if (null !== a && !Ug) + return b.updateQueue = a.updateQueue, b.flags &= -2053, a.lanes &= ~e, $i(a, b, e); + I && c && vg(b); + b.flags |= 1; + Yi(a, b, d, e); + return b.child; + } + function aj(a, b, c, d, e) { + if (null === a) { + var f = c.type; + if ("function" === typeof f && !bj(f) && void 0 === f.defaultProps && null === c.compare && void 0 === c.defaultProps) + return b.tag = 15, b.type = f, cj(a, b, f, d, e); + a = yh(c.type, null, d, b, b.mode, e); + a.ref = b.ref; + a.return = b; + return b.child = a; + } + f = a.child; + if (0 === (a.lanes & e)) { + var g = f.memoizedProps; + c = c.compare; + c = null !== c ? c : Ie; + if (c(g, d) && a.ref === b.ref) + return $i(a, b, e); + } + b.flags |= 1; + a = wh(f, d); + a.ref = b.ref; + a.return = b; + return b.child = a; + } + function cj(a, b, c, d, e) { + if (null !== a) { + var f = a.memoizedProps; + if (Ie(f, d) && a.ref === b.ref) + if (Ug = false, b.pendingProps = d = f, 0 !== (a.lanes & e)) + 0 !== (a.flags & 131072) && (Ug = true); + else + return b.lanes = a.lanes, $i(a, b, e); + } + return dj(a, b, c, d, e); + } + function ej(a, b, c) { + var d = b.pendingProps, e = d.children, f = null !== a ? a.memoizedState : null; + if ("hidden" === d.mode) + if (0 === (b.mode & 1)) + b.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G(fj, gj), gj |= c; + else { + if (0 === (c & 1073741824)) + return a = null !== f ? f.baseLanes | c : c, b.lanes = b.childLanes = 1073741824, b.memoizedState = { baseLanes: a, cachePool: null, transitions: null }, b.updateQueue = null, G(fj, gj), gj |= a, null; + b.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }; + d = null !== f ? f.baseLanes : c; + G(fj, gj); + gj |= d; + } + else + null !== f ? (d = f.baseLanes | c, b.memoizedState = null) : d = c, G(fj, gj), gj |= d; + Yi(a, b, e, c); + return b.child; + } + function hj(a, b) { + var c = b.ref; + if (null === a && null !== c || null !== a && a.ref !== c) + b.flags |= 512, b.flags |= 2097152; + } + function dj(a, b, c, d, e) { + var f = Zf(c) ? Xf : H.current; + f = Yf(b, f); + Tg(b, e); + c = Xh(a, b, c, d, f, e); + d = bi(); + if (null !== a && !Ug) + return b.updateQueue = a.updateQueue, b.flags &= -2053, a.lanes &= ~e, $i(a, b, e); + I && d && vg(b); + b.flags |= 1; + Yi(a, b, c, e); + return b.child; + } + function ij(a, b, c, d, e) { + if (Zf(c)) { + var f = true; + cg(b); + } else + f = false; + Tg(b, e); + if (null === b.stateNode) + jj(a, b), ph(b, c, d), rh(b, c, d, e), d = true; + else if (null === a) { + var g = b.stateNode, h = b.memoizedProps; + g.props = h; + var k = g.context, l = c.contextType; + "object" === typeof l && null !== l ? l = Vg(l) : (l = Zf(c) ? Xf : H.current, l = Yf(b, l)); + var m = c.getDerivedStateFromProps, q = "function" === typeof m || "function" === typeof g.getSnapshotBeforeUpdate; + q || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== d || k !== l) && qh(b, g, d, l); + $g = false; + var r = b.memoizedState; + g.state = r; + gh(b, d, g, e); + k = b.memoizedState; + h !== d || r !== k || Wf.current || $g ? ("function" === typeof m && (kh(b, c, m, d), k = b.memoizedState), (h = $g || oh(b, c, h, d, r, k, l)) ? (q || "function" !== typeof g.UNSAFE_componentWillMount && "function" !== typeof g.componentWillMount || ("function" === typeof g.componentWillMount && g.componentWillMount(), "function" === typeof g.UNSAFE_componentWillMount && g.UNSAFE_componentWillMount()), "function" === typeof g.componentDidMount && (b.flags |= 4194308)) : ("function" === typeof g.componentDidMount && (b.flags |= 4194308), b.memoizedProps = d, b.memoizedState = k), g.props = d, g.state = k, g.context = l, d = h) : ("function" === typeof g.componentDidMount && (b.flags |= 4194308), d = false); + } else { + g = b.stateNode; + bh(a, b); + h = b.memoizedProps; + l = b.type === b.elementType ? h : Lg(b.type, h); + g.props = l; + q = b.pendingProps; + r = g.context; + k = c.contextType; + "object" === typeof k && null !== k ? k = Vg(k) : (k = Zf(c) ? Xf : H.current, k = Yf(b, k)); + var y = c.getDerivedStateFromProps; + (m = "function" === typeof y || "function" === typeof g.getSnapshotBeforeUpdate) || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== q || r !== k) && qh(b, g, d, k); + $g = false; + r = b.memoizedState; + g.state = r; + gh(b, d, g, e); + var n = b.memoizedState; + h !== q || r !== n || Wf.current || $g ? ("function" === typeof y && (kh(b, c, y, d), n = b.memoizedState), (l = $g || oh(b, c, l, d, r, n, k) || false) ? (m || "function" !== typeof g.UNSAFE_componentWillUpdate && "function" !== typeof g.componentWillUpdate || ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(d, n, k), "function" === typeof g.UNSAFE_componentWillUpdate && g.UNSAFE_componentWillUpdate(d, n, k)), "function" === typeof g.componentDidUpdate && (b.flags |= 4), "function" === typeof g.getSnapshotBeforeUpdate && (b.flags |= 1024)) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 1024), b.memoizedProps = d, b.memoizedState = n), g.props = d, g.state = n, g.context = k, d = l) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 1024), d = false); + } + return kj(a, b, c, d, f, e); + } + function kj(a, b, c, d, e, f) { + hj(a, b); + var g = 0 !== (b.flags & 128); + if (!d && !g) + return e && dg(b, c, false), $i(a, b, f); + d = b.stateNode; + Xi.current = b; + var h = g && "function" !== typeof c.getDerivedStateFromError ? null : d.render(); + b.flags |= 1; + null !== a && g ? (b.child = Bh(b, a.child, null, f), b.child = Bh(b, null, h, f)) : Yi(a, b, h, f); + b.memoizedState = d.state; + e && dg(b, c, true); + return b.child; + } + function lj(a) { + var b = a.stateNode; + b.pendingContext ? ag(a, b.pendingContext, b.pendingContext !== b.context) : b.context && ag(a, b.context, false); + Ih(a, b.containerInfo); + } + function mj(a, b, c, d, e) { + Ig(); + Jg(e); + b.flags |= 256; + Yi(a, b, c, d); + return b.child; + } + var nj = { dehydrated: null, treeContext: null, retryLane: 0 }; + function oj(a) { + return { baseLanes: a, cachePool: null, transitions: null }; + } + function pj(a, b, c) { + var d = b.pendingProps, e = M.current, f = false, g = 0 !== (b.flags & 128), h; + (h = g) || (h = null !== a && null === a.memoizedState ? false : 0 !== (e & 2)); + if (h) + f = true, b.flags &= -129; + else if (null === a || null !== a.memoizedState) + e |= 1; + G(M, e & 1); + if (null === a) { + Eg(b); + a = b.memoizedState; + if (null !== a && (a = a.dehydrated, null !== a)) + return 0 === (b.mode & 1) ? b.lanes = 1 : "$!" === a.data ? b.lanes = 8 : b.lanes = 1073741824, null; + g = d.children; + a = d.fallback; + return f ? (d = b.mode, f = b.child, g = { mode: "hidden", children: g }, 0 === (d & 1) && null !== f ? (f.childLanes = 0, f.pendingProps = g) : f = qj(g, d, 0, null), a = Ah(a, d, c, null), f.return = b, a.return = b, f.sibling = a, b.child = f, b.child.memoizedState = oj(c), b.memoizedState = nj, a) : rj(b, g); + } + e = a.memoizedState; + if (null !== e && (h = e.dehydrated, null !== h)) + return sj(a, b, g, d, h, e, c); + if (f) { + f = d.fallback; + g = b.mode; + e = a.child; + h = e.sibling; + var k = { mode: "hidden", children: d.children }; + 0 === (g & 1) && b.child !== e ? (d = b.child, d.childLanes = 0, d.pendingProps = k, b.deletions = null) : (d = wh(e, k), d.subtreeFlags = e.subtreeFlags & 14680064); + null !== h ? f = wh(h, f) : (f = Ah(f, g, c, null), f.flags |= 2); + f.return = b; + d.return = b; + d.sibling = f; + b.child = d; + d = f; + f = b.child; + g = a.child.memoizedState; + g = null === g ? oj(c) : { baseLanes: g.baseLanes | c, cachePool: null, transitions: g.transitions }; + f.memoizedState = g; + f.childLanes = a.childLanes & ~c; + b.memoizedState = nj; + return d; + } + f = a.child; + a = f.sibling; + d = wh(f, { mode: "visible", children: d.children }); + 0 === (b.mode & 1) && (d.lanes = c); + d.return = b; + d.sibling = null; + null !== a && (c = b.deletions, null === c ? (b.deletions = [a], b.flags |= 16) : c.push(a)); + b.child = d; + b.memoizedState = null; + return d; + } + function rj(a, b) { + b = qj({ mode: "visible", children: b }, a.mode, 0, null); + b.return = a; + return a.child = b; + } + function tj(a, b, c, d) { + null !== d && Jg(d); + Bh(b, a.child, null, c); + a = rj(b, b.pendingProps.children); + a.flags |= 2; + b.memoizedState = null; + return a; + } + function sj(a, b, c, d, e, f, g) { + if (c) { + if (b.flags & 256) + return b.flags &= -257, d = Li(Error(p(422))), tj(a, b, g, d); + if (null !== b.memoizedState) + return b.child = a.child, b.flags |= 128, null; + f = d.fallback; + e = b.mode; + d = qj({ mode: "visible", children: d.children }, e, 0, null); + f = Ah(f, e, g, null); + f.flags |= 2; + d.return = b; + f.return = b; + d.sibling = f; + b.child = d; + 0 !== (b.mode & 1) && Bh(b, a.child, null, g); + b.child.memoizedState = oj(g); + b.memoizedState = nj; + return f; + } + if (0 === (b.mode & 1)) + return tj(a, b, g, null); + if ("$!" === e.data) { + d = e.nextSibling && e.nextSibling.dataset; + if (d) + var h = d.dgst; + d = h; + f = Error(p(419)); + d = Li(f, d, void 0); + return tj(a, b, g, d); + } + h = 0 !== (g & a.childLanes); + if (Ug || h) { + d = R; + if (null !== d) { + switch (g & -g) { + case 4: + e = 2; + break; + case 16: + e = 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: + e = 32; + break; + case 536870912: + e = 268435456; + break; + default: + e = 0; + } + e = 0 !== (e & (d.suspendedLanes | g)) ? 0 : e; + 0 !== e && e !== f.retryLane && (f.retryLane = e, Zg(a, e), mh(d, a, e, -1)); + } + uj(); + d = Li(Error(p(421))); + return tj(a, b, g, d); + } + if ("$?" === e.data) + return b.flags |= 128, b.child = a.child, b = vj.bind(null, a), e._reactRetry = b, null; + a = f.treeContext; + yg = Lf(e.nextSibling); + xg = b; + I = true; + zg = null; + null !== a && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a.id, sg = a.overflow, qg = b); + b = rj(b, d.children); + b.flags |= 4096; + return b; + } + function wj(a, b, c) { + a.lanes |= b; + var d = a.alternate; + null !== d && (d.lanes |= b); + Sg(a.return, b, c); + } + function xj(a, b, c, d, e) { + var f = a.memoizedState; + null === f ? a.memoizedState = { isBackwards: b, rendering: null, renderingStartTime: 0, last: d, tail: c, tailMode: e } : (f.isBackwards = b, f.rendering = null, f.renderingStartTime = 0, f.last = d, f.tail = c, f.tailMode = e); + } + function yj(a, b, c) { + var d = b.pendingProps, e = d.revealOrder, f = d.tail; + Yi(a, b, d.children, c); + d = M.current; + if (0 !== (d & 2)) + d = d & 1 | 2, b.flags |= 128; + else { + if (null !== a && 0 !== (a.flags & 128)) + a: + for (a = b.child; null !== a; ) { + if (13 === a.tag) + null !== a.memoizedState && wj(a, c, b); + else if (19 === a.tag) + wj(a, c, b); + else if (null !== a.child) { + a.child.return = a; + a = a.child; + continue; + } + if (a === b) + break a; + for (; null === a.sibling; ) { + if (null === a.return || a.return === b) + break a; + a = a.return; + } + a.sibling.return = a.return; + a = a.sibling; + } + d &= 1; + } + G(M, d); + if (0 === (b.mode & 1)) + b.memoizedState = null; + else + switch (e) { + case "forwards": + c = b.child; + for (e = null; null !== c; ) + a = c.alternate, null !== a && null === Mh(a) && (e = c), c = c.sibling; + c = e; + null === c ? (e = b.child, b.child = null) : (e = c.sibling, c.sibling = null); + xj(b, false, e, c, f); + break; + case "backwards": + c = null; + e = b.child; + for (b.child = null; null !== e; ) { + a = e.alternate; + if (null !== a && null === Mh(a)) { + b.child = e; + break; + } + a = e.sibling; + e.sibling = c; + c = e; + e = a; + } + xj(b, true, c, null, f); + break; + case "together": + xj(b, false, null, null, void 0); + break; + default: + b.memoizedState = null; + } + return b.child; + } + function jj(a, b) { + 0 === (b.mode & 1) && null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2); + } + function $i(a, b, c) { + null !== a && (b.dependencies = a.dependencies); + hh |= b.lanes; + if (0 === (c & b.childLanes)) + return null; + if (null !== a && b.child !== a.child) + throw Error(p(153)); + if (null !== b.child) { + a = b.child; + c = wh(a, a.pendingProps); + b.child = c; + for (c.return = b; null !== a.sibling; ) + a = a.sibling, c = c.sibling = wh(a, a.pendingProps), c.return = b; + c.sibling = null; + } + return b.child; + } + function zj(a, b, c) { + switch (b.tag) { + case 3: + lj(b); + Ig(); + break; + case 5: + Kh(b); + break; + case 1: + Zf(b.type) && cg(b); + break; + case 4: + Ih(b, b.stateNode.containerInfo); + break; + case 10: + var d = b.type._context, e = b.memoizedProps.value; + G(Mg, d._currentValue); + d._currentValue = e; + break; + case 13: + d = b.memoizedState; + if (null !== d) { + if (null !== d.dehydrated) + return G(M, M.current & 1), b.flags |= 128, null; + if (0 !== (c & b.child.childLanes)) + return pj(a, b, c); + G(M, M.current & 1); + a = $i(a, b, c); + return null !== a ? a.sibling : null; + } + G(M, M.current & 1); + break; + case 19: + d = 0 !== (c & b.childLanes); + if (0 !== (a.flags & 128)) { + if (d) + return yj(a, b, c); + b.flags |= 128; + } + e = b.memoizedState; + null !== e && (e.rendering = null, e.tail = null, e.lastEffect = null); + G(M, M.current); + if (d) + break; + else + return null; + case 22: + case 23: + return b.lanes = 0, ej(a, b, c); + } + return $i(a, b, c); + } + var Aj; + var Bj; + var Cj; + var Dj; + Aj = function(a, b) { + for (var c = b.child; null !== c; ) { + if (5 === c.tag || 6 === c.tag) + a.appendChild(c.stateNode); + else if (4 !== c.tag && null !== c.child) { + c.child.return = c; + c = c.child; + continue; + } + if (c === b) + break; + for (; null === c.sibling; ) { + if (null === c.return || c.return === b) + return; + c = c.return; + } + c.sibling.return = c.return; + c = c.sibling; + } + }; + Bj = function() { + }; + Cj = function(a, b, c, d) { + var e = a.memoizedProps; + if (e !== d) { + a = b.stateNode; + Hh(Eh.current); + var f = null; + switch (c) { + case "input": + e = Ya(a, e); + d = Ya(a, d); + f = []; + break; + case "select": + e = A({}, e, { value: void 0 }); + d = A({}, d, { value: void 0 }); + f = []; + break; + case "textarea": + e = gb(a, e); + d = gb(a, d); + f = []; + break; + default: + "function" !== typeof e.onClick && "function" === typeof d.onClick && (a.onclick = Bf); + } + ub(c, d); + var g; + c = null; + for (l in e) + if (!d.hasOwnProperty(l) && e.hasOwnProperty(l) && null != e[l]) + if ("style" === l) { + var h = e[l]; + for (g in h) + h.hasOwnProperty(g) && (c || (c = {}), c[g] = ""); + } else + "dangerouslySetInnerHTML" !== l && "children" !== l && "suppressContentEditableWarning" !== l && "suppressHydrationWarning" !== l && "autoFocus" !== l && (ea.hasOwnProperty(l) ? f || (f = []) : (f = f || []).push(l, null)); + for (l in d) { + var k = d[l]; + h = null != e ? e[l] : void 0; + if (d.hasOwnProperty(l) && k !== h && (null != k || null != h)) + if ("style" === l) + if (h) { + for (g in h) + !h.hasOwnProperty(g) || k && k.hasOwnProperty(g) || (c || (c = {}), c[g] = ""); + for (g in k) + k.hasOwnProperty(g) && h[g] !== k[g] && (c || (c = {}), c[g] = k[g]); + } else + c || (f || (f = []), f.push( + l, + c + )), c = k; + else + "dangerouslySetInnerHTML" === l ? (k = k ? k.__html : void 0, h = h ? h.__html : void 0, null != k && h !== k && (f = f || []).push(l, k)) : "children" === l ? "string" !== typeof k && "number" !== typeof k || (f = f || []).push(l, "" + k) : "suppressContentEditableWarning" !== l && "suppressHydrationWarning" !== l && (ea.hasOwnProperty(l) ? (null != k && "onScroll" === l && D("scroll", a), f || h === k || (f = [])) : (f = f || []).push(l, k)); + } + c && (f = f || []).push("style", c); + var l = f; + if (b.updateQueue = l) + b.flags |= 4; + } + }; + Dj = function(a, b, c, d) { + c !== d && (b.flags |= 4); + }; + function Ej(a, b) { + if (!I) + switch (a.tailMode) { + case "hidden": + b = a.tail; + for (var c = null; null !== b; ) + null !== b.alternate && (c = b), b = b.sibling; + null === c ? a.tail = null : c.sibling = null; + break; + case "collapsed": + c = a.tail; + for (var d = null; null !== c; ) + null !== c.alternate && (d = c), c = c.sibling; + null === d ? b || null === a.tail ? a.tail = null : a.tail.sibling = null : d.sibling = null; + } + } + function S(a) { + var b = null !== a.alternate && a.alternate.child === a.child, c = 0, d = 0; + if (b) + for (var e = a.child; null !== e; ) + c |= e.lanes | e.childLanes, d |= e.subtreeFlags & 14680064, d |= e.flags & 14680064, e.return = a, e = e.sibling; + else + for (e = a.child; null !== e; ) + c |= e.lanes | e.childLanes, d |= e.subtreeFlags, d |= e.flags, e.return = a, e = e.sibling; + a.subtreeFlags |= d; + a.childLanes = c; + return b; + } + function Fj(a, b, c) { + var d = b.pendingProps; + wg(b); + switch (b.tag) { + case 2: + case 16: + case 15: + case 0: + case 11: + case 7: + case 8: + case 12: + case 9: + case 14: + return S(b), null; + case 1: + return Zf(b.type) && $f(), S(b), null; + case 3: + d = b.stateNode; + Jh(); + E(Wf); + E(H); + Oh(); + d.pendingContext && (d.context = d.pendingContext, d.pendingContext = null); + if (null === a || null === a.child) + Gg(b) ? b.flags |= 4 : null === a || a.memoizedState.isDehydrated && 0 === (b.flags & 256) || (b.flags |= 1024, null !== zg && (Gj(zg), zg = null)); + Bj(a, b); + S(b); + return null; + case 5: + Lh(b); + var e = Hh(Gh.current); + c = b.type; + if (null !== a && null != b.stateNode) + Cj(a, b, c, d, e), a.ref !== b.ref && (b.flags |= 512, b.flags |= 2097152); + else { + if (!d) { + if (null === b.stateNode) + throw Error(p(166)); + S(b); + return null; + } + a = Hh(Eh.current); + if (Gg(b)) { + d = b.stateNode; + c = b.type; + var f = b.memoizedProps; + d[Of] = b; + d[Pf] = f; + a = 0 !== (b.mode & 1); + switch (c) { + case "dialog": + D("cancel", d); + D("close", d); + break; + case "iframe": + case "object": + case "embed": + D("load", d); + break; + case "video": + case "audio": + for (e = 0; e < lf.length; e++) + D(lf[e], d); + break; + case "source": + D("error", d); + break; + case "img": + case "image": + case "link": + D( + "error", + d + ); + D("load", d); + break; + case "details": + D("toggle", d); + break; + case "input": + Za(d, f); + D("invalid", d); + break; + case "select": + d._wrapperState = { wasMultiple: !!f.multiple }; + D("invalid", d); + break; + case "textarea": + hb(d, f), D("invalid", d); + } + ub(c, f); + e = null; + for (var g in f) + if (f.hasOwnProperty(g)) { + var h = f[g]; + "children" === g ? "string" === typeof h ? d.textContent !== h && (true !== f.suppressHydrationWarning && Af(d.textContent, h, a), e = ["children", h]) : "number" === typeof h && d.textContent !== "" + h && (true !== f.suppressHydrationWarning && Af( + d.textContent, + h, + a + ), e = ["children", "" + h]) : ea.hasOwnProperty(g) && null != h && "onScroll" === g && D("scroll", d); + } + switch (c) { + case "input": + Va(d); + db(d, f, true); + break; + case "textarea": + Va(d); + jb(d); + break; + case "select": + case "option": + break; + default: + "function" === typeof f.onClick && (d.onclick = Bf); + } + d = e; + b.updateQueue = d; + null !== d && (b.flags |= 4); + } else { + g = 9 === e.nodeType ? e : e.ownerDocument; + "http://www.w3.org/1999/xhtml" === a && (a = kb(c)); + "http://www.w3.org/1999/xhtml" === a ? "script" === c ? (a = g.createElement("div"), a.innerHTML = "", a = a.removeChild(a.firstChild)) : "string" === typeof d.is ? a = g.createElement(c, { is: d.is }) : (a = g.createElement(c), "select" === c && (g = a, d.multiple ? g.multiple = true : d.size && (g.size = d.size))) : a = g.createElementNS(a, c); + a[Of] = b; + a[Pf] = d; + Aj(a, b, false, false); + b.stateNode = a; + a: { + g = vb(c, d); + switch (c) { + case "dialog": + D("cancel", a); + D("close", a); + e = d; + break; + case "iframe": + case "object": + case "embed": + D("load", a); + e = d; + break; + case "video": + case "audio": + for (e = 0; e < lf.length; e++) + D(lf[e], a); + e = d; + break; + case "source": + D("error", a); + e = d; + break; + case "img": + case "image": + case "link": + D( + "error", + a + ); + D("load", a); + e = d; + break; + case "details": + D("toggle", a); + e = d; + break; + case "input": + Za(a, d); + e = Ya(a, d); + D("invalid", a); + break; + case "option": + e = d; + break; + case "select": + a._wrapperState = { wasMultiple: !!d.multiple }; + e = A({}, d, { value: void 0 }); + D("invalid", a); + break; + case "textarea": + hb(a, d); + e = gb(a, d); + D("invalid", a); + break; + default: + e = d; + } + ub(c, e); + h = e; + for (f in h) + if (h.hasOwnProperty(f)) { + var k = h[f]; + "style" === f ? sb(a, k) : "dangerouslySetInnerHTML" === f ? (k = k ? k.__html : void 0, null != k && nb(a, k)) : "children" === f ? "string" === typeof k ? ("textarea" !== c || "" !== k) && ob(a, k) : "number" === typeof k && ob(a, "" + k) : "suppressContentEditableWarning" !== f && "suppressHydrationWarning" !== f && "autoFocus" !== f && (ea.hasOwnProperty(f) ? null != k && "onScroll" === f && D("scroll", a) : null != k && ta(a, f, k, g)); + } + switch (c) { + case "input": + Va(a); + db(a, d, false); + break; + case "textarea": + Va(a); + jb(a); + break; + case "option": + null != d.value && a.setAttribute("value", "" + Sa(d.value)); + break; + case "select": + a.multiple = !!d.multiple; + f = d.value; + null != f ? fb(a, !!d.multiple, f, false) : null != d.defaultValue && fb( + a, + !!d.multiple, + d.defaultValue, + true + ); + break; + default: + "function" === typeof e.onClick && (a.onclick = Bf); + } + switch (c) { + case "button": + case "input": + case "select": + case "textarea": + d = !!d.autoFocus; + break a; + case "img": + d = true; + break a; + default: + d = false; + } + } + d && (b.flags |= 4); + } + null !== b.ref && (b.flags |= 512, b.flags |= 2097152); + } + S(b); + return null; + case 6: + if (a && null != b.stateNode) + Dj(a, b, a.memoizedProps, d); + else { + if ("string" !== typeof d && null === b.stateNode) + throw Error(p(166)); + c = Hh(Gh.current); + Hh(Eh.current); + if (Gg(b)) { + d = b.stateNode; + c = b.memoizedProps; + d[Of] = b; + if (f = d.nodeValue !== c) { + if (a = xg, null !== a) + switch (a.tag) { + case 3: + Af(d.nodeValue, c, 0 !== (a.mode & 1)); + break; + case 5: + true !== a.memoizedProps.suppressHydrationWarning && Af(d.nodeValue, c, 0 !== (a.mode & 1)); + } + } + f && (b.flags |= 4); + } else + d = (9 === c.nodeType ? c : c.ownerDocument).createTextNode(d), d[Of] = b, b.stateNode = d; + } + S(b); + return null; + case 13: + E(M); + d = b.memoizedState; + if (null === a || null !== a.memoizedState && null !== a.memoizedState.dehydrated) { + if (I && null !== yg && 0 !== (b.mode & 1) && 0 === (b.flags & 128)) + Hg(), Ig(), b.flags |= 98560, f = false; + else if (f = Gg(b), null !== d && null !== d.dehydrated) { + if (null === a) { + if (!f) + throw Error(p(318)); + f = b.memoizedState; + f = null !== f ? f.dehydrated : null; + if (!f) + throw Error(p(317)); + f[Of] = b; + } else + Ig(), 0 === (b.flags & 128) && (b.memoizedState = null), b.flags |= 4; + S(b); + f = false; + } else + null !== zg && (Gj(zg), zg = null), f = true; + if (!f) + return b.flags & 65536 ? b : null; + } + if (0 !== (b.flags & 128)) + return b.lanes = c, b; + d = null !== d; + d !== (null !== a && null !== a.memoizedState) && d && (b.child.flags |= 8192, 0 !== (b.mode & 1) && (null === a || 0 !== (M.current & 1) ? 0 === T && (T = 3) : uj())); + null !== b.updateQueue && (b.flags |= 4); + S(b); + return null; + case 4: + return Jh(), Bj(a, b), null === a && sf(b.stateNode.containerInfo), S(b), null; + case 10: + return Rg(b.type._context), S(b), null; + case 17: + return Zf(b.type) && $f(), S(b), null; + case 19: + E(M); + f = b.memoizedState; + if (null === f) + return S(b), null; + d = 0 !== (b.flags & 128); + g = f.rendering; + if (null === g) + if (d) + Ej(f, false); + else { + if (0 !== T || null !== a && 0 !== (a.flags & 128)) + for (a = b.child; null !== a; ) { + g = Mh(a); + if (null !== g) { + b.flags |= 128; + Ej(f, false); + d = g.updateQueue; + null !== d && (b.updateQueue = d, b.flags |= 4); + b.subtreeFlags = 0; + d = c; + for (c = b.child; null !== c; ) + f = c, a = d, f.flags &= 14680066, g = f.alternate, null === g ? (f.childLanes = 0, f.lanes = a, f.child = null, f.subtreeFlags = 0, f.memoizedProps = null, f.memoizedState = null, f.updateQueue = null, f.dependencies = null, f.stateNode = null) : (f.childLanes = g.childLanes, f.lanes = g.lanes, f.child = g.child, f.subtreeFlags = 0, f.deletions = null, f.memoizedProps = g.memoizedProps, f.memoizedState = g.memoizedState, f.updateQueue = g.updateQueue, f.type = g.type, a = g.dependencies, f.dependencies = null === a ? null : { lanes: a.lanes, firstContext: a.firstContext }), c = c.sibling; + G(M, M.current & 1 | 2); + return b.child; + } + a = a.sibling; + } + null !== f.tail && B() > Hj && (b.flags |= 128, d = true, Ej(f, false), b.lanes = 4194304); + } + else { + if (!d) + if (a = Mh(g), null !== a) { + if (b.flags |= 128, d = true, c = a.updateQueue, null !== c && (b.updateQueue = c, b.flags |= 4), Ej(f, true), null === f.tail && "hidden" === f.tailMode && !g.alternate && !I) + return S(b), null; + } else + 2 * B() - f.renderingStartTime > Hj && 1073741824 !== c && (b.flags |= 128, d = true, Ej(f, false), b.lanes = 4194304); + f.isBackwards ? (g.sibling = b.child, b.child = g) : (c = f.last, null !== c ? c.sibling = g : b.child = g, f.last = g); + } + if (null !== f.tail) + return b = f.tail, f.rendering = b, f.tail = b.sibling, f.renderingStartTime = B(), b.sibling = null, c = M.current, G(M, d ? c & 1 | 2 : c & 1), b; + S(b); + return null; + case 22: + case 23: + return Ij(), d = null !== b.memoizedState, null !== a && null !== a.memoizedState !== d && (b.flags |= 8192), d && 0 !== (b.mode & 1) ? 0 !== (gj & 1073741824) && (S(b), b.subtreeFlags & 6 && (b.flags |= 8192)) : S(b), null; + case 24: + return null; + case 25: + return null; + } + throw Error(p(156, b.tag)); + } + function Jj(a, b) { + wg(b); + switch (b.tag) { + case 1: + return Zf(b.type) && $f(), a = b.flags, a & 65536 ? (b.flags = a & -65537 | 128, b) : null; + case 3: + return Jh(), E(Wf), E(H), Oh(), a = b.flags, 0 !== (a & 65536) && 0 === (a & 128) ? (b.flags = a & -65537 | 128, b) : null; + case 5: + return Lh(b), null; + case 13: + E(M); + a = b.memoizedState; + if (null !== a && null !== a.dehydrated) { + if (null === b.alternate) + throw Error(p(340)); + Ig(); + } + a = b.flags; + return a & 65536 ? (b.flags = a & -65537 | 128, b) : null; + case 19: + return E(M), null; + case 4: + return Jh(), null; + case 10: + return Rg(b.type._context), null; + case 22: + case 23: + return Ij(), null; + case 24: + return null; + default: + return null; + } + } + var Kj = false; + var U = false; + var Lj = "function" === typeof WeakSet ? WeakSet : Set; + var V = null; + function Mj(a, b) { + var c = a.ref; + if (null !== c) + if ("function" === typeof c) + try { + c(null); + } catch (d) { + W(a, b, d); + } + else + c.current = null; + } + function Nj(a, b, c) { + try { + c(); + } catch (d) { + W(a, b, d); + } + } + var Oj = false; + function Pj(a, b) { + Cf = dd; + a = Me(); + if (Ne(a)) { + if ("selectionStart" in a) + var c = { start: a.selectionStart, end: a.selectionEnd }; + else + a: { + c = (c = a.ownerDocument) && c.defaultView || window; + var d = c.getSelection && c.getSelection(); + if (d && 0 !== d.rangeCount) { + c = d.anchorNode; + var e = d.anchorOffset, f = d.focusNode; + d = d.focusOffset; + try { + c.nodeType, f.nodeType; + } catch (F) { + c = null; + break a; + } + var g = 0, h = -1, k = -1, l = 0, m = 0, q = a, r = null; + b: + for (; ; ) { + for (var y; ; ) { + q !== c || 0 !== e && 3 !== q.nodeType || (h = g + e); + q !== f || 0 !== d && 3 !== q.nodeType || (k = g + d); + 3 === q.nodeType && (g += q.nodeValue.length); + if (null === (y = q.firstChild)) + break; + r = q; + q = y; + } + for (; ; ) { + if (q === a) + break b; + r === c && ++l === e && (h = g); + r === f && ++m === d && (k = g); + if (null !== (y = q.nextSibling)) + break; + q = r; + r = q.parentNode; + } + q = y; + } + c = -1 === h || -1 === k ? null : { start: h, end: k }; + } else + c = null; + } + c = c || { start: 0, end: 0 }; + } else + c = null; + Df = { focusedElem: a, selectionRange: c }; + dd = false; + for (V = b; null !== V; ) + if (b = V, a = b.child, 0 !== (b.subtreeFlags & 1028) && null !== a) + a.return = b, V = a; + else + for (; null !== V; ) { + b = V; + try { + var n = b.alternate; + if (0 !== (b.flags & 1024)) + switch (b.tag) { + case 0: + case 11: + case 15: + break; + case 1: + if (null !== n) { + var t = n.memoizedProps, J = n.memoizedState, x = b.stateNode, w = x.getSnapshotBeforeUpdate(b.elementType === b.type ? t : Lg(b.type, t), J); + x.__reactInternalSnapshotBeforeUpdate = w; + } + break; + case 3: + var u = b.stateNode.containerInfo; + 1 === u.nodeType ? u.textContent = "" : 9 === u.nodeType && u.documentElement && u.removeChild(u.documentElement); + break; + case 5: + case 6: + case 4: + case 17: + break; + default: + throw Error(p(163)); + } + } catch (F) { + W(b, b.return, F); + } + a = b.sibling; + if (null !== a) { + a.return = b.return; + V = a; + break; + } + V = b.return; + } + n = Oj; + Oj = false; + return n; + } + function Qj(a, b, c) { + var d = b.updateQueue; + d = null !== d ? d.lastEffect : null; + if (null !== d) { + var e = d = d.next; + do { + if ((e.tag & a) === a) { + var f = e.destroy; + e.destroy = void 0; + void 0 !== f && Nj(b, c, f); + } + e = e.next; + } while (e !== d); + } + } + function Rj(a, b) { + b = b.updateQueue; + b = null !== b ? b.lastEffect : null; + if (null !== b) { + var c = b = b.next; + do { + if ((c.tag & a) === a) { + var d = c.create; + c.destroy = d(); + } + c = c.next; + } while (c !== b); + } + } + function Sj(a) { + var b = a.ref; + if (null !== b) { + var c = a.stateNode; + switch (a.tag) { + case 5: + a = c; + break; + default: + a = c; + } + "function" === typeof b ? b(a) : b.current = a; + } + } + function Tj(a) { + var b = a.alternate; + null !== b && (a.alternate = null, Tj(b)); + a.child = null; + a.deletions = null; + a.sibling = null; + 5 === a.tag && (b = a.stateNode, null !== b && (delete b[Of], delete b[Pf], delete b[of], delete b[Qf], delete b[Rf])); + a.stateNode = null; + a.return = null; + a.dependencies = null; + a.memoizedProps = null; + a.memoizedState = null; + a.pendingProps = null; + a.stateNode = null; + a.updateQueue = null; + } + function Uj(a) { + return 5 === a.tag || 3 === a.tag || 4 === a.tag; + } + function Vj(a) { + a: + for (; ; ) { + for (; null === a.sibling; ) { + if (null === a.return || Uj(a.return)) + return null; + a = a.return; + } + a.sibling.return = a.return; + for (a = a.sibling; 5 !== a.tag && 6 !== a.tag && 18 !== a.tag; ) { + if (a.flags & 2) + continue a; + if (null === a.child || 4 === a.tag) + continue a; + else + a.child.return = a, a = a.child; + } + if (!(a.flags & 2)) + return a.stateNode; + } + } + function Wj(a, b, c) { + var d = a.tag; + if (5 === d || 6 === d) + a = a.stateNode, b ? 8 === c.nodeType ? c.parentNode.insertBefore(a, b) : c.insertBefore(a, b) : (8 === c.nodeType ? (b = c.parentNode, b.insertBefore(a, c)) : (b = c, b.appendChild(a)), c = c._reactRootContainer, null !== c && void 0 !== c || null !== b.onclick || (b.onclick = Bf)); + else if (4 !== d && (a = a.child, null !== a)) + for (Wj(a, b, c), a = a.sibling; null !== a; ) + Wj(a, b, c), a = a.sibling; + } + function Xj(a, b, c) { + var d = a.tag; + if (5 === d || 6 === d) + a = a.stateNode, b ? c.insertBefore(a, b) : c.appendChild(a); + else if (4 !== d && (a = a.child, null !== a)) + for (Xj(a, b, c), a = a.sibling; null !== a; ) + Xj(a, b, c), a = a.sibling; + } + var X = null; + var Yj = false; + function Zj(a, b, c) { + for (c = c.child; null !== c; ) + ak(a, b, c), c = c.sibling; + } + function ak(a, b, c) { + if (lc && "function" === typeof lc.onCommitFiberUnmount) + try { + lc.onCommitFiberUnmount(kc, c); + } catch (h) { + } + switch (c.tag) { + case 5: + U || Mj(c, b); + case 6: + var d = X, e = Yj; + X = null; + Zj(a, b, c); + X = d; + Yj = e; + null !== X && (Yj ? (a = X, c = c.stateNode, 8 === a.nodeType ? a.parentNode.removeChild(c) : a.removeChild(c)) : X.removeChild(c.stateNode)); + break; + case 18: + null !== X && (Yj ? (a = X, c = c.stateNode, 8 === a.nodeType ? Kf(a.parentNode, c) : 1 === a.nodeType && Kf(a, c), bd(a)) : Kf(X, c.stateNode)); + break; + case 4: + d = X; + e = Yj; + X = c.stateNode.containerInfo; + Yj = true; + Zj(a, b, c); + X = d; + Yj = e; + break; + case 0: + case 11: + case 14: + case 15: + if (!U && (d = c.updateQueue, null !== d && (d = d.lastEffect, null !== d))) { + e = d = d.next; + do { + var f = e, g = f.destroy; + f = f.tag; + void 0 !== g && (0 !== (f & 2) ? Nj(c, b, g) : 0 !== (f & 4) && Nj(c, b, g)); + e = e.next; + } while (e !== d); + } + Zj(a, b, c); + break; + case 1: + if (!U && (Mj(c, b), d = c.stateNode, "function" === typeof d.componentWillUnmount)) + try { + d.props = c.memoizedProps, d.state = c.memoizedState, d.componentWillUnmount(); + } catch (h) { + W(c, b, h); + } + Zj(a, b, c); + break; + case 21: + Zj(a, b, c); + break; + case 22: + c.mode & 1 ? (U = (d = U) || null !== c.memoizedState, Zj(a, b, c), U = d) : Zj(a, b, c); + break; + default: + Zj(a, b, c); + } + } + function bk(a) { + var b = a.updateQueue; + if (null !== b) { + a.updateQueue = null; + var c = a.stateNode; + null === c && (c = a.stateNode = new Lj()); + b.forEach(function(b2) { + var d = ck.bind(null, a, b2); + c.has(b2) || (c.add(b2), b2.then(d, d)); + }); + } + } + function dk(a, b) { + var c = b.deletions; + if (null !== c) + for (var d = 0; d < c.length; d++) { + var e = c[d]; + try { + var f = a, g = b, h = g; + a: + for (; null !== h; ) { + switch (h.tag) { + case 5: + X = h.stateNode; + Yj = false; + break a; + case 3: + X = h.stateNode.containerInfo; + Yj = true; + break a; + case 4: + X = h.stateNode.containerInfo; + Yj = true; + break a; + } + h = h.return; + } + if (null === X) + throw Error(p(160)); + ak(f, g, e); + X = null; + Yj = false; + var k = e.alternate; + null !== k && (k.return = null); + e.return = null; + } catch (l) { + W(e, b, l); + } + } + if (b.subtreeFlags & 12854) + for (b = b.child; null !== b; ) + ek(b, a), b = b.sibling; + } + function ek(a, b) { + var c = a.alternate, d = a.flags; + switch (a.tag) { + case 0: + case 11: + case 14: + case 15: + dk(b, a); + fk(a); + if (d & 4) { + try { + Qj(3, a, a.return), Rj(3, a); + } catch (t) { + W(a, a.return, t); + } + try { + Qj(5, a, a.return); + } catch (t) { + W(a, a.return, t); + } + } + break; + case 1: + dk(b, a); + fk(a); + d & 512 && null !== c && Mj(c, c.return); + break; + case 5: + dk(b, a); + fk(a); + d & 512 && null !== c && Mj(c, c.return); + if (a.flags & 32) { + var e = a.stateNode; + try { + ob(e, ""); + } catch (t) { + W(a, a.return, t); + } + } + if (d & 4 && (e = a.stateNode, null != e)) { + var f = a.memoizedProps, g = null !== c ? c.memoizedProps : f, h = a.type, k = a.updateQueue; + a.updateQueue = null; + if (null !== k) + try { + "input" === h && "radio" === f.type && null != f.name && ab(e, f); + vb(h, g); + var l = vb(h, f); + for (g = 0; g < k.length; g += 2) { + var m = k[g], q = k[g + 1]; + "style" === m ? sb(e, q) : "dangerouslySetInnerHTML" === m ? nb(e, q) : "children" === m ? ob(e, q) : ta(e, m, q, l); + } + switch (h) { + case "input": + bb(e, f); + break; + case "textarea": + ib(e, f); + break; + case "select": + var r = e._wrapperState.wasMultiple; + e._wrapperState.wasMultiple = !!f.multiple; + var y = f.value; + null != y ? fb(e, !!f.multiple, y, false) : r !== !!f.multiple && (null != f.defaultValue ? fb( + e, + !!f.multiple, + f.defaultValue, + true + ) : fb(e, !!f.multiple, f.multiple ? [] : "", false)); + } + e[Pf] = f; + } catch (t) { + W(a, a.return, t); + } + } + break; + case 6: + dk(b, a); + fk(a); + if (d & 4) { + if (null === a.stateNode) + throw Error(p(162)); + e = a.stateNode; + f = a.memoizedProps; + try { + e.nodeValue = f; + } catch (t) { + W(a, a.return, t); + } + } + break; + case 3: + dk(b, a); + fk(a); + if (d & 4 && null !== c && c.memoizedState.isDehydrated) + try { + bd(b.containerInfo); + } catch (t) { + W(a, a.return, t); + } + break; + case 4: + dk(b, a); + fk(a); + break; + case 13: + dk(b, a); + fk(a); + e = a.child; + e.flags & 8192 && (f = null !== e.memoizedState, e.stateNode.isHidden = f, !f || null !== e.alternate && null !== e.alternate.memoizedState || (gk = B())); + d & 4 && bk(a); + break; + case 22: + m = null !== c && null !== c.memoizedState; + a.mode & 1 ? (U = (l = U) || m, dk(b, a), U = l) : dk(b, a); + fk(a); + if (d & 8192) { + l = null !== a.memoizedState; + if ((a.stateNode.isHidden = l) && !m && 0 !== (a.mode & 1)) + for (V = a, m = a.child; null !== m; ) { + for (q = V = m; null !== V; ) { + r = V; + y = r.child; + switch (r.tag) { + case 0: + case 11: + case 14: + case 15: + Qj(4, r, r.return); + break; + case 1: + Mj(r, r.return); + var n = r.stateNode; + if ("function" === typeof n.componentWillUnmount) { + d = r; + c = r.return; + try { + b = d, n.props = b.memoizedProps, n.state = b.memoizedState, n.componentWillUnmount(); + } catch (t) { + W(d, c, t); + } + } + break; + case 5: + Mj(r, r.return); + break; + case 22: + if (null !== r.memoizedState) { + hk(q); + continue; + } + } + null !== y ? (y.return = r, V = y) : hk(q); + } + m = m.sibling; + } + a: + for (m = null, q = a; ; ) { + if (5 === q.tag) { + if (null === m) { + m = q; + try { + e = q.stateNode, l ? (f = e.style, "function" === typeof f.setProperty ? f.setProperty("display", "none", "important") : f.display = "none") : (h = q.stateNode, k = q.memoizedProps.style, g = void 0 !== k && null !== k && k.hasOwnProperty("display") ? k.display : null, h.style.display = rb("display", g)); + } catch (t) { + W(a, a.return, t); + } + } + } else if (6 === q.tag) { + if (null === m) + try { + q.stateNode.nodeValue = l ? "" : q.memoizedProps; + } catch (t) { + W(a, a.return, t); + } + } else if ((22 !== q.tag && 23 !== q.tag || null === q.memoizedState || q === a) && null !== q.child) { + q.child.return = q; + q = q.child; + continue; + } + if (q === a) + break a; + for (; null === q.sibling; ) { + if (null === q.return || q.return === a) + break a; + m === q && (m = null); + q = q.return; + } + m === q && (m = null); + q.sibling.return = q.return; + q = q.sibling; + } + } + break; + case 19: + dk(b, a); + fk(a); + d & 4 && bk(a); + break; + case 21: + break; + default: + dk( + b, + a + ), fk(a); + } + } + function fk(a) { + var b = a.flags; + if (b & 2) { + try { + a: { + for (var c = a.return; null !== c; ) { + if (Uj(c)) { + var d = c; + break a; + } + c = c.return; + } + throw Error(p(160)); + } + switch (d.tag) { + case 5: + var e = d.stateNode; + d.flags & 32 && (ob(e, ""), d.flags &= -33); + var f = Vj(a); + Xj(a, f, e); + break; + case 3: + case 4: + var g = d.stateNode.containerInfo, h = Vj(a); + Wj(a, h, g); + break; + default: + throw Error(p(161)); + } + } catch (k) { + W(a, a.return, k); + } + a.flags &= -3; + } + b & 4096 && (a.flags &= -4097); + } + function ik(a, b, c) { + V = a; + jk(a, b, c); + } + function jk(a, b, c) { + for (var d = 0 !== (a.mode & 1); null !== V; ) { + var e = V, f = e.child; + if (22 === e.tag && d) { + var g = null !== e.memoizedState || Kj; + if (!g) { + var h = e.alternate, k = null !== h && null !== h.memoizedState || U; + h = Kj; + var l = U; + Kj = g; + if ((U = k) && !l) + for (V = e; null !== V; ) + g = V, k = g.child, 22 === g.tag && null !== g.memoizedState ? kk(e) : null !== k ? (k.return = g, V = k) : kk(e); + for (; null !== f; ) + V = f, jk(f, b, c), f = f.sibling; + V = e; + Kj = h; + U = l; + } + lk(a, b, c); + } else + 0 !== (e.subtreeFlags & 8772) && null !== f ? (f.return = e, V = f) : lk(a, b, c); + } + } + function lk(a) { + for (; null !== V; ) { + var b = V; + if (0 !== (b.flags & 8772)) { + var c = b.alternate; + try { + if (0 !== (b.flags & 8772)) + switch (b.tag) { + case 0: + case 11: + case 15: + U || Rj(5, b); + break; + case 1: + var d = b.stateNode; + if (b.flags & 4 && !U) + if (null === c) + d.componentDidMount(); + else { + var e = b.elementType === b.type ? c.memoizedProps : Lg(b.type, c.memoizedProps); + d.componentDidUpdate(e, c.memoizedState, d.__reactInternalSnapshotBeforeUpdate); + } + var f = b.updateQueue; + null !== f && ih(b, f, d); + break; + case 3: + var g = b.updateQueue; + if (null !== g) { + c = null; + if (null !== b.child) + switch (b.child.tag) { + case 5: + c = b.child.stateNode; + break; + case 1: + c = b.child.stateNode; + } + ih(b, g, c); + } + break; + case 5: + var h = b.stateNode; + if (null === c && b.flags & 4) { + c = h; + var k = b.memoizedProps; + switch (b.type) { + case "button": + case "input": + case "select": + case "textarea": + k.autoFocus && c.focus(); + break; + case "img": + k.src && (c.src = k.src); + } + } + break; + case 6: + break; + case 4: + break; + case 12: + break; + case 13: + if (null === b.memoizedState) { + var l = b.alternate; + if (null !== l) { + var m = l.memoizedState; + if (null !== m) { + var q = m.dehydrated; + null !== q && bd(q); + } + } + } + break; + case 19: + case 17: + case 21: + case 22: + case 23: + case 25: + break; + default: + throw Error(p(163)); + } + U || b.flags & 512 && Sj(b); + } catch (r) { + W(b, b.return, r); + } + } + if (b === a) { + V = null; + break; + } + c = b.sibling; + if (null !== c) { + c.return = b.return; + V = c; + break; + } + V = b.return; + } + } + function hk(a) { + for (; null !== V; ) { + var b = V; + if (b === a) { + V = null; + break; + } + var c = b.sibling; + if (null !== c) { + c.return = b.return; + V = c; + break; + } + V = b.return; + } + } + function kk(a) { + for (; null !== V; ) { + var b = V; + try { + switch (b.tag) { + case 0: + case 11: + case 15: + var c = b.return; + try { + Rj(4, b); + } catch (k) { + W(b, c, k); + } + break; + case 1: + var d = b.stateNode; + if ("function" === typeof d.componentDidMount) { + var e = b.return; + try { + d.componentDidMount(); + } catch (k) { + W(b, e, k); + } + } + var f = b.return; + try { + Sj(b); + } catch (k) { + W(b, f, k); + } + break; + case 5: + var g = b.return; + try { + Sj(b); + } catch (k) { + W(b, g, k); + } + } + } catch (k) { + W(b, b.return, k); + } + if (b === a) { + V = null; + break; + } + var h = b.sibling; + if (null !== h) { + h.return = b.return; + V = h; + break; + } + V = b.return; + } + } + var mk = Math.ceil; + var nk = ua.ReactCurrentDispatcher; + var ok = ua.ReactCurrentOwner; + var pk = ua.ReactCurrentBatchConfig; + var K = 0; + var R = null; + var Y = null; + var Z = 0; + var gj = 0; + var fj = Uf(0); + var T = 0; + var qk = null; + var hh = 0; + var rk = 0; + var sk = 0; + var tk = null; + var uk = null; + var gk = 0; + var Hj = Infinity; + var vk = null; + var Pi = false; + var Qi = null; + var Si = null; + var wk = false; + var xk = null; + var yk = 0; + var zk = 0; + var Ak = null; + var Bk = -1; + var Ck = 0; + function L() { + return 0 !== (K & 6) ? B() : -1 !== Bk ? Bk : Bk = B(); + } + function lh(a) { + if (0 === (a.mode & 1)) + return 1; + if (0 !== (K & 2) && 0 !== Z) + return Z & -Z; + if (null !== Kg.transition) + return 0 === Ck && (Ck = yc()), Ck; + a = C; + if (0 !== a) + return a; + a = window.event; + a = void 0 === a ? 16 : jd(a.type); + return a; + } + function mh(a, b, c, d) { + if (50 < zk) + throw zk = 0, Ak = null, Error(p(185)); + Ac(a, c, d); + if (0 === (K & 2) || a !== R) + a === R && (0 === (K & 2) && (rk |= c), 4 === T && Dk(a, Z)), Ek(a, d), 1 === c && 0 === K && 0 === (b.mode & 1) && (Hj = B() + 500, fg && jg()); + } + function Ek(a, b) { + var c = a.callbackNode; + wc(a, b); + var d = uc(a, a === R ? Z : 0); + if (0 === d) + null !== c && bc(c), a.callbackNode = null, a.callbackPriority = 0; + else if (b = d & -d, a.callbackPriority !== b) { + null != c && bc(c); + if (1 === b) + 0 === a.tag ? ig(Fk.bind(null, a)) : hg(Fk.bind(null, a)), Jf(function() { + 0 === (K & 6) && jg(); + }), c = null; + else { + switch (Dc(d)) { + case 1: + c = fc; + break; + case 4: + c = gc; + break; + case 16: + c = hc; + break; + case 536870912: + c = jc; + break; + default: + c = hc; + } + c = Gk(c, Hk.bind(null, a)); + } + a.callbackPriority = b; + a.callbackNode = c; + } + } + function Hk(a, b) { + Bk = -1; + Ck = 0; + if (0 !== (K & 6)) + throw Error(p(327)); + var c = a.callbackNode; + if (Ik() && a.callbackNode !== c) + return null; + var d = uc(a, a === R ? Z : 0); + if (0 === d) + return null; + if (0 !== (d & 30) || 0 !== (d & a.expiredLanes) || b) + b = Jk(a, d); + else { + b = d; + var e = K; + K |= 2; + var f = Kk(); + if (R !== a || Z !== b) + vk = null, Hj = B() + 500, Lk(a, b); + do + try { + Mk(); + break; + } catch (h) { + Nk(a, h); + } + while (1); + Qg(); + nk.current = f; + K = e; + null !== Y ? b = 0 : (R = null, Z = 0, b = T); + } + if (0 !== b) { + 2 === b && (e = xc(a), 0 !== e && (d = e, b = Ok(a, e))); + if (1 === b) + throw c = qk, Lk(a, 0), Dk(a, d), Ek(a, B()), c; + if (6 === b) + Dk(a, d); + else { + e = a.current.alternate; + if (0 === (d & 30) && !Pk(e) && (b = Jk(a, d), 2 === b && (f = xc(a), 0 !== f && (d = f, b = Ok(a, f))), 1 === b)) + throw c = qk, Lk(a, 0), Dk(a, d), Ek(a, B()), c; + a.finishedWork = e; + a.finishedLanes = d; + switch (b) { + case 0: + case 1: + throw Error(p(345)); + case 2: + Qk(a, uk, vk); + break; + case 3: + Dk(a, d); + if ((d & 130023424) === d && (b = gk + 500 - B(), 10 < b)) { + if (0 !== uc(a, 0)) + break; + e = a.suspendedLanes; + if ((e & d) !== d) { + L(); + a.pingedLanes |= a.suspendedLanes & e; + break; + } + a.timeoutHandle = Ff(Qk.bind(null, a, uk, vk), b); + break; + } + Qk(a, uk, vk); + break; + case 4: + Dk(a, d); + if ((d & 4194240) === d) + break; + b = a.eventTimes; + for (e = -1; 0 < d; ) { + var g = 31 - oc(d); + f = 1 << g; + g = b[g]; + g > e && (e = g); + d &= ~f; + } + d = e; + d = B() - d; + d = (120 > d ? 120 : 480 > d ? 480 : 1080 > d ? 1080 : 1920 > d ? 1920 : 3e3 > d ? 3e3 : 4320 > d ? 4320 : 1960 * mk(d / 1960)) - d; + if (10 < d) { + a.timeoutHandle = Ff(Qk.bind(null, a, uk, vk), d); + break; + } + Qk(a, uk, vk); + break; + case 5: + Qk(a, uk, vk); + break; + default: + throw Error(p(329)); + } + } + } + Ek(a, B()); + return a.callbackNode === c ? Hk.bind(null, a) : null; + } + function Ok(a, b) { + var c = tk; + a.current.memoizedState.isDehydrated && (Lk(a, b).flags |= 256); + a = Jk(a, b); + 2 !== a && (b = uk, uk = c, null !== b && Gj(b)); + return a; + } + function Gj(a) { + null === uk ? uk = a : uk.push.apply(uk, a); + } + function Pk(a) { + for (var b = a; ; ) { + if (b.flags & 16384) { + var c = b.updateQueue; + if (null !== c && (c = c.stores, null !== c)) + for (var d = 0; d < c.length; d++) { + var e = c[d], f = e.getSnapshot; + e = e.value; + try { + if (!He(f(), e)) + return false; + } catch (g) { + return false; + } + } + } + c = b.child; + if (b.subtreeFlags & 16384 && null !== c) + c.return = b, b = c; + else { + if (b === a) + break; + for (; null === b.sibling; ) { + if (null === b.return || b.return === a) + return true; + b = b.return; + } + b.sibling.return = b.return; + b = b.sibling; + } + } + return true; + } + function Dk(a, b) { + b &= ~sk; + b &= ~rk; + a.suspendedLanes |= b; + a.pingedLanes &= ~b; + for (a = a.expirationTimes; 0 < b; ) { + var c = 31 - oc(b), d = 1 << c; + a[c] = -1; + b &= ~d; + } + } + function Fk(a) { + if (0 !== (K & 6)) + throw Error(p(327)); + Ik(); + var b = uc(a, 0); + if (0 === (b & 1)) + return Ek(a, B()), null; + var c = Jk(a, b); + if (0 !== a.tag && 2 === c) { + var d = xc(a); + 0 !== d && (b = d, c = Ok(a, d)); + } + if (1 === c) + throw c = qk, Lk(a, 0), Dk(a, b), Ek(a, B()), c; + if (6 === c) + throw Error(p(345)); + a.finishedWork = a.current.alternate; + a.finishedLanes = b; + Qk(a, uk, vk); + Ek(a, B()); + return null; + } + function Rk(a, b) { + var c = K; + K |= 1; + try { + return a(b); + } finally { + K = c, 0 === K && (Hj = B() + 500, fg && jg()); + } + } + function Sk(a) { + null !== xk && 0 === xk.tag && 0 === (K & 6) && Ik(); + var b = K; + K |= 1; + var c = pk.transition, d = C; + try { + if (pk.transition = null, C = 1, a) + return a(); + } finally { + C = d, pk.transition = c, K = b, 0 === (K & 6) && jg(); + } + } + function Ij() { + gj = fj.current; + E(fj); + } + function Lk(a, b) { + a.finishedWork = null; + a.finishedLanes = 0; + var c = a.timeoutHandle; + -1 !== c && (a.timeoutHandle = -1, Gf(c)); + if (null !== Y) + for (c = Y.return; null !== c; ) { + var d = c; + wg(d); + switch (d.tag) { + case 1: + d = d.type.childContextTypes; + null !== d && void 0 !== d && $f(); + break; + case 3: + Jh(); + E(Wf); + E(H); + Oh(); + break; + case 5: + Lh(d); + break; + case 4: + Jh(); + break; + case 13: + E(M); + break; + case 19: + E(M); + break; + case 10: + Rg(d.type._context); + break; + case 22: + case 23: + Ij(); + } + c = c.return; + } + R = a; + Y = a = wh(a.current, null); + Z = gj = b; + T = 0; + qk = null; + sk = rk = hh = 0; + uk = tk = null; + if (null !== Wg) { + for (b = 0; b < Wg.length; b++) + if (c = Wg[b], d = c.interleaved, null !== d) { + c.interleaved = null; + var e = d.next, f = c.pending; + if (null !== f) { + var g = f.next; + f.next = e; + d.next = g; + } + c.pending = d; + } + Wg = null; + } + return a; + } + function Nk(a, b) { + do { + var c = Y; + try { + Qg(); + Ph.current = ai; + if (Sh) { + for (var d = N.memoizedState; null !== d; ) { + var e = d.queue; + null !== e && (e.pending = null); + d = d.next; + } + Sh = false; + } + Rh = 0; + P = O = N = null; + Th = false; + Uh = 0; + ok.current = null; + if (null === c || null === c.return) { + T = 1; + qk = b; + Y = null; + break; + } + a: { + var f = a, g = c.return, h = c, k = b; + b = Z; + h.flags |= 32768; + if (null !== k && "object" === typeof k && "function" === typeof k.then) { + var l = k, m = h, q = m.tag; + if (0 === (m.mode & 1) && (0 === q || 11 === q || 15 === q)) { + var r = m.alternate; + r ? (m.updateQueue = r.updateQueue, m.memoizedState = r.memoizedState, m.lanes = r.lanes) : (m.updateQueue = null, m.memoizedState = null); + } + var y = Vi(g); + if (null !== y) { + y.flags &= -257; + Wi(y, g, h, f, b); + y.mode & 1 && Ti(f, l, b); + b = y; + k = l; + var n = b.updateQueue; + if (null === n) { + var t = /* @__PURE__ */ new Set(); + t.add(k); + b.updateQueue = t; + } else + n.add(k); + break a; + } else { + if (0 === (b & 1)) { + Ti(f, l, b); + uj(); + break a; + } + k = Error(p(426)); + } + } else if (I && h.mode & 1) { + var J = Vi(g); + if (null !== J) { + 0 === (J.flags & 65536) && (J.flags |= 256); + Wi(J, g, h, f, b); + Jg(Ki(k, h)); + break a; + } + } + f = k = Ki(k, h); + 4 !== T && (T = 2); + null === tk ? tk = [f] : tk.push(f); + f = g; + do { + switch (f.tag) { + case 3: + f.flags |= 65536; + b &= -b; + f.lanes |= b; + var x = Oi(f, k, b); + fh(f, x); + break a; + case 1: + h = k; + var w = f.type, u = f.stateNode; + if (0 === (f.flags & 128) && ("function" === typeof w.getDerivedStateFromError || null !== u && "function" === typeof u.componentDidCatch && (null === Si || !Si.has(u)))) { + f.flags |= 65536; + b &= -b; + f.lanes |= b; + var F = Ri(f, h, b); + fh(f, F); + break a; + } + } + f = f.return; + } while (null !== f); + } + Tk(c); + } catch (na) { + b = na; + Y === c && null !== c && (Y = c = c.return); + continue; + } + break; + } while (1); + } + function Kk() { + var a = nk.current; + nk.current = ai; + return null === a ? ai : a; + } + function uj() { + if (0 === T || 3 === T || 2 === T) + T = 4; + null === R || 0 === (hh & 268435455) && 0 === (rk & 268435455) || Dk(R, Z); + } + function Jk(a, b) { + var c = K; + K |= 2; + var d = Kk(); + if (R !== a || Z !== b) + vk = null, Lk(a, b); + do + try { + Uk(); + break; + } catch (e) { + Nk(a, e); + } + while (1); + Qg(); + K = c; + nk.current = d; + if (null !== Y) + throw Error(p(261)); + R = null; + Z = 0; + return T; + } + function Uk() { + for (; null !== Y; ) + Vk(Y); + } + function Mk() { + for (; null !== Y && !cc(); ) + Vk(Y); + } + function Vk(a) { + var b = Wk(a.alternate, a, gj); + a.memoizedProps = a.pendingProps; + null === b ? Tk(a) : Y = b; + ok.current = null; + } + function Tk(a) { + var b = a; + do { + var c = b.alternate; + a = b.return; + if (0 === (b.flags & 32768)) { + if (c = Fj(c, b, gj), null !== c) { + Y = c; + return; + } + } else { + c = Jj(c, b); + if (null !== c) { + c.flags &= 32767; + Y = c; + return; + } + if (null !== a) + a.flags |= 32768, a.subtreeFlags = 0, a.deletions = null; + else { + T = 6; + Y = null; + return; + } + } + b = b.sibling; + if (null !== b) { + Y = b; + return; + } + Y = b = a; + } while (null !== b); + 0 === T && (T = 5); + } + function Qk(a, b, c) { + var d = C, e = pk.transition; + try { + pk.transition = null, C = 1, Xk(a, b, c, d); + } finally { + pk.transition = e, C = d; + } + return null; + } + function Xk(a, b, c, d) { + do + Ik(); + while (null !== xk); + if (0 !== (K & 6)) + throw Error(p(327)); + c = a.finishedWork; + var e = a.finishedLanes; + if (null === c) + return null; + a.finishedWork = null; + a.finishedLanes = 0; + if (c === a.current) + throw Error(p(177)); + a.callbackNode = null; + a.callbackPriority = 0; + var f = c.lanes | c.childLanes; + Bc(a, f); + a === R && (Y = R = null, Z = 0); + 0 === (c.subtreeFlags & 2064) && 0 === (c.flags & 2064) || wk || (wk = true, Gk(hc, function() { + Ik(); + return null; + })); + f = 0 !== (c.flags & 15990); + if (0 !== (c.subtreeFlags & 15990) || f) { + f = pk.transition; + pk.transition = null; + var g = C; + C = 1; + var h = K; + K |= 4; + ok.current = null; + Pj(a, c); + ek(c, a); + Oe(Df); + dd = !!Cf; + Df = Cf = null; + a.current = c; + ik(c, a, e); + dc(); + K = h; + C = g; + pk.transition = f; + } else + a.current = c; + wk && (wk = false, xk = a, yk = e); + f = a.pendingLanes; + 0 === f && (Si = null); + mc(c.stateNode, d); + Ek(a, B()); + if (null !== b) + for (d = a.onRecoverableError, c = 0; c < b.length; c++) + e = b[c], d(e.value, { componentStack: e.stack, digest: e.digest }); + if (Pi) + throw Pi = false, a = Qi, Qi = null, a; + 0 !== (yk & 1) && 0 !== a.tag && Ik(); + f = a.pendingLanes; + 0 !== (f & 1) ? a === Ak ? zk++ : (zk = 0, Ak = a) : zk = 0; + jg(); + return null; + } + function Ik() { + if (null !== xk) { + var a = Dc(yk), b = pk.transition, c = C; + try { + pk.transition = null; + C = 16 > a ? 16 : a; + if (null === xk) + var d = false; + else { + a = xk; + xk = null; + yk = 0; + if (0 !== (K & 6)) + throw Error(p(331)); + var e = K; + K |= 4; + for (V = a.current; null !== V; ) { + var f = V, g = f.child; + if (0 !== (V.flags & 16)) { + var h = f.deletions; + if (null !== h) { + for (var k = 0; k < h.length; k++) { + var l = h[k]; + for (V = l; null !== V; ) { + var m = V; + switch (m.tag) { + case 0: + case 11: + case 15: + Qj(8, m, f); + } + var q = m.child; + if (null !== q) + q.return = m, V = q; + else + for (; null !== V; ) { + m = V; + var r = m.sibling, y = m.return; + Tj(m); + if (m === l) { + V = null; + break; + } + if (null !== r) { + r.return = y; + V = r; + break; + } + V = y; + } + } + } + var n = f.alternate; + if (null !== n) { + var t = n.child; + if (null !== t) { + n.child = null; + do { + var J = t.sibling; + t.sibling = null; + t = J; + } while (null !== t); + } + } + V = f; + } + } + if (0 !== (f.subtreeFlags & 2064) && null !== g) + g.return = f, V = g; + else + b: + for (; null !== V; ) { + f = V; + if (0 !== (f.flags & 2048)) + switch (f.tag) { + case 0: + case 11: + case 15: + Qj(9, f, f.return); + } + var x = f.sibling; + if (null !== x) { + x.return = f.return; + V = x; + break b; + } + V = f.return; + } + } + var w = a.current; + for (V = w; null !== V; ) { + g = V; + var u = g.child; + if (0 !== (g.subtreeFlags & 2064) && null !== u) + u.return = g, V = u; + else + b: + for (g = w; null !== V; ) { + h = V; + if (0 !== (h.flags & 2048)) + try { + switch (h.tag) { + case 0: + case 11: + case 15: + Rj(9, h); + } + } catch (na) { + W(h, h.return, na); + } + if (h === g) { + V = null; + break b; + } + var F = h.sibling; + if (null !== F) { + F.return = h.return; + V = F; + break b; + } + V = h.return; + } + } + K = e; + jg(); + if (lc && "function" === typeof lc.onPostCommitFiberRoot) + try { + lc.onPostCommitFiberRoot(kc, a); + } catch (na) { + } + d = true; + } + return d; + } finally { + C = c, pk.transition = b; + } + } + return false; + } + function Yk(a, b, c) { + b = Ki(c, b); + b = Oi(a, b, 1); + a = dh(a, b, 1); + b = L(); + null !== a && (Ac(a, 1, b), Ek(a, b)); + } + function W(a, b, c) { + if (3 === a.tag) + Yk(a, a, c); + else + for (; null !== b; ) { + if (3 === b.tag) { + Yk(b, a, c); + break; + } else if (1 === b.tag) { + var d = b.stateNode; + if ("function" === typeof b.type.getDerivedStateFromError || "function" === typeof d.componentDidCatch && (null === Si || !Si.has(d))) { + a = Ki(c, a); + a = Ri(b, a, 1); + b = dh(b, a, 1); + a = L(); + null !== b && (Ac(b, 1, a), Ek(b, a)); + break; + } + } + b = b.return; + } + } + function Ui(a, b, c) { + var d = a.pingCache; + null !== d && d.delete(b); + b = L(); + a.pingedLanes |= a.suspendedLanes & c; + R === a && (Z & c) === c && (4 === T || 3 === T && (Z & 130023424) === Z && 500 > B() - gk ? Lk(a, 0) : sk |= c); + Ek(a, b); + } + function Zk(a, b) { + 0 === b && (0 === (a.mode & 1) ? b = 1 : (b = sc, sc <<= 1, 0 === (sc & 130023424) && (sc = 4194304))); + var c = L(); + a = Zg(a, b); + null !== a && (Ac(a, b, c), Ek(a, c)); + } + function vj(a) { + var b = a.memoizedState, c = 0; + null !== b && (c = b.retryLane); + Zk(a, c); + } + function ck(a, b) { + var c = 0; + switch (a.tag) { + case 13: + var d = a.stateNode; + var e = a.memoizedState; + null !== e && (c = e.retryLane); + break; + case 19: + d = a.stateNode; + break; + default: + throw Error(p(314)); + } + null !== d && d.delete(b); + Zk(a, c); + } + var Wk; + Wk = function(a, b, c) { + if (null !== a) + if (a.memoizedProps !== b.pendingProps || Wf.current) + Ug = true; + else { + if (0 === (a.lanes & c) && 0 === (b.flags & 128)) + return Ug = false, zj(a, b, c); + Ug = 0 !== (a.flags & 131072) ? true : false; + } + else + Ug = false, I && 0 !== (b.flags & 1048576) && ug(b, ng, b.index); + b.lanes = 0; + switch (b.tag) { + case 2: + var d = b.type; + jj(a, b); + a = b.pendingProps; + var e = Yf(b, H.current); + Tg(b, c); + e = Xh(null, b, d, a, e, c); + var f = bi(); + b.flags |= 1; + "object" === typeof e && null !== e && "function" === typeof e.render && void 0 === e.$$typeof ? (b.tag = 1, b.memoizedState = null, b.updateQueue = null, Zf(d) ? (f = true, cg(b)) : f = false, b.memoizedState = null !== e.state && void 0 !== e.state ? e.state : null, ah(b), e.updater = nh, b.stateNode = e, e._reactInternals = b, rh(b, d, a, c), b = kj(null, b, d, true, f, c)) : (b.tag = 0, I && f && vg(b), Yi(null, b, e, c), b = b.child); + return b; + case 16: + d = b.elementType; + a: { + jj(a, b); + a = b.pendingProps; + e = d._init; + d = e(d._payload); + b.type = d; + e = b.tag = $k(d); + a = Lg(d, a); + switch (e) { + case 0: + b = dj(null, b, d, a, c); + break a; + case 1: + b = ij(null, b, d, a, c); + break a; + case 11: + b = Zi(null, b, d, a, c); + break a; + case 14: + b = aj(null, b, d, Lg(d.type, a), c); + break a; + } + throw Error(p( + 306, + d, + "" + )); + } + return b; + case 0: + return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), dj(a, b, d, e, c); + case 1: + return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), ij(a, b, d, e, c); + case 3: + a: { + lj(b); + if (null === a) + throw Error(p(387)); + d = b.pendingProps; + f = b.memoizedState; + e = f.element; + bh(a, b); + gh(b, d, null, c); + var g = b.memoizedState; + d = g.element; + if (f.isDehydrated) + if (f = { element: d, isDehydrated: false, cache: g.cache, pendingSuspenseBoundaries: g.pendingSuspenseBoundaries, transitions: g.transitions }, b.updateQueue.baseState = f, b.memoizedState = f, b.flags & 256) { + e = Ki(Error(p(423)), b); + b = mj(a, b, d, c, e); + break a; + } else if (d !== e) { + e = Ki(Error(p(424)), b); + b = mj(a, b, d, c, e); + break a; + } else + for (yg = Lf(b.stateNode.containerInfo.firstChild), xg = b, I = true, zg = null, c = Ch(b, null, d, c), b.child = c; c; ) + c.flags = c.flags & -3 | 4096, c = c.sibling; + else { + Ig(); + if (d === e) { + b = $i(a, b, c); + break a; + } + Yi(a, b, d, c); + } + b = b.child; + } + return b; + case 5: + return Kh(b), null === a && Eg(b), d = b.type, e = b.pendingProps, f = null !== a ? a.memoizedProps : null, g = e.children, Ef(d, e) ? g = null : null !== f && Ef(d, f) && (b.flags |= 32), hj(a, b), Yi(a, b, g, c), b.child; + case 6: + return null === a && Eg(b), null; + case 13: + return pj(a, b, c); + case 4: + return Ih(b, b.stateNode.containerInfo), d = b.pendingProps, null === a ? b.child = Bh(b, null, d, c) : Yi(a, b, d, c), b.child; + case 11: + return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), Zi(a, b, d, e, c); + case 7: + return Yi(a, b, b.pendingProps, c), b.child; + case 8: + return Yi(a, b, b.pendingProps.children, c), b.child; + case 12: + return Yi(a, b, b.pendingProps.children, c), b.child; + case 10: + a: { + d = b.type._context; + e = b.pendingProps; + f = b.memoizedProps; + g = e.value; + G(Mg, d._currentValue); + d._currentValue = g; + if (null !== f) + if (He(f.value, g)) { + if (f.children === e.children && !Wf.current) { + b = $i(a, b, c); + break a; + } + } else + for (f = b.child, null !== f && (f.return = b); null !== f; ) { + var h = f.dependencies; + if (null !== h) { + g = f.child; + for (var k = h.firstContext; null !== k; ) { + if (k.context === d) { + if (1 === f.tag) { + k = ch(-1, c & -c); + k.tag = 2; + var l = f.updateQueue; + if (null !== l) { + l = l.shared; + var m = l.pending; + null === m ? k.next = k : (k.next = m.next, m.next = k); + l.pending = k; + } + } + f.lanes |= c; + k = f.alternate; + null !== k && (k.lanes |= c); + Sg( + f.return, + c, + b + ); + h.lanes |= c; + break; + } + k = k.next; + } + } else if (10 === f.tag) + g = f.type === b.type ? null : f.child; + else if (18 === f.tag) { + g = f.return; + if (null === g) + throw Error(p(341)); + g.lanes |= c; + h = g.alternate; + null !== h && (h.lanes |= c); + Sg(g, c, b); + g = f.sibling; + } else + g = f.child; + if (null !== g) + g.return = f; + else + for (g = f; null !== g; ) { + if (g === b) { + g = null; + break; + } + f = g.sibling; + if (null !== f) { + f.return = g.return; + g = f; + break; + } + g = g.return; + } + f = g; + } + Yi(a, b, e.children, c); + b = b.child; + } + return b; + case 9: + return e = b.type, d = b.pendingProps.children, Tg(b, c), e = Vg(e), d = d(e), b.flags |= 1, Yi(a, b, d, c), b.child; + case 14: + return d = b.type, e = Lg(d, b.pendingProps), e = Lg(d.type, e), aj(a, b, d, e, c); + case 15: + return cj(a, b, b.type, b.pendingProps, c); + case 17: + return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), jj(a, b), b.tag = 1, Zf(d) ? (a = true, cg(b)) : a = false, Tg(b, c), ph(b, d, e), rh(b, d, e, c), kj(null, b, d, true, a, c); + case 19: + return yj(a, b, c); + case 22: + return ej(a, b, c); + } + throw Error(p(156, b.tag)); + }; + function Gk(a, b) { + return ac(a, b); + } + function al(a, b, c, d) { + this.tag = a; + this.key = c; + this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null; + this.index = 0; + this.ref = null; + this.pendingProps = b; + this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null; + this.mode = d; + this.subtreeFlags = this.flags = 0; + this.deletions = null; + this.childLanes = this.lanes = 0; + this.alternate = null; + } + function Bg(a, b, c, d) { + return new al(a, b, c, d); + } + function bj(a) { + a = a.prototype; + return !(!a || !a.isReactComponent); + } + function $k(a) { + if ("function" === typeof a) + return bj(a) ? 1 : 0; + if (void 0 !== a && null !== a) { + a = a.$$typeof; + if (a === Da) + return 11; + if (a === Ga) + return 14; + } + return 2; + } + function wh(a, b) { + var c = a.alternate; + null === c ? (c = Bg(a.tag, b, a.key, a.mode), c.elementType = a.elementType, c.type = a.type, c.stateNode = a.stateNode, c.alternate = a, a.alternate = c) : (c.pendingProps = b, c.type = a.type, c.flags = 0, c.subtreeFlags = 0, c.deletions = null); + c.flags = a.flags & 14680064; + c.childLanes = a.childLanes; + c.lanes = a.lanes; + c.child = a.child; + c.memoizedProps = a.memoizedProps; + c.memoizedState = a.memoizedState; + c.updateQueue = a.updateQueue; + b = a.dependencies; + c.dependencies = null === b ? null : { lanes: b.lanes, firstContext: b.firstContext }; + c.sibling = a.sibling; + c.index = a.index; + c.ref = a.ref; + return c; + } + function yh(a, b, c, d, e, f) { + var g = 2; + d = a; + if ("function" === typeof a) + bj(a) && (g = 1); + else if ("string" === typeof a) + g = 5; + else + a: + switch (a) { + case ya: + return Ah(c.children, e, f, b); + case za: + g = 8; + e |= 8; + break; + case Aa: + return a = Bg(12, c, b, e | 2), a.elementType = Aa, a.lanes = f, a; + case Ea: + return a = Bg(13, c, b, e), a.elementType = Ea, a.lanes = f, a; + case Fa: + return a = Bg(19, c, b, e), a.elementType = Fa, a.lanes = f, a; + case Ia: + return qj(c, e, f, b); + default: + if ("object" === typeof a && null !== a) + switch (a.$$typeof) { + case Ba: + g = 10; + break a; + case Ca: + g = 9; + break a; + case Da: + g = 11; + break a; + case Ga: + g = 14; + break a; + case Ha: + g = 16; + d = null; + break a; + } + throw Error(p(130, null == a ? a : typeof a, "")); + } + b = Bg(g, c, b, e); + b.elementType = a; + b.type = d; + b.lanes = f; + return b; + } + function Ah(a, b, c, d) { + a = Bg(7, a, d, b); + a.lanes = c; + return a; + } + function qj(a, b, c, d) { + a = Bg(22, a, d, b); + a.elementType = Ia; + a.lanes = c; + a.stateNode = { isHidden: false }; + return a; + } + function xh(a, b, c) { + a = Bg(6, a, null, b); + a.lanes = c; + return a; + } + function zh(a, b, c) { + b = Bg(4, null !== a.children ? a.children : [], a.key, b); + b.lanes = c; + b.stateNode = { containerInfo: a.containerInfo, pendingChildren: null, implementation: a.implementation }; + return b; + } + function bl(a, b, c, d, e) { + this.tag = b; + this.containerInfo = a; + this.finishedWork = this.pingCache = this.current = this.pendingChildren = null; + this.timeoutHandle = -1; + this.callbackNode = this.pendingContext = this.context = null; + this.callbackPriority = 0; + this.eventTimes = zc(0); + this.expirationTimes = zc(-1); + this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0; + this.entanglements = zc(0); + this.identifierPrefix = d; + this.onRecoverableError = e; + this.mutableSourceEagerHydrationData = null; + } + function cl(a, b, c, d, e, f, g, h, k) { + a = new bl(a, b, c, h, k); + 1 === b ? (b = 1, true === f && (b |= 8)) : b = 0; + f = Bg(3, null, null, b); + a.current = f; + f.stateNode = a; + f.memoizedState = { element: d, isDehydrated: c, cache: null, transitions: null, pendingSuspenseBoundaries: null }; + ah(f); + return a; + } + function dl(a, b, c) { + var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null; + return { $$typeof: wa, key: null == d ? null : "" + d, children: a, containerInfo: b, implementation: c }; + } + function el(a) { + if (!a) + return Vf; + a = a._reactInternals; + a: { + if (Vb(a) !== a || 1 !== a.tag) + throw Error(p(170)); + var b = a; + do { + switch (b.tag) { + case 3: + b = b.stateNode.context; + break a; + case 1: + if (Zf(b.type)) { + b = b.stateNode.__reactInternalMemoizedMergedChildContext; + break a; + } + } + b = b.return; + } while (null !== b); + throw Error(p(171)); + } + if (1 === a.tag) { + var c = a.type; + if (Zf(c)) + return bg(a, c, b); + } + return b; + } + function fl(a, b, c, d, e, f, g, h, k) { + a = cl(c, d, true, a, e, f, g, h, k); + a.context = el(null); + c = a.current; + d = L(); + e = lh(c); + f = ch(d, e); + f.callback = void 0 !== b && null !== b ? b : null; + dh(c, f, e); + a.current.lanes = e; + Ac(a, e, d); + Ek(a, d); + return a; + } + function gl(a, b, c, d) { + var e = b.current, f = L(), g = lh(e); + c = el(c); + null === b.context ? b.context = c : b.pendingContext = c; + b = ch(f, g); + b.payload = { element: a }; + d = void 0 === d ? null : d; + null !== d && (b.callback = d); + a = dh(e, b, g); + null !== a && (mh(a, e, g, f), eh(a, e, g)); + return g; + } + function hl(a) { + a = a.current; + if (!a.child) + return null; + switch (a.child.tag) { + case 5: + return a.child.stateNode; + default: + return a.child.stateNode; + } + } + function il(a, b) { + a = a.memoizedState; + if (null !== a && null !== a.dehydrated) { + var c = a.retryLane; + a.retryLane = 0 !== c && c < b ? c : b; + } + } + function jl(a, b) { + il(a, b); + (a = a.alternate) && il(a, b); + } + function kl() { + return null; + } + var ll = "function" === typeof reportError ? reportError : function(a) { + console.error(a); + }; + function ml(a) { + this._internalRoot = a; + } + nl.prototype.render = ml.prototype.render = function(a) { + var b = this._internalRoot; + if (null === b) + throw Error(p(409)); + gl(a, b, null, null); + }; + nl.prototype.unmount = ml.prototype.unmount = function() { + var a = this._internalRoot; + if (null !== a) { + this._internalRoot = null; + var b = a.containerInfo; + Sk(function() { + gl(null, a, null, null); + }); + b[uf] = null; + } + }; + function nl(a) { + this._internalRoot = a; + } + nl.prototype.unstable_scheduleHydration = function(a) { + if (a) { + var b = Hc(); + a = { blockedOn: null, target: a, priority: b }; + for (var c = 0; c < Qc.length && 0 !== b && b < Qc[c].priority; c++) + ; + Qc.splice(c, 0, a); + 0 === c && Vc(a); + } + }; + function ol(a) { + return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType); + } + function pl(a) { + return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType && (8 !== a.nodeType || " react-mount-point-unstable " !== a.nodeValue)); + } + function ql() { + } + function rl(a, b, c, d, e) { + if (e) { + if ("function" === typeof d) { + var f = d; + d = function() { + var a2 = hl(g); + f.call(a2); + }; + } + var g = fl(b, d, a, 0, null, false, false, "", ql); + a._reactRootContainer = g; + a[uf] = g.current; + sf(8 === a.nodeType ? a.parentNode : a); + Sk(); + return g; + } + for (; e = a.lastChild; ) + a.removeChild(e); + if ("function" === typeof d) { + var h = d; + d = function() { + var a2 = hl(k); + h.call(a2); + }; + } + var k = cl(a, 0, false, null, null, false, false, "", ql); + a._reactRootContainer = k; + a[uf] = k.current; + sf(8 === a.nodeType ? a.parentNode : a); + Sk(function() { + gl(b, k, c, d); + }); + return k; + } + function sl(a, b, c, d, e) { + var f = c._reactRootContainer; + if (f) { + var g = f; + if ("function" === typeof e) { + var h = e; + e = function() { + var a2 = hl(g); + h.call(a2); + }; + } + gl(b, g, a, e); + } else + g = rl(c, b, a, e, d); + return hl(g); + } + Ec = function(a) { + switch (a.tag) { + case 3: + var b = a.stateNode; + if (b.current.memoizedState.isDehydrated) { + var c = tc(b.pendingLanes); + 0 !== c && (Cc(b, c | 1), Ek(b, B()), 0 === (K & 6) && (Hj = B() + 500, jg())); + } + break; + case 13: + Sk(function() { + var b2 = Zg(a, 1); + if (null !== b2) { + var c2 = L(); + mh(b2, a, 1, c2); + } + }), jl(a, 1); + } + }; + Fc = function(a) { + if (13 === a.tag) { + var b = Zg(a, 134217728); + if (null !== b) { + var c = L(); + mh(b, a, 134217728, c); + } + jl(a, 134217728); + } + }; + Gc = function(a) { + if (13 === a.tag) { + var b = lh(a), c = Zg(a, b); + if (null !== c) { + var d = L(); + mh(c, a, b, d); + } + jl(a, b); + } + }; + Hc = function() { + return C; + }; + Ic = function(a, b) { + var c = C; + try { + return C = a, b(); + } finally { + C = c; + } + }; + yb = function(a, b, c) { + switch (b) { + case "input": + bb(a, c); + b = c.name; + if ("radio" === c.type && null != b) { + for (c = a; c.parentNode; ) + c = c.parentNode; + c = c.querySelectorAll("input[name=" + JSON.stringify("" + b) + '][type="radio"]'); + for (b = 0; b < c.length; b++) { + var d = c[b]; + if (d !== a && d.form === a.form) { + var e = Db(d); + if (!e) + throw Error(p(90)); + Wa(d); + bb(d, e); + } + } + } + break; + case "textarea": + ib(a, c); + break; + case "select": + b = c.value, null != b && fb(a, !!c.multiple, b, false); + } + }; + Gb = Rk; + Hb = Sk; + var tl = { usingClientEntryPoint: false, Events: [Cb, ue, Db, Eb, Fb, Rk] }; + var ul = { findFiberByHostInstance: Wc, bundleType: 0, version: "18.2.0", rendererPackageName: "react-dom" }; + var vl = { bundleType: ul.bundleType, version: ul.version, rendererPackageName: ul.rendererPackageName, rendererConfig: ul.rendererConfig, overrideHookState: null, overrideHookStateDeletePath: null, overrideHookStateRenamePath: null, overrideProps: null, overridePropsDeletePath: null, overridePropsRenamePath: null, setErrorHandler: null, setSuspenseHandler: null, scheduleUpdate: null, currentDispatcherRef: ua.ReactCurrentDispatcher, findHostInstanceByFiber: function(a) { + a = Zb(a); + return null === a ? null : a.stateNode; + }, findFiberByHostInstance: ul.findFiberByHostInstance || kl, findHostInstancesForRefresh: null, scheduleRefresh: null, scheduleRoot: null, setRefreshHandler: null, getCurrentFiber: null, reconcilerVersion: "18.2.0-next-9e3b772b8-20220608" }; + if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) { + wl = __REACT_DEVTOOLS_GLOBAL_HOOK__; + if (!wl.isDisabled && wl.supportsFiber) + try { + kc = wl.inject(vl), lc = wl; + } catch (a) { + } + } + var wl; + exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = tl; + exports.createPortal = function(a, b) { + var c = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null; + if (!ol(b)) + throw Error(p(200)); + return dl(a, b, null, c); + }; + exports.createRoot = function(a, b) { + if (!ol(a)) + throw Error(p(299)); + var c = false, d = "", e = ll; + null !== b && void 0 !== b && (true === b.unstable_strictMode && (c = true), void 0 !== b.identifierPrefix && (d = b.identifierPrefix), void 0 !== b.onRecoverableError && (e = b.onRecoverableError)); + b = cl(a, 1, false, null, null, c, false, d, e); + a[uf] = b.current; + sf(8 === a.nodeType ? a.parentNode : a); + return new ml(b); + }; + exports.findDOMNode = function(a) { + if (null == a) + return null; + if (1 === a.nodeType) + return a; + var b = a._reactInternals; + if (void 0 === b) { + if ("function" === typeof a.render) + throw Error(p(188)); + a = Object.keys(a).join(","); + throw Error(p(268, a)); + } + a = Zb(b); + a = null === a ? null : a.stateNode; + return a; + }; + exports.flushSync = function(a) { + return Sk(a); + }; + exports.hydrate = function(a, b, c) { + if (!pl(b)) + throw Error(p(200)); + return sl(null, a, b, true, c); + }; + exports.hydrateRoot = function(a, b, c) { + if (!ol(a)) + throw Error(p(405)); + var d = null != c && c.hydratedSources || null, e = false, f = "", g = ll; + null !== c && void 0 !== c && (true === c.unstable_strictMode && (e = true), void 0 !== c.identifierPrefix && (f = c.identifierPrefix), void 0 !== c.onRecoverableError && (g = c.onRecoverableError)); + b = fl(b, null, a, 1, null != c ? c : null, e, false, f, g); + a[uf] = b.current; + sf(a); + if (d) + for (a = 0; a < d.length; a++) + c = d[a], e = c._getVersion, e = e(c._source), null == b.mutableSourceEagerHydrationData ? b.mutableSourceEagerHydrationData = [c, e] : b.mutableSourceEagerHydrationData.push( + c, + e + ); + return new nl(b); + }; + exports.render = function(a, b, c) { + if (!pl(b)) + throw Error(p(200)); + return sl(null, a, b, false, c); + }; + exports.unmountComponentAtNode = function(a) { + if (!pl(a)) + throw Error(p(40)); + return a._reactRootContainer ? (Sk(function() { + sl(null, null, a, false, function() { + a._reactRootContainer = null; + a[uf] = null; + }); + }), true) : false; + }; + exports.unstable_batchedUpdates = Rk; + exports.unstable_renderSubtreeIntoContainer = function(a, b, c, d) { + if (!pl(c)) + throw Error(p(200)); + if (null == a || void 0 === a._reactInternals) + throw Error(p(38)); + return sl(a, b, c, false, d); + }; + exports.version = "18.2.0-next-9e3b772b8-20220608"; + } +}); + +// node_modules/react-dom/cjs/react-dom.development.js +var require_react_dom_development = __commonJS({ + "node_modules/react-dom/cjs/react-dom.development.js"(exports) { + "use strict"; + init_cjs_shim(); + if (process.env.NODE_ENV !== "production") { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var React2 = __require("react"); + var Scheduler = require_scheduler(); + var ReactSharedInternals = React2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + var suppressWarning = false; + function setSuppressWarning(newSuppressWarning) { + { + suppressWarning = newSuppressWarning; + } + } + function warn(format) { + { + if (!suppressWarning) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + printWarning("warn", format, args); + } + } + } + function error(format) { + { + if (!suppressWarning) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + printWarning("error", format, args); + } + } + } + function printWarning(level, format, args) { + { + var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame2.getStackAddendum(); + if (stack !== "") { + format += "%s"; + args = args.concat([stack]); + } + var argsWithFormat = args.map(function(item) { + return String(item); + }); + argsWithFormat.unshift("Warning: " + format); + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + } + var FunctionComponent = 0; + var ClassComponent = 1; + var IndeterminateComponent = 2; + var HostRoot = 3; + var HostPortal = 4; + var HostComponent = 5; + var HostText = 6; + var Fragment = 7; + var Mode = 8; + var ContextConsumer = 9; + var ContextProvider = 10; + var ForwardRef = 11; + var Profiler = 12; + var SuspenseComponent = 13; + var MemoComponent = 14; + var SimpleMemoComponent = 15; + var LazyComponent = 16; + var IncompleteClassComponent = 17; + var DehydratedFragment = 18; + var SuspenseListComponent = 19; + var ScopeComponent = 21; + var OffscreenComponent = 22; + var LegacyHiddenComponent = 23; + var CacheComponent = 24; + var TracingMarkerComponent = 25; + var enableClientRenderFallbackOnTextMismatch = true; + var enableNewReconciler = false; + var enableLazyContextPropagation = false; + var enableLegacyHidden = false; + var enableSuspenseAvoidThisFallback = false; + var disableCommentsAsDOMContainers = true; + var enableCustomElementPropertySupport = false; + var warnAboutStringRefs = false; + var enableSchedulingProfiler = true; + var enableProfilerTimer = true; + var enableProfilerCommitHooks = true; + var allNativeEvents = /* @__PURE__ */ new Set(); + var registrationNameDependencies = {}; + var possibleRegistrationNames = {}; + function registerTwoPhaseEvent(registrationName, dependencies) { + registerDirectEvent(registrationName, dependencies); + registerDirectEvent(registrationName + "Capture", dependencies); + } + function registerDirectEvent(registrationName, dependencies) { + { + if (registrationNameDependencies[registrationName]) { + error("EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.", registrationName); + } + } + registrationNameDependencies[registrationName] = dependencies; + { + var lowerCasedName = registrationName.toLowerCase(); + possibleRegistrationNames[lowerCasedName] = registrationName; + if (registrationName === "onDoubleClick") { + possibleRegistrationNames.ondblclick = registrationName; + } + } + for (var i = 0; i < dependencies.length; i++) { + allNativeEvents.add(dependencies[i]); + } + } + var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"); + var hasOwnProperty = Object.prototype.hasOwnProperty; + function typeName(value) { + { + var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; + return type; + } + } + function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } + } + function testStringCoercion(value) { + return "" + value; + } + function checkAttributeStringCoercion(value, attributeName) { + { + if (willCoercionThrow(value)) { + error("The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before before using it here.", attributeName, typeName(value)); + return testStringCoercion(value); + } + } + } + function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + function checkPropStringCoercion(value, propName) { + { + if (willCoercionThrow(value)) { + error("The provided `%s` prop is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(value)); + return testStringCoercion(value); + } + } + } + function checkCSSPropertyStringCoercion(value, propName) { + { + if (willCoercionThrow(value)) { + error("The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(value)); + return testStringCoercion(value); + } + } + } + function checkHtmlStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + function checkFormFieldValueStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("Form field values (value, checked, defaultValue, or defaultChecked props) must be strings, not %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + var RESERVED = 0; + var STRING = 1; + var BOOLEANISH_STRING = 2; + var BOOLEAN = 3; + var OVERLOADED_BOOLEAN = 4; + var NUMERIC = 5; + var POSITIVE_NUMERIC = 6; + var ATTRIBUTE_NAME_START_CHAR = ":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"; + var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040"; + var VALID_ATTRIBUTE_NAME_REGEX = new RegExp("^[" + ATTRIBUTE_NAME_START_CHAR + "][" + ATTRIBUTE_NAME_CHAR + "]*$"); + var illegalAttributeNameCache = {}; + var validatedAttributeNameCache = {}; + function isAttributeNameSafe(attributeName) { + if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) { + return true; + } + if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) { + return false; + } + if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) { + validatedAttributeNameCache[attributeName] = true; + return true; + } + illegalAttributeNameCache[attributeName] = true; + { + error("Invalid attribute name: `%s`", attributeName); + } + return false; + } + function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null) { + return propertyInfo.type === RESERVED; + } + if (isCustomComponentTag) { + return false; + } + if (name.length > 2 && (name[0] === "o" || name[0] === "O") && (name[1] === "n" || name[1] === "N")) { + return true; + } + return false; + } + function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null && propertyInfo.type === RESERVED) { + return false; + } + switch (typeof value) { + case "function": + case "symbol": + return true; + case "boolean": { + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + return !propertyInfo.acceptsBooleans; + } else { + var prefix2 = name.toLowerCase().slice(0, 5); + return prefix2 !== "data-" && prefix2 !== "aria-"; + } + } + default: + return false; + } + } + function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) { + if (value === null || typeof value === "undefined") { + return true; + } + if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) { + return true; + } + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + switch (propertyInfo.type) { + case BOOLEAN: + return !value; + case OVERLOADED_BOOLEAN: + return value === false; + case NUMERIC: + return isNaN(value); + case POSITIVE_NUMERIC: + return isNaN(value) || value < 1; + } + } + return false; + } + function getPropertyInfo(name) { + return properties.hasOwnProperty(name) ? properties[name] : null; + } + function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL2, removeEmptyString) { + this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN; + this.attributeName = attributeName; + this.attributeNamespace = attributeNamespace; + this.mustUseProperty = mustUseProperty; + this.propertyName = name; + this.type = type; + this.sanitizeURL = sanitizeURL2; + this.removeEmptyString = removeEmptyString; + } + var properties = {}; + var reservedProps = [ + "children", + "dangerouslySetInnerHTML", + // TODO: This prevents the assignment of defaultValue to regular + // elements (not just inputs). Now that ReactDOMInput assigns to the + // defaultValue property -- do we need this? + "defaultValue", + "defaultChecked", + "innerHTML", + "suppressContentEditableWarning", + "suppressHydrationWarning", + "style" + ]; + reservedProps.forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + RESERVED, + false, + // mustUseProperty + name, + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + [["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(_ref) { + var name = _ref[0], attributeName = _ref[1]; + properties[name] = new PropertyInfoRecord( + name, + STRING, + false, + // mustUseProperty + attributeName, + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + ["contentEditable", "draggable", "spellCheck", "value"].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + BOOLEANISH_STRING, + false, + // mustUseProperty + name.toLowerCase(), + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + BOOLEANISH_STRING, + false, + // mustUseProperty + name, + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + [ + "allowFullScreen", + "async", + // Note: there is a special case that prevents it from being written to the DOM + // on the client side because the browsers are inconsistent. Instead we call focus(). + "autoFocus", + "autoPlay", + "controls", + "default", + "defer", + "disabled", + "disablePictureInPicture", + "disableRemotePlayback", + "formNoValidate", + "hidden", + "loop", + "noModule", + "noValidate", + "open", + "playsInline", + "readOnly", + "required", + "reversed", + "scoped", + "seamless", + // Microdata + "itemScope" + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + BOOLEAN, + false, + // mustUseProperty + name.toLowerCase(), + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + [ + "checked", + // Note: `option.selected` is not updated if `select.multiple` is + // disabled with `removeAttribute`. We have special logic for handling this. + "multiple", + "muted", + "selected" + // NOTE: if you add a camelCased prop to this list, + // you'll need to set attributeName to name.toLowerCase() + // instead in the assignment below. + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + BOOLEAN, + true, + // mustUseProperty + name, + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + [ + "capture", + "download" + // NOTE: if you add a camelCased prop to this list, + // you'll need to set attributeName to name.toLowerCase() + // instead in the assignment below. + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + OVERLOADED_BOOLEAN, + false, + // mustUseProperty + name, + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + [ + "cols", + "rows", + "size", + "span" + // NOTE: if you add a camelCased prop to this list, + // you'll need to set attributeName to name.toLowerCase() + // instead in the assignment below. + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + POSITIVE_NUMERIC, + false, + // mustUseProperty + name, + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + ["rowSpan", "start"].forEach(function(name) { + properties[name] = new PropertyInfoRecord( + name, + NUMERIC, + false, + // mustUseProperty + name.toLowerCase(), + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + var CAMELIZE = /[\-\:]([a-z])/g; + var capitalize = function(token) { + return token[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" + // NOTE: if you add a camelCased prop to this list, + // you'll need to set attributeName to name.toLowerCase() + // instead in the assignment below. + ].forEach(function(attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord( + name, + STRING, + false, + // mustUseProperty + attributeName, + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + [ + "xlink:actuate", + "xlink:arcrole", + "xlink:role", + "xlink:show", + "xlink:title", + "xlink:type" + // NOTE: if you add a camelCased prop to this list, + // you'll need to set attributeName to name.toLowerCase() + // instead in the assignment below. + ].forEach(function(attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord( + name, + STRING, + false, + // mustUseProperty + attributeName, + "http://www.w3.org/1999/xlink", + false, + // sanitizeURL + false + ); + }); + [ + "xml:base", + "xml:lang", + "xml:space" + // NOTE: if you add a camelCased prop to this list, + // you'll need to set attributeName to name.toLowerCase() + // instead in the assignment below. + ].forEach(function(attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord( + name, + STRING, + false, + // mustUseProperty + attributeName, + "http://www.w3.org/XML/1998/namespace", + false, + // sanitizeURL + false + ); + }); + ["tabIndex", "crossOrigin"].forEach(function(attributeName) { + properties[attributeName] = new PropertyInfoRecord( + attributeName, + STRING, + false, + // mustUseProperty + attributeName.toLowerCase(), + // attributeName + null, + // attributeNamespace + false, + // sanitizeURL + false + ); + }); + var xlinkHref = "xlinkHref"; + properties[xlinkHref] = new PropertyInfoRecord( + "xlinkHref", + STRING, + false, + // mustUseProperty + "xlink:href", + "http://www.w3.org/1999/xlink", + true, + // sanitizeURL + false + ); + ["src", "href", "action", "formAction"].forEach(function(attributeName) { + properties[attributeName] = new PropertyInfoRecord( + attributeName, + STRING, + false, + // mustUseProperty + attributeName.toLowerCase(), + // attributeName + null, + // attributeNamespace + true, + // sanitizeURL + true + ); + }); + var isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i; + var didWarn = false; + function sanitizeURL(url) { + { + if (!didWarn && isJavaScriptProtocol.test(url)) { + didWarn = true; + error("A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML try using dangerouslySetInnerHTML instead. React was passed %s.", JSON.stringify(url)); + } + } + } + function getValueForProperty(node, name, expected, propertyInfo) { + { + if (propertyInfo.mustUseProperty) { + var propertyName = propertyInfo.propertyName; + return node[propertyName]; + } else { + { + checkAttributeStringCoercion(expected, name); + } + if (propertyInfo.sanitizeURL) { + sanitizeURL("" + expected); + } + var attributeName = propertyInfo.attributeName; + var stringValue = null; + if (propertyInfo.type === OVERLOADED_BOOLEAN) { + if (node.hasAttribute(attributeName)) { + var value = node.getAttribute(attributeName); + if (value === "") { + return true; + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return value; + } + if (value === "" + expected) { + return expected; + } + return value; + } + } else if (node.hasAttribute(attributeName)) { + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return node.getAttribute(attributeName); + } + if (propertyInfo.type === BOOLEAN) { + return expected; + } + stringValue = node.getAttribute(attributeName); + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return stringValue === null ? expected : stringValue; + } else if (stringValue === "" + expected) { + return expected; + } else { + return stringValue; + } + } + } + } + function getValueForAttribute(node, name, expected, isCustomComponentTag) { + { + if (!isAttributeNameSafe(name)) { + return; + } + if (!node.hasAttribute(name)) { + return expected === void 0 ? void 0 : null; + } + var value = node.getAttribute(name); + { + checkAttributeStringCoercion(expected, name); + } + if (value === "" + expected) { + return expected; + } + return value; + } + } + function setValueForProperty(node, name, value, isCustomComponentTag) { + var propertyInfo = getPropertyInfo(name); + if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) { + return; + } + if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) { + value = null; + } + if (isCustomComponentTag || propertyInfo === null) { + if (isAttributeNameSafe(name)) { + var _attributeName = name; + if (value === null) { + node.removeAttribute(_attributeName); + } else { + { + checkAttributeStringCoercion(value, name); + } + node.setAttribute(_attributeName, "" + value); + } + } + return; + } + var mustUseProperty = propertyInfo.mustUseProperty; + if (mustUseProperty) { + var propertyName = propertyInfo.propertyName; + if (value === null) { + var type = propertyInfo.type; + node[propertyName] = type === BOOLEAN ? false : ""; + } else { + node[propertyName] = value; + } + return; + } + var attributeName = propertyInfo.attributeName, attributeNamespace = propertyInfo.attributeNamespace; + if (value === null) { + node.removeAttribute(attributeName); + } else { + var _type = propertyInfo.type; + var attributeValue; + if (_type === BOOLEAN || _type === OVERLOADED_BOOLEAN && value === true) { + attributeValue = ""; + } else { + { + { + checkAttributeStringCoercion(value, attributeName); + } + attributeValue = "" + value; + } + if (propertyInfo.sanitizeURL) { + sanitizeURL(attributeValue.toString()); + } + } + if (attributeNamespace) { + node.setAttributeNS(attributeNamespace, attributeName, attributeValue); + } else { + node.setAttribute(attributeName, attributeValue); + } + } + } + var REACT_ELEMENT_TYPE = Symbol.for("react.element"); + var REACT_PORTAL_TYPE = Symbol.for("react.portal"); + var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"); + var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"); + var REACT_PROFILER_TYPE = Symbol.for("react.profiler"); + var REACT_PROVIDER_TYPE = Symbol.for("react.provider"); + var REACT_CONTEXT_TYPE = Symbol.for("react.context"); + var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"); + var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"); + var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"); + var REACT_MEMO_TYPE = Symbol.for("react.memo"); + var REACT_LAZY_TYPE = Symbol.for("react.lazy"); + var REACT_SCOPE_TYPE = Symbol.for("react.scope"); + var REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode"); + var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"); + var REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"); + var REACT_CACHE_TYPE = Symbol.for("react.cache"); + var REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker"); + var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = "@@iterator"; + function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== "object") { + return null; + } + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + if (typeof maybeIterator === "function") { + return maybeIterator; + } + return null; + } + var assign = Object.assign; + var disabledDepth = 0; + var prevLog; + var prevInfo; + var prevWarn; + var prevError; + var prevGroup; + var prevGroupCollapsed; + var prevGroupEnd; + function disabledLog() { + } + disabledLog.__reactDisabledLog = true; + function disableLogs() { + { + if (disabledDepth === 0) { + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + } + disabledDepth++; + } + } + function reenableLogs() { + { + disabledDepth--; + if (disabledDepth === 0) { + var props = { + configurable: true, + enumerable: true, + writable: true + }; + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + } + if (disabledDepth < 0) { + error("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + } + var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher; + var prefix; + function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === void 0) { + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ""; + } + } + return "\n" + prefix + name; + } + } + var reentry = false; + var componentFrameCache; + { + var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); + } + function describeNativeComponentFrame(fn, construct) { + if (!fn || reentry) { + return ""; + } + { + var frame = componentFrameCache.get(fn); + if (frame !== void 0) { + return frame; + } + } + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var previousDispatcher; + { + previousDispatcher = ReactCurrentDispatcher.current; + ReactCurrentDispatcher.current = null; + disableLogs(); + } + try { + if (construct) { + var Fake = function() { + throw Error(); + }; + Object.defineProperty(Fake.prototype, "props", { + set: function() { + throw Error(); + } + }); + if (typeof Reflect === "object" && Reflect.construct) { + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + fn(); + } + } catch (sample) { + if (sample && control && typeof sample.stack === "string") { + var sampleLines = sample.stack.split("\n"); + var controlLines = control.stack.split("\n"); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + c--; + } + for (; s >= 1 && c >= 0; s--, c--) { + if (sampleLines[s] !== controlLines[c]) { + if (s !== 1 || c !== 1) { + do { + s--; + c--; + if (c < 0 || sampleLines[s] !== controlLines[c]) { + var _frame = "\n" + sampleLines[s].replace(" at new ", " at "); + if (fn.displayName && _frame.includes("")) { + _frame = _frame.replace("", fn.displayName); + } + { + if (typeof fn === "function") { + componentFrameCache.set(fn, _frame); + } + } + return _frame; + } + } while (s >= 1 && c >= 0); + } + break; + } + } + } + } finally { + reentry = false; + { + ReactCurrentDispatcher.current = previousDispatcher; + reenableLogs(); + } + Error.prepareStackTrace = previousPrepareStackTrace; + } + var name = fn ? fn.displayName || fn.name : ""; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ""; + { + if (typeof fn === "function") { + componentFrameCache.set(fn, syntheticFrame); + } + } + return syntheticFrame; + } + function describeClassComponentFrame(ctor, source, ownerFn) { + { + return describeNativeComponentFrame(ctor, true); + } + } + function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } + } + function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); + } + function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + if (type == null) { + return ""; + } + if (typeof type === "function") { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + if (typeof type === "string") { + return describeBuiltInComponentFrame(type); + } + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame("Suspense"); + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame("SuspenseList"); + } + if (typeof type === "object") { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + case REACT_MEMO_TYPE: + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + case REACT_LAZY_TYPE: { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) { + } + } + } + } + return ""; + } + function describeFiber(fiber) { + var owner = fiber._debugOwner ? fiber._debugOwner.type : null; + var source = fiber._debugSource; + switch (fiber.tag) { + case HostComponent: + return describeBuiltInComponentFrame(fiber.type); + case LazyComponent: + return describeBuiltInComponentFrame("Lazy"); + case SuspenseComponent: + return describeBuiltInComponentFrame("Suspense"); + case SuspenseListComponent: + return describeBuiltInComponentFrame("SuspenseList"); + case FunctionComponent: + case IndeterminateComponent: + case SimpleMemoComponent: + return describeFunctionComponentFrame(fiber.type); + case ForwardRef: + return describeFunctionComponentFrame(fiber.type.render); + case ClassComponent: + return describeClassComponentFrame(fiber.type); + default: + return ""; + } + } + function getStackByFiberInDevAndProd(workInProgress2) { + try { + var info = ""; + var node = workInProgress2; + do { + info += describeFiber(node); + node = node.return; + } while (node); + return info; + } catch (x) { + return "\nError generating stack: " + x.message + "\n" + x.stack; + } + } + function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + if (displayName) { + return displayName; + } + var functionName = innerType.displayName || innerType.name || ""; + return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName; + } + function getContextName(type) { + return type.displayName || "Context"; + } + function getComponentNameFromType(type) { + if (type == null) { + return null; + } + { + if (typeof type.tag === "number") { + error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."); + } + } + if (typeof type === "function") { + return type.displayName || type.name || null; + } + if (typeof type === "string") { + return type; + } + switch (type) { + case REACT_FRAGMENT_TYPE: + return "Fragment"; + case REACT_PORTAL_TYPE: + return "Portal"; + case REACT_PROFILER_TYPE: + return "Profiler"; + case REACT_STRICT_MODE_TYPE: + return "StrictMode"; + case REACT_SUSPENSE_TYPE: + return "Suspense"; + case REACT_SUSPENSE_LIST_TYPE: + return "SuspenseList"; + } + if (typeof type === "object") { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + ".Consumer"; + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + ".Provider"; + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, "ForwardRef"); + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + if (outerName !== null) { + return outerName; + } + return getComponentNameFromType(type.type) || "Memo"; + case REACT_LAZY_TYPE: { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + } + } + return null; + } + function getWrappedName$1(outerType, innerType, wrapperName) { + var functionName = innerType.displayName || innerType.name || ""; + return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName); + } + function getContextName$1(type) { + return type.displayName || "Context"; + } + function getComponentNameFromFiber(fiber) { + var tag = fiber.tag, type = fiber.type; + switch (tag) { + case CacheComponent: + return "Cache"; + case ContextConsumer: + var context = type; + return getContextName$1(context) + ".Consumer"; + case ContextProvider: + var provider = type; + return getContextName$1(provider._context) + ".Provider"; + case DehydratedFragment: + return "DehydratedFragment"; + case ForwardRef: + return getWrappedName$1(type, type.render, "ForwardRef"); + case Fragment: + return "Fragment"; + case HostComponent: + return type; + case HostPortal: + return "Portal"; + case HostRoot: + return "Root"; + case HostText: + return "Text"; + case LazyComponent: + return getComponentNameFromType(type); + case Mode: + if (type === REACT_STRICT_MODE_TYPE) { + return "StrictMode"; + } + return "Mode"; + case OffscreenComponent: + return "Offscreen"; + case Profiler: + return "Profiler"; + case ScopeComponent: + return "Scope"; + case SuspenseComponent: + return "Suspense"; + case SuspenseListComponent: + return "SuspenseList"; + case TracingMarkerComponent: + return "TracingMarker"; + case ClassComponent: + case FunctionComponent: + case IncompleteClassComponent: + case IndeterminateComponent: + case MemoComponent: + case SimpleMemoComponent: + if (typeof type === "function") { + return type.displayName || type.name || null; + } + if (typeof type === "string") { + return type; + } + break; + } + return null; + } + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var current = null; + var isRendering = false; + function getCurrentFiberOwnerNameInDevOrNull() { + { + if (current === null) { + return null; + } + var owner = current._debugOwner; + if (owner !== null && typeof owner !== "undefined") { + return getComponentNameFromFiber(owner); + } + } + return null; + } + function getCurrentFiberStackInDev() { + { + if (current === null) { + return ""; + } + return getStackByFiberInDevAndProd(current); + } + } + function resetCurrentFiber() { + { + ReactDebugCurrentFrame.getCurrentStack = null; + current = null; + isRendering = false; + } + } + function setCurrentFiber(fiber) { + { + ReactDebugCurrentFrame.getCurrentStack = fiber === null ? null : getCurrentFiberStackInDev; + current = fiber; + isRendering = false; + } + } + function getCurrentFiber() { + { + return current; + } + } + function setIsRendering(rendering) { + { + isRendering = rendering; + } + } + function toString(value) { + return "" + value; + } + function getToStringValue(value) { + switch (typeof value) { + case "boolean": + case "number": + case "string": + case "undefined": + return value; + case "object": + { + checkFormFieldValueStringCoercion(value); + } + return value; + default: + return ""; + } + } + var hasReadOnlyValue = { + button: true, + checkbox: true, + image: true, + hidden: true, + radio: true, + reset: true, + submit: true + }; + function checkControlledValueProps(tagName, props) { + { + if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) { + error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`."); + } + if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) { + error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`."); + } + } + } + function isCheckable(elem) { + var type = elem.type; + var nodeName = elem.nodeName; + return nodeName && nodeName.toLowerCase() === "input" && (type === "checkbox" || type === "radio"); + } + function getTracker(node) { + return node._valueTracker; + } + function detachTracker(node) { + node._valueTracker = null; + } + function getValueFromNode(node) { + var value = ""; + if (!node) { + return value; + } + if (isCheckable(node)) { + value = node.checked ? "true" : "false"; + } else { + value = node.value; + } + return value; + } + function trackValueOnNode(node) { + var valueField = isCheckable(node) ? "checked" : "value"; + var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField); + { + checkFormFieldValueStringCoercion(node[valueField]); + } + var currentValue = "" + node[valueField]; + if (node.hasOwnProperty(valueField) || typeof descriptor === "undefined" || typeof descriptor.get !== "function" || typeof descriptor.set !== "function") { + return; + } + var get2 = descriptor.get, set2 = descriptor.set; + Object.defineProperty(node, valueField, { + configurable: true, + get: function() { + return get2.call(this); + }, + set: function(value) { + { + checkFormFieldValueStringCoercion(value); + } + currentValue = "" + value; + set2.call(this, value); + } + }); + Object.defineProperty(node, valueField, { + enumerable: descriptor.enumerable + }); + var tracker = { + getValue: function() { + return currentValue; + }, + setValue: function(value) { + { + checkFormFieldValueStringCoercion(value); + } + currentValue = "" + value; + }, + stopTracking: function() { + detachTracker(node); + delete node[valueField]; + } + }; + return tracker; + } + function track(node) { + if (getTracker(node)) { + return; + } + node._valueTracker = trackValueOnNode(node); + } + function updateValueIfChanged(node) { + if (!node) { + return false; + } + var tracker = getTracker(node); + if (!tracker) { + return true; + } + var lastValue = tracker.getValue(); + var nextValue = getValueFromNode(node); + if (nextValue !== lastValue) { + tracker.setValue(nextValue); + return true; + } + return false; + } + function getActiveElement(doc) { + doc = doc || (typeof document !== "undefined" ? document : void 0); + if (typeof doc === "undefined") { + return null; + } + try { + return doc.activeElement || doc.body; + } catch (e) { + return doc.body; + } + } + var didWarnValueDefaultValue = false; + var didWarnCheckedDefaultChecked = false; + var didWarnControlledToUncontrolled = false; + var didWarnUncontrolledToControlled = false; + function isControlled(props) { + var usesChecked = props.type === "checkbox" || props.type === "radio"; + return usesChecked ? props.checked != null : props.value != null; + } + function getHostProps(element, props) { + var node = element; + var checked = props.checked; + var hostProps = assign({}, props, { + defaultChecked: void 0, + defaultValue: void 0, + value: void 0, + checked: checked != null ? checked : node._wrapperState.initialChecked + }); + return hostProps; + } + function initWrapperState(element, props) { + { + checkControlledValueProps("input", props); + if (props.checked !== void 0 && props.defaultChecked !== void 0 && !didWarnCheckedDefaultChecked) { + error("%s contains an input of type %s with both checked and defaultChecked props. Input elements must be either controlled or uncontrolled (specify either the checked prop, or the defaultChecked prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type); + didWarnCheckedDefaultChecked = true; + } + if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnValueDefaultValue) { + error("%s contains an input of type %s with both value and defaultValue props. Input elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type); + didWarnValueDefaultValue = true; + } + } + var node = element; + var defaultValue = props.defaultValue == null ? "" : props.defaultValue; + node._wrapperState = { + initialChecked: props.checked != null ? props.checked : props.defaultChecked, + initialValue: getToStringValue(props.value != null ? props.value : defaultValue), + controlled: isControlled(props) + }; + } + function updateChecked(element, props) { + var node = element; + var checked = props.checked; + if (checked != null) { + setValueForProperty(node, "checked", checked, false); + } + } + function updateWrapper(element, props) { + var node = element; + { + var controlled = isControlled(props); + if (!node._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) { + error("A component is changing an uncontrolled input to be controlled. This is likely caused by the value changing from undefined to a defined value, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"); + didWarnUncontrolledToControlled = true; + } + if (node._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) { + error("A component is changing a controlled input to be uncontrolled. This is likely caused by the value changing from a defined to undefined, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"); + didWarnControlledToUncontrolled = true; + } + } + updateChecked(element, props); + var value = getToStringValue(props.value); + var type = props.type; + if (value != null) { + if (type === "number") { + if (value === 0 && node.value === "" || // We explicitly want to coerce to number here if possible. + // eslint-disable-next-line + node.value != value) { + node.value = toString(value); + } + } else if (node.value !== toString(value)) { + node.value = toString(value); + } + } else if (type === "submit" || type === "reset") { + node.removeAttribute("value"); + return; + } + { + if (props.hasOwnProperty("value")) { + setDefaultValue(node, props.type, value); + } else if (props.hasOwnProperty("defaultValue")) { + setDefaultValue(node, props.type, getToStringValue(props.defaultValue)); + } + } + { + if (props.checked == null && props.defaultChecked != null) { + node.defaultChecked = !!props.defaultChecked; + } + } + } + function postMountWrapper(element, props, isHydrating2) { + var node = element; + if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) { + var type = props.type; + var isButton = type === "submit" || type === "reset"; + if (isButton && (props.value === void 0 || props.value === null)) { + return; + } + var initialValue = toString(node._wrapperState.initialValue); + if (!isHydrating2) { + { + if (initialValue !== node.value) { + node.value = initialValue; + } + } + } + { + node.defaultValue = initialValue; + } + } + var name = node.name; + if (name !== "") { + node.name = ""; + } + { + node.defaultChecked = !node.defaultChecked; + node.defaultChecked = !!node._wrapperState.initialChecked; + } + if (name !== "") { + node.name = name; + } + } + function restoreControlledState(element, props) { + var node = element; + updateWrapper(node, props); + updateNamedCousins(node, props); + } + function updateNamedCousins(rootNode, props) { + var name = props.name; + if (props.type === "radio" && name != null) { + var queryRoot = rootNode; + while (queryRoot.parentNode) { + queryRoot = queryRoot.parentNode; + } + { + checkAttributeStringCoercion(name, "name"); + } + var group = queryRoot.querySelectorAll("input[name=" + JSON.stringify("" + name) + '][type="radio"]'); + for (var i = 0; i < group.length; i++) { + var otherNode = group[i]; + if (otherNode === rootNode || otherNode.form !== rootNode.form) { + continue; + } + var otherProps = getFiberCurrentPropsFromNode(otherNode); + if (!otherProps) { + throw new Error("ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported."); + } + updateValueIfChanged(otherNode); + updateWrapper(otherNode, otherProps); + } + } + } + function setDefaultValue(node, type, value) { + if ( + // Focused number inputs synchronize on blur. See ChangeEventPlugin.js + type !== "number" || getActiveElement(node.ownerDocument) !== node + ) { + if (value == null) { + node.defaultValue = toString(node._wrapperState.initialValue); + } else if (node.defaultValue !== toString(value)) { + node.defaultValue = toString(value); + } + } + } + var didWarnSelectedSetOnOption = false; + var didWarnInvalidChild = false; + var didWarnInvalidInnerHTML = false; + function validateProps(element, props) { + { + if (props.value == null) { + if (typeof props.children === "object" && props.children !== null) { + React2.Children.forEach(props.children, function(child) { + if (child == null) { + return; + } + if (typeof child === "string" || typeof child === "number") { + return; + } + if (!didWarnInvalidChild) { + didWarnInvalidChild = true; + error("Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to