diff --git a/changelog.md b/changelog.md index c0731b93..2c91b64f 100644 --- a/changelog.md +++ b/changelog.md @@ -5,6 +5,7 @@ ## New features * Added a color legend overlay to the visualization. It is captured automatically from `color_nodes`/`color_relationships`, can be set explicitly via `set_legend`, and toggled via `show_legend`. +* Added `neo4j_viz.streamlit.display_widget` to embed an interactive `GraphWidget` in a Streamlit app with two-way state sync (selection and options flow back to Python), following the Streamlit light/dark theme. Install with the `streamlit` extra (`pip install neo4j-viz[streamlit]`). ## Bug fixes diff --git a/docs/antora/modules/ROOT/pages/rendering.adoc b/docs/antora/modules/ROOT/pages/rendering.adoc index a76ae2cc..1d500bee 100644 --- a/docs/antora/modules/ROOT/pages/rendering.adoc +++ b/docs/antora/modules/ROOT/pages/rendering.adoc @@ -52,6 +52,58 @@ But you can disable this by passing `show_hover_tooltip=False`. Refer to the xref:getting-started.adoc[] and the link:{tutorials-docs-uri}[tutorials] for examples of `render` method usage. +== Using with Streamlit + +There are two ways to display a graph in a https://streamlit.io/[Streamlit] app. + +=== Static rendering + +The HTML object returned by `render` can be embedded directly. Pass its `data` +attribute to `st.iframe`: + +[source, python] +---- +import streamlit as st +from neo4j_viz import VisualizationGraph + +st.iframe(VG.render(height="600px").data, height=600) +---- + +This is the simplest option and fully supports the in-canvas interactions +(pan, zoom, selection, layout switching), but nothing is communicated back to +Python. + +=== Interactive widget with two-way sync + +To read interactions such as the current selection back in Python, use +`neo4j_viz.streamlit.display_widget`. It renders the same interactive widget as +`render_widget` does in a notebook and syncs the `selected` and `options` state +back into the `GraphWidget` you pass in (in place) on each rerun. + +This requires the `streamlit` optional dependency (Streamlit 1.58 or newer): + +[source, bash] +---- +pip install neo4j-viz[streamlit] +---- + +[source, python] +---- +import streamlit as st +from neo4j_viz.streamlit import display_widget + +widget = VG.render_widget() +display_widget(widget, key="my-graph") + +selection = widget.selected +st.write("Selected node IDs:", selection.nodeIds) +---- + +`display_widget` takes a `GraphWidget` (as returned by +`VisualizationGraph.render_widget()`), so you can configure the widget with all +the usual options (`layout`, `initial_zoom`, `height`, ...) when building it. +When displaying more than one graph in an app, give each a unique `key`. + == Exporting to HTML The object returned by the `render` method is a `IPython.display.HTML` object. diff --git a/examples/datasets/cora/cora_nodes.parquet.gzip b/examples/datasets/cora/cora_nodes.parquet.gzip deleted file mode 100644 index 07f8f612..00000000 Binary files a/examples/datasets/cora/cora_nodes.parquet.gzip and /dev/null differ diff --git a/examples/datasets/cora/cora_rels.parquet.gzip b/examples/datasets/cora/cora_rels.parquet.gzip deleted file mode 100644 index 0dd6d452..00000000 Binary files a/examples/datasets/cora/cora_rels.parquet.gzip and /dev/null differ diff --git a/examples/getting-started.ipynb b/examples/getting-started.ipynb index c74a0fb1..ce055c49 100644 --- a/examples/getting-started.ipynb +++ b/examples/getting-started.ipynb @@ -36,12 +36,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "50baeb1722b94ae58cd6604cb9f4257d", + "model_id": "ef711de91aae4e4994fefd733268edda", "version_major": 2, "version_minor": 1 }, "text/plain": [ - "" + "" ] }, "execution_count": 1, diff --git a/examples/streamlit-example.py b/examples/streamlit-example.py index ab3106cc..03982607 100644 --- a/examples/streamlit-example.py +++ b/examples/streamlit-example.py @@ -1,69 +1,93 @@ -import streamlit as st -from IPython.display import HTML -import streamlit.components.v1 as components -from pandas import read_parquet import pathlib +import random + +import streamlit as st -from neo4j_viz.pandas import from_dfs -from neo4j_viz import VisualizationGraph +from neo4j_viz import Node, Relationship, VisualizationGraph +from neo4j_viz.streamlit import display_widget # Path to this file script_path = pathlib.Path(__file__).resolve() -script_dir_path = pathlib.Path(__file__).parent.resolve() - - -@st.cache_data -def create_visualization_graph() -> VisualizationGraph: - cora_nodes_path = f"{script_dir_path}/datasets/cora/cora_nodes.parquet.gzip" - cora_rels_path = f"{script_dir_path}/datasets/cora/cora_rels.parquet.gzip" - - nodes_df = read_parquet(cora_nodes_path) - nodes_df = nodes_df.rename(columns={"nodeId": "id"}) - - rels_df = read_parquet(cora_rels_path) - rels_df = rels_df.rename( - columns={"sourceNodeId": "source", "targetNodeId": "target"} - ) - - # Drop the features column since it's not needed for visualization - # Also numpy arrays are not supported by the visualization library - nodes_df.drop(columns="features", inplace=True) - - VG = from_dfs(nodes_df, rels_df) - VG.color_nodes(property="subject") - return VG - - -@st.cache_data -def render_graph( - _VG: VisualizationGraph, height: int, initial_zoom: float = 0.1 -) -> HTML: - return VG.render(initial_zoom=initial_zoom, height=f"{height}px") - - -VG = create_visualization_graph() st.title("Neo4j Viz Streamlit Example") st.text( - "This is an example of how to use Streamlit with the Graph " - "Visualization for Python library by Neo4j." + "This is an example of how to use Streamlit with the Graph Visualization for Python library by Neo4j." ) + +def create_small_graph() -> VisualizationGraph: + people = [ + ("Alice", "Engineer"), + ("Bob", "Designer"), + ("Carol", "Engineer"), + ("Dan", "Manager"), + ] + nodes = [ + Node(id=str(i), caption=name, properties={"role": role}) + for i, (name, role) in enumerate(people) + ] + relationships = [ + Relationship(source="0", target="1", caption="KNOWS"), + Relationship(source="1", target="2", caption="KNOWS"), + Relationship(source="2", target="3", caption="KNOWS"), + ] + vg = VisualizationGraph(nodes=nodes, relationships=relationships) + # Coloring by a property populates the legend overlay shown in the widget. + vg.color_nodes(property="role") + return vg + + +small_graph = create_small_graph() + +# Nodes/relationships added at runtime, kept in session state so they survive reruns. +if "added_nodes" not in st.session_state: + st.session_state.added_nodes = [] + st.session_state.added_relationships = [] + with st.sidebar: height = st.slider("Height in pixels", 100, 2000, 600, 50) + if st.button("Add random node"): + existing_ids = [n.id for n in small_graph.nodes] + [ + n.id for n in st.session_state.added_nodes + ] + new_node = Node( + id=f"added-{len(st.session_state.added_nodes)}", caption="New", size=20 + ) + st.session_state.added_nodes.append(new_node) + # Link the new node to a random existing one. + st.session_state.added_relationships.append( + Relationship( + source=new_node.id, + target=random.choice(existing_ids), + caption="LINKS_TO", + ) + ) show_code = st.checkbox("Show code") -st.header("Visualization") +st.header("Interactive widget") st.text( - "A visualization of the famous Cora citation network. Each of its " - "seven scientific subjects is represented by a different color." + "A small graph rendered as an interactive widget, colored by role (see the " + "legend overlay). Selecting nodes or relationships in the graph syncs the " + "selection back to Python, and Python can push data changes back to the graph " + "— use the sidebar button to watch a new node appear and link into the graph." ) -components.html( - render_graph(VG, height=height).data, - height=height, +# Build the widget from the small graph plus any runtime additions. +graph_widget = small_graph.render_widget(height=f"{height}px") +if st.session_state.added_nodes: + graph_widget.add_data( + st.session_state.added_nodes, st.session_state.added_relationships + ) + +display_widget(graph_widget, key="small-graph-widget") + +selection = graph_widget.selected +st.write( + f"Selected {len(selection.nodeIds)} node(s) and {len(selection.relationshipIds)} relationship(s)." ) +if selection.nodeIds: + st.write("Selected node IDs:", selection.nodeIds) if show_code: st.header("Code") diff --git a/js-applet/package.json b/js-applet/package.json index 92fd7790..2a11cbfc 100644 --- a/js-applet/package.json +++ b/js-applet/package.json @@ -7,9 +7,10 @@ "dev:widget": "vite build --watch", "dev:html": "vite build --watch --config vite.config.html.ts", "dev:jupyter": "cd ../python-wrapper && ANYWIDGET_HMR=1 uv run jupyter lab ../examples/", - "build": "tsc && vite build && vite build --config vite.config.html.ts", + "build": "tsc && vite build && vite build --config vite.config.html.ts && npm run build:streamlit", "build:widget": "vite build", "build:html": "vite build --config vite.config.html.ts", + "build:streamlit": "vite build --config vite.config.streamlit.ts", "test": "vitest run", "test:watch": "vitest" }, diff --git a/js-applet/src/streamlit-entrypoint.ts b/js-applet/src/streamlit-entrypoint.ts new file mode 100644 index 00000000..ff5d8d7c --- /dev/null +++ b/js-applet/src/streamlit-entrypoint.ts @@ -0,0 +1,201 @@ +import widget, { type Theme, type WidgetData } from "./graph-widget"; + +/** + * Streamlit Components v2 entrypoint for two-way rendering inside a Streamlit app. + * + * Streamlit does not support the Jupyter/anywidget comm protocol, so the notebook + * `GraphWidget` can't be embedded directly (the community bridge streamlit-anywidget + * also ignores traitlets `to_json`/`from_json` serializers, see + * https://github.com/mdrazak2001/streamlit-anywidget/issues/6). Instead we reuse the + * exact same React component via a small model shim and bridge state over Streamlit's + * `st.components.v2.component` contract: + * + * Python --(get_state, respects to_json)--> `data` prop + * Python <--(set_state, respects from_json)-- setStateValue("selected"/"options", ...) + * + * The module's default export is the v2 mount function. It receives + * `{ data, key, parentElement, setStateValue, ... }`. v2 mounts inline in the host + * DOM (a shadow root when `isolate_styles=True`), and re-invokes this function with + * fresh `data` whenever the data changes -- WITHOUT running the previous cleanup. So + * we mount React exactly once per container and update it in place on later invokes, + * avoiding a full remount (and graph relayout) of this heavy component. + */ + +// ── The v2 component object passed to the default export ───────────────────── +type ComponentArg = { + name: string; + data: Partial | null; + key: string; + parentElement: ShadowRoot | HTMLElement; + setStateValue: (name: string, value: unknown) => void; + setTriggerValue: (name: string, value: unknown) => void; +}; + +// ── Read-write anywidget model shim ───────────────────────────────────────── +// Backs `@anywidget/react`'s `useModelState`/`createRender`, which only rely on +// get / set / save_changes / on / off. Writes from the React component are pushed +// back to Python via setStateValue; updates coming from Python (`applyIncoming`) +// emit `change:` events to refresh React but are not echoed back, avoiding loops. +type Listener = (...args: unknown[]) => void; + +// Traits the frontend is allowed to write back to Python. Mirror the two-way traits +// on GraphWidget (`selected` and `options`) and `_RECEIVE_KEYS` in streamlit.py. +const WRITABLE_KEYS: (keyof WidgetData)[] = ["selected", "options"]; + +class StreamlitModel { + private state: Partial = {}; + private listeners = new Map>(); + private pending = new Set(); + + constructor(private setStateValue: (name: string, value: unknown) => void) {} + + get(key: K): WidgetData[K] { + return this.state[key] as WidgetData[K]; + } + + set(key: K, value: WidgetData[K]): void { + this.state[key] = value; + if (WRITABLE_KEYS.includes(key)) this.pending.add(key); + this.emit(key); + } + + save_changes(): void { + for (const key of this.pending) this.setStateValue(key, this.state[key]); + this.pending.clear(); + } + + on(event: string, cb: Listener): void { + const key = event.startsWith("change:") ? event.slice("change:".length) : event; + if (!this.listeners.has(key)) this.listeners.set(key, new Set()); + this.listeners.get(key)!.add(cb); + } + + off(event: string, cb?: Listener): void { + const key = event.startsWith("change:") ? event.slice("change:".length) : event; + const set = this.listeners.get(key); + if (!set) return; + if (cb) set.delete(cb); + else set.clear(); + } + + private emit(key: keyof WidgetData): void { + this.listeners.get(key as string)?.forEach((cb) => cb()); + this.listeners.get("change")?.forEach((cb) => cb()); + } + + /** Seed initial state silently (before the React mount reads it). */ + initialize(incoming: Partial): void { + this.state = { ...incoming }; + } + + /** + * Apply state pushed from Python without echoing it back. Only keys whose + * serialized value actually changed emit a `change:` event, so React re-renders + * exactly once and there's no feedback loop. + */ + applyIncoming(incoming: Partial): void { + for (const rawKey of Object.keys(incoming) as (keyof WidgetData)[]) { + const next = incoming[rawKey]; + const prev = this.state[rawKey]; + if (JSON.stringify(next) === JSON.stringify(prev)) continue; + (this.state as Record)[rawKey] = next; + this.emit(rawKey); + } + } +} + +// ── Theme: v2 exposes the Streamlit theme only as CSS custom properties on the +// host, so (unlike VS Code/Marimo) there is no class to sniff. Resolve "auto" from +// the host's `--st-background-color` brightness. ──────────────────────────────── +function hostElement(parentElement: ShadowRoot | HTMLElement): HTMLElement { + return parentElement instanceof ShadowRoot + ? (parentElement.host as HTMLElement) + : parentElement; +} + +function resolveStreamlitTheme(host: HTMLElement): "light" | "dark" | null { + const bg = getComputedStyle(host).getPropertyValue("--st-background-color").trim(); + const rgb = bg.match(/\d+/g); + if (!rgb || rgb.length < 3) return null; + const brightness = + Number(rgb[0]) * 0.2126 + Number(rgb[1]) * 0.7152 + Number(rgb[2]) * 0.0722; + return brightness < 128 ? "dark" : "light"; +} + +/** Replace a "auto" theme with the concrete Streamlit theme when we can detect it. */ +function withResolvedTheme( + data: Partial, + host: HTMLElement +): Partial { + if ((data.theme ?? "auto") !== "auto") return data; + const resolved = resolveStreamlitTheme(host); + return resolved ? { ...data, theme: resolved as Theme } : data; +} + +type Mounted = { + model: StreamlitModel; + host: HTMLElement; + el: HTMLElement; + width: string; + height: string; + dispose: () => void; +}; + +// One mounted React instance per container. The shadow root / host element is stable +// across v2 re-invocations for the same component instance, so we key on it. +const mounts = new WeakMap(); + +export default function render(component: ComponentArg): () => void { + const { data, parentElement, setStateValue } = component; + const host = hostElement(parentElement); + const incoming = withResolvedTheme(data ?? {}, host); + + const width = incoming.width ?? "100%"; + const height = incoming.height ?? "600px"; + + let mounted = mounts.get(parentElement); + + // NVL reads its container size once at construction and exposes no resize API (and + // doesn't observe container resizes), so a width/height change can't be applied to + // the live instance — we must re-initialize the graph at the new size. This only + // happens when the dimensions actually change; other updates (nodes, selection, + // options) are applied in place below. + if (mounted && (mounted.width !== width || mounted.height !== height)) { + mounted.dispose(); + mounted = undefined; + } + + if (!mounted) { + const model = new StreamlitModel(setStateValue); + model.initialize(incoming); + + const el = document.createElement("div"); + // Size the container before mounting so NVL initializes at the correct size. + el.style.width = width; + el.style.height = height; + parentElement.appendChild(el); + + const unmount = widget.render({ model, el } as unknown as Parameters[0]); + + // Re-resolve the theme when Streamlit toggles it (the `--st-*` vars change on + // the host element's inline style). + const observer = new MutationObserver(() => { + model.applyIncoming(withResolvedTheme({ theme: "auto" }, host)); + }); + observer.observe(host, { attributes: true, attributeFilter: ["style", "class"] }); + + const dispose = () => { + observer.disconnect(); + Promise.resolve(unmount).then((fn) => (typeof fn === "function" ? fn() : undefined)); + el.remove(); + mounts.delete(parentElement); + }; + + mounted = { model, host, el, width, height, dispose }; + mounts.set(parentElement, mounted); + } else { + mounted.model.applyIncoming(incoming); + } + + return mounted.dispose; +} diff --git a/js-applet/vite.config.streamlit.ts b/js-applet/vite.config.streamlit.ts new file mode 100644 index 00000000..3c7e2ced --- /dev/null +++ b/js-applet/vite.config.streamlit.ts @@ -0,0 +1,30 @@ +import react from "@vitejs/plugin-react"; +import { defineConfig } from "vite"; + +// Streamlit build: produces an ES module (graph.js + style.css) shipped as package +// data and passed inline as the `js`/`css` of an st.components.v2.component (see +// python-wrapper/src/neo4j_viz/streamlit.py). The module's default export is the v2 +// mount function in src/streamlit-entrypoint.ts. +export default defineConfig({ + plugins: [react()], + define: { + // React reads process.env.NODE_ENV at runtime. + "process.env.NODE_ENV": JSON.stringify("production"), + }, + build: { + outDir: "../python-wrapper/src/neo4j_viz/resources/streamlit_v2", + emptyOutDir: true, + lib: { + entry: ["src/streamlit-entrypoint.ts"], + formats: ["es"], + fileName: () => "graph.js", + }, + rollupOptions: { + output: { + // Bundle everything into a single graph.js + style.css. + inlineDynamicImports: true, + assetFileNames: "style.[ext]", + }, + }, + }, +}); diff --git a/python-wrapper/.gitignore b/python-wrapper/.gitignore index b869a759..7eb79624 100644 --- a/python-wrapper/.gitignore +++ b/python-wrapper/.gitignore @@ -3,10 +3,5 @@ __pycache__ build dist -# Should we ignore the following? -src/neo4j_viz/resources/nvl_entrypoint/* -!src/neo4j_viz/resources/nvl_entrypoint/widget.js -!src/neo4j_viz/resources/nvl_entrypoint/style.css -!src/neo4j_viz/resources/nvl_entrypoint/index.html -!src/neo4j_viz/resources/nvl_entrypoint/__init__.py +src/neo4j_viz/resources/*/assets out/* diff --git a/python-wrapper/pyproject.toml b/python-wrapper/pyproject.toml index 5f82ab79..3166ea10 100644 --- a/python-wrapper/pyproject.toml +++ b/python-wrapper/pyproject.toml @@ -46,6 +46,9 @@ pandas = ["pandas>=2, <3", "pandas-stubs>=2, <3"] gds = ["graphdatascience>=1.22, <3"] neo4j = ["neo4j"] snowflake = ["snowflake-snowpark-python>=1, <2"] +# The Streamlit integration (neo4j_viz.streamlit) uses the Components v2 API, +# available from streamlit 1.58. +streamlit = ["streamlit>=1.58, <2"] [dependency-groups] @@ -107,6 +110,8 @@ neo4j_viz = [ "resources/nvl_entrypoint/widget.js", "resources/nvl_entrypoint/style.css", "resources/nvl_entrypoint/index.html", + "resources/streamlit_v2/graph.js", + "resources/streamlit_v2/style.css", "py.typed" ] diff --git a/python-wrapper/src/neo4j_viz/gds.py b/python-wrapper/src/neo4j_viz/gds.py index 67a1a428..8756e0b0 100644 --- a/python-wrapper/src/neo4j_viz/gds.py +++ b/python-wrapper/src/neo4j_viz/gds.py @@ -5,9 +5,14 @@ from typing import Any, Collection, Optional from uuid import uuid4 -import pandas as pd -from graphdatascience import GraphDataScience -from graphdatascience.session import AuraGraphDataScience +try: + import pandas as pd + from graphdatascience import GraphDataScience + from graphdatascience.session import AuraGraphDataScience +except ImportError as exc: + raise ImportError( + "neo4j_viz.gds requires the optional 'gds' dependency. Install it with: pip install 'neo4j-viz[gds]'" + ) from exc from neo4j_viz.colors import NEO4J_COLORS_DISCRETE, ColorSpace diff --git a/python-wrapper/src/neo4j_viz/neo4j.py b/python-wrapper/src/neo4j_viz/neo4j.py index bcee0d73..eed856ab 100644 --- a/python-wrapper/src/neo4j_viz/neo4j.py +++ b/python-wrapper/src/neo4j_viz/neo4j.py @@ -3,8 +3,13 @@ import warnings from typing import Optional, Union -import neo4j.graph -from neo4j import Driver, EagerResult, Result, RoutingControl +try: + import neo4j.graph + from neo4j import Driver, EagerResult, Result, RoutingControl +except ImportError as exc: + raise ImportError( + "neo4j_viz.neo4j requires the optional 'neo4j' dependency. Install it with: pip install 'neo4j-viz[neo4j]'" + ) from exc from pydantic import BaseModel, ValidationError from neo4j_viz.colors import NEO4J_COLORS_DISCRETE, ColorSpace diff --git a/python-wrapper/src/neo4j_viz/pandas.py b/python-wrapper/src/neo4j_viz/pandas.py index 50d19a9b..9f65dfa7 100644 --- a/python-wrapper/src/neo4j_viz/pandas.py +++ b/python-wrapper/src/neo4j_viz/pandas.py @@ -3,7 +3,12 @@ from collections.abc import Iterable from typing import Optional, Union -from pandas import DataFrame +try: + from pandas import DataFrame +except ImportError as exc: + raise ImportError( + "neo4j_viz.pandas requires the optional 'pandas' dependency. Install it with: pip install 'neo4j-viz[pandas]'" + ) from exc from pydantic import BaseModel, ValidationError from .node import Node diff --git a/python-wrapper/src/neo4j_viz/resources/streamlit_v2/graph.js b/python-wrapper/src/neo4j_viz/resources/streamlit_v2/graph.js new file mode 100644 index 00000000..88d5cf28 --- /dev/null +++ b/python-wrapper/src/neo4j_viz/resources/streamlit_v2/graph.js @@ -0,0 +1,86546 @@ +var YW = Object.defineProperty; +var XW = (t, r, e) => r in t ? YW(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e; +var Be = (t, r, e) => XW(t, typeof r != "symbol" ? r + "" : r, e); +function ZW(t, r) { + for (var e = 0; e < r.length; e++) { + const o = r[e]; + if (typeof o != "string" && !Array.isArray(o)) { + for (const n in o) + if (n !== "default" && !(n in t)) { + const a = Object.getOwnPropertyDescriptor(o, n); + a && Object.defineProperty(t, n, a.get ? a : { + enumerable: !0, + get: () => o[n] + }); + } + } + } + return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" })); +} +var Zu = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}; +function ov(t) { + return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t; +} +function KW(t) { + if (Object.prototype.hasOwnProperty.call(t, "__esModule")) return t; + var r = t.default; + if (typeof r == "function") { + var e = function o() { + return this instanceof o ? Reflect.construct(r, arguments, this.constructor) : r.apply(this, arguments); + }; + e.prototype = r.prototype; + } else e = {}; + return Object.defineProperty(e, "__esModule", { value: !0 }), Object.keys(t).forEach(function(o) { + var n = Object.getOwnPropertyDescriptor(t, o); + Object.defineProperty(e, o, n.get ? n : { + enumerable: !0, + get: function() { + return t[o]; + } + }); + }), e; +} +var $3 = { exports: {} }, wm = {}; +/** + * @license React + * react-jsx-runtime.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var PA; +function QW() { + if (PA) return wm; + PA = 1; + var t = Symbol.for("react.transitional.element"), r = Symbol.for("react.fragment"); + function e(o, n, a) { + var i = null; + if (a !== void 0 && (i = "" + a), n.key !== void 0 && (i = "" + n.key), "key" in n) { + a = {}; + for (var c in n) + c !== "key" && (a[c] = n[c]); + } else a = n; + return n = a.ref, { + $$typeof: t, + type: o, + key: i, + ref: n !== void 0 ? n : null, + props: a + }; + } + return wm.Fragment = r, wm.jsx = e, wm.jsxs = e, wm; +} +var MA; +function JW() { + return MA || (MA = 1, $3.exports = QW()), $3.exports; +} +var vr = JW(), r6 = { exports: {} }, ho = {}; +/** + * @license React + * react.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var IA; +function $W() { + if (IA) return ho; + IA = 1; + var t = Symbol.for("react.transitional.element"), r = Symbol.for("react.portal"), e = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), n = Symbol.for("react.profiler"), a = Symbol.for("react.consumer"), i = Symbol.for("react.context"), c = Symbol.for("react.forward_ref"), l = Symbol.for("react.suspense"), d = Symbol.for("react.memo"), s = Symbol.for("react.lazy"), u = Symbol.for("react.activity"), g = Symbol.iterator; + function b(X) { + return X === null || typeof X != "object" ? null : (X = g && X[g] || X["@@iterator"], typeof X == "function" ? X : null); + } + var f = { + isMounted: function() { + return !1; + }, + enqueueForceUpdate: function() { + }, + enqueueReplaceState: function() { + }, + enqueueSetState: function() { + } + }, v = Object.assign, p = {}; + function m(X, Q, lr) { + this.props = X, this.context = Q, this.refs = p, this.updater = lr || f; + } + m.prototype.isReactComponent = {}, m.prototype.setState = function(X, Q) { + if (typeof X != "object" && typeof X != "function" && X != null) + throw Error( + "takes an object of state variables to update or a function which returns an object of state variables." + ); + this.updater.enqueueSetState(this, X, Q, "setState"); + }, m.prototype.forceUpdate = function(X) { + this.updater.enqueueForceUpdate(this, X, "forceUpdate"); + }; + function y() { + } + y.prototype = m.prototype; + function k(X, Q, lr) { + this.props = X, this.context = Q, this.refs = p, this.updater = lr || f; + } + var x = k.prototype = new y(); + x.constructor = k, v(x, m.prototype), x.isPureReactComponent = !0; + var _ = Array.isArray; + function S() { + } + var E = { H: null, A: null, T: null, S: null }, O = Object.prototype.hasOwnProperty; + function R(X, Q, lr) { + var or = lr.ref; + return { + $$typeof: t, + type: X, + key: Q, + ref: or !== void 0 ? or : null, + props: lr + }; + } + function M(X, Q) { + return R(X.type, Q, X.props); + } + function I(X) { + return typeof X == "object" && X !== null && X.$$typeof === t; + } + function L(X) { + var Q = { "=": "=0", ":": "=2" }; + return "$" + X.replace(/[=:]/g, function(lr) { + return Q[lr]; + }); + } + var j = /\/+/g; + function z(X, Q) { + return typeof X == "object" && X !== null && X.key != null ? L("" + X.key) : Q.toString(36); + } + function F(X) { + switch (X.status) { + case "fulfilled": + return X.value; + case "rejected": + throw X.reason; + default: + switch (typeof X.status == "string" ? X.then(S, S) : (X.status = "pending", X.then( + function(Q) { + X.status === "pending" && (X.status = "fulfilled", X.value = Q); + }, + function(Q) { + X.status === "pending" && (X.status = "rejected", X.reason = Q); + } + )), X.status) { + case "fulfilled": + return X.value; + case "rejected": + throw X.reason; + } + } + throw X; + } + function H(X, Q, lr, or, tr) { + var dr = typeof X; + (dr === "undefined" || dr === "boolean") && (X = null); + var sr = !1; + if (X === null) sr = !0; + else + switch (dr) { + case "bigint": + case "string": + case "number": + sr = !0; + break; + case "object": + switch (X.$$typeof) { + case t: + case r: + sr = !0; + break; + case s: + return sr = X._init, H( + sr(X._payload), + Q, + lr, + or, + tr + ); + } + } + if (sr) + return tr = tr(X), sr = or === "" ? "." + z(X, 0) : or, _(tr) ? (lr = "", sr != null && (lr = sr.replace(j, "$&/") + "/"), H(tr, Q, lr, "", function(cr) { + return cr; + })) : tr != null && (I(tr) && (tr = M( + tr, + lr + (tr.key == null || X && X.key === tr.key ? "" : ("" + tr.key).replace( + j, + "$&/" + ) + "/") + sr + )), Q.push(tr)), 1; + sr = 0; + var pr = or === "" ? "." : or + ":"; + if (_(X)) + for (var ur = 0; ur < X.length; ur++) + or = X[ur], dr = pr + z(or, ur), sr += H( + or, + Q, + lr, + dr, + tr + ); + else if (ur = b(X), typeof ur == "function") + for (X = ur.call(X), ur = 0; !(or = X.next()).done; ) + or = or.value, dr = pr + z(or, ur++), sr += H( + or, + Q, + lr, + dr, + tr + ); + else if (dr === "object") { + if (typeof X.then == "function") + return H( + F(X), + Q, + lr, + or, + tr + ); + throw Q = String(X), Error( + "Objects are not valid as a React child (found: " + (Q === "[object Object]" ? "object with keys {" + Object.keys(X).join(", ") + "}" : Q) + "). If you meant to render a collection of children, use an array instead." + ); + } + return sr; + } + function q(X, Q, lr) { + if (X == null) return X; + var or = [], tr = 0; + return H(X, or, "", "", function(dr) { + return Q.call(lr, dr, tr++); + }), or; + } + function W(X) { + if (X._status === -1) { + var Q = X._result; + Q = Q(), Q.then( + function(lr) { + (X._status === 0 || X._status === -1) && (X._status = 1, X._result = lr); + }, + function(lr) { + (X._status === 0 || X._status === -1) && (X._status = 2, X._result = lr); + } + ), X._status === -1 && (X._status = 0, X._result = Q); + } + if (X._status === 1) return X._result.default; + throw X._result; + } + var Z = typeof reportError == "function" ? reportError : function(X) { + if (typeof window == "object" && typeof window.ErrorEvent == "function") { + var Q = new window.ErrorEvent("error", { + bubbles: !0, + cancelable: !0, + message: typeof X == "object" && X !== null && typeof X.message == "string" ? String(X.message) : String(X), + error: X + }); + if (!window.dispatchEvent(Q)) return; + } else if (typeof process == "object" && typeof process.emit == "function") { + process.emit("uncaughtException", X); + return; + } + console.error(X); + }, $ = { + map: q, + forEach: function(X, Q, lr) { + q( + X, + function() { + Q.apply(this, arguments); + }, + lr + ); + }, + count: function(X) { + var Q = 0; + return q(X, function() { + Q++; + }), Q; + }, + toArray: function(X) { + return q(X, function(Q) { + return Q; + }) || []; + }, + only: function(X) { + if (!I(X)) + throw Error( + "React.Children.only expected to receive a single React element child." + ); + return X; + } + }; + return ho.Activity = u, ho.Children = $, ho.Component = m, ho.Fragment = e, ho.Profiler = n, ho.PureComponent = k, ho.StrictMode = o, ho.Suspense = l, ho.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = E, ho.__COMPILER_RUNTIME = { + __proto__: null, + c: function(X) { + return E.H.useMemoCache(X); + } + }, ho.cache = function(X) { + return function() { + return X.apply(null, arguments); + }; + }, ho.cacheSignal = function() { + return null; + }, ho.cloneElement = function(X, Q, lr) { + if (X == null) + throw Error( + "The argument must be a React element, but you passed " + X + "." + ); + var or = v({}, X.props), tr = X.key; + if (Q != null) + for (dr in Q.key !== void 0 && (tr = "" + Q.key), Q) + !O.call(Q, dr) || dr === "key" || dr === "__self" || dr === "__source" || dr === "ref" && Q.ref === void 0 || (or[dr] = Q[dr]); + var dr = arguments.length - 2; + if (dr === 1) or.children = lr; + else if (1 < dr) { + for (var sr = Array(dr), pr = 0; pr < dr; pr++) + sr[pr] = arguments[pr + 2]; + or.children = sr; + } + return R(X.type, tr, or); + }, ho.createContext = function(X) { + return X = { + $$typeof: i, + _currentValue: X, + _currentValue2: X, + _threadCount: 0, + Provider: null, + Consumer: null + }, X.Provider = X, X.Consumer = { + $$typeof: a, + _context: X + }, X; + }, ho.createElement = function(X, Q, lr) { + var or, tr = {}, dr = null; + if (Q != null) + for (or in Q.key !== void 0 && (dr = "" + Q.key), Q) + O.call(Q, or) && or !== "key" && or !== "__self" && or !== "__source" && (tr[or] = Q[or]); + var sr = arguments.length - 2; + if (sr === 1) tr.children = lr; + else if (1 < sr) { + for (var pr = Array(sr), ur = 0; ur < sr; ur++) + pr[ur] = arguments[ur + 2]; + tr.children = pr; + } + if (X && X.defaultProps) + for (or in sr = X.defaultProps, sr) + tr[or] === void 0 && (tr[or] = sr[or]); + return R(X, dr, tr); + }, ho.createRef = function() { + return { current: null }; + }, ho.forwardRef = function(X) { + return { $$typeof: c, render: X }; + }, ho.isValidElement = I, ho.lazy = function(X) { + return { + $$typeof: s, + _payload: { _status: -1, _result: X }, + _init: W + }; + }, ho.memo = function(X, Q) { + return { + $$typeof: d, + type: X, + compare: Q === void 0 ? null : Q + }; + }, ho.startTransition = function(X) { + var Q = E.T, lr = {}; + E.T = lr; + try { + var or = X(), tr = E.S; + tr !== null && tr(lr, or), typeof or == "object" && or !== null && typeof or.then == "function" && or.then(S, Z); + } catch (dr) { + Z(dr); + } finally { + Q !== null && lr.types !== null && (Q.types = lr.types), E.T = Q; + } + }, ho.unstable_useCacheRefresh = function() { + return E.H.useCacheRefresh(); + }, ho.use = function(X) { + return E.H.use(X); + }, ho.useActionState = function(X, Q, lr) { + return E.H.useActionState(X, Q, lr); + }, ho.useCallback = function(X, Q) { + return E.H.useCallback(X, Q); + }, ho.useContext = function(X) { + return E.H.useContext(X); + }, ho.useDebugValue = function() { + }, ho.useDeferredValue = function(X, Q) { + return E.H.useDeferredValue(X, Q); + }, ho.useEffect = function(X, Q) { + return E.H.useEffect(X, Q); + }, ho.useEffectEvent = function(X) { + return E.H.useEffectEvent(X); + }, ho.useId = function() { + return E.H.useId(); + }, ho.useImperativeHandle = function(X, Q, lr) { + return E.H.useImperativeHandle(X, Q, lr); + }, ho.useInsertionEffect = function(X, Q) { + return E.H.useInsertionEffect(X, Q); + }, ho.useLayoutEffect = function(X, Q) { + return E.H.useLayoutEffect(X, Q); + }, ho.useMemo = function(X, Q) { + return E.H.useMemo(X, Q); + }, ho.useOptimistic = function(X, Q) { + return E.H.useOptimistic(X, Q); + }, ho.useReducer = function(X, Q, lr) { + return E.H.useReducer(X, Q, lr); + }, ho.useRef = function(X) { + return E.H.useRef(X); + }, ho.useState = function(X) { + return E.H.useState(X); + }, ho.useSyncExternalStore = function(X, Q, lr) { + return E.H.useSyncExternalStore( + X, + Q, + lr + ); + }, ho.useTransition = function() { + return E.H.useTransition(); + }, ho.version = "19.2.4", ho; +} +var DA; +function GO() { + return DA || (DA = 1, r6.exports = $W()), r6.exports; +} +var fr = GO(); +const fn = /* @__PURE__ */ ov(fr), JB = /* @__PURE__ */ ZW({ + __proto__: null, + default: fn +}, [fr]); +var e6 = { exports: {} }, xm = {}, t6 = { exports: {} }, o6 = {}; +/** + * @license React + * scheduler.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var NA; +function rY() { + return NA || (NA = 1, (function(t) { + function r(H, q) { + var W = H.length; + H.push(q); + r: for (; 0 < W; ) { + var Z = W - 1 >>> 1, $ = H[Z]; + if (0 < n($, q)) + H[Z] = q, H[W] = $, W = Z; + else break r; + } + } + function e(H) { + return H.length === 0 ? null : H[0]; + } + function o(H) { + if (H.length === 0) return null; + var q = H[0], W = H.pop(); + if (W !== q) { + H[0] = W; + r: for (var Z = 0, $ = H.length, X = $ >>> 1; Z < X; ) { + var Q = 2 * (Z + 1) - 1, lr = H[Q], or = Q + 1, tr = H[or]; + if (0 > n(lr, W)) + or < $ && 0 > n(tr, lr) ? (H[Z] = tr, H[or] = W, Z = or) : (H[Z] = lr, H[Q] = W, Z = Q); + else if (or < $ && 0 > n(tr, W)) + H[Z] = tr, H[or] = W, Z = or; + else break r; + } + } + return q; + } + function n(H, q) { + var W = H.sortIndex - q.sortIndex; + return W !== 0 ? W : H.id - q.id; + } + if (t.unstable_now = void 0, typeof performance == "object" && typeof performance.now == "function") { + var a = performance; + t.unstable_now = function() { + return a.now(); + }; + } else { + var i = Date, c = i.now(); + t.unstable_now = function() { + return i.now() - c; + }; + } + var l = [], d = [], s = 1, u = null, g = 3, b = !1, f = !1, v = !1, p = !1, m = typeof setTimeout == "function" ? setTimeout : null, y = typeof clearTimeout == "function" ? clearTimeout : null, k = typeof setImmediate < "u" ? setImmediate : null; + function x(H) { + for (var q = e(d); q !== null; ) { + if (q.callback === null) o(d); + else if (q.startTime <= H) + o(d), q.sortIndex = q.expirationTime, r(l, q); + else break; + q = e(d); + } + } + function _(H) { + if (v = !1, x(H), !f) + if (e(l) !== null) + f = !0, S || (S = !0, L()); + else { + var q = e(d); + q !== null && F(_, q.startTime - H); + } + } + var S = !1, E = -1, O = 5, R = -1; + function M() { + return p ? !0 : !(t.unstable_now() - R < O); + } + function I() { + if (p = !1, S) { + var H = t.unstable_now(); + R = H; + var q = !0; + try { + r: { + f = !1, v && (v = !1, y(E), E = -1), b = !0; + var W = g; + try { + e: { + for (x(H), u = e(l); u !== null && !(u.expirationTime > H && M()); ) { + var Z = u.callback; + if (typeof Z == "function") { + u.callback = null, g = u.priorityLevel; + var $ = Z( + u.expirationTime <= H + ); + if (H = t.unstable_now(), typeof $ == "function") { + u.callback = $, x(H), q = !0; + break e; + } + u === e(l) && o(l), x(H); + } else o(l); + u = e(l); + } + if (u !== null) q = !0; + else { + var X = e(d); + X !== null && F( + _, + X.startTime - H + ), q = !1; + } + } + break r; + } finally { + u = null, g = W, b = !1; + } + q = void 0; + } + } finally { + q ? L() : S = !1; + } + } + } + var L; + if (typeof k == "function") + L = function() { + k(I); + }; + else if (typeof MessageChannel < "u") { + var j = new MessageChannel(), z = j.port2; + j.port1.onmessage = I, L = function() { + z.postMessage(null); + }; + } else + L = function() { + m(I, 0); + }; + function F(H, q) { + E = m(function() { + H(t.unstable_now()); + }, q); + } + t.unstable_IdlePriority = 5, t.unstable_ImmediatePriority = 1, t.unstable_LowPriority = 4, t.unstable_NormalPriority = 3, t.unstable_Profiling = null, t.unstable_UserBlockingPriority = 2, t.unstable_cancelCallback = function(H) { + H.callback = null; + }, t.unstable_forceFrameRate = function(H) { + 0 > H || 125 < H ? console.error( + "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported" + ) : O = 0 < H ? Math.floor(1e3 / H) : 5; + }, t.unstable_getCurrentPriorityLevel = function() { + return g; + }, t.unstable_next = function(H) { + switch (g) { + case 1: + case 2: + case 3: + var q = 3; + break; + default: + q = g; + } + var W = g; + g = q; + try { + return H(); + } finally { + g = W; + } + }, t.unstable_requestPaint = function() { + p = !0; + }, t.unstable_runWithPriority = function(H, q) { + switch (H) { + case 1: + case 2: + case 3: + case 4: + case 5: + break; + default: + H = 3; + } + var W = g; + g = H; + try { + return q(); + } finally { + g = W; + } + }, t.unstable_scheduleCallback = function(H, q, W) { + var Z = t.unstable_now(); + switch (typeof W == "object" && W !== null ? (W = W.delay, W = typeof W == "number" && 0 < W ? Z + W : Z) : W = Z, H) { + case 1: + var $ = -1; + break; + case 2: + $ = 250; + break; + case 5: + $ = 1073741823; + break; + case 4: + $ = 1e4; + break; + default: + $ = 5e3; + } + return $ = W + $, H = { + id: s++, + callback: q, + priorityLevel: H, + startTime: W, + expirationTime: $, + sortIndex: -1 + }, W > Z ? (H.sortIndex = W, r(d, H), e(l) === null && H === e(d) && (v ? (y(E), E = -1) : v = !0, F(_, W - Z))) : (H.sortIndex = $, r(l, H), f || b || (f = !0, S || (S = !0, L()))), H; + }, t.unstable_shouldYield = M, t.unstable_wrapCallback = function(H) { + var q = g; + return function() { + var W = g; + g = q; + try { + return H.apply(this, arguments); + } finally { + g = W; + } + }; + }; + })(o6)), o6; +} +var LA; +function eY() { + return LA || (LA = 1, t6.exports = rY()), t6.exports; +} +var n6 = { exports: {} }, ed = {}; +/** + * @license React + * react-dom.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var jA; +function tY() { + if (jA) return ed; + jA = 1; + var t = GO(); + function r(l) { + var d = "https://react.dev/errors/" + l; + if (1 < arguments.length) { + d += "?args[]=" + encodeURIComponent(arguments[1]); + for (var s = 2; s < arguments.length; s++) + d += "&args[]=" + encodeURIComponent(arguments[s]); + } + return "Minified React error #" + l + "; visit " + d + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; + } + function e() { + } + var o = { + d: { + f: e, + r: function() { + throw Error(r(522)); + }, + D: e, + C: e, + L: e, + m: e, + X: e, + S: e, + M: e + }, + p: 0, + findDOMNode: null + }, n = Symbol.for("react.portal"); + function a(l, d, s) { + var u = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null; + return { + $$typeof: n, + key: u == null ? null : "" + u, + children: l, + containerInfo: d, + implementation: s + }; + } + var i = t.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE; + function c(l, d) { + if (l === "font") return ""; + if (typeof d == "string") + return d === "use-credentials" ? d : ""; + } + return ed.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = o, ed.createPortal = function(l, d) { + var s = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null; + if (!d || d.nodeType !== 1 && d.nodeType !== 9 && d.nodeType !== 11) + throw Error(r(299)); + return a(l, d, null, s); + }, ed.flushSync = function(l) { + var d = i.T, s = o.p; + try { + if (i.T = null, o.p = 2, l) return l(); + } finally { + i.T = d, o.p = s, o.d.f(); + } + }, ed.preconnect = function(l, d) { + typeof l == "string" && (d ? (d = d.crossOrigin, d = typeof d == "string" ? d === "use-credentials" ? d : "" : void 0) : d = null, o.d.C(l, d)); + }, ed.prefetchDNS = function(l) { + typeof l == "string" && o.d.D(l); + }, ed.preinit = function(l, d) { + if (typeof l == "string" && d && typeof d.as == "string") { + var s = d.as, u = c(s, d.crossOrigin), g = typeof d.integrity == "string" ? d.integrity : void 0, b = typeof d.fetchPriority == "string" ? d.fetchPriority : void 0; + s === "style" ? o.d.S( + l, + typeof d.precedence == "string" ? d.precedence : void 0, + { + crossOrigin: u, + integrity: g, + fetchPriority: b + } + ) : s === "script" && o.d.X(l, { + crossOrigin: u, + integrity: g, + fetchPriority: b, + nonce: typeof d.nonce == "string" ? d.nonce : void 0 + }); + } + }, ed.preinitModule = function(l, d) { + if (typeof l == "string") + if (typeof d == "object" && d !== null) { + if (d.as == null || d.as === "script") { + var s = c( + d.as, + d.crossOrigin + ); + o.d.M(l, { + crossOrigin: s, + integrity: typeof d.integrity == "string" ? d.integrity : void 0, + nonce: typeof d.nonce == "string" ? d.nonce : void 0 + }); + } + } else d == null && o.d.M(l); + }, ed.preload = function(l, d) { + if (typeof l == "string" && typeof d == "object" && d !== null && typeof d.as == "string") { + var s = d.as, u = c(s, d.crossOrigin); + o.d.L(l, s, { + crossOrigin: u, + integrity: typeof d.integrity == "string" ? d.integrity : void 0, + nonce: typeof d.nonce == "string" ? d.nonce : void 0, + type: typeof d.type == "string" ? d.type : void 0, + fetchPriority: typeof d.fetchPriority == "string" ? d.fetchPriority : void 0, + referrerPolicy: typeof d.referrerPolicy == "string" ? d.referrerPolicy : void 0, + imageSrcSet: typeof d.imageSrcSet == "string" ? d.imageSrcSet : void 0, + imageSizes: typeof d.imageSizes == "string" ? d.imageSizes : void 0, + media: typeof d.media == "string" ? d.media : void 0 + }); + } + }, ed.preloadModule = function(l, d) { + if (typeof l == "string") + if (d) { + var s = c(d.as, d.crossOrigin); + o.d.m(l, { + as: typeof d.as == "string" && d.as !== "script" ? d.as : void 0, + crossOrigin: s, + integrity: typeof d.integrity == "string" ? d.integrity : void 0 + }); + } else o.d.m(l); + }, ed.requestFormReset = function(l) { + o.d.r(l); + }, ed.unstable_batchedUpdates = function(l, d) { + return l(d); + }, ed.useFormState = function(l, d, s) { + return i.H.useFormState(l, d, s); + }, ed.useFormStatus = function() { + return i.H.useHostTransitionStatus(); + }, ed.version = "19.2.4", ed; +} +var zA; +function $B() { + if (zA) return n6.exports; + zA = 1; + function t() { + if (!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > "u" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE != "function")) + try { + __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(t); + } catch (r) { + console.error(r); + } + } + return t(), n6.exports = tY(), n6.exports; +} +/** + * @license React + * react-dom-client.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var BA; +function oY() { + if (BA) return xm; + BA = 1; + var t = eY(), r = GO(), e = $B(); + function o(h) { + var w = "https://react.dev/errors/" + h; + if (1 < arguments.length) { + w += "?args[]=" + encodeURIComponent(arguments[1]); + for (var T = 2; T < arguments.length; T++) + w += "&args[]=" + encodeURIComponent(arguments[T]); + } + return "Minified React error #" + h + "; visit " + w + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; + } + function n(h) { + return !(!h || h.nodeType !== 1 && h.nodeType !== 9 && h.nodeType !== 11); + } + function a(h) { + var w = h, T = h; + if (h.alternate) for (; w.return; ) w = w.return; + else { + h = w; + do + w = h, (w.flags & 4098) !== 0 && (T = w.return), h = w.return; + while (h); + } + return w.tag === 3 ? T : null; + } + function i(h) { + if (h.tag === 13) { + var w = h.memoizedState; + if (w === null && (h = h.alternate, h !== null && (w = h.memoizedState)), w !== null) return w.dehydrated; + } + return null; + } + function c(h) { + if (h.tag === 31) { + var w = h.memoizedState; + if (w === null && (h = h.alternate, h !== null && (w = h.memoizedState)), w !== null) return w.dehydrated; + } + return null; + } + function l(h) { + if (a(h) !== h) + throw Error(o(188)); + } + function d(h) { + var w = h.alternate; + if (!w) { + if (w = a(h), w === null) throw Error(o(188)); + return w !== h ? null : h; + } + for (var T = h, P = w; ; ) { + var B = T.return; + if (B === null) break; + var V = B.alternate; + if (V === null) { + if (P = B.return, P !== null) { + T = P; + continue; + } + break; + } + if (B.child === V.child) { + for (V = B.child; V; ) { + if (V === T) return l(B), h; + if (V === P) return l(B), w; + V = V.sibling; + } + throw Error(o(188)); + } + if (T.return !== P.return) T = B, P = V; + else { + for (var ar = !1, Sr = B.child; Sr; ) { + if (Sr === T) { + ar = !0, T = B, P = V; + break; + } + if (Sr === P) { + ar = !0, P = B, T = V; + break; + } + Sr = Sr.sibling; + } + if (!ar) { + for (Sr = V.child; Sr; ) { + if (Sr === T) { + ar = !0, T = V, P = B; + break; + } + if (Sr === P) { + ar = !0, P = V, T = B; + break; + } + Sr = Sr.sibling; + } + if (!ar) throw Error(o(189)); + } + } + if (T.alternate !== P) throw Error(o(190)); + } + if (T.tag !== 3) throw Error(o(188)); + return T.stateNode.current === T ? h : w; + } + function s(h) { + var w = h.tag; + if (w === 5 || w === 26 || w === 27 || w === 6) return h; + for (h = h.child; h !== null; ) { + if (w = s(h), w !== null) return w; + h = h.sibling; + } + return null; + } + var u = Object.assign, g = Symbol.for("react.element"), b = Symbol.for("react.transitional.element"), f = Symbol.for("react.portal"), v = Symbol.for("react.fragment"), p = Symbol.for("react.strict_mode"), m = Symbol.for("react.profiler"), y = Symbol.for("react.consumer"), k = Symbol.for("react.context"), x = Symbol.for("react.forward_ref"), _ = Symbol.for("react.suspense"), S = Symbol.for("react.suspense_list"), E = Symbol.for("react.memo"), O = Symbol.for("react.lazy"), R = Symbol.for("react.activity"), M = Symbol.for("react.memo_cache_sentinel"), I = Symbol.iterator; + function L(h) { + return h === null || typeof h != "object" ? null : (h = I && h[I] || h["@@iterator"], typeof h == "function" ? h : null); + } + var j = Symbol.for("react.client.reference"); + function z(h) { + if (h == null) return null; + if (typeof h == "function") + return h.$$typeof === j ? null : h.displayName || h.name || null; + if (typeof h == "string") return h; + switch (h) { + case v: + return "Fragment"; + case m: + return "Profiler"; + case p: + return "StrictMode"; + case _: + return "Suspense"; + case S: + return "SuspenseList"; + case R: + return "Activity"; + } + if (typeof h == "object") + switch (h.$$typeof) { + case f: + return "Portal"; + case k: + return h.displayName || "Context"; + case y: + return (h._context.displayName || "Context") + ".Consumer"; + case x: + var w = h.render; + return h = h.displayName, h || (h = w.displayName || w.name || "", h = h !== "" ? "ForwardRef(" + h + ")" : "ForwardRef"), h; + case E: + return w = h.displayName || null, w !== null ? w : z(h.type) || "Memo"; + case O: + w = h._payload, h = h._init; + try { + return z(h(w)); + } catch { + } + } + return null; + } + var F = Array.isArray, H = r.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, q = e.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, W = { + pending: !1, + data: null, + method: null, + action: null + }, Z = [], $ = -1; + function X(h) { + return { current: h }; + } + function Q(h) { + 0 > $ || (h.current = Z[$], Z[$] = null, $--); + } + function lr(h, w) { + $++, Z[$] = h.current, h.current = w; + } + var or = X(null), tr = X(null), dr = X(null), sr = X(null); + function pr(h, w) { + switch (lr(dr, w), lr(tr, h), lr(or, null), w.nodeType) { + case 9: + case 11: + h = (h = w.documentElement) && (h = h.namespaceURI) ? zv(h) : 0; + break; + default: + if (h = w.tagName, w = w.namespaceURI) + w = zv(w), h = $l(w, h); + else + switch (h) { + case "svg": + h = 1; + break; + case "math": + h = 2; + break; + default: + h = 0; + } + } + Q(or), lr(or, h); + } + function ur() { + Q(or), Q(tr), Q(dr); + } + function cr(h) { + h.memoizedState !== null && lr(sr, h); + var w = or.current, T = $l(w, h.type); + w !== T && (lr(tr, h), lr(or, T)); + } + function gr(h) { + tr.current === h && (Q(or), Q(tr)), sr.current === h && (Q(sr), gf._currentValue = W); + } + var kr, Or; + function Ir(h) { + if (kr === void 0) + try { + throw Error(); + } catch (T) { + var w = T.stack.trim().match(/\n( *(at )?)/); + kr = w && w[1] || "", Or = -1 < T.stack.indexOf(` + at`) ? " ()" : -1 < T.stack.indexOf("@") ? "@unknown:0:0" : ""; + } + return ` +` + kr + h + Or; + } + var Mr = !1; + function Lr(h, w) { + if (!h || Mr) return ""; + Mr = !0; + var T = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + try { + var P = { + DetermineComponentFrameRoot: function() { + try { + if (w) { + var we = function() { + throw Error(); + }; + if (Object.defineProperty(we.prototype, "props", { + set: function() { + throw Error(); + } + }), typeof Reflect == "object" && Reflect.construct) { + try { + Reflect.construct(we, []); + } catch (de) { + var ae = de; + } + Reflect.construct(h, [], we); + } else { + try { + we.call(); + } catch (de) { + ae = de; + } + h.call(we.prototype); + } + } else { + try { + throw Error(); + } catch (de) { + ae = de; + } + (we = h()) && typeof we.catch == "function" && we.catch(function() { + }); + } + } catch (de) { + if (de && ae && typeof de.stack == "string") + return [de.stack, ae.stack]; + } + return [null, null]; + } + }; + P.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot"; + var B = Object.getOwnPropertyDescriptor( + P.DetermineComponentFrameRoot, + "name" + ); + B && B.configurable && Object.defineProperty( + P.DetermineComponentFrameRoot, + "name", + { value: "DetermineComponentFrameRoot" } + ); + var V = P.DetermineComponentFrameRoot(), ar = V[0], Sr = V[1]; + if (ar && Sr) { + var Br = ar.split(` +`), ne = Sr.split(` +`); + for (B = P = 0; P < Br.length && !Br[P].includes("DetermineComponentFrameRoot"); ) + P++; + for (; B < ne.length && !ne[B].includes( + "DetermineComponentFrameRoot" + ); ) + B++; + if (P === Br.length || B === ne.length) + for (P = Br.length - 1, B = ne.length - 1; 1 <= P && 0 <= B && Br[P] !== ne[B]; ) + B--; + for (; 1 <= P && 0 <= B; P--, B--) + if (Br[P] !== ne[B]) { + if (P !== 1 || B !== 1) + do + if (P--, B--, 0 > B || Br[P] !== ne[B]) { + var be = ` +` + Br[P].replace(" at new ", " at "); + return h.displayName && be.includes("") && (be = be.replace("", h.displayName)), be; + } + while (1 <= P && 0 <= B); + break; + } + } + } finally { + Mr = !1, Error.prepareStackTrace = T; + } + return (T = h ? h.displayName || h.name : "") ? Ir(T) : ""; + } + function Tr(h, w) { + switch (h.tag) { + case 26: + case 27: + case 5: + return Ir(h.type); + case 16: + return Ir("Lazy"); + case 13: + return h.child !== w && w !== null ? Ir("Suspense Fallback") : Ir("Suspense"); + case 19: + return Ir("SuspenseList"); + case 0: + case 15: + return Lr(h.type, !1); + case 11: + return Lr(h.type.render, !1); + case 1: + return Lr(h.type, !0); + case 31: + return Ir("Activity"); + default: + return ""; + } + } + function Y(h) { + try { + var w = "", T = null; + do + w += Tr(h, T), T = h, h = h.return; + while (h); + return w; + } catch (P) { + return ` +Error generating stack: ` + P.message + ` +` + P.stack; + } + } + var J = Object.prototype.hasOwnProperty, nr = t.unstable_scheduleCallback, xr = t.unstable_cancelCallback, Er = t.unstable_shouldYield, Pr = t.unstable_requestPaint, Dr = t.unstable_now, Yr = t.unstable_getCurrentPriorityLevel, ie = t.unstable_ImmediatePriority, me = t.unstable_UserBlockingPriority, xe = t.unstable_NormalPriority, Me = t.unstable_LowPriority, Ie = t.unstable_IdlePriority, he = t.log, ee = t.unstable_setDisableYieldValue, wr = null, Ur = null; + function Jr(h) { + if (typeof he == "function" && ee(h), Ur && typeof Ur.setStrictMode == "function") + try { + Ur.setStrictMode(wr, h); + } catch { + } + } + var Qr = Math.clz32 ? Math.clz32 : se, oe = Math.log, Ne = Math.LN2; + function se(h) { + return h >>>= 0, h === 0 ? 32 : 31 - (oe(h) / Ne | 0) | 0; + } + var je = 256, Re = 262144, ze = 4194304; + function Xe(h) { + var w = h & 42; + if (w !== 0) return w; + switch (h & -h) { + case 1: + return 1; + case 2: + return 2; + case 4: + return 4; + case 8: + return 8; + case 16: + return 16; + case 32: + return 32; + case 64: + return 64; + case 128: + return 128; + case 256: + case 512: + case 1024: + case 2048: + case 4096: + case 8192: + case 16384: + case 32768: + case 65536: + case 131072: + return h & 261888; + case 262144: + case 524288: + case 1048576: + case 2097152: + return h & 3932160; + case 4194304: + case 8388608: + case 16777216: + case 33554432: + return h & 62914560; + case 67108864: + return 67108864; + case 134217728: + return 134217728; + case 268435456: + return 268435456; + case 536870912: + return 536870912; + case 1073741824: + return 0; + default: + return h; + } + } + function lt(h, w, T) { + var P = h.pendingLanes; + if (P === 0) return 0; + var B = 0, V = h.suspendedLanes, ar = h.pingedLanes; + h = h.warmLanes; + var Sr = P & 134217727; + return Sr !== 0 ? (P = Sr & ~V, P !== 0 ? B = Xe(P) : (ar &= Sr, ar !== 0 ? B = Xe(ar) : T || (T = Sr & ~h, T !== 0 && (B = Xe(T))))) : (Sr = P & ~V, Sr !== 0 ? B = Xe(Sr) : ar !== 0 ? B = Xe(ar) : T || (T = P & ~h, T !== 0 && (B = Xe(T)))), B === 0 ? 0 : w !== 0 && w !== B && (w & V) === 0 && (V = B & -B, T = w & -w, V >= T || V === 32 && (T & 4194048) !== 0) ? w : B; + } + function Fe(h, w) { + return (h.pendingLanes & ~(h.suspendedLanes & ~h.pingedLanes) & w) === 0; + } + function Pt(h, w) { + switch (h) { + case 1: + case 2: + case 4: + case 8: + case 64: + return w + 250; + case 16: + case 32: + 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 w + 5e3; + case 4194304: + case 8388608: + case 16777216: + case 33554432: + return -1; + case 67108864: + case 134217728: + case 268435456: + case 536870912: + case 1073741824: + return -1; + default: + return -1; + } + } + function Ze() { + var h = ze; + return ze <<= 1, (ze & 62914560) === 0 && (ze = 4194304), h; + } + function Wt(h) { + for (var w = [], T = 0; 31 > T; T++) w.push(h); + return w; + } + function Ut(h, w) { + h.pendingLanes |= w, w !== 268435456 && (h.suspendedLanes = 0, h.pingedLanes = 0, h.warmLanes = 0); + } + function mt(h, w, T, P, B, V) { + var ar = h.pendingLanes; + h.pendingLanes = T, h.suspendedLanes = 0, h.pingedLanes = 0, h.warmLanes = 0, h.expiredLanes &= T, h.entangledLanes &= T, h.errorRecoveryDisabledLanes &= T, h.shellSuspendCounter = 0; + var Sr = h.entanglements, Br = h.expirationTimes, ne = h.hiddenUpdates; + for (T = ar & ~T; 0 < T; ) { + var be = 31 - Qr(T), we = 1 << be; + Sr[be] = 0, Br[be] = -1; + var ae = ne[be]; + if (ae !== null) + for (ne[be] = null, be = 0; be < ae.length; be++) { + var de = ae[be]; + de !== null && (de.lane &= -536870913); + } + T &= ~we; + } + P !== 0 && dt(h, P, 0), V !== 0 && B === 0 && h.tag !== 0 && (h.suspendedLanes |= V & ~(ar & ~w)); + } + function dt(h, w, T) { + h.pendingLanes |= w, h.suspendedLanes &= ~w; + var P = 31 - Qr(w); + h.entangledLanes |= w, h.entanglements[P] = h.entanglements[P] | 1073741824 | T & 261930; + } + function so(h, w) { + var T = h.entangledLanes |= w; + for (h = h.entanglements; T; ) { + var P = 31 - Qr(T), B = 1 << P; + B & w | h[P] & w && (h[P] |= w), T &= ~B; + } + } + function Ft(h, w) { + var T = w & -w; + return T = (T & 42) !== 0 ? 1 : uo(T), (T & (h.suspendedLanes | w)) !== 0 ? 0 : T; + } + function uo(h) { + switch (h) { + case 2: + h = 1; + break; + case 8: + h = 4; + break; + case 32: + h = 16; + break; + 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: + h = 128; + break; + case 268435456: + h = 134217728; + break; + default: + h = 0; + } + return h; + } + function xo(h) { + return h &= -h, 2 < h ? 8 < h ? (h & 134217727) !== 0 ? 32 : 268435456 : 8 : 2; + } + function Eo() { + var h = q.p; + return h !== 0 ? h : (h = window.event, h === void 0 ? 32 : B1(h.type)); + } + function _o(h, w) { + var T = q.p; + try { + return q.p = h, w(); + } finally { + q.p = T; + } + } + var So = Math.random().toString(36).slice(2), lo = "__reactFiber$" + So, zo = "__reactProps$" + So, vn = "__reactContainer$" + So, mo = "__reactEvents$" + So, yo = "__reactListeners$" + So, tn = "__reactHandles$" + So, Sn = "__reactResources$" + So, Lt = "__reactMarker$" + So; + function wa(h) { + delete h[lo], delete h[zo], delete h[mo], delete h[yo], delete h[tn]; + } + function pn(h) { + var w = h[lo]; + if (w) return w; + for (var T = h.parentNode; T; ) { + if (w = T[vn] || T[lo]) { + if (T = w.alternate, w.child !== null || T !== null && T.child !== null) + for (h = x1(h); h !== null; ) { + if (T = h[lo]) return T; + h = x1(h); + } + return w; + } + h = T, T = h.parentNode; + } + return null; + } + function Ue(h) { + if (h = h[lo] || h[vn]) { + var w = h.tag; + if (w === 5 || w === 6 || w === 13 || w === 31 || w === 26 || w === 27 || w === 3) + return h; + } + return null; + } + function ht(h) { + var w = h.tag; + if (w === 5 || w === 26 || w === 27 || w === 6) return h.stateNode; + throw Error(o(33)); + } + function on(h) { + var w = h[Sn]; + return w || (w = h[Sn] = { hoistableStyles: /* @__PURE__ */ new Map(), hoistableScripts: /* @__PURE__ */ new Map() }), w; + } + function Yo(h) { + h[Lt] = !0; + } + var wc = /* @__PURE__ */ new Set(), Ga = {}; + function zn(h, w) { + Xt(h, w), Xt(h + "Capture", w); + } + function Xt(h, w) { + for (Ga[h] = w, h = 0; h < w.length; h++) + wc.add(w[h]); + } + var jt = RegExp( + "^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$" + ), la = {}, Zc = {}; + function El(h) { + return J.call(Zc, h) ? !0 : J.call(la, h) ? !1 : jt.test(h) ? Zc[h] = !0 : (la[h] = !0, !1); + } + function xa(h, w, T) { + if (El(w)) + if (T === null) h.removeAttribute(w); + else { + switch (typeof T) { + case "undefined": + case "function": + case "symbol": + h.removeAttribute(w); + return; + case "boolean": + var P = w.toLowerCase().slice(0, 5); + if (P !== "data-" && P !== "aria-") { + h.removeAttribute(w); + return; + } + } + h.setAttribute(w, "" + T); + } + } + function Kc(h, w, T) { + if (T === null) h.removeAttribute(w); + else { + switch (typeof T) { + case "undefined": + case "function": + case "symbol": + case "boolean": + h.removeAttribute(w); + return; + } + h.setAttribute(w, "" + T); + } + } + function Bo(h, w, T, P) { + if (P === null) h.removeAttribute(T); + else { + switch (typeof P) { + case "undefined": + case "function": + case "symbol": + case "boolean": + h.removeAttribute(T); + return; + } + h.setAttributeNS(w, T, "" + P); + } + } + function Bn(h) { + switch (typeof h) { + case "bigint": + case "boolean": + case "number": + case "string": + case "undefined": + return h; + case "object": + return h; + default: + return ""; + } + } + function Un(h) { + var w = h.type; + return (h = h.nodeName) && h.toLowerCase() === "input" && (w === "checkbox" || w === "radio"); + } + function Gs(h, w, T) { + var P = Object.getOwnPropertyDescriptor( + h.constructor.prototype, + w + ); + if (!h.hasOwnProperty(w) && typeof P < "u" && typeof P.get == "function" && typeof P.set == "function") { + var B = P.get, V = P.set; + return Object.defineProperty(h, w, { + configurable: !0, + get: function() { + return B.call(this); + }, + set: function(ar) { + T = "" + ar, V.call(this, ar); + } + }), Object.defineProperty(h, w, { + enumerable: P.enumerable + }), { + getValue: function() { + return T; + }, + setValue: function(ar) { + T = "" + ar; + }, + stopTracking: function() { + h._valueTracker = null, delete h[w]; + } + }; + } + } + function Sl(h) { + if (!h._valueTracker) { + var w = Un(h) ? "checked" : "value"; + h._valueTracker = Gs( + h, + w, + "" + h[w] + ); + } + } + function da(h) { + if (!h) return !1; + var w = h._valueTracker; + if (!w) return !0; + var T = w.getValue(), P = ""; + return h && (P = Un(h) ? h.checked ? "true" : "false" : h.value), h = P, h !== T ? (w.setValue(h), !0) : !1; + } + function os(h) { + if (h = h || (typeof document < "u" ? document : void 0), typeof h > "u") return null; + try { + return h.activeElement || h.body; + } catch { + return h.body; + } + } + var Hg = /[\n"\\]/g; + function oi(h) { + return h.replace( + Hg, + function(w) { + return "\\" + w.charCodeAt(0).toString(16) + " "; + } + ); + } + function ns(h, w, T, P, B, V, ar, Sr) { + h.name = "", ar != null && typeof ar != "function" && typeof ar != "symbol" && typeof ar != "boolean" ? h.type = ar : h.removeAttribute("type"), w != null ? ar === "number" ? (w === 0 && h.value === "" || h.value != w) && (h.value = "" + Bn(w)) : h.value !== "" + Bn(w) && (h.value = "" + Bn(w)) : ar !== "submit" && ar !== "reset" || h.removeAttribute("value"), w != null ? pu(h, ar, Bn(w)) : T != null ? pu(h, ar, Bn(T)) : P != null && h.removeAttribute("value"), B == null && V != null && (h.defaultChecked = !!V), B != null && (h.checked = B && typeof B != "function" && typeof B != "symbol"), Sr != null && typeof Sr != "function" && typeof Sr != "symbol" && typeof Sr != "boolean" ? h.name = "" + Bn(Sr) : h.removeAttribute("name"); + } + function as(h, w, T, P, B, V, ar, Sr) { + if (V != null && typeof V != "function" && typeof V != "symbol" && typeof V != "boolean" && (h.type = V), w != null || T != null) { + if (!(V !== "submit" && V !== "reset" || w != null)) { + Sl(h); + return; + } + T = T != null ? "" + Bn(T) : "", w = w != null ? "" + Bn(w) : T, Sr || w === h.value || (h.value = w), h.defaultValue = w; + } + P = P ?? B, P = typeof P != "function" && typeof P != "symbol" && !!P, h.checked = Sr ? h.checked : !!P, h.defaultChecked = !!P, ar != null && typeof ar != "function" && typeof ar != "symbol" && typeof ar != "boolean" && (h.name = ar), Sl(h); + } + function pu(h, w, T) { + w === "number" && os(h.ownerDocument) === h || h.defaultValue === "" + T || (h.defaultValue = "" + T); + } + function Qn(h, w, T, P) { + if (h = h.options, w) { + w = {}; + for (var B = 0; B < T.length; B++) + w["$" + T[B]] = !0; + for (T = 0; T < h.length; T++) + B = w.hasOwnProperty("$" + h[T].value), h[T].selected !== B && (h[T].selected = B), B && P && (h[T].defaultSelected = !0); + } else { + for (T = "" + Bn(T), w = null, B = 0; B < h.length; B++) { + if (h[B].value === T) { + h[B].selected = !0, P && (h[B].defaultSelected = !0); + return; + } + w !== null || h[B].disabled || (w = h[B]); + } + w !== null && (w.selected = !0); + } + } + function ku(h, w, T) { + if (w != null && (w = "" + Bn(w), w !== h.value && (h.value = w), T == null)) { + h.defaultValue !== w && (h.defaultValue = w); + return; + } + h.defaultValue = T != null ? "" + Bn(T) : ""; + } + function Va(h, w, T, P) { + if (w == null) { + if (P != null) { + if (T != null) throw Error(o(92)); + if (F(P)) { + if (1 < P.length) throw Error(o(93)); + P = P[0]; + } + T = P; + } + T == null && (T = ""), w = T; + } + T = Bn(w), h.defaultValue = T, P = h.textContent, P === T && P !== "" && P !== null && (h.value = P), Sl(h); + } + function Ji(h, w) { + if (w) { + var T = h.firstChild; + if (T && T === h.lastChild && T.nodeType === 3) { + T.nodeValue = w; + return; + } + } + h.textContent = w; + } + var og = new Set( + "animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split( + " " + ) + ); + function xc(h, w, T) { + var P = w.indexOf("--") === 0; + T == null || typeof T == "boolean" || T === "" ? P ? h.setProperty(w, "") : w === "float" ? h.cssFloat = "" : h[w] = "" : P ? h.setProperty(w, T) : typeof T != "number" || T === 0 || og.has(w) ? w === "float" ? h.cssFloat = T : h[w] = ("" + T).trim() : h[w] = T + "px"; + } + function Vs(h, w, T) { + if (w != null && typeof w != "object") + throw Error(o(62)); + if (h = h.style, T != null) { + for (var P in T) + !T.hasOwnProperty(P) || w != null && w.hasOwnProperty(P) || (P.indexOf("--") === 0 ? h.setProperty(P, "") : P === "float" ? h.cssFloat = "" : h[P] = ""); + for (var B in w) + P = w[B], w.hasOwnProperty(B) && T[B] !== P && xc(h, B, P); + } else + for (var V in w) + w.hasOwnProperty(V) && xc(h, V, w[V]); + } + function is(h) { + if (h.indexOf("-") === -1) return !1; + switch (h) { + case "annotation-xml": + case "color-profile": + case "font-face": + case "font-face-src": + case "font-face-uri": + case "font-face-format": + case "font-face-name": + case "missing-glyph": + return !1; + default: + return !0; + } + } + var nn = /* @__PURE__ */ new Map([ + ["acceptCharset", "accept-charset"], + ["htmlFor", "for"], + ["httpEquiv", "http-equiv"], + ["crossOrigin", "crossorigin"], + ["accentHeight", "accent-height"], + ["alignmentBaseline", "alignment-baseline"], + ["arabicForm", "arabic-form"], + ["baselineShift", "baseline-shift"], + ["capHeight", "cap-height"], + ["clipPath", "clip-path"], + ["clipRule", "clip-rule"], + ["colorInterpolation", "color-interpolation"], + ["colorInterpolationFilters", "color-interpolation-filters"], + ["colorProfile", "color-profile"], + ["colorRendering", "color-rendering"], + ["dominantBaseline", "dominant-baseline"], + ["enableBackground", "enable-background"], + ["fillOpacity", "fill-opacity"], + ["fillRule", "fill-rule"], + ["floodColor", "flood-color"], + ["floodOpacity", "flood-opacity"], + ["fontFamily", "font-family"], + ["fontSize", "font-size"], + ["fontSizeAdjust", "font-size-adjust"], + ["fontStretch", "font-stretch"], + ["fontStyle", "font-style"], + ["fontVariant", "font-variant"], + ["fontWeight", "font-weight"], + ["glyphName", "glyph-name"], + ["glyphOrientationHorizontal", "glyph-orientation-horizontal"], + ["glyphOrientationVertical", "glyph-orientation-vertical"], + ["horizAdvX", "horiz-adv-x"], + ["horizOriginX", "horiz-origin-x"], + ["imageRendering", "image-rendering"], + ["letterSpacing", "letter-spacing"], + ["lightingColor", "lighting-color"], + ["markerEnd", "marker-end"], + ["markerMid", "marker-mid"], + ["markerStart", "marker-start"], + ["overlinePosition", "overline-position"], + ["overlineThickness", "overline-thickness"], + ["paintOrder", "paint-order"], + ["panose-1", "panose-1"], + ["pointerEvents", "pointer-events"], + ["renderingIntent", "rendering-intent"], + ["shapeRendering", "shape-rendering"], + ["stopColor", "stop-color"], + ["stopOpacity", "stop-opacity"], + ["strikethroughPosition", "strikethrough-position"], + ["strikethroughThickness", "strikethrough-thickness"], + ["strokeDasharray", "stroke-dasharray"], + ["strokeDashoffset", "stroke-dashoffset"], + ["strokeLinecap", "stroke-linecap"], + ["strokeLinejoin", "stroke-linejoin"], + ["strokeMiterlimit", "stroke-miterlimit"], + ["strokeOpacity", "stroke-opacity"], + ["strokeWidth", "stroke-width"], + ["textAnchor", "text-anchor"], + ["textDecoration", "text-decoration"], + ["textRendering", "text-rendering"], + ["transformOrigin", "transform-origin"], + ["underlinePosition", "underline-position"], + ["underlineThickness", "underline-thickness"], + ["unicodeBidi", "unicode-bidi"], + ["unicodeRange", "unicode-range"], + ["unitsPerEm", "units-per-em"], + ["vAlphabetic", "v-alphabetic"], + ["vHanging", "v-hanging"], + ["vIdeographic", "v-ideographic"], + ["vMathematical", "v-mathematical"], + ["vectorEffect", "vector-effect"], + ["vertAdvY", "vert-adv-y"], + ["vertOriginX", "vert-origin-x"], + ["vertOriginY", "vert-origin-y"], + ["wordSpacing", "word-spacing"], + ["writingMode", "writing-mode"], + ["xmlnsXlink", "xmlns:xlink"], + ["xHeight", "x-height"] + ]), Qc = /^[\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; + function dd(h) { + return Qc.test("" + h) ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')" : h; + } + function Jc() { + } + var cs = null; + function mu(h) { + return h = h.target || h.srcElement || window, h.correspondingUseElement && (h = h.correspondingUseElement), h.nodeType === 3 ? h.parentNode : h; + } + var Ol = null, Ci = null; + function Ri(h) { + var w = Ue(h); + if (w && (h = w.stateNode)) { + var T = h[zo] || null; + r: switch (h = w.stateNode, w.type) { + case "input": + if (ns( + h, + T.value, + T.defaultValue, + T.defaultValue, + T.checked, + T.defaultChecked, + T.type, + T.name + ), w = T.name, T.type === "radio" && w != null) { + for (T = h; T.parentNode; ) T = T.parentNode; + for (T = T.querySelectorAll( + 'input[name="' + oi( + "" + w + ) + '"][type="radio"]' + ), w = 0; w < T.length; w++) { + var P = T[w]; + if (P !== h && P.form === h.form) { + var B = P[zo] || null; + if (!B) throw Error(o(90)); + ns( + P, + B.value, + B.defaultValue, + B.defaultValue, + B.checked, + B.defaultChecked, + B.type, + B.name + ); + } + } + for (w = 0; w < T.length; w++) + P = T[w], P.form === h.form && da(P); + } + break r; + case "textarea": + ku(h, T.value, T.defaultValue); + break r; + case "select": + w = T.value, w != null && Qn(h, !!T.multiple, w, !1); + } + } + } + var ng = !1; + function yu(h, w, T) { + if (ng) return h(w, T); + ng = !0; + try { + var P = h(w); + return P; + } finally { + if (ng = !1, (Ol !== null || Ci !== null) && (K0(), Ol && (w = Ol, h = Ci, Ci = Ol = null, Ri(w), h))) + for (w = 0; w < h.length; w++) Ri(h[w]); + } + } + function Tl(h, w) { + var T = h.stateNode; + if (T === null) return null; + var P = T[zo] || null; + if (P === null) return null; + T = P[w]; + r: switch (w) { + case "onClick": + case "onClickCapture": + case "onDoubleClick": + case "onDoubleClickCapture": + case "onMouseDown": + case "onMouseDownCapture": + case "onMouseMove": + case "onMouseMoveCapture": + case "onMouseUp": + case "onMouseUpCapture": + case "onMouseEnter": + (P = !P.disabled) || (h = h.type, P = !(h === "button" || h === "input" || h === "select" || h === "textarea")), h = !P; + break r; + default: + h = !1; + } + if (h) return null; + if (T && typeof T != "function") + throw Error( + o(231, w, typeof T) + ); + return T; + } + var pi = !(typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u"), sd = !1; + if (pi) + try { + var ls = {}; + Object.defineProperty(ls, "passive", { + get: function() { + sd = !0; + } + }), window.addEventListener("test", ls, ls), window.removeEventListener("test", ls, ls); + } catch { + sd = !1; + } + var $i = null, _c = null, Uo = null; + function $t() { + if (Uo) return Uo; + var h, w = _c, T = w.length, P, B = "value" in $i ? $i.value : $i.textContent, V = B.length; + for (h = 0; h < T && w[h] === B[h]; h++) ; + var ar = T - h; + for (P = 1; P <= ar && w[T - P] === B[V - P]; P++) ; + return Uo = B.slice(h, 1 < P ? 1 - P : void 0); + } + function ds(h) { + var w = h.keyCode; + return "charCode" in h ? (h = h.charCode, h === 0 && w === 13 && (h = 13)) : h = w, h === 10 && (h = 13), 32 <= h || h === 13 ? h : 0; + } + function Ec() { + return !0; + } + function Hs() { + return !1; + } + function Ma(h) { + function w(T, P, B, V, ar) { + this._reactName = T, this._targetInst = B, this.type = P, this.nativeEvent = V, this.target = ar, this.currentTarget = null; + for (var Sr in h) + h.hasOwnProperty(Sr) && (T = h[Sr], this[Sr] = T ? T(V) : V[Sr]); + return this.isDefaultPrevented = (V.defaultPrevented != null ? V.defaultPrevented : V.returnValue === !1) ? Ec : Hs, this.isPropagationStopped = Hs, this; + } + return u(w.prototype, { + preventDefault: function() { + this.defaultPrevented = !0; + var T = this.nativeEvent; + T && (T.preventDefault ? T.preventDefault() : typeof T.returnValue != "unknown" && (T.returnValue = !1), this.isDefaultPrevented = Ec); + }, + stopPropagation: function() { + var T = this.nativeEvent; + T && (T.stopPropagation ? T.stopPropagation() : typeof T.cancelBubble != "unknown" && (T.cancelBubble = !0), this.isPropagationStopped = Ec); + }, + persist: function() { + }, + isPersistent: Ec + }), w; + } + var ud = { + eventPhase: 0, + bubbles: 0, + cancelable: 0, + timeStamp: function(h) { + return h.timeStamp || Date.now(); + }, + defaultPrevented: 0, + isTrusted: 0 + }, wu = Ma(ud), ss = u({}, ud, { view: 0, detail: 0 }), gd = Ma(ss), On, us, sa, Al = u({}, ss, { + screenX: 0, + screenY: 0, + clientX: 0, + clientY: 0, + pageX: 0, + pageY: 0, + ctrlKey: 0, + shiftKey: 0, + altKey: 0, + metaKey: 0, + getModifierState: gs, + button: 0, + buttons: 0, + relatedTarget: function(h) { + return h.relatedTarget === void 0 ? h.fromElement === h.srcElement ? h.toElement : h.fromElement : h.relatedTarget; + }, + movementX: function(h) { + return "movementX" in h ? h.movementX : (h !== sa && (sa && h.type === "mousemove" ? (On = h.screenX - sa.screenX, us = h.screenY - sa.screenY) : us = On = 0, sa = h), On); + }, + movementY: function(h) { + return "movementY" in h ? h.movementY : us; + } + }), xu = Ma(Al), _a = u({}, Al, { dataTransfer: 0 }), Ea = Ma(_a), Cl = u({}, ss, { relatedTarget: 0 }), ki = Ma(Cl), rc = u({}, ud, { + animationName: 0, + elapsedTime: 0, + pseudoElement: 0 + }), ce = Ma(rc), _e = u({}, ud, { + clipboardData: function(h) { + return "clipboardData" in h ? h.clipboardData : window.clipboardData; + } + }), fe = Ma(_e), Ye = u({}, ud, { data: 0 }), at = Ma(Ye), Oo = { + Esc: "Escape", + Spacebar: " ", + Left: "ArrowLeft", + Up: "ArrowUp", + Right: "ArrowRight", + Down: "ArrowDown", + Del: "Delete", + Win: "OS", + Menu: "ContextMenu", + Apps: "ContextMenu", + Scroll: "ScrollLock", + MozPrintableKey: "Unidentified" + }, ua = { + 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" + }, Ha = { + Alt: "altKey", + Control: "ctrlKey", + Meta: "metaKey", + Shift: "shiftKey" + }; + function Jo(h) { + var w = this.nativeEvent; + return w.getModifierState ? w.getModifierState(h) : (h = Ha[h]) ? !!w[h] : !1; + } + function gs() { + return Jo; + } + var Tn = u({}, ss, { + key: function(h) { + if (h.key) { + var w = Oo[h.key] || h.key; + if (w !== "Unidentified") return w; + } + return h.type === "keypress" ? (h = ds(h), h === 13 ? "Enter" : String.fromCharCode(h)) : h.type === "keydown" || h.type === "keyup" ? ua[h.keyCode] || "Unidentified" : ""; + }, + code: 0, + location: 0, + ctrlKey: 0, + shiftKey: 0, + altKey: 0, + metaKey: 0, + repeat: 0, + locale: 0, + getModifierState: gs, + charCode: function(h) { + return h.type === "keypress" ? ds(h) : 0; + }, + keyCode: function(h) { + return h.type === "keydown" || h.type === "keyup" ? h.keyCode : 0; + }, + which: function(h) { + return h.type === "keypress" ? ds(h) : h.type === "keydown" || h.type === "keyup" ? h.keyCode : 0; + } + }), Sa = Ma(Tn), _u = u({}, Al, { + pointerId: 0, + width: 0, + height: 0, + pressure: 0, + tangentialPressure: 0, + tiltX: 0, + tiltY: 0, + twist: 0, + pointerType: 0, + isPrimary: 0 + }), jh = Ma(_u), bd = u({}, ss, { + touches: 0, + targetTouches: 0, + changedTouches: 0, + altKey: 0, + metaKey: 0, + ctrlKey: 0, + shiftKey: 0, + getModifierState: gs + }), Wg = Ma(bd), Yg = u({}, ud, { + propertyName: 0, + elapsedTime: 0, + pseudoElement: 0 + }), qo = Ma(Yg), zh = u({}, Al, { + deltaX: function(h) { + return "deltaX" in h ? h.deltaX : "wheelDeltaX" in h ? -h.wheelDeltaX : 0; + }, + deltaY: function(h) { + return "deltaY" in h ? h.deltaY : "wheelDeltaY" in h ? -h.wheelDeltaY : "wheelDelta" in h ? -h.wheelDelta : 0; + }, + deltaZ: 0, + deltaMode: 0 + }), ag = Ma(zh), hd = u({}, ud, { + newState: 0, + oldState: 0 + }), Bh = Ma(hd), ig = [9, 13, 27, 32], Eu = pi && "CompositionEvent" in window, $c = null; + pi && "documentMode" in document && ($c = document.documentMode); + var Rl = pi && "TextEvent" in window && !$c, Ws = pi && (!Eu || $c && 8 < $c && 11 >= $c), Gb = " ", bs = !1; + function cg(h, w) { + switch (h) { + case "keyup": + return ig.indexOf(w.keyCode) !== -1; + case "keydown": + return w.keyCode !== 229; + case "keypress": + case "mousedown": + case "focusout": + return !0; + default: + return !1; + } + } + function Ys(h) { + return h = h.detail, typeof h == "object" && "data" in h ? h.data : null; + } + var Pl = !1; + function Pi(h, w) { + switch (h) { + case "compositionend": + return Ys(w); + case "keypress": + return w.which !== 32 ? null : (bs = !0, Gb); + case "textInput": + return h = w.data, h === Gb && bs ? null : h; + default: + return null; + } + } + function Xs(h, w) { + if (Pl) + return h === "compositionend" || !Eu && cg(h, w) ? (h = $t(), Uo = _c = $i = null, Pl = !1, h) : null; + switch (h) { + case "paste": + return null; + case "keypress": + if (!(w.ctrlKey || w.altKey || w.metaKey) || w.ctrlKey && w.altKey) { + if (w.char && 1 < w.char.length) + return w.char; + if (w.which) return String.fromCharCode(w.which); + } + return null; + case "compositionend": + return Ws && w.locale !== "ko" ? null : w.data; + default: + return null; + } + } + var rl = { + color: !0, + date: !0, + datetime: !0, + "datetime-local": !0, + email: !0, + month: !0, + number: !0, + password: !0, + range: !0, + search: !0, + tel: !0, + text: !0, + time: !0, + url: !0, + week: !0 + }; + function Su(h) { + var w = h && h.nodeName && h.nodeName.toLowerCase(); + return w === "input" ? !!rl[h.type] : w === "textarea"; + } + function Vb(h, w, T, P) { + Ol ? Ci ? Ci.push(P) : Ci = [P] : Ol = P, w = Dv(w, "onChange"), 0 < w.length && (T = new wu( + "onChange", + "change", + null, + T, + P + ), h.push({ event: T, listeners: w })); + } + var lg = null, dg = null; + function Xg(h) { + b1(h, 0); + } + function hs(h) { + var w = ht(h); + if (da(w)) return h; + } + function sg(h, w) { + if (h === "change") return w; + } + var Zs = !1; + if (pi) { + var Zg; + if (pi) { + var Hb = "oninput" in document; + if (!Hb) { + var Ou = document.createElement("div"); + Ou.setAttribute("oninput", "return;"), Hb = typeof Ou.oninput == "function"; + } + Zg = Hb; + } else Zg = !1; + Zs = Zg && (!document.documentMode || 9 < document.documentMode); + } + function Fn() { + lg && (lg.detachEvent("onpropertychange", kn), dg = lg = null); + } + function kn(h) { + if (h.propertyName === "value" && hs(dg)) { + var w = []; + Vb( + w, + dg, + h, + mu(h) + ), yu(Xg, w); + } + } + function ug(h, w, T) { + h === "focusin" ? (Fn(), lg = w, dg = T, lg.attachEvent("onpropertychange", kn)) : h === "focusout" && Fn(); + } + function Uh(h) { + if (h === "selectionchange" || h === "keyup" || h === "keydown") + return hs(dg); + } + function gg(h, w) { + if (h === "click") return hs(w); + } + function hv(h, w) { + if (h === "input" || h === "change") + return hs(w); + } + function fd(h, w) { + return h === w && (h !== 0 || 1 / h === 1 / w) || h !== h && w !== w; + } + var an = typeof Object.is == "function" ? Object.is : fd; + function fs(h, w) { + if (an(h, w)) return !0; + if (typeof h != "object" || h === null || typeof w != "object" || w === null) + return !1; + var T = Object.keys(h), P = Object.keys(w); + if (T.length !== P.length) return !1; + for (P = 0; P < T.length; P++) { + var B = T[P]; + if (!J.call(w, B) || !an(h[B], w[B])) + return !1; + } + return !0; + } + function Ks(h) { + for (; h && h.firstChild; ) h = h.firstChild; + return h; + } + function Tu(h, w) { + var T = Ks(h); + h = 0; + for (var P; T; ) { + if (T.nodeType === 3) { + if (P = h + T.textContent.length, h <= w && P >= w) + return { node: T, offset: w - h }; + h = P; + } + r: { + for (; T; ) { + if (T.nextSibling) { + T = T.nextSibling; + break r; + } + T = T.parentNode; + } + T = void 0; + } + T = Ks(T); + } + } + function Au(h, w) { + return h && w ? h === w ? !0 : h && h.nodeType === 3 ? !1 : w && w.nodeType === 3 ? Au(h, w.parentNode) : "contains" in h ? h.contains(w) : h.compareDocumentPosition ? !!(h.compareDocumentPosition(w) & 16) : !1 : !1; + } + function Qs(h) { + h = h != null && h.ownerDocument != null && h.ownerDocument.defaultView != null ? h.ownerDocument.defaultView : window; + for (var w = os(h.document); w instanceof h.HTMLIFrameElement; ) { + try { + var T = typeof w.contentWindow.location.href == "string"; + } catch { + T = !1; + } + if (T) h = w.contentWindow; + else break; + w = os(h.document); + } + return w; + } + function el(h) { + var w = h && h.nodeName && h.nodeName.toLowerCase(); + return w && (w === "input" && (h.type === "text" || h.type === "search" || h.type === "tel" || h.type === "url" || h.type === "password") || w === "textarea" || h.contentEditable === "true"); + } + var vs = pi && "documentMode" in document && 11 >= document.documentMode, Wr = null, ue = null, le = null, Qe = !1; + function Mt(h, w, T) { + var P = T.window === T ? T.document : T.nodeType === 9 ? T : T.ownerDocument; + Qe || Wr == null || Wr !== os(P) || (P = Wr, "selectionStart" in P && el(P) ? P = { start: P.selectionStart, end: P.selectionEnd } : (P = (P.ownerDocument && P.ownerDocument.defaultView || window).getSelection(), P = { + anchorNode: P.anchorNode, + anchorOffset: P.anchorOffset, + focusNode: P.focusNode, + focusOffset: P.focusOffset + }), le && fs(le, P) || (le = P, P = Dv(ue, "onSelect"), 0 < P.length && (w = new wu( + "onSelect", + "select", + null, + w, + T + ), h.push({ event: w, listeners: P }), w.target = Wr))); + } + function ro(h, w) { + var T = {}; + return T[h.toLowerCase()] = w.toLowerCase(), T["Webkit" + h] = "webkit" + w, T["Moz" + h] = "moz" + w, T; + } + var sn = { + animationend: ro("Animation", "AnimationEnd"), + animationiteration: ro("Animation", "AnimationIteration"), + animationstart: ro("Animation", "AnimationStart"), + transitionrun: ro("Transition", "TransitionRun"), + transitionstart: ro("Transition", "TransitionStart"), + transitioncancel: ro("Transition", "TransitionCancel"), + transitionend: ro("Transition", "TransitionEnd") + }, yr = {}, vd = {}; + pi && (vd = document.createElement("div").style, "AnimationEvent" in window || (delete sn.animationend.animation, delete sn.animationiteration.animation, delete sn.animationstart.animation), "TransitionEvent" in window || delete sn.transitionend.transition); + function ec(h) { + if (yr[h]) return yr[h]; + if (!sn[h]) return h; + var w = sn[h], T; + for (T in w) + if (w.hasOwnProperty(T) && T in vd) + return yr[h] = w[T]; + return h; + } + var An = ec("animationend"), io = ec("animationiteration"), pd = ec("animationstart"), ni = ec("transitionrun"), Sc = ec("transitionstart"), Ml = ec("transitioncancel"), eo = ec("transitionend"), Kg = /* @__PURE__ */ new Map(), Cu = "abort auxClick beforeToggle 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( + " " + ); + Cu.push("scrollEnd"); + function Mi(h, w) { + Kg.set(h, w), zn(w, [h]); + } + var Qg = typeof reportError == "function" ? reportError : function(h) { + if (typeof window == "object" && typeof window.ErrorEvent == "function") { + var w = new window.ErrorEvent("error", { + bubbles: !0, + cancelable: !0, + message: typeof h == "object" && h !== null && typeof h.message == "string" ? String(h.message) : String(h), + error: h + }); + if (!window.dispatchEvent(w)) return; + } else if (typeof process == "object" && typeof process.emit == "function") { + process.emit("uncaughtException", h); + return; + } + console.error(h); + }, Ii = [], Il = 0, kd = 0; + function tl() { + for (var h = Il, w = kd = Il = 0; w < h; ) { + var T = Ii[w]; + Ii[w++] = null; + var P = Ii[w]; + Ii[w++] = null; + var B = Ii[w]; + Ii[w++] = null; + var V = Ii[w]; + if (Ii[w++] = null, P !== null && B !== null) { + var ar = P.pending; + ar === null ? B.next = B : (B.next = ar.next, ar.next = B), P.pending = B; + } + V !== 0 && md(T, B, V); + } + } + function ps(h, w, T, P) { + Ii[Il++] = h, Ii[Il++] = w, Ii[Il++] = T, Ii[Il++] = P, kd |= P, h.lanes |= P, h = h.alternate, h !== null && (h.lanes |= P); + } + function Oc(h, w, T, P) { + return ps(h, w, T, P), ai(h); + } + function Tc(h, w) { + return ps(h, null, null, w), ai(h); + } + function md(h, w, T) { + h.lanes |= T; + var P = h.alternate; + P !== null && (P.lanes |= T); + for (var B = !1, V = h.return; V !== null; ) + V.childLanes |= T, P = V.alternate, P !== null && (P.childLanes |= T), V.tag === 22 && (h = V.stateNode, h === null || h._visibility & 1 || (B = !0)), h = V, V = V.return; + return h.tag === 3 ? (V = h.stateNode, B && w !== null && (B = 31 - Qr(T), h = V.hiddenUpdates, P = h[B], P === null ? h[B] = [w] : P.push(w), w.lane = T | 536870912), V) : null; + } + function ai(h) { + if (50 < Tv) + throw Tv = 0, Hk = null, Error(o(185)); + for (var w = h.return; w !== null; ) + h = w, w = h.return; + return h.tag === 3 ? h.stateNode : null; + } + var Dl = {}; + function Wb(h, w, T, P) { + this.tag = h, this.key = T, this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null, this.index = 0, this.refCleanup = this.ref = null, this.pendingProps = w, this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null, this.mode = P, this.subtreeFlags = this.flags = 0, this.deletions = null, this.childLanes = this.lanes = 0, this.alternate = null; + } + function Jn(h, w, T, P) { + return new Wb(h, w, T, P); + } + function Wa(h) { + return h = h.prototype, !(!h || !h.isReactComponent); + } + function Di(h, w) { + var T = h.alternate; + return T === null ? (T = Jn( + h.tag, + w, + h.key, + h.mode + ), T.elementType = h.elementType, T.type = h.type, T.stateNode = h.stateNode, T.alternate = h, h.alternate = T) : (T.pendingProps = w, T.type = h.type, T.flags = 0, T.subtreeFlags = 0, T.deletions = null), T.flags = h.flags & 65011712, T.childLanes = h.childLanes, T.lanes = h.lanes, T.child = h.child, T.memoizedProps = h.memoizedProps, T.memoizedState = h.memoizedState, T.updateQueue = h.updateQueue, w = h.dependencies, T.dependencies = w === null ? null : { lanes: w.lanes, firstContext: w.firstContext }, T.sibling = h.sibling, T.index = h.index, T.ref = h.ref, T.refCleanup = h.refCleanup, T; + } + function Fh(h, w) { + h.flags &= 65011714; + var T = h.alternate; + return T === null ? (h.childLanes = 0, h.lanes = w, h.child = null, h.subtreeFlags = 0, h.memoizedProps = null, h.memoizedState = null, h.updateQueue = null, h.dependencies = null, h.stateNode = null) : (h.childLanes = T.childLanes, h.lanes = T.lanes, h.child = T.child, h.subtreeFlags = 0, h.deletions = null, h.memoizedProps = T.memoizedProps, h.memoizedState = T.memoizedState, h.updateQueue = T.updateQueue, h.type = T.type, w = T.dependencies, h.dependencies = w === null ? null : { + lanes: w.lanes, + firstContext: w.firstContext + }), h; + } + function ks(h, w, T, P, B, V) { + var ar = 0; + if (P = h, typeof h == "function") Wa(h) && (ar = 1); + else if (typeof h == "string") + ar = V3( + h, + T, + or.current + ) ? 26 : h === "html" || h === "head" || h === "body" ? 27 : 5; + else + r: switch (h) { + case R: + return h = Jn(31, T, w, B), h.elementType = R, h.lanes = V, h; + case v: + return ms(T.children, B, V, w); + case p: + ar = 8, B |= 24; + break; + case m: + return h = Jn(12, T, w, B | 2), h.elementType = m, h.lanes = V, h; + case _: + return h = Jn(13, T, w, B), h.elementType = _, h.lanes = V, h; + case S: + return h = Jn(19, T, w, B), h.elementType = S, h.lanes = V, h; + default: + if (typeof h == "object" && h !== null) + switch (h.$$typeof) { + case k: + ar = 10; + break r; + case y: + ar = 9; + break r; + case x: + ar = 11; + break r; + case E: + ar = 14; + break r; + case O: + ar = 16, P = null; + break r; + } + ar = 29, T = Error( + o(130, h === null ? "null" : typeof h, "") + ), P = null; + } + return w = Jn(ar, T, w, B), w.elementType = h, w.type = P, w.lanes = V, w; + } + function ms(h, w, T, P) { + return h = Jn(7, h, P, w), h.lanes = T, h; + } + function qn(h, w, T) { + return h = Jn(6, h, null, w), h.lanes = T, h; + } + function tc(h) { + var w = Jn(18, null, null, 0); + return w.stateNode = h, w; + } + function Ru(h, w, T) { + return w = Jn( + 4, + h.children !== null ? h.children : [], + h.key, + w + ), w.lanes = T, w.stateNode = { + containerInfo: h.containerInfo, + pendingChildren: null, + implementation: h.implementation + }, w; + } + var ol = /* @__PURE__ */ new WeakMap(); + function ga(h, w) { + if (typeof h == "object" && h !== null) { + var T = ol.get(h); + return T !== void 0 ? T : (w = { + value: h, + source: w, + stack: Y(w) + }, ol.set(h, w), w); + } + return { + value: h, + source: w, + stack: Y(w) + }; + } + var yd = [], Ac = 0, Nn = null, To = 0, Ni = [], Li = 0, $n = null, oc = 1, Ya = ""; + function Xa(h, w) { + yd[Ac++] = To, yd[Ac++] = Nn, Nn = h, To = w; + } + function wd(h, w, T) { + Ni[Li++] = oc, Ni[Li++] = Ya, Ni[Li++] = $n, $n = h; + var P = oc; + h = Ya; + var B = 32 - Qr(P) - 1; + P &= ~(1 << B), T += 1; + var V = 32 - Qr(w) + B; + if (30 < V) { + var ar = B - B % 5; + V = (P & (1 << ar) - 1).toString(32), P >>= ar, B -= ar, oc = 1 << 32 - Qr(w) + B | T << B | P, Ya = V + h; + } else + oc = 1 << V | T << B | P, Ya = h; + } + function nl(h) { + h.return !== null && (Xa(h, 1), wd(h, 1, 0)); + } + function ys(h) { + for (; h === Nn; ) + Nn = yd[--Ac], yd[Ac] = null, To = yd[--Ac], yd[Ac] = null; + for (; h === $n; ) + $n = Ni[--Li], Ni[Li] = null, Ya = Ni[--Li], Ni[Li] = null, oc = Ni[--Li], Ni[Li] = null; + } + function ws(h, w) { + Ni[Li++] = oc, Ni[Li++] = Ya, Ni[Li++] = $n, oc = w.id, Ya = w.overflow, $n = h; + } + var Cn = null, Mo = null, vo = !1, Nl = null, nc = !1, Pu = Error(o(519)); + function xd(h) { + var w = Error( + o( + 418, + 1 < arguments.length && arguments[1] !== void 0 && arguments[1] ? "text" : "HTML", + "" + ) + ); + throw al(ga(w, h)), Pu; + } + function xs(h) { + var w = h.stateNode, T = h.type, P = h.memoizedProps; + switch (w[lo] = h, w[zo] = P, T) { + case "dialog": + Ro("cancel", w), Ro("close", w); + break; + case "iframe": + case "object": + case "embed": + Ro("load", w); + break; + case "video": + case "audio": + for (T = 0; T < Iv.length; T++) + Ro(Iv[T], w); + break; + case "source": + Ro("error", w); + break; + case "img": + case "image": + case "link": + Ro("error", w), Ro("load", w); + break; + case "details": + Ro("toggle", w); + break; + case "input": + Ro("invalid", w), as( + w, + P.value, + P.defaultValue, + P.checked, + P.defaultChecked, + P.type, + P.name, + !0 + ); + break; + case "select": + Ro("invalid", w); + break; + case "textarea": + Ro("invalid", w), Va(w, P.value, P.defaultValue, P.children); + } + T = P.children, typeof T != "string" && typeof T != "number" && typeof T != "bigint" || w.textContent === "" + T || P.suppressHydrationWarning === !0 || v1(w.textContent, T) ? (P.popover != null && (Ro("beforetoggle", w), Ro("toggle", w)), P.onScroll != null && Ro("scroll", w), P.onScrollEnd != null && Ro("scrollend", w), P.onClick != null && (w.onclick = Jc), w = !0) : w = !1, w || xd(h, !0); + } + function Cc(h) { + for (Cn = h.return; Cn; ) + switch (Cn.tag) { + case 5: + case 31: + case 13: + nc = !1; + return; + case 27: + case 3: + nc = !0; + return; + default: + Cn = Cn.return; + } + } + function _d(h) { + if (h !== Cn) return !1; + if (!vo) return Cc(h), vo = !0, !1; + var w = h.tag, T; + if ((T = w !== 3 && w !== 27) && ((T = w === 5) && (T = h.type, T = !(T !== "form" && T !== "button") || hb(h.type, h.memoizedProps)), T = !T), T && Mo && xd(h), Cc(h), w === 13) { + if (h = h.memoizedState, h = h !== null ? h.dehydrated : null, !h) throw Error(o(317)); + Mo = w1(h); + } else if (w === 31) { + if (h = h.memoizedState, h = h !== null ? h.dehydrated : null, !h) throw Error(o(317)); + Mo = w1(h); + } else + w === 27 ? (w = Mo, Gt(h.type) ? (h = um, um = null, Mo = h) : Mo = w) : Mo = Cn ? Ns(h.stateNode.nextSibling) : null; + return !0; + } + function _r() { + Mo = Cn = null, vo = !1; + } + function Ll() { + var h = Nl; + return h !== null && (Si === null ? Si = h : Si.push.apply( + Si, + h + ), Nl = null), h; + } + function al(h) { + Nl === null ? Nl = [h] : Nl.push(h); + } + var it = X(null), Zt = null, jl = null; + function Rc(h, w, T) { + lr(it, w._currentValue), w._currentValue = T; + } + function zl(h) { + h._currentValue = it.current, Q(it); + } + function Ed(h, w, T) { + for (; h !== null; ) { + var P = h.alternate; + if ((h.childLanes & w) !== w ? (h.childLanes |= w, P !== null && (P.childLanes |= w)) : P !== null && (P.childLanes & w) !== w && (P.childLanes |= w), h === T) break; + h = h.return; + } + } + function Yb(h, w, T, P) { + var B = h.child; + for (B !== null && (B.return = h); B !== null; ) { + var V = B.dependencies; + if (V !== null) { + var ar = B.child; + V = V.firstContext; + r: for (; V !== null; ) { + var Sr = V; + V = B; + for (var Br = 0; Br < w.length; Br++) + if (Sr.context === w[Br]) { + V.lanes |= T, Sr = V.alternate, Sr !== null && (Sr.lanes |= T), Ed( + V.return, + T, + h + ), P || (ar = null); + break r; + } + V = Sr.next; + } + } else if (B.tag === 18) { + if (ar = B.return, ar === null) throw Error(o(341)); + ar.lanes |= T, V = ar.alternate, V !== null && (V.lanes |= T), Ed(ar, T, h), ar = null; + } else ar = B.child; + if (ar !== null) ar.return = B; + else + for (ar = B; ar !== null; ) { + if (ar === h) { + ar = null; + break; + } + if (B = ar.sibling, B !== null) { + B.return = ar.return, ar = B; + break; + } + ar = ar.return; + } + B = ar; + } + } + function Za(h, w, T, P) { + h = null; + for (var B = w, V = !1; B !== null; ) { + if (!V) { + if ((B.flags & 524288) !== 0) V = !0; + else if ((B.flags & 262144) !== 0) break; + } + if (B.tag === 10) { + var ar = B.alternate; + if (ar === null) throw Error(o(387)); + if (ar = ar.memoizedProps, ar !== null) { + var Sr = B.type; + an(B.pendingProps.value, ar.value) || (h !== null ? h.push(Sr) : h = [Sr]); + } + } else if (B === sr.current) { + if (ar = B.alternate, ar === null) throw Error(o(387)); + ar.memoizedState.memoizedState !== B.memoizedState.memoizedState && (h !== null ? h.push(gf) : h = [gf]); + } + B = B.return; + } + h !== null && Yb( + w, + h, + T, + P + ), w.flags |= 262144; + } + function Jg(h) { + for (h = h.firstContext; h !== null; ) { + if (!an( + h.context._currentValue, + h.memoizedValue + )) + return !0; + h = h.next; + } + return !1; + } + function Bl(h) { + Zt = h, jl = null, h = h.dependencies, h !== null && (h.firstContext = null); + } + function Oa(h) { + return Xb(Zt, h); + } + function ac(h, w) { + return Zt === null && Bl(h), Xb(h, w); + } + function Xb(h, w) { + var T = w._currentValue; + if (w = { context: w, memoizedValue: T, next: null }, jl === null) { + if (h === null) throw Error(o(308)); + jl = w, h.dependencies = { lanes: 0, firstContext: w }, h.flags |= 524288; + } else jl = jl.next = w; + return T; + } + var ic = typeof AbortController < "u" ? AbortController : function() { + var h = [], w = this.signal = { + aborted: !1, + addEventListener: function(T, P) { + h.push(P); + } + }; + this.abort = function() { + w.aborted = !0, h.forEach(function(T) { + return T(); + }); + }; + }, _s = t.unstable_scheduleCallback, Zb = t.unstable_NormalPriority, ra = { + $$typeof: k, + Consumer: null, + Provider: null, + _currentValue: null, + _currentValue2: null, + _threadCount: 0 + }; + function ii() { + return { + controller: new ic(), + data: /* @__PURE__ */ new Map(), + refCount: 0 + }; + } + function Mu(h) { + h.refCount--, h.refCount === 0 && _s(Zb, function() { + h.controller.abort(); + }); + } + var Sd = null, Iu = 0, Ul = 0, Od = null; + function mi(h, w) { + if (Sd === null) { + var T = Sd = []; + Iu = 0, Ul = Bd(), Od = { + status: "pending", + value: void 0, + then: function(P) { + T.push(P); + } + }; + } + return Iu++, w.then(qh, qh), w; + } + function qh() { + if (--Iu === 0 && Sd !== null) { + Od !== null && (Od.status = "fulfilled"); + var h = Sd; + Sd = null, Ul = 0, Od = null; + for (var w = 0; w < h.length; w++) (0, h[w])(); + } + } + function Es(h, w) { + var T = [], P = { + status: "pending", + value: null, + reason: null, + then: function(B) { + T.push(B); + } + }; + return h.then( + function() { + P.status = "fulfilled", P.value = w; + for (var B = 0; B < T.length; B++) (0, T[B])(w); + }, + function(B) { + for (P.status = "rejected", P.reason = B, B = 0; B < T.length; B++) + (0, T[B])(void 0); + } + ), P; + } + var cc = H.S; + H.S = function(h, w) { + Z5 = Dr(), typeof w == "object" && w !== null && typeof w.then == "function" && mi(h, w), cc !== null && cc(h, w); + }; + var Ia = X(null); + function Fl() { + var h = Ia.current; + return h !== null ? h : Yt.pooledCache; + } + function bg(h, w) { + w === null ? lr(Ia, Ia.current) : lr(Ia, w.pool); + } + function hg() { + var h = Fl(); + return h === null ? null : { parent: ra._currentValue, pool: h }; + } + var Js = Error(o(460)), Td = Error(o(474)), Da = Error(o(542)), lc = { then: function() { + } }; + function fg(h) { + return h = h.status, h === "fulfilled" || h === "rejected"; + } + function Ad(h, w, T) { + switch (T = h[T], T === void 0 ? h.push(w) : T !== w && (w.then(Jc, Jc), w = T), w.status) { + case "fulfilled": + return w.value; + case "rejected": + throw h = w.reason, yi(h), h; + default: + if (typeof w.status == "string") w.then(Jc, Jc); + else { + if (h = Yt, h !== null && 100 < h.shellSuspendCounter) + throw Error(o(482)); + h = w, h.status = "pending", h.then( + function(P) { + if (w.status === "pending") { + var B = w; + B.status = "fulfilled", B.value = P; + } + }, + function(P) { + if (w.status === "pending") { + var B = w; + B.status = "rejected", B.reason = P; + } + } + ); + } + switch (w.status) { + case "fulfilled": + return w.value; + case "rejected": + throw h = w.reason, yi(h), h; + } + throw ea = w, Js; + } + } + function ji(h) { + try { + var w = h._init; + return w(h._payload); + } catch (T) { + throw T !== null && typeof T == "object" && typeof T.then == "function" ? (ea = T, Js) : T; + } + } + var ea = null; + function ql() { + if (ea === null) throw Error(o(459)); + var h = ea; + return ea = null, h; + } + function yi(h) { + if (h === Js || h === Da) + throw Error(o(483)); + } + var Gl = null, zi = 0; + function $s(h) { + var w = zi; + return zi += 1, Gl === null && (Gl = []), Ad(Gl, h, w); + } + function Bi(h, w) { + w = w.props.ref, h.ref = w !== void 0 ? w : null; + } + function ci(h, w) { + throw w.$$typeof === g ? Error(o(525)) : (h = Object.prototype.toString.call(w), Error( + o( + 31, + h === "[object Object]" ? "object with keys {" + Object.keys(w).join(", ") + "}" : h + ) + )); + } + function vg(h) { + function w(Xr, Vr) { + if (h) { + var te = Xr.deletions; + te === null ? (Xr.deletions = [Vr], Xr.flags |= 16) : te.push(Vr); + } + } + function T(Xr, Vr) { + if (!h) return null; + for (; Vr !== null; ) + w(Xr, Vr), Vr = Vr.sibling; + return null; + } + function P(Xr) { + for (var Vr = /* @__PURE__ */ new Map(); Xr !== null; ) + Xr.key !== null ? Vr.set(Xr.key, Xr) : Vr.set(Xr.index, Xr), Xr = Xr.sibling; + return Vr; + } + function B(Xr, Vr) { + return Xr = Di(Xr, Vr), Xr.index = 0, Xr.sibling = null, Xr; + } + function V(Xr, Vr, te) { + return Xr.index = te, h ? (te = Xr.alternate, te !== null ? (te = te.index, te < Vr ? (Xr.flags |= 67108866, Vr) : te) : (Xr.flags |= 67108866, Vr)) : (Xr.flags |= 1048576, Vr); + } + function ar(Xr) { + return h && Xr.alternate === null && (Xr.flags |= 67108866), Xr; + } + function Sr(Xr, Vr, te, ye) { + return Vr === null || Vr.tag !== 6 ? (Vr = qn(te, Xr.mode, ye), Vr.return = Xr, Vr) : (Vr = B(Vr, te), Vr.return = Xr, Vr); + } + function Br(Xr, Vr, te, ye) { + var xt = te.type; + return xt === v ? be( + Xr, + Vr, + te.props.children, + ye, + te.key + ) : Vr !== null && (Vr.elementType === xt || typeof xt == "object" && xt !== null && xt.$$typeof === O && ji(xt) === Vr.type) ? (Vr = B(Vr, te.props), Bi(Vr, te), Vr.return = Xr, Vr) : (Vr = ks( + te.type, + te.key, + te.props, + null, + Xr.mode, + ye + ), Bi(Vr, te), Vr.return = Xr, Vr); + } + function ne(Xr, Vr, te, ye) { + return Vr === null || Vr.tag !== 4 || Vr.stateNode.containerInfo !== te.containerInfo || Vr.stateNode.implementation !== te.implementation ? (Vr = Ru(te, Xr.mode, ye), Vr.return = Xr, Vr) : (Vr = B(Vr, te.children || []), Vr.return = Xr, Vr); + } + function be(Xr, Vr, te, ye, xt) { + return Vr === null || Vr.tag !== 7 ? (Vr = ms( + te, + Xr.mode, + ye, + xt + ), Vr.return = Xr, Vr) : (Vr = B(Vr, te), Vr.return = Xr, Vr); + } + function we(Xr, Vr, te) { + if (typeof Vr == "string" && Vr !== "" || typeof Vr == "number" || typeof Vr == "bigint") + return Vr = qn( + "" + Vr, + Xr.mode, + te + ), Vr.return = Xr, Vr; + if (typeof Vr == "object" && Vr !== null) { + switch (Vr.$$typeof) { + case b: + return te = ks( + Vr.type, + Vr.key, + Vr.props, + null, + Xr.mode, + te + ), Bi(te, Vr), te.return = Xr, te; + case f: + return Vr = Ru( + Vr, + Xr.mode, + te + ), Vr.return = Xr, Vr; + case O: + return Vr = ji(Vr), we(Xr, Vr, te); + } + if (F(Vr) || L(Vr)) + return Vr = ms( + Vr, + Xr.mode, + te, + null + ), Vr.return = Xr, Vr; + if (typeof Vr.then == "function") + return we(Xr, $s(Vr), te); + if (Vr.$$typeof === k) + return we( + Xr, + ac(Xr, Vr), + te + ); + ci(Xr, Vr); + } + return null; + } + function ae(Xr, Vr, te, ye) { + var xt = Vr !== null ? Vr.key : null; + if (typeof te == "string" && te !== "" || typeof te == "number" || typeof te == "bigint") + return xt !== null ? null : Sr(Xr, Vr, "" + te, ye); + if (typeof te == "object" && te !== null) { + switch (te.$$typeof) { + case b: + return te.key === xt ? Br(Xr, Vr, te, ye) : null; + case f: + return te.key === xt ? ne(Xr, Vr, te, ye) : null; + case O: + return te = ji(te), ae(Xr, Vr, te, ye); + } + if (F(te) || L(te)) + return xt !== null ? null : be(Xr, Vr, te, ye, null); + if (typeof te.then == "function") + return ae( + Xr, + Vr, + $s(te), + ye + ); + if (te.$$typeof === k) + return ae( + Xr, + Vr, + ac(Xr, te), + ye + ); + ci(Xr, te); + } + return null; + } + function de(Xr, Vr, te, ye, xt) { + if (typeof ye == "string" && ye !== "" || typeof ye == "number" || typeof ye == "bigint") + return Xr = Xr.get(te) || null, Sr(Vr, Xr, "" + ye, xt); + if (typeof ye == "object" && ye !== null) { + switch (ye.$$typeof) { + case b: + return Xr = Xr.get( + ye.key === null ? te : ye.key + ) || null, Br(Vr, Xr, ye, xt); + case f: + return Xr = Xr.get( + ye.key === null ? te : ye.key + ) || null, ne(Vr, Xr, ye, xt); + case O: + return ye = ji(ye), de( + Xr, + Vr, + te, + ye, + xt + ); + } + if (F(ye) || L(ye)) + return Xr = Xr.get(te) || null, be(Vr, Xr, ye, xt, null); + if (typeof ye.then == "function") + return de( + Xr, + Vr, + te, + $s(ye), + xt + ); + if (ye.$$typeof === k) + return de( + Xr, + Vr, + te, + ac(Vr, ye), + xt + ); + ci(Vr, ye); + } + return null; + } + function ot(Xr, Vr, te, ye) { + for (var xt = null, $o = null, ct = Vr, ko = Vr = 0, Lo = null; ct !== null && ko < te.length; ko++) { + ct.index > ko ? (Lo = ct, ct = null) : Lo = ct.sibling; + var rn = ae( + Xr, + ct, + te[ko], + ye + ); + if (rn === null) { + ct === null && (ct = Lo); + break; + } + h && ct && rn.alternate === null && w(Xr, ct), Vr = V(rn, Vr, ko), $o === null ? xt = rn : $o.sibling = rn, $o = rn, ct = Lo; + } + if (ko === te.length) + return T(Xr, ct), vo && Xa(Xr, ko), xt; + if (ct === null) { + for (; ko < te.length; ko++) + ct = we(Xr, te[ko], ye), ct !== null && (Vr = V( + ct, + Vr, + ko + ), $o === null ? xt = ct : $o.sibling = ct, $o = ct); + return vo && Xa(Xr, ko), xt; + } + for (ct = P(ct); ko < te.length; ko++) + Lo = de( + ct, + Xr, + ko, + te[ko], + ye + ), Lo !== null && (h && Lo.alternate !== null && ct.delete( + Lo.key === null ? ko : Lo.key + ), Vr = V( + Lo, + Vr, + ko + ), $o === null ? xt = Lo : $o.sibling = Lo, $o = Lo); + return h && ct.forEach(function(yb) { + return w(Xr, yb); + }), vo && Xa(Xr, ko), xt; + } + function Dt(Xr, Vr, te, ye) { + if (te == null) throw Error(o(151)); + for (var xt = null, $o = null, ct = Vr, ko = Vr = 0, Lo = null, rn = te.next(); ct !== null && !rn.done; ko++, rn = te.next()) { + ct.index > ko ? (Lo = ct, ct = null) : Lo = ct.sibling; + var yb = ae(Xr, ct, rn.value, ye); + if (yb === null) { + ct === null && (ct = Lo); + break; + } + h && ct && yb.alternate === null && w(Xr, ct), Vr = V(yb, Vr, ko), $o === null ? xt = yb : $o.sibling = yb, $o = yb, ct = Lo; + } + if (rn.done) + return T(Xr, ct), vo && Xa(Xr, ko), xt; + if (ct === null) { + for (; !rn.done; ko++, rn = te.next()) + rn = we(Xr, rn.value, ye), rn !== null && (Vr = V(rn, Vr, ko), $o === null ? xt = rn : $o.sibling = rn, $o = rn); + return vo && Xa(Xr, ko), xt; + } + for (ct = P(ct); !rn.done; ko++, rn = te.next()) + rn = de(ct, Xr, ko, rn.value, ye), rn !== null && (h && rn.alternate !== null && ct.delete(rn.key === null ? ko : rn.key), Vr = V(rn, Vr, ko), $o === null ? xt = rn : $o.sibling = rn, $o = rn); + return h && ct.forEach(function(J3) { + return w(Xr, J3); + }), vo && Xa(Xr, ko), xt; + } + function Pn(Xr, Vr, te, ye) { + if (typeof te == "object" && te !== null && te.type === v && te.key === null && (te = te.props.children), typeof te == "object" && te !== null) { + switch (te.$$typeof) { + case b: + r: { + for (var xt = te.key; Vr !== null; ) { + if (Vr.key === xt) { + if (xt = te.type, xt === v) { + if (Vr.tag === 7) { + T( + Xr, + Vr.sibling + ), ye = B( + Vr, + te.props.children + ), ye.return = Xr, Xr = ye; + break r; + } + } else if (Vr.elementType === xt || typeof xt == "object" && xt !== null && xt.$$typeof === O && ji(xt) === Vr.type) { + T( + Xr, + Vr.sibling + ), ye = B(Vr, te.props), Bi(ye, te), ye.return = Xr, Xr = ye; + break r; + } + T(Xr, Vr); + break; + } else w(Xr, Vr); + Vr = Vr.sibling; + } + te.type === v ? (ye = ms( + te.props.children, + Xr.mode, + ye, + te.key + ), ye.return = Xr, Xr = ye) : (ye = ks( + te.type, + te.key, + te.props, + null, + Xr.mode, + ye + ), Bi(ye, te), ye.return = Xr, Xr = ye); + } + return ar(Xr); + case f: + r: { + for (xt = te.key; Vr !== null; ) { + if (Vr.key === xt) + if (Vr.tag === 4 && Vr.stateNode.containerInfo === te.containerInfo && Vr.stateNode.implementation === te.implementation) { + T( + Xr, + Vr.sibling + ), ye = B(Vr, te.children || []), ye.return = Xr, Xr = ye; + break r; + } else { + T(Xr, Vr); + break; + } + else w(Xr, Vr); + Vr = Vr.sibling; + } + ye = Ru(te, Xr.mode, ye), ye.return = Xr, Xr = ye; + } + return ar(Xr); + case O: + return te = ji(te), Pn( + Xr, + Vr, + te, + ye + ); + } + if (F(te)) + return ot( + Xr, + Vr, + te, + ye + ); + if (L(te)) { + if (xt = L(te), typeof xt != "function") throw Error(o(150)); + return te = xt.call(te), Dt( + Xr, + Vr, + te, + ye + ); + } + if (typeof te.then == "function") + return Pn( + Xr, + Vr, + $s(te), + ye + ); + if (te.$$typeof === k) + return Pn( + Xr, + Vr, + ac(Xr, te), + ye + ); + ci(Xr, te); + } + return typeof te == "string" && te !== "" || typeof te == "number" || typeof te == "bigint" ? (te = "" + te, Vr !== null && Vr.tag === 6 ? (T(Xr, Vr.sibling), ye = B(Vr, te), ye.return = Xr, Xr = ye) : (T(Xr, Vr), ye = qn(te, Xr.mode, ye), ye.return = Xr, Xr = ye), ar(Xr)) : T(Xr, Vr); + } + return function(Xr, Vr, te, ye) { + try { + zi = 0; + var xt = Pn( + Xr, + Vr, + te, + ye + ); + return Gl = null, xt; + } catch (ct) { + if (ct === Js || ct === Da) throw ct; + var $o = Jn(29, ct, null, Xr.mode); + return $o.lanes = ye, $o.return = Xr, $o; + } finally { + } + }; + } + var Vl = vg(!0), Du = vg(!1), dc = !1; + function wi(h) { + h.updateQueue = { + baseState: h.memoizedState, + firstBaseUpdate: null, + lastBaseUpdate: null, + shared: { pending: null, lanes: 0, hiddenCallbacks: null }, + callbacks: null + }; + } + function pg(h, w) { + h = h.updateQueue, w.updateQueue === h && (w.updateQueue = { + baseState: h.baseState, + firstBaseUpdate: h.firstBaseUpdate, + lastBaseUpdate: h.lastBaseUpdate, + shared: h.shared, + callbacks: null + }); + } + function Hl(h) { + return { lane: h, tag: 0, payload: null, callback: null, next: null }; + } + function il(h, w, T) { + var P = h.updateQueue; + if (P === null) return null; + if (P = P.shared, (qe & 2) !== 0) { + var B = P.pending; + return B === null ? w.next = w : (w.next = B.next, B.next = w), P.pending = w, w = ai(h), md(h, null, T), w; + } + return ps(h, P, w, T), ai(h); + } + function Nu(h, w, T) { + if (w = w.updateQueue, w !== null && (w = w.shared, (T & 4194048) !== 0)) { + var P = w.lanes; + P &= h.pendingLanes, T |= P, w.lanes = T, so(h, T); + } + } + function Pc(h, w) { + var T = h.updateQueue, P = h.alternate; + if (P !== null && (P = P.updateQueue, T === P)) { + var B = null, V = null; + if (T = T.firstBaseUpdate, T !== null) { + do { + var ar = { + lane: T.lane, + tag: T.tag, + payload: T.payload, + callback: null, + next: null + }; + V === null ? B = V = ar : V = V.next = ar, T = T.next; + } while (T !== null); + V === null ? B = V = w : V = V.next = w; + } else B = V = w; + T = { + baseState: P.baseState, + firstBaseUpdate: B, + lastBaseUpdate: V, + shared: P.shared, + callbacks: P.callbacks + }, h.updateQueue = T; + return; + } + h = T.lastBaseUpdate, h === null ? T.firstBaseUpdate = w : h.next = w, T.lastBaseUpdate = w; + } + var ta = !1; + function Ss() { + if (ta) { + var h = Od; + if (h !== null) throw h; + } + } + function Lu(h, w, T, P) { + ta = !1; + var B = h.updateQueue; + dc = !1; + var V = B.firstBaseUpdate, ar = B.lastBaseUpdate, Sr = B.shared.pending; + if (Sr !== null) { + B.shared.pending = null; + var Br = Sr, ne = Br.next; + Br.next = null, ar === null ? V = ne : ar.next = ne, ar = Br; + var be = h.alternate; + be !== null && (be = be.updateQueue, Sr = be.lastBaseUpdate, Sr !== ar && (Sr === null ? be.firstBaseUpdate = ne : Sr.next = ne, be.lastBaseUpdate = Br)); + } + if (V !== null) { + var we = B.baseState; + ar = 0, be = ne = Br = null, Sr = V; + do { + var ae = Sr.lane & -536870913, de = ae !== Sr.lane; + if (de ? (It & ae) === ae : (P & ae) === ae) { + ae !== 0 && ae === Ul && (ta = !0), be !== null && (be = be.next = { + lane: 0, + tag: Sr.tag, + payload: Sr.payload, + callback: null, + next: null + }); + r: { + var ot = h, Dt = Sr; + ae = w; + var Pn = T; + switch (Dt.tag) { + case 1: + if (ot = Dt.payload, typeof ot == "function") { + we = ot.call(Pn, we, ae); + break r; + } + we = ot; + break r; + case 3: + ot.flags = ot.flags & -65537 | 128; + case 0: + if (ot = Dt.payload, ae = typeof ot == "function" ? ot.call(Pn, we, ae) : ot, ae == null) break r; + we = u({}, we, ae); + break r; + case 2: + dc = !0; + } + } + ae = Sr.callback, ae !== null && (h.flags |= 64, de && (h.flags |= 8192), de = B.callbacks, de === null ? B.callbacks = [ae] : de.push(ae)); + } else + de = { + lane: ae, + tag: Sr.tag, + payload: Sr.payload, + callback: Sr.callback, + next: null + }, be === null ? (ne = be = de, Br = we) : be = be.next = de, ar |= ae; + if (Sr = Sr.next, Sr === null) { + if (Sr = B.shared.pending, Sr === null) + break; + de = Sr, Sr = de.next, de.next = null, B.lastBaseUpdate = de, B.shared.pending = null; + } + } while (!0); + be === null && (Br = we), B.baseState = Br, B.firstBaseUpdate = ne, B.lastBaseUpdate = be, V === null && (B.shared.lanes = 0), cu |= ar, h.lanes = ar, h.memoizedState = we; + } + } + function Mc(h, w) { + if (typeof h != "function") + throw Error(o(191, h)); + h.call(w); + } + function Ic(h, w) { + var T = h.callbacks; + if (T !== null) + for (h.callbacks = null, h = 0; h < T.length; h++) + Mc(T[h], w); + } + var cl = X(null), Dc = X(0); + function ru(h, w) { + h = Qa, lr(Dc, h), lr(cl, w), Qa = h | w.baseLanes; + } + function oa() { + lr(Dc, Qa), lr(cl, cl.current); + } + function Wl() { + Qa = Dc.current, Q(cl), Q(Dc); + } + var et = X(null), xi = null; + function ll(h) { + var w = h.alternate; + lr(Ln, Ln.current & 1), lr(et, h), xi === null && (w === null || cl.current !== null || w.memoizedState !== null) && (xi = h); + } + function Nc(h) { + lr(Ln, Ln.current), lr(et, h), xi === null && (xi = h); + } + function kg(h) { + h.tag === 22 ? (lr(Ln, Ln.current), lr(et, h), xi === null && (xi = h)) : Ui(); + } + function Ui() { + lr(Ln, Ln.current), lr(et, et.current); + } + function Xo(h) { + Q(et), xi === h && (xi = null), Q(Ln); + } + var Ln = X(0); + function sc(h) { + for (var w = h; w !== null; ) { + if (w.tag === 13) { + var T = w.memoizedState; + if (T !== null && (T = T.dehydrated, T === null || ip(T) || af(T))) + return w; + } else if (w.tag === 19 && (w.memoizedProps.revealOrder === "forwards" || w.memoizedProps.revealOrder === "backwards" || w.memoizedProps.revealOrder === "unstable_legacy-backwards" || w.memoizedProps.revealOrder === "together")) { + if ((w.flags & 128) !== 0) return w; + } else if (w.child !== null) { + w.child.return = w, w = w.child; + continue; + } + if (w === h) break; + for (; w.sibling === null; ) { + if (w.return === null || w.return === h) return null; + w = w.return; + } + w.sibling.return = w.return, w = w.sibling; + } + return null; + } + var Io = 0, Ot = null, Kt = null, mn = null, Os = !1, Cd = !1, Lc = !1, mg = 0, Ts = 0, Rd = null, Kb = 0; + function un() { + throw Error(o(321)); + } + function yg(h, w) { + if (w === null) return !1; + for (var T = 0; T < w.length && T < h.length; T++) + if (!an(h[T], w[T])) return !1; + return !0; + } + function As(h, w, T, P, B, V) { + return Io = V, Ot = w, w.memoizedState = null, w.updateQueue = null, w.lanes = 0, H.H = h === null || h.memoizedState === null ? gc : Hn, Lc = !1, V = T(P, B), Lc = !1, Cd && (V = eu( + w, + T, + P, + B + )), ju(h), V; + } + function ju(h) { + H.H = Uu; + var w = Kt !== null && Kt.next !== null; + if (Io = 0, mn = Kt = Ot = null, Os = !1, Ts = 0, Rd = null, w) throw Error(o(300)); + h === null || aa || (h = h.dependencies, h !== null && Jg(h) && (aa = !0)); + } + function eu(h, w, T, P) { + Ot = h; + var B = 0; + do { + if (Cd && (Rd = null), Ts = 0, Cd = !1, 25 <= B) throw Error(o(301)); + if (B += 1, mn = Kt = null, h.updateQueue != null) { + var V = h.updateQueue; + V.lastEffect = null, V.events = null, V.stores = null, V.memoCache != null && (V.memoCache.index = 0); + } + H.H = Kl, V = w(T, P); + } while (Cd); + return V; + } + function Gh() { + var h = H.H, w = h.useState()[0]; + return w = typeof w.then == "function" ? tu(w) : w, h = h.useState()[0], (Kt !== null ? Kt.memoizedState : null) !== h && (Ot.flags |= 1024), w; + } + function Yl() { + var h = mg !== 0; + return mg = 0, h; + } + function Cs(h, w, T) { + w.updateQueue = h.updateQueue, w.flags &= -2053, h.lanes &= ~T; + } + function zu(h) { + if (Os) { + for (h = h.memoizedState; h !== null; ) { + var w = h.queue; + w !== null && (w.pending = null), h = h.next; + } + Os = !1; + } + Io = 0, mn = Kt = Ot = null, Cd = !1, Ts = mg = 0, Rd = null; + } + function Na() { + var h = { + memoizedState: null, + baseState: null, + baseQueue: null, + queue: null, + next: null + }; + return mn === null ? Ot.memoizedState = mn = h : mn = mn.next = h, mn; + } + function Go() { + if (Kt === null) { + var h = Ot.alternate; + h = h !== null ? h.memoizedState : null; + } else h = Kt.next; + var w = mn === null ? Ot.memoizedState : mn.next; + if (w !== null) + mn = w, Kt = h; + else { + if (h === null) + throw Ot.alternate === null ? Error(o(467)) : Error(o(310)); + Kt = h, h = { + memoizedState: Kt.memoizedState, + baseState: Kt.baseState, + baseQueue: Kt.baseQueue, + queue: Kt.queue, + next: null + }, mn === null ? Ot.memoizedState = mn = h : mn = mn.next = h; + } + return mn; + } + function Zo() { + return { lastEffect: null, events: null, stores: null, memoCache: null }; + } + function tu(h) { + var w = Ts; + return Ts += 1, Rd === null && (Rd = []), h = Ad(Rd, h, w), w = Ot, (mn === null ? w.memoizedState : mn.next) === null && (w = w.alternate, H.H = w === null || w.memoizedState === null ? gc : Hn), h; + } + function K(h) { + if (h !== null && typeof h == "object") { + if (typeof h.then == "function") return tu(h); + if (h.$$typeof === k) return Oa(h); + } + throw Error(o(438, String(h))); + } + function ir(h) { + var w = null, T = Ot.updateQueue; + if (T !== null && (w = T.memoCache), w == null) { + var P = Ot.alternate; + P !== null && (P = P.updateQueue, P !== null && (P = P.memoCache, P != null && (w = { + data: P.data.map(function(B) { + return B.slice(); + }), + index: 0 + }))); + } + if (w == null && (w = { data: [], index: 0 }), T === null && (T = Zo(), Ot.updateQueue = T), T.memoCache = w, T = w.data[w.index], T === void 0) + for (T = w.data[w.index] = Array(h), P = 0; P < h; P++) + T[P] = M; + return w.index++, T; + } + function mr(h, w) { + return typeof w == "function" ? w(h) : w; + } + function Rr(h) { + var w = Go(); + return Fr(w, Kt, h); + } + function Fr(h, w, T) { + var P = h.queue; + if (P === null) throw Error(o(311)); + P.lastRenderedReducer = T; + var B = h.baseQueue, V = P.pending; + if (V !== null) { + if (B !== null) { + var ar = B.next; + B.next = V.next, V.next = ar; + } + w.baseQueue = B = V, P.pending = null; + } + if (V = h.baseState, B === null) h.memoizedState = V; + else { + w = B.next; + var Sr = ar = null, Br = null, ne = w, be = !1; + do { + var we = ne.lane & -536870913; + if (we !== ne.lane ? (It & we) === we : (Io & we) === we) { + var ae = ne.revertLane; + if (ae === 0) + Br !== null && (Br = Br.next = { + lane: 0, + revertLane: 0, + gesture: null, + action: ne.action, + hasEagerState: ne.hasEagerState, + eagerState: ne.eagerState, + next: null + }), we === Ul && (be = !0); + else if ((Io & ae) === ae) { + ne = ne.next, ae === Ul && (be = !0); + continue; + } else + we = { + lane: 0, + revertLane: ne.revertLane, + gesture: null, + action: ne.action, + hasEagerState: ne.hasEagerState, + eagerState: ne.eagerState, + next: null + }, Br === null ? (Sr = Br = we, ar = V) : Br = Br.next = we, Ot.lanes |= ae, cu |= ae; + we = ne.action, Lc && T(V, we), V = ne.hasEagerState ? ne.eagerState : T(V, we); + } else + ae = { + lane: we, + revertLane: ne.revertLane, + gesture: ne.gesture, + action: ne.action, + hasEagerState: ne.hasEagerState, + eagerState: ne.eagerState, + next: null + }, Br === null ? (Sr = Br = ae, ar = V) : Br = Br.next = ae, Ot.lanes |= we, cu |= we; + ne = ne.next; + } while (ne !== null && ne !== w); + if (Br === null ? ar = V : Br.next = Sr, !an(V, h.memoizedState) && (aa = !0, be && (T = Od, T !== null))) + throw T; + h.memoizedState = V, h.baseState = ar, h.baseQueue = Br, P.lastRenderedState = V; + } + return B === null && (P.lanes = 0), [h.memoizedState, P.dispatch]; + } + function Gr(h) { + var w = Go(), T = w.queue; + if (T === null) throw Error(o(311)); + T.lastRenderedReducer = h; + var P = T.dispatch, B = T.pending, V = w.memoizedState; + if (B !== null) { + T.pending = null; + var ar = B = B.next; + do + V = h(V, ar.action), ar = ar.next; + while (ar !== B); + an(V, w.memoizedState) || (aa = !0), w.memoizedState = V, w.baseQueue === null && (w.baseState = V), T.lastRenderedState = V; + } + return [V, P]; + } + function zr(h, w, T) { + var P = Ot, B = Go(), V = vo; + if (V) { + if (T === void 0) throw Error(o(407)); + T = T(); + } else T = w(); + var ar = !an( + (Kt || B).memoizedState, + T + ); + if (ar && (B.memoizedState = T, aa = !0), B = B.queue, Ao(ve.bind(null, P, B, h), [ + h + ]), B.getSnapshot !== w || ar || mn !== null && mn.memoizedState.tag & 1) { + if (P.flags |= 2048, kt( + 9, + { destroy: void 0 }, + $r.bind( + null, + P, + B, + T, + w + ), + null + ), Yt === null) throw Error(o(349)); + V || (Io & 127) !== 0 || Kr(P, w, T); + } + return T; + } + function Kr(h, w, T) { + h.flags |= 16384, h = { getSnapshot: w, value: T }, w = Ot.updateQueue, w === null ? (w = Zo(), Ot.updateQueue = w, w.stores = [h]) : (T = w.stores, T === null ? w.stores = [h] : T.push(h)); + } + function $r(h, w, T, P) { + w.value = T, w.getSnapshot = P, ge(w) && Ge(h); + } + function ve(h, w, T) { + return T(function() { + ge(w) && Ge(h); + }); + } + function ge(h) { + var w = h.getSnapshot; + h = h.value; + try { + var T = w(); + return !an(h, T); + } catch { + return !0; + } + } + function Ge(h) { + var w = Tc(h, 2); + w !== null && Ql(w, h, 2); + } + function Ae(h) { + var w = Na(); + if (typeof h == "function") { + var T = h; + if (h = T(), Lc) { + Jr(!0); + try { + T(); + } finally { + Jr(!1); + } + } + } + return w.memoizedState = w.baseState = h, w.queue = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: mr, + lastRenderedState: h + }, w; + } + function rt(h, w, T, P) { + return h.baseState = T, Fr( + h, + Kt, + typeof P == "function" ? P : mr + ); + } + function Je(h, w, T, P, B) { + if (Jb(h)) throw Error(o(485)); + if (h = w.action, h !== null) { + var V = { + payload: B, + action: h, + next: null, + isTransition: !0, + status: "pending", + value: null, + reason: null, + listeners: [], + then: function(ar) { + V.listeners.push(ar); + } + }; + H.T !== null ? T(!0) : V.isTransition = !1, P(V), T = w.pending, T === null ? (V.next = w.pending = V, to(w, V)) : (V.next = T.next, w.pending = T.next = V); + } + } + function to(h, w) { + var T = w.action, P = w.payload, B = h.state; + if (w.isTransition) { + var V = H.T, ar = {}; + H.T = ar; + try { + var Sr = T(B, P), Br = H.S; + Br !== null && Br(ar, Sr), Tt(h, w, Sr); + } catch (ne) { + po(h, w, ne); + } finally { + V !== null && ar.types !== null && (V.types = ar.types), H.T = V; + } + } else + try { + V = T(B, P), Tt(h, w, V); + } catch (ne) { + po(h, w, ne); + } + } + function Tt(h, w, T) { + T !== null && typeof T == "object" && typeof T.then == "function" ? T.then( + function(P) { + Qt(h, w, P); + }, + function(P) { + return po(h, w, P); + } + ) : Qt(h, w, T); + } + function Qt(h, w, T) { + w.status = "fulfilled", w.value = T, ba(w), h.state = T, w = h.pending, w !== null && (T = w.next, T === w ? h.pending = null : (T = T.next, w.next = T, to(h, T))); + } + function po(h, w, T) { + var P = h.pending; + if (h.pending = null, P !== null) { + P = P.next; + do + w.status = "rejected", w.reason = T, ba(w), w = w.next; + while (w !== P); + } + h.action = null; + } + function ba(h) { + h = h.listeners; + for (var w = 0; w < h.length; w++) (0, h[w])(); + } + function Gn(h, w) { + return w; + } + function li(h, w) { + if (vo) { + var T = Yt.formState; + if (T !== null) { + r: { + var P = Ot; + if (vo) { + if (Mo) { + e: { + for (var B = Mo, V = nc; B.nodeType !== 8; ) { + if (!V) { + B = null; + break e; + } + if (B = Ns( + B.nextSibling + ), B === null) { + B = null; + break e; + } + } + V = B.data, B = V === "F!" || V === "F" ? B : null; + } + if (B) { + Mo = Ns( + B.nextSibling + ), P = B.data === "F!"; + break r; + } + } + xd(P); + } + P = !1; + } + P && (w = T[0]); + } + } + return T = Na(), T.memoizedState = T.baseState = w, P = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: Gn, + lastRenderedState: w + }, T.queue = P, T = pv.bind( + null, + Ot, + P + ), P.dispatch = T, P = Ae(!1), V = eb.bind( + null, + Ot, + !1, + P.queue + ), P = Na(), B = { + state: w, + dispatch: null, + action: h, + pending: null + }, P.queue = B, T = Je.bind( + null, + Ot, + B, + V, + T + ), B.dispatch = T, P.memoizedState = h, [w, T, !1]; + } + function go(h) { + var w = Go(); + return De(w, Kt, h); + } + function De(h, w, T) { + if (w = Fr( + h, + w, + Gn + )[0], h = Rr(mr)[0], typeof w == "object" && w !== null && typeof w.then == "function") + try { + var P = tu(w); + } catch (ar) { + throw ar === Js ? Da : ar; + } + else P = w; + w = Go(); + var B = w.queue, V = B.dispatch; + return T !== w.memoizedState && (Ot.flags |= 2048, kt( + 9, + { destroy: void 0 }, + pt.bind(null, B, T), + null + )), [P, V, h]; + } + function pt(h, w) { + h.action = w; + } + function oo(h) { + var w = Go(), T = Kt; + if (T !== null) + return De(w, T, h); + Go(), w = w.memoizedState, T = Go(); + var P = T.queue.dispatch; + return T.memoizedState = h, [w, P, !1]; + } + function kt(h, w, T, P) { + return h = { tag: h, create: T, deps: P, inst: w, next: null }, w = Ot.updateQueue, w === null && (w = Zo(), Ot.updateQueue = w), T = w.lastEffect, T === null ? w.lastEffect = h.next = h : (P = T.next, T.next = h, h.next = P, w.lastEffect = h), h; + } + function na() { + return Go().memoizedState; + } + function wo(h, w, T, P) { + var B = Na(); + Ot.flags |= h, B.memoizedState = kt( + 1 | w, + { destroy: void 0 }, + T, + P === void 0 ? null : P + ); + } + function bo(h, w, T, P) { + var B = Go(); + P = P === void 0 ? null : P; + var V = B.memoizedState.inst; + Kt !== null && P !== null && yg(P, Kt.memoizedState.deps) ? B.memoizedState = kt(w, V, T, P) : (Ot.flags |= h, B.memoizedState = kt( + 1 | w, + V, + T, + P + )); + } + function Do(h, w) { + wo(8390656, 8, h, w); + } + function Ao(h, w) { + bo(2048, 8, h, w); + } + function Vo(h) { + Ot.flags |= 4; + var w = Ot.updateQueue; + if (w === null) + w = Zo(), Ot.updateQueue = w, w.events = [h]; + else { + var T = w.events; + T === null ? w.events = [h] : T.push(h); + } + } + function uc(h) { + var w = Go().memoizedState; + return Vo({ ref: w, nextImpl: h }), function() { + if ((qe & 2) !== 0) throw Error(o(440)); + return w.impl.apply(void 0, arguments); + }; + } + function Pd(h, w) { + return bo(4, 2, h, w); + } + function Xl(h, w) { + return bo(4, 4, h, w); + } + function Rs(h, w) { + if (typeof w == "function") { + h = h(); + var T = w(h); + return function() { + typeof T == "function" ? T() : w(null); + }; + } + if (w != null) + return h = h(), w.current = h, function() { + w.current = null; + }; + } + function Zl(h, w, T) { + T = T != null ? T.concat([h]) : null, bo(4, 4, Rs.bind(null, w, h), T); + } + function jc() { + } + function Md(h, w) { + var T = Go(); + w = w === void 0 ? null : w; + var P = T.memoizedState; + return w !== null && yg(w, P[1]) ? P[0] : (T.memoizedState = [h, w], h); + } + function Vn(h, w) { + var T = Go(); + w = w === void 0 ? null : w; + var P = T.memoizedState; + if (w !== null && yg(w, P[1])) + return P[0]; + if (P = h(), Lc) { + Jr(!0); + try { + h(); + } finally { + Jr(!1); + } + } + return T.memoizedState = [P, w], P; + } + function Ta(h, w, T) { + return T === void 0 || (Io & 1073741824) !== 0 && (It & 261930) === 0 ? h.memoizedState = w : (h.memoizedState = T, h = Q5(), Ot.lanes |= h, cu |= h, T); + } + function wg(h, w, T, P) { + return an(T, w) ? T : cl.current !== null ? (h = Ta(h, T, P), an(h, w) || (aa = !0), h) : (Io & 42) === 0 || (Io & 1073741824) !== 0 && (It & 261930) === 0 ? (aa = !0, h.memoizedState = T) : (h = Q5(), Ot.lanes |= h, cu |= h, w); + } + function Bu(h, w, T, P, B) { + var V = q.p; + q.p = V !== 0 && 8 > V ? V : 8; + var ar = H.T, Sr = {}; + H.T = Sr, eb(h, !1, w, T); + try { + var Br = B(), ne = H.S; + if (ne !== null && ne(Sr, Br), Br !== null && typeof Br == "object" && typeof Br.then == "function") { + var be = Es( + Br, + P + ); + Fi( + h, + w, + be, + zd(h) + ); + } else + Fi( + h, + w, + P, + zd(h) + ); + } catch (we) { + Fi( + h, + w, + { then: function() { + }, status: "rejected", reason: we }, + zd() + ); + } finally { + q.p = V, ar !== null && Sr.types !== null && (ar.types = Sr.types), H.T = ar; + } + } + function Qb() { + } + function ou(h, w, T, P) { + if (h.tag !== 5) throw Error(o(476)); + var B = fv(h).queue; + Bu( + h, + B, + w, + W, + T === null ? Qb : function() { + return vv(h), T(P); + } + ); + } + function fv(h) { + var w = h.memoizedState; + if (w !== null) return w; + w = { + memoizedState: W, + baseState: W, + baseQueue: null, + queue: { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: mr, + lastRenderedState: W + }, + next: null + }; + var T = {}; + return w.next = { + memoizedState: T, + baseState: T, + baseQueue: null, + queue: { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: mr, + lastRenderedState: T + }, + next: null + }, h.memoizedState = w, h = h.alternate, h !== null && (h.memoizedState = w), w; + } + function vv(h) { + var w = fv(h); + w.next === null && (w = h.alternate.memoizedState), Fi( + h, + w.next.queue, + {}, + zd() + ); + } + function $g() { + return Oa(gf); + } + function rb() { + return Go().memoizedState; + } + function xg() { + return Go().memoizedState; + } + function _g(h) { + for (var w = h.return; w !== null; ) { + switch (w.tag) { + case 24: + case 3: + var T = zd(); + h = Hl(T); + var P = il(w, h, T); + P !== null && (Ql(P, w, T), Nu(P, w, T)), w = { cache: ii() }, h.payload = w; + return; + } + w = w.return; + } + } + function z0(h, w, T) { + var P = zd(); + T = { + lane: P, + revertLane: 0, + gesture: null, + action: T, + hasEagerState: !1, + eagerState: null, + next: null + }, Jb(h) ? Id(w, T) : (T = Oc(h, w, T, P), T !== null && (Ql(T, h, P), qt(T, w, P))); + } + function pv(h, w, T) { + var P = zd(); + Fi(h, w, T, P); + } + function Fi(h, w, T, P) { + var B = { + lane: P, + revertLane: 0, + gesture: null, + action: T, + hasEagerState: !1, + eagerState: null, + next: null + }; + if (Jb(h)) Id(w, B); + else { + var V = h.alternate; + if (h.lanes === 0 && (V === null || V.lanes === 0) && (V = w.lastRenderedReducer, V !== null)) + try { + var ar = w.lastRenderedState, Sr = V(ar, T); + if (B.hasEagerState = !0, B.eagerState = Sr, an(Sr, ar)) + return ps(h, w, B, 0), Yt === null && tl(), !1; + } catch { + } finally { + } + if (T = Oc(h, w, B, P), T !== null) + return Ql(T, h, P), qt(T, w, P), !0; + } + return !1; + } + function eb(h, w, T, P) { + if (P = { + lane: 2, + revertLane: Bd(), + gesture: null, + action: P, + hasEagerState: !1, + eagerState: null, + next: null + }, Jb(h)) { + if (w) throw Error(o(479)); + } else + w = Oc( + h, + T, + P, + 2 + ), w !== null && Ql(w, h, 2); + } + function Jb(h) { + var w = h.alternate; + return h === Ot || w !== null && w === Ot; + } + function Id(h, w) { + Cd = Os = !0; + var T = h.pending; + T === null ? w.next = w : (w.next = T.next, T.next = w), h.pending = w; + } + function qt(h, w, T) { + if ((T & 4194048) !== 0) { + var P = w.lanes; + P &= h.pendingLanes, T |= P, w.lanes = T, so(h, T); + } + } + var Uu = { + readContext: Oa, + use: K, + useCallback: un, + useContext: un, + useEffect: un, + useImperativeHandle: un, + useLayoutEffect: un, + useInsertionEffect: un, + useMemo: un, + useReducer: un, + useRef: un, + useState: un, + useDebugValue: un, + useDeferredValue: un, + useTransition: un, + useSyncExternalStore: un, + useId: un, + useHostTransitionStatus: un, + useFormState: un, + useActionState: un, + useOptimistic: un, + useMemoCache: un, + useCacheRefresh: un + }; + Uu.useEffectEvent = un; + var gc = { + readContext: Oa, + use: K, + useCallback: function(h, w) { + return Na().memoizedState = [ + h, + w === void 0 ? null : w + ], h; + }, + useContext: Oa, + useEffect: Do, + useImperativeHandle: function(h, w, T) { + T = T != null ? T.concat([h]) : null, wo( + 4194308, + 4, + Rs.bind(null, w, h), + T + ); + }, + useLayoutEffect: function(h, w) { + return wo(4194308, 4, h, w); + }, + useInsertionEffect: function(h, w) { + wo(4, 2, h, w); + }, + useMemo: function(h, w) { + var T = Na(); + w = w === void 0 ? null : w; + var P = h(); + if (Lc) { + Jr(!0); + try { + h(); + } finally { + Jr(!1); + } + } + return T.memoizedState = [P, w], P; + }, + useReducer: function(h, w, T) { + var P = Na(); + if (T !== void 0) { + var B = T(w); + if (Lc) { + Jr(!0); + try { + T(w); + } finally { + Jr(!1); + } + } + } else B = w; + return P.memoizedState = P.baseState = B, h = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: h, + lastRenderedState: B + }, P.queue = h, h = h.dispatch = z0.bind( + null, + Ot, + h + ), [P.memoizedState, h]; + }, + useRef: function(h) { + var w = Na(); + return h = { current: h }, w.memoizedState = h; + }, + useState: function(h) { + h = Ae(h); + var w = h.queue, T = pv.bind(null, Ot, w); + return w.dispatch = T, [h.memoizedState, T]; + }, + useDebugValue: jc, + useDeferredValue: function(h, w) { + var T = Na(); + return Ta(T, h, w); + }, + useTransition: function() { + var h = Ae(!1); + return h = Bu.bind( + null, + Ot, + h.queue, + !0, + !1 + ), Na().memoizedState = h, [!1, h]; + }, + useSyncExternalStore: function(h, w, T) { + var P = Ot, B = Na(); + if (vo) { + if (T === void 0) + throw Error(o(407)); + T = T(); + } else { + if (T = w(), Yt === null) + throw Error(o(349)); + (It & 127) !== 0 || Kr(P, w, T); + } + B.memoizedState = T; + var V = { value: T, getSnapshot: w }; + return B.queue = V, Do(ve.bind(null, P, V, h), [ + h + ]), P.flags |= 2048, kt( + 9, + { destroy: void 0 }, + $r.bind( + null, + P, + V, + T, + w + ), + null + ), T; + }, + useId: function() { + var h = Na(), w = Yt.identifierPrefix; + if (vo) { + var T = Ya, P = oc; + T = (P & ~(1 << 32 - Qr(P) - 1)).toString(32) + T, w = "_" + w + "R_" + T, T = mg++, 0 < T && (w += "H" + T.toString(32)), w += "_"; + } else + T = Kb++, w = "_" + w + "r_" + T.toString(32) + "_"; + return h.memoizedState = w; + }, + useHostTransitionStatus: $g, + useFormState: li, + useActionState: li, + useOptimistic: function(h) { + var w = Na(); + w.memoizedState = w.baseState = h; + var T = { + pending: null, + lanes: 0, + dispatch: null, + lastRenderedReducer: null, + lastRenderedState: null + }; + return w.queue = T, w = eb.bind( + null, + Ot, + !0, + T + ), T.dispatch = w, [h, w]; + }, + useMemoCache: ir, + useCacheRefresh: function() { + return Na().memoizedState = _g.bind( + null, + Ot + ); + }, + useEffectEvent: function(h) { + var w = Na(), T = { impl: h }; + return w.memoizedState = T, function() { + if ((qe & 2) !== 0) + throw Error(o(440)); + return T.impl.apply(void 0, arguments); + }; + } + }, Hn = { + readContext: Oa, + use: K, + useCallback: Md, + useContext: Oa, + useEffect: Ao, + useImperativeHandle: Zl, + useInsertionEffect: Pd, + useLayoutEffect: Xl, + useMemo: Vn, + useReducer: Rr, + useRef: na, + useState: function() { + return Rr(mr); + }, + useDebugValue: jc, + useDeferredValue: function(h, w) { + var T = Go(); + return wg( + T, + Kt.memoizedState, + h, + w + ); + }, + useTransition: function() { + var h = Rr(mr)[0], w = Go().memoizedState; + return [ + typeof h == "boolean" ? h : tu(h), + w + ]; + }, + useSyncExternalStore: zr, + useId: rb, + useHostTransitionStatus: $g, + useFormState: go, + useActionState: go, + useOptimistic: function(h, w) { + var T = Go(); + return rt(T, Kt, h, w); + }, + useMemoCache: ir, + useCacheRefresh: xg + }; + Hn.useEffectEvent = uc; + var Kl = { + readContext: Oa, + use: K, + useCallback: Md, + useContext: Oa, + useEffect: Ao, + useImperativeHandle: Zl, + useInsertionEffect: Pd, + useLayoutEffect: Xl, + useMemo: Vn, + useReducer: Gr, + useRef: na, + useState: function() { + return Gr(mr); + }, + useDebugValue: jc, + useDeferredValue: function(h, w) { + var T = Go(); + return Kt === null ? Ta(T, h, w) : wg( + T, + Kt.memoizedState, + h, + w + ); + }, + useTransition: function() { + var h = Gr(mr)[0], w = Go().memoizedState; + return [ + typeof h == "boolean" ? h : tu(h), + w + ]; + }, + useSyncExternalStore: zr, + useId: rb, + useHostTransitionStatus: $g, + useFormState: oo, + useActionState: oo, + useOptimistic: function(h, w) { + var T = Go(); + return Kt !== null ? rt(T, Kt, h, w) : (T.baseState = h, [h, T.queue.dispatch]); + }, + useMemoCache: ir, + useCacheRefresh: xg + }; + Kl.useEffectEvent = uc; + function Vh(h, w, T, P) { + w = h.memoizedState, T = T(P, w), T = T == null ? w : u({}, w, T), h.memoizedState = T, h.lanes === 0 && (h.updateQueue.baseState = T); + } + var Eg = { + enqueueSetState: function(h, w, T) { + h = h._reactInternals; + var P = zd(), B = Hl(P); + B.payload = w, T != null && (B.callback = T), w = il(h, B, P), w !== null && (Ql(w, h, P), Nu(w, h, P)); + }, + enqueueReplaceState: function(h, w, T) { + h = h._reactInternals; + var P = zd(), B = Hl(P); + B.tag = 1, B.payload = w, T != null && (B.callback = T), w = il(h, B, P), w !== null && (Ql(w, h, P), Nu(w, h, P)); + }, + enqueueForceUpdate: function(h, w) { + h = h._reactInternals; + var T = zd(), P = Hl(T); + P.tag = 2, w != null && (P.callback = w), w = il(h, P, T), w !== null && (Ql(w, h, T), Nu(w, h, T)); + } + }; + function Ps(h, w, T, P, B, V, ar) { + return h = h.stateNode, typeof h.shouldComponentUpdate == "function" ? h.shouldComponentUpdate(P, V, ar) : w.prototype && w.prototype.isPureReactComponent ? !fs(T, P) || !fs(B, V) : !0; + } + function Hh(h, w, T, P) { + h = w.state, typeof w.componentWillReceiveProps == "function" && w.componentWillReceiveProps(T, P), typeof w.UNSAFE_componentWillReceiveProps == "function" && w.UNSAFE_componentWillReceiveProps(T, P), w.state !== h && Eg.enqueueReplaceState(w, w.state, null); + } + function di(h, w) { + var T = w; + if ("ref" in w) { + T = {}; + for (var P in w) + P !== "ref" && (T[P] = w[P]); + } + if (h = h.defaultProps) { + T === w && (T = u({}, T)); + for (var B in h) + T[B] === void 0 && (T[B] = h[B]); + } + return T; + } + function jn(h) { + Qg(h); + } + function Wn(h) { + console.error(h); + } + function kv(h) { + Qg(h); + } + function tb(h, w) { + try { + var T = h.onUncaughtError; + T(w.value, { componentStack: w.stack }); + } catch (P) { + setTimeout(function() { + throw P; + }); + } + } + function ob(h, w, T) { + try { + var P = h.onCaughtError; + P(T.value, { + componentStack: T.stack, + errorBoundary: w.tag === 1 ? w.stateNode : null + }); + } catch (B) { + setTimeout(function() { + throw B; + }); + } + } + function $b(h, w, T) { + return T = Hl(T), T.tag = 3, T.payload = { element: null }, T.callback = function() { + tb(h, w); + }, T; + } + function Dd(h) { + return h = Hl(h), h.tag = 3, h; + } + function Sg(h, w, T, P) { + var B = T.type.getDerivedStateFromError; + if (typeof B == "function") { + var V = P.value; + h.payload = function() { + return B(V); + }, h.callback = function() { + ob(w, T, P); + }; + } + var ar = T.stateNode; + ar !== null && typeof ar.componentDidCatch == "function" && (h.callback = function() { + ob(w, T, P), typeof B != "function" && (sb === null ? sb = /* @__PURE__ */ new Set([this]) : sb.add(this)); + var Sr = P.stack; + this.componentDidCatch(P.value, { + componentStack: Sr !== null ? Sr : "" + }); + }); + } + function bc(h, w, T, P, B) { + if (T.flags |= 32768, P !== null && typeof P == "object" && typeof P.then == "function") { + if (w = T.alternate, w !== null && Za( + w, + T, + B, + !0 + ), T = et.current, T !== null) { + switch (T.tag) { + case 31: + case 13: + return xi === null ? Q0() : T.alternate === null && Yn === 0 && (Yn = 3), T.flags &= -257, T.flags |= 65536, T.lanes = B, P === lc ? T.flags |= 16384 : (w = T.updateQueue, w === null ? T.updateQueue = /* @__PURE__ */ new Set([P]) : w.add(P), $k(h, P, B)), !1; + case 22: + return T.flags |= 65536, P === lc ? T.flags |= 16384 : (w = T.updateQueue, w === null ? (w = { + transitions: null, + markerInstances: null, + retryQueue: /* @__PURE__ */ new Set([P]) + }, T.updateQueue = w) : (T = w.retryQueue, T === null ? w.retryQueue = /* @__PURE__ */ new Set([P]) : T.add(P)), $k(h, P, B)), !1; + } + throw Error(o(435, T.tag)); + } + return $k(h, P, B), Q0(), !1; + } + if (vo) + return w = et.current, w !== null ? ((w.flags & 65536) === 0 && (w.flags |= 256), w.flags |= 65536, w.lanes = B, P !== Pu && (h = Error(o(422), { cause: P }), al(ga(h, T)))) : (P !== Pu && (w = Error(o(423), { + cause: P + }), al( + ga(w, T) + )), h = h.current.alternate, h.flags |= 65536, B &= -B, h.lanes |= B, P = ga(P, T), B = $b( + h.stateNode, + P, + B + ), Pc(h, B), Yn !== 4 && (Yn = 2)), !1; + var V = Error(o(520), { cause: P }); + if (V = ga(V, T), lb === null ? lb = [V] : lb.push(V), Yn !== 4 && (Yn = 2), w === null) return !0; + P = ga(P, T), T = w; + do { + switch (T.tag) { + case 3: + return T.flags |= 65536, h = B & -B, T.lanes |= h, h = $b(T.stateNode, P, h), Pc(T, h), !1; + case 1: + if (w = T.type, V = T.stateNode, (T.flags & 128) === 0 && (typeof w.getDerivedStateFromError == "function" || V !== null && typeof V.componentDidCatch == "function" && (sb === null || !sb.has(V)))) + return T.flags |= 65536, B &= -B, T.lanes |= B, B = Dd(B), Sg( + B, + h, + T, + P + ), Pc(T, B), !1; + } + T = T.return; + } while (T !== null); + return !1; + } + var Ms = Error(o(461)), aa = !1; + function ha(h, w, T, P) { + w.child = h === null ? Du(w, null, T, P) : Vl( + w, + h.child, + T, + P + ); + } + function yt(h, w, T, P, B) { + T = T.render; + var V = w.ref; + if ("ref" in P) { + var ar = {}; + for (var Sr in P) + Sr !== "ref" && (ar[Sr] = P[Sr]); + } else ar = P; + return Bl(w), P = As( + h, + w, + T, + ar, + V, + B + ), Sr = Yl(), h !== null && !aa ? (Cs(h, w, B), Is(h, w, B)) : (vo && Sr && nl(w), w.flags |= 1, ha(h, w, P, B), w.child); + } + function dl(h, w, T, P, B) { + if (h === null) { + var V = T.type; + return typeof V == "function" && !Wa(V) && V.defaultProps === void 0 && T.compare === null ? (w.tag = 15, w.type = V, Jt( + h, + w, + V, + P, + B + )) : (h = ks( + T.type, + null, + P, + w, + w.mode, + B + ), h.ref = w.ref, h.return = w, w.child = h); + } + if (V = h.child, !nh(h, B)) { + var ar = V.memoizedProps; + if (T = T.compare, T = T !== null ? T : fs, T(ar, P) && h.ref === w.ref) + return Is(h, w, B); + } + return w.flags |= 1, h = Di(V, P), h.ref = w.ref, h.return = w, w.child = h; + } + function Jt(h, w, T, P, B) { + if (h !== null) { + var V = h.memoizedProps; + if (fs(V, P) && h.ref === w.ref) + if (aa = !1, w.pendingProps = P = V, nh(h, B)) + (h.flags & 131072) !== 0 && (aa = !0); + else + return w.lanes = h.lanes, Is(h, w, B); + } + return Wh( + h, + w, + T, + P, + B + ); + } + function nu(h, w, T, P) { + var B = P.children, V = h !== null ? h.memoizedState : null; + if (h === null && w.stateNode === null && (w.stateNode = { + _visibility: 1, + _pendingMarkers: null, + _retryCache: null, + _transitions: null + }), P.mode === "hidden") { + if ((w.flags & 128) !== 0) { + if (V = V !== null ? V.baseLanes | T : T, h !== null) { + for (P = w.child = h.child, B = 0; P !== null; ) + B = B | P.lanes | P.childLanes, P = P.sibling; + P = B & ~V; + } else P = 0, w.child = null; + return rh( + h, + w, + V, + T, + P + ); + } + if ((T & 536870912) !== 0) + w.memoizedState = { baseLanes: 0, cachePool: null }, h !== null && bg( + w, + V !== null ? V.cachePool : null + ), V !== null ? ru(w, V) : oa(), kg(w); + else + return P = w.lanes = 536870912, rh( + h, + w, + V !== null ? V.baseLanes | T : T, + T, + P + ); + } else + V !== null ? (bg(w, V.cachePool), ru(w, V), Ui(), w.memoizedState = null) : (h !== null && bg(w, null), oa(), Ui()); + return ha(h, w, B, T), w.child; + } + function qi(h, w) { + return h !== null && h.tag === 22 || w.stateNode !== null || (w.stateNode = { + _visibility: 1, + _pendingMarkers: null, + _retryCache: null, + _transitions: null + }), w.sibling; + } + function rh(h, w, T, P, B) { + var V = Fl(); + return V = V === null ? null : { parent: ra._currentValue, pool: V }, w.memoizedState = { + baseLanes: T, + cachePool: V + }, h !== null && bg(w, null), oa(), kg(w), h !== null && Za(h, w, P, !0), w.childLanes = B, null; + } + function No(h, w) { + return w = Aa( + { mode: w.mode, children: w.children }, + h.mode + ), w.ref = h.ref, h.child = w, w.return = h, w; + } + function _i(h, w, T) { + return Vl(w, h.child, null, T), h = No(w, w.pendingProps), h.flags |= 2, Xo(w), w.memoizedState = null, h; + } + function B0(h, w, T) { + var P = w.pendingProps, B = (w.flags & 128) !== 0; + if (w.flags &= -129, h === null) { + if (vo) { + if (P.mode === "hidden") + return h = No(w, P), w.lanes = 536870912, qi(null, h); + if (Nc(w), (h = Mo) ? (h = y1( + h, + nc + ), h = h !== null && h.data === "&" ? h : null, h !== null && (w.memoizedState = { + dehydrated: h, + treeContext: $n !== null ? { id: oc, overflow: Ya } : null, + retryLane: 536870912, + hydrationErrors: null + }, T = tc(h), T.return = w, w.child = T, Cn = w, Mo = null)) : h = null, h === null) throw xd(w); + return w.lanes = 536870912, null; + } + return No(w, P); + } + var V = h.memoizedState; + if (V !== null) { + var ar = V.dehydrated; + if (Nc(w), B) + if (w.flags & 256) + w.flags &= -257, w = _i( + h, + w, + T + ); + else if (w.memoizedState !== null) + w.child = h.child, w.flags |= 128, w = null; + else throw Error(o(558)); + else if (aa || Za(h, w, T, !1), B = (T & h.childLanes) !== 0, aa || B) { + if (P = Yt, P !== null && (ar = Ft(P, T), ar !== 0 && ar !== V.retryLane)) + throw V.retryLane = ar, Tc(h, ar), Ql(P, h, ar), Ms; + Q0(), w = _i( + h, + w, + T + ); + } else + h = V.treeContext, Mo = Ns(ar.nextSibling), Cn = w, vo = !0, Nl = null, nc = !1, h !== null && ws(w, h), w = No(w, P), w.flags |= 4096; + return w; + } + return h = Di(h.child, { + mode: P.mode, + children: P.children + }), h.ref = w.ref, w.child = h, h.return = w, h; + } + function Og(h, w) { + var T = w.ref; + if (T === null) + h !== null && h.ref !== null && (w.flags |= 4194816); + else { + if (typeof T != "function" && typeof T != "object") + throw Error(o(284)); + (h === null || h.ref !== T) && (w.flags |= 4194816); + } + } + function Wh(h, w, T, P, B) { + return Bl(w), T = As( + h, + w, + T, + P, + void 0, + B + ), P = Yl(), h !== null && !aa ? (Cs(h, w, B), Is(h, w, B)) : (vo && P && nl(w), w.flags |= 1, ha(h, w, T, B), w.child); + } + function U0(h, w, T, P, B, V) { + return Bl(w), w.updateQueue = null, T = eu( + w, + P, + T, + B + ), ju(h), P = Yl(), h !== null && !aa ? (Cs(h, w, V), Is(h, w, V)) : (vo && P && nl(w), w.flags |= 1, ha(h, w, T, V), w.child); + } + function mv(h, w, T, P, B) { + if (Bl(w), w.stateNode === null) { + var V = Dl, ar = T.contextType; + typeof ar == "object" && ar !== null && (V = Oa(ar)), V = new T(P, V), w.memoizedState = V.state !== null && V.state !== void 0 ? V.state : null, V.updater = Eg, w.stateNode = V, V._reactInternals = w, V = w.stateNode, V.props = P, V.state = w.memoizedState, V.refs = {}, wi(w), ar = T.contextType, V.context = typeof ar == "object" && ar !== null ? Oa(ar) : Dl, V.state = w.memoizedState, ar = T.getDerivedStateFromProps, typeof ar == "function" && (Vh( + w, + T, + ar, + P + ), V.state = w.memoizedState), typeof T.getDerivedStateFromProps == "function" || typeof V.getSnapshotBeforeUpdate == "function" || typeof V.UNSAFE_componentWillMount != "function" && typeof V.componentWillMount != "function" || (ar = V.state, typeof V.componentWillMount == "function" && V.componentWillMount(), typeof V.UNSAFE_componentWillMount == "function" && V.UNSAFE_componentWillMount(), ar !== V.state && Eg.enqueueReplaceState(V, V.state, null), Lu(w, P, V, B), Ss(), V.state = w.memoizedState), typeof V.componentDidMount == "function" && (w.flags |= 4194308), P = !0; + } else if (h === null) { + V = w.stateNode; + var Sr = w.memoizedProps, Br = di(T, Sr); + V.props = Br; + var ne = V.context, be = T.contextType; + ar = Dl, typeof be == "object" && be !== null && (ar = Oa(be)); + var we = T.getDerivedStateFromProps; + be = typeof we == "function" || typeof V.getSnapshotBeforeUpdate == "function", Sr = w.pendingProps !== Sr, be || typeof V.UNSAFE_componentWillReceiveProps != "function" && typeof V.componentWillReceiveProps != "function" || (Sr || ne !== ar) && Hh( + w, + V, + P, + ar + ), dc = !1; + var ae = w.memoizedState; + V.state = ae, Lu(w, P, V, B), Ss(), ne = w.memoizedState, Sr || ae !== ne || dc ? (typeof we == "function" && (Vh( + w, + T, + we, + P + ), ne = w.memoizedState), (Br = dc || Ps( + w, + T, + Br, + P, + ae, + ne, + ar + )) ? (be || typeof V.UNSAFE_componentWillMount != "function" && typeof V.componentWillMount != "function" || (typeof V.componentWillMount == "function" && V.componentWillMount(), typeof V.UNSAFE_componentWillMount == "function" && V.UNSAFE_componentWillMount()), typeof V.componentDidMount == "function" && (w.flags |= 4194308)) : (typeof V.componentDidMount == "function" && (w.flags |= 4194308), w.memoizedProps = P, w.memoizedState = ne), V.props = P, V.state = ne, V.context = ar, P = Br) : (typeof V.componentDidMount == "function" && (w.flags |= 4194308), P = !1); + } else { + V = w.stateNode, pg(h, w), ar = w.memoizedProps, be = di(T, ar), V.props = be, we = w.pendingProps, ae = V.context, ne = T.contextType, Br = Dl, typeof ne == "object" && ne !== null && (Br = Oa(ne)), Sr = T.getDerivedStateFromProps, (ne = typeof Sr == "function" || typeof V.getSnapshotBeforeUpdate == "function") || typeof V.UNSAFE_componentWillReceiveProps != "function" && typeof V.componentWillReceiveProps != "function" || (ar !== we || ae !== Br) && Hh( + w, + V, + P, + Br + ), dc = !1, ae = w.memoizedState, V.state = ae, Lu(w, P, V, B), Ss(); + var de = w.memoizedState; + ar !== we || ae !== de || dc || h !== null && h.dependencies !== null && Jg(h.dependencies) ? (typeof Sr == "function" && (Vh( + w, + T, + Sr, + P + ), de = w.memoizedState), (be = dc || Ps( + w, + T, + be, + P, + ae, + de, + Br + ) || h !== null && h.dependencies !== null && Jg(h.dependencies)) ? (ne || typeof V.UNSAFE_componentWillUpdate != "function" && typeof V.componentWillUpdate != "function" || (typeof V.componentWillUpdate == "function" && V.componentWillUpdate(P, de, Br), typeof V.UNSAFE_componentWillUpdate == "function" && V.UNSAFE_componentWillUpdate( + P, + de, + Br + )), typeof V.componentDidUpdate == "function" && (w.flags |= 4), typeof V.getSnapshotBeforeUpdate == "function" && (w.flags |= 1024)) : (typeof V.componentDidUpdate != "function" || ar === h.memoizedProps && ae === h.memoizedState || (w.flags |= 4), typeof V.getSnapshotBeforeUpdate != "function" || ar === h.memoizedProps && ae === h.memoizedState || (w.flags |= 1024), w.memoizedProps = P, w.memoizedState = de), V.props = P, V.state = de, V.context = Br, P = be) : (typeof V.componentDidUpdate != "function" || ar === h.memoizedProps && ae === h.memoizedState || (w.flags |= 4), typeof V.getSnapshotBeforeUpdate != "function" || ar === h.memoizedProps && ae === h.memoizedState || (w.flags |= 1024), P = !1); + } + return V = P, Og(h, w), P = (w.flags & 128) !== 0, V || P ? (V = w.stateNode, T = P && typeof T.getDerivedStateFromError != "function" ? null : V.render(), w.flags |= 1, h !== null && P ? (w.child = Vl( + w, + h.child, + null, + B + ), w.child = Vl( + w, + null, + T, + B + )) : ha(h, w, T, B), w.memoizedState = V.state, h = w.child) : h = Is( + h, + w, + B + ), h; + } + function F0(h, w, T, P) { + return _r(), w.flags |= 256, ha(h, w, T, P), w.child; + } + var eh = { + dehydrated: null, + treeContext: null, + retryLane: 0, + hydrationErrors: null + }; + function th(h) { + return { baseLanes: h, cachePool: hg() }; + } + function Nd(h, w, T) { + return h = h !== null ? h.childLanes & ~T : 0, w && (h |= Hi), h; + } + function Gi(h, w, T) { + var P = w.pendingProps, B = !1, V = (w.flags & 128) !== 0, ar; + if ((ar = V) || (ar = h !== null && h.memoizedState === null ? !1 : (Ln.current & 2) !== 0), ar && (B = !0, w.flags &= -129), ar = (w.flags & 32) !== 0, w.flags &= -33, h === null) { + if (vo) { + if (B ? ll(w) : Ui(), (h = Mo) ? (h = y1( + h, + nc + ), h = h !== null && h.data !== "&" ? h : null, h !== null && (w.memoizedState = { + dehydrated: h, + treeContext: $n !== null ? { id: oc, overflow: Ya } : null, + retryLane: 536870912, + hydrationErrors: null + }, T = tc(h), T.return = w, w.child = T, Cn = w, Mo = null)) : h = null, h === null) throw xd(w); + return af(h) ? w.lanes = 32 : w.lanes = 536870912, null; + } + var Sr = P.children; + return P = P.fallback, B ? (Ui(), B = w.mode, Sr = Aa( + { mode: "hidden", children: Sr }, + B + ), P = ms( + P, + B, + T, + null + ), Sr.return = w, P.return = w, Sr.sibling = P, w.child = Sr, P = w.child, P.memoizedState = th(T), P.childLanes = Nd( + h, + ar, + T + ), w.memoizedState = eh, qi(null, P)) : (ll(w), oh(w, Sr)); + } + var Br = h.memoizedState; + if (Br !== null && (Sr = Br.dehydrated, Sr !== null)) { + if (V) + w.flags & 256 ? (ll(w), w.flags &= -257, w = si( + h, + w, + T + )) : w.memoizedState !== null ? (Ui(), w.child = h.child, w.flags |= 128, w = null) : (Ui(), Sr = P.fallback, B = w.mode, P = Aa( + { mode: "visible", children: P.children }, + B + ), Sr = ms( + Sr, + B, + T, + null + ), Sr.flags |= 2, P.return = w, Sr.return = w, P.sibling = Sr, w.child = P, Vl( + w, + h.child, + null, + T + ), P = w.child, P.memoizedState = th(T), P.childLanes = Nd( + h, + ar, + T + ), w.memoizedState = eh, w = qi(null, P)); + else if (ll(w), af(Sr)) { + if (ar = Sr.nextSibling && Sr.nextSibling.dataset, ar) var ne = ar.dgst; + ar = ne, P = Error(o(419)), P.stack = "", P.digest = ar, al({ value: P, source: null, stack: null }), w = si( + h, + w, + T + ); + } else if (aa || Za(h, w, T, !1), ar = (T & h.childLanes) !== 0, aa || ar) { + if (ar = Yt, ar !== null && (P = Ft(ar, T), P !== 0 && P !== Br.retryLane)) + throw Br.retryLane = P, Tc(h, P), Ql(ar, h, P), Ms; + ip(Sr) || Q0(), w = si( + h, + w, + T + ); + } else + ip(Sr) ? (w.flags |= 192, w.child = h.child, w = null) : (h = Br.treeContext, Mo = Ns( + Sr.nextSibling + ), Cn = w, vo = !0, Nl = null, nc = !1, h !== null && ws(w, h), w = oh( + w, + P.children + ), w.flags |= 4096); + return w; + } + return B ? (Ui(), Sr = P.fallback, B = w.mode, Br = h.child, ne = Br.sibling, P = Di(Br, { + mode: "hidden", + children: P.children + }), P.subtreeFlags = Br.subtreeFlags & 65011712, ne !== null ? Sr = Di( + ne, + Sr + ) : (Sr = ms( + Sr, + B, + T, + null + ), Sr.flags |= 2), Sr.return = w, P.return = w, P.sibling = Sr, w.child = P, qi(null, P), P = w.child, Sr = h.child.memoizedState, Sr === null ? Sr = th(T) : (B = Sr.cachePool, B !== null ? (Br = ra._currentValue, B = B.parent !== Br ? { parent: Br, pool: Br } : B) : B = hg(), Sr = { + baseLanes: Sr.baseLanes | T, + cachePool: B + }), P.memoizedState = Sr, P.childLanes = Nd( + h, + ar, + T + ), w.memoizedState = eh, qi(h.child, P)) : (ll(w), T = h.child, h = T.sibling, T = Di(T, { + mode: "visible", + children: P.children + }), T.return = w, T.sibling = null, h !== null && (ar = w.deletions, ar === null ? (w.deletions = [h], w.flags |= 16) : ar.push(h)), w.child = T, w.memoizedState = null, T); + } + function oh(h, w) { + return w = Aa( + { mode: "visible", children: w }, + h.mode + ), w.return = h, h.child = w; + } + function Aa(h, w) { + return h = Jn(22, h, null, w), h.lanes = 0, h; + } + function si(h, w, T) { + return Vl(w, h.child, null, T), h = oh( + w, + w.pendingProps.children + ), h.flags |= 2, w.memoizedState = null, h; + } + function q0(h, w, T) { + h.lanes |= w; + var P = h.alternate; + P !== null && (P.lanes |= w), Ed(h.return, w, T); + } + function Yh(h, w, T, P, B, V) { + var ar = h.memoizedState; + ar === null ? h.memoizedState = { + isBackwards: w, + rendering: null, + renderingStartTime: 0, + last: P, + tail: T, + tailMode: B, + treeForkCount: V + } : (ar.isBackwards = w, ar.rendering = null, ar.renderingStartTime = 0, ar.last = P, ar.tail = T, ar.tailMode = B, ar.treeForkCount = V); + } + function nb(h, w, T) { + var P = w.pendingProps, B = P.revealOrder, V = P.tail; + P = P.children; + var ar = Ln.current, Sr = (ar & 2) !== 0; + if (Sr ? (ar = ar & 1 | 2, w.flags |= 128) : ar &= 1, lr(Ln, ar), ha(h, w, P, T), P = vo ? To : 0, !Sr && h !== null && (h.flags & 128) !== 0) + r: for (h = w.child; h !== null; ) { + if (h.tag === 13) + h.memoizedState !== null && q0(h, T, w); + else if (h.tag === 19) + q0(h, T, w); + else if (h.child !== null) { + h.child.return = h, h = h.child; + continue; + } + if (h === w) break r; + for (; h.sibling === null; ) { + if (h.return === null || h.return === w) + break r; + h = h.return; + } + h.sibling.return = h.return, h = h.sibling; + } + switch (B) { + case "forwards": + for (T = w.child, B = null; T !== null; ) + h = T.alternate, h !== null && sc(h) === null && (B = T), T = T.sibling; + T = B, T === null ? (B = w.child, w.child = null) : (B = T.sibling, T.sibling = null), Yh( + w, + !1, + B, + T, + V, + P + ); + break; + case "backwards": + case "unstable_legacy-backwards": + for (T = null, B = w.child, w.child = null; B !== null; ) { + if (h = B.alternate, h !== null && sc(h) === null) { + w.child = B; + break; + } + h = B.sibling, B.sibling = T, T = B, B = h; + } + Yh( + w, + !0, + T, + null, + V, + P + ); + break; + case "together": + Yh( + w, + !1, + null, + null, + void 0, + P + ); + break; + default: + w.memoizedState = null; + } + return w.child; + } + function Is(h, w, T) { + if (h !== null && (w.dependencies = h.dependencies), cu |= w.lanes, (T & w.childLanes) === 0) + if (h !== null) { + if (Za( + h, + w, + T, + !1 + ), (T & w.childLanes) === 0) + return null; + } else return null; + if (h !== null && w.child !== h.child) + throw Error(o(153)); + if (w.child !== null) { + for (h = w.child, T = Di(h, h.pendingProps), w.child = T, T.return = w; h.sibling !== null; ) + h = h.sibling, T = T.sibling = Di(h, h.pendingProps), T.return = w; + T.sibling = null; + } + return w.child; + } + function nh(h, w) { + return (h.lanes & w) !== 0 ? !0 : (h = h.dependencies, !!(h !== null && Jg(h))); + } + function G0(h, w, T) { + switch (w.tag) { + case 3: + pr(w, w.stateNode.containerInfo), Rc(w, ra, h.memoizedState.cache), _r(); + break; + case 27: + case 5: + cr(w); + break; + case 4: + pr(w, w.stateNode.containerInfo); + break; + case 10: + Rc( + w, + w.type, + w.memoizedProps.value + ); + break; + case 31: + if (w.memoizedState !== null) + return w.flags |= 128, Nc(w), null; + break; + case 13: + var P = w.memoizedState; + if (P !== null) + return P.dehydrated !== null ? (ll(w), w.flags |= 128, null) : (T & w.child.childLanes) !== 0 ? Gi(h, w, T) : (ll(w), h = Is( + h, + w, + T + ), h !== null ? h.sibling : null); + ll(w); + break; + case 19: + var B = (h.flags & 128) !== 0; + if (P = (T & w.childLanes) !== 0, P || (Za( + h, + w, + T, + !1 + ), P = (T & w.childLanes) !== 0), B) { + if (P) + return nb( + h, + w, + T + ); + w.flags |= 128; + } + if (B = w.memoizedState, B !== null && (B.rendering = null, B.tail = null, B.lastEffect = null), lr(Ln, Ln.current), P) break; + return null; + case 22: + return w.lanes = 0, nu( + h, + w, + T, + w.pendingProps + ); + case 24: + Rc(w, ra, h.memoizedState.cache); + } + return Is(h, w, T); + } + function yv(h, w, T) { + if (h !== null) + if (h.memoizedProps !== w.pendingProps) + aa = !0; + else { + if (!nh(h, T) && (w.flags & 128) === 0) + return aa = !1, G0( + h, + w, + T + ); + aa = (h.flags & 131072) !== 0; + } + else + aa = !1, vo && (w.flags & 1048576) !== 0 && wd(w, To, w.index); + switch (w.lanes = 0, w.tag) { + case 16: + r: { + var P = w.pendingProps; + if (h = ji(w.elementType), w.type = h, typeof h == "function") + Wa(h) ? (P = di(h, P), w.tag = 1, w = mv( + null, + w, + h, + P, + T + )) : (w.tag = 0, w = Wh( + null, + w, + h, + P, + T + )); + else { + if (h != null) { + var B = h.$$typeof; + if (B === x) { + w.tag = 11, w = yt( + null, + w, + h, + P, + T + ); + break r; + } else if (B === E) { + w.tag = 14, w = dl( + null, + w, + h, + P, + T + ); + break r; + } + } + throw w = z(h) || h, Error(o(306, w, "")); + } + } + return w; + case 0: + return Wh( + h, + w, + w.type, + w.pendingProps, + T + ); + case 1: + return P = w.type, B = di( + P, + w.pendingProps + ), mv( + h, + w, + P, + B, + T + ); + case 3: + r: { + if (pr( + w, + w.stateNode.containerInfo + ), h === null) throw Error(o(387)); + P = w.pendingProps; + var V = w.memoizedState; + B = V.element, pg(h, w), Lu(w, P, null, T); + var ar = w.memoizedState; + if (P = ar.cache, Rc(w, ra, P), P !== V.cache && Yb( + w, + [ra], + T, + !0 + ), Ss(), P = ar.element, V.isDehydrated) + if (V = { + element: P, + isDehydrated: !1, + cache: ar.cache + }, w.updateQueue.baseState = V, w.memoizedState = V, w.flags & 256) { + w = F0( + h, + w, + P, + T + ); + break r; + } else if (P !== B) { + B = ga( + Error(o(424)), + w + ), al(B), w = F0( + h, + w, + P, + T + ); + break r; + } else { + switch (h = w.stateNode.containerInfo, h.nodeType) { + case 9: + h = h.body; + break; + default: + h = h.nodeName === "HTML" ? h.ownerDocument.body : h; + } + for (Mo = Ns(h.firstChild), Cn = w, vo = !0, Nl = null, nc = !0, T = Du( + w, + null, + P, + T + ), w.child = T; T; ) + T.flags = T.flags & -3 | 4096, T = T.sibling; + } + else { + if (_r(), P === B) { + w = Is( + h, + w, + T + ); + break r; + } + ha(h, w, P, T); + } + w = w.child; + } + return w; + case 26: + return Og(h, w), h === null ? (T = O1( + w.type, + null, + w.pendingProps, + null + )) ? w.memoizedState = T : vo || (T = w.type, h = w.pendingProps, P = jv( + dr.current + ).createElement(T), P[lo] = w, P[zo] = h, fc(P, T, h), Yo(P), w.stateNode = P) : w.memoizedState = O1( + w.type, + h.memoizedProps, + w.pendingProps, + h.memoizedState + ), null; + case 27: + return cr(w), h === null && vo && (P = w.stateNode = _1( + w.type, + w.pendingProps, + dr.current + ), Cn = w, nc = !0, B = Mo, Gt(w.type) ? (um = B, Mo = Ns(P.firstChild)) : Mo = B), ha( + h, + w, + w.pendingProps.children, + T + ), Og(h, w), h === null && (w.flags |= 4194304), w.child; + case 5: + return h === null && vo && ((B = P = Mo) && (P = N3( + P, + w.type, + w.pendingProps, + nc + ), P !== null ? (w.stateNode = P, Cn = w, Mo = Ns(P.firstChild), nc = !1, B = !0) : B = !1), B || xd(w)), cr(w), B = w.type, V = w.pendingProps, ar = h !== null ? h.memoizedProps : null, P = V.children, hb(B, V) ? P = null : ar !== null && hb(B, ar) && (w.flags |= 32), w.memoizedState !== null && (B = As( + h, + w, + Gh, + null, + null, + T + ), gf._currentValue = B), Og(h, w), ha(h, w, P, T), w.child; + case 6: + return h === null && vo && ((h = T = Mo) && (T = bn( + T, + w.pendingProps, + nc + ), T !== null ? (w.stateNode = T, Cn = w, Mo = null, h = !0) : h = !1), h || xd(w)), null; + case 13: + return Gi(h, w, T); + case 4: + return pr( + w, + w.stateNode.containerInfo + ), P = w.pendingProps, h === null ? w.child = Vl( + w, + null, + P, + T + ) : ha(h, w, P, T), w.child; + case 11: + return yt( + h, + w, + w.type, + w.pendingProps, + T + ); + case 7: + return ha( + h, + w, + w.pendingProps, + T + ), w.child; + case 8: + return ha( + h, + w, + w.pendingProps.children, + T + ), w.child; + case 12: + return ha( + h, + w, + w.pendingProps.children, + T + ), w.child; + case 10: + return P = w.pendingProps, Rc(w, w.type, P.value), ha(h, w, P.children, T), w.child; + case 9: + return B = w.type._context, P = w.pendingProps.children, Bl(w), B = Oa(B), P = P(B), w.flags |= 1, ha(h, w, P, T), w.child; + case 14: + return dl( + h, + w, + w.type, + w.pendingProps, + T + ); + case 15: + return Jt( + h, + w, + w.type, + w.pendingProps, + T + ); + case 19: + return nb(h, w, T); + case 31: + return B0(h, w, T); + case 22: + return nu( + h, + w, + T, + w.pendingProps + ); + case 24: + return Bl(w), P = Oa(ra), h === null ? (B = Fl(), B === null && (B = Yt, V = ii(), B.pooledCache = V, V.refCount++, V !== null && (B.pooledCacheLanes |= T), B = V), w.memoizedState = { parent: P, cache: B }, wi(w), Rc(w, ra, B)) : ((h.lanes & T) !== 0 && (pg(h, w), Lu(w, null, null, T), Ss()), B = h.memoizedState, V = w.memoizedState, B.parent !== P ? (B = { parent: P, cache: P }, w.memoizedState = B, w.lanes === 0 && (w.memoizedState = w.updateQueue.baseState = B), Rc(w, ra, P)) : (P = V.cache, Rc(w, ra, P), P !== B.cache && Yb( + w, + [ra], + T, + !0 + ))), ha( + h, + w, + w.pendingProps.children, + T + ), w.child; + case 29: + throw w.pendingProps; + } + throw Error(o(156, w.tag)); + } + function zc(h) { + h.flags |= 4; + } + function wv(h, w, T, P, B) { + if ((w = (h.mode & 32) !== 0) && (w = !1), w) { + if (h.flags |= 16777216, (B & 335544128) === B) + if (h.stateNode.complete) h.flags |= 8192; + else if (Av()) h.flags |= 8192; + else + throw ea = lc, Td; + } else h.flags &= -16777217; + } + function Xh(h, w) { + if (w.type !== "stylesheet" || (w.state.loading & 4) !== 0) + h.flags &= -16777217; + else if (h.flags |= 16777216, !P1(w)) + if (Av()) h.flags |= 8192; + else + throw ea = lc, Td; + } + function ab(h, w) { + w !== null && (h.flags |= 4), h.flags & 16384 && (w = h.tag !== 22 ? Ze() : 536870912, h.lanes |= w, lu |= w); + } + function ah(h, w) { + if (!vo) + switch (h.tailMode) { + case "hidden": + w = h.tail; + for (var T = null; w !== null; ) + w.alternate !== null && (T = w), w = w.sibling; + T === null ? h.tail = null : T.sibling = null; + break; + case "collapsed": + T = h.tail; + for (var P = null; T !== null; ) + T.alternate !== null && (P = T), T = T.sibling; + P === null ? w || h.tail === null ? h.tail = null : h.tail.sibling = null : P.sibling = null; + } + } + function yn(h) { + var w = h.alternate !== null && h.alternate.child === h.child, T = 0, P = 0; + if (w) + for (var B = h.child; B !== null; ) + T |= B.lanes | B.childLanes, P |= B.subtreeFlags & 65011712, P |= B.flags & 65011712, B.return = h, B = B.sibling; + else + for (B = h.child; B !== null; ) + T |= B.lanes | B.childLanes, P |= B.subtreeFlags, P |= B.flags, B.return = h, B = B.sibling; + return h.subtreeFlags |= P, h.childLanes = T, w; + } + function V0(h, w, T) { + var P = w.pendingProps; + switch (ys(w), w.tag) { + case 16: + case 15: + case 0: + case 11: + case 7: + case 8: + case 12: + case 9: + case 14: + return yn(w), null; + case 1: + return yn(w), null; + case 3: + return T = w.stateNode, P = null, h !== null && (P = h.memoizedState.cache), w.memoizedState.cache !== P && (w.flags |= 2048), zl(ra), ur(), T.pendingContext && (T.context = T.pendingContext, T.pendingContext = null), (h === null || h.child === null) && (_d(w) ? zc(w) : h === null || h.memoizedState.isDehydrated && (w.flags & 256) === 0 || (w.flags |= 1024, Ll())), yn(w), null; + case 26: + var B = w.type, V = w.memoizedState; + return h === null ? (zc(w), V !== null ? (yn(w), Xh(w, V)) : (yn(w), wv( + w, + B, + null, + P, + T + ))) : V ? V !== h.memoizedState ? (zc(w), yn(w), Xh(w, V)) : (yn(w), w.flags &= -16777217) : (h = h.memoizedProps, h !== P && zc(w), yn(w), wv( + w, + B, + h, + P, + T + )), null; + case 27: + if (gr(w), T = dr.current, B = w.type, h !== null && w.stateNode != null) + h.memoizedProps !== P && zc(w); + else { + if (!P) { + if (w.stateNode === null) + throw Error(o(166)); + return yn(w), null; + } + h = or.current, _d(w) ? xs(w) : (h = _1(B, P, T), w.stateNode = h, zc(w)); + } + return yn(w), null; + case 5: + if (gr(w), B = w.type, h !== null && w.stateNode != null) + h.memoizedProps !== P && zc(w); + else { + if (!P) { + if (w.stateNode === null) + throw Error(o(166)); + return yn(w), null; + } + if (V = or.current, _d(w)) + xs(w); + else { + var ar = jv( + dr.current + ); + switch (V) { + case 1: + V = ar.createElementNS( + "http://www.w3.org/2000/svg", + B + ); + break; + case 2: + V = ar.createElementNS( + "http://www.w3.org/1998/Math/MathML", + B + ); + break; + default: + switch (B) { + case "svg": + V = ar.createElementNS( + "http://www.w3.org/2000/svg", + B + ); + break; + case "math": + V = ar.createElementNS( + "http://www.w3.org/1998/Math/MathML", + B + ); + break; + case "script": + V = ar.createElement("div"), V.innerHTML = "