From f73f2c6345a0076f1ba05a1bc032bc3c33a61b95 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Fri, 19 Sep 2025 14:18:04 -0700 Subject: [PATCH 01/14] more typing --- vite-app/src/GlobalState.tsx | 15 ++++++++++----- vite-app/src/components/EvaluationRow.tsx | 2 +- vite-app/src/components/FilterInput.tsx | 2 +- vite-app/src/components/FilterSelector.tsx | 2 +- vite-app/src/components/PivotTab.tsx | 2 +- vite-app/src/types/{filters.ts => configs.ts} | 10 ++++++++++ vite-app/src/util/field-processors.ts | 2 +- vite-app/src/util/filter-utils.ts | 2 +- 8 files changed, 26 insertions(+), 11 deletions(-) rename vite-app/src/types/{filters.ts => configs.ts} (80%) diff --git a/vite-app/src/GlobalState.tsx b/vite-app/src/GlobalState.tsx index 69ba2385..6cd9af49 100644 --- a/vite-app/src/GlobalState.tsx +++ b/vite-app/src/GlobalState.tsx @@ -1,6 +1,11 @@ import { makeAutoObservable, runInAction } from "mobx"; import type { EvaluationRow } from "./types/eval-protocol"; -import type { PivotConfig, FilterGroup } from "./types/filters"; +import type { + PivotConfig, + FilterGroup, + PaginationConfig, + SortConfig, +} from "./types/configs"; import flattenJson from "./util/flatten-json"; import type { FlatJson } from "./util/flatten-json"; import { createFilterFunction } from "./util/filter-utils"; @@ -17,13 +22,13 @@ const DEFAULT_PIVOT_CONFIG: PivotConfig = { const DEFAULT_FILTER_CONFIG: FilterGroup[] = []; // Default pagination configuration -const DEFAULT_PAGINATION_CONFIG = { +const DEFAULT_PAGINATION_CONFIG: PaginationConfig = { currentPage: 1, pageSize: 25, }; // Default sort configuration -const DEFAULT_SORT_CONFIG = { +const DEFAULT_SORT_CONFIG: SortConfig = { sortField: "created_at", sortDirection: "desc" as "asc" | "desc", }; @@ -110,7 +115,7 @@ export class GlobalState { } // Load pagination configuration from localStorage - private loadPaginationConfig() { + private loadPaginationConfig(): PaginationConfig { try { const stored = localStorage.getItem("paginationConfig"); if (stored) { @@ -128,7 +133,7 @@ export class GlobalState { } // Load sort configuration from localStorage - private loadSortConfig() { + private loadSortConfig(): SortConfig { try { const stored = localStorage.getItem("sortConfig"); if (stored) { diff --git a/vite-app/src/components/EvaluationRow.tsx b/vite-app/src/components/EvaluationRow.tsx index c6a0c015..9fc2f9b6 100644 --- a/vite-app/src/components/EvaluationRow.tsx +++ b/vite-app/src/components/EvaluationRow.tsx @@ -9,7 +9,7 @@ import StatusIndicator from "./StatusIndicator"; import { state } from "../App"; import { TableCell, TableRowInteractive } from "./TableContainer"; import { useState } from "react"; -import type { FilterGroup, FilterConfig } from "../types/filters"; +import type { FilterGroup, FilterConfig } from "../types/configs"; import { Tooltip } from "./Tooltip"; import { JSONTooltip } from "./JSONTooltip"; diff --git a/vite-app/src/components/FilterInput.tsx b/vite-app/src/components/FilterInput.tsx index c6d03f5a..36959c4d 100644 --- a/vite-app/src/components/FilterInput.tsx +++ b/vite-app/src/components/FilterInput.tsx @@ -1,5 +1,5 @@ import React, { useEffect, useRef, useState } from "react"; -import type { FilterConfig } from "../types/filters"; +import type { FilterConfig } from "../types/configs"; import { commonStyles } from "../styles/common"; interface FilterInputProps { diff --git a/vite-app/src/components/FilterSelector.tsx b/vite-app/src/components/FilterSelector.tsx index 2800063d..de9774fc 100644 --- a/vite-app/src/components/FilterSelector.tsx +++ b/vite-app/src/components/FilterSelector.tsx @@ -1,5 +1,5 @@ import React, { useCallback, useMemo } from "react"; -import type { FilterConfig, FilterGroup } from "../types/filters"; +import type { FilterConfig, FilterGroup } from "../types/configs"; import SearchableSelect from "./SearchableSelect"; import FilterInput from "./FilterInput"; import Button from "./Button"; diff --git a/vite-app/src/components/PivotTab.tsx b/vite-app/src/components/PivotTab.tsx index 27a6259b..c4259b7f 100644 --- a/vite-app/src/components/PivotTab.tsx +++ b/vite-app/src/components/PivotTab.tsx @@ -5,7 +5,7 @@ import ChartExport from "./ChartExport"; import SearchableSelect from "./SearchableSelect"; import Button from "./Button"; import FilterSelector from "./FilterSelector"; -import { type FilterGroup } from "../types/filters"; +import { type FilterGroup } from "../types/configs"; import { usePivotData } from "../hooks/usePivotData"; import { createFieldHandlerSet, diff --git a/vite-app/src/types/filters.ts b/vite-app/src/types/configs.ts similarity index 80% rename from vite-app/src/types/filters.ts rename to vite-app/src/types/configs.ts index c73bf61f..9b0b9f19 100644 --- a/vite-app/src/types/filters.ts +++ b/vite-app/src/types/configs.ts @@ -27,3 +27,13 @@ export interface PivotConfig { selectedValueField: string; selectedAggregator: string; } + +export interface PaginationConfig { + currentPage: number; + pageSize: number; +} + +export interface SortConfig { + sortField: string; + sortDirection: "asc" | "desc"; +} diff --git a/vite-app/src/util/field-processors.ts b/vite-app/src/util/field-processors.ts index e1851f15..ee752efd 100644 --- a/vite-app/src/util/field-processors.ts +++ b/vite-app/src/util/field-processors.ts @@ -1,6 +1,6 @@ import { state } from '../App'; import { createFilterFunction as createFilterFunctionUtil } from '../util/filter-utils'; -import { type FilterGroup } from '../types/filters'; +import { type FilterGroup } from '../types/configs'; /** * Utility functions for processing field configurations and creating handlers diff --git a/vite-app/src/util/filter-utils.ts b/vite-app/src/util/filter-utils.ts index 7a311476..f602ff52 100644 --- a/vite-app/src/util/filter-utils.ts +++ b/vite-app/src/util/filter-utils.ts @@ -1,4 +1,4 @@ -import type { FilterConfig, FilterGroup, FilterOperator } from "../types/filters"; +import type { FilterConfig, FilterGroup, FilterOperator } from "../types/configs"; // Filter utilities export const isDateField = (field: string): boolean => { From 0a03e0063eaa193055f93308a427ea826c9ac82a Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Fri, 19 Sep 2025 14:39:19 -0700 Subject: [PATCH 02/14] Add TypeScript formatter to VSCode settings --- .vscode/settings.json | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.vscode/settings.json b/.vscode/settings.json index 2c4a8fff..3d7f425e 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -10,5 +10,8 @@ "editor.formatOnSave": true, "[python]": { "editor.defaultFormatter": "charliermarsh.ruff" + }, + "[typescript]": { + "editor.defaultFormatter": "esbenp.prettier-vscode" } } From 4418a9c08833d918099dbb72b340f6d3171f9f62 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Fri, 19 Sep 2025 14:54:33 -0700 Subject: [PATCH 03/14] Refactor GlobalState to use GlobalConfig and improve pagination and sorting management - Introduced GlobalConfig interface to encapsulate pivot, filter, pagination, and sort configurations. - Updated GlobalState to utilize computed properties for pagination and sorting. - Refactored methods to directly manipulate pagination and sort configurations. - Enhanced FilterSelector and TableContainer components to use new FilterLogic and SortDirection types. - Improved type definitions in configs and filter utilities for better clarity and maintainability. --- vite-app/src/GlobalState.tsx | 149 ++++++++++++--------- vite-app/src/components/FilterSelector.tsx | 6 +- vite-app/src/components/TableContainer.tsx | 3 +- vite-app/src/types/configs.ts | 22 ++- vite-app/src/util/filter-utils.ts | 14 +- 5 files changed, 123 insertions(+), 71 deletions(-) diff --git a/vite-app/src/GlobalState.tsx b/vite-app/src/GlobalState.tsx index 6cd9af49..70b85cc8 100644 --- a/vite-app/src/GlobalState.tsx +++ b/vite-app/src/GlobalState.tsx @@ -5,6 +5,8 @@ import type { FilterGroup, PaginationConfig, SortConfig, + GlobalConfig, + SortDirection, } from "./types/configs"; import flattenJson from "./util/flatten-json"; import type { FlatJson } from "./util/flatten-json"; @@ -30,7 +32,14 @@ const DEFAULT_PAGINATION_CONFIG: PaginationConfig = { // Default sort configuration const DEFAULT_SORT_CONFIG: SortConfig = { sortField: "created_at", - sortDirection: "desc" as "asc" | "desc", + sortDirection: "desc", +}; + +const DEFAULT_GLOBAL_CONFIG: GlobalConfig = { + pivotConfig: DEFAULT_PIVOT_CONFIG, + filterConfig: DEFAULT_FILTER_CONFIG, + paginationConfig: DEFAULT_PAGINATION_CONFIG, + sortConfig: DEFAULT_SORT_CONFIG, }; export class GlobalState { @@ -43,14 +52,12 @@ export class GlobalState { pivotConfig: PivotConfig; // Unified filter configuration for both pivot and table views filterConfig: FilterGroup[]; - // Debounced, actually applied filter configuration (for performance while typing) - appliedFilterConfig: FilterGroup[]; // Pagination configuration - currentPage: number; - pageSize: number; + paginationConfig: PaginationConfig; // Sort configuration - sortField: string; - sortDirection: "asc" | "desc"; + sortConfig: SortConfig; + // Debounced, actually applied filter configuration (for performance while typing) + appliedFilterConfig: FilterGroup[]; // Loading state isLoading: boolean = true; @@ -75,16 +82,30 @@ export class GlobalState { // Initialize applied filter config with current value this.appliedFilterConfig = this.filterConfig.slice(); // Load pagination config from localStorage or use defaults - const paginationConfig = this.loadPaginationConfig(); - this.currentPage = paginationConfig.currentPage; - this.pageSize = paginationConfig.pageSize; + this.paginationConfig = this.loadPaginationConfig(); // Load sort config from localStorage or use defaults - const sortConfig = this.loadSortConfig(); - this.sortField = sortConfig.sortField; - this.sortDirection = sortConfig.sortDirection; + this.sortConfig = this.loadSortConfig(); makeAutoObservable(this); } + // Computed getters for individual pagination properties + get currentPage(): number { + return this.paginationConfig.currentPage; + } + + get pageSize(): number { + return this.paginationConfig.pageSize; + } + + // Computed getters for individual sort properties + get sortField(): string { + return this.sortConfig.sortField; + } + + get sortDirection(): SortDirection { + return this.sortConfig.sortDirection; + } + // Load pivot configuration from localStorage private loadPivotConfig(): PivotConfig { try { @@ -179,10 +200,7 @@ export class GlobalState { try { localStorage.setItem( "paginationConfig", - JSON.stringify({ - currentPage: this.currentPage, - pageSize: this.pageSize, - }) + JSON.stringify(this.paginationConfig) ); } catch (error) { console.warn( @@ -198,13 +216,7 @@ export class GlobalState { if (this.saveFilterConfigTimer) clearTimeout(this.saveFilterConfigTimer); this.saveFilterConfigTimer = setTimeout(() => { try { - localStorage.setItem( - "sortConfig", - JSON.stringify({ - sortField: this.sortField, - sortDirection: this.sortDirection, - }) - ); + localStorage.setItem("sortConfig", JSON.stringify(this.sortConfig)); } catch (error) { console.warn("Failed to save sort config to localStorage:", error); } @@ -230,37 +242,29 @@ export class GlobalState { } // Update pagination configuration and save to localStorage - updatePaginationConfig( - updates: Partial<{ currentPage: number; pageSize: number }> - ) { - if (updates.currentPage !== undefined) { - this.currentPage = updates.currentPage; - } - if (updates.pageSize !== undefined) { - this.pageSize = updates.pageSize; - } + updatePaginationConfig(updates: Partial) { + Object.assign(this.paginationConfig, updates); this.savePaginationConfig(); } // Update sort configuration and save to localStorage - updateSortConfig( - updates: Partial<{ sortField: string; sortDirection: "asc" | "desc" }> - ) { - Object.assign(this, updates); + updateSortConfig(updates: Partial) { + Object.assign(this.sortConfig, updates); // Reset to first page when sorting changes - this.currentPage = 1; + this.paginationConfig.currentPage = 1; this.saveSortConfig(); } // Handle sort field click - toggle direction if same field, set to asc if new field handleSortFieldClick(field: string) { - if (this.sortField === field) { + if (this.sortConfig.sortField === field) { // Toggle direction for same field - this.sortDirection = this.sortDirection === "asc" ? "desc" : "asc"; + this.sortConfig.sortDirection = + this.sortConfig.sortDirection === "asc" ? "desc" : "asc"; } else { // New field, set to ascending - this.sortField = field; - this.sortDirection = "asc"; + this.sortConfig.sortField = field; + this.sortConfig.sortDirection = "asc"; } this.saveSortConfig(); } @@ -280,28 +284,26 @@ export class GlobalState { // Reset pagination configuration to defaults resetPaginationConfig() { - this.currentPage = DEFAULT_PAGINATION_CONFIG.currentPage; - this.pageSize = DEFAULT_PAGINATION_CONFIG.pageSize; + this.paginationConfig = { ...DEFAULT_PAGINATION_CONFIG }; this.savePaginationConfig(); } // Reset sort configuration to defaults resetSortConfig() { - this.sortField = DEFAULT_SORT_CONFIG.sortField; - this.sortDirection = DEFAULT_SORT_CONFIG.sortDirection; + this.sortConfig = { ...DEFAULT_SORT_CONFIG }; this.saveSortConfig(); } // Set current page setCurrentPage(page: number) { - this.currentPage = page; + this.paginationConfig.currentPage = page; this.savePaginationConfig(); } // Set page size setPageSize(size: number) { - this.pageSize = size; - this.currentPage = 1; // Reset to first page when changing page size + this.paginationConfig.pageSize = size; + this.paginationConfig.currentPage = 1; // Reset to first page when changing page size this.savePaginationConfig(); } @@ -335,7 +337,7 @@ export class GlobalState { runInAction(() => { // Reset to first page when dataset changes - this.currentPage = 1; + this.paginationConfig.currentPage = 1; this.isLoading = false; }); this.savePaginationConfig(); @@ -365,16 +367,27 @@ export class GlobalState { }); } + get globalConfig(): GlobalConfig { + return { + pivotConfig: this.pivotConfig, + filterConfig: this.filterConfig, + paginationConfig: this.paginationConfig, + sortConfig: this.sortConfig, + }; + } + // Computed values following MobX best practices get sortedIds() { const ids = Object.keys(this.dataset); - if (this.sortField === "created_at") { + if (this.sortConfig.sortField === "created_at") { // Special case for created_at - use cached timestamp return ids.sort((a, b) => { const aTime = this.createdAtMsById[a] ?? 0; const bTime = this.createdAtMsById[b] ?? 0; - return this.sortDirection === "asc" ? aTime - bTime : bTime - aTime; + return this.sortConfig.sortDirection === "asc" + ? aTime - bTime + : bTime - aTime; }); } @@ -385,29 +398,35 @@ export class GlobalState { if (!aFlat || !bFlat) return 0; - const aValue = aFlat[this.sortField]; - const bValue = bFlat[this.sortField]; + const aValue = aFlat[this.sortConfig.sortField]; + const bValue = bFlat[this.sortConfig.sortField]; // Handle undefined values if (aValue === undefined && bValue === undefined) return 0; - if (aValue === undefined) return this.sortDirection === "asc" ? -1 : 1; - if (bValue === undefined) return this.sortDirection === "asc" ? 1 : -1; + if (aValue === undefined) + return this.sortConfig.sortDirection === "asc" ? -1 : 1; + if (bValue === undefined) + return this.sortConfig.sortDirection === "asc" ? 1 : -1; // Handle different types if (typeof aValue === "string" && typeof bValue === "string") { const comparison = aValue.localeCompare(bValue); - return this.sortDirection === "asc" ? comparison : -comparison; + return this.sortConfig.sortDirection === "asc" + ? comparison + : -comparison; } if (typeof aValue === "number" && typeof bValue === "number") { - return this.sortDirection === "asc" ? aValue - bValue : bValue - aValue; + return this.sortConfig.sortDirection === "asc" + ? aValue - bValue + : bValue - aValue; } // Fallback to string comparison const aStr = String(aValue); const bStr = String(bValue); const comparison = aStr.localeCompare(bStr); - return this.sortDirection === "asc" ? comparison : -comparison; + return this.sortConfig.sortDirection === "asc" ? comparison : -comparison; }); } @@ -456,14 +475,20 @@ export class GlobalState { } get totalPages() { - return Math.ceil(this.totalCount / this.pageSize); + return Math.ceil(this.totalCount / this.paginationConfig.pageSize); } get startRow() { - return (this.currentPage - 1) * this.pageSize + 1; + return ( + (this.paginationConfig.currentPage - 1) * this.paginationConfig.pageSize + + 1 + ); } get endRow() { - return Math.min(this.currentPage * this.pageSize, this.totalCount); + return Math.min( + this.paginationConfig.currentPage * this.paginationConfig.pageSize, + this.totalCount + ); } } diff --git a/vite-app/src/components/FilterSelector.tsx b/vite-app/src/components/FilterSelector.tsx index de9774fc..8726314e 100644 --- a/vite-app/src/components/FilterSelector.tsx +++ b/vite-app/src/components/FilterSelector.tsx @@ -1,5 +1,5 @@ import React, { useCallback, useMemo } from "react"; -import type { FilterConfig, FilterGroup } from "../types/configs"; +import type { FilterConfig, FilterGroup, FilterLogic } from "../types/configs"; import SearchableSelect from "./SearchableSelect"; import FilterInput from "./FilterInput"; import Button from "./Button"; @@ -30,7 +30,7 @@ const FilterSelectorComponent = ({ ); const updateFilterGroupLogic = useCallback( - (index: number, logic: "AND" | "OR") => { + (index: number, logic: FilterLogic) => { const newFilters = [...filters]; newFilters[index] = { ...newFilters[index], logic }; onFiltersChange(newFilters); @@ -110,7 +110,7 @@ const FilterSelectorComponent = ({ - updateFilterGroupLogic(groupIndex, value as "AND" | "OR") + updateFilterGroupLogic(groupIndex, value as FilterLogic) } options={[ { value: "AND", label: "AND (all filters must match)" }, diff --git a/vite-app/src/components/TableContainer.tsx b/vite-app/src/components/TableContainer.tsx index 0b04964e..fe368e9c 100644 --- a/vite-app/src/components/TableContainer.tsx +++ b/vite-app/src/components/TableContainer.tsx @@ -1,4 +1,5 @@ import React from "react"; +import type { SortDirection } from "../types/configs"; export interface TableContainerProps { /** @@ -42,7 +43,7 @@ export interface SortableTableHeaderProps extends TableHeaderProps { /** * Current sort direction */ - currentSortDirection: "asc" | "desc"; + currentSortDirection: SortDirection; /** * Click handler for sorting */ diff --git a/vite-app/src/types/configs.ts b/vite-app/src/types/configs.ts index 9b0b9f19..f1bf1e02 100644 --- a/vite-app/src/types/configs.ts +++ b/vite-app/src/types/configs.ts @@ -1,4 +1,13 @@ -export type Operator = "==" | "!=" | ">" | "<" | ">=" | "<=" | "contains" | "!contains" | "between"; +export type Operator = + | "==" + | "!=" + | ">" + | "<" + | ">=" + | "<=" + | "contains" + | "!contains" + | "between"; // Filter configuration interface export interface FilterConfig { @@ -14,9 +23,11 @@ export type FilterOperator = { label: string; }; +export type FilterLogic = "AND" | "OR"; + // Filter group interface for AND/OR logic export interface FilterGroup { - logic: "AND" | "OR"; + logic: FilterLogic; filters: FilterConfig[]; } @@ -37,3 +48,10 @@ export interface SortConfig { sortField: string; sortDirection: "asc" | "desc"; } + +export interface GlobalConfig { + pivotConfig: PivotConfig; + filterConfig: FilterGroup[]; + paginationConfig: PaginationConfig; + sortConfig: SortConfig; +} diff --git a/vite-app/src/util/filter-utils.ts b/vite-app/src/util/filter-utils.ts index f602ff52..9ab2a77e 100644 --- a/vite-app/src/util/filter-utils.ts +++ b/vite-app/src/util/filter-utils.ts @@ -1,4 +1,9 @@ -import type { FilterConfig, FilterGroup, FilterOperator } from "../types/configs"; +import type { + FilterConfig, + FilterGroup, + FilterOperator, + FilterType, +} from "../types/configs"; // Filter utilities export const isDateField = (field: string): boolean => { @@ -10,11 +15,14 @@ export const isDateField = (field: string): boolean => { ); }; -export const getFieldType = (field: string): "text" | "date" | "date-range" => { +export const getFieldType = (field: string): FilterType => { return isDateField(field) ? "date" : "text"; }; -export const getOperatorsForField = (field: string, type?: string): FilterOperator[] => { +export const getOperatorsForField = ( + field: string, + type?: string +): FilterOperator[] => { if (type === "date" || type === "date-range" || isDateField(field)) { return [ { value: ">=", label: "on or after" }, From f080e642de022bb16422d177206325207ef78c31 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Fri, 19 Sep 2025 15:11:41 -0700 Subject: [PATCH 04/14] tests work --- vite-app/src/util/query-params.test.ts | 857 +++++++++++++++++++++++++ vite-app/src/util/query-params.ts | 102 +++ 2 files changed, 959 insertions(+) create mode 100644 vite-app/src/util/query-params.test.ts create mode 100644 vite-app/src/util/query-params.ts diff --git a/vite-app/src/util/query-params.test.ts b/vite-app/src/util/query-params.test.ts new file mode 100644 index 00000000..5dbba8ad --- /dev/null +++ b/vite-app/src/util/query-params.test.ts @@ -0,0 +1,857 @@ +import { describe, it, expect } from "vitest"; +import { nonDefaultValues } from "./query-params"; +import type { GlobalConfig } from "../types/configs"; +import { DEFAULT_GLOBAL_CONFIG } from "../GlobalState"; + +describe("query-params", () => { + describe("nonDefaultValues", () => { + it("returns empty object when config matches default", () => { + const result = nonDefaultValues(DEFAULT_GLOBAL_CONFIG); + expect(result).toEqual({}); + }); + + it("returns empty object when config is identical to default", () => { + const identicalConfig: GlobalConfig = { + pivotConfig: { + selectedRowFields: ["$.eval_metadata.name"], + selectedColumnFields: ["$.input_metadata.completion_params.model"], + selectedValueField: "$.evaluation_result.score", + selectedAggregator: "avg", + }, + filterConfig: [], + paginationConfig: { + currentPage: 1, + pageSize: 25, + }, + sortConfig: { + sortField: "created_at", + sortDirection: "desc", + }, + }; + + const result = nonDefaultValues(identicalConfig); + expect(result).toEqual({}); + }); + + it("detects differences in pivot config", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedRowFields: [ + "$.eval_metadata.name", + "$.eval_metadata.version", + ], + selectedAggregator: "sum", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedRowFields": + '["$.eval_metadata.name","$.eval_metadata.version"]', + "pivotConfig.selectedAggregator": '"sum"', + }); + }); + + it("detects differences in filter config", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "score", + operator: ">", + value: "0.5", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"score","operator":">","value":"0.5","type":"text"}]}]', + }); + }); + + it("detects differences in pagination config", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + paginationConfig: { + currentPage: 3, + pageSize: 50, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "paginationConfig.currentPage": "3", + "paginationConfig.pageSize": "50", + }); + }); + + it("detects differences in sort config", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + sortConfig: { + sortField: "score", + sortDirection: "asc", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "sortConfig.sortField": '"score"', + "sortConfig.sortDirection": '"asc"', + }); + }); + + it("detects multiple differences across different config sections", () => { + const modifiedConfig: GlobalConfig = { + pivotConfig: { + selectedRowFields: ["$.eval_metadata.name"], + selectedColumnFields: ["$.input_metadata.completion_params.model"], + selectedValueField: "$.evaluation_result.score", + selectedAggregator: "max", + }, + filterConfig: [ + { + logic: "OR", + filters: [ + { + field: "status", + operator: "==", + value: "completed", + type: "text", + }, + ], + }, + ], + paginationConfig: { + currentPage: 2, + pageSize: 100, + }, + sortConfig: { + sortField: "timestamp", + sortDirection: "asc", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedAggregator": '"max"', + filterConfig: + '[{"logic":"OR","filters":[{"field":"status","operator":"==","value":"completed","type":"text"}]}]', + "paginationConfig.currentPage": "2", + "paginationConfig.pageSize": "100", + "sortConfig.sortField": '"timestamp"', + "sortConfig.sortDirection": '"asc"', + }); + }); + + it("handles nested array differences in filter config", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "score", + operator: ">", + value: "0.5", + type: "text", + }, + { + field: "status", + operator: "==", + value: "active", + type: "text", + }, + ], + }, + { + logic: "OR", + filters: [ + { + field: "category", + operator: "contains", + value: "test", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"score","operator":">","value":"0.5","type":"text"},{"field":"status","operator":"==","value":"active","type":"text"}]},{"logic":"OR","filters":[{"field":"category","operator":"contains","value":"test","type":"text"}]}]', + }); + }); + + it("handles null and undefined values correctly", () => { + const configWithNulls: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "test", + operator: "==", + value: "null", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(configWithNulls); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"test","operator":"==","value":"null","type":"text"}]}]', + }); + }); + + it("handles empty arrays correctly", () => { + const configWithEmptyArrays: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedRowFields: [], + selectedColumnFields: [], + }, + }; + + const result = nonDefaultValues(configWithEmptyArrays); + + expect(result).toEqual({ + "pivotConfig.selectedRowFields": "[]", + "pivotConfig.selectedColumnFields": "[]", + }); + }); + + it("handles complex nested structures", () => { + const complexConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "metadata.tags", + operator: "contains", + value: "important", + type: "text", + }, + { + field: "score", + operator: "between", + value: "0.5", + value2: "1.0", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(complexConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"metadata.tags","operator":"contains","value":"important","type":"text"},{"field":"score","operator":"between","value":"0.5","value2":"1.0","type":"text"}]}]', + }); + }); + + it("preserves JSON serialization format", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedRowFields: ["field1", "field2"], + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + // Verify that arrays are properly JSON stringified + expect(result["pivotConfig.selectedRowFields"]).toBe( + '["field1","field2"]' + ); + + // Verify that strings are properly JSON stringified (with quotes) + expect(result["pivotConfig.selectedAggregator"]).toBeUndefined(); // No change from default + }); + + it("handles edge case with all default values but different object references", () => { + // Create a config that has the same values but different object references + const configWithNewObjects: GlobalConfig = { + pivotConfig: { + selectedRowFields: ["$.eval_metadata.name"], + selectedColumnFields: ["$.input_metadata.completion_params.model"], + selectedValueField: "$.evaluation_result.score", + selectedAggregator: "avg", + }, + filterConfig: [], + paginationConfig: { + currentPage: 1, + pageSize: 25, + }, + sortConfig: { + sortField: "created_at", + sortDirection: "desc", + }, + }; + + const result = nonDefaultValues(configWithNewObjects); + + // Should return empty object since values are identical to defaults + expect(result).toEqual({}); + }); + + it("handles boolean values correctly", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "isActive", + operator: "==", + value: "true", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"isActive","operator":"==","value":"true","type":"text"}]}]', + }); + }); + + it("handles numeric values correctly", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + paginationConfig: { + currentPage: 0, + pageSize: 1000, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "paginationConfig.currentPage": "0", + "paginationConfig.pageSize": "1000", + }); + }); + + it("handles special characters in string values", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedValueField: "$.metadata['special-chars']", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedValueField": "\"$.metadata['special-chars']\"", + }); + }); + + it("handles deeply nested filter configurations", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "metadata.nested.deep.value", + operator: "contains", + value: "test", + type: "text", + }, + { + field: "scores[0]", + operator: ">", + value: "0.5", + type: "text", + }, + ], + }, + { + logic: "OR", + filters: [ + { + field: "status", + operator: "==", + value: "active", + type: "text", + }, + { + field: "status", + operator: "==", + value: "pending", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"metadata.nested.deep.value","operator":"contains","value":"test","type":"text"},{"field":"scores[0]","operator":">","value":"0.5","type":"text"}]},{"logic":"OR","filters":[{"field":"status","operator":"==","value":"active","type":"text"},{"field":"status","operator":"==","value":"pending","type":"text"}]}]', + }); + }); + + it("handles date range filters correctly", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "created_at", + operator: "between", + value: "2024-01-01", + value2: "2024-12-31", + type: "date-range", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"created_at","operator":"between","value":"2024-01-01","value2":"2024-12-31","type":"date-range"}]}]', + }); + }); + + it("handles all sort directions", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + sortConfig: { + sortField: "name", + sortDirection: "asc", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "sortConfig.sortField": '"name"', + "sortConfig.sortDirection": '"asc"', + }); + }); + + it("handles all aggregator types", () => { + const aggregators = ["sum", "min", "max", "count"]; // Exclude "avg" since it's the default + + for (const aggregator of aggregators) { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedAggregator: aggregator, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedAggregator": `"${aggregator}"`, + }); + } + }); + + it("verifies default aggregator returns empty result", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedAggregator: "avg", // This is the default value + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({}); + }); + + it("handles all filter operators", () => { + const operators = [ + "==", + "!=", + ">", + "<", + ">=", + "<=", + "contains", + "!contains", + "between", + ]; + + for (const operator of operators) { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "test", + operator: operator as any, + value: "test-value", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: `[{"logic":"AND","filters":[{"field":"test","operator":"${operator}","value":"test-value","type":"text"}]}]`, + }); + } + }); + + it("handles all filter logic types", () => { + const logics = ["AND", "OR"]; + + for (const logic of logics) { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: logic as any, + filters: [ + { + field: "test", + operator: "==", + value: "test-value", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: `[{"logic":"${logic}","filters":[{"field":"test","operator":"==","value":"test-value","type":"text"}]}]`, + }); + } + }); + + it("handles all filter types", () => { + const filterTypes = ["text", "date", "date-range"]; + + for (const filterType of filterTypes) { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "test", + operator: "==", + value: "test-value", + type: filterType as any, + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: `[{"logic":"AND","filters":[{"field":"test","operator":"==","value":"test-value","type":"${filterType}"}]}]`, + }); + } + }); + + it("handles very large page sizes", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + paginationConfig: { + currentPage: 1, + pageSize: 10000, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "paginationConfig.pageSize": "10000", + }); + }); + + it("handles zero values correctly", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + paginationConfig: { + currentPage: 0, + pageSize: 0, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "paginationConfig.currentPage": "0", + "paginationConfig.pageSize": "0", + }); + }); + + it("handles negative values correctly", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + paginationConfig: { + currentPage: -1, + pageSize: -5, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "paginationConfig.currentPage": "-1", + "paginationConfig.pageSize": "-5", + }); + }); + + it("handles very long field names", () => { + const longFieldName = + "very_long_field_name_that_might_be_used_in_real_world_scenarios_with_deeply_nested_objects_and_arrays"; + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedValueField: `$.${longFieldName}`, + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedValueField": `"$.${longFieldName}"`, + }); + }); + + it("handles unicode characters in values", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedValueField: "$.metadata.测试字段", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedValueField": '"$.metadata.测试字段"', + }); + }); + + it("handles empty string values", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedValueField: "", + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedValueField": '""', + }); + }); + + it("handles very deep nesting in filter configs", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p", + operator: "==", + value: "deep_value", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p","operator":"==","value":"deep_value","type":"text"}]}]', + }); + }); + + it("handles mixed data types in arrays", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedRowFields: ["string", "123", "true", "null"], + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedRowFields": '["string","123","true","null"]', + }); + }); + + it("handles complex JSON paths", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + ...DEFAULT_GLOBAL_CONFIG.pivotConfig, + selectedRowFields: [ + "$.data[0].items[1].metadata.tags[2]", + "$['special-key'].value", + "$.nested['with spaces'].value", + ], + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedRowFields": + '["$.data[0].items[1].metadata.tags[2]","$[\'special-key\'].value","$.nested[\'with spaces\'].value"]', + }); + }); + + it("handles partial config changes with some defaults preserved", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + pivotConfig: { + selectedRowFields: ["$.eval_metadata.name"], // Same as default + selectedColumnFields: ["$.input_metadata.completion_params.model"], // Same as default + selectedValueField: "$.evaluation_result.score", // Same as default + selectedAggregator: "sum", // Different from default + }, + filterConfig: [], // Same as default + paginationConfig: { + currentPage: 1, // Same as default + pageSize: 50, // Different from default + }, + sortConfig: { + sortField: "created_at", // Same as default + sortDirection: "asc", // Different from default + }, + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + "pivotConfig.selectedAggregator": '"sum"', + "paginationConfig.pageSize": "50", + "sortConfig.sortDirection": '"asc"', + }); + }); + + it("handles edge case with undefined values in optional fields", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "test", + operator: "==", + value: "test", + type: "text", + // value2 is optional and undefined + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"test","operator":"==","value":"test","type":"text"}]}]', + }); + }); + + it("handles edge case with value2 field in between operator", () => { + const modifiedConfig: GlobalConfig = { + ...DEFAULT_GLOBAL_CONFIG, + filterConfig: [ + { + logic: "AND", + filters: [ + { + field: "score", + operator: "between", + value: "0.5", + value2: "1.0", + type: "text", + }, + ], + }, + ], + }; + + const result = nonDefaultValues(modifiedConfig); + + expect(result).toEqual({ + filterConfig: + '[{"logic":"AND","filters":[{"field":"score","operator":"between","value":"0.5","value2":"1.0","type":"text"}]}]', + }); + }); + }); +}); diff --git a/vite-app/src/util/query-params.ts b/vite-app/src/util/query-params.ts new file mode 100644 index 00000000..e6e104b0 --- /dev/null +++ b/vite-app/src/util/query-params.ts @@ -0,0 +1,102 @@ +/** + * Module for handling the reactivity, update, and querying of query params based on GlobalState + */ + +import { autorun } from "mobx"; +import { state } from "../App"; +import type { GlobalConfig } from "../types/configs"; +import { DEFAULT_GLOBAL_CONFIG } from "../GlobalState"; + +export function initWatcher() { + autorun(() => { + const globalConfig = state.globalConfig; + console.log(JSON.stringify(globalConfig)); + }); +} + +export function nonDefaultValues( + globalConfig: GlobalConfig, + defaultConfig: GlobalConfig = DEFAULT_GLOBAL_CONFIG +): Record { + /** + * Return a collection of non-default values based on an instance of GlobalConfig + * + * This is particularly useful for computing query params since we want to + * keep the links as minimal as possible so they are easy to understand and + * log to console. + * + * Return + * - The key is a JSON path to the field + * - The value is the JSON serialized value of the field + */ + return calculateDifferentValues(globalConfig, defaultConfig); +} + +function calculateDifferentValues( + globalConfig: GlobalConfig, + defaultConfig: GlobalConfig +): Record { + const differences: Record = {}; + + function compareObjects(obj1: any, obj2: any, path: string = ""): void { + // Handle null/undefined cases + if (obj1 === null || obj1 === undefined) { + if (obj2 !== null && obj2 !== undefined) { + differences[path] = JSON.stringify(obj1); + } + return; + } + + if (obj2 === null || obj2 === undefined) { + if (obj1 !== null && obj1 !== undefined) { + differences[path] = JSON.stringify(obj1); + } + return; + } + + // Handle primitive types + if (typeof obj1 !== "object" || typeof obj2 !== "object") { + if (obj1 !== obj2) { + differences[path] = JSON.stringify(obj1); + } + return; + } + + // Handle arrays + if (Array.isArray(obj1) && Array.isArray(obj2)) { + if (JSON.stringify(obj1) !== JSON.stringify(obj2)) { + differences[path] = JSON.stringify(obj1); + } + return; + } + + // Handle objects + if (Array.isArray(obj1) || Array.isArray(obj2)) { + if (JSON.stringify(obj1) !== JSON.stringify(obj2)) { + differences[path] = JSON.stringify(obj1); + } + return; + } + + // Get all unique keys from both objects + const allKeys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]); + + for (const key of allKeys) { + const currentPath = path ? `${path}.${key}` : key; + + if (!(key in obj1)) { + // Key exists in obj2 but not obj1 + differences[currentPath] = JSON.stringify(undefined); + } else if (!(key in obj2)) { + // Key exists in obj1 but not obj2 + differences[currentPath] = JSON.stringify(obj1[key]); + } else { + // Key exists in both objects, compare recursively + compareObjects(obj1[key], obj2[key], currentPath); + } + } + } + + compareObjects(globalConfig, defaultConfig); + return differences; +} From 927d5b9c56815cac39406478fd038beaa51dcfda Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Fri, 19 Sep 2025 15:53:03 -0700 Subject: [PATCH 05/14] fix pivot.test.ts --- vite-app/src/util/pivot.test.ts | 514 ++++++++++++++++---------------- 1 file changed, 259 insertions(+), 255 deletions(-) diff --git a/vite-app/src/util/pivot.test.ts b/vite-app/src/util/pivot.test.ts index 558208b7..b2d45fa6 100644 --- a/vite-app/src/util/pivot.test.ts +++ b/vite-app/src/util/pivot.test.ts @@ -1,402 +1,406 @@ -import { describe, it, expect } from 'vitest' -import { computePivot, type Aggregator } from './pivot' -import { readFileSync } from 'fs' -import flattenJson, { type FlatJson } from './flatten-json' +import { describe, it, expect } from "vitest"; +import { computePivot, type Aggregator } from "./pivot"; +import { readFileSync } from "fs"; +import flattenJson, { type FlatJson } from "./flatten-json"; type Row = { - region: string - rep: string - product: string - amount?: number | string -} + region: string; + rep: string; + product: string; + amount?: number | string; +}; const rows: Row[] = [ - { region: 'West', rep: 'A', product: 'Widget', amount: 120 }, - { region: 'West', rep: 'B', product: 'Gadget', amount: 90 }, - { region: 'East', rep: 'A', product: 'Widget', amount: 200 }, - { region: 'East', rep: 'B', product: 'Gadget', amount: '10' }, - { region: 'East', rep: 'B', product: 'Gadget', amount: 'not-a-number' }, - -] - -describe('computePivot', () => { - it('computes count when no valueField provided', () => { + { region: "West", rep: "A", product: "Widget", amount: 120 }, + { region: "West", rep: "B", product: "Gadget", amount: 90 }, + { region: "East", rep: "A", product: "Widget", amount: 200 }, + { region: "East", rep: "B", product: "Gadget", amount: "10" }, + { region: "East", rep: "B", product: "Gadget", amount: "not-a-number" }, +]; + +describe("computePivot", () => { + it("computes count when no valueField provided", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - }) + rowFields: ["region"], + columnFields: ["product"], + }); // Expect two row keys and two column keys - expect(res.rowKeyTuples.map((t) => String(t))).toEqual([ - 'East', - 'West', - ]) + expect(res.rowKeyTuples.map((t) => String(t))).toEqual(["East", "West"]); expect(res.colKeyTuples.map((t) => String(t))).toEqual([ - 'Gadget', - 'Widget', - ]) + "Gadget", + "Widget", + ]); // East/Gadget should count two (one invalid amount ignored in count mode) - const rKeyEast = 'East' - const cKeyGadget = 'Gadget' - expect(res.cells[rKeyEast][cKeyGadget].value).toBe(2) - }) + const rKeyEast = "East"; + const cKeyGadget = "Gadget"; + expect(res.cells[rKeyEast][cKeyGadget].value).toBe(2); + }); - it('computes sum aggregator', () => { + it("computes sum aggregator", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'sum', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "sum", + }); - const rKeyEast = 'East' - const rKeyWest = 'West' - const cKeyGadget = 'Gadget' - const cKeyWidget = 'Widget' + const rKeyEast = "East"; + const rKeyWest = "West"; + const cKeyGadget = "Gadget"; + const cKeyWidget = "Widget"; // East Gadget: 10 (string convertible) + invalid -> 10 - expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10) + expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10); // West Gadget: 90 - expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90) + expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90); // East Widget: 200 - expect(res.cells[rKeyEast][cKeyWidget].value).toBe(200) + expect(res.cells[rKeyEast][cKeyWidget].value).toBe(200); // West Widget: 120 - expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120) - }) + expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120); + }); - it('computes average aggregator', () => { + it("computes average aggregator", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'avg', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "avg", + }); - const rKeyEast = 'East' - const rKeyWest = 'West' - const cKeyGadget = 'Gadget' + const rKeyEast = "East"; + const rKeyWest = "West"; + const cKeyGadget = "Gadget"; // East Gadget: values -> [10] => avg 10 - expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10) + expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10); // West Gadget: values -> [90] => avg 90 - expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90) - }) + expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90); + }); - it('computes minimum aggregator', () => { + it("computes minimum aggregator", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'min', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "min", + }); - const rKeyEast = 'East' - const rKeyWest = 'West' - const cKeyGadget = 'Gadget' - const cKeyWidget = 'Widget' + const rKeyEast = "East"; + const rKeyWest = "West"; + const cKeyGadget = "Gadget"; + const cKeyWidget = "Widget"; // East Gadget: values -> [10] => min 10 - expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10) + expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10); // West Gadget: values -> [90] => min 90 - expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90) + expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90); // East Widget: values -> [200] => min 200 - expect(res.cells[rKeyEast][cKeyWidget].value).toBe(200) + expect(res.cells[rKeyEast][cKeyWidget].value).toBe(200); // West Widget: values -> [120] => min 120 - expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120) - }) + expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120); + }); - it('computes maximum aggregator', () => { + it("computes maximum aggregator", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'max', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "max", + }); - const rKeyEast = 'East' - const rKeyWest = 'West' - const cKeyGadget = 'Gadget' - const cKeyWidget = 'Widget' + const rKeyEast = "East"; + const rKeyWest = "West"; + const cKeyGadget = "Gadget"; + const cKeyWidget = "Widget"; // East Gadget: values -> [10] => max 10 - expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10) + expect(res.cells[rKeyEast][cKeyGadget].value).toBe(10); // West Gadget: values -> [90] => max 90 - expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90) + expect(res.cells[rKeyWest][cKeyGadget].value).toBe(90); // East Widget: values -> [200] => max 200 - expect(res.cells[rKeyEast][cKeyWidget].value).toBe(200) + expect(res.cells[rKeyEast][cKeyWidget].value).toBe(200); // West Widget: values -> [120] => max 120 - expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120) - }) + expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120); + }); - it('handles empty cells for min/max aggregators', () => { + it("handles empty cells for min/max aggregators", () => { // Add a row with no valid numeric values const rowsWithEmpty = [ ...rows, - { region: 'North', rep: 'C', product: 'Widget', amount: 'not-a-number' }, - { region: 'North', rep: 'D', product: 'Gadget', amount: 'also-not-a-number' }, - ] + { region: "North", rep: "C", product: "Widget", amount: "not-a-number" }, + { + region: "North", + rep: "D", + product: "Gadget", + amount: "also-not-a-number", + }, + ]; const res = computePivot({ data: rowsWithEmpty, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'min', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "min", + }); - const rKeyNorth = 'North' - const cKeyWidget = 'Widget' - const cKeyGadget = 'Gadget' + const rKeyNorth = "North"; + const cKeyWidget = "Widget"; + const cKeyGadget = "Gadget"; // North region has no valid numeric values, should return 0 for min - expect(res.cells[rKeyNorth][cKeyWidget].value).toBe(0) - expect(res.cells[rKeyNorth][cKeyGadget].value).toBe(0) - }) + expect(res.cells[rKeyNorth][cKeyWidget].value).toBe(0); + expect(res.cells[rKeyNorth][cKeyGadget].value).toBe(0); + }); - it('applies filter before pivoting', () => { + it("applies filter before pivoting", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'sum', - filter: (record) => record.region === 'East', // Only include East region - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "sum", + filter: (record) => record.region === "East", // Only include East region + }); // Should only have East region rows - expect(res.rowKeyTuples.map((t) => String(t))).toEqual(['East']) + expect(res.rowKeyTuples.map((t) => String(t))).toEqual(["East"]); // Should still have all product columns - expect(res.colKeyTuples.map((t) => String(t))).toEqual(['Gadget', 'Widget']) + expect(res.colKeyTuples.map((t) => String(t)).sort()).toEqual( + ["Gadget", "Widget"].sort() + ); // East Gadget: 10 (string convertible) + invalid -> 10 - expect(res.cells['East']['Gadget'].value).toBe(10) + expect(res.cells["East"]["Gadget"].value).toBe(10); // East Widget: 200 - expect(res.cells['East']['Widget'].value).toBe(200) + expect(res.cells["East"]["Widget"].value).toBe(200); // West region should not be present - expect(res.cells['West']).toBeUndefined() + expect(res.cells["West"]).toBeUndefined(); // Grand total should only include East region data - expect(res.grandTotal).toBe(210) // 10 + 200 - }) + expect(res.grandTotal).toBe(210); // 10 + 200 + }); - it('column totals use same aggregation method as cells', () => { + it("column totals use same aggregation method as cells", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'avg', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "avg", + }); // Row totals should sum the cell values (for display purposes) - expect(res.rowTotals['East']).toBe(105) // (10 + 200) / 2 = 105 - expect(res.rowTotals['West']).toBe(105) // (90 + 120) / 2 = 105 + expect(res.rowTotals["East"]).toBe(105); // (10 + 200) / 2 = 105 + expect(res.rowTotals["West"]).toBe(105); // (90 + 120) / 2 = 105 // Column totals should use the same aggregation method (avg) over all records in that column // Gadget column: values [90, 10] -> avg = 50 - expect(res.colTotals['Gadget']).toBe(50) + expect(res.colTotals["Gadget"]).toBe(50); // Widget column: values [120, 200] -> avg = 160 - expect(res.colTotals['Widget']).toBe(160) + expect(res.colTotals["Widget"]).toBe(160); // Grand total should also use avg over all records - expect(res.grandTotal).toBe(105) // (90 + 10 + 120 + 200) / 4 = 105 - }) + expect(res.grandTotal).toBe(105); // (90 + 10 + 120 + 200) / 4 = 105 + }); - it('column totals with count aggregator', () => { + it("column totals with count aggregator", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - aggregator: 'count', // No valueField, just count records - }) + rowFields: ["region"], + columnFields: ["product"], + aggregator: "count", // No valueField, just count records + }); // Each cell should count records - expect(res.cells['East']['Gadget'].value).toBe(2) // 2 records - expect(res.cells['East']['Widget'].value).toBe(1) // 1 record - expect(res.cells['West']['Gadget'].value).toBe(1) // 1 record - expect(res.cells['West']['Widget'].value).toBe(1) // 1 record + expect(res.cells["East"]["Gadget"].value).toBe(2); // 2 records + expect(res.cells["East"]["Widget"].value).toBe(1); // 1 record + expect(res.cells["West"]["Gadget"].value).toBe(1); // 1 record + expect(res.cells["West"]["Widget"].value).toBe(1); // 1 record // Row totals should sum the counts - expect(res.rowTotals['East']).toBe(3) // 2 + 1 - expect(res.rowTotals['West']).toBe(2) // 1 + 1 + expect(res.rowTotals["East"]).toBe(3); // 2 + 1 + expect(res.rowTotals["West"]).toBe(2); // 1 + 1 // Column totals should count total records in each column - expect(res.colTotals['Gadget']).toBe(3) // 2 + 1 = 3 records - expect(res.colTotals['Widget']).toBe(2) // 1 + 1 = 2 records + expect(res.colTotals["Gadget"]).toBe(3); // 2 + 1 = 3 records + expect(res.colTotals["Widget"]).toBe(2); // 1 + 1 = 2 records // Grand total should count all records - expect(res.grandTotal).toBe(5) // Total records - }) + expect(res.grandTotal).toBe(5); // Total records + }); - it('supports custom aggregator', () => { + it("supports custom aggregator", () => { const maxAgg: Aggregator = (values) => - values.length ? Math.max(...values) : 0 + values.length ? Math.max(...values) : 0; const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", aggregator: maxAgg, - }) + }); - const rKeyWest = 'West' - const cKeyWidget = 'Widget' - expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120) - }) + const rKeyWest = "West"; + const cKeyWidget = "Widget"; + expect(res.cells[rKeyWest][cKeyWidget].value).toBe(120); + }); - it('supports multiple column fields (composite columns)', () => { + it("supports multiple column fields (composite columns)", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product', 'rep'], - valueField: 'amount', - aggregator: 'sum', - }) + rowFields: ["region"], + columnFields: ["product", "rep"], + valueField: "amount", + aggregator: "sum", + }); // Row and column key tuples - expect(res.rowKeyTuples).toEqual([ - ['East'], - ['West'], - ]) - expect(res.colKeyTuples).toEqual([ - ['Gadget', 'B'], - ['Widget', 'A'], - ]) - - const rEast = 'East' - const rWest = 'West' - const cGadgetB = 'Gadget||B' - const cWidgetA = 'Widget||A' + expect(res.rowKeyTuples).toEqual([["East"], ["West"]]); + // Normalize order for comparison since columns are sorted by aggregate score + const expectedColTuples = [ + ["Gadget", "B"], + ["Widget", "A"], + ]; + expect(res.colKeyTuples.sort()).toEqual(expectedColTuples.sort()); + + const rEast = "East"; + const rWest = "West"; + const cGadgetB = "Gadget||B"; + const cWidgetA = "Widget||A"; // Cell values (sum of numeric amounts) - expect(res.cells[rEast][cGadgetB].value).toBe(10) - expect(res.cells[rWest][cGadgetB].value).toBe(90) - expect(res.cells[rEast][cWidgetA].value).toBe(200) - expect(res.cells[rWest][cWidgetA].value).toBe(120) + expect(res.cells[rEast][cGadgetB].value).toBe(10); + expect(res.cells[rWest][cGadgetB].value).toBe(90); + expect(res.cells[rEast][cWidgetA].value).toBe(200); + expect(res.cells[rWest][cWidgetA].value).toBe(120); // Totals - expect(res.rowTotals[rEast]).toBe(210) - expect(res.rowTotals[rWest]).toBe(210) - expect(res.colTotals[cGadgetB]).toBe(100) - expect(res.colTotals[cWidgetA]).toBe(320) - expect(res.grandTotal).toBe(420) - }) - - it('skips records with undefined row field values', () => { + expect(res.rowTotals[rEast]).toBe(210); + expect(res.rowTotals[rWest]).toBe(210); + expect(res.colTotals[cGadgetB]).toBe(100); + expect(res.colTotals[cWidgetA]).toBe(320); + expect(res.grandTotal).toBe(420); + }); + + it("skips records with undefined row field values", () => { type LooseRow = { - region?: string - rep?: string - product?: string - amount?: number | string - } + region?: string; + rep?: string; + product?: string; + amount?: number | string; + }; const mixed: LooseRow[] = [ - { region: 'West', rep: 'A', product: 'Widget', amount: 120 }, + { region: "West", rep: "A", product: "Widget", amount: 120 }, // Missing region should be excluded from cells entirely - { rep: 'B', product: 'Gadget', amount: 90 }, - ] + { rep: "B", product: "Gadget", amount: 90 }, + ]; const res = computePivot({ data: mixed, - rowFields: ['region'], - columnFields: ['product'], - }) + rowFields: ["region"], + columnFields: ["product"], + }); // Only 'West' row should be present; no 'undefined' row key - expect(res.rowKeyTuples.map((t) => String(t))).toEqual(['West']) - expect(Object.keys(res.cells)).toEqual(['West']) + expect(res.rowKeyTuples.map((t) => String(t))).toEqual(["West"]); + expect(Object.keys(res.cells)).toEqual(["West"]); - const rKeyWest = 'West' - const cKeyWidget = 'Widget' + const rKeyWest = "West"; + const cKeyWidget = "Widget"; // Count aggregator by default; only the valid record should be counted - expect(res.cells[rKeyWest][cKeyWidget].value).toBe(1) + expect(res.cells[rKeyWest][cKeyWidget].value).toBe(1); // Grand total reflects only included records - expect(res.grandTotal).toBe(1) - }) + expect(res.grandTotal).toBe(1); + }); - it('skips records with undefined column field values', () => { + it("skips records with undefined column field values", () => { type LooseRow = { - region: string - rep?: string - product?: string - amount?: number | string - } + region: string; + rep?: string; + product?: string; + amount?: number | string; + }; const mixed: LooseRow[] = [ - { region: 'West', rep: 'A', product: 'Widget', amount: 120 }, + { region: "West", rep: "A", product: "Widget", amount: 120 }, // Missing product should be excluded entirely (no 'undefined' column) - { region: 'West', rep: 'B', amount: 90 }, - { region: 'East', rep: 'B', product: 'Gadget', amount: 10 }, - ] + { region: "West", rep: "B", amount: 90 }, + { region: "East", rep: "B", product: "Gadget", amount: 10 }, + ]; const res = computePivot({ data: mixed, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'sum', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "sum", + }); // Columns should not contain 'undefined' - expect(res.colKeyTuples.map((t) => String(t))).toEqual(['Gadget', 'Widget']) + expect(res.colKeyTuples.map((t) => String(t)).sort()).toEqual( + ["Gadget", "Widget"].sort() + ); - const rWest = 'West' - const rEast = 'East' - const cWidget = 'Widget' - const cGadget = 'Gadget' + const rWest = "West"; + const rEast = "East"; + const cWidget = "Widget"; + const cGadget = "Gadget"; // Only valid records contribute - expect(res.cells[rWest][cWidget].value).toBe(120) - expect(res.cells[rEast][cGadget].value).toBe(10) - expect(res.cells[rWest][cGadget]).toBeUndefined() - }) + expect(res.cells[rWest][cWidget].value).toBe(120); + expect(res.cells[rEast][cGadget].value).toBe(10); + expect(res.cells[rWest][cGadget]).toBeUndefined(); + }); - it('row totals use the provided aggregation over row records', () => { + it("row totals use the provided aggregation over row records", () => { const res = computePivot({ data: rows, - rowFields: ['region'], - columnFields: ['product'], - valueField: 'amount', - aggregator: 'avg', - }) + rowFields: ["region"], + columnFields: ["product"], + valueField: "amount", + aggregator: "avg", + }); // East row has values [10, 200] => avg 105 - expect(res.rowTotals['East']).toBe(105) + expect(res.rowTotals["East"]).toBe(105); // West row has values [90, 120] => avg 105 - expect(res.rowTotals['West']).toBe(105) - }) + expect(res.rowTotals["West"]).toBe(105); + }); it("test_flaky_passes_sometimes", () => { // read logs.json from data/logs.json - const logsUrl = new URL('../../data/logs.jsonl', import.meta.url) - const raw = readFileSync(logsUrl, 'utf-8') - const rows: FlatJson[] = [] + const logsUrl = new URL("../../data/logs.jsonl", import.meta.url); + const raw = readFileSync(logsUrl, "utf-8"); + const rows: FlatJson[] = []; // iterate through each line and parse JSON - raw.split('\n').forEach((line) => { - if (line.trim() === '') return - const parsed = JSON.parse(line) - rows.push(flattenJson(parsed)) - }) + raw.split("\n").forEach((line) => { + if (line.trim() === "") return; + const parsed = JSON.parse(line); + rows.push(flattenJson(parsed)); + }); const res = computePivot({ data: rows, - rowFields: ['$.eval_metadata.name', '$.execution_metadata.experiment_id'], - columnFields: ['$.input_metadata.completion_params.model'], - valueField: '$.evaluation_result.score', - aggregator: 'avg', - }) - - console.log(res) - }) -}) + rowFields: ["$.eval_metadata.name", "$.execution_metadata.experiment_id"], + columnFields: ["$.input_metadata.completion_params.model"], + valueField: "$.evaluation_result.score", + aggregator: "avg", + }); + + console.log(res); + }); +}); From e8fec9f9fcde67ca431c09b511e924ca82739a2b Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Fri, 19 Sep 2025 16:27:11 -0700 Subject: [PATCH 06/14] tighten the types up --- vite-app/src/types/configs.ts | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/vite-app/src/types/configs.ts b/vite-app/src/types/configs.ts index f1bf1e02..6cb4dfb3 100644 --- a/vite-app/src/types/configs.ts +++ b/vite-app/src/types/configs.ts @@ -9,13 +9,15 @@ export type Operator = | "!contains" | "between"; +export type FilterType = "text" | "date" | "date-range"; + // Filter configuration interface export interface FilterConfig { field: string; operator: Operator; value: string; value2?: string; // For filtering between dates - type?: "text" | "date" | "date-range"; + type?: FilterType; } export type FilterOperator = { @@ -44,9 +46,11 @@ export interface PaginationConfig { pageSize: number; } +export type SortDirection = "asc" | "desc"; + export interface SortConfig { sortField: string; - sortDirection: "asc" | "desc"; + sortDirection: SortDirection; } export interface GlobalConfig { From f1fdfaefa9e64ff17c9f644ff971b0436d1dc1f9 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 12:42:41 -0700 Subject: [PATCH 07/14] updates query params / preserves state across tabs --- vite-app/src/GlobalState.tsx | 6 +- vite-app/src/components/Dashboard.tsx | 20 ++++- vite-app/src/util/query-params.ts | 105 ++++++++++++++++++++++++-- 3 files changed, 121 insertions(+), 10 deletions(-) diff --git a/vite-app/src/GlobalState.tsx b/vite-app/src/GlobalState.tsx index 70b85cc8..06db4be2 100644 --- a/vite-app/src/GlobalState.tsx +++ b/vite-app/src/GlobalState.tsx @@ -11,6 +11,7 @@ import type { import flattenJson from "./util/flatten-json"; import type { FlatJson } from "./util/flatten-json"; import { createFilterFunction } from "./util/filter-utils"; +import { QueryParamsWatcher } from "./util/query-params"; // Default pivot configuration const DEFAULT_PIVOT_CONFIG: PivotConfig = { @@ -35,7 +36,7 @@ const DEFAULT_SORT_CONFIG: SortConfig = { sortDirection: "desc", }; -const DEFAULT_GLOBAL_CONFIG: GlobalConfig = { +export const DEFAULT_GLOBAL_CONFIG: GlobalConfig = { pivotConfig: DEFAULT_PIVOT_CONFIG, filterConfig: DEFAULT_FILTER_CONFIG, paginationConfig: DEFAULT_PAGINATION_CONFIG, @@ -61,6 +62,8 @@ export class GlobalState { // Loading state isLoading: boolean = true; + queryParamsWatcher: QueryParamsWatcher; + // Cached, denormalized data for performance // rollout_id -> flattened row private flattenedById: Record = {}; @@ -86,6 +89,7 @@ export class GlobalState { // Load sort config from localStorage or use defaults this.sortConfig = this.loadSortConfig(); makeAutoObservable(this); + this.queryParamsWatcher = new QueryParamsWatcher(this); } // Computed getters for individual pagination properties diff --git a/vite-app/src/components/Dashboard.tsx b/vite-app/src/components/Dashboard.tsx index ace28316..f7c5a8c4 100644 --- a/vite-app/src/components/Dashboard.tsx +++ b/vite-app/src/components/Dashboard.tsx @@ -2,6 +2,7 @@ import { observer } from "mobx-react"; import { useState, useEffect } from "react"; import { useLocation, useNavigate } from "react-router-dom"; import { state } from "../App"; +import { useQueryParamsSync } from "../util/query-params"; import Button from "./Button"; import { EvaluationTable } from "./EvaluationTable"; import PivotTab from "./PivotTab"; @@ -74,6 +75,9 @@ const Dashboard = observer(({ onRefresh }: DashboardProps) => { const location = useLocation(); const navigate = useNavigate(); + // Use the query params sync hook + useQueryParamsSync(state.queryParamsWatcher); + const deriveTabFromPath = (path: string): "table" | "pivot" => path.endsWith("/pivot") ? "pivot" : "table"; @@ -103,7 +107,13 @@ const Dashboard = observer(({ onRefresh }: DashboardProps) => { isActive={activeTab === "table"} onClick={() => { setActiveTab("table"); - navigate("/table"); + navigate( + { + pathname: "/table", + search: location.search, + }, + { replace: true } + ); }} title="View table" /> @@ -112,7 +122,13 @@ const Dashboard = observer(({ onRefresh }: DashboardProps) => { isActive={activeTab === "pivot"} onClick={() => { setActiveTab("pivot"); - navigate("/pivot"); + navigate( + { + pathname: "/pivot", + search: location.search, + }, + { replace: true } + ); }} title="View pivot" /> diff --git a/vite-app/src/util/query-params.ts b/vite-app/src/util/query-params.ts index e6e104b0..3f2b62d5 100644 --- a/vite-app/src/util/query-params.ts +++ b/vite-app/src/util/query-params.ts @@ -3,15 +3,75 @@ */ import { autorun } from "mobx"; -import { state } from "../App"; +import { useEffect } from "react"; +import { useSearchParams } from "react-router-dom"; import type { GlobalConfig } from "../types/configs"; -import { DEFAULT_GLOBAL_CONFIG } from "../GlobalState"; +import { DEFAULT_GLOBAL_CONFIG, GlobalState } from "../GlobalState"; -export function initWatcher() { - autorun(() => { - const globalConfig = state.globalConfig; - console.log(JSON.stringify(globalConfig)); - }); +export class QueryParamsWatcher { + queryParams: Record; + private updateUrlCallback: + | ((queryParams: Record) => void) + | null = null; + private state: GlobalState; + + constructor(state: GlobalState) { + this.state = state; + this.queryParams = nonDefaultValues(this.state.globalConfig); + this.init(); + } + + init() { + autorun(() => { + const globalConfig = this.state.globalConfig; + const diff = nonDefaultValues(globalConfig); + const previousUrlEncodedQueryParams = + this.generateUrlEncodedQueryParams(); + this.queryParams = diff; + const newUrlEncodedQueryParams = this.generateUrlEncodedQueryParams(); + if (previousUrlEncodedQueryParams !== newUrlEncodedQueryParams) { + console.log( + `Query params changed from ${previousUrlEncodedQueryParams} to ${newUrlEncodedQueryParams}` + ); + this.updateUrl(); + } + }); + } + + setUpdateUrlCallback( + callback: (queryParams: Record) => void + ) { + this.updateUrlCallback = callback; + } + + stableQueryParams(): [string, string][] { + /** + * Returns a stable query params object that is idempotent based on this.queryParams. First sorts by key and then by value. + */ + return Object.entries(this.queryParams).sort((a, b) => { + const keyCompare = a[0].localeCompare(b[0]); + if (keyCompare !== 0) return keyCompare; + return a[1].localeCompare(b[1]); + }); + } + + generateUrlEncodedQueryParams(): string { + return this.stableQueryParams() + .map( + ([key, value]) => + `${encodeURIComponent(key)}=${encodeURIComponent(value)}` + ) + .join("&"); + } + + private updateUrl() { + /** + * Update the browser URL with current query params using React Router callback + */ + if (this.updateUrlCallback) { + this.updateUrlCallback(this.queryParams); + } + } } export function nonDefaultValues( @@ -100,3 +160,34 @@ function calculateDifferentValues( compareObjects(globalConfig, defaultConfig); return differences; } + +/** + * Custom hook that integrates QueryParamsWatcher with React Router's useSearchParams + * This hook should be used in components that need to sync global state with URL query params + */ +export function useQueryParamsSync(queryParamsWatcher: QueryParamsWatcher) { + const [, setSearchParams] = useSearchParams(); + + useEffect(() => { + // Set up the callback for the QueryParamsWatcher to update URL + const updateUrl = (queryParams: Record) => { + const newSearchParams = new URLSearchParams(); + + // Add all query params to URLSearchParams + Object.entries(queryParams).forEach(([key, value]) => { + newSearchParams.set(key, value); + }); + + // Update the URL using React Router + setSearchParams(newSearchParams, { replace: true }); + }; + + // Set the callback on the global queryParamsWatcher + queryParamsWatcher.setUpdateUrlCallback(updateUrl); + + // Cleanup: remove callback when component unmounts + return () => { + queryParamsWatcher.setUpdateUrlCallback(() => {}); + }; + }, [setSearchParams]); +} From 95c63e890003ca21249cda4380ade2953b8d963d Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 12:45:40 -0700 Subject: [PATCH 08/14] pnp build --- vite-app/dist/assets/index-CenJkZJd.js.map | 1 - .../{index-CenJkZJd.js => index-DzSO2_2t.js} | 56 +++++++++---------- vite-app/dist/assets/index-DzSO2_2t.js.map | 1 + vite-app/dist/index.html | 2 +- 4 files changed, 30 insertions(+), 30 deletions(-) delete mode 100644 vite-app/dist/assets/index-CenJkZJd.js.map rename vite-app/dist/assets/{index-CenJkZJd.js => index-DzSO2_2t.js} (58%) create mode 100644 vite-app/dist/assets/index-DzSO2_2t.js.map diff --git a/vite-app/dist/assets/index-CenJkZJd.js.map b/vite-app/dist/assets/index-CenJkZJd.js.map deleted file mode 100644 index e19ac075..00000000 --- a/vite-app/dist/assets/index-CenJkZJd.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"index-CenJkZJd.js","sources":["../../node_modules/.pnpm/react@19.1.1/node_modules/react/cjs/react-jsx-runtime.production.js","../../node_modules/.pnpm/react@19.1.1/node_modules/react/jsx-runtime.js","../../node_modules/.pnpm/react@19.1.1/node_modules/react/cjs/react.production.js","../../node_modules/.pnpm/react@19.1.1/node_modules/react/index.js","../../node_modules/.pnpm/scheduler@0.26.0/node_modules/scheduler/cjs/scheduler.production.js","../../node_modules/.pnpm/scheduler@0.26.0/node_modules/scheduler/index.js","../../node_modules/.pnpm/react-dom@19.1.1_react@19.1.1/node_modules/react-dom/cjs/react-dom.production.js","../../node_modules/.pnpm/react-dom@19.1.1_react@19.1.1/node_modules/react-dom/index.js","../../node_modules/.pnpm/react-dom@19.1.1_react@19.1.1/node_modules/react-dom/cjs/react-dom-client.production.js","../../node_modules/.pnpm/react-dom@19.1.1_react@19.1.1/node_modules/react-dom/client.js","../../node_modules/.pnpm/react-router@7.7.1_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-router/dist/development/chunk-C37GKA54.mjs","../../node_modules/.pnpm/mobx@6.13.7/node_modules/mobx/dist/mobx.esm.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/utils/assertEnvironment.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/utils/observerBatching.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/utils/printDebugValue.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/utils/UniversalFinalizationRegistry.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/utils/observerFinalizationRegistry.js","../../node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.1/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js","../../node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.1/node_modules/use-sync-external-store/shim/index.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/useObserver.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/observer.js","../../node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react-lite/es/index.js","../../node_modules/.pnpm/mobx-react@9.2.0_mobx@6.13.7_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/mobx-react/dist/mobxreact.esm.js","../../src/styles/common.ts","../../src/components/Button.tsx","../../node_modules/.pnpm/@floating-ui+utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","../../node_modules/.pnpm/@floating-ui+core@1.7.3/node_modules/@floating-ui/core/dist/floating-ui.core.mjs","../../node_modules/.pnpm/@floating-ui+utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","../../node_modules/.pnpm/@floating-ui+dom@1.7.4/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","../../node_modules/.pnpm/classnames@2.5.1/node_modules/classnames/index.js","../../node_modules/.pnpm/react-tooltip@5.29.1_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-tooltip/dist/react-tooltip.min.mjs","../../src/components/Tooltip.tsx","../../src/components/MessageBubble.tsx","../../src/components/ChatInterface.tsx","../../src/components/MetadataSection.tsx","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/core.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/util.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/errors.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/parse.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/regexes.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/checks.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/doc.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/versions.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/schemas.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/registries.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/core/api.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/classic/iso.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/classic/errors.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/classic/parse.js","../../node_modules/.pnpm/zod@4.0.14/node_modules/zod/v4/classic/schemas.js","../../src/types/eval-protocol.ts","../../src/components/StatusIndicator.tsx","../../src/components/TableContainer.tsx","../../src/components/JSONTooltip.tsx","../../src/components/EvaluationRow.tsx","../../src/components/Select.tsx","../../src/components/SearchableSelect.tsx","../../src/components/FilterInput.tsx","../../src/util/filter-utils.ts","../../src/components/FilterSelector.tsx","../../src/components/EvaluationTable.tsx","../../src/util/pivot.ts","../../src/components/PivotTable.tsx","../../node_modules/.pnpm/@kurkle+color@0.3.4/node_modules/@kurkle/color/dist/color.esm.js","../../node_modules/.pnpm/chart.js@4.5.0/node_modules/chart.js/dist/chunks/helpers.dataset.js","../../node_modules/.pnpm/chart.js@4.5.0/node_modules/chart.js/dist/chart.js","../../node_modules/.pnpm/react-chartjs-2@5.3.0_chart.js@4.5.0_react@19.1.1/node_modules/react-chartjs-2/dist/index.js","../../node_modules/.pnpm/html2canvas-oklch@1.5.0-alpha.0/node_modules/html2canvas-oklch/dist/html2canvas.esm.js","../../src/components/ChartExport.tsx","../../src/hooks/usePivotData.ts","../../src/util/field-processors.ts","../../src/components/PivotTab.tsx","../../src/components/TabButton.tsx","../../src/components/Dashboard.tsx","../../src/types/websocket.ts","../../src/util/flatten-json.ts","../../src/GlobalState.tsx","../../src/assets/logo-light.png","../../src/config.ts","../../src/App.tsx","../../src/main.tsx"],"sourcesContent":["/**\n * @license React\n * react-jsx-runtime.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nvar REACT_ELEMENT_TYPE = Symbol.for(\"react.transitional.element\"),\n REACT_FRAGMENT_TYPE = Symbol.for(\"react.fragment\");\nfunction jsxProd(type, config, maybeKey) {\n var key = null;\n void 0 !== maybeKey && (key = \"\" + maybeKey);\n void 0 !== config.key && (key = \"\" + config.key);\n if (\"key\" in config) {\n maybeKey = {};\n for (var propName in config)\n \"key\" !== propName && (maybeKey[propName] = config[propName]);\n } else maybeKey = config;\n config = maybeKey.ref;\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type: type,\n key: key,\n ref: void 0 !== config ? config : null,\n props: maybeKey\n };\n}\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.jsx = jsxProd;\nexports.jsxs = jsxProd;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/react-jsx-runtime.production.js');\n} else {\n module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","/**\n * @license React\n * react.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nvar REACT_ELEMENT_TYPE = Symbol.for(\"react.transitional.element\"),\n REACT_PORTAL_TYPE = Symbol.for(\"react.portal\"),\n REACT_FRAGMENT_TYPE = Symbol.for(\"react.fragment\"),\n REACT_STRICT_MODE_TYPE = Symbol.for(\"react.strict_mode\"),\n REACT_PROFILER_TYPE = Symbol.for(\"react.profiler\"),\n REACT_CONSUMER_TYPE = Symbol.for(\"react.consumer\"),\n REACT_CONTEXT_TYPE = Symbol.for(\"react.context\"),\n REACT_FORWARD_REF_TYPE = Symbol.for(\"react.forward_ref\"),\n REACT_SUSPENSE_TYPE = Symbol.for(\"react.suspense\"),\n REACT_MEMO_TYPE = Symbol.for(\"react.memo\"),\n REACT_LAZY_TYPE = Symbol.for(\"react.lazy\"),\n MAYBE_ITERATOR_SYMBOL = Symbol.iterator;\nfunction getIteratorFn(maybeIterable) {\n if (null === maybeIterable || \"object\" !== typeof maybeIterable) return null;\n maybeIterable =\n (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||\n maybeIterable[\"@@iterator\"];\n return \"function\" === typeof maybeIterable ? maybeIterable : null;\n}\nvar ReactNoopUpdateQueue = {\n isMounted: function () {\n return !1;\n },\n enqueueForceUpdate: function () {},\n enqueueReplaceState: function () {},\n enqueueSetState: function () {}\n },\n assign = Object.assign,\n emptyObject = {};\nfunction Component(props, context, updater) {\n this.props = props;\n this.context = context;\n this.refs = emptyObject;\n this.updater = updater || ReactNoopUpdateQueue;\n}\nComponent.prototype.isReactComponent = {};\nComponent.prototype.setState = function (partialState, callback) {\n if (\n \"object\" !== typeof partialState &&\n \"function\" !== typeof partialState &&\n null != partialState\n )\n throw Error(\n \"takes an object of state variables to update or a function which returns an object of state variables.\"\n );\n this.updater.enqueueSetState(this, partialState, callback, \"setState\");\n};\nComponent.prototype.forceUpdate = function (callback) {\n this.updater.enqueueForceUpdate(this, callback, \"forceUpdate\");\n};\nfunction ComponentDummy() {}\nComponentDummy.prototype = Component.prototype;\nfunction PureComponent(props, context, updater) {\n this.props = props;\n this.context = context;\n this.refs = emptyObject;\n this.updater = updater || ReactNoopUpdateQueue;\n}\nvar pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());\npureComponentPrototype.constructor = PureComponent;\nassign(pureComponentPrototype, Component.prototype);\npureComponentPrototype.isPureReactComponent = !0;\nvar isArrayImpl = Array.isArray,\n ReactSharedInternals = { H: null, A: null, T: null, S: null, V: null },\n hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction ReactElement(type, key, self, source, owner, props) {\n self = props.ref;\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type: type,\n key: key,\n ref: void 0 !== self ? self : null,\n props: props\n };\n}\nfunction cloneAndReplaceKey(oldElement, newKey) {\n return ReactElement(\n oldElement.type,\n newKey,\n void 0,\n void 0,\n void 0,\n oldElement.props\n );\n}\nfunction isValidElement(object) {\n return (\n \"object\" === typeof object &&\n null !== object &&\n object.$$typeof === REACT_ELEMENT_TYPE\n );\n}\nfunction escape(key) {\n var escaperLookup = { \"=\": \"=0\", \":\": \"=2\" };\n return (\n \"$\" +\n key.replace(/[=:]/g, function (match) {\n return escaperLookup[match];\n })\n );\n}\nvar userProvidedKeyEscapeRegex = /\\/+/g;\nfunction getElementKey(element, index) {\n return \"object\" === typeof element && null !== element && null != element.key\n ? escape(\"\" + element.key)\n : index.toString(36);\n}\nfunction noop$1() {}\nfunction resolveThenable(thenable) {\n switch (thenable.status) {\n case \"fulfilled\":\n return thenable.value;\n case \"rejected\":\n throw thenable.reason;\n default:\n switch (\n (\"string\" === typeof thenable.status\n ? thenable.then(noop$1, noop$1)\n : ((thenable.status = \"pending\"),\n thenable.then(\n function (fulfilledValue) {\n \"pending\" === thenable.status &&\n ((thenable.status = \"fulfilled\"),\n (thenable.value = fulfilledValue));\n },\n function (error) {\n \"pending\" === thenable.status &&\n ((thenable.status = \"rejected\"), (thenable.reason = error));\n }\n )),\n thenable.status)\n ) {\n case \"fulfilled\":\n return thenable.value;\n case \"rejected\":\n throw thenable.reason;\n }\n }\n throw thenable;\n}\nfunction mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {\n var type = typeof children;\n if (\"undefined\" === type || \"boolean\" === type) children = null;\n var invokeCallback = !1;\n if (null === children) invokeCallback = !0;\n else\n switch (type) {\n case \"bigint\":\n case \"string\":\n case \"number\":\n invokeCallback = !0;\n break;\n case \"object\":\n switch (children.$$typeof) {\n case REACT_ELEMENT_TYPE:\n case REACT_PORTAL_TYPE:\n invokeCallback = !0;\n break;\n case REACT_LAZY_TYPE:\n return (\n (invokeCallback = children._init),\n mapIntoArray(\n invokeCallback(children._payload),\n array,\n escapedPrefix,\n nameSoFar,\n callback\n )\n );\n }\n }\n if (invokeCallback)\n return (\n (callback = callback(children)),\n (invokeCallback =\n \"\" === nameSoFar ? \".\" + getElementKey(children, 0) : nameSoFar),\n isArrayImpl(callback)\n ? ((escapedPrefix = \"\"),\n null != invokeCallback &&\n (escapedPrefix =\n invokeCallback.replace(userProvidedKeyEscapeRegex, \"$&/\") + \"/\"),\n mapIntoArray(callback, array, escapedPrefix, \"\", function (c) {\n return c;\n }))\n : null != callback &&\n (isValidElement(callback) &&\n (callback = cloneAndReplaceKey(\n callback,\n escapedPrefix +\n (null == callback.key ||\n (children && children.key === callback.key)\n ? \"\"\n : (\"\" + callback.key).replace(\n userProvidedKeyEscapeRegex,\n \"$&/\"\n ) + \"/\") +\n invokeCallback\n )),\n array.push(callback)),\n 1\n );\n invokeCallback = 0;\n var nextNamePrefix = \"\" === nameSoFar ? \".\" : nameSoFar + \":\";\n if (isArrayImpl(children))\n for (var i = 0; i < children.length; i++)\n (nameSoFar = children[i]),\n (type = nextNamePrefix + getElementKey(nameSoFar, i)),\n (invokeCallback += mapIntoArray(\n nameSoFar,\n array,\n escapedPrefix,\n type,\n callback\n ));\n else if (((i = getIteratorFn(children)), \"function\" === typeof i))\n for (\n children = i.call(children), i = 0;\n !(nameSoFar = children.next()).done;\n\n )\n (nameSoFar = nameSoFar.value),\n (type = nextNamePrefix + getElementKey(nameSoFar, i++)),\n (invokeCallback += mapIntoArray(\n nameSoFar,\n array,\n escapedPrefix,\n type,\n callback\n ));\n else if (\"object\" === type) {\n if (\"function\" === typeof children.then)\n return mapIntoArray(\n resolveThenable(children),\n array,\n escapedPrefix,\n nameSoFar,\n callback\n );\n array = String(children);\n throw Error(\n \"Objects are not valid as a React child (found: \" +\n (\"[object Object]\" === array\n ? \"object with keys {\" + Object.keys(children).join(\", \") + \"}\"\n : array) +\n \"). If you meant to render a collection of children, use an array instead.\"\n );\n }\n return invokeCallback;\n}\nfunction mapChildren(children, func, context) {\n if (null == children) return children;\n var result = [],\n count = 0;\n mapIntoArray(children, result, \"\", \"\", function (child) {\n return func.call(context, child, count++);\n });\n return result;\n}\nfunction lazyInitializer(payload) {\n if (-1 === payload._status) {\n var ctor = payload._result;\n ctor = ctor();\n ctor.then(\n function (moduleObject) {\n if (0 === payload._status || -1 === payload._status)\n (payload._status = 1), (payload._result = moduleObject);\n },\n function (error) {\n if (0 === payload._status || -1 === payload._status)\n (payload._status = 2), (payload._result = error);\n }\n );\n -1 === payload._status && ((payload._status = 0), (payload._result = ctor));\n }\n if (1 === payload._status) return payload._result.default;\n throw payload._result;\n}\nvar reportGlobalError =\n \"function\" === typeof reportError\n ? reportError\n : function (error) {\n if (\n \"object\" === typeof window &&\n \"function\" === typeof window.ErrorEvent\n ) {\n var event = new window.ErrorEvent(\"error\", {\n bubbles: !0,\n cancelable: !0,\n message:\n \"object\" === typeof error &&\n null !== error &&\n \"string\" === typeof error.message\n ? String(error.message)\n : String(error),\n error: error\n });\n if (!window.dispatchEvent(event)) return;\n } else if (\n \"object\" === typeof process &&\n \"function\" === typeof process.emit\n ) {\n process.emit(\"uncaughtException\", error);\n return;\n }\n console.error(error);\n };\nfunction noop() {}\nexports.Children = {\n map: mapChildren,\n forEach: function (children, forEachFunc, forEachContext) {\n mapChildren(\n children,\n function () {\n forEachFunc.apply(this, arguments);\n },\n forEachContext\n );\n },\n count: function (children) {\n var n = 0;\n mapChildren(children, function () {\n n++;\n });\n return n;\n },\n toArray: function (children) {\n return (\n mapChildren(children, function (child) {\n return child;\n }) || []\n );\n },\n only: function (children) {\n if (!isValidElement(children))\n throw Error(\n \"React.Children.only expected to receive a single React element child.\"\n );\n return children;\n }\n};\nexports.Component = Component;\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.Profiler = REACT_PROFILER_TYPE;\nexports.PureComponent = PureComponent;\nexports.StrictMode = REACT_STRICT_MODE_TYPE;\nexports.Suspense = REACT_SUSPENSE_TYPE;\nexports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =\n ReactSharedInternals;\nexports.__COMPILER_RUNTIME = {\n __proto__: null,\n c: function (size) {\n return ReactSharedInternals.H.useMemoCache(size);\n }\n};\nexports.cache = function (fn) {\n return function () {\n return fn.apply(null, arguments);\n };\n};\nexports.cloneElement = function (element, config, children) {\n if (null === element || void 0 === element)\n throw Error(\n \"The argument must be a React element, but you passed \" + element + \".\"\n );\n var props = assign({}, element.props),\n key = element.key,\n owner = void 0;\n if (null != config)\n for (propName in (void 0 !== config.ref && (owner = void 0),\n void 0 !== config.key && (key = \"\" + config.key),\n config))\n !hasOwnProperty.call(config, propName) ||\n \"key\" === propName ||\n \"__self\" === propName ||\n \"__source\" === propName ||\n (\"ref\" === propName && void 0 === config.ref) ||\n (props[propName] = config[propName]);\n var propName = arguments.length - 2;\n if (1 === propName) props.children = children;\n else if (1 < propName) {\n for (var childArray = Array(propName), i = 0; i < propName; i++)\n childArray[i] = arguments[i + 2];\n props.children = childArray;\n }\n return ReactElement(element.type, key, void 0, void 0, owner, props);\n};\nexports.createContext = function (defaultValue) {\n defaultValue = {\n $$typeof: REACT_CONTEXT_TYPE,\n _currentValue: defaultValue,\n _currentValue2: defaultValue,\n _threadCount: 0,\n Provider: null,\n Consumer: null\n };\n defaultValue.Provider = defaultValue;\n defaultValue.Consumer = {\n $$typeof: REACT_CONSUMER_TYPE,\n _context: defaultValue\n };\n return defaultValue;\n};\nexports.createElement = function (type, config, children) {\n var propName,\n props = {},\n key = null;\n if (null != config)\n for (propName in (void 0 !== config.key && (key = \"\" + config.key), config))\n hasOwnProperty.call(config, propName) &&\n \"key\" !== propName &&\n \"__self\" !== propName &&\n \"__source\" !== propName &&\n (props[propName] = config[propName]);\n var childrenLength = arguments.length - 2;\n if (1 === childrenLength) props.children = children;\n else if (1 < childrenLength) {\n for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)\n childArray[i] = arguments[i + 2];\n props.children = childArray;\n }\n if (type && type.defaultProps)\n for (propName in ((childrenLength = type.defaultProps), childrenLength))\n void 0 === props[propName] &&\n (props[propName] = childrenLength[propName]);\n return ReactElement(type, key, void 0, void 0, null, props);\n};\nexports.createRef = function () {\n return { current: null };\n};\nexports.forwardRef = function (render) {\n return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };\n};\nexports.isValidElement = isValidElement;\nexports.lazy = function (ctor) {\n return {\n $$typeof: REACT_LAZY_TYPE,\n _payload: { _status: -1, _result: ctor },\n _init: lazyInitializer\n };\n};\nexports.memo = function (type, compare) {\n return {\n $$typeof: REACT_MEMO_TYPE,\n type: type,\n compare: void 0 === compare ? null : compare\n };\n};\nexports.startTransition = function (scope) {\n var prevTransition = ReactSharedInternals.T,\n currentTransition = {};\n ReactSharedInternals.T = currentTransition;\n try {\n var returnValue = scope(),\n onStartTransitionFinish = ReactSharedInternals.S;\n null !== onStartTransitionFinish &&\n onStartTransitionFinish(currentTransition, returnValue);\n \"object\" === typeof returnValue &&\n null !== returnValue &&\n \"function\" === typeof returnValue.then &&\n returnValue.then(noop, reportGlobalError);\n } catch (error) {\n reportGlobalError(error);\n } finally {\n ReactSharedInternals.T = prevTransition;\n }\n};\nexports.unstable_useCacheRefresh = function () {\n return ReactSharedInternals.H.useCacheRefresh();\n};\nexports.use = function (usable) {\n return ReactSharedInternals.H.use(usable);\n};\nexports.useActionState = function (action, initialState, permalink) {\n return ReactSharedInternals.H.useActionState(action, initialState, permalink);\n};\nexports.useCallback = function (callback, deps) {\n return ReactSharedInternals.H.useCallback(callback, deps);\n};\nexports.useContext = function (Context) {\n return ReactSharedInternals.H.useContext(Context);\n};\nexports.useDebugValue = function () {};\nexports.useDeferredValue = function (value, initialValue) {\n return ReactSharedInternals.H.useDeferredValue(value, initialValue);\n};\nexports.useEffect = function (create, createDeps, update) {\n var dispatcher = ReactSharedInternals.H;\n if (\"function\" === typeof update)\n throw Error(\n \"useEffect CRUD overload is not enabled in this build of React.\"\n );\n return dispatcher.useEffect(create, createDeps);\n};\nexports.useId = function () {\n return ReactSharedInternals.H.useId();\n};\nexports.useImperativeHandle = function (ref, create, deps) {\n return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);\n};\nexports.useInsertionEffect = function (create, deps) {\n return ReactSharedInternals.H.useInsertionEffect(create, deps);\n};\nexports.useLayoutEffect = function (create, deps) {\n return ReactSharedInternals.H.useLayoutEffect(create, deps);\n};\nexports.useMemo = function (create, deps) {\n return ReactSharedInternals.H.useMemo(create, deps);\n};\nexports.useOptimistic = function (passthrough, reducer) {\n return ReactSharedInternals.H.useOptimistic(passthrough, reducer);\n};\nexports.useReducer = function (reducer, initialArg, init) {\n return ReactSharedInternals.H.useReducer(reducer, initialArg, init);\n};\nexports.useRef = function (initialValue) {\n return ReactSharedInternals.H.useRef(initialValue);\n};\nexports.useState = function (initialState) {\n return ReactSharedInternals.H.useState(initialState);\n};\nexports.useSyncExternalStore = function (\n subscribe,\n getSnapshot,\n getServerSnapshot\n) {\n return ReactSharedInternals.H.useSyncExternalStore(\n subscribe,\n getSnapshot,\n getServerSnapshot\n );\n};\nexports.useTransition = function () {\n return ReactSharedInternals.H.useTransition();\n};\nexports.version = \"19.1.1\";\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/react.production.js');\n} else {\n module.exports = require('./cjs/react.development.js');\n}\n","/**\n * @license React\n * scheduler.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nfunction push(heap, node) {\n var index = heap.length;\n heap.push(node);\n a: for (; 0 < index; ) {\n var parentIndex = (index - 1) >>> 1,\n parent = heap[parentIndex];\n if (0 < compare(parent, node))\n (heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);\n else break a;\n }\n}\nfunction peek(heap) {\n return 0 === heap.length ? null : heap[0];\n}\nfunction pop(heap) {\n if (0 === heap.length) return null;\n var first = heap[0],\n last = heap.pop();\n if (last !== first) {\n heap[0] = last;\n a: for (\n var index = 0, length = heap.length, halfLength = length >>> 1;\n index < halfLength;\n\n ) {\n var leftIndex = 2 * (index + 1) - 1,\n left = heap[leftIndex],\n rightIndex = leftIndex + 1,\n right = heap[rightIndex];\n if (0 > compare(left, last))\n rightIndex < length && 0 > compare(right, left)\n ? ((heap[index] = right),\n (heap[rightIndex] = last),\n (index = rightIndex))\n : ((heap[index] = left),\n (heap[leftIndex] = last),\n (index = leftIndex));\n else if (rightIndex < length && 0 > compare(right, last))\n (heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);\n else break a;\n }\n }\n return first;\n}\nfunction compare(a, b) {\n var diff = a.sortIndex - b.sortIndex;\n return 0 !== diff ? diff : a.id - b.id;\n}\nexports.unstable_now = void 0;\nif (\"object\" === typeof performance && \"function\" === typeof performance.now) {\n var localPerformance = performance;\n exports.unstable_now = function () {\n return localPerformance.now();\n };\n} else {\n var localDate = Date,\n initialTime = localDate.now();\n exports.unstable_now = function () {\n return localDate.now() - initialTime;\n };\n}\nvar taskQueue = [],\n timerQueue = [],\n taskIdCounter = 1,\n currentTask = null,\n currentPriorityLevel = 3,\n isPerformingWork = !1,\n isHostCallbackScheduled = !1,\n isHostTimeoutScheduled = !1,\n needsPaint = !1,\n localSetTimeout = \"function\" === typeof setTimeout ? setTimeout : null,\n localClearTimeout = \"function\" === typeof clearTimeout ? clearTimeout : null,\n localSetImmediate = \"undefined\" !== typeof setImmediate ? setImmediate : null;\nfunction advanceTimers(currentTime) {\n for (var timer = peek(timerQueue); null !== timer; ) {\n if (null === timer.callback) pop(timerQueue);\n else if (timer.startTime <= currentTime)\n pop(timerQueue),\n (timer.sortIndex = timer.expirationTime),\n push(taskQueue, timer);\n else break;\n timer = peek(timerQueue);\n }\n}\nfunction handleTimeout(currentTime) {\n isHostTimeoutScheduled = !1;\n advanceTimers(currentTime);\n if (!isHostCallbackScheduled)\n if (null !== peek(taskQueue))\n (isHostCallbackScheduled = !0),\n isMessageLoopRunning ||\n ((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());\n else {\n var firstTimer = peek(timerQueue);\n null !== firstTimer &&\n requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);\n }\n}\nvar isMessageLoopRunning = !1,\n taskTimeoutID = -1,\n frameInterval = 5,\n startTime = -1;\nfunction shouldYieldToHost() {\n return needsPaint\n ? !0\n : exports.unstable_now() - startTime < frameInterval\n ? !1\n : !0;\n}\nfunction performWorkUntilDeadline() {\n needsPaint = !1;\n if (isMessageLoopRunning) {\n var currentTime = exports.unstable_now();\n startTime = currentTime;\n var hasMoreWork = !0;\n try {\n a: {\n isHostCallbackScheduled = !1;\n isHostTimeoutScheduled &&\n ((isHostTimeoutScheduled = !1),\n localClearTimeout(taskTimeoutID),\n (taskTimeoutID = -1));\n isPerformingWork = !0;\n var previousPriorityLevel = currentPriorityLevel;\n try {\n b: {\n advanceTimers(currentTime);\n for (\n currentTask = peek(taskQueue);\n null !== currentTask &&\n !(\n currentTask.expirationTime > currentTime && shouldYieldToHost()\n );\n\n ) {\n var callback = currentTask.callback;\n if (\"function\" === typeof callback) {\n currentTask.callback = null;\n currentPriorityLevel = currentTask.priorityLevel;\n var continuationCallback = callback(\n currentTask.expirationTime <= currentTime\n );\n currentTime = exports.unstable_now();\n if (\"function\" === typeof continuationCallback) {\n currentTask.callback = continuationCallback;\n advanceTimers(currentTime);\n hasMoreWork = !0;\n break b;\n }\n currentTask === peek(taskQueue) && pop(taskQueue);\n advanceTimers(currentTime);\n } else pop(taskQueue);\n currentTask = peek(taskQueue);\n }\n if (null !== currentTask) hasMoreWork = !0;\n else {\n var firstTimer = peek(timerQueue);\n null !== firstTimer &&\n requestHostTimeout(\n handleTimeout,\n firstTimer.startTime - currentTime\n );\n hasMoreWork = !1;\n }\n }\n break a;\n } finally {\n (currentTask = null),\n (currentPriorityLevel = previousPriorityLevel),\n (isPerformingWork = !1);\n }\n hasMoreWork = void 0;\n }\n } finally {\n hasMoreWork\n ? schedulePerformWorkUntilDeadline()\n : (isMessageLoopRunning = !1);\n }\n }\n}\nvar schedulePerformWorkUntilDeadline;\nif (\"function\" === typeof localSetImmediate)\n schedulePerformWorkUntilDeadline = function () {\n localSetImmediate(performWorkUntilDeadline);\n };\nelse if (\"undefined\" !== typeof MessageChannel) {\n var channel = new MessageChannel(),\n port = channel.port2;\n channel.port1.onmessage = performWorkUntilDeadline;\n schedulePerformWorkUntilDeadline = function () {\n port.postMessage(null);\n };\n} else\n schedulePerformWorkUntilDeadline = function () {\n localSetTimeout(performWorkUntilDeadline, 0);\n };\nfunction requestHostTimeout(callback, ms) {\n taskTimeoutID = localSetTimeout(function () {\n callback(exports.unstable_now());\n }, ms);\n}\nexports.unstable_IdlePriority = 5;\nexports.unstable_ImmediatePriority = 1;\nexports.unstable_LowPriority = 4;\nexports.unstable_NormalPriority = 3;\nexports.unstable_Profiling = null;\nexports.unstable_UserBlockingPriority = 2;\nexports.unstable_cancelCallback = function (task) {\n task.callback = null;\n};\nexports.unstable_forceFrameRate = function (fps) {\n 0 > fps || 125 < fps\n ? console.error(\n \"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"\n )\n : (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5);\n};\nexports.unstable_getCurrentPriorityLevel = function () {\n return currentPriorityLevel;\n};\nexports.unstable_next = function (eventHandler) {\n switch (currentPriorityLevel) {\n case 1:\n case 2:\n case 3:\n var priorityLevel = 3;\n break;\n default:\n priorityLevel = currentPriorityLevel;\n }\n var previousPriorityLevel = currentPriorityLevel;\n currentPriorityLevel = priorityLevel;\n try {\n return eventHandler();\n } finally {\n currentPriorityLevel = previousPriorityLevel;\n }\n};\nexports.unstable_requestPaint = function () {\n needsPaint = !0;\n};\nexports.unstable_runWithPriority = function (priorityLevel, eventHandler) {\n switch (priorityLevel) {\n case 1:\n case 2:\n case 3:\n case 4:\n case 5:\n break;\n default:\n priorityLevel = 3;\n }\n var previousPriorityLevel = currentPriorityLevel;\n currentPriorityLevel = priorityLevel;\n try {\n return eventHandler();\n } finally {\n currentPriorityLevel = previousPriorityLevel;\n }\n};\nexports.unstable_scheduleCallback = function (\n priorityLevel,\n callback,\n options\n) {\n var currentTime = exports.unstable_now();\n \"object\" === typeof options && null !== options\n ? ((options = options.delay),\n (options =\n \"number\" === typeof options && 0 < options\n ? currentTime + options\n : currentTime))\n : (options = currentTime);\n switch (priorityLevel) {\n case 1:\n var timeout = -1;\n break;\n case 2:\n timeout = 250;\n break;\n case 5:\n timeout = 1073741823;\n break;\n case 4:\n timeout = 1e4;\n break;\n default:\n timeout = 5e3;\n }\n timeout = options + timeout;\n priorityLevel = {\n id: taskIdCounter++,\n callback: callback,\n priorityLevel: priorityLevel,\n startTime: options,\n expirationTime: timeout,\n sortIndex: -1\n };\n options > currentTime\n ? ((priorityLevel.sortIndex = options),\n push(timerQueue, priorityLevel),\n null === peek(taskQueue) &&\n priorityLevel === peek(timerQueue) &&\n (isHostTimeoutScheduled\n ? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))\n : (isHostTimeoutScheduled = !0),\n requestHostTimeout(handleTimeout, options - currentTime)))\n : ((priorityLevel.sortIndex = timeout),\n push(taskQueue, priorityLevel),\n isHostCallbackScheduled ||\n isPerformingWork ||\n ((isHostCallbackScheduled = !0),\n isMessageLoopRunning ||\n ((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline())));\n return priorityLevel;\n};\nexports.unstable_shouldYield = shouldYieldToHost;\nexports.unstable_wrapCallback = function (callback) {\n var parentPriorityLevel = currentPriorityLevel;\n return function () {\n var previousPriorityLevel = currentPriorityLevel;\n currentPriorityLevel = parentPriorityLevel;\n try {\n return callback.apply(this, arguments);\n } finally {\n currentPriorityLevel = previousPriorityLevel;\n }\n };\n};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/scheduler.production.js');\n} else {\n module.exports = require('./cjs/scheduler.development.js');\n}\n","/**\n * @license React\n * react-dom.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nvar React = require(\"react\");\nfunction formatProdErrorMessage(code) {\n var url = \"https://react.dev/errors/\" + code;\n if (1 < arguments.length) {\n url += \"?args[]=\" + encodeURIComponent(arguments[1]);\n for (var i = 2; i < arguments.length; i++)\n url += \"&args[]=\" + encodeURIComponent(arguments[i]);\n }\n return (\n \"Minified React error #\" +\n code +\n \"; visit \" +\n url +\n \" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"\n );\n}\nfunction noop() {}\nvar Internals = {\n d: {\n f: noop,\n r: function () {\n throw Error(formatProdErrorMessage(522));\n },\n D: noop,\n C: noop,\n L: noop,\n m: noop,\n X: noop,\n S: noop,\n M: noop\n },\n p: 0,\n findDOMNode: null\n },\n REACT_PORTAL_TYPE = Symbol.for(\"react.portal\");\nfunction createPortal$1(children, containerInfo, implementation) {\n var key =\n 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;\n return {\n $$typeof: REACT_PORTAL_TYPE,\n key: null == key ? null : \"\" + key,\n children: children,\n containerInfo: containerInfo,\n implementation: implementation\n };\n}\nvar ReactSharedInternals =\n React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;\nfunction getCrossOriginStringAs(as, input) {\n if (\"font\" === as) return \"\";\n if (\"string\" === typeof input)\n return \"use-credentials\" === input ? input : \"\";\n}\nexports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =\n Internals;\nexports.createPortal = function (children, container) {\n var key =\n 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;\n if (\n !container ||\n (1 !== container.nodeType &&\n 9 !== container.nodeType &&\n 11 !== container.nodeType)\n )\n throw Error(formatProdErrorMessage(299));\n return createPortal$1(children, container, null, key);\n};\nexports.flushSync = function (fn) {\n var previousTransition = ReactSharedInternals.T,\n previousUpdatePriority = Internals.p;\n try {\n if (((ReactSharedInternals.T = null), (Internals.p = 2), fn)) return fn();\n } finally {\n (ReactSharedInternals.T = previousTransition),\n (Internals.p = previousUpdatePriority),\n Internals.d.f();\n }\n};\nexports.preconnect = function (href, options) {\n \"string\" === typeof href &&\n (options\n ? ((options = options.crossOrigin),\n (options =\n \"string\" === typeof options\n ? \"use-credentials\" === options\n ? options\n : \"\"\n : void 0))\n : (options = null),\n Internals.d.C(href, options));\n};\nexports.prefetchDNS = function (href) {\n \"string\" === typeof href && Internals.d.D(href);\n};\nexports.preinit = function (href, options) {\n if (\"string\" === typeof href && options && \"string\" === typeof options.as) {\n var as = options.as,\n crossOrigin = getCrossOriginStringAs(as, options.crossOrigin),\n integrity =\n \"string\" === typeof options.integrity ? options.integrity : void 0,\n fetchPriority =\n \"string\" === typeof options.fetchPriority\n ? options.fetchPriority\n : void 0;\n \"style\" === as\n ? Internals.d.S(\n href,\n \"string\" === typeof options.precedence ? options.precedence : void 0,\n {\n crossOrigin: crossOrigin,\n integrity: integrity,\n fetchPriority: fetchPriority\n }\n )\n : \"script\" === as &&\n Internals.d.X(href, {\n crossOrigin: crossOrigin,\n integrity: integrity,\n fetchPriority: fetchPriority,\n nonce: \"string\" === typeof options.nonce ? options.nonce : void 0\n });\n }\n};\nexports.preinitModule = function (href, options) {\n if (\"string\" === typeof href)\n if (\"object\" === typeof options && null !== options) {\n if (null == options.as || \"script\" === options.as) {\n var crossOrigin = getCrossOriginStringAs(\n options.as,\n options.crossOrigin\n );\n Internals.d.M(href, {\n crossOrigin: crossOrigin,\n integrity:\n \"string\" === typeof options.integrity ? options.integrity : void 0,\n nonce: \"string\" === typeof options.nonce ? options.nonce : void 0\n });\n }\n } else null == options && Internals.d.M(href);\n};\nexports.preload = function (href, options) {\n if (\n \"string\" === typeof href &&\n \"object\" === typeof options &&\n null !== options &&\n \"string\" === typeof options.as\n ) {\n var as = options.as,\n crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);\n Internals.d.L(href, as, {\n crossOrigin: crossOrigin,\n integrity:\n \"string\" === typeof options.integrity ? options.integrity : void 0,\n nonce: \"string\" === typeof options.nonce ? options.nonce : void 0,\n type: \"string\" === typeof options.type ? options.type : void 0,\n fetchPriority:\n \"string\" === typeof options.fetchPriority\n ? options.fetchPriority\n : void 0,\n referrerPolicy:\n \"string\" === typeof options.referrerPolicy\n ? options.referrerPolicy\n : void 0,\n imageSrcSet:\n \"string\" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,\n imageSizes:\n \"string\" === typeof options.imageSizes ? options.imageSizes : void 0,\n media: \"string\" === typeof options.media ? options.media : void 0\n });\n }\n};\nexports.preloadModule = function (href, options) {\n if (\"string\" === typeof href)\n if (options) {\n var crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);\n Internals.d.m(href, {\n as:\n \"string\" === typeof options.as && \"script\" !== options.as\n ? options.as\n : void 0,\n crossOrigin: crossOrigin,\n integrity:\n \"string\" === typeof options.integrity ? options.integrity : void 0\n });\n } else Internals.d.m(href);\n};\nexports.requestFormReset = function (form) {\n Internals.d.r(form);\n};\nexports.unstable_batchedUpdates = function (fn, a) {\n return fn(a);\n};\nexports.useFormState = function (action, initialState, permalink) {\n return ReactSharedInternals.H.useFormState(action, initialState, permalink);\n};\nexports.useFormStatus = function () {\n return ReactSharedInternals.H.useHostTransitionStatus();\n};\nexports.version = \"19.1.1\";\n","'use strict';\n\nfunction checkDCE() {\n /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\n if (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'\n ) {\n return;\n }\n if (process.env.NODE_ENV !== 'production') {\n // This branch is unreachable because this function is only called\n // in production, but the condition is true only in development.\n // Therefore if the branch is still here, dead code elimination wasn't\n // properly applied.\n // Don't change the message. React DevTools relies on it. Also make sure\n // this message doesn't occur elsewhere in this function, or it will cause\n // a false positive.\n throw new Error('^_^');\n }\n try {\n // Verify that the code above has been dead code eliminated (DCE'd).\n __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);\n } catch (err) {\n // DevTools shouldn't crash React, no matter what.\n // We should still report in case we break this code.\n console.error(err);\n }\n}\n\nif (process.env.NODE_ENV === 'production') {\n // DCE check should happen before ReactDOM bundle executes so that\n // DevTools can report bad minification during injection.\n checkDCE();\n module.exports = require('./cjs/react-dom.production.js');\n} else {\n module.exports = require('./cjs/react-dom.development.js');\n}\n","/**\n * @license React\n * react-dom-client.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n/*\n Modernizr 3.0.0pre (Custom Build) | MIT\n*/\n\"use strict\";\nvar Scheduler = require(\"scheduler\"),\n React = require(\"react\"),\n ReactDOM = require(\"react-dom\");\nfunction formatProdErrorMessage(code) {\n var url = \"https://react.dev/errors/\" + code;\n if (1 < arguments.length) {\n url += \"?args[]=\" + encodeURIComponent(arguments[1]);\n for (var i = 2; i < arguments.length; i++)\n url += \"&args[]=\" + encodeURIComponent(arguments[i]);\n }\n return (\n \"Minified React error #\" +\n code +\n \"; visit \" +\n url +\n \" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"\n );\n}\nfunction isValidContainer(node) {\n return !(\n !node ||\n (1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType)\n );\n}\nfunction getNearestMountedFiber(fiber) {\n var node = fiber,\n nearestMounted = fiber;\n if (fiber.alternate) for (; node.return; ) node = node.return;\n else {\n fiber = node;\n do\n (node = fiber),\n 0 !== (node.flags & 4098) && (nearestMounted = node.return),\n (fiber = node.return);\n while (fiber);\n }\n return 3 === node.tag ? nearestMounted : null;\n}\nfunction getSuspenseInstanceFromFiber(fiber) {\n if (13 === fiber.tag) {\n var suspenseState = fiber.memoizedState;\n null === suspenseState &&\n ((fiber = fiber.alternate),\n null !== fiber && (suspenseState = fiber.memoizedState));\n if (null !== suspenseState) return suspenseState.dehydrated;\n }\n return null;\n}\nfunction assertIsMounted(fiber) {\n if (getNearestMountedFiber(fiber) !== fiber)\n throw Error(formatProdErrorMessage(188));\n}\nfunction findCurrentFiberUsingSlowPath(fiber) {\n var alternate = fiber.alternate;\n if (!alternate) {\n alternate = getNearestMountedFiber(fiber);\n if (null === alternate) throw Error(formatProdErrorMessage(188));\n return alternate !== fiber ? null : fiber;\n }\n for (var a = fiber, b = alternate; ; ) {\n var parentA = a.return;\n if (null === parentA) break;\n var parentB = parentA.alternate;\n if (null === parentB) {\n b = parentA.return;\n if (null !== b) {\n a = b;\n continue;\n }\n break;\n }\n if (parentA.child === parentB.child) {\n for (parentB = parentA.child; parentB; ) {\n if (parentB === a) return assertIsMounted(parentA), fiber;\n if (parentB === b) return assertIsMounted(parentA), alternate;\n parentB = parentB.sibling;\n }\n throw Error(formatProdErrorMessage(188));\n }\n if (a.return !== b.return) (a = parentA), (b = parentB);\n else {\n for (var didFindChild = !1, child$0 = parentA.child; child$0; ) {\n if (child$0 === a) {\n didFindChild = !0;\n a = parentA;\n b = parentB;\n break;\n }\n if (child$0 === b) {\n didFindChild = !0;\n b = parentA;\n a = parentB;\n break;\n }\n child$0 = child$0.sibling;\n }\n if (!didFindChild) {\n for (child$0 = parentB.child; child$0; ) {\n if (child$0 === a) {\n didFindChild = !0;\n a = parentB;\n b = parentA;\n break;\n }\n if (child$0 === b) {\n didFindChild = !0;\n b = parentB;\n a = parentA;\n break;\n }\n child$0 = child$0.sibling;\n }\n if (!didFindChild) throw Error(formatProdErrorMessage(189));\n }\n }\n if (a.alternate !== b) throw Error(formatProdErrorMessage(190));\n }\n if (3 !== a.tag) throw Error(formatProdErrorMessage(188));\n return a.stateNode.current === a ? fiber : alternate;\n}\nfunction findCurrentHostFiberImpl(node) {\n var tag = node.tag;\n if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;\n for (node = node.child; null !== node; ) {\n tag = findCurrentHostFiberImpl(node);\n if (null !== tag) return tag;\n node = node.sibling;\n }\n return null;\n}\nvar assign = Object.assign,\n REACT_LEGACY_ELEMENT_TYPE = Symbol.for(\"react.element\"),\n REACT_ELEMENT_TYPE = Symbol.for(\"react.transitional.element\"),\n REACT_PORTAL_TYPE = Symbol.for(\"react.portal\"),\n REACT_FRAGMENT_TYPE = Symbol.for(\"react.fragment\"),\n REACT_STRICT_MODE_TYPE = Symbol.for(\"react.strict_mode\"),\n REACT_PROFILER_TYPE = Symbol.for(\"react.profiler\"),\n REACT_PROVIDER_TYPE = Symbol.for(\"react.provider\"),\n REACT_CONSUMER_TYPE = Symbol.for(\"react.consumer\"),\n REACT_CONTEXT_TYPE = Symbol.for(\"react.context\"),\n REACT_FORWARD_REF_TYPE = Symbol.for(\"react.forward_ref\"),\n REACT_SUSPENSE_TYPE = Symbol.for(\"react.suspense\"),\n REACT_SUSPENSE_LIST_TYPE = Symbol.for(\"react.suspense_list\"),\n REACT_MEMO_TYPE = Symbol.for(\"react.memo\"),\n REACT_LAZY_TYPE = Symbol.for(\"react.lazy\");\nSymbol.for(\"react.scope\");\nvar REACT_ACTIVITY_TYPE = Symbol.for(\"react.activity\");\nSymbol.for(\"react.legacy_hidden\");\nSymbol.for(\"react.tracing_marker\");\nvar REACT_MEMO_CACHE_SENTINEL = Symbol.for(\"react.memo_cache_sentinel\");\nSymbol.for(\"react.view_transition\");\nvar MAYBE_ITERATOR_SYMBOL = Symbol.iterator;\nfunction getIteratorFn(maybeIterable) {\n if (null === maybeIterable || \"object\" !== typeof maybeIterable) return null;\n maybeIterable =\n (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||\n maybeIterable[\"@@iterator\"];\n return \"function\" === typeof maybeIterable ? maybeIterable : null;\n}\nvar REACT_CLIENT_REFERENCE = Symbol.for(\"react.client.reference\");\nfunction getComponentNameFromType(type) {\n if (null == type) return null;\n if (\"function\" === typeof type)\n return type.$$typeof === REACT_CLIENT_REFERENCE\n ? null\n : type.displayName || type.name || null;\n if (\"string\" === typeof type) return type;\n switch (type) {\n case REACT_FRAGMENT_TYPE:\n return \"Fragment\";\n case REACT_PROFILER_TYPE:\n return \"Profiler\";\n case REACT_STRICT_MODE_TYPE:\n return \"StrictMode\";\n case REACT_SUSPENSE_TYPE:\n return \"Suspense\";\n case REACT_SUSPENSE_LIST_TYPE:\n return \"SuspenseList\";\n case REACT_ACTIVITY_TYPE:\n return \"Activity\";\n }\n if (\"object\" === typeof type)\n switch (type.$$typeof) {\n case REACT_PORTAL_TYPE:\n return \"Portal\";\n case REACT_CONTEXT_TYPE:\n return (type.displayName || \"Context\") + \".Provider\";\n case REACT_CONSUMER_TYPE:\n return (type._context.displayName || \"Context\") + \".Consumer\";\n case REACT_FORWARD_REF_TYPE:\n var innerType = type.render;\n type = type.displayName;\n type ||\n ((type = innerType.displayName || innerType.name || \"\"),\n (type = \"\" !== type ? \"ForwardRef(\" + type + \")\" : \"ForwardRef\"));\n return type;\n case REACT_MEMO_TYPE:\n return (\n (innerType = type.displayName || null),\n null !== innerType\n ? innerType\n : getComponentNameFromType(type.type) || \"Memo\"\n );\n case REACT_LAZY_TYPE:\n innerType = type._payload;\n type = type._init;\n try {\n return getComponentNameFromType(type(innerType));\n } catch (x) {}\n }\n return null;\n}\nvar isArrayImpl = Array.isArray,\n ReactSharedInternals =\n React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,\n ReactDOMSharedInternals =\n ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,\n sharedNotPendingObject = {\n pending: !1,\n data: null,\n method: null,\n action: null\n },\n valueStack = [],\n index = -1;\nfunction createCursor(defaultValue) {\n return { current: defaultValue };\n}\nfunction pop(cursor) {\n 0 > index ||\n ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);\n}\nfunction push(cursor, value) {\n index++;\n valueStack[index] = cursor.current;\n cursor.current = value;\n}\nvar contextStackCursor = createCursor(null),\n contextFiberStackCursor = createCursor(null),\n rootInstanceStackCursor = createCursor(null),\n hostTransitionProviderCursor = createCursor(null);\nfunction pushHostContainer(fiber, nextRootInstance) {\n push(rootInstanceStackCursor, nextRootInstance);\n push(contextFiberStackCursor, fiber);\n push(contextStackCursor, null);\n switch (nextRootInstance.nodeType) {\n case 9:\n case 11:\n fiber = (fiber = nextRootInstance.documentElement)\n ? (fiber = fiber.namespaceURI)\n ? getOwnHostContext(fiber)\n : 0\n : 0;\n break;\n default:\n if (\n ((fiber = nextRootInstance.tagName),\n (nextRootInstance = nextRootInstance.namespaceURI))\n )\n (nextRootInstance = getOwnHostContext(nextRootInstance)),\n (fiber = getChildHostContextProd(nextRootInstance, fiber));\n else\n switch (fiber) {\n case \"svg\":\n fiber = 1;\n break;\n case \"math\":\n fiber = 2;\n break;\n default:\n fiber = 0;\n }\n }\n pop(contextStackCursor);\n push(contextStackCursor, fiber);\n}\nfunction popHostContainer() {\n pop(contextStackCursor);\n pop(contextFiberStackCursor);\n pop(rootInstanceStackCursor);\n}\nfunction pushHostContext(fiber) {\n null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber);\n var context = contextStackCursor.current;\n var JSCompiler_inline_result = getChildHostContextProd(context, fiber.type);\n context !== JSCompiler_inline_result &&\n (push(contextFiberStackCursor, fiber),\n push(contextStackCursor, JSCompiler_inline_result));\n}\nfunction popHostContext(fiber) {\n contextFiberStackCursor.current === fiber &&\n (pop(contextStackCursor), pop(contextFiberStackCursor));\n hostTransitionProviderCursor.current === fiber &&\n (pop(hostTransitionProviderCursor),\n (HostTransitionContext._currentValue = sharedNotPendingObject));\n}\nvar hasOwnProperty = Object.prototype.hasOwnProperty,\n scheduleCallback$3 = Scheduler.unstable_scheduleCallback,\n cancelCallback$1 = Scheduler.unstable_cancelCallback,\n shouldYield = Scheduler.unstable_shouldYield,\n requestPaint = Scheduler.unstable_requestPaint,\n now = Scheduler.unstable_now,\n getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,\n ImmediatePriority = Scheduler.unstable_ImmediatePriority,\n UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,\n NormalPriority$1 = Scheduler.unstable_NormalPriority,\n LowPriority = Scheduler.unstable_LowPriority,\n IdlePriority = Scheduler.unstable_IdlePriority,\n log$1 = Scheduler.log,\n unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue,\n rendererID = null,\n injectedHook = null;\nfunction setIsStrictModeForDevtools(newIsStrictMode) {\n \"function\" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);\n if (injectedHook && \"function\" === typeof injectedHook.setStrictMode)\n try {\n injectedHook.setStrictMode(rendererID, newIsStrictMode);\n } catch (err) {}\n}\nvar clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,\n log = Math.log,\n LN2 = Math.LN2;\nfunction clz32Fallback(x) {\n x >>>= 0;\n return 0 === x ? 32 : (31 - ((log(x) / LN2) | 0)) | 0;\n}\nvar nextTransitionLane = 256,\n nextRetryLane = 4194304;\nfunction getHighestPriorityLanes(lanes) {\n var pendingSyncLanes = lanes & 42;\n if (0 !== pendingSyncLanes) return pendingSyncLanes;\n switch (lanes & -lanes) {\n case 1:\n return 1;\n case 2:\n return 2;\n case 4:\n return 4;\n case 8:\n return 8;\n case 16:\n return 16;\n case 32:\n return 32;\n case 64:\n return 64;\n case 128:\n return 128;\n case 256:\n case 512:\n case 1024:\n case 2048:\n case 4096:\n case 8192:\n case 16384:\n case 32768:\n case 65536:\n case 131072:\n case 262144:\n case 524288:\n case 1048576:\n case 2097152:\n return lanes & 4194048;\n case 4194304:\n case 8388608:\n case 16777216:\n case 33554432:\n return lanes & 62914560;\n case 67108864:\n return 67108864;\n case 134217728:\n return 134217728;\n case 268435456:\n return 268435456;\n case 536870912:\n return 536870912;\n case 1073741824:\n return 0;\n default:\n return lanes;\n }\n}\nfunction getNextLanes(root, wipLanes, rootHasPendingCommit) {\n var pendingLanes = root.pendingLanes;\n if (0 === pendingLanes) return 0;\n var nextLanes = 0,\n suspendedLanes = root.suspendedLanes,\n pingedLanes = root.pingedLanes;\n root = root.warmLanes;\n var nonIdlePendingLanes = pendingLanes & 134217727;\n 0 !== nonIdlePendingLanes\n ? ((pendingLanes = nonIdlePendingLanes & ~suspendedLanes),\n 0 !== pendingLanes\n ? (nextLanes = getHighestPriorityLanes(pendingLanes))\n : ((pingedLanes &= nonIdlePendingLanes),\n 0 !== pingedLanes\n ? (nextLanes = getHighestPriorityLanes(pingedLanes))\n : rootHasPendingCommit ||\n ((rootHasPendingCommit = nonIdlePendingLanes & ~root),\n 0 !== rootHasPendingCommit &&\n (nextLanes = getHighestPriorityLanes(rootHasPendingCommit)))))\n : ((nonIdlePendingLanes = pendingLanes & ~suspendedLanes),\n 0 !== nonIdlePendingLanes\n ? (nextLanes = getHighestPriorityLanes(nonIdlePendingLanes))\n : 0 !== pingedLanes\n ? (nextLanes = getHighestPriorityLanes(pingedLanes))\n : rootHasPendingCommit ||\n ((rootHasPendingCommit = pendingLanes & ~root),\n 0 !== rootHasPendingCommit &&\n (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));\n return 0 === nextLanes\n ? 0\n : 0 !== wipLanes &&\n wipLanes !== nextLanes &&\n 0 === (wipLanes & suspendedLanes) &&\n ((suspendedLanes = nextLanes & -nextLanes),\n (rootHasPendingCommit = wipLanes & -wipLanes),\n suspendedLanes >= rootHasPendingCommit ||\n (32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)))\n ? wipLanes\n : nextLanes;\n}\nfunction checkIfRootIsPrerendering(root, renderLanes) {\n return (\n 0 ===\n (root.pendingLanes &\n ~(root.suspendedLanes & ~root.pingedLanes) &\n renderLanes)\n );\n}\nfunction computeExpirationTime(lane, currentTime) {\n switch (lane) {\n case 1:\n case 2:\n case 4:\n case 8:\n case 64:\n return currentTime + 250;\n case 16:\n case 32:\n case 128:\n case 256:\n case 512:\n case 1024:\n case 2048:\n case 4096:\n case 8192:\n case 16384:\n case 32768:\n case 65536:\n case 131072:\n case 262144:\n case 524288:\n case 1048576:\n case 2097152:\n return currentTime + 5e3;\n case 4194304:\n case 8388608:\n case 16777216:\n case 33554432:\n return -1;\n case 67108864:\n case 134217728:\n case 268435456:\n case 536870912:\n case 1073741824:\n return -1;\n default:\n return -1;\n }\n}\nfunction claimNextTransitionLane() {\n var lane = nextTransitionLane;\n nextTransitionLane <<= 1;\n 0 === (nextTransitionLane & 4194048) && (nextTransitionLane = 256);\n return lane;\n}\nfunction claimNextRetryLane() {\n var lane = nextRetryLane;\n nextRetryLane <<= 1;\n 0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);\n return lane;\n}\nfunction createLaneMap(initial) {\n for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);\n return laneMap;\n}\nfunction markRootUpdated$1(root, updateLane) {\n root.pendingLanes |= updateLane;\n 268435456 !== updateLane &&\n ((root.suspendedLanes = 0), (root.pingedLanes = 0), (root.warmLanes = 0));\n}\nfunction markRootFinished(\n root,\n finishedLanes,\n remainingLanes,\n spawnedLane,\n updatedLanes,\n suspendedRetryLanes\n) {\n var previouslyPendingLanes = root.pendingLanes;\n root.pendingLanes = remainingLanes;\n root.suspendedLanes = 0;\n root.pingedLanes = 0;\n root.warmLanes = 0;\n root.expiredLanes &= remainingLanes;\n root.entangledLanes &= remainingLanes;\n root.errorRecoveryDisabledLanes &= remainingLanes;\n root.shellSuspendCounter = 0;\n var entanglements = root.entanglements,\n expirationTimes = root.expirationTimes,\n hiddenUpdates = root.hiddenUpdates;\n for (\n remainingLanes = previouslyPendingLanes & ~remainingLanes;\n 0 < remainingLanes;\n\n ) {\n var index$5 = 31 - clz32(remainingLanes),\n lane = 1 << index$5;\n entanglements[index$5] = 0;\n expirationTimes[index$5] = -1;\n var hiddenUpdatesForLane = hiddenUpdates[index$5];\n if (null !== hiddenUpdatesForLane)\n for (\n hiddenUpdates[index$5] = null, index$5 = 0;\n index$5 < hiddenUpdatesForLane.length;\n index$5++\n ) {\n var update = hiddenUpdatesForLane[index$5];\n null !== update && (update.lane &= -536870913);\n }\n remainingLanes &= ~lane;\n }\n 0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);\n 0 !== suspendedRetryLanes &&\n 0 === updatedLanes &&\n 0 !== root.tag &&\n (root.suspendedLanes |=\n suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));\n}\nfunction markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {\n root.pendingLanes |= spawnedLane;\n root.suspendedLanes &= ~spawnedLane;\n var spawnedLaneIndex = 31 - clz32(spawnedLane);\n root.entangledLanes |= spawnedLane;\n root.entanglements[spawnedLaneIndex] =\n root.entanglements[spawnedLaneIndex] |\n 1073741824 |\n (entangledLanes & 4194090);\n}\nfunction markRootEntangled(root, entangledLanes) {\n var rootEntangledLanes = (root.entangledLanes |= entangledLanes);\n for (root = root.entanglements; rootEntangledLanes; ) {\n var index$6 = 31 - clz32(rootEntangledLanes),\n lane = 1 << index$6;\n (lane & entangledLanes) | (root[index$6] & entangledLanes) &&\n (root[index$6] |= entangledLanes);\n rootEntangledLanes &= ~lane;\n }\n}\nfunction getBumpedLaneForHydrationByLane(lane) {\n switch (lane) {\n case 2:\n lane = 1;\n break;\n case 8:\n lane = 4;\n break;\n case 32:\n lane = 16;\n break;\n case 256:\n case 512:\n case 1024:\n case 2048:\n case 4096:\n case 8192:\n case 16384:\n case 32768:\n case 65536:\n case 131072:\n case 262144:\n case 524288:\n case 1048576:\n case 2097152:\n case 4194304:\n case 8388608:\n case 16777216:\n case 33554432:\n lane = 128;\n break;\n case 268435456:\n lane = 134217728;\n break;\n default:\n lane = 0;\n }\n return lane;\n}\nfunction lanesToEventPriority(lanes) {\n lanes &= -lanes;\n return 2 < lanes\n ? 8 < lanes\n ? 0 !== (lanes & 134217727)\n ? 32\n : 268435456\n : 8\n : 2;\n}\nfunction resolveUpdatePriority() {\n var updatePriority = ReactDOMSharedInternals.p;\n if (0 !== updatePriority) return updatePriority;\n updatePriority = window.event;\n return void 0 === updatePriority ? 32 : getEventPriority(updatePriority.type);\n}\nfunction runWithPriority(priority, fn) {\n var previousPriority = ReactDOMSharedInternals.p;\n try {\n return (ReactDOMSharedInternals.p = priority), fn();\n } finally {\n ReactDOMSharedInternals.p = previousPriority;\n }\n}\nvar randomKey = Math.random().toString(36).slice(2),\n internalInstanceKey = \"__reactFiber$\" + randomKey,\n internalPropsKey = \"__reactProps$\" + randomKey,\n internalContainerInstanceKey = \"__reactContainer$\" + randomKey,\n internalEventHandlersKey = \"__reactEvents$\" + randomKey,\n internalEventHandlerListenersKey = \"__reactListeners$\" + randomKey,\n internalEventHandlesSetKey = \"__reactHandles$\" + randomKey,\n internalRootNodeResourcesKey = \"__reactResources$\" + randomKey,\n internalHoistableMarker = \"__reactMarker$\" + randomKey;\nfunction detachDeletedInstance(node) {\n delete node[internalInstanceKey];\n delete node[internalPropsKey];\n delete node[internalEventHandlersKey];\n delete node[internalEventHandlerListenersKey];\n delete node[internalEventHandlesSetKey];\n}\nfunction getClosestInstanceFromNode(targetNode) {\n var targetInst = targetNode[internalInstanceKey];\n if (targetInst) return targetInst;\n for (var parentNode = targetNode.parentNode; parentNode; ) {\n if (\n (targetInst =\n parentNode[internalContainerInstanceKey] ||\n parentNode[internalInstanceKey])\n ) {\n parentNode = targetInst.alternate;\n if (\n null !== targetInst.child ||\n (null !== parentNode && null !== parentNode.child)\n )\n for (\n targetNode = getParentSuspenseInstance(targetNode);\n null !== targetNode;\n\n ) {\n if ((parentNode = targetNode[internalInstanceKey])) return parentNode;\n targetNode = getParentSuspenseInstance(targetNode);\n }\n return targetInst;\n }\n targetNode = parentNode;\n parentNode = targetNode.parentNode;\n }\n return null;\n}\nfunction getInstanceFromNode(node) {\n if (\n (node = node[internalInstanceKey] || node[internalContainerInstanceKey])\n ) {\n var tag = node.tag;\n if (\n 5 === tag ||\n 6 === tag ||\n 13 === tag ||\n 26 === tag ||\n 27 === tag ||\n 3 === tag\n )\n return node;\n }\n return null;\n}\nfunction getNodeFromInstance(inst) {\n var tag = inst.tag;\n if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return inst.stateNode;\n throw Error(formatProdErrorMessage(33));\n}\nfunction getResourcesFromRoot(root) {\n var resources = root[internalRootNodeResourcesKey];\n resources ||\n (resources = root[internalRootNodeResourcesKey] =\n { hoistableStyles: new Map(), hoistableScripts: new Map() });\n return resources;\n}\nfunction markNodeAsHoistable(node) {\n node[internalHoistableMarker] = !0;\n}\nvar allNativeEvents = new Set(),\n registrationNameDependencies = {};\nfunction registerTwoPhaseEvent(registrationName, dependencies) {\n registerDirectEvent(registrationName, dependencies);\n registerDirectEvent(registrationName + \"Capture\", dependencies);\n}\nfunction registerDirectEvent(registrationName, dependencies) {\n registrationNameDependencies[registrationName] = dependencies;\n for (\n registrationName = 0;\n registrationName < dependencies.length;\n registrationName++\n )\n allNativeEvents.add(dependencies[registrationName]);\n}\nvar VALID_ATTRIBUTE_NAME_REGEX = RegExp(\n \"^[: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]*$\"\n ),\n illegalAttributeNameCache = {},\n validatedAttributeNameCache = {};\nfunction isAttributeNameSafe(attributeName) {\n if (hasOwnProperty.call(validatedAttributeNameCache, attributeName))\n return !0;\n if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) return !1;\n if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName))\n return (validatedAttributeNameCache[attributeName] = !0);\n illegalAttributeNameCache[attributeName] = !0;\n return !1;\n}\nfunction setValueForAttribute(node, name, value) {\n if (isAttributeNameSafe(name))\n if (null === value) node.removeAttribute(name);\n else {\n switch (typeof value) {\n case \"undefined\":\n case \"function\":\n case \"symbol\":\n node.removeAttribute(name);\n return;\n case \"boolean\":\n var prefix$8 = name.toLowerCase().slice(0, 5);\n if (\"data-\" !== prefix$8 && \"aria-\" !== prefix$8) {\n node.removeAttribute(name);\n return;\n }\n }\n node.setAttribute(name, \"\" + value);\n }\n}\nfunction setValueForKnownAttribute(node, name, value) {\n if (null === value) node.removeAttribute(name);\n else {\n switch (typeof value) {\n case \"undefined\":\n case \"function\":\n case \"symbol\":\n case \"boolean\":\n node.removeAttribute(name);\n return;\n }\n node.setAttribute(name, \"\" + value);\n }\n}\nfunction setValueForNamespacedAttribute(node, namespace, name, value) {\n if (null === value) node.removeAttribute(name);\n else {\n switch (typeof value) {\n case \"undefined\":\n case \"function\":\n case \"symbol\":\n case \"boolean\":\n node.removeAttribute(name);\n return;\n }\n node.setAttributeNS(namespace, name, \"\" + value);\n }\n}\nvar prefix, suffix;\nfunction describeBuiltInComponentFrame(name) {\n if (void 0 === prefix)\n try {\n throw Error();\n } catch (x) {\n var match = x.stack.trim().match(/\\n( *(at )?)/);\n prefix = (match && match[1]) || \"\";\n suffix =\n -1 < x.stack.indexOf(\"\\n at\")\n ? \" ()\"\n : -1 < x.stack.indexOf(\"@\")\n ? \"@unknown:0:0\"\n : \"\";\n }\n return \"\\n\" + prefix + name + suffix;\n}\nvar reentry = !1;\nfunction describeNativeComponentFrame(fn, construct) {\n if (!fn || reentry) return \"\";\n reentry = !0;\n var previousPrepareStackTrace = Error.prepareStackTrace;\n Error.prepareStackTrace = void 0;\n try {\n var RunInRootFrame = {\n DetermineComponentFrameRoot: function () {\n try {\n if (construct) {\n var Fake = function () {\n throw Error();\n };\n Object.defineProperty(Fake.prototype, \"props\", {\n set: function () {\n throw Error();\n }\n });\n if (\"object\" === typeof Reflect && Reflect.construct) {\n try {\n Reflect.construct(Fake, []);\n } catch (x) {\n var control = x;\n }\n Reflect.construct(fn, [], Fake);\n } else {\n try {\n Fake.call();\n } catch (x$9) {\n control = x$9;\n }\n fn.call(Fake.prototype);\n }\n } else {\n try {\n throw Error();\n } catch (x$10) {\n control = x$10;\n }\n (Fake = fn()) &&\n \"function\" === typeof Fake.catch &&\n Fake.catch(function () {});\n }\n } catch (sample) {\n if (sample && control && \"string\" === typeof sample.stack)\n return [sample.stack, control.stack];\n }\n return [null, null];\n }\n };\n RunInRootFrame.DetermineComponentFrameRoot.displayName =\n \"DetermineComponentFrameRoot\";\n var namePropDescriptor = Object.getOwnPropertyDescriptor(\n RunInRootFrame.DetermineComponentFrameRoot,\n \"name\"\n );\n namePropDescriptor &&\n namePropDescriptor.configurable &&\n Object.defineProperty(\n RunInRootFrame.DetermineComponentFrameRoot,\n \"name\",\n { value: \"DetermineComponentFrameRoot\" }\n );\n var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),\n sampleStack = _RunInRootFrame$Deter[0],\n controlStack = _RunInRootFrame$Deter[1];\n if (sampleStack && controlStack) {\n var sampleLines = sampleStack.split(\"\\n\"),\n controlLines = controlStack.split(\"\\n\");\n for (\n namePropDescriptor = RunInRootFrame = 0;\n RunInRootFrame < sampleLines.length &&\n !sampleLines[RunInRootFrame].includes(\"DetermineComponentFrameRoot\");\n\n )\n RunInRootFrame++;\n for (\n ;\n namePropDescriptor < controlLines.length &&\n !controlLines[namePropDescriptor].includes(\n \"DetermineComponentFrameRoot\"\n );\n\n )\n namePropDescriptor++;\n if (\n RunInRootFrame === sampleLines.length ||\n namePropDescriptor === controlLines.length\n )\n for (\n RunInRootFrame = sampleLines.length - 1,\n namePropDescriptor = controlLines.length - 1;\n 1 <= RunInRootFrame &&\n 0 <= namePropDescriptor &&\n sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];\n\n )\n namePropDescriptor--;\n for (\n ;\n 1 <= RunInRootFrame && 0 <= namePropDescriptor;\n RunInRootFrame--, namePropDescriptor--\n )\n if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {\n if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {\n do\n if (\n (RunInRootFrame--,\n namePropDescriptor--,\n 0 > namePropDescriptor ||\n sampleLines[RunInRootFrame] !==\n controlLines[namePropDescriptor])\n ) {\n var frame =\n \"\\n\" +\n sampleLines[RunInRootFrame].replace(\" at new \", \" at \");\n fn.displayName &&\n frame.includes(\"\") &&\n (frame = frame.replace(\"\", fn.displayName));\n return frame;\n }\n while (1 <= RunInRootFrame && 0 <= namePropDescriptor);\n }\n break;\n }\n }\n } finally {\n (reentry = !1), (Error.prepareStackTrace = previousPrepareStackTrace);\n }\n return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : \"\")\n ? describeBuiltInComponentFrame(previousPrepareStackTrace)\n : \"\";\n}\nfunction describeFiber(fiber) {\n switch (fiber.tag) {\n case 26:\n case 27:\n case 5:\n return describeBuiltInComponentFrame(fiber.type);\n case 16:\n return describeBuiltInComponentFrame(\"Lazy\");\n case 13:\n return describeBuiltInComponentFrame(\"Suspense\");\n case 19:\n return describeBuiltInComponentFrame(\"SuspenseList\");\n case 0:\n case 15:\n return describeNativeComponentFrame(fiber.type, !1);\n case 11:\n return describeNativeComponentFrame(fiber.type.render, !1);\n case 1:\n return describeNativeComponentFrame(fiber.type, !0);\n case 31:\n return describeBuiltInComponentFrame(\"Activity\");\n default:\n return \"\";\n }\n}\nfunction getStackByFiberInDevAndProd(workInProgress) {\n try {\n var info = \"\";\n do\n (info += describeFiber(workInProgress)),\n (workInProgress = workInProgress.return);\n while (workInProgress);\n return info;\n } catch (x) {\n return \"\\nError generating stack: \" + x.message + \"\\n\" + x.stack;\n }\n}\nfunction getToStringValue(value) {\n switch (typeof value) {\n case \"bigint\":\n case \"boolean\":\n case \"number\":\n case \"string\":\n case \"undefined\":\n return value;\n case \"object\":\n return value;\n default:\n return \"\";\n }\n}\nfunction isCheckable(elem) {\n var type = elem.type;\n return (\n (elem = elem.nodeName) &&\n \"input\" === elem.toLowerCase() &&\n (\"checkbox\" === type || \"radio\" === type)\n );\n}\nfunction trackValueOnNode(node) {\n var valueField = isCheckable(node) ? \"checked\" : \"value\",\n descriptor = Object.getOwnPropertyDescriptor(\n node.constructor.prototype,\n valueField\n ),\n currentValue = \"\" + node[valueField];\n if (\n !node.hasOwnProperty(valueField) &&\n \"undefined\" !== typeof descriptor &&\n \"function\" === typeof descriptor.get &&\n \"function\" === typeof descriptor.set\n ) {\n var get = descriptor.get,\n set = descriptor.set;\n Object.defineProperty(node, valueField, {\n configurable: !0,\n get: function () {\n return get.call(this);\n },\n set: function (value) {\n currentValue = \"\" + value;\n set.call(this, value);\n }\n });\n Object.defineProperty(node, valueField, {\n enumerable: descriptor.enumerable\n });\n return {\n getValue: function () {\n return currentValue;\n },\n setValue: function (value) {\n currentValue = \"\" + value;\n },\n stopTracking: function () {\n node._valueTracker = null;\n delete node[valueField];\n }\n };\n }\n}\nfunction track(node) {\n node._valueTracker || (node._valueTracker = trackValueOnNode(node));\n}\nfunction updateValueIfChanged(node) {\n if (!node) return !1;\n var tracker = node._valueTracker;\n if (!tracker) return !0;\n var lastValue = tracker.getValue();\n var value = \"\";\n node &&\n (value = isCheckable(node)\n ? node.checked\n ? \"true\"\n : \"false\"\n : node.value);\n node = value;\n return node !== lastValue ? (tracker.setValue(node), !0) : !1;\n}\nfunction getActiveElement(doc) {\n doc = doc || (\"undefined\" !== typeof document ? document : void 0);\n if (\"undefined\" === typeof doc) return null;\n try {\n return doc.activeElement || doc.body;\n } catch (e) {\n return doc.body;\n }\n}\nvar escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\\n\"\\\\]/g;\nfunction escapeSelectorAttributeValueInsideDoubleQuotes(value) {\n return value.replace(\n escapeSelectorAttributeValueInsideDoubleQuotesRegex,\n function (ch) {\n return \"\\\\\" + ch.charCodeAt(0).toString(16) + \" \";\n }\n );\n}\nfunction updateInput(\n element,\n value,\n defaultValue,\n lastDefaultValue,\n checked,\n defaultChecked,\n type,\n name\n) {\n element.name = \"\";\n null != type &&\n \"function\" !== typeof type &&\n \"symbol\" !== typeof type &&\n \"boolean\" !== typeof type\n ? (element.type = type)\n : element.removeAttribute(\"type\");\n if (null != value)\n if (\"number\" === type) {\n if ((0 === value && \"\" === element.value) || element.value != value)\n element.value = \"\" + getToStringValue(value);\n } else\n element.value !== \"\" + getToStringValue(value) &&\n (element.value = \"\" + getToStringValue(value));\n else\n (\"submit\" !== type && \"reset\" !== type) || element.removeAttribute(\"value\");\n null != value\n ? setDefaultValue(element, type, getToStringValue(value))\n : null != defaultValue\n ? setDefaultValue(element, type, getToStringValue(defaultValue))\n : null != lastDefaultValue && element.removeAttribute(\"value\");\n null == checked &&\n null != defaultChecked &&\n (element.defaultChecked = !!defaultChecked);\n null != checked &&\n (element.checked =\n checked && \"function\" !== typeof checked && \"symbol\" !== typeof checked);\n null != name &&\n \"function\" !== typeof name &&\n \"symbol\" !== typeof name &&\n \"boolean\" !== typeof name\n ? (element.name = \"\" + getToStringValue(name))\n : element.removeAttribute(\"name\");\n}\nfunction initInput(\n element,\n value,\n defaultValue,\n checked,\n defaultChecked,\n type,\n name,\n isHydrating\n) {\n null != type &&\n \"function\" !== typeof type &&\n \"symbol\" !== typeof type &&\n \"boolean\" !== typeof type &&\n (element.type = type);\n if (null != value || null != defaultValue) {\n if (\n !(\n (\"submit\" !== type && \"reset\" !== type) ||\n (void 0 !== value && null !== value)\n )\n )\n return;\n defaultValue =\n null != defaultValue ? \"\" + getToStringValue(defaultValue) : \"\";\n value = null != value ? \"\" + getToStringValue(value) : defaultValue;\n isHydrating || value === element.value || (element.value = value);\n element.defaultValue = value;\n }\n checked = null != checked ? checked : defaultChecked;\n checked =\n \"function\" !== typeof checked && \"symbol\" !== typeof checked && !!checked;\n element.checked = isHydrating ? element.checked : !!checked;\n element.defaultChecked = !!checked;\n null != name &&\n \"function\" !== typeof name &&\n \"symbol\" !== typeof name &&\n \"boolean\" !== typeof name &&\n (element.name = name);\n}\nfunction setDefaultValue(node, type, value) {\n (\"number\" === type && getActiveElement(node.ownerDocument) === node) ||\n node.defaultValue === \"\" + value ||\n (node.defaultValue = \"\" + value);\n}\nfunction updateOptions(node, multiple, propValue, setDefaultSelected) {\n node = node.options;\n if (multiple) {\n multiple = {};\n for (var i = 0; i < propValue.length; i++)\n multiple[\"$\" + propValue[i]] = !0;\n for (propValue = 0; propValue < node.length; propValue++)\n (i = multiple.hasOwnProperty(\"$\" + node[propValue].value)),\n node[propValue].selected !== i && (node[propValue].selected = i),\n i && setDefaultSelected && (node[propValue].defaultSelected = !0);\n } else {\n propValue = \"\" + getToStringValue(propValue);\n multiple = null;\n for (i = 0; i < node.length; i++) {\n if (node[i].value === propValue) {\n node[i].selected = !0;\n setDefaultSelected && (node[i].defaultSelected = !0);\n return;\n }\n null !== multiple || node[i].disabled || (multiple = node[i]);\n }\n null !== multiple && (multiple.selected = !0);\n }\n}\nfunction updateTextarea(element, value, defaultValue) {\n if (\n null != value &&\n ((value = \"\" + getToStringValue(value)),\n value !== element.value && (element.value = value),\n null == defaultValue)\n ) {\n element.defaultValue !== value && (element.defaultValue = value);\n return;\n }\n element.defaultValue =\n null != defaultValue ? \"\" + getToStringValue(defaultValue) : \"\";\n}\nfunction initTextarea(element, value, defaultValue, children) {\n if (null == value) {\n if (null != children) {\n if (null != defaultValue) throw Error(formatProdErrorMessage(92));\n if (isArrayImpl(children)) {\n if (1 < children.length) throw Error(formatProdErrorMessage(93));\n children = children[0];\n }\n defaultValue = children;\n }\n null == defaultValue && (defaultValue = \"\");\n value = defaultValue;\n }\n defaultValue = getToStringValue(value);\n element.defaultValue = defaultValue;\n children = element.textContent;\n children === defaultValue &&\n \"\" !== children &&\n null !== children &&\n (element.value = children);\n}\nfunction setTextContent(node, text) {\n if (text) {\n var firstChild = node.firstChild;\n if (\n firstChild &&\n firstChild === node.lastChild &&\n 3 === firstChild.nodeType\n ) {\n firstChild.nodeValue = text;\n return;\n }\n }\n node.textContent = text;\n}\nvar unitlessNumbers = new Set(\n \"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(\n \" \"\n )\n);\nfunction setValueForStyle(style, styleName, value) {\n var isCustomProperty = 0 === styleName.indexOf(\"--\");\n null == value || \"boolean\" === typeof value || \"\" === value\n ? isCustomProperty\n ? style.setProperty(styleName, \"\")\n : \"float\" === styleName\n ? (style.cssFloat = \"\")\n : (style[styleName] = \"\")\n : isCustomProperty\n ? style.setProperty(styleName, value)\n : \"number\" !== typeof value ||\n 0 === value ||\n unitlessNumbers.has(styleName)\n ? \"float\" === styleName\n ? (style.cssFloat = value)\n : (style[styleName] = (\"\" + value).trim())\n : (style[styleName] = value + \"px\");\n}\nfunction setValueForStyles(node, styles, prevStyles) {\n if (null != styles && \"object\" !== typeof styles)\n throw Error(formatProdErrorMessage(62));\n node = node.style;\n if (null != prevStyles) {\n for (var styleName in prevStyles)\n !prevStyles.hasOwnProperty(styleName) ||\n (null != styles && styles.hasOwnProperty(styleName)) ||\n (0 === styleName.indexOf(\"--\")\n ? node.setProperty(styleName, \"\")\n : \"float\" === styleName\n ? (node.cssFloat = \"\")\n : (node[styleName] = \"\"));\n for (var styleName$16 in styles)\n (styleName = styles[styleName$16]),\n styles.hasOwnProperty(styleName$16) &&\n prevStyles[styleName$16] !== styleName &&\n setValueForStyle(node, styleName$16, styleName);\n } else\n for (var styleName$17 in styles)\n styles.hasOwnProperty(styleName$17) &&\n setValueForStyle(node, styleName$17, styles[styleName$17]);\n}\nfunction isCustomElement(tagName) {\n if (-1 === tagName.indexOf(\"-\")) return !1;\n switch (tagName) {\n case \"annotation-xml\":\n case \"color-profile\":\n case \"font-face\":\n case \"font-face-src\":\n case \"font-face-uri\":\n case \"font-face-format\":\n case \"font-face-name\":\n case \"missing-glyph\":\n return !1;\n default:\n return !0;\n }\n}\nvar aliases = new Map([\n [\"acceptCharset\", \"accept-charset\"],\n [\"htmlFor\", \"for\"],\n [\"httpEquiv\", \"http-equiv\"],\n [\"crossOrigin\", \"crossorigin\"],\n [\"accentHeight\", \"accent-height\"],\n [\"alignmentBaseline\", \"alignment-baseline\"],\n [\"arabicForm\", \"arabic-form\"],\n [\"baselineShift\", \"baseline-shift\"],\n [\"capHeight\", \"cap-height\"],\n [\"clipPath\", \"clip-path\"],\n [\"clipRule\", \"clip-rule\"],\n [\"colorInterpolation\", \"color-interpolation\"],\n [\"colorInterpolationFilters\", \"color-interpolation-filters\"],\n [\"colorProfile\", \"color-profile\"],\n [\"colorRendering\", \"color-rendering\"],\n [\"dominantBaseline\", \"dominant-baseline\"],\n [\"enableBackground\", \"enable-background\"],\n [\"fillOpacity\", \"fill-opacity\"],\n [\"fillRule\", \"fill-rule\"],\n [\"floodColor\", \"flood-color\"],\n [\"floodOpacity\", \"flood-opacity\"],\n [\"fontFamily\", \"font-family\"],\n [\"fontSize\", \"font-size\"],\n [\"fontSizeAdjust\", \"font-size-adjust\"],\n [\"fontStretch\", \"font-stretch\"],\n [\"fontStyle\", \"font-style\"],\n [\"fontVariant\", \"font-variant\"],\n [\"fontWeight\", \"font-weight\"],\n [\"glyphName\", \"glyph-name\"],\n [\"glyphOrientationHorizontal\", \"glyph-orientation-horizontal\"],\n [\"glyphOrientationVertical\", \"glyph-orientation-vertical\"],\n [\"horizAdvX\", \"horiz-adv-x\"],\n [\"horizOriginX\", \"horiz-origin-x\"],\n [\"imageRendering\", \"image-rendering\"],\n [\"letterSpacing\", \"letter-spacing\"],\n [\"lightingColor\", \"lighting-color\"],\n [\"markerEnd\", \"marker-end\"],\n [\"markerMid\", \"marker-mid\"],\n [\"markerStart\", \"marker-start\"],\n [\"overlinePosition\", \"overline-position\"],\n [\"overlineThickness\", \"overline-thickness\"],\n [\"paintOrder\", \"paint-order\"],\n [\"panose-1\", \"panose-1\"],\n [\"pointerEvents\", \"pointer-events\"],\n [\"renderingIntent\", \"rendering-intent\"],\n [\"shapeRendering\", \"shape-rendering\"],\n [\"stopColor\", \"stop-color\"],\n [\"stopOpacity\", \"stop-opacity\"],\n [\"strikethroughPosition\", \"strikethrough-position\"],\n [\"strikethroughThickness\", \"strikethrough-thickness\"],\n [\"strokeDasharray\", \"stroke-dasharray\"],\n [\"strokeDashoffset\", \"stroke-dashoffset\"],\n [\"strokeLinecap\", \"stroke-linecap\"],\n [\"strokeLinejoin\", \"stroke-linejoin\"],\n [\"strokeMiterlimit\", \"stroke-miterlimit\"],\n [\"strokeOpacity\", \"stroke-opacity\"],\n [\"strokeWidth\", \"stroke-width\"],\n [\"textAnchor\", \"text-anchor\"],\n [\"textDecoration\", \"text-decoration\"],\n [\"textRendering\", \"text-rendering\"],\n [\"transformOrigin\", \"transform-origin\"],\n [\"underlinePosition\", \"underline-position\"],\n [\"underlineThickness\", \"underline-thickness\"],\n [\"unicodeBidi\", \"unicode-bidi\"],\n [\"unicodeRange\", \"unicode-range\"],\n [\"unitsPerEm\", \"units-per-em\"],\n [\"vAlphabetic\", \"v-alphabetic\"],\n [\"vHanging\", \"v-hanging\"],\n [\"vIdeographic\", \"v-ideographic\"],\n [\"vMathematical\", \"v-mathematical\"],\n [\"vectorEffect\", \"vector-effect\"],\n [\"vertAdvY\", \"vert-adv-y\"],\n [\"vertOriginX\", \"vert-origin-x\"],\n [\"vertOriginY\", \"vert-origin-y\"],\n [\"wordSpacing\", \"word-spacing\"],\n [\"writingMode\", \"writing-mode\"],\n [\"xmlnsXlink\", \"xmlns:xlink\"],\n [\"xHeight\", \"x-height\"]\n ]),\n isJavaScriptProtocol =\n /^[\\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;\nfunction sanitizeURL(url) {\n return isJavaScriptProtocol.test(\"\" + url)\n ? \"javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')\"\n : url;\n}\nvar currentReplayingEvent = null;\nfunction getEventTarget(nativeEvent) {\n nativeEvent = nativeEvent.target || nativeEvent.srcElement || window;\n nativeEvent.correspondingUseElement &&\n (nativeEvent = nativeEvent.correspondingUseElement);\n return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;\n}\nvar restoreTarget = null,\n restoreQueue = null;\nfunction restoreStateOfTarget(target) {\n var internalInstance = getInstanceFromNode(target);\n if (internalInstance && (target = internalInstance.stateNode)) {\n var props = target[internalPropsKey] || null;\n a: switch (((target = internalInstance.stateNode), internalInstance.type)) {\n case \"input\":\n updateInput(\n target,\n props.value,\n props.defaultValue,\n props.defaultValue,\n props.checked,\n props.defaultChecked,\n props.type,\n props.name\n );\n internalInstance = props.name;\n if (\"radio\" === props.type && null != internalInstance) {\n for (props = target; props.parentNode; ) props = props.parentNode;\n props = props.querySelectorAll(\n 'input[name=\"' +\n escapeSelectorAttributeValueInsideDoubleQuotes(\n \"\" + internalInstance\n ) +\n '\"][type=\"radio\"]'\n );\n for (\n internalInstance = 0;\n internalInstance < props.length;\n internalInstance++\n ) {\n var otherNode = props[internalInstance];\n if (otherNode !== target && otherNode.form === target.form) {\n var otherProps = otherNode[internalPropsKey] || null;\n if (!otherProps) throw Error(formatProdErrorMessage(90));\n updateInput(\n otherNode,\n otherProps.value,\n otherProps.defaultValue,\n otherProps.defaultValue,\n otherProps.checked,\n otherProps.defaultChecked,\n otherProps.type,\n otherProps.name\n );\n }\n }\n for (\n internalInstance = 0;\n internalInstance < props.length;\n internalInstance++\n )\n (otherNode = props[internalInstance]),\n otherNode.form === target.form && updateValueIfChanged(otherNode);\n }\n break a;\n case \"textarea\":\n updateTextarea(target, props.value, props.defaultValue);\n break a;\n case \"select\":\n (internalInstance = props.value),\n null != internalInstance &&\n updateOptions(target, !!props.multiple, internalInstance, !1);\n }\n }\n}\nvar isInsideEventHandler = !1;\nfunction batchedUpdates$1(fn, a, b) {\n if (isInsideEventHandler) return fn(a, b);\n isInsideEventHandler = !0;\n try {\n var JSCompiler_inline_result = fn(a);\n return JSCompiler_inline_result;\n } finally {\n if (\n ((isInsideEventHandler = !1),\n null !== restoreTarget || null !== restoreQueue)\n )\n if (\n (flushSyncWork$1(),\n restoreTarget &&\n ((a = restoreTarget),\n (fn = restoreQueue),\n (restoreQueue = restoreTarget = null),\n restoreStateOfTarget(a),\n fn))\n )\n for (a = 0; a < fn.length; a++) restoreStateOfTarget(fn[a]);\n }\n}\nfunction getListener(inst, registrationName) {\n var stateNode = inst.stateNode;\n if (null === stateNode) return null;\n var props = stateNode[internalPropsKey] || null;\n if (null === props) return null;\n stateNode = props[registrationName];\n a: switch (registrationName) {\n case \"onClick\":\n case \"onClickCapture\":\n case \"onDoubleClick\":\n case \"onDoubleClickCapture\":\n case \"onMouseDown\":\n case \"onMouseDownCapture\":\n case \"onMouseMove\":\n case \"onMouseMoveCapture\":\n case \"onMouseUp\":\n case \"onMouseUpCapture\":\n case \"onMouseEnter\":\n (props = !props.disabled) ||\n ((inst = inst.type),\n (props = !(\n \"button\" === inst ||\n \"input\" === inst ||\n \"select\" === inst ||\n \"textarea\" === inst\n )));\n inst = !props;\n break a;\n default:\n inst = !1;\n }\n if (inst) return null;\n if (stateNode && \"function\" !== typeof stateNode)\n throw Error(\n formatProdErrorMessage(231, registrationName, typeof stateNode)\n );\n return stateNode;\n}\nvar canUseDOM = !(\n \"undefined\" === typeof window ||\n \"undefined\" === typeof window.document ||\n \"undefined\" === typeof window.document.createElement\n ),\n passiveBrowserEventsSupported = !1;\nif (canUseDOM)\n try {\n var options = {};\n Object.defineProperty(options, \"passive\", {\n get: function () {\n passiveBrowserEventsSupported = !0;\n }\n });\n window.addEventListener(\"test\", options, options);\n window.removeEventListener(\"test\", options, options);\n } catch (e) {\n passiveBrowserEventsSupported = !1;\n }\nvar root = null,\n startText = null,\n fallbackText = null;\nfunction getData() {\n if (fallbackText) return fallbackText;\n var start,\n startValue = startText,\n startLength = startValue.length,\n end,\n endValue = \"value\" in root ? root.value : root.textContent,\n endLength = endValue.length;\n for (\n start = 0;\n start < startLength && startValue[start] === endValue[start];\n start++\n );\n var minEnd = startLength - start;\n for (\n end = 1;\n end <= minEnd &&\n startValue[startLength - end] === endValue[endLength - end];\n end++\n );\n return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));\n}\nfunction getEventCharCode(nativeEvent) {\n var keyCode = nativeEvent.keyCode;\n \"charCode\" in nativeEvent\n ? ((nativeEvent = nativeEvent.charCode),\n 0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))\n : (nativeEvent = keyCode);\n 10 === nativeEvent && (nativeEvent = 13);\n return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;\n}\nfunction functionThatReturnsTrue() {\n return !0;\n}\nfunction functionThatReturnsFalse() {\n return !1;\n}\nfunction createSyntheticEvent(Interface) {\n function SyntheticBaseEvent(\n reactName,\n reactEventType,\n targetInst,\n nativeEvent,\n nativeEventTarget\n ) {\n this._reactName = reactName;\n this._targetInst = targetInst;\n this.type = reactEventType;\n this.nativeEvent = nativeEvent;\n this.target = nativeEventTarget;\n this.currentTarget = null;\n for (var propName in Interface)\n Interface.hasOwnProperty(propName) &&\n ((reactName = Interface[propName]),\n (this[propName] = reactName\n ? reactName(nativeEvent)\n : nativeEvent[propName]));\n this.isDefaultPrevented = (\n null != nativeEvent.defaultPrevented\n ? nativeEvent.defaultPrevented\n : !1 === nativeEvent.returnValue\n )\n ? functionThatReturnsTrue\n : functionThatReturnsFalse;\n this.isPropagationStopped = functionThatReturnsFalse;\n return this;\n }\n assign(SyntheticBaseEvent.prototype, {\n preventDefault: function () {\n this.defaultPrevented = !0;\n var event = this.nativeEvent;\n event &&\n (event.preventDefault\n ? event.preventDefault()\n : \"unknown\" !== typeof event.returnValue && (event.returnValue = !1),\n (this.isDefaultPrevented = functionThatReturnsTrue));\n },\n stopPropagation: function () {\n var event = this.nativeEvent;\n event &&\n (event.stopPropagation\n ? event.stopPropagation()\n : \"unknown\" !== typeof event.cancelBubble &&\n (event.cancelBubble = !0),\n (this.isPropagationStopped = functionThatReturnsTrue));\n },\n persist: function () {},\n isPersistent: functionThatReturnsTrue\n });\n return SyntheticBaseEvent;\n}\nvar EventInterface = {\n eventPhase: 0,\n bubbles: 0,\n cancelable: 0,\n timeStamp: function (event) {\n return event.timeStamp || Date.now();\n },\n defaultPrevented: 0,\n isTrusted: 0\n },\n SyntheticEvent = createSyntheticEvent(EventInterface),\n UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),\n SyntheticUIEvent = createSyntheticEvent(UIEventInterface),\n lastMovementX,\n lastMovementY,\n lastMouseEvent,\n MouseEventInterface = assign({}, UIEventInterface, {\n screenX: 0,\n screenY: 0,\n clientX: 0,\n clientY: 0,\n pageX: 0,\n pageY: 0,\n ctrlKey: 0,\n shiftKey: 0,\n altKey: 0,\n metaKey: 0,\n getModifierState: getEventModifierState,\n button: 0,\n buttons: 0,\n relatedTarget: function (event) {\n return void 0 === event.relatedTarget\n ? event.fromElement === event.srcElement\n ? event.toElement\n : event.fromElement\n : event.relatedTarget;\n },\n movementX: function (event) {\n if (\"movementX\" in event) return event.movementX;\n event !== lastMouseEvent &&\n (lastMouseEvent && \"mousemove\" === event.type\n ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),\n (lastMovementY = event.screenY - lastMouseEvent.screenY))\n : (lastMovementY = lastMovementX = 0),\n (lastMouseEvent = event));\n return lastMovementX;\n },\n movementY: function (event) {\n return \"movementY\" in event ? event.movementY : lastMovementY;\n }\n }),\n SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),\n DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),\n SyntheticDragEvent = createSyntheticEvent(DragEventInterface),\n FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),\n SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),\n AnimationEventInterface = assign({}, EventInterface, {\n animationName: 0,\n elapsedTime: 0,\n pseudoElement: 0\n }),\n SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),\n ClipboardEventInterface = assign({}, EventInterface, {\n clipboardData: function (event) {\n return \"clipboardData\" in event\n ? event.clipboardData\n : window.clipboardData;\n }\n }),\n SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),\n CompositionEventInterface = assign({}, EventInterface, { data: 0 }),\n SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),\n normalizeKey = {\n Esc: \"Escape\",\n Spacebar: \" \",\n Left: \"ArrowLeft\",\n Up: \"ArrowUp\",\n Right: \"ArrowRight\",\n Down: \"ArrowDown\",\n Del: \"Delete\",\n Win: \"OS\",\n Menu: \"ContextMenu\",\n Apps: \"ContextMenu\",\n Scroll: \"ScrollLock\",\n MozPrintableKey: \"Unidentified\"\n },\n translateToKey = {\n 8: \"Backspace\",\n 9: \"Tab\",\n 12: \"Clear\",\n 13: \"Enter\",\n 16: \"Shift\",\n 17: \"Control\",\n 18: \"Alt\",\n 19: \"Pause\",\n 20: \"CapsLock\",\n 27: \"Escape\",\n 32: \" \",\n 33: \"PageUp\",\n 34: \"PageDown\",\n 35: \"End\",\n 36: \"Home\",\n 37: \"ArrowLeft\",\n 38: \"ArrowUp\",\n 39: \"ArrowRight\",\n 40: \"ArrowDown\",\n 45: \"Insert\",\n 46: \"Delete\",\n 112: \"F1\",\n 113: \"F2\",\n 114: \"F3\",\n 115: \"F4\",\n 116: \"F5\",\n 117: \"F6\",\n 118: \"F7\",\n 119: \"F8\",\n 120: \"F9\",\n 121: \"F10\",\n 122: \"F11\",\n 123: \"F12\",\n 144: \"NumLock\",\n 145: \"ScrollLock\",\n 224: \"Meta\"\n },\n modifierKeyToProp = {\n Alt: \"altKey\",\n Control: \"ctrlKey\",\n Meta: \"metaKey\",\n Shift: \"shiftKey\"\n };\nfunction modifierStateGetter(keyArg) {\n var nativeEvent = this.nativeEvent;\n return nativeEvent.getModifierState\n ? nativeEvent.getModifierState(keyArg)\n : (keyArg = modifierKeyToProp[keyArg])\n ? !!nativeEvent[keyArg]\n : !1;\n}\nfunction getEventModifierState() {\n return modifierStateGetter;\n}\nvar KeyboardEventInterface = assign({}, UIEventInterface, {\n key: function (nativeEvent) {\n if (nativeEvent.key) {\n var key = normalizeKey[nativeEvent.key] || nativeEvent.key;\n if (\"Unidentified\" !== key) return key;\n }\n return \"keypress\" === nativeEvent.type\n ? ((nativeEvent = getEventCharCode(nativeEvent)),\n 13 === nativeEvent ? \"Enter\" : String.fromCharCode(nativeEvent))\n : \"keydown\" === nativeEvent.type || \"keyup\" === nativeEvent.type\n ? translateToKey[nativeEvent.keyCode] || \"Unidentified\"\n : \"\";\n },\n code: 0,\n location: 0,\n ctrlKey: 0,\n shiftKey: 0,\n altKey: 0,\n metaKey: 0,\n repeat: 0,\n locale: 0,\n getModifierState: getEventModifierState,\n charCode: function (event) {\n return \"keypress\" === event.type ? getEventCharCode(event) : 0;\n },\n keyCode: function (event) {\n return \"keydown\" === event.type || \"keyup\" === event.type\n ? event.keyCode\n : 0;\n },\n which: function (event) {\n return \"keypress\" === event.type\n ? getEventCharCode(event)\n : \"keydown\" === event.type || \"keyup\" === event.type\n ? event.keyCode\n : 0;\n }\n }),\n SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),\n PointerEventInterface = assign({}, MouseEventInterface, {\n pointerId: 0,\n width: 0,\n height: 0,\n pressure: 0,\n tangentialPressure: 0,\n tiltX: 0,\n tiltY: 0,\n twist: 0,\n pointerType: 0,\n isPrimary: 0\n }),\n SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),\n TouchEventInterface = assign({}, UIEventInterface, {\n touches: 0,\n targetTouches: 0,\n changedTouches: 0,\n altKey: 0,\n metaKey: 0,\n ctrlKey: 0,\n shiftKey: 0,\n getModifierState: getEventModifierState\n }),\n SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),\n TransitionEventInterface = assign({}, EventInterface, {\n propertyName: 0,\n elapsedTime: 0,\n pseudoElement: 0\n }),\n SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),\n WheelEventInterface = assign({}, MouseEventInterface, {\n deltaX: function (event) {\n return \"deltaX\" in event\n ? event.deltaX\n : \"wheelDeltaX\" in event\n ? -event.wheelDeltaX\n : 0;\n },\n deltaY: function (event) {\n return \"deltaY\" in event\n ? event.deltaY\n : \"wheelDeltaY\" in event\n ? -event.wheelDeltaY\n : \"wheelDelta\" in event\n ? -event.wheelDelta\n : 0;\n },\n deltaZ: 0,\n deltaMode: 0\n }),\n SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),\n ToggleEventInterface = assign({}, EventInterface, {\n newState: 0,\n oldState: 0\n }),\n SyntheticToggleEvent = createSyntheticEvent(ToggleEventInterface),\n END_KEYCODES = [9, 13, 27, 32],\n canUseCompositionEvent = canUseDOM && \"CompositionEvent\" in window,\n documentMode = null;\ncanUseDOM &&\n \"documentMode\" in document &&\n (documentMode = document.documentMode);\nvar canUseTextInputEvent = canUseDOM && \"TextEvent\" in window && !documentMode,\n useFallbackCompositionData =\n canUseDOM &&\n (!canUseCompositionEvent ||\n (documentMode && 8 < documentMode && 11 >= documentMode)),\n SPACEBAR_CHAR = String.fromCharCode(32),\n hasSpaceKeypress = !1;\nfunction isFallbackCompositionEnd(domEventName, nativeEvent) {\n switch (domEventName) {\n case \"keyup\":\n return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);\n case \"keydown\":\n return 229 !== nativeEvent.keyCode;\n case \"keypress\":\n case \"mousedown\":\n case \"focusout\":\n return !0;\n default:\n return !1;\n }\n}\nfunction getDataFromCustomEvent(nativeEvent) {\n nativeEvent = nativeEvent.detail;\n return \"object\" === typeof nativeEvent && \"data\" in nativeEvent\n ? nativeEvent.data\n : null;\n}\nvar isComposing = !1;\nfunction getNativeBeforeInputChars(domEventName, nativeEvent) {\n switch (domEventName) {\n case \"compositionend\":\n return getDataFromCustomEvent(nativeEvent);\n case \"keypress\":\n if (32 !== nativeEvent.which) return null;\n hasSpaceKeypress = !0;\n return SPACEBAR_CHAR;\n case \"textInput\":\n return (\n (domEventName = nativeEvent.data),\n domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName\n );\n default:\n return null;\n }\n}\nfunction getFallbackBeforeInputChars(domEventName, nativeEvent) {\n if (isComposing)\n return \"compositionend\" === domEventName ||\n (!canUseCompositionEvent &&\n isFallbackCompositionEnd(domEventName, nativeEvent))\n ? ((domEventName = getData()),\n (fallbackText = startText = root = null),\n (isComposing = !1),\n domEventName)\n : null;\n switch (domEventName) {\n case \"paste\":\n return null;\n case \"keypress\":\n if (\n !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||\n (nativeEvent.ctrlKey && nativeEvent.altKey)\n ) {\n if (nativeEvent.char && 1 < nativeEvent.char.length)\n return nativeEvent.char;\n if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);\n }\n return null;\n case \"compositionend\":\n return useFallbackCompositionData && \"ko\" !== nativeEvent.locale\n ? null\n : nativeEvent.data;\n default:\n return null;\n }\n}\nvar supportedInputTypes = {\n color: !0,\n date: !0,\n datetime: !0,\n \"datetime-local\": !0,\n email: !0,\n month: !0,\n number: !0,\n password: !0,\n range: !0,\n search: !0,\n tel: !0,\n text: !0,\n time: !0,\n url: !0,\n week: !0\n};\nfunction isTextInputElement(elem) {\n var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n return \"input\" === nodeName\n ? !!supportedInputTypes[elem.type]\n : \"textarea\" === nodeName\n ? !0\n : !1;\n}\nfunction createAndAccumulateChangeEvent(\n dispatchQueue,\n inst,\n nativeEvent,\n target\n) {\n restoreTarget\n ? restoreQueue\n ? restoreQueue.push(target)\n : (restoreQueue = [target])\n : (restoreTarget = target);\n inst = accumulateTwoPhaseListeners(inst, \"onChange\");\n 0 < inst.length &&\n ((nativeEvent = new SyntheticEvent(\n \"onChange\",\n \"change\",\n null,\n nativeEvent,\n target\n )),\n dispatchQueue.push({ event: nativeEvent, listeners: inst }));\n}\nvar activeElement$1 = null,\n activeElementInst$1 = null;\nfunction runEventInBatch(dispatchQueue) {\n processDispatchQueue(dispatchQueue, 0);\n}\nfunction getInstIfValueChanged(targetInst) {\n var targetNode = getNodeFromInstance(targetInst);\n if (updateValueIfChanged(targetNode)) return targetInst;\n}\nfunction getTargetInstForChangeEvent(domEventName, targetInst) {\n if (\"change\" === domEventName) return targetInst;\n}\nvar isInputEventSupported = !1;\nif (canUseDOM) {\n var JSCompiler_inline_result$jscomp$282;\n if (canUseDOM) {\n var isSupported$jscomp$inline_417 = \"oninput\" in document;\n if (!isSupported$jscomp$inline_417) {\n var element$jscomp$inline_418 = document.createElement(\"div\");\n element$jscomp$inline_418.setAttribute(\"oninput\", \"return;\");\n isSupported$jscomp$inline_417 =\n \"function\" === typeof element$jscomp$inline_418.oninput;\n }\n JSCompiler_inline_result$jscomp$282 = isSupported$jscomp$inline_417;\n } else JSCompiler_inline_result$jscomp$282 = !1;\n isInputEventSupported =\n JSCompiler_inline_result$jscomp$282 &&\n (!document.documentMode || 9 < document.documentMode);\n}\nfunction stopWatchingForValueChange() {\n activeElement$1 &&\n (activeElement$1.detachEvent(\"onpropertychange\", handlePropertyChange),\n (activeElementInst$1 = activeElement$1 = null));\n}\nfunction handlePropertyChange(nativeEvent) {\n if (\n \"value\" === nativeEvent.propertyName &&\n getInstIfValueChanged(activeElementInst$1)\n ) {\n var dispatchQueue = [];\n createAndAccumulateChangeEvent(\n dispatchQueue,\n activeElementInst$1,\n nativeEvent,\n getEventTarget(nativeEvent)\n );\n batchedUpdates$1(runEventInBatch, dispatchQueue);\n }\n}\nfunction handleEventsForInputEventPolyfill(domEventName, target, targetInst) {\n \"focusin\" === domEventName\n ? (stopWatchingForValueChange(),\n (activeElement$1 = target),\n (activeElementInst$1 = targetInst),\n activeElement$1.attachEvent(\"onpropertychange\", handlePropertyChange))\n : \"focusout\" === domEventName && stopWatchingForValueChange();\n}\nfunction getTargetInstForInputEventPolyfill(domEventName) {\n if (\n \"selectionchange\" === domEventName ||\n \"keyup\" === domEventName ||\n \"keydown\" === domEventName\n )\n return getInstIfValueChanged(activeElementInst$1);\n}\nfunction getTargetInstForClickEvent(domEventName, targetInst) {\n if (\"click\" === domEventName) return getInstIfValueChanged(targetInst);\n}\nfunction getTargetInstForInputOrChangeEvent(domEventName, targetInst) {\n if (\"input\" === domEventName || \"change\" === domEventName)\n return getInstIfValueChanged(targetInst);\n}\nfunction is(x, y) {\n return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);\n}\nvar objectIs = \"function\" === typeof Object.is ? Object.is : is;\nfunction shallowEqual(objA, objB) {\n if (objectIs(objA, objB)) return !0;\n if (\n \"object\" !== typeof objA ||\n null === objA ||\n \"object\" !== typeof objB ||\n null === objB\n )\n return !1;\n var keysA = Object.keys(objA),\n keysB = Object.keys(objB);\n if (keysA.length !== keysB.length) return !1;\n for (keysB = 0; keysB < keysA.length; keysB++) {\n var currentKey = keysA[keysB];\n if (\n !hasOwnProperty.call(objB, currentKey) ||\n !objectIs(objA[currentKey], objB[currentKey])\n )\n return !1;\n }\n return !0;\n}\nfunction getLeafNode(node) {\n for (; node && node.firstChild; ) node = node.firstChild;\n return node;\n}\nfunction getNodeForCharacterOffset(root, offset) {\n var node = getLeafNode(root);\n root = 0;\n for (var nodeEnd; node; ) {\n if (3 === node.nodeType) {\n nodeEnd = root + node.textContent.length;\n if (root <= offset && nodeEnd >= offset)\n return { node: node, offset: offset - root };\n root = nodeEnd;\n }\n a: {\n for (; node; ) {\n if (node.nextSibling) {\n node = node.nextSibling;\n break a;\n }\n node = node.parentNode;\n }\n node = void 0;\n }\n node = getLeafNode(node);\n }\n}\nfunction containsNode(outerNode, innerNode) {\n return outerNode && innerNode\n ? outerNode === innerNode\n ? !0\n : outerNode && 3 === outerNode.nodeType\n ? !1\n : innerNode && 3 === innerNode.nodeType\n ? containsNode(outerNode, innerNode.parentNode)\n : \"contains\" in outerNode\n ? outerNode.contains(innerNode)\n : outerNode.compareDocumentPosition\n ? !!(outerNode.compareDocumentPosition(innerNode) & 16)\n : !1\n : !1;\n}\nfunction getActiveElementDeep(containerInfo) {\n containerInfo =\n null != containerInfo &&\n null != containerInfo.ownerDocument &&\n null != containerInfo.ownerDocument.defaultView\n ? containerInfo.ownerDocument.defaultView\n : window;\n for (\n var element = getActiveElement(containerInfo.document);\n element instanceof containerInfo.HTMLIFrameElement;\n\n ) {\n try {\n var JSCompiler_inline_result =\n \"string\" === typeof element.contentWindow.location.href;\n } catch (err) {\n JSCompiler_inline_result = !1;\n }\n if (JSCompiler_inline_result) containerInfo = element.contentWindow;\n else break;\n element = getActiveElement(containerInfo.document);\n }\n return element;\n}\nfunction hasSelectionCapabilities(elem) {\n var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n return (\n nodeName &&\n ((\"input\" === nodeName &&\n (\"text\" === elem.type ||\n \"search\" === elem.type ||\n \"tel\" === elem.type ||\n \"url\" === elem.type ||\n \"password\" === elem.type)) ||\n \"textarea\" === nodeName ||\n \"true\" === elem.contentEditable)\n );\n}\nvar skipSelectionChangeEvent =\n canUseDOM && \"documentMode\" in document && 11 >= document.documentMode,\n activeElement = null,\n activeElementInst = null,\n lastSelection = null,\n mouseDown = !1;\nfunction constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {\n var doc =\n nativeEventTarget.window === nativeEventTarget\n ? nativeEventTarget.document\n : 9 === nativeEventTarget.nodeType\n ? nativeEventTarget\n : nativeEventTarget.ownerDocument;\n mouseDown ||\n null == activeElement ||\n activeElement !== getActiveElement(doc) ||\n ((doc = activeElement),\n \"selectionStart\" in doc && hasSelectionCapabilities(doc)\n ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })\n : ((doc = (\n (doc.ownerDocument && doc.ownerDocument.defaultView) ||\n window\n ).getSelection()),\n (doc = {\n anchorNode: doc.anchorNode,\n anchorOffset: doc.anchorOffset,\n focusNode: doc.focusNode,\n focusOffset: doc.focusOffset\n })),\n (lastSelection && shallowEqual(lastSelection, doc)) ||\n ((lastSelection = doc),\n (doc = accumulateTwoPhaseListeners(activeElementInst, \"onSelect\")),\n 0 < doc.length &&\n ((nativeEvent = new SyntheticEvent(\n \"onSelect\",\n \"select\",\n null,\n nativeEvent,\n nativeEventTarget\n )),\n dispatchQueue.push({ event: nativeEvent, listeners: doc }),\n (nativeEvent.target = activeElement))));\n}\nfunction makePrefixMap(styleProp, eventName) {\n var prefixes = {};\n prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();\n prefixes[\"Webkit\" + styleProp] = \"webkit\" + eventName;\n prefixes[\"Moz\" + styleProp] = \"moz\" + eventName;\n return prefixes;\n}\nvar vendorPrefixes = {\n animationend: makePrefixMap(\"Animation\", \"AnimationEnd\"),\n animationiteration: makePrefixMap(\"Animation\", \"AnimationIteration\"),\n animationstart: makePrefixMap(\"Animation\", \"AnimationStart\"),\n transitionrun: makePrefixMap(\"Transition\", \"TransitionRun\"),\n transitionstart: makePrefixMap(\"Transition\", \"TransitionStart\"),\n transitioncancel: makePrefixMap(\"Transition\", \"TransitionCancel\"),\n transitionend: makePrefixMap(\"Transition\", \"TransitionEnd\")\n },\n prefixedEventNames = {},\n style = {};\ncanUseDOM &&\n ((style = document.createElement(\"div\").style),\n \"AnimationEvent\" in window ||\n (delete vendorPrefixes.animationend.animation,\n delete vendorPrefixes.animationiteration.animation,\n delete vendorPrefixes.animationstart.animation),\n \"TransitionEvent\" in window ||\n delete vendorPrefixes.transitionend.transition);\nfunction getVendorPrefixedEventName(eventName) {\n if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];\n if (!vendorPrefixes[eventName]) return eventName;\n var prefixMap = vendorPrefixes[eventName],\n styleProp;\n for (styleProp in prefixMap)\n if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)\n return (prefixedEventNames[eventName] = prefixMap[styleProp]);\n return eventName;\n}\nvar ANIMATION_END = getVendorPrefixedEventName(\"animationend\"),\n ANIMATION_ITERATION = getVendorPrefixedEventName(\"animationiteration\"),\n ANIMATION_START = getVendorPrefixedEventName(\"animationstart\"),\n TRANSITION_RUN = getVendorPrefixedEventName(\"transitionrun\"),\n TRANSITION_START = getVendorPrefixedEventName(\"transitionstart\"),\n TRANSITION_CANCEL = getVendorPrefixedEventName(\"transitioncancel\"),\n TRANSITION_END = getVendorPrefixedEventName(\"transitionend\"),\n topLevelEventsToReactNames = new Map(),\n simpleEventPluginEvents =\n \"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(\n \" \"\n );\nsimpleEventPluginEvents.push(\"scrollEnd\");\nfunction registerSimpleEvent(domEventName, reactName) {\n topLevelEventsToReactNames.set(domEventName, reactName);\n registerTwoPhaseEvent(reactName, [domEventName]);\n}\nvar CapturedStacks = new WeakMap();\nfunction createCapturedValueAtFiber(value, source) {\n if (\"object\" === typeof value && null !== value) {\n var existing = CapturedStacks.get(value);\n if (void 0 !== existing) return existing;\n source = {\n value: value,\n source: source,\n stack: getStackByFiberInDevAndProd(source)\n };\n CapturedStacks.set(value, source);\n return source;\n }\n return {\n value: value,\n source: source,\n stack: getStackByFiberInDevAndProd(source)\n };\n}\nvar concurrentQueues = [],\n concurrentQueuesIndex = 0,\n concurrentlyUpdatedLanes = 0;\nfunction finishQueueingConcurrentUpdates() {\n for (\n var endIndex = concurrentQueuesIndex,\n i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);\n i < endIndex;\n\n ) {\n var fiber = concurrentQueues[i];\n concurrentQueues[i++] = null;\n var queue = concurrentQueues[i];\n concurrentQueues[i++] = null;\n var update = concurrentQueues[i];\n concurrentQueues[i++] = null;\n var lane = concurrentQueues[i];\n concurrentQueues[i++] = null;\n if (null !== queue && null !== update) {\n var pending = queue.pending;\n null === pending\n ? (update.next = update)\n : ((update.next = pending.next), (pending.next = update));\n queue.pending = update;\n }\n 0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);\n }\n}\nfunction enqueueUpdate$1(fiber, queue, update, lane) {\n concurrentQueues[concurrentQueuesIndex++] = fiber;\n concurrentQueues[concurrentQueuesIndex++] = queue;\n concurrentQueues[concurrentQueuesIndex++] = update;\n concurrentQueues[concurrentQueuesIndex++] = lane;\n concurrentlyUpdatedLanes |= lane;\n fiber.lanes |= lane;\n fiber = fiber.alternate;\n null !== fiber && (fiber.lanes |= lane);\n}\nfunction enqueueConcurrentHookUpdate(fiber, queue, update, lane) {\n enqueueUpdate$1(fiber, queue, update, lane);\n return getRootForUpdatedFiber(fiber);\n}\nfunction enqueueConcurrentRenderForLane(fiber, lane) {\n enqueueUpdate$1(fiber, null, null, lane);\n return getRootForUpdatedFiber(fiber);\n}\nfunction markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {\n sourceFiber.lanes |= lane;\n var alternate = sourceFiber.alternate;\n null !== alternate && (alternate.lanes |= lane);\n for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )\n (parent.childLanes |= lane),\n (alternate = parent.alternate),\n null !== alternate && (alternate.childLanes |= lane),\n 22 === parent.tag &&\n ((sourceFiber = parent.stateNode),\n null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),\n (sourceFiber = parent),\n (parent = parent.return);\n return 3 === sourceFiber.tag\n ? ((parent = sourceFiber.stateNode),\n isHidden &&\n null !== update &&\n ((isHidden = 31 - clz32(lane)),\n (sourceFiber = parent.hiddenUpdates),\n (alternate = sourceFiber[isHidden]),\n null === alternate\n ? (sourceFiber[isHidden] = [update])\n : alternate.push(update),\n (update.lane = lane | 536870912)),\n parent)\n : null;\n}\nfunction getRootForUpdatedFiber(sourceFiber) {\n if (50 < nestedUpdateCount)\n throw (\n ((nestedUpdateCount = 0),\n (rootWithNestedUpdates = null),\n Error(formatProdErrorMessage(185)))\n );\n for (var parent = sourceFiber.return; null !== parent; )\n (sourceFiber = parent), (parent = sourceFiber.return);\n return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;\n}\nvar emptyContextObject = {};\nfunction FiberNode(tag, pendingProps, key, mode) {\n this.tag = tag;\n this.key = key;\n this.sibling =\n this.child =\n this.return =\n this.stateNode =\n this.type =\n this.elementType =\n null;\n this.index = 0;\n this.refCleanup = this.ref = null;\n this.pendingProps = pendingProps;\n this.dependencies =\n this.memoizedState =\n this.updateQueue =\n this.memoizedProps =\n null;\n this.mode = mode;\n this.subtreeFlags = this.flags = 0;\n this.deletions = null;\n this.childLanes = this.lanes = 0;\n this.alternate = null;\n}\nfunction createFiberImplClass(tag, pendingProps, key, mode) {\n return new FiberNode(tag, pendingProps, key, mode);\n}\nfunction shouldConstruct(Component) {\n Component = Component.prototype;\n return !(!Component || !Component.isReactComponent);\n}\nfunction createWorkInProgress(current, pendingProps) {\n var workInProgress = current.alternate;\n null === workInProgress\n ? ((workInProgress = createFiberImplClass(\n current.tag,\n pendingProps,\n current.key,\n current.mode\n )),\n (workInProgress.elementType = current.elementType),\n (workInProgress.type = current.type),\n (workInProgress.stateNode = current.stateNode),\n (workInProgress.alternate = current),\n (current.alternate = workInProgress))\n : ((workInProgress.pendingProps = pendingProps),\n (workInProgress.type = current.type),\n (workInProgress.flags = 0),\n (workInProgress.subtreeFlags = 0),\n (workInProgress.deletions = null));\n workInProgress.flags = current.flags & 65011712;\n workInProgress.childLanes = current.childLanes;\n workInProgress.lanes = current.lanes;\n workInProgress.child = current.child;\n workInProgress.memoizedProps = current.memoizedProps;\n workInProgress.memoizedState = current.memoizedState;\n workInProgress.updateQueue = current.updateQueue;\n pendingProps = current.dependencies;\n workInProgress.dependencies =\n null === pendingProps\n ? null\n : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };\n workInProgress.sibling = current.sibling;\n workInProgress.index = current.index;\n workInProgress.ref = current.ref;\n workInProgress.refCleanup = current.refCleanup;\n return workInProgress;\n}\nfunction resetWorkInProgress(workInProgress, renderLanes) {\n workInProgress.flags &= 65011714;\n var current = workInProgress.alternate;\n null === current\n ? ((workInProgress.childLanes = 0),\n (workInProgress.lanes = renderLanes),\n (workInProgress.child = null),\n (workInProgress.subtreeFlags = 0),\n (workInProgress.memoizedProps = null),\n (workInProgress.memoizedState = null),\n (workInProgress.updateQueue = null),\n (workInProgress.dependencies = null),\n (workInProgress.stateNode = null))\n : ((workInProgress.childLanes = current.childLanes),\n (workInProgress.lanes = current.lanes),\n (workInProgress.child = current.child),\n (workInProgress.subtreeFlags = 0),\n (workInProgress.deletions = null),\n (workInProgress.memoizedProps = current.memoizedProps),\n (workInProgress.memoizedState = current.memoizedState),\n (workInProgress.updateQueue = current.updateQueue),\n (workInProgress.type = current.type),\n (renderLanes = current.dependencies),\n (workInProgress.dependencies =\n null === renderLanes\n ? null\n : {\n lanes: renderLanes.lanes,\n firstContext: renderLanes.firstContext\n }));\n return workInProgress;\n}\nfunction createFiberFromTypeAndProps(\n type,\n key,\n pendingProps,\n owner,\n mode,\n lanes\n) {\n var fiberTag = 0;\n owner = type;\n if (\"function\" === typeof type) shouldConstruct(type) && (fiberTag = 1);\n else if (\"string\" === typeof type)\n fiberTag = isHostHoistableType(\n type,\n pendingProps,\n contextStackCursor.current\n )\n ? 26\n : \"html\" === type || \"head\" === type || \"body\" === type\n ? 27\n : 5;\n else\n a: switch (type) {\n case REACT_ACTIVITY_TYPE:\n return (\n (type = createFiberImplClass(31, pendingProps, key, mode)),\n (type.elementType = REACT_ACTIVITY_TYPE),\n (type.lanes = lanes),\n type\n );\n case REACT_FRAGMENT_TYPE:\n return createFiberFromFragment(pendingProps.children, mode, lanes, key);\n case REACT_STRICT_MODE_TYPE:\n fiberTag = 8;\n mode |= 24;\n break;\n case REACT_PROFILER_TYPE:\n return (\n (type = createFiberImplClass(12, pendingProps, key, mode | 2)),\n (type.elementType = REACT_PROFILER_TYPE),\n (type.lanes = lanes),\n type\n );\n case REACT_SUSPENSE_TYPE:\n return (\n (type = createFiberImplClass(13, pendingProps, key, mode)),\n (type.elementType = REACT_SUSPENSE_TYPE),\n (type.lanes = lanes),\n type\n );\n case REACT_SUSPENSE_LIST_TYPE:\n return (\n (type = createFiberImplClass(19, pendingProps, key, mode)),\n (type.elementType = REACT_SUSPENSE_LIST_TYPE),\n (type.lanes = lanes),\n type\n );\n default:\n if (\"object\" === typeof type && null !== type)\n switch (type.$$typeof) {\n case REACT_PROVIDER_TYPE:\n case REACT_CONTEXT_TYPE:\n fiberTag = 10;\n break a;\n case REACT_CONSUMER_TYPE:\n fiberTag = 9;\n break a;\n case REACT_FORWARD_REF_TYPE:\n fiberTag = 11;\n break a;\n case REACT_MEMO_TYPE:\n fiberTag = 14;\n break a;\n case REACT_LAZY_TYPE:\n fiberTag = 16;\n owner = null;\n break a;\n }\n fiberTag = 29;\n pendingProps = Error(\n formatProdErrorMessage(130, null === type ? \"null\" : typeof type, \"\")\n );\n owner = null;\n }\n key = createFiberImplClass(fiberTag, pendingProps, key, mode);\n key.elementType = type;\n key.type = owner;\n key.lanes = lanes;\n return key;\n}\nfunction createFiberFromFragment(elements, mode, lanes, key) {\n elements = createFiberImplClass(7, elements, key, mode);\n elements.lanes = lanes;\n return elements;\n}\nfunction createFiberFromText(content, mode, lanes) {\n content = createFiberImplClass(6, content, null, mode);\n content.lanes = lanes;\n return content;\n}\nfunction createFiberFromPortal(portal, mode, lanes) {\n mode = createFiberImplClass(\n 4,\n null !== portal.children ? portal.children : [],\n portal.key,\n mode\n );\n mode.lanes = lanes;\n mode.stateNode = {\n containerInfo: portal.containerInfo,\n pendingChildren: null,\n implementation: portal.implementation\n };\n return mode;\n}\nvar forkStack = [],\n forkStackIndex = 0,\n treeForkProvider = null,\n treeForkCount = 0,\n idStack = [],\n idStackIndex = 0,\n treeContextProvider = null,\n treeContextId = 1,\n treeContextOverflow = \"\";\nfunction pushTreeFork(workInProgress, totalChildren) {\n forkStack[forkStackIndex++] = treeForkCount;\n forkStack[forkStackIndex++] = treeForkProvider;\n treeForkProvider = workInProgress;\n treeForkCount = totalChildren;\n}\nfunction pushTreeId(workInProgress, totalChildren, index) {\n idStack[idStackIndex++] = treeContextId;\n idStack[idStackIndex++] = treeContextOverflow;\n idStack[idStackIndex++] = treeContextProvider;\n treeContextProvider = workInProgress;\n var baseIdWithLeadingBit = treeContextId;\n workInProgress = treeContextOverflow;\n var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;\n baseIdWithLeadingBit &= ~(1 << baseLength);\n index += 1;\n var length = 32 - clz32(totalChildren) + baseLength;\n if (30 < length) {\n var numberOfOverflowBits = baseLength - (baseLength % 5);\n length = (\n baseIdWithLeadingBit &\n ((1 << numberOfOverflowBits) - 1)\n ).toString(32);\n baseIdWithLeadingBit >>= numberOfOverflowBits;\n baseLength -= numberOfOverflowBits;\n treeContextId =\n (1 << (32 - clz32(totalChildren) + baseLength)) |\n (index << baseLength) |\n baseIdWithLeadingBit;\n treeContextOverflow = length + workInProgress;\n } else\n (treeContextId =\n (1 << length) | (index << baseLength) | baseIdWithLeadingBit),\n (treeContextOverflow = workInProgress);\n}\nfunction pushMaterializedTreeId(workInProgress) {\n null !== workInProgress.return &&\n (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));\n}\nfunction popTreeContext(workInProgress) {\n for (; workInProgress === treeForkProvider; )\n (treeForkProvider = forkStack[--forkStackIndex]),\n (forkStack[forkStackIndex] = null),\n (treeForkCount = forkStack[--forkStackIndex]),\n (forkStack[forkStackIndex] = null);\n for (; workInProgress === treeContextProvider; )\n (treeContextProvider = idStack[--idStackIndex]),\n (idStack[idStackIndex] = null),\n (treeContextOverflow = idStack[--idStackIndex]),\n (idStack[idStackIndex] = null),\n (treeContextId = idStack[--idStackIndex]),\n (idStack[idStackIndex] = null);\n}\nvar hydrationParentFiber = null,\n nextHydratableInstance = null,\n isHydrating = !1,\n hydrationErrors = null,\n rootOrSingletonContext = !1,\n HydrationMismatchException = Error(formatProdErrorMessage(519));\nfunction throwOnHydrationMismatch(fiber) {\n var error = Error(formatProdErrorMessage(418, \"\"));\n queueHydrationError(createCapturedValueAtFiber(error, fiber));\n throw HydrationMismatchException;\n}\nfunction prepareToHydrateHostInstance(fiber) {\n var instance = fiber.stateNode,\n type = fiber.type,\n props = fiber.memoizedProps;\n instance[internalInstanceKey] = fiber;\n instance[internalPropsKey] = props;\n switch (type) {\n case \"dialog\":\n listenToNonDelegatedEvent(\"cancel\", instance);\n listenToNonDelegatedEvent(\"close\", instance);\n break;\n case \"iframe\":\n case \"object\":\n case \"embed\":\n listenToNonDelegatedEvent(\"load\", instance);\n break;\n case \"video\":\n case \"audio\":\n for (type = 0; type < mediaEventTypes.length; type++)\n listenToNonDelegatedEvent(mediaEventTypes[type], instance);\n break;\n case \"source\":\n listenToNonDelegatedEvent(\"error\", instance);\n break;\n case \"img\":\n case \"image\":\n case \"link\":\n listenToNonDelegatedEvent(\"error\", instance);\n listenToNonDelegatedEvent(\"load\", instance);\n break;\n case \"details\":\n listenToNonDelegatedEvent(\"toggle\", instance);\n break;\n case \"input\":\n listenToNonDelegatedEvent(\"invalid\", instance);\n initInput(\n instance,\n props.value,\n props.defaultValue,\n props.checked,\n props.defaultChecked,\n props.type,\n props.name,\n !0\n );\n track(instance);\n break;\n case \"select\":\n listenToNonDelegatedEvent(\"invalid\", instance);\n break;\n case \"textarea\":\n listenToNonDelegatedEvent(\"invalid\", instance),\n initTextarea(instance, props.value, props.defaultValue, props.children),\n track(instance);\n }\n type = props.children;\n (\"string\" !== typeof type &&\n \"number\" !== typeof type &&\n \"bigint\" !== typeof type) ||\n instance.textContent === \"\" + type ||\n !0 === props.suppressHydrationWarning ||\n checkForUnmatchedText(instance.textContent, type)\n ? (null != props.popover &&\n (listenToNonDelegatedEvent(\"beforetoggle\", instance),\n listenToNonDelegatedEvent(\"toggle\", instance)),\n null != props.onScroll && listenToNonDelegatedEvent(\"scroll\", instance),\n null != props.onScrollEnd &&\n listenToNonDelegatedEvent(\"scrollend\", instance),\n null != props.onClick && (instance.onclick = noop$1),\n (instance = !0))\n : (instance = !1);\n instance || throwOnHydrationMismatch(fiber);\n}\nfunction popToNextHostParent(fiber) {\n for (hydrationParentFiber = fiber.return; hydrationParentFiber; )\n switch (hydrationParentFiber.tag) {\n case 5:\n case 13:\n rootOrSingletonContext = !1;\n return;\n case 27:\n case 3:\n rootOrSingletonContext = !0;\n return;\n default:\n hydrationParentFiber = hydrationParentFiber.return;\n }\n}\nfunction popHydrationState(fiber) {\n if (fiber !== hydrationParentFiber) return !1;\n if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;\n var tag = fiber.tag,\n JSCompiler_temp;\n if ((JSCompiler_temp = 3 !== tag && 27 !== tag)) {\n if ((JSCompiler_temp = 5 === tag))\n (JSCompiler_temp = fiber.type),\n (JSCompiler_temp =\n !(\"form\" !== JSCompiler_temp && \"button\" !== JSCompiler_temp) ||\n shouldSetTextContent(fiber.type, fiber.memoizedProps));\n JSCompiler_temp = !JSCompiler_temp;\n }\n JSCompiler_temp && nextHydratableInstance && throwOnHydrationMismatch(fiber);\n popToNextHostParent(fiber);\n if (13 === tag) {\n fiber = fiber.memoizedState;\n fiber = null !== fiber ? fiber.dehydrated : null;\n if (!fiber) throw Error(formatProdErrorMessage(317));\n a: {\n fiber = fiber.nextSibling;\n for (tag = 0; fiber; ) {\n if (8 === fiber.nodeType)\n if (((JSCompiler_temp = fiber.data), \"/$\" === JSCompiler_temp)) {\n if (0 === tag) {\n nextHydratableInstance = getNextHydratable(fiber.nextSibling);\n break a;\n }\n tag--;\n } else\n (\"$\" !== JSCompiler_temp &&\n \"$!\" !== JSCompiler_temp &&\n \"$?\" !== JSCompiler_temp) ||\n tag++;\n fiber = fiber.nextSibling;\n }\n nextHydratableInstance = null;\n }\n } else\n 27 === tag\n ? ((tag = nextHydratableInstance),\n isSingletonScope(fiber.type)\n ? ((fiber = previousHydratableOnEnteringScopedSingleton),\n (previousHydratableOnEnteringScopedSingleton = null),\n (nextHydratableInstance = fiber))\n : (nextHydratableInstance = tag))\n : (nextHydratableInstance = hydrationParentFiber\n ? getNextHydratable(fiber.stateNode.nextSibling)\n : null);\n return !0;\n}\nfunction resetHydrationState() {\n nextHydratableInstance = hydrationParentFiber = null;\n isHydrating = !1;\n}\nfunction upgradeHydrationErrorsToRecoverable() {\n var queuedErrors = hydrationErrors;\n null !== queuedErrors &&\n (null === workInProgressRootRecoverableErrors\n ? (workInProgressRootRecoverableErrors = queuedErrors)\n : workInProgressRootRecoverableErrors.push.apply(\n workInProgressRootRecoverableErrors,\n queuedErrors\n ),\n (hydrationErrors = null));\n return queuedErrors;\n}\nfunction queueHydrationError(error) {\n null === hydrationErrors\n ? (hydrationErrors = [error])\n : hydrationErrors.push(error);\n}\nvar valueCursor = createCursor(null),\n currentlyRenderingFiber$1 = null,\n lastContextDependency = null;\nfunction pushProvider(providerFiber, context, nextValue) {\n push(valueCursor, context._currentValue);\n context._currentValue = nextValue;\n}\nfunction popProvider(context) {\n context._currentValue = valueCursor.current;\n pop(valueCursor);\n}\nfunction scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {\n for (; null !== parent; ) {\n var alternate = parent.alternate;\n (parent.childLanes & renderLanes) !== renderLanes\n ? ((parent.childLanes |= renderLanes),\n null !== alternate && (alternate.childLanes |= renderLanes))\n : null !== alternate &&\n (alternate.childLanes & renderLanes) !== renderLanes &&\n (alternate.childLanes |= renderLanes);\n if (parent === propagationRoot) break;\n parent = parent.return;\n }\n}\nfunction propagateContextChanges(\n workInProgress,\n contexts,\n renderLanes,\n forcePropagateEntireTree\n) {\n var fiber = workInProgress.child;\n null !== fiber && (fiber.return = workInProgress);\n for (; null !== fiber; ) {\n var list = fiber.dependencies;\n if (null !== list) {\n var nextFiber = fiber.child;\n list = list.firstContext;\n a: for (; null !== list; ) {\n var dependency = list;\n list = fiber;\n for (var i = 0; i < contexts.length; i++)\n if (dependency.context === contexts[i]) {\n list.lanes |= renderLanes;\n dependency = list.alternate;\n null !== dependency && (dependency.lanes |= renderLanes);\n scheduleContextWorkOnParentPath(\n list.return,\n renderLanes,\n workInProgress\n );\n forcePropagateEntireTree || (nextFiber = null);\n break a;\n }\n list = dependency.next;\n }\n } else if (18 === fiber.tag) {\n nextFiber = fiber.return;\n if (null === nextFiber) throw Error(formatProdErrorMessage(341));\n nextFiber.lanes |= renderLanes;\n list = nextFiber.alternate;\n null !== list && (list.lanes |= renderLanes);\n scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);\n nextFiber = null;\n } else nextFiber = fiber.child;\n if (null !== nextFiber) nextFiber.return = fiber;\n else\n for (nextFiber = fiber; null !== nextFiber; ) {\n if (nextFiber === workInProgress) {\n nextFiber = null;\n break;\n }\n fiber = nextFiber.sibling;\n if (null !== fiber) {\n fiber.return = nextFiber.return;\n nextFiber = fiber;\n break;\n }\n nextFiber = nextFiber.return;\n }\n fiber = nextFiber;\n }\n}\nfunction propagateParentContextChanges(\n current,\n workInProgress,\n renderLanes,\n forcePropagateEntireTree\n) {\n current = null;\n for (\n var parent = workInProgress, isInsidePropagationBailout = !1;\n null !== parent;\n\n ) {\n if (!isInsidePropagationBailout)\n if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;\n else if (0 !== (parent.flags & 262144)) break;\n if (10 === parent.tag) {\n var currentParent = parent.alternate;\n if (null === currentParent) throw Error(formatProdErrorMessage(387));\n currentParent = currentParent.memoizedProps;\n if (null !== currentParent) {\n var context = parent.type;\n objectIs(parent.pendingProps.value, currentParent.value) ||\n (null !== current ? current.push(context) : (current = [context]));\n }\n } else if (parent === hostTransitionProviderCursor.current) {\n currentParent = parent.alternate;\n if (null === currentParent) throw Error(formatProdErrorMessage(387));\n currentParent.memoizedState.memoizedState !==\n parent.memoizedState.memoizedState &&\n (null !== current\n ? current.push(HostTransitionContext)\n : (current = [HostTransitionContext]));\n }\n parent = parent.return;\n }\n null !== current &&\n propagateContextChanges(\n workInProgress,\n current,\n renderLanes,\n forcePropagateEntireTree\n );\n workInProgress.flags |= 262144;\n}\nfunction checkIfContextChanged(currentDependencies) {\n for (\n currentDependencies = currentDependencies.firstContext;\n null !== currentDependencies;\n\n ) {\n if (\n !objectIs(\n currentDependencies.context._currentValue,\n currentDependencies.memoizedValue\n )\n )\n return !0;\n currentDependencies = currentDependencies.next;\n }\n return !1;\n}\nfunction prepareToReadContext(workInProgress) {\n currentlyRenderingFiber$1 = workInProgress;\n lastContextDependency = null;\n workInProgress = workInProgress.dependencies;\n null !== workInProgress && (workInProgress.firstContext = null);\n}\nfunction readContext(context) {\n return readContextForConsumer(currentlyRenderingFiber$1, context);\n}\nfunction readContextDuringReconciliation(consumer, context) {\n null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);\n return readContextForConsumer(consumer, context);\n}\nfunction readContextForConsumer(consumer, context) {\n var value = context._currentValue;\n context = { context: context, memoizedValue: value, next: null };\n if (null === lastContextDependency) {\n if (null === consumer) throw Error(formatProdErrorMessage(308));\n lastContextDependency = context;\n consumer.dependencies = { lanes: 0, firstContext: context };\n consumer.flags |= 524288;\n } else lastContextDependency = lastContextDependency.next = context;\n return value;\n}\nvar AbortControllerLocal =\n \"undefined\" !== typeof AbortController\n ? AbortController\n : function () {\n var listeners = [],\n signal = (this.signal = {\n aborted: !1,\n addEventListener: function (type, listener) {\n listeners.push(listener);\n }\n });\n this.abort = function () {\n signal.aborted = !0;\n listeners.forEach(function (listener) {\n return listener();\n });\n };\n },\n scheduleCallback$2 = Scheduler.unstable_scheduleCallback,\n NormalPriority = Scheduler.unstable_NormalPriority,\n CacheContext = {\n $$typeof: REACT_CONTEXT_TYPE,\n Consumer: null,\n Provider: null,\n _currentValue: null,\n _currentValue2: null,\n _threadCount: 0\n };\nfunction createCache() {\n return {\n controller: new AbortControllerLocal(),\n data: new Map(),\n refCount: 0\n };\n}\nfunction releaseCache(cache) {\n cache.refCount--;\n 0 === cache.refCount &&\n scheduleCallback$2(NormalPriority, function () {\n cache.controller.abort();\n });\n}\nvar currentEntangledListeners = null,\n currentEntangledPendingCount = 0,\n currentEntangledLane = 0,\n currentEntangledActionThenable = null;\nfunction entangleAsyncAction(transition, thenable) {\n if (null === currentEntangledListeners) {\n var entangledListeners = (currentEntangledListeners = []);\n currentEntangledPendingCount = 0;\n currentEntangledLane = requestTransitionLane();\n currentEntangledActionThenable = {\n status: \"pending\",\n value: void 0,\n then: function (resolve) {\n entangledListeners.push(resolve);\n }\n };\n }\n currentEntangledPendingCount++;\n thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);\n return thenable;\n}\nfunction pingEngtangledActionScope() {\n if (\n 0 === --currentEntangledPendingCount &&\n null !== currentEntangledListeners\n ) {\n null !== currentEntangledActionThenable &&\n (currentEntangledActionThenable.status = \"fulfilled\");\n var listeners = currentEntangledListeners;\n currentEntangledListeners = null;\n currentEntangledLane = 0;\n currentEntangledActionThenable = null;\n for (var i = 0; i < listeners.length; i++) (0, listeners[i])();\n }\n}\nfunction chainThenableValue(thenable, result) {\n var listeners = [],\n thenableWithOverride = {\n status: \"pending\",\n value: null,\n reason: null,\n then: function (resolve) {\n listeners.push(resolve);\n }\n };\n thenable.then(\n function () {\n thenableWithOverride.status = \"fulfilled\";\n thenableWithOverride.value = result;\n for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);\n },\n function (error) {\n thenableWithOverride.status = \"rejected\";\n thenableWithOverride.reason = error;\n for (error = 0; error < listeners.length; error++)\n (0, listeners[error])(void 0);\n }\n );\n return thenableWithOverride;\n}\nvar prevOnStartTransitionFinish = ReactSharedInternals.S;\nReactSharedInternals.S = function (transition, returnValue) {\n \"object\" === typeof returnValue &&\n null !== returnValue &&\n \"function\" === typeof returnValue.then &&\n entangleAsyncAction(transition, returnValue);\n null !== prevOnStartTransitionFinish &&\n prevOnStartTransitionFinish(transition, returnValue);\n};\nvar resumedCache = createCursor(null);\nfunction peekCacheFromPool() {\n var cacheResumedFromPreviousRender = resumedCache.current;\n return null !== cacheResumedFromPreviousRender\n ? cacheResumedFromPreviousRender\n : workInProgressRoot.pooledCache;\n}\nfunction pushTransition(offscreenWorkInProgress, prevCachePool) {\n null === prevCachePool\n ? push(resumedCache, resumedCache.current)\n : push(resumedCache, prevCachePool.pool);\n}\nfunction getSuspendedCache() {\n var cacheFromPool = peekCacheFromPool();\n return null === cacheFromPool\n ? null\n : { parent: CacheContext._currentValue, pool: cacheFromPool };\n}\nvar SuspenseException = Error(formatProdErrorMessage(460)),\n SuspenseyCommitException = Error(formatProdErrorMessage(474)),\n SuspenseActionException = Error(formatProdErrorMessage(542)),\n noopSuspenseyCommitThenable = { then: function () {} };\nfunction isThenableResolved(thenable) {\n thenable = thenable.status;\n return \"fulfilled\" === thenable || \"rejected\" === thenable;\n}\nfunction noop$3() {}\nfunction trackUsedThenable(thenableState, thenable, index) {\n index = thenableState[index];\n void 0 === index\n ? thenableState.push(thenable)\n : index !== thenable && (thenable.then(noop$3, noop$3), (thenable = index));\n switch (thenable.status) {\n case \"fulfilled\":\n return thenable.value;\n case \"rejected\":\n throw (\n ((thenableState = thenable.reason),\n checkIfUseWrappedInAsyncCatch(thenableState),\n thenableState)\n );\n default:\n if (\"string\" === typeof thenable.status) thenable.then(noop$3, noop$3);\n else {\n thenableState = workInProgressRoot;\n if (null !== thenableState && 100 < thenableState.shellSuspendCounter)\n throw Error(formatProdErrorMessage(482));\n thenableState = thenable;\n thenableState.status = \"pending\";\n thenableState.then(\n function (fulfilledValue) {\n if (\"pending\" === thenable.status) {\n var fulfilledThenable = thenable;\n fulfilledThenable.status = \"fulfilled\";\n fulfilledThenable.value = fulfilledValue;\n }\n },\n function (error) {\n if (\"pending\" === thenable.status) {\n var rejectedThenable = thenable;\n rejectedThenable.status = \"rejected\";\n rejectedThenable.reason = error;\n }\n }\n );\n }\n switch (thenable.status) {\n case \"fulfilled\":\n return thenable.value;\n case \"rejected\":\n throw (\n ((thenableState = thenable.reason),\n checkIfUseWrappedInAsyncCatch(thenableState),\n thenableState)\n );\n }\n suspendedThenable = thenable;\n throw SuspenseException;\n }\n}\nvar suspendedThenable = null;\nfunction getSuspendedThenable() {\n if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));\n var thenable = suspendedThenable;\n suspendedThenable = null;\n return thenable;\n}\nfunction checkIfUseWrappedInAsyncCatch(rejectedReason) {\n if (\n rejectedReason === SuspenseException ||\n rejectedReason === SuspenseActionException\n )\n throw Error(formatProdErrorMessage(483));\n}\nvar hasForceUpdate = !1;\nfunction initializeUpdateQueue(fiber) {\n fiber.updateQueue = {\n baseState: fiber.memoizedState,\n firstBaseUpdate: null,\n lastBaseUpdate: null,\n shared: { pending: null, lanes: 0, hiddenCallbacks: null },\n callbacks: null\n };\n}\nfunction cloneUpdateQueue(current, workInProgress) {\n current = current.updateQueue;\n workInProgress.updateQueue === current &&\n (workInProgress.updateQueue = {\n baseState: current.baseState,\n firstBaseUpdate: current.firstBaseUpdate,\n lastBaseUpdate: current.lastBaseUpdate,\n shared: current.shared,\n callbacks: null\n });\n}\nfunction createUpdate(lane) {\n return { lane: lane, tag: 0, payload: null, callback: null, next: null };\n}\nfunction enqueueUpdate(fiber, update, lane) {\n var updateQueue = fiber.updateQueue;\n if (null === updateQueue) return null;\n updateQueue = updateQueue.shared;\n if (0 !== (executionContext & 2)) {\n var pending = updateQueue.pending;\n null === pending\n ? (update.next = update)\n : ((update.next = pending.next), (pending.next = update));\n updateQueue.pending = update;\n update = getRootForUpdatedFiber(fiber);\n markUpdateLaneFromFiberToRoot(fiber, null, lane);\n return update;\n }\n enqueueUpdate$1(fiber, updateQueue, update, lane);\n return getRootForUpdatedFiber(fiber);\n}\nfunction entangleTransitions(root, fiber, lane) {\n fiber = fiber.updateQueue;\n if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 4194048))) {\n var queueLanes = fiber.lanes;\n queueLanes &= root.pendingLanes;\n lane |= queueLanes;\n fiber.lanes = lane;\n markRootEntangled(root, lane);\n }\n}\nfunction enqueueCapturedUpdate(workInProgress, capturedUpdate) {\n var queue = workInProgress.updateQueue,\n current = workInProgress.alternate;\n if (\n null !== current &&\n ((current = current.updateQueue), queue === current)\n ) {\n var newFirst = null,\n newLast = null;\n queue = queue.firstBaseUpdate;\n if (null !== queue) {\n do {\n var clone = {\n lane: queue.lane,\n tag: queue.tag,\n payload: queue.payload,\n callback: null,\n next: null\n };\n null === newLast\n ? (newFirst = newLast = clone)\n : (newLast = newLast.next = clone);\n queue = queue.next;\n } while (null !== queue);\n null === newLast\n ? (newFirst = newLast = capturedUpdate)\n : (newLast = newLast.next = capturedUpdate);\n } else newFirst = newLast = capturedUpdate;\n queue = {\n baseState: current.baseState,\n firstBaseUpdate: newFirst,\n lastBaseUpdate: newLast,\n shared: current.shared,\n callbacks: current.callbacks\n };\n workInProgress.updateQueue = queue;\n return;\n }\n workInProgress = queue.lastBaseUpdate;\n null === workInProgress\n ? (queue.firstBaseUpdate = capturedUpdate)\n : (workInProgress.next = capturedUpdate);\n queue.lastBaseUpdate = capturedUpdate;\n}\nvar didReadFromEntangledAsyncAction = !1;\nfunction suspendIfUpdateReadFromEntangledAsyncAction() {\n if (didReadFromEntangledAsyncAction) {\n var entangledActionThenable = currentEntangledActionThenable;\n if (null !== entangledActionThenable) throw entangledActionThenable;\n }\n}\nfunction processUpdateQueue(\n workInProgress$jscomp$0,\n props,\n instance$jscomp$0,\n renderLanes\n) {\n didReadFromEntangledAsyncAction = !1;\n var queue = workInProgress$jscomp$0.updateQueue;\n hasForceUpdate = !1;\n var firstBaseUpdate = queue.firstBaseUpdate,\n lastBaseUpdate = queue.lastBaseUpdate,\n pendingQueue = queue.shared.pending;\n if (null !== pendingQueue) {\n queue.shared.pending = null;\n var lastPendingUpdate = pendingQueue,\n firstPendingUpdate = lastPendingUpdate.next;\n lastPendingUpdate.next = null;\n null === lastBaseUpdate\n ? (firstBaseUpdate = firstPendingUpdate)\n : (lastBaseUpdate.next = firstPendingUpdate);\n lastBaseUpdate = lastPendingUpdate;\n var current = workInProgress$jscomp$0.alternate;\n null !== current &&\n ((current = current.updateQueue),\n (pendingQueue = current.lastBaseUpdate),\n pendingQueue !== lastBaseUpdate &&\n (null === pendingQueue\n ? (current.firstBaseUpdate = firstPendingUpdate)\n : (pendingQueue.next = firstPendingUpdate),\n (current.lastBaseUpdate = lastPendingUpdate)));\n }\n if (null !== firstBaseUpdate) {\n var newState = queue.baseState;\n lastBaseUpdate = 0;\n current = firstPendingUpdate = lastPendingUpdate = null;\n pendingQueue = firstBaseUpdate;\n do {\n var updateLane = pendingQueue.lane & -536870913,\n isHiddenUpdate = updateLane !== pendingQueue.lane;\n if (\n isHiddenUpdate\n ? (workInProgressRootRenderLanes & updateLane) === updateLane\n : (renderLanes & updateLane) === updateLane\n ) {\n 0 !== updateLane &&\n updateLane === currentEntangledLane &&\n (didReadFromEntangledAsyncAction = !0);\n null !== current &&\n (current = current.next =\n {\n lane: 0,\n tag: pendingQueue.tag,\n payload: pendingQueue.payload,\n callback: null,\n next: null\n });\n a: {\n var workInProgress = workInProgress$jscomp$0,\n update = pendingQueue;\n updateLane = props;\n var instance = instance$jscomp$0;\n switch (update.tag) {\n case 1:\n workInProgress = update.payload;\n if (\"function\" === typeof workInProgress) {\n newState = workInProgress.call(instance, newState, updateLane);\n break a;\n }\n newState = workInProgress;\n break a;\n case 3:\n workInProgress.flags = (workInProgress.flags & -65537) | 128;\n case 0:\n workInProgress = update.payload;\n updateLane =\n \"function\" === typeof workInProgress\n ? workInProgress.call(instance, newState, updateLane)\n : workInProgress;\n if (null === updateLane || void 0 === updateLane) break a;\n newState = assign({}, newState, updateLane);\n break a;\n case 2:\n hasForceUpdate = !0;\n }\n }\n updateLane = pendingQueue.callback;\n null !== updateLane &&\n ((workInProgress$jscomp$0.flags |= 64),\n isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),\n (isHiddenUpdate = queue.callbacks),\n null === isHiddenUpdate\n ? (queue.callbacks = [updateLane])\n : isHiddenUpdate.push(updateLane));\n } else\n (isHiddenUpdate = {\n lane: updateLane,\n tag: pendingQueue.tag,\n payload: pendingQueue.payload,\n callback: pendingQueue.callback,\n next: null\n }),\n null === current\n ? ((firstPendingUpdate = current = isHiddenUpdate),\n (lastPendingUpdate = newState))\n : (current = current.next = isHiddenUpdate),\n (lastBaseUpdate |= updateLane);\n pendingQueue = pendingQueue.next;\n if (null === pendingQueue)\n if (((pendingQueue = queue.shared.pending), null === pendingQueue))\n break;\n else\n (isHiddenUpdate = pendingQueue),\n (pendingQueue = isHiddenUpdate.next),\n (isHiddenUpdate.next = null),\n (queue.lastBaseUpdate = isHiddenUpdate),\n (queue.shared.pending = null);\n } while (1);\n null === current && (lastPendingUpdate = newState);\n queue.baseState = lastPendingUpdate;\n queue.firstBaseUpdate = firstPendingUpdate;\n queue.lastBaseUpdate = current;\n null === firstBaseUpdate && (queue.shared.lanes = 0);\n workInProgressRootSkippedLanes |= lastBaseUpdate;\n workInProgress$jscomp$0.lanes = lastBaseUpdate;\n workInProgress$jscomp$0.memoizedState = newState;\n }\n}\nfunction callCallback(callback, context) {\n if (\"function\" !== typeof callback)\n throw Error(formatProdErrorMessage(191, callback));\n callback.call(context);\n}\nfunction commitCallbacks(updateQueue, context) {\n var callbacks = updateQueue.callbacks;\n if (null !== callbacks)\n for (\n updateQueue.callbacks = null, updateQueue = 0;\n updateQueue < callbacks.length;\n updateQueue++\n )\n callCallback(callbacks[updateQueue], context);\n}\nvar currentTreeHiddenStackCursor = createCursor(null),\n prevEntangledRenderLanesCursor = createCursor(0);\nfunction pushHiddenContext(fiber, context) {\n fiber = entangledRenderLanes;\n push(prevEntangledRenderLanesCursor, fiber);\n push(currentTreeHiddenStackCursor, context);\n entangledRenderLanes = fiber | context.baseLanes;\n}\nfunction reuseHiddenContextOnStack() {\n push(prevEntangledRenderLanesCursor, entangledRenderLanes);\n push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);\n}\nfunction popHiddenContext() {\n entangledRenderLanes = prevEntangledRenderLanesCursor.current;\n pop(currentTreeHiddenStackCursor);\n pop(prevEntangledRenderLanesCursor);\n}\nvar renderLanes = 0,\n currentlyRenderingFiber = null,\n currentHook = null,\n workInProgressHook = null,\n didScheduleRenderPhaseUpdate = !1,\n didScheduleRenderPhaseUpdateDuringThisPass = !1,\n shouldDoubleInvokeUserFnsInHooksDEV = !1,\n localIdCounter = 0,\n thenableIndexCounter$1 = 0,\n thenableState$1 = null,\n globalClientIdCounter = 0;\nfunction throwInvalidHookError() {\n throw Error(formatProdErrorMessage(321));\n}\nfunction areHookInputsEqual(nextDeps, prevDeps) {\n if (null === prevDeps) return !1;\n for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)\n if (!objectIs(nextDeps[i], prevDeps[i])) return !1;\n return !0;\n}\nfunction renderWithHooks(\n current,\n workInProgress,\n Component,\n props,\n secondArg,\n nextRenderLanes\n) {\n renderLanes = nextRenderLanes;\n currentlyRenderingFiber = workInProgress;\n workInProgress.memoizedState = null;\n workInProgress.updateQueue = null;\n workInProgress.lanes = 0;\n ReactSharedInternals.H =\n null === current || null === current.memoizedState\n ? HooksDispatcherOnMount\n : HooksDispatcherOnUpdate;\n shouldDoubleInvokeUserFnsInHooksDEV = !1;\n nextRenderLanes = Component(props, secondArg);\n shouldDoubleInvokeUserFnsInHooksDEV = !1;\n didScheduleRenderPhaseUpdateDuringThisPass &&\n (nextRenderLanes = renderWithHooksAgain(\n workInProgress,\n Component,\n props,\n secondArg\n ));\n finishRenderingHooks(current);\n return nextRenderLanes;\n}\nfunction finishRenderingHooks(current) {\n ReactSharedInternals.H = ContextOnlyDispatcher;\n var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;\n renderLanes = 0;\n workInProgressHook = currentHook = currentlyRenderingFiber = null;\n didScheduleRenderPhaseUpdate = !1;\n thenableIndexCounter$1 = 0;\n thenableState$1 = null;\n if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));\n null === current ||\n didReceiveUpdate ||\n ((current = current.dependencies),\n null !== current &&\n checkIfContextChanged(current) &&\n (didReceiveUpdate = !0));\n}\nfunction renderWithHooksAgain(workInProgress, Component, props, secondArg) {\n currentlyRenderingFiber = workInProgress;\n var numberOfReRenders = 0;\n do {\n didScheduleRenderPhaseUpdateDuringThisPass && (thenableState$1 = null);\n thenableIndexCounter$1 = 0;\n didScheduleRenderPhaseUpdateDuringThisPass = !1;\n if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));\n numberOfReRenders += 1;\n workInProgressHook = currentHook = null;\n if (null != workInProgress.updateQueue) {\n var children = workInProgress.updateQueue;\n children.lastEffect = null;\n children.events = null;\n children.stores = null;\n null != children.memoCache && (children.memoCache.index = 0);\n }\n ReactSharedInternals.H = HooksDispatcherOnRerender;\n children = Component(props, secondArg);\n } while (didScheduleRenderPhaseUpdateDuringThisPass);\n return children;\n}\nfunction TransitionAwareHostComponent() {\n var dispatcher = ReactSharedInternals.H,\n maybeThenable = dispatcher.useState()[0];\n maybeThenable =\n \"function\" === typeof maybeThenable.then\n ? useThenable(maybeThenable)\n : maybeThenable;\n dispatcher = dispatcher.useState()[0];\n (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher &&\n (currentlyRenderingFiber.flags |= 1024);\n return maybeThenable;\n}\nfunction checkDidRenderIdHook() {\n var didRenderIdHook = 0 !== localIdCounter;\n localIdCounter = 0;\n return didRenderIdHook;\n}\nfunction bailoutHooks(current, workInProgress, lanes) {\n workInProgress.updateQueue = current.updateQueue;\n workInProgress.flags &= -2053;\n current.lanes &= ~lanes;\n}\nfunction resetHooksOnUnwind(workInProgress) {\n if (didScheduleRenderPhaseUpdate) {\n for (\n workInProgress = workInProgress.memoizedState;\n null !== workInProgress;\n\n ) {\n var queue = workInProgress.queue;\n null !== queue && (queue.pending = null);\n workInProgress = workInProgress.next;\n }\n didScheduleRenderPhaseUpdate = !1;\n }\n renderLanes = 0;\n workInProgressHook = currentHook = currentlyRenderingFiber = null;\n didScheduleRenderPhaseUpdateDuringThisPass = !1;\n thenableIndexCounter$1 = localIdCounter = 0;\n thenableState$1 = null;\n}\nfunction mountWorkInProgressHook() {\n var hook = {\n memoizedState: null,\n baseState: null,\n baseQueue: null,\n queue: null,\n next: null\n };\n null === workInProgressHook\n ? (currentlyRenderingFiber.memoizedState = workInProgressHook = hook)\n : (workInProgressHook = workInProgressHook.next = hook);\n return workInProgressHook;\n}\nfunction updateWorkInProgressHook() {\n if (null === currentHook) {\n var nextCurrentHook = currentlyRenderingFiber.alternate;\n nextCurrentHook =\n null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;\n } else nextCurrentHook = currentHook.next;\n var nextWorkInProgressHook =\n null === workInProgressHook\n ? currentlyRenderingFiber.memoizedState\n : workInProgressHook.next;\n if (null !== nextWorkInProgressHook)\n (workInProgressHook = nextWorkInProgressHook),\n (currentHook = nextCurrentHook);\n else {\n if (null === nextCurrentHook) {\n if (null === currentlyRenderingFiber.alternate)\n throw Error(formatProdErrorMessage(467));\n throw Error(formatProdErrorMessage(310));\n }\n currentHook = nextCurrentHook;\n nextCurrentHook = {\n memoizedState: currentHook.memoizedState,\n baseState: currentHook.baseState,\n baseQueue: currentHook.baseQueue,\n queue: currentHook.queue,\n next: null\n };\n null === workInProgressHook\n ? (currentlyRenderingFiber.memoizedState = workInProgressHook =\n nextCurrentHook)\n : (workInProgressHook = workInProgressHook.next = nextCurrentHook);\n }\n return workInProgressHook;\n}\nfunction createFunctionComponentUpdateQueue() {\n return { lastEffect: null, events: null, stores: null, memoCache: null };\n}\nfunction useThenable(thenable) {\n var index = thenableIndexCounter$1;\n thenableIndexCounter$1 += 1;\n null === thenableState$1 && (thenableState$1 = []);\n thenable = trackUsedThenable(thenableState$1, thenable, index);\n index = currentlyRenderingFiber;\n null ===\n (null === workInProgressHook\n ? index.memoizedState\n : workInProgressHook.next) &&\n ((index = index.alternate),\n (ReactSharedInternals.H =\n null === index || null === index.memoizedState\n ? HooksDispatcherOnMount\n : HooksDispatcherOnUpdate));\n return thenable;\n}\nfunction use(usable) {\n if (null !== usable && \"object\" === typeof usable) {\n if (\"function\" === typeof usable.then) return useThenable(usable);\n if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);\n }\n throw Error(formatProdErrorMessage(438, String(usable)));\n}\nfunction useMemoCache(size) {\n var memoCache = null,\n updateQueue = currentlyRenderingFiber.updateQueue;\n null !== updateQueue && (memoCache = updateQueue.memoCache);\n if (null == memoCache) {\n var current = currentlyRenderingFiber.alternate;\n null !== current &&\n ((current = current.updateQueue),\n null !== current &&\n ((current = current.memoCache),\n null != current &&\n (memoCache = {\n data: current.data.map(function (array) {\n return array.slice();\n }),\n index: 0\n })));\n }\n null == memoCache && (memoCache = { data: [], index: 0 });\n null === updateQueue &&\n ((updateQueue = createFunctionComponentUpdateQueue()),\n (currentlyRenderingFiber.updateQueue = updateQueue));\n updateQueue.memoCache = memoCache;\n updateQueue = memoCache.data[memoCache.index];\n if (void 0 === updateQueue)\n for (\n updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;\n current < size;\n current++\n )\n updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;\n memoCache.index++;\n return updateQueue;\n}\nfunction basicStateReducer(state, action) {\n return \"function\" === typeof action ? action(state) : action;\n}\nfunction updateReducer(reducer) {\n var hook = updateWorkInProgressHook();\n return updateReducerImpl(hook, currentHook, reducer);\n}\nfunction updateReducerImpl(hook, current, reducer) {\n var queue = hook.queue;\n if (null === queue) throw Error(formatProdErrorMessage(311));\n queue.lastRenderedReducer = reducer;\n var baseQueue = hook.baseQueue,\n pendingQueue = queue.pending;\n if (null !== pendingQueue) {\n if (null !== baseQueue) {\n var baseFirst = baseQueue.next;\n baseQueue.next = pendingQueue.next;\n pendingQueue.next = baseFirst;\n }\n current.baseQueue = baseQueue = pendingQueue;\n queue.pending = null;\n }\n pendingQueue = hook.baseState;\n if (null === baseQueue) hook.memoizedState = pendingQueue;\n else {\n current = baseQueue.next;\n var newBaseQueueFirst = (baseFirst = null),\n newBaseQueueLast = null,\n update = current,\n didReadFromEntangledAsyncAction$32 = !1;\n do {\n var updateLane = update.lane & -536870913;\n if (\n updateLane !== update.lane\n ? (workInProgressRootRenderLanes & updateLane) === updateLane\n : (renderLanes & updateLane) === updateLane\n ) {\n var revertLane = update.revertLane;\n if (0 === revertLane)\n null !== newBaseQueueLast &&\n (newBaseQueueLast = newBaseQueueLast.next =\n {\n lane: 0,\n revertLane: 0,\n action: update.action,\n hasEagerState: update.hasEagerState,\n eagerState: update.eagerState,\n next: null\n }),\n updateLane === currentEntangledLane &&\n (didReadFromEntangledAsyncAction$32 = !0);\n else if ((renderLanes & revertLane) === revertLane) {\n update = update.next;\n revertLane === currentEntangledLane &&\n (didReadFromEntangledAsyncAction$32 = !0);\n continue;\n } else\n (updateLane = {\n lane: 0,\n revertLane: update.revertLane,\n action: update.action,\n hasEagerState: update.hasEagerState,\n eagerState: update.eagerState,\n next: null\n }),\n null === newBaseQueueLast\n ? ((newBaseQueueFirst = newBaseQueueLast = updateLane),\n (baseFirst = pendingQueue))\n : (newBaseQueueLast = newBaseQueueLast.next = updateLane),\n (currentlyRenderingFiber.lanes |= revertLane),\n (workInProgressRootSkippedLanes |= revertLane);\n updateLane = update.action;\n shouldDoubleInvokeUserFnsInHooksDEV &&\n reducer(pendingQueue, updateLane);\n pendingQueue = update.hasEagerState\n ? update.eagerState\n : reducer(pendingQueue, updateLane);\n } else\n (revertLane = {\n lane: updateLane,\n revertLane: update.revertLane,\n action: update.action,\n hasEagerState: update.hasEagerState,\n eagerState: update.eagerState,\n next: null\n }),\n null === newBaseQueueLast\n ? ((newBaseQueueFirst = newBaseQueueLast = revertLane),\n (baseFirst = pendingQueue))\n : (newBaseQueueLast = newBaseQueueLast.next = revertLane),\n (currentlyRenderingFiber.lanes |= updateLane),\n (workInProgressRootSkippedLanes |= updateLane);\n update = update.next;\n } while (null !== update && update !== current);\n null === newBaseQueueLast\n ? (baseFirst = pendingQueue)\n : (newBaseQueueLast.next = newBaseQueueFirst);\n if (\n !objectIs(pendingQueue, hook.memoizedState) &&\n ((didReceiveUpdate = !0),\n didReadFromEntangledAsyncAction$32 &&\n ((reducer = currentEntangledActionThenable), null !== reducer))\n )\n throw reducer;\n hook.memoizedState = pendingQueue;\n hook.baseState = baseFirst;\n hook.baseQueue = newBaseQueueLast;\n queue.lastRenderedState = pendingQueue;\n }\n null === baseQueue && (queue.lanes = 0);\n return [hook.memoizedState, queue.dispatch];\n}\nfunction rerenderReducer(reducer) {\n var hook = updateWorkInProgressHook(),\n queue = hook.queue;\n if (null === queue) throw Error(formatProdErrorMessage(311));\n queue.lastRenderedReducer = reducer;\n var dispatch = queue.dispatch,\n lastRenderPhaseUpdate = queue.pending,\n newState = hook.memoizedState;\n if (null !== lastRenderPhaseUpdate) {\n queue.pending = null;\n var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);\n do (newState = reducer(newState, update.action)), (update = update.next);\n while (update !== lastRenderPhaseUpdate);\n objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);\n hook.memoizedState = newState;\n null === hook.baseQueue && (hook.baseState = newState);\n queue.lastRenderedState = newState;\n }\n return [newState, dispatch];\n}\nfunction updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {\n var fiber = currentlyRenderingFiber,\n hook = updateWorkInProgressHook(),\n isHydrating$jscomp$0 = isHydrating;\n if (isHydrating$jscomp$0) {\n if (void 0 === getServerSnapshot) throw Error(formatProdErrorMessage(407));\n getServerSnapshot = getServerSnapshot();\n } else getServerSnapshot = getSnapshot();\n var snapshotChanged = !objectIs(\n (currentHook || hook).memoizedState,\n getServerSnapshot\n );\n snapshotChanged &&\n ((hook.memoizedState = getServerSnapshot), (didReceiveUpdate = !0));\n hook = hook.queue;\n var create = subscribeToStore.bind(null, fiber, hook, subscribe);\n updateEffectImpl(2048, 8, create, [subscribe]);\n if (\n hook.getSnapshot !== getSnapshot ||\n snapshotChanged ||\n (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)\n ) {\n fiber.flags |= 2048;\n pushSimpleEffect(\n 9,\n createEffectInstance(),\n updateStoreInstance.bind(\n null,\n fiber,\n hook,\n getServerSnapshot,\n getSnapshot\n ),\n null\n );\n if (null === workInProgressRoot) throw Error(formatProdErrorMessage(349));\n isHydrating$jscomp$0 ||\n 0 !== (renderLanes & 124) ||\n pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);\n }\n return getServerSnapshot;\n}\nfunction pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {\n fiber.flags |= 16384;\n fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };\n getSnapshot = currentlyRenderingFiber.updateQueue;\n null === getSnapshot\n ? ((getSnapshot = createFunctionComponentUpdateQueue()),\n (currentlyRenderingFiber.updateQueue = getSnapshot),\n (getSnapshot.stores = [fiber]))\n : ((renderedSnapshot = getSnapshot.stores),\n null === renderedSnapshot\n ? (getSnapshot.stores = [fiber])\n : renderedSnapshot.push(fiber));\n}\nfunction updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {\n inst.value = nextSnapshot;\n inst.getSnapshot = getSnapshot;\n checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);\n}\nfunction subscribeToStore(fiber, inst, subscribe) {\n return subscribe(function () {\n checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);\n });\n}\nfunction checkIfSnapshotChanged(inst) {\n var latestGetSnapshot = inst.getSnapshot;\n inst = inst.value;\n try {\n var nextValue = latestGetSnapshot();\n return !objectIs(inst, nextValue);\n } catch (error) {\n return !0;\n }\n}\nfunction forceStoreRerender(fiber) {\n var root = enqueueConcurrentRenderForLane(fiber, 2);\n null !== root && scheduleUpdateOnFiber(root, fiber, 2);\n}\nfunction mountStateImpl(initialState) {\n var hook = mountWorkInProgressHook();\n if (\"function\" === typeof initialState) {\n var initialStateInitializer = initialState;\n initialState = initialStateInitializer();\n if (shouldDoubleInvokeUserFnsInHooksDEV) {\n setIsStrictModeForDevtools(!0);\n try {\n initialStateInitializer();\n } finally {\n setIsStrictModeForDevtools(!1);\n }\n }\n }\n hook.memoizedState = hook.baseState = initialState;\n hook.queue = {\n pending: null,\n lanes: 0,\n dispatch: null,\n lastRenderedReducer: basicStateReducer,\n lastRenderedState: initialState\n };\n return hook;\n}\nfunction updateOptimisticImpl(hook, current, passthrough, reducer) {\n hook.baseState = passthrough;\n return updateReducerImpl(\n hook,\n currentHook,\n \"function\" === typeof reducer ? reducer : basicStateReducer\n );\n}\nfunction dispatchActionState(\n fiber,\n actionQueue,\n setPendingState,\n setState,\n payload\n) {\n if (isRenderPhaseUpdate(fiber)) throw Error(formatProdErrorMessage(485));\n fiber = actionQueue.action;\n if (null !== fiber) {\n var actionNode = {\n payload: payload,\n action: fiber,\n next: null,\n isTransition: !0,\n status: \"pending\",\n value: null,\n reason: null,\n listeners: [],\n then: function (listener) {\n actionNode.listeners.push(listener);\n }\n };\n null !== ReactSharedInternals.T\n ? setPendingState(!0)\n : (actionNode.isTransition = !1);\n setState(actionNode);\n setPendingState = actionQueue.pending;\n null === setPendingState\n ? ((actionNode.next = actionQueue.pending = actionNode),\n runActionStateAction(actionQueue, actionNode))\n : ((actionNode.next = setPendingState.next),\n (actionQueue.pending = setPendingState.next = actionNode));\n }\n}\nfunction runActionStateAction(actionQueue, node) {\n var action = node.action,\n payload = node.payload,\n prevState = actionQueue.state;\n if (node.isTransition) {\n var prevTransition = ReactSharedInternals.T,\n currentTransition = {};\n ReactSharedInternals.T = currentTransition;\n try {\n var returnValue = action(prevState, payload),\n onStartTransitionFinish = ReactSharedInternals.S;\n null !== onStartTransitionFinish &&\n onStartTransitionFinish(currentTransition, returnValue);\n handleActionReturnValue(actionQueue, node, returnValue);\n } catch (error) {\n onActionError(actionQueue, node, error);\n } finally {\n ReactSharedInternals.T = prevTransition;\n }\n } else\n try {\n (prevTransition = action(prevState, payload)),\n handleActionReturnValue(actionQueue, node, prevTransition);\n } catch (error$38) {\n onActionError(actionQueue, node, error$38);\n }\n}\nfunction handleActionReturnValue(actionQueue, node, returnValue) {\n null !== returnValue &&\n \"object\" === typeof returnValue &&\n \"function\" === typeof returnValue.then\n ? returnValue.then(\n function (nextState) {\n onActionSuccess(actionQueue, node, nextState);\n },\n function (error) {\n return onActionError(actionQueue, node, error);\n }\n )\n : onActionSuccess(actionQueue, node, returnValue);\n}\nfunction onActionSuccess(actionQueue, actionNode, nextState) {\n actionNode.status = \"fulfilled\";\n actionNode.value = nextState;\n notifyActionListeners(actionNode);\n actionQueue.state = nextState;\n actionNode = actionQueue.pending;\n null !== actionNode &&\n ((nextState = actionNode.next),\n nextState === actionNode\n ? (actionQueue.pending = null)\n : ((nextState = nextState.next),\n (actionNode.next = nextState),\n runActionStateAction(actionQueue, nextState)));\n}\nfunction onActionError(actionQueue, actionNode, error) {\n var last = actionQueue.pending;\n actionQueue.pending = null;\n if (null !== last) {\n last = last.next;\n do\n (actionNode.status = \"rejected\"),\n (actionNode.reason = error),\n notifyActionListeners(actionNode),\n (actionNode = actionNode.next);\n while (actionNode !== last);\n }\n actionQueue.action = null;\n}\nfunction notifyActionListeners(actionNode) {\n actionNode = actionNode.listeners;\n for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();\n}\nfunction actionStateReducer(oldState, newState) {\n return newState;\n}\nfunction mountActionState(action, initialStateProp) {\n if (isHydrating) {\n var ssrFormState = workInProgressRoot.formState;\n if (null !== ssrFormState) {\n a: {\n var JSCompiler_inline_result = currentlyRenderingFiber;\n if (isHydrating) {\n if (nextHydratableInstance) {\n b: {\n var JSCompiler_inline_result$jscomp$0 = nextHydratableInstance;\n for (\n var inRootOrSingleton = rootOrSingletonContext;\n 8 !== JSCompiler_inline_result$jscomp$0.nodeType;\n\n ) {\n if (!inRootOrSingleton) {\n JSCompiler_inline_result$jscomp$0 = null;\n break b;\n }\n JSCompiler_inline_result$jscomp$0 = getNextHydratable(\n JSCompiler_inline_result$jscomp$0.nextSibling\n );\n if (null === JSCompiler_inline_result$jscomp$0) {\n JSCompiler_inline_result$jscomp$0 = null;\n break b;\n }\n }\n inRootOrSingleton = JSCompiler_inline_result$jscomp$0.data;\n JSCompiler_inline_result$jscomp$0 =\n \"F!\" === inRootOrSingleton || \"F\" === inRootOrSingleton\n ? JSCompiler_inline_result$jscomp$0\n : null;\n }\n if (JSCompiler_inline_result$jscomp$0) {\n nextHydratableInstance = getNextHydratable(\n JSCompiler_inline_result$jscomp$0.nextSibling\n );\n JSCompiler_inline_result =\n \"F!\" === JSCompiler_inline_result$jscomp$0.data;\n break a;\n }\n }\n throwOnHydrationMismatch(JSCompiler_inline_result);\n }\n JSCompiler_inline_result = !1;\n }\n JSCompiler_inline_result && (initialStateProp = ssrFormState[0]);\n }\n }\n ssrFormState = mountWorkInProgressHook();\n ssrFormState.memoizedState = ssrFormState.baseState = initialStateProp;\n JSCompiler_inline_result = {\n pending: null,\n lanes: 0,\n dispatch: null,\n lastRenderedReducer: actionStateReducer,\n lastRenderedState: initialStateProp\n };\n ssrFormState.queue = JSCompiler_inline_result;\n ssrFormState = dispatchSetState.bind(\n null,\n currentlyRenderingFiber,\n JSCompiler_inline_result\n );\n JSCompiler_inline_result.dispatch = ssrFormState;\n JSCompiler_inline_result = mountStateImpl(!1);\n inRootOrSingleton = dispatchOptimisticSetState.bind(\n null,\n currentlyRenderingFiber,\n !1,\n JSCompiler_inline_result.queue\n );\n JSCompiler_inline_result = mountWorkInProgressHook();\n JSCompiler_inline_result$jscomp$0 = {\n state: initialStateProp,\n dispatch: null,\n action: action,\n pending: null\n };\n JSCompiler_inline_result.queue = JSCompiler_inline_result$jscomp$0;\n ssrFormState = dispatchActionState.bind(\n null,\n currentlyRenderingFiber,\n JSCompiler_inline_result$jscomp$0,\n inRootOrSingleton,\n ssrFormState\n );\n JSCompiler_inline_result$jscomp$0.dispatch = ssrFormState;\n JSCompiler_inline_result.memoizedState = action;\n return [initialStateProp, ssrFormState, !1];\n}\nfunction updateActionState(action) {\n var stateHook = updateWorkInProgressHook();\n return updateActionStateImpl(stateHook, currentHook, action);\n}\nfunction updateActionStateImpl(stateHook, currentStateHook, action) {\n currentStateHook = updateReducerImpl(\n stateHook,\n currentStateHook,\n actionStateReducer\n )[0];\n stateHook = updateReducer(basicStateReducer)[0];\n if (\n \"object\" === typeof currentStateHook &&\n null !== currentStateHook &&\n \"function\" === typeof currentStateHook.then\n )\n try {\n var state = useThenable(currentStateHook);\n } catch (x) {\n if (x === SuspenseException) throw SuspenseActionException;\n throw x;\n }\n else state = currentStateHook;\n currentStateHook = updateWorkInProgressHook();\n var actionQueue = currentStateHook.queue,\n dispatch = actionQueue.dispatch;\n action !== currentStateHook.memoizedState &&\n ((currentlyRenderingFiber.flags |= 2048),\n pushSimpleEffect(\n 9,\n createEffectInstance(),\n actionStateActionEffect.bind(null, actionQueue, action),\n null\n ));\n return [state, dispatch, stateHook];\n}\nfunction actionStateActionEffect(actionQueue, action) {\n actionQueue.action = action;\n}\nfunction rerenderActionState(action) {\n var stateHook = updateWorkInProgressHook(),\n currentStateHook = currentHook;\n if (null !== currentStateHook)\n return updateActionStateImpl(stateHook, currentStateHook, action);\n updateWorkInProgressHook();\n stateHook = stateHook.memoizedState;\n currentStateHook = updateWorkInProgressHook();\n var dispatch = currentStateHook.queue.dispatch;\n currentStateHook.memoizedState = action;\n return [stateHook, dispatch, !1];\n}\nfunction pushSimpleEffect(tag, inst, create, createDeps) {\n tag = { tag: tag, create: create, deps: createDeps, inst: inst, next: null };\n inst = currentlyRenderingFiber.updateQueue;\n null === inst &&\n ((inst = createFunctionComponentUpdateQueue()),\n (currentlyRenderingFiber.updateQueue = inst));\n create = inst.lastEffect;\n null === create\n ? (inst.lastEffect = tag.next = tag)\n : ((createDeps = create.next),\n (create.next = tag),\n (tag.next = createDeps),\n (inst.lastEffect = tag));\n return tag;\n}\nfunction createEffectInstance() {\n return { destroy: void 0, resource: void 0 };\n}\nfunction updateRef() {\n return updateWorkInProgressHook().memoizedState;\n}\nfunction mountEffectImpl(fiberFlags, hookFlags, create, createDeps) {\n var hook = mountWorkInProgressHook();\n createDeps = void 0 === createDeps ? null : createDeps;\n currentlyRenderingFiber.flags |= fiberFlags;\n hook.memoizedState = pushSimpleEffect(\n 1 | hookFlags,\n createEffectInstance(),\n create,\n createDeps\n );\n}\nfunction updateEffectImpl(fiberFlags, hookFlags, create, deps) {\n var hook = updateWorkInProgressHook();\n deps = void 0 === deps ? null : deps;\n var inst = hook.memoizedState.inst;\n null !== currentHook &&\n null !== deps &&\n areHookInputsEqual(deps, currentHook.memoizedState.deps)\n ? (hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps))\n : ((currentlyRenderingFiber.flags |= fiberFlags),\n (hook.memoizedState = pushSimpleEffect(\n 1 | hookFlags,\n inst,\n create,\n deps\n )));\n}\nfunction mountEffect(create, createDeps) {\n mountEffectImpl(8390656, 8, create, createDeps);\n}\nfunction updateEffect(create, createDeps) {\n updateEffectImpl(2048, 8, create, createDeps);\n}\nfunction updateInsertionEffect(create, deps) {\n return updateEffectImpl(4, 2, create, deps);\n}\nfunction updateLayoutEffect(create, deps) {\n return updateEffectImpl(4, 4, create, deps);\n}\nfunction imperativeHandleEffect(create, ref) {\n if (\"function\" === typeof ref) {\n create = create();\n var refCleanup = ref(create);\n return function () {\n \"function\" === typeof refCleanup ? refCleanup() : ref(null);\n };\n }\n if (null !== ref && void 0 !== ref)\n return (\n (create = create()),\n (ref.current = create),\n function () {\n ref.current = null;\n }\n );\n}\nfunction updateImperativeHandle(ref, create, deps) {\n deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;\n updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);\n}\nfunction mountDebugValue() {}\nfunction updateCallback(callback, deps) {\n var hook = updateWorkInProgressHook();\n deps = void 0 === deps ? null : deps;\n var prevState = hook.memoizedState;\n if (null !== deps && areHookInputsEqual(deps, prevState[1]))\n return prevState[0];\n hook.memoizedState = [callback, deps];\n return callback;\n}\nfunction updateMemo(nextCreate, deps) {\n var hook = updateWorkInProgressHook();\n deps = void 0 === deps ? null : deps;\n var prevState = hook.memoizedState;\n if (null !== deps && areHookInputsEqual(deps, prevState[1]))\n return prevState[0];\n prevState = nextCreate();\n if (shouldDoubleInvokeUserFnsInHooksDEV) {\n setIsStrictModeForDevtools(!0);\n try {\n nextCreate();\n } finally {\n setIsStrictModeForDevtools(!1);\n }\n }\n hook.memoizedState = [prevState, deps];\n return prevState;\n}\nfunction mountDeferredValueImpl(hook, value, initialValue) {\n if (void 0 === initialValue || 0 !== (renderLanes & 1073741824))\n return (hook.memoizedState = value);\n hook.memoizedState = initialValue;\n hook = requestDeferredLane();\n currentlyRenderingFiber.lanes |= hook;\n workInProgressRootSkippedLanes |= hook;\n return initialValue;\n}\nfunction updateDeferredValueImpl(hook, prevValue, value, initialValue) {\n if (objectIs(value, prevValue)) return value;\n if (null !== currentTreeHiddenStackCursor.current)\n return (\n (hook = mountDeferredValueImpl(hook, value, initialValue)),\n objectIs(hook, prevValue) || (didReceiveUpdate = !0),\n hook\n );\n if (0 === (renderLanes & 42))\n return (didReceiveUpdate = !0), (hook.memoizedState = value);\n hook = requestDeferredLane();\n currentlyRenderingFiber.lanes |= hook;\n workInProgressRootSkippedLanes |= hook;\n return prevValue;\n}\nfunction startTransition(fiber, queue, pendingState, finishedState, callback) {\n var previousPriority = ReactDOMSharedInternals.p;\n ReactDOMSharedInternals.p =\n 0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;\n var prevTransition = ReactSharedInternals.T,\n currentTransition = {};\n ReactSharedInternals.T = currentTransition;\n dispatchOptimisticSetState(fiber, !1, queue, pendingState);\n try {\n var returnValue = callback(),\n onStartTransitionFinish = ReactSharedInternals.S;\n null !== onStartTransitionFinish &&\n onStartTransitionFinish(currentTransition, returnValue);\n if (\n null !== returnValue &&\n \"object\" === typeof returnValue &&\n \"function\" === typeof returnValue.then\n ) {\n var thenableForFinishedState = chainThenableValue(\n returnValue,\n finishedState\n );\n dispatchSetStateInternal(\n fiber,\n queue,\n thenableForFinishedState,\n requestUpdateLane(fiber)\n );\n } else\n dispatchSetStateInternal(\n fiber,\n queue,\n finishedState,\n requestUpdateLane(fiber)\n );\n } catch (error) {\n dispatchSetStateInternal(\n fiber,\n queue,\n { then: function () {}, status: \"rejected\", reason: error },\n requestUpdateLane()\n );\n } finally {\n (ReactDOMSharedInternals.p = previousPriority),\n (ReactSharedInternals.T = prevTransition);\n }\n}\nfunction noop$2() {}\nfunction startHostTransition(formFiber, pendingState, action, formData) {\n if (5 !== formFiber.tag) throw Error(formatProdErrorMessage(476));\n var queue = ensureFormComponentIsStateful(formFiber).queue;\n startTransition(\n formFiber,\n queue,\n pendingState,\n sharedNotPendingObject,\n null === action\n ? noop$2\n : function () {\n requestFormReset$1(formFiber);\n return action(formData);\n }\n );\n}\nfunction ensureFormComponentIsStateful(formFiber) {\n var existingStateHook = formFiber.memoizedState;\n if (null !== existingStateHook) return existingStateHook;\n existingStateHook = {\n memoizedState: sharedNotPendingObject,\n baseState: sharedNotPendingObject,\n baseQueue: null,\n queue: {\n pending: null,\n lanes: 0,\n dispatch: null,\n lastRenderedReducer: basicStateReducer,\n lastRenderedState: sharedNotPendingObject\n },\n next: null\n };\n var initialResetState = {};\n existingStateHook.next = {\n memoizedState: initialResetState,\n baseState: initialResetState,\n baseQueue: null,\n queue: {\n pending: null,\n lanes: 0,\n dispatch: null,\n lastRenderedReducer: basicStateReducer,\n lastRenderedState: initialResetState\n },\n next: null\n };\n formFiber.memoizedState = existingStateHook;\n formFiber = formFiber.alternate;\n null !== formFiber && (formFiber.memoizedState = existingStateHook);\n return existingStateHook;\n}\nfunction requestFormReset$1(formFiber) {\n var resetStateQueue = ensureFormComponentIsStateful(formFiber).next.queue;\n dispatchSetStateInternal(formFiber, resetStateQueue, {}, requestUpdateLane());\n}\nfunction useHostTransitionStatus() {\n return readContext(HostTransitionContext);\n}\nfunction updateId() {\n return updateWorkInProgressHook().memoizedState;\n}\nfunction updateRefresh() {\n return updateWorkInProgressHook().memoizedState;\n}\nfunction refreshCache(fiber) {\n for (var provider = fiber.return; null !== provider; ) {\n switch (provider.tag) {\n case 24:\n case 3:\n var lane = requestUpdateLane();\n fiber = createUpdate(lane);\n var root$41 = enqueueUpdate(provider, fiber, lane);\n null !== root$41 &&\n (scheduleUpdateOnFiber(root$41, provider, lane),\n entangleTransitions(root$41, provider, lane));\n provider = { cache: createCache() };\n fiber.payload = provider;\n return;\n }\n provider = provider.return;\n }\n}\nfunction dispatchReducerAction(fiber, queue, action) {\n var lane = requestUpdateLane();\n action = {\n lane: lane,\n revertLane: 0,\n action: action,\n hasEagerState: !1,\n eagerState: null,\n next: null\n };\n isRenderPhaseUpdate(fiber)\n ? enqueueRenderPhaseUpdate(queue, action)\n : ((action = enqueueConcurrentHookUpdate(fiber, queue, action, lane)),\n null !== action &&\n (scheduleUpdateOnFiber(action, fiber, lane),\n entangleTransitionUpdate(action, queue, lane)));\n}\nfunction dispatchSetState(fiber, queue, action) {\n var lane = requestUpdateLane();\n dispatchSetStateInternal(fiber, queue, action, lane);\n}\nfunction dispatchSetStateInternal(fiber, queue, action, lane) {\n var update = {\n lane: lane,\n revertLane: 0,\n action: action,\n hasEagerState: !1,\n eagerState: null,\n next: null\n };\n if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);\n else {\n var alternate = fiber.alternate;\n if (\n 0 === fiber.lanes &&\n (null === alternate || 0 === alternate.lanes) &&\n ((alternate = queue.lastRenderedReducer), null !== alternate)\n )\n try {\n var currentState = queue.lastRenderedState,\n eagerState = alternate(currentState, action);\n update.hasEagerState = !0;\n update.eagerState = eagerState;\n if (objectIs(eagerState, currentState))\n return (\n enqueueUpdate$1(fiber, queue, update, 0),\n null === workInProgressRoot && finishQueueingConcurrentUpdates(),\n !1\n );\n } catch (error) {\n } finally {\n }\n action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);\n if (null !== action)\n return (\n scheduleUpdateOnFiber(action, fiber, lane),\n entangleTransitionUpdate(action, queue, lane),\n !0\n );\n }\n return !1;\n}\nfunction dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {\n action = {\n lane: 2,\n revertLane: requestTransitionLane(),\n action: action,\n hasEagerState: !1,\n eagerState: null,\n next: null\n };\n if (isRenderPhaseUpdate(fiber)) {\n if (throwIfDuringRender) throw Error(formatProdErrorMessage(479));\n } else\n (throwIfDuringRender = enqueueConcurrentHookUpdate(\n fiber,\n queue,\n action,\n 2\n )),\n null !== throwIfDuringRender &&\n scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);\n}\nfunction isRenderPhaseUpdate(fiber) {\n var alternate = fiber.alternate;\n return (\n fiber === currentlyRenderingFiber ||\n (null !== alternate && alternate === currentlyRenderingFiber)\n );\n}\nfunction enqueueRenderPhaseUpdate(queue, update) {\n didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =\n !0;\n var pending = queue.pending;\n null === pending\n ? (update.next = update)\n : ((update.next = pending.next), (pending.next = update));\n queue.pending = update;\n}\nfunction entangleTransitionUpdate(root, queue, lane) {\n if (0 !== (lane & 4194048)) {\n var queueLanes = queue.lanes;\n queueLanes &= root.pendingLanes;\n lane |= queueLanes;\n queue.lanes = lane;\n markRootEntangled(root, lane);\n }\n}\nvar ContextOnlyDispatcher = {\n readContext: readContext,\n use: use,\n useCallback: throwInvalidHookError,\n useContext: throwInvalidHookError,\n useEffect: throwInvalidHookError,\n useImperativeHandle: throwInvalidHookError,\n useLayoutEffect: throwInvalidHookError,\n useInsertionEffect: throwInvalidHookError,\n useMemo: throwInvalidHookError,\n useReducer: throwInvalidHookError,\n useRef: throwInvalidHookError,\n useState: throwInvalidHookError,\n useDebugValue: throwInvalidHookError,\n useDeferredValue: throwInvalidHookError,\n useTransition: throwInvalidHookError,\n useSyncExternalStore: throwInvalidHookError,\n useId: throwInvalidHookError,\n useHostTransitionStatus: throwInvalidHookError,\n useFormState: throwInvalidHookError,\n useActionState: throwInvalidHookError,\n useOptimistic: throwInvalidHookError,\n useMemoCache: throwInvalidHookError,\n useCacheRefresh: throwInvalidHookError\n },\n HooksDispatcherOnMount = {\n readContext: readContext,\n use: use,\n useCallback: function (callback, deps) {\n mountWorkInProgressHook().memoizedState = [\n callback,\n void 0 === deps ? null : deps\n ];\n return callback;\n },\n useContext: readContext,\n useEffect: mountEffect,\n useImperativeHandle: function (ref, create, deps) {\n deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;\n mountEffectImpl(\n 4194308,\n 4,\n imperativeHandleEffect.bind(null, create, ref),\n deps\n );\n },\n useLayoutEffect: function (create, deps) {\n return mountEffectImpl(4194308, 4, create, deps);\n },\n useInsertionEffect: function (create, deps) {\n mountEffectImpl(4, 2, create, deps);\n },\n useMemo: function (nextCreate, deps) {\n var hook = mountWorkInProgressHook();\n deps = void 0 === deps ? null : deps;\n var nextValue = nextCreate();\n if (shouldDoubleInvokeUserFnsInHooksDEV) {\n setIsStrictModeForDevtools(!0);\n try {\n nextCreate();\n } finally {\n setIsStrictModeForDevtools(!1);\n }\n }\n hook.memoizedState = [nextValue, deps];\n return nextValue;\n },\n useReducer: function (reducer, initialArg, init) {\n var hook = mountWorkInProgressHook();\n if (void 0 !== init) {\n var initialState = init(initialArg);\n if (shouldDoubleInvokeUserFnsInHooksDEV) {\n setIsStrictModeForDevtools(!0);\n try {\n init(initialArg);\n } finally {\n setIsStrictModeForDevtools(!1);\n }\n }\n } else initialState = initialArg;\n hook.memoizedState = hook.baseState = initialState;\n reducer = {\n pending: null,\n lanes: 0,\n dispatch: null,\n lastRenderedReducer: reducer,\n lastRenderedState: initialState\n };\n hook.queue = reducer;\n reducer = reducer.dispatch = dispatchReducerAction.bind(\n null,\n currentlyRenderingFiber,\n reducer\n );\n return [hook.memoizedState, reducer];\n },\n useRef: function (initialValue) {\n var hook = mountWorkInProgressHook();\n initialValue = { current: initialValue };\n return (hook.memoizedState = initialValue);\n },\n useState: function (initialState) {\n initialState = mountStateImpl(initialState);\n var queue = initialState.queue,\n dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);\n queue.dispatch = dispatch;\n return [initialState.memoizedState, dispatch];\n },\n useDebugValue: mountDebugValue,\n useDeferredValue: function (value, initialValue) {\n var hook = mountWorkInProgressHook();\n return mountDeferredValueImpl(hook, value, initialValue);\n },\n useTransition: function () {\n var stateHook = mountStateImpl(!1);\n stateHook = startTransition.bind(\n null,\n currentlyRenderingFiber,\n stateHook.queue,\n !0,\n !1\n );\n mountWorkInProgressHook().memoizedState = stateHook;\n return [!1, stateHook];\n },\n useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {\n var fiber = currentlyRenderingFiber,\n hook = mountWorkInProgressHook();\n if (isHydrating) {\n if (void 0 === getServerSnapshot)\n throw Error(formatProdErrorMessage(407));\n getServerSnapshot = getServerSnapshot();\n } else {\n getServerSnapshot = getSnapshot();\n if (null === workInProgressRoot)\n throw Error(formatProdErrorMessage(349));\n 0 !== (workInProgressRootRenderLanes & 124) ||\n pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);\n }\n hook.memoizedState = getServerSnapshot;\n var inst = { value: getServerSnapshot, getSnapshot: getSnapshot };\n hook.queue = inst;\n mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [\n subscribe\n ]);\n fiber.flags |= 2048;\n pushSimpleEffect(\n 9,\n createEffectInstance(),\n updateStoreInstance.bind(\n null,\n fiber,\n inst,\n getServerSnapshot,\n getSnapshot\n ),\n null\n );\n return getServerSnapshot;\n },\n useId: function () {\n var hook = mountWorkInProgressHook(),\n identifierPrefix = workInProgressRoot.identifierPrefix;\n if (isHydrating) {\n var JSCompiler_inline_result = treeContextOverflow;\n var idWithLeadingBit = treeContextId;\n JSCompiler_inline_result =\n (\n idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))\n ).toString(32) + JSCompiler_inline_result;\n identifierPrefix =\n \"\\u00ab\" + identifierPrefix + \"R\" + JSCompiler_inline_result;\n JSCompiler_inline_result = localIdCounter++;\n 0 < JSCompiler_inline_result &&\n (identifierPrefix += \"H\" + JSCompiler_inline_result.toString(32));\n identifierPrefix += \"\\u00bb\";\n } else\n (JSCompiler_inline_result = globalClientIdCounter++),\n (identifierPrefix =\n \"\\u00ab\" +\n identifierPrefix +\n \"r\" +\n JSCompiler_inline_result.toString(32) +\n \"\\u00bb\");\n return (hook.memoizedState = identifierPrefix);\n },\n useHostTransitionStatus: useHostTransitionStatus,\n useFormState: mountActionState,\n useActionState: mountActionState,\n useOptimistic: function (passthrough) {\n var hook = mountWorkInProgressHook();\n hook.memoizedState = hook.baseState = passthrough;\n var queue = {\n pending: null,\n lanes: 0,\n dispatch: null,\n lastRenderedReducer: null,\n lastRenderedState: null\n };\n hook.queue = queue;\n hook = dispatchOptimisticSetState.bind(\n null,\n currentlyRenderingFiber,\n !0,\n queue\n );\n queue.dispatch = hook;\n return [passthrough, hook];\n },\n useMemoCache: useMemoCache,\n useCacheRefresh: function () {\n return (mountWorkInProgressHook().memoizedState = refreshCache.bind(\n null,\n currentlyRenderingFiber\n ));\n }\n },\n HooksDispatcherOnUpdate = {\n readContext: readContext,\n use: use,\n useCallback: updateCallback,\n useContext: readContext,\n useEffect: updateEffect,\n useImperativeHandle: updateImperativeHandle,\n useInsertionEffect: updateInsertionEffect,\n useLayoutEffect: updateLayoutEffect,\n useMemo: updateMemo,\n useReducer: updateReducer,\n useRef: updateRef,\n useState: function () {\n return updateReducer(basicStateReducer);\n },\n useDebugValue: mountDebugValue,\n useDeferredValue: function (value, initialValue) {\n var hook = updateWorkInProgressHook();\n return updateDeferredValueImpl(\n hook,\n currentHook.memoizedState,\n value,\n initialValue\n );\n },\n useTransition: function () {\n var booleanOrThenable = updateReducer(basicStateReducer)[0],\n start = updateWorkInProgressHook().memoizedState;\n return [\n \"boolean\" === typeof booleanOrThenable\n ? booleanOrThenable\n : useThenable(booleanOrThenable),\n start\n ];\n },\n useSyncExternalStore: updateSyncExternalStore,\n useId: updateId,\n useHostTransitionStatus: useHostTransitionStatus,\n useFormState: updateActionState,\n useActionState: updateActionState,\n useOptimistic: function (passthrough, reducer) {\n var hook = updateWorkInProgressHook();\n return updateOptimisticImpl(hook, currentHook, passthrough, reducer);\n },\n useMemoCache: useMemoCache,\n useCacheRefresh: updateRefresh\n },\n HooksDispatcherOnRerender = {\n readContext: readContext,\n use: use,\n useCallback: updateCallback,\n useContext: readContext,\n useEffect: updateEffect,\n useImperativeHandle: updateImperativeHandle,\n useInsertionEffect: updateInsertionEffect,\n useLayoutEffect: updateLayoutEffect,\n useMemo: updateMemo,\n useReducer: rerenderReducer,\n useRef: updateRef,\n useState: function () {\n return rerenderReducer(basicStateReducer);\n },\n useDebugValue: mountDebugValue,\n useDeferredValue: function (value, initialValue) {\n var hook = updateWorkInProgressHook();\n return null === currentHook\n ? mountDeferredValueImpl(hook, value, initialValue)\n : updateDeferredValueImpl(\n hook,\n currentHook.memoizedState,\n value,\n initialValue\n );\n },\n useTransition: function () {\n var booleanOrThenable = rerenderReducer(basicStateReducer)[0],\n start = updateWorkInProgressHook().memoizedState;\n return [\n \"boolean\" === typeof booleanOrThenable\n ? booleanOrThenable\n : useThenable(booleanOrThenable),\n start\n ];\n },\n useSyncExternalStore: updateSyncExternalStore,\n useId: updateId,\n useHostTransitionStatus: useHostTransitionStatus,\n useFormState: rerenderActionState,\n useActionState: rerenderActionState,\n useOptimistic: function (passthrough, reducer) {\n var hook = updateWorkInProgressHook();\n if (null !== currentHook)\n return updateOptimisticImpl(hook, currentHook, passthrough, reducer);\n hook.baseState = passthrough;\n return [passthrough, hook.queue.dispatch];\n },\n useMemoCache: useMemoCache,\n useCacheRefresh: updateRefresh\n },\n thenableState = null,\n thenableIndexCounter = 0;\nfunction unwrapThenable(thenable) {\n var index = thenableIndexCounter;\n thenableIndexCounter += 1;\n null === thenableState && (thenableState = []);\n return trackUsedThenable(thenableState, thenable, index);\n}\nfunction coerceRef(workInProgress, element) {\n element = element.props.ref;\n workInProgress.ref = void 0 !== element ? element : null;\n}\nfunction throwOnInvalidObjectType(returnFiber, newChild) {\n if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE)\n throw Error(formatProdErrorMessage(525));\n returnFiber = Object.prototype.toString.call(newChild);\n throw Error(\n formatProdErrorMessage(\n 31,\n \"[object Object]\" === returnFiber\n ? \"object with keys {\" + Object.keys(newChild).join(\", \") + \"}\"\n : returnFiber\n )\n );\n}\nfunction resolveLazy(lazyType) {\n var init = lazyType._init;\n return init(lazyType._payload);\n}\nfunction createChildReconciler(shouldTrackSideEffects) {\n function deleteChild(returnFiber, childToDelete) {\n if (shouldTrackSideEffects) {\n var deletions = returnFiber.deletions;\n null === deletions\n ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))\n : deletions.push(childToDelete);\n }\n }\n function deleteRemainingChildren(returnFiber, currentFirstChild) {\n if (!shouldTrackSideEffects) return null;\n for (; null !== currentFirstChild; )\n deleteChild(returnFiber, currentFirstChild),\n (currentFirstChild = currentFirstChild.sibling);\n return null;\n }\n function mapRemainingChildren(currentFirstChild) {\n for (var existingChildren = new Map(); null !== currentFirstChild; )\n null !== currentFirstChild.key\n ? existingChildren.set(currentFirstChild.key, currentFirstChild)\n : existingChildren.set(currentFirstChild.index, currentFirstChild),\n (currentFirstChild = currentFirstChild.sibling);\n return existingChildren;\n }\n function useFiber(fiber, pendingProps) {\n fiber = createWorkInProgress(fiber, pendingProps);\n fiber.index = 0;\n fiber.sibling = null;\n return fiber;\n }\n function placeChild(newFiber, lastPlacedIndex, newIndex) {\n newFiber.index = newIndex;\n if (!shouldTrackSideEffects)\n return (newFiber.flags |= 1048576), lastPlacedIndex;\n newIndex = newFiber.alternate;\n if (null !== newIndex)\n return (\n (newIndex = newIndex.index),\n newIndex < lastPlacedIndex\n ? ((newFiber.flags |= 67108866), lastPlacedIndex)\n : newIndex\n );\n newFiber.flags |= 67108866;\n return lastPlacedIndex;\n }\n function placeSingleChild(newFiber) {\n shouldTrackSideEffects &&\n null === newFiber.alternate &&\n (newFiber.flags |= 67108866);\n return newFiber;\n }\n function updateTextNode(returnFiber, current, textContent, lanes) {\n if (null === current || 6 !== current.tag)\n return (\n (current = createFiberFromText(textContent, returnFiber.mode, lanes)),\n (current.return = returnFiber),\n current\n );\n current = useFiber(current, textContent);\n current.return = returnFiber;\n return current;\n }\n function updateElement(returnFiber, current, element, lanes) {\n var elementType = element.type;\n if (elementType === REACT_FRAGMENT_TYPE)\n return updateFragment(\n returnFiber,\n current,\n element.props.children,\n lanes,\n element.key\n );\n if (\n null !== current &&\n (current.elementType === elementType ||\n (\"object\" === typeof elementType &&\n null !== elementType &&\n elementType.$$typeof === REACT_LAZY_TYPE &&\n resolveLazy(elementType) === current.type))\n )\n return (\n (current = useFiber(current, element.props)),\n coerceRef(current, element),\n (current.return = returnFiber),\n current\n );\n current = createFiberFromTypeAndProps(\n element.type,\n element.key,\n element.props,\n null,\n returnFiber.mode,\n lanes\n );\n coerceRef(current, element);\n current.return = returnFiber;\n return current;\n }\n function updatePortal(returnFiber, current, portal, lanes) {\n if (\n null === current ||\n 4 !== current.tag ||\n current.stateNode.containerInfo !== portal.containerInfo ||\n current.stateNode.implementation !== portal.implementation\n )\n return (\n (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),\n (current.return = returnFiber),\n current\n );\n current = useFiber(current, portal.children || []);\n current.return = returnFiber;\n return current;\n }\n function updateFragment(returnFiber, current, fragment, lanes, key) {\n if (null === current || 7 !== current.tag)\n return (\n (current = createFiberFromFragment(\n fragment,\n returnFiber.mode,\n lanes,\n key\n )),\n (current.return = returnFiber),\n current\n );\n current = useFiber(current, fragment);\n current.return = returnFiber;\n return current;\n }\n function createChild(returnFiber, newChild, lanes) {\n if (\n (\"string\" === typeof newChild && \"\" !== newChild) ||\n \"number\" === typeof newChild ||\n \"bigint\" === typeof newChild\n )\n return (\n (newChild = createFiberFromText(\n \"\" + newChild,\n returnFiber.mode,\n lanes\n )),\n (newChild.return = returnFiber),\n newChild\n );\n if (\"object\" === typeof newChild && null !== newChild) {\n switch (newChild.$$typeof) {\n case REACT_ELEMENT_TYPE:\n return (\n (lanes = createFiberFromTypeAndProps(\n newChild.type,\n newChild.key,\n newChild.props,\n null,\n returnFiber.mode,\n lanes\n )),\n coerceRef(lanes, newChild),\n (lanes.return = returnFiber),\n lanes\n );\n case REACT_PORTAL_TYPE:\n return (\n (newChild = createFiberFromPortal(\n newChild,\n returnFiber.mode,\n lanes\n )),\n (newChild.return = returnFiber),\n newChild\n );\n case REACT_LAZY_TYPE:\n var init = newChild._init;\n newChild = init(newChild._payload);\n return createChild(returnFiber, newChild, lanes);\n }\n if (isArrayImpl(newChild) || getIteratorFn(newChild))\n return (\n (newChild = createFiberFromFragment(\n newChild,\n returnFiber.mode,\n lanes,\n null\n )),\n (newChild.return = returnFiber),\n newChild\n );\n if (\"function\" === typeof newChild.then)\n return createChild(returnFiber, unwrapThenable(newChild), lanes);\n if (newChild.$$typeof === REACT_CONTEXT_TYPE)\n return createChild(\n returnFiber,\n readContextDuringReconciliation(returnFiber, newChild),\n lanes\n );\n throwOnInvalidObjectType(returnFiber, newChild);\n }\n return null;\n }\n function updateSlot(returnFiber, oldFiber, newChild, lanes) {\n var key = null !== oldFiber ? oldFiber.key : null;\n if (\n (\"string\" === typeof newChild && \"\" !== newChild) ||\n \"number\" === typeof newChild ||\n \"bigint\" === typeof newChild\n )\n return null !== key\n ? null\n : updateTextNode(returnFiber, oldFiber, \"\" + newChild, lanes);\n if (\"object\" === typeof newChild && null !== newChild) {\n switch (newChild.$$typeof) {\n case REACT_ELEMENT_TYPE:\n return newChild.key === key\n ? updateElement(returnFiber, oldFiber, newChild, lanes)\n : null;\n case REACT_PORTAL_TYPE:\n return newChild.key === key\n ? updatePortal(returnFiber, oldFiber, newChild, lanes)\n : null;\n case REACT_LAZY_TYPE:\n return (\n (key = newChild._init),\n (newChild = key(newChild._payload)),\n updateSlot(returnFiber, oldFiber, newChild, lanes)\n );\n }\n if (isArrayImpl(newChild) || getIteratorFn(newChild))\n return null !== key\n ? null\n : updateFragment(returnFiber, oldFiber, newChild, lanes, null);\n if (\"function\" === typeof newChild.then)\n return updateSlot(\n returnFiber,\n oldFiber,\n unwrapThenable(newChild),\n lanes\n );\n if (newChild.$$typeof === REACT_CONTEXT_TYPE)\n return updateSlot(\n returnFiber,\n oldFiber,\n readContextDuringReconciliation(returnFiber, newChild),\n lanes\n );\n throwOnInvalidObjectType(returnFiber, newChild);\n }\n return null;\n }\n function updateFromMap(\n existingChildren,\n returnFiber,\n newIdx,\n newChild,\n lanes\n ) {\n if (\n (\"string\" === typeof newChild && \"\" !== newChild) ||\n \"number\" === typeof newChild ||\n \"bigint\" === typeof newChild\n )\n return (\n (existingChildren = existingChildren.get(newIdx) || null),\n updateTextNode(returnFiber, existingChildren, \"\" + newChild, lanes)\n );\n if (\"object\" === typeof newChild && null !== newChild) {\n switch (newChild.$$typeof) {\n case REACT_ELEMENT_TYPE:\n return (\n (existingChildren =\n existingChildren.get(\n null === newChild.key ? newIdx : newChild.key\n ) || null),\n updateElement(returnFiber, existingChildren, newChild, lanes)\n );\n case REACT_PORTAL_TYPE:\n return (\n (existingChildren =\n existingChildren.get(\n null === newChild.key ? newIdx : newChild.key\n ) || null),\n updatePortal(returnFiber, existingChildren, newChild, lanes)\n );\n case REACT_LAZY_TYPE:\n var init = newChild._init;\n newChild = init(newChild._payload);\n return updateFromMap(\n existingChildren,\n returnFiber,\n newIdx,\n newChild,\n lanes\n );\n }\n if (isArrayImpl(newChild) || getIteratorFn(newChild))\n return (\n (existingChildren = existingChildren.get(newIdx) || null),\n updateFragment(returnFiber, existingChildren, newChild, lanes, null)\n );\n if (\"function\" === typeof newChild.then)\n return updateFromMap(\n existingChildren,\n returnFiber,\n newIdx,\n unwrapThenable(newChild),\n lanes\n );\n if (newChild.$$typeof === REACT_CONTEXT_TYPE)\n return updateFromMap(\n existingChildren,\n returnFiber,\n newIdx,\n readContextDuringReconciliation(returnFiber, newChild),\n lanes\n );\n throwOnInvalidObjectType(returnFiber, newChild);\n }\n return null;\n }\n function reconcileChildrenArray(\n returnFiber,\n currentFirstChild,\n newChildren,\n lanes\n ) {\n for (\n var resultingFirstChild = null,\n previousNewFiber = null,\n oldFiber = currentFirstChild,\n newIdx = (currentFirstChild = 0),\n nextOldFiber = null;\n null !== oldFiber && newIdx < newChildren.length;\n newIdx++\n ) {\n oldFiber.index > newIdx\n ? ((nextOldFiber = oldFiber), (oldFiber = null))\n : (nextOldFiber = oldFiber.sibling);\n var newFiber = updateSlot(\n returnFiber,\n oldFiber,\n newChildren[newIdx],\n lanes\n );\n if (null === newFiber) {\n null === oldFiber && (oldFiber = nextOldFiber);\n break;\n }\n shouldTrackSideEffects &&\n oldFiber &&\n null === newFiber.alternate &&\n deleteChild(returnFiber, oldFiber);\n currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);\n null === previousNewFiber\n ? (resultingFirstChild = newFiber)\n : (previousNewFiber.sibling = newFiber);\n previousNewFiber = newFiber;\n oldFiber = nextOldFiber;\n }\n if (newIdx === newChildren.length)\n return (\n deleteRemainingChildren(returnFiber, oldFiber),\n isHydrating && pushTreeFork(returnFiber, newIdx),\n resultingFirstChild\n );\n if (null === oldFiber) {\n for (; newIdx < newChildren.length; newIdx++)\n (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),\n null !== oldFiber &&\n ((currentFirstChild = placeChild(\n oldFiber,\n currentFirstChild,\n newIdx\n )),\n null === previousNewFiber\n ? (resultingFirstChild = oldFiber)\n : (previousNewFiber.sibling = oldFiber),\n (previousNewFiber = oldFiber));\n isHydrating && pushTreeFork(returnFiber, newIdx);\n return resultingFirstChild;\n }\n for (\n oldFiber = mapRemainingChildren(oldFiber);\n newIdx < newChildren.length;\n newIdx++\n )\n (nextOldFiber = updateFromMap(\n oldFiber,\n returnFiber,\n newIdx,\n newChildren[newIdx],\n lanes\n )),\n null !== nextOldFiber &&\n (shouldTrackSideEffects &&\n null !== nextOldFiber.alternate &&\n oldFiber.delete(\n null === nextOldFiber.key ? newIdx : nextOldFiber.key\n ),\n (currentFirstChild = placeChild(\n nextOldFiber,\n currentFirstChild,\n newIdx\n )),\n null === previousNewFiber\n ? (resultingFirstChild = nextOldFiber)\n : (previousNewFiber.sibling = nextOldFiber),\n (previousNewFiber = nextOldFiber));\n shouldTrackSideEffects &&\n oldFiber.forEach(function (child) {\n return deleteChild(returnFiber, child);\n });\n isHydrating && pushTreeFork(returnFiber, newIdx);\n return resultingFirstChild;\n }\n function reconcileChildrenIterator(\n returnFiber,\n currentFirstChild,\n newChildren,\n lanes\n ) {\n if (null == newChildren) throw Error(formatProdErrorMessage(151));\n for (\n var resultingFirstChild = null,\n previousNewFiber = null,\n oldFiber = currentFirstChild,\n newIdx = (currentFirstChild = 0),\n nextOldFiber = null,\n step = newChildren.next();\n null !== oldFiber && !step.done;\n newIdx++, step = newChildren.next()\n ) {\n oldFiber.index > newIdx\n ? ((nextOldFiber = oldFiber), (oldFiber = null))\n : (nextOldFiber = oldFiber.sibling);\n var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);\n if (null === newFiber) {\n null === oldFiber && (oldFiber = nextOldFiber);\n break;\n }\n shouldTrackSideEffects &&\n oldFiber &&\n null === newFiber.alternate &&\n deleteChild(returnFiber, oldFiber);\n currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);\n null === previousNewFiber\n ? (resultingFirstChild = newFiber)\n : (previousNewFiber.sibling = newFiber);\n previousNewFiber = newFiber;\n oldFiber = nextOldFiber;\n }\n if (step.done)\n return (\n deleteRemainingChildren(returnFiber, oldFiber),\n isHydrating && pushTreeFork(returnFiber, newIdx),\n resultingFirstChild\n );\n if (null === oldFiber) {\n for (; !step.done; newIdx++, step = newChildren.next())\n (step = createChild(returnFiber, step.value, lanes)),\n null !== step &&\n ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),\n null === previousNewFiber\n ? (resultingFirstChild = step)\n : (previousNewFiber.sibling = step),\n (previousNewFiber = step));\n isHydrating && pushTreeFork(returnFiber, newIdx);\n return resultingFirstChild;\n }\n for (\n oldFiber = mapRemainingChildren(oldFiber);\n !step.done;\n newIdx++, step = newChildren.next()\n )\n (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),\n null !== step &&\n (shouldTrackSideEffects &&\n null !== step.alternate &&\n oldFiber.delete(null === step.key ? newIdx : step.key),\n (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),\n null === previousNewFiber\n ? (resultingFirstChild = step)\n : (previousNewFiber.sibling = step),\n (previousNewFiber = step));\n shouldTrackSideEffects &&\n oldFiber.forEach(function (child) {\n return deleteChild(returnFiber, child);\n });\n isHydrating && pushTreeFork(returnFiber, newIdx);\n return resultingFirstChild;\n }\n function reconcileChildFibersImpl(\n returnFiber,\n currentFirstChild,\n newChild,\n lanes\n ) {\n \"object\" === typeof newChild &&\n null !== newChild &&\n newChild.type === REACT_FRAGMENT_TYPE &&\n null === newChild.key &&\n (newChild = newChild.props.children);\n if (\"object\" === typeof newChild && null !== newChild) {\n switch (newChild.$$typeof) {\n case REACT_ELEMENT_TYPE:\n a: {\n for (var key = newChild.key; null !== currentFirstChild; ) {\n if (currentFirstChild.key === key) {\n key = newChild.type;\n if (key === REACT_FRAGMENT_TYPE) {\n if (7 === currentFirstChild.tag) {\n deleteRemainingChildren(\n returnFiber,\n currentFirstChild.sibling\n );\n lanes = useFiber(\n currentFirstChild,\n newChild.props.children\n );\n lanes.return = returnFiber;\n returnFiber = lanes;\n break a;\n }\n } else if (\n currentFirstChild.elementType === key ||\n (\"object\" === typeof key &&\n null !== key &&\n key.$$typeof === REACT_LAZY_TYPE &&\n resolveLazy(key) === currentFirstChild.type)\n ) {\n deleteRemainingChildren(\n returnFiber,\n currentFirstChild.sibling\n );\n lanes = useFiber(currentFirstChild, newChild.props);\n coerceRef(lanes, newChild);\n lanes.return = returnFiber;\n returnFiber = lanes;\n break a;\n }\n deleteRemainingChildren(returnFiber, currentFirstChild);\n break;\n } else deleteChild(returnFiber, currentFirstChild);\n currentFirstChild = currentFirstChild.sibling;\n }\n newChild.type === REACT_FRAGMENT_TYPE\n ? ((lanes = createFiberFromFragment(\n newChild.props.children,\n returnFiber.mode,\n lanes,\n newChild.key\n )),\n (lanes.return = returnFiber),\n (returnFiber = lanes))\n : ((lanes = createFiberFromTypeAndProps(\n newChild.type,\n newChild.key,\n newChild.props,\n null,\n returnFiber.mode,\n lanes\n )),\n coerceRef(lanes, newChild),\n (lanes.return = returnFiber),\n (returnFiber = lanes));\n }\n return placeSingleChild(returnFiber);\n case REACT_PORTAL_TYPE:\n a: {\n for (key = newChild.key; null !== currentFirstChild; ) {\n if (currentFirstChild.key === key)\n if (\n 4 === currentFirstChild.tag &&\n currentFirstChild.stateNode.containerInfo ===\n newChild.containerInfo &&\n currentFirstChild.stateNode.implementation ===\n newChild.implementation\n ) {\n deleteRemainingChildren(\n returnFiber,\n currentFirstChild.sibling\n );\n lanes = useFiber(currentFirstChild, newChild.children || []);\n lanes.return = returnFiber;\n returnFiber = lanes;\n break a;\n } else {\n deleteRemainingChildren(returnFiber, currentFirstChild);\n break;\n }\n else deleteChild(returnFiber, currentFirstChild);\n currentFirstChild = currentFirstChild.sibling;\n }\n lanes = createFiberFromPortal(newChild, returnFiber.mode, lanes);\n lanes.return = returnFiber;\n returnFiber = lanes;\n }\n return placeSingleChild(returnFiber);\n case REACT_LAZY_TYPE:\n return (\n (key = newChild._init),\n (newChild = key(newChild._payload)),\n reconcileChildFibersImpl(\n returnFiber,\n currentFirstChild,\n newChild,\n lanes\n )\n );\n }\n if (isArrayImpl(newChild))\n return reconcileChildrenArray(\n returnFiber,\n currentFirstChild,\n newChild,\n lanes\n );\n if (getIteratorFn(newChild)) {\n key = getIteratorFn(newChild);\n if (\"function\" !== typeof key) throw Error(formatProdErrorMessage(150));\n newChild = key.call(newChild);\n return reconcileChildrenIterator(\n returnFiber,\n currentFirstChild,\n newChild,\n lanes\n );\n }\n if (\"function\" === typeof newChild.then)\n return reconcileChildFibersImpl(\n returnFiber,\n currentFirstChild,\n unwrapThenable(newChild),\n lanes\n );\n if (newChild.$$typeof === REACT_CONTEXT_TYPE)\n return reconcileChildFibersImpl(\n returnFiber,\n currentFirstChild,\n readContextDuringReconciliation(returnFiber, newChild),\n lanes\n );\n throwOnInvalidObjectType(returnFiber, newChild);\n }\n return (\"string\" === typeof newChild && \"\" !== newChild) ||\n \"number\" === typeof newChild ||\n \"bigint\" === typeof newChild\n ? ((newChild = \"\" + newChild),\n null !== currentFirstChild && 6 === currentFirstChild.tag\n ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),\n (lanes = useFiber(currentFirstChild, newChild)),\n (lanes.return = returnFiber),\n (returnFiber = lanes))\n : (deleteRemainingChildren(returnFiber, currentFirstChild),\n (lanes = createFiberFromText(newChild, returnFiber.mode, lanes)),\n (lanes.return = returnFiber),\n (returnFiber = lanes)),\n placeSingleChild(returnFiber))\n : deleteRemainingChildren(returnFiber, currentFirstChild);\n }\n return function (returnFiber, currentFirstChild, newChild, lanes) {\n try {\n thenableIndexCounter = 0;\n var firstChildFiber = reconcileChildFibersImpl(\n returnFiber,\n currentFirstChild,\n newChild,\n lanes\n );\n thenableState = null;\n return firstChildFiber;\n } catch (x) {\n if (x === SuspenseException || x === SuspenseActionException) throw x;\n var fiber = createFiberImplClass(29, x, null, returnFiber.mode);\n fiber.lanes = lanes;\n fiber.return = returnFiber;\n return fiber;\n } finally {\n }\n };\n}\nvar reconcileChildFibers = createChildReconciler(!0),\n mountChildFibers = createChildReconciler(!1),\n suspenseHandlerStackCursor = createCursor(null),\n shellBoundary = null;\nfunction pushPrimaryTreeSuspenseHandler(handler) {\n var current = handler.alternate;\n push(suspenseStackCursor, suspenseStackCursor.current & 1);\n push(suspenseHandlerStackCursor, handler);\n null === shellBoundary &&\n (null === current || null !== currentTreeHiddenStackCursor.current\n ? (shellBoundary = handler)\n : null !== current.memoizedState && (shellBoundary = handler));\n}\nfunction pushOffscreenSuspenseHandler(fiber) {\n if (22 === fiber.tag) {\n if (\n (push(suspenseStackCursor, suspenseStackCursor.current),\n push(suspenseHandlerStackCursor, fiber),\n null === shellBoundary)\n ) {\n var current = fiber.alternate;\n null !== current &&\n null !== current.memoizedState &&\n (shellBoundary = fiber);\n }\n } else reuseSuspenseHandlerOnStack(fiber);\n}\nfunction reuseSuspenseHandlerOnStack() {\n push(suspenseStackCursor, suspenseStackCursor.current);\n push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);\n}\nfunction popSuspenseHandler(fiber) {\n pop(suspenseHandlerStackCursor);\n shellBoundary === fiber && (shellBoundary = null);\n pop(suspenseStackCursor);\n}\nvar suspenseStackCursor = createCursor(0);\nfunction findFirstSuspended(row) {\n for (var node = row; null !== node; ) {\n if (13 === node.tag) {\n var state = node.memoizedState;\n if (\n null !== state &&\n ((state = state.dehydrated),\n null === state ||\n \"$?\" === state.data ||\n isSuspenseInstanceFallback(state))\n )\n return node;\n } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {\n if (0 !== (node.flags & 128)) return node;\n } else if (null !== node.child) {\n node.child.return = node;\n node = node.child;\n continue;\n }\n if (node === row) break;\n for (; null === node.sibling; ) {\n if (null === node.return || node.return === row) return null;\n node = node.return;\n }\n node.sibling.return = node.return;\n node = node.sibling;\n }\n return null;\n}\nfunction applyDerivedStateFromProps(\n workInProgress,\n ctor,\n getDerivedStateFromProps,\n nextProps\n) {\n ctor = workInProgress.memoizedState;\n getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);\n getDerivedStateFromProps =\n null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps\n ? ctor\n : assign({}, ctor, getDerivedStateFromProps);\n workInProgress.memoizedState = getDerivedStateFromProps;\n 0 === workInProgress.lanes &&\n (workInProgress.updateQueue.baseState = getDerivedStateFromProps);\n}\nvar classComponentUpdater = {\n enqueueSetState: function (inst, payload, callback) {\n inst = inst._reactInternals;\n var lane = requestUpdateLane(),\n update = createUpdate(lane);\n update.payload = payload;\n void 0 !== callback && null !== callback && (update.callback = callback);\n payload = enqueueUpdate(inst, update, lane);\n null !== payload &&\n (scheduleUpdateOnFiber(payload, inst, lane),\n entangleTransitions(payload, inst, lane));\n },\n enqueueReplaceState: function (inst, payload, callback) {\n inst = inst._reactInternals;\n var lane = requestUpdateLane(),\n update = createUpdate(lane);\n update.tag = 1;\n update.payload = payload;\n void 0 !== callback && null !== callback && (update.callback = callback);\n payload = enqueueUpdate(inst, update, lane);\n null !== payload &&\n (scheduleUpdateOnFiber(payload, inst, lane),\n entangleTransitions(payload, inst, lane));\n },\n enqueueForceUpdate: function (inst, callback) {\n inst = inst._reactInternals;\n var lane = requestUpdateLane(),\n update = createUpdate(lane);\n update.tag = 2;\n void 0 !== callback && null !== callback && (update.callback = callback);\n callback = enqueueUpdate(inst, update, lane);\n null !== callback &&\n (scheduleUpdateOnFiber(callback, inst, lane),\n entangleTransitions(callback, inst, lane));\n }\n};\nfunction checkShouldComponentUpdate(\n workInProgress,\n ctor,\n oldProps,\n newProps,\n oldState,\n newState,\n nextContext\n) {\n workInProgress = workInProgress.stateNode;\n return \"function\" === typeof workInProgress.shouldComponentUpdate\n ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)\n : ctor.prototype && ctor.prototype.isPureReactComponent\n ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)\n : !0;\n}\nfunction callComponentWillReceiveProps(\n workInProgress,\n instance,\n newProps,\n nextContext\n) {\n workInProgress = instance.state;\n \"function\" === typeof instance.componentWillReceiveProps &&\n instance.componentWillReceiveProps(newProps, nextContext);\n \"function\" === typeof instance.UNSAFE_componentWillReceiveProps &&\n instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);\n instance.state !== workInProgress &&\n classComponentUpdater.enqueueReplaceState(instance, instance.state, null);\n}\nfunction resolveClassComponentProps(Component, baseProps) {\n var newProps = baseProps;\n if (\"ref\" in baseProps) {\n newProps = {};\n for (var propName in baseProps)\n \"ref\" !== propName && (newProps[propName] = baseProps[propName]);\n }\n if ((Component = Component.defaultProps)) {\n newProps === baseProps && (newProps = assign({}, newProps));\n for (var propName$73 in Component)\n void 0 === newProps[propName$73] &&\n (newProps[propName$73] = Component[propName$73]);\n }\n return newProps;\n}\nvar reportGlobalError =\n \"function\" === typeof reportError\n ? reportError\n : function (error) {\n if (\n \"object\" === typeof window &&\n \"function\" === typeof window.ErrorEvent\n ) {\n var event = new window.ErrorEvent(\"error\", {\n bubbles: !0,\n cancelable: !0,\n message:\n \"object\" === typeof error &&\n null !== error &&\n \"string\" === typeof error.message\n ? String(error.message)\n : String(error),\n error: error\n });\n if (!window.dispatchEvent(event)) return;\n } else if (\n \"object\" === typeof process &&\n \"function\" === typeof process.emit\n ) {\n process.emit(\"uncaughtException\", error);\n return;\n }\n console.error(error);\n };\nfunction defaultOnUncaughtError(error) {\n reportGlobalError(error);\n}\nfunction defaultOnCaughtError(error) {\n console.error(error);\n}\nfunction defaultOnRecoverableError(error) {\n reportGlobalError(error);\n}\nfunction logUncaughtError(root, errorInfo) {\n try {\n var onUncaughtError = root.onUncaughtError;\n onUncaughtError(errorInfo.value, { componentStack: errorInfo.stack });\n } catch (e$74) {\n setTimeout(function () {\n throw e$74;\n });\n }\n}\nfunction logCaughtError(root, boundary, errorInfo) {\n try {\n var onCaughtError = root.onCaughtError;\n onCaughtError(errorInfo.value, {\n componentStack: errorInfo.stack,\n errorBoundary: 1 === boundary.tag ? boundary.stateNode : null\n });\n } catch (e$75) {\n setTimeout(function () {\n throw e$75;\n });\n }\n}\nfunction createRootErrorUpdate(root, errorInfo, lane) {\n lane = createUpdate(lane);\n lane.tag = 3;\n lane.payload = { element: null };\n lane.callback = function () {\n logUncaughtError(root, errorInfo);\n };\n return lane;\n}\nfunction createClassErrorUpdate(lane) {\n lane = createUpdate(lane);\n lane.tag = 3;\n return lane;\n}\nfunction initializeClassErrorUpdate(update, root, fiber, errorInfo) {\n var getDerivedStateFromError = fiber.type.getDerivedStateFromError;\n if (\"function\" === typeof getDerivedStateFromError) {\n var error = errorInfo.value;\n update.payload = function () {\n return getDerivedStateFromError(error);\n };\n update.callback = function () {\n logCaughtError(root, fiber, errorInfo);\n };\n }\n var inst = fiber.stateNode;\n null !== inst &&\n \"function\" === typeof inst.componentDidCatch &&\n (update.callback = function () {\n logCaughtError(root, fiber, errorInfo);\n \"function\" !== typeof getDerivedStateFromError &&\n (null === legacyErrorBoundariesThatAlreadyFailed\n ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))\n : legacyErrorBoundariesThatAlreadyFailed.add(this));\n var stack = errorInfo.stack;\n this.componentDidCatch(errorInfo.value, {\n componentStack: null !== stack ? stack : \"\"\n });\n });\n}\nfunction throwException(\n root,\n returnFiber,\n sourceFiber,\n value,\n rootRenderLanes\n) {\n sourceFiber.flags |= 32768;\n if (\n null !== value &&\n \"object\" === typeof value &&\n \"function\" === typeof value.then\n ) {\n returnFiber = sourceFiber.alternate;\n null !== returnFiber &&\n propagateParentContextChanges(\n returnFiber,\n sourceFiber,\n rootRenderLanes,\n !0\n );\n sourceFiber = suspenseHandlerStackCursor.current;\n if (null !== sourceFiber) {\n switch (sourceFiber.tag) {\n case 13:\n return (\n null === shellBoundary\n ? renderDidSuspendDelayIfPossible()\n : null === sourceFiber.alternate &&\n 0 === workInProgressRootExitStatus &&\n (workInProgressRootExitStatus = 3),\n (sourceFiber.flags &= -257),\n (sourceFiber.flags |= 65536),\n (sourceFiber.lanes = rootRenderLanes),\n value === noopSuspenseyCommitThenable\n ? (sourceFiber.flags |= 16384)\n : ((returnFiber = sourceFiber.updateQueue),\n null === returnFiber\n ? (sourceFiber.updateQueue = new Set([value]))\n : returnFiber.add(value),\n attachPingListener(root, value, rootRenderLanes)),\n !1\n );\n case 22:\n return (\n (sourceFiber.flags |= 65536),\n value === noopSuspenseyCommitThenable\n ? (sourceFiber.flags |= 16384)\n : ((returnFiber = sourceFiber.updateQueue),\n null === returnFiber\n ? ((returnFiber = {\n transitions: null,\n markerInstances: null,\n retryQueue: new Set([value])\n }),\n (sourceFiber.updateQueue = returnFiber))\n : ((sourceFiber = returnFiber.retryQueue),\n null === sourceFiber\n ? (returnFiber.retryQueue = new Set([value]))\n : sourceFiber.add(value)),\n attachPingListener(root, value, rootRenderLanes)),\n !1\n );\n }\n throw Error(formatProdErrorMessage(435, sourceFiber.tag));\n }\n attachPingListener(root, value, rootRenderLanes);\n renderDidSuspendDelayIfPossible();\n return !1;\n }\n if (isHydrating)\n return (\n (returnFiber = suspenseHandlerStackCursor.current),\n null !== returnFiber\n ? (0 === (returnFiber.flags & 65536) && (returnFiber.flags |= 256),\n (returnFiber.flags |= 65536),\n (returnFiber.lanes = rootRenderLanes),\n value !== HydrationMismatchException &&\n ((root = Error(formatProdErrorMessage(422), { cause: value })),\n queueHydrationError(createCapturedValueAtFiber(root, sourceFiber))))\n : (value !== HydrationMismatchException &&\n ((returnFiber = Error(formatProdErrorMessage(423), {\n cause: value\n })),\n queueHydrationError(\n createCapturedValueAtFiber(returnFiber, sourceFiber)\n )),\n (root = root.current.alternate),\n (root.flags |= 65536),\n (rootRenderLanes &= -rootRenderLanes),\n (root.lanes |= rootRenderLanes),\n (value = createCapturedValueAtFiber(value, sourceFiber)),\n (rootRenderLanes = createRootErrorUpdate(\n root.stateNode,\n value,\n rootRenderLanes\n )),\n enqueueCapturedUpdate(root, rootRenderLanes),\n 4 !== workInProgressRootExitStatus &&\n (workInProgressRootExitStatus = 2)),\n !1\n );\n var wrapperError = Error(formatProdErrorMessage(520), { cause: value });\n wrapperError = createCapturedValueAtFiber(wrapperError, sourceFiber);\n null === workInProgressRootConcurrentErrors\n ? (workInProgressRootConcurrentErrors = [wrapperError])\n : workInProgressRootConcurrentErrors.push(wrapperError);\n 4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2);\n if (null === returnFiber) return !0;\n value = createCapturedValueAtFiber(value, sourceFiber);\n sourceFiber = returnFiber;\n do {\n switch (sourceFiber.tag) {\n case 3:\n return (\n (sourceFiber.flags |= 65536),\n (root = rootRenderLanes & -rootRenderLanes),\n (sourceFiber.lanes |= root),\n (root = createRootErrorUpdate(sourceFiber.stateNode, value, root)),\n enqueueCapturedUpdate(sourceFiber, root),\n !1\n );\n case 1:\n if (\n ((returnFiber = sourceFiber.type),\n (wrapperError = sourceFiber.stateNode),\n 0 === (sourceFiber.flags & 128) &&\n (\"function\" === typeof returnFiber.getDerivedStateFromError ||\n (null !== wrapperError &&\n \"function\" === typeof wrapperError.componentDidCatch &&\n (null === legacyErrorBoundariesThatAlreadyFailed ||\n !legacyErrorBoundariesThatAlreadyFailed.has(wrapperError)))))\n )\n return (\n (sourceFiber.flags |= 65536),\n (rootRenderLanes &= -rootRenderLanes),\n (sourceFiber.lanes |= rootRenderLanes),\n (rootRenderLanes = createClassErrorUpdate(rootRenderLanes)),\n initializeClassErrorUpdate(\n rootRenderLanes,\n root,\n sourceFiber,\n value\n ),\n enqueueCapturedUpdate(sourceFiber, rootRenderLanes),\n !1\n );\n }\n sourceFiber = sourceFiber.return;\n } while (null !== sourceFiber);\n return !1;\n}\nvar SelectiveHydrationException = Error(formatProdErrorMessage(461)),\n didReceiveUpdate = !1;\nfunction reconcileChildren(current, workInProgress, nextChildren, renderLanes) {\n workInProgress.child =\n null === current\n ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)\n : reconcileChildFibers(\n workInProgress,\n current.child,\n nextChildren,\n renderLanes\n );\n}\nfunction updateForwardRef(\n current,\n workInProgress,\n Component,\n nextProps,\n renderLanes\n) {\n Component = Component.render;\n var ref = workInProgress.ref;\n if (\"ref\" in nextProps) {\n var propsWithoutRef = {};\n for (var key in nextProps)\n \"ref\" !== key && (propsWithoutRef[key] = nextProps[key]);\n } else propsWithoutRef = nextProps;\n prepareToReadContext(workInProgress);\n nextProps = renderWithHooks(\n current,\n workInProgress,\n Component,\n propsWithoutRef,\n ref,\n renderLanes\n );\n key = checkDidRenderIdHook();\n if (null !== current && !didReceiveUpdate)\n return (\n bailoutHooks(current, workInProgress, renderLanes),\n bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)\n );\n isHydrating && key && pushMaterializedTreeId(workInProgress);\n workInProgress.flags |= 1;\n reconcileChildren(current, workInProgress, nextProps, renderLanes);\n return workInProgress.child;\n}\nfunction updateMemoComponent(\n current,\n workInProgress,\n Component,\n nextProps,\n renderLanes\n) {\n if (null === current) {\n var type = Component.type;\n if (\n \"function\" === typeof type &&\n !shouldConstruct(type) &&\n void 0 === type.defaultProps &&\n null === Component.compare\n )\n return (\n (workInProgress.tag = 15),\n (workInProgress.type = type),\n updateSimpleMemoComponent(\n current,\n workInProgress,\n type,\n nextProps,\n renderLanes\n )\n );\n current = createFiberFromTypeAndProps(\n Component.type,\n null,\n nextProps,\n workInProgress,\n workInProgress.mode,\n renderLanes\n );\n current.ref = workInProgress.ref;\n current.return = workInProgress;\n return (workInProgress.child = current);\n }\n type = current.child;\n if (!checkScheduledUpdateOrContext(current, renderLanes)) {\n var prevProps = type.memoizedProps;\n Component = Component.compare;\n Component = null !== Component ? Component : shallowEqual;\n if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)\n return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n }\n workInProgress.flags |= 1;\n current = createWorkInProgress(type, nextProps);\n current.ref = workInProgress.ref;\n current.return = workInProgress;\n return (workInProgress.child = current);\n}\nfunction updateSimpleMemoComponent(\n current,\n workInProgress,\n Component,\n nextProps,\n renderLanes\n) {\n if (null !== current) {\n var prevProps = current.memoizedProps;\n if (\n shallowEqual(prevProps, nextProps) &&\n current.ref === workInProgress.ref\n )\n if (\n ((didReceiveUpdate = !1),\n (workInProgress.pendingProps = nextProps = prevProps),\n checkScheduledUpdateOrContext(current, renderLanes))\n )\n 0 !== (current.flags & 131072) && (didReceiveUpdate = !0);\n else\n return (\n (workInProgress.lanes = current.lanes),\n bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)\n );\n }\n return updateFunctionComponent(\n current,\n workInProgress,\n Component,\n nextProps,\n renderLanes\n );\n}\nfunction updateOffscreenComponent(current, workInProgress, renderLanes) {\n var nextProps = workInProgress.pendingProps,\n nextChildren = nextProps.children,\n prevState = null !== current ? current.memoizedState : null;\n if (\"hidden\" === nextProps.mode) {\n if (0 !== (workInProgress.flags & 128)) {\n nextProps =\n null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;\n if (null !== current) {\n nextChildren = workInProgress.child = current.child;\n for (prevState = 0; null !== nextChildren; )\n (prevState =\n prevState | nextChildren.lanes | nextChildren.childLanes),\n (nextChildren = nextChildren.sibling);\n workInProgress.childLanes = prevState & ~nextProps;\n } else (workInProgress.childLanes = 0), (workInProgress.child = null);\n return deferHiddenOffscreenComponent(\n current,\n workInProgress,\n nextProps,\n renderLanes\n );\n }\n if (0 !== (renderLanes & 536870912))\n (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),\n null !== current &&\n pushTransition(\n workInProgress,\n null !== prevState ? prevState.cachePool : null\n ),\n null !== prevState\n ? pushHiddenContext(workInProgress, prevState)\n : reuseHiddenContextOnStack(),\n pushOffscreenSuspenseHandler(workInProgress);\n else\n return (\n (workInProgress.lanes = workInProgress.childLanes = 536870912),\n deferHiddenOffscreenComponent(\n current,\n workInProgress,\n null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,\n renderLanes\n )\n );\n } else\n null !== prevState\n ? (pushTransition(workInProgress, prevState.cachePool),\n pushHiddenContext(workInProgress, prevState),\n reuseSuspenseHandlerOnStack(workInProgress),\n (workInProgress.memoizedState = null))\n : (null !== current && pushTransition(workInProgress, null),\n reuseHiddenContextOnStack(),\n reuseSuspenseHandlerOnStack(workInProgress));\n reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n return workInProgress.child;\n}\nfunction deferHiddenOffscreenComponent(\n current,\n workInProgress,\n nextBaseLanes,\n renderLanes\n) {\n var JSCompiler_inline_result = peekCacheFromPool();\n JSCompiler_inline_result =\n null === JSCompiler_inline_result\n ? null\n : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };\n workInProgress.memoizedState = {\n baseLanes: nextBaseLanes,\n cachePool: JSCompiler_inline_result\n };\n null !== current && pushTransition(workInProgress, null);\n reuseHiddenContextOnStack();\n pushOffscreenSuspenseHandler(workInProgress);\n null !== current &&\n propagateParentContextChanges(current, workInProgress, renderLanes, !0);\n return null;\n}\nfunction markRef(current, workInProgress) {\n var ref = workInProgress.ref;\n if (null === ref)\n null !== current &&\n null !== current.ref &&\n (workInProgress.flags |= 4194816);\n else {\n if (\"function\" !== typeof ref && \"object\" !== typeof ref)\n throw Error(formatProdErrorMessage(284));\n if (null === current || current.ref !== ref)\n workInProgress.flags |= 4194816;\n }\n}\nfunction updateFunctionComponent(\n current,\n workInProgress,\n Component,\n nextProps,\n renderLanes\n) {\n prepareToReadContext(workInProgress);\n Component = renderWithHooks(\n current,\n workInProgress,\n Component,\n nextProps,\n void 0,\n renderLanes\n );\n nextProps = checkDidRenderIdHook();\n if (null !== current && !didReceiveUpdate)\n return (\n bailoutHooks(current, workInProgress, renderLanes),\n bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)\n );\n isHydrating && nextProps && pushMaterializedTreeId(workInProgress);\n workInProgress.flags |= 1;\n reconcileChildren(current, workInProgress, Component, renderLanes);\n return workInProgress.child;\n}\nfunction replayFunctionComponent(\n current,\n workInProgress,\n nextProps,\n Component,\n secondArg,\n renderLanes\n) {\n prepareToReadContext(workInProgress);\n workInProgress.updateQueue = null;\n nextProps = renderWithHooksAgain(\n workInProgress,\n Component,\n nextProps,\n secondArg\n );\n finishRenderingHooks(current);\n Component = checkDidRenderIdHook();\n if (null !== current && !didReceiveUpdate)\n return (\n bailoutHooks(current, workInProgress, renderLanes),\n bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)\n );\n isHydrating && Component && pushMaterializedTreeId(workInProgress);\n workInProgress.flags |= 1;\n reconcileChildren(current, workInProgress, nextProps, renderLanes);\n return workInProgress.child;\n}\nfunction updateClassComponent(\n current,\n workInProgress,\n Component,\n nextProps,\n renderLanes\n) {\n prepareToReadContext(workInProgress);\n if (null === workInProgress.stateNode) {\n var context = emptyContextObject,\n contextType = Component.contextType;\n \"object\" === typeof contextType &&\n null !== contextType &&\n (context = readContext(contextType));\n context = new Component(nextProps, context);\n workInProgress.memoizedState =\n null !== context.state && void 0 !== context.state ? context.state : null;\n context.updater = classComponentUpdater;\n workInProgress.stateNode = context;\n context._reactInternals = workInProgress;\n context = workInProgress.stateNode;\n context.props = nextProps;\n context.state = workInProgress.memoizedState;\n context.refs = {};\n initializeUpdateQueue(workInProgress);\n contextType = Component.contextType;\n context.context =\n \"object\" === typeof contextType && null !== contextType\n ? readContext(contextType)\n : emptyContextObject;\n context.state = workInProgress.memoizedState;\n contextType = Component.getDerivedStateFromProps;\n \"function\" === typeof contextType &&\n (applyDerivedStateFromProps(\n workInProgress,\n Component,\n contextType,\n nextProps\n ),\n (context.state = workInProgress.memoizedState));\n \"function\" === typeof Component.getDerivedStateFromProps ||\n \"function\" === typeof context.getSnapshotBeforeUpdate ||\n (\"function\" !== typeof context.UNSAFE_componentWillMount &&\n \"function\" !== typeof context.componentWillMount) ||\n ((contextType = context.state),\n \"function\" === typeof context.componentWillMount &&\n context.componentWillMount(),\n \"function\" === typeof context.UNSAFE_componentWillMount &&\n context.UNSAFE_componentWillMount(),\n contextType !== context.state &&\n classComponentUpdater.enqueueReplaceState(context, context.state, null),\n processUpdateQueue(workInProgress, nextProps, context, renderLanes),\n suspendIfUpdateReadFromEntangledAsyncAction(),\n (context.state = workInProgress.memoizedState));\n \"function\" === typeof context.componentDidMount &&\n (workInProgress.flags |= 4194308);\n nextProps = !0;\n } else if (null === current) {\n context = workInProgress.stateNode;\n var unresolvedOldProps = workInProgress.memoizedProps,\n oldProps = resolveClassComponentProps(Component, unresolvedOldProps);\n context.props = oldProps;\n var oldContext = context.context,\n contextType$jscomp$0 = Component.contextType;\n contextType = emptyContextObject;\n \"object\" === typeof contextType$jscomp$0 &&\n null !== contextType$jscomp$0 &&\n (contextType = readContext(contextType$jscomp$0));\n var getDerivedStateFromProps = Component.getDerivedStateFromProps;\n contextType$jscomp$0 =\n \"function\" === typeof getDerivedStateFromProps ||\n \"function\" === typeof context.getSnapshotBeforeUpdate;\n unresolvedOldProps = workInProgress.pendingProps !== unresolvedOldProps;\n contextType$jscomp$0 ||\n (\"function\" !== typeof context.UNSAFE_componentWillReceiveProps &&\n \"function\" !== typeof context.componentWillReceiveProps) ||\n ((unresolvedOldProps || oldContext !== contextType) &&\n callComponentWillReceiveProps(\n workInProgress,\n context,\n nextProps,\n contextType\n ));\n hasForceUpdate = !1;\n var oldState = workInProgress.memoizedState;\n context.state = oldState;\n processUpdateQueue(workInProgress, nextProps, context, renderLanes);\n suspendIfUpdateReadFromEntangledAsyncAction();\n oldContext = workInProgress.memoizedState;\n unresolvedOldProps || oldState !== oldContext || hasForceUpdate\n ? (\"function\" === typeof getDerivedStateFromProps &&\n (applyDerivedStateFromProps(\n workInProgress,\n Component,\n getDerivedStateFromProps,\n nextProps\n ),\n (oldContext = workInProgress.memoizedState)),\n (oldProps =\n hasForceUpdate ||\n checkShouldComponentUpdate(\n workInProgress,\n Component,\n oldProps,\n nextProps,\n oldState,\n oldContext,\n contextType\n ))\n ? (contextType$jscomp$0 ||\n (\"function\" !== typeof context.UNSAFE_componentWillMount &&\n \"function\" !== typeof context.componentWillMount) ||\n (\"function\" === typeof context.componentWillMount &&\n context.componentWillMount(),\n \"function\" === typeof context.UNSAFE_componentWillMount &&\n context.UNSAFE_componentWillMount()),\n \"function\" === typeof context.componentDidMount &&\n (workInProgress.flags |= 4194308))\n : (\"function\" === typeof context.componentDidMount &&\n (workInProgress.flags |= 4194308),\n (workInProgress.memoizedProps = nextProps),\n (workInProgress.memoizedState = oldContext)),\n (context.props = nextProps),\n (context.state = oldContext),\n (context.context = contextType),\n (nextProps = oldProps))\n : (\"function\" === typeof context.componentDidMount &&\n (workInProgress.flags |= 4194308),\n (nextProps = !1));\n } else {\n context = workInProgress.stateNode;\n cloneUpdateQueue(current, workInProgress);\n contextType = workInProgress.memoizedProps;\n contextType$jscomp$0 = resolveClassComponentProps(Component, contextType);\n context.props = contextType$jscomp$0;\n getDerivedStateFromProps = workInProgress.pendingProps;\n oldState = context.context;\n oldContext = Component.contextType;\n oldProps = emptyContextObject;\n \"object\" === typeof oldContext &&\n null !== oldContext &&\n (oldProps = readContext(oldContext));\n unresolvedOldProps = Component.getDerivedStateFromProps;\n (oldContext =\n \"function\" === typeof unresolvedOldProps ||\n \"function\" === typeof context.getSnapshotBeforeUpdate) ||\n (\"function\" !== typeof context.UNSAFE_componentWillReceiveProps &&\n \"function\" !== typeof context.componentWillReceiveProps) ||\n ((contextType !== getDerivedStateFromProps || oldState !== oldProps) &&\n callComponentWillReceiveProps(\n workInProgress,\n context,\n nextProps,\n oldProps\n ));\n hasForceUpdate = !1;\n oldState = workInProgress.memoizedState;\n context.state = oldState;\n processUpdateQueue(workInProgress, nextProps, context, renderLanes);\n suspendIfUpdateReadFromEntangledAsyncAction();\n var newState = workInProgress.memoizedState;\n contextType !== getDerivedStateFromProps ||\n oldState !== newState ||\n hasForceUpdate ||\n (null !== current &&\n null !== current.dependencies &&\n checkIfContextChanged(current.dependencies))\n ? (\"function\" === typeof unresolvedOldProps &&\n (applyDerivedStateFromProps(\n workInProgress,\n Component,\n unresolvedOldProps,\n nextProps\n ),\n (newState = workInProgress.memoizedState)),\n (contextType$jscomp$0 =\n hasForceUpdate ||\n checkShouldComponentUpdate(\n workInProgress,\n Component,\n contextType$jscomp$0,\n nextProps,\n oldState,\n newState,\n oldProps\n ) ||\n (null !== current &&\n null !== current.dependencies &&\n checkIfContextChanged(current.dependencies)))\n ? (oldContext ||\n (\"function\" !== typeof context.UNSAFE_componentWillUpdate &&\n \"function\" !== typeof context.componentWillUpdate) ||\n (\"function\" === typeof context.componentWillUpdate &&\n context.componentWillUpdate(nextProps, newState, oldProps),\n \"function\" === typeof context.UNSAFE_componentWillUpdate &&\n context.UNSAFE_componentWillUpdate(\n nextProps,\n newState,\n oldProps\n )),\n \"function\" === typeof context.componentDidUpdate &&\n (workInProgress.flags |= 4),\n \"function\" === typeof context.getSnapshotBeforeUpdate &&\n (workInProgress.flags |= 1024))\n : (\"function\" !== typeof context.componentDidUpdate ||\n (contextType === current.memoizedProps &&\n oldState === current.memoizedState) ||\n (workInProgress.flags |= 4),\n \"function\" !== typeof context.getSnapshotBeforeUpdate ||\n (contextType === current.memoizedProps &&\n oldState === current.memoizedState) ||\n (workInProgress.flags |= 1024),\n (workInProgress.memoizedProps = nextProps),\n (workInProgress.memoizedState = newState)),\n (context.props = nextProps),\n (context.state = newState),\n (context.context = oldProps),\n (nextProps = contextType$jscomp$0))\n : (\"function\" !== typeof context.componentDidUpdate ||\n (contextType === current.memoizedProps &&\n oldState === current.memoizedState) ||\n (workInProgress.flags |= 4),\n \"function\" !== typeof context.getSnapshotBeforeUpdate ||\n (contextType === current.memoizedProps &&\n oldState === current.memoizedState) ||\n (workInProgress.flags |= 1024),\n (nextProps = !1));\n }\n context = nextProps;\n markRef(current, workInProgress);\n nextProps = 0 !== (workInProgress.flags & 128);\n context || nextProps\n ? ((context = workInProgress.stateNode),\n (Component =\n nextProps && \"function\" !== typeof Component.getDerivedStateFromError\n ? null\n : context.render()),\n (workInProgress.flags |= 1),\n null !== current && nextProps\n ? ((workInProgress.child = reconcileChildFibers(\n workInProgress,\n current.child,\n null,\n renderLanes\n )),\n (workInProgress.child = reconcileChildFibers(\n workInProgress,\n null,\n Component,\n renderLanes\n )))\n : reconcileChildren(current, workInProgress, Component, renderLanes),\n (workInProgress.memoizedState = context.state),\n (current = workInProgress.child))\n : (current = bailoutOnAlreadyFinishedWork(\n current,\n workInProgress,\n renderLanes\n ));\n return current;\n}\nfunction mountHostRootWithoutHydrating(\n current,\n workInProgress,\n nextChildren,\n renderLanes\n) {\n resetHydrationState();\n workInProgress.flags |= 256;\n reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n return workInProgress.child;\n}\nvar SUSPENDED_MARKER = {\n dehydrated: null,\n treeContext: null,\n retryLane: 0,\n hydrationErrors: null\n};\nfunction mountSuspenseOffscreenState(renderLanes) {\n return { baseLanes: renderLanes, cachePool: getSuspendedCache() };\n}\nfunction getRemainingWorkInPrimaryTree(\n current,\n primaryTreeDidDefer,\n renderLanes\n) {\n current = null !== current ? current.childLanes & ~renderLanes : 0;\n primaryTreeDidDefer && (current |= workInProgressDeferredLane);\n return current;\n}\nfunction updateSuspenseComponent(current, workInProgress, renderLanes) {\n var nextProps = workInProgress.pendingProps,\n showFallback = !1,\n didSuspend = 0 !== (workInProgress.flags & 128),\n JSCompiler_temp;\n (JSCompiler_temp = didSuspend) ||\n (JSCompiler_temp =\n null !== current && null === current.memoizedState\n ? !1\n : 0 !== (suspenseStackCursor.current & 2));\n JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));\n JSCompiler_temp = 0 !== (workInProgress.flags & 32);\n workInProgress.flags &= -33;\n if (null === current) {\n if (isHydrating) {\n showFallback\n ? pushPrimaryTreeSuspenseHandler(workInProgress)\n : reuseSuspenseHandlerOnStack(workInProgress);\n if (isHydrating) {\n var nextInstance = nextHydratableInstance,\n JSCompiler_temp$jscomp$0;\n if ((JSCompiler_temp$jscomp$0 = nextInstance)) {\n c: {\n JSCompiler_temp$jscomp$0 = nextInstance;\n for (\n nextInstance = rootOrSingletonContext;\n 8 !== JSCompiler_temp$jscomp$0.nodeType;\n\n ) {\n if (!nextInstance) {\n nextInstance = null;\n break c;\n }\n JSCompiler_temp$jscomp$0 = getNextHydratable(\n JSCompiler_temp$jscomp$0.nextSibling\n );\n if (null === JSCompiler_temp$jscomp$0) {\n nextInstance = null;\n break c;\n }\n }\n nextInstance = JSCompiler_temp$jscomp$0;\n }\n null !== nextInstance\n ? ((workInProgress.memoizedState = {\n dehydrated: nextInstance,\n treeContext:\n null !== treeContextProvider\n ? { id: treeContextId, overflow: treeContextOverflow }\n : null,\n retryLane: 536870912,\n hydrationErrors: null\n }),\n (JSCompiler_temp$jscomp$0 = createFiberImplClass(\n 18,\n null,\n null,\n 0\n )),\n (JSCompiler_temp$jscomp$0.stateNode = nextInstance),\n (JSCompiler_temp$jscomp$0.return = workInProgress),\n (workInProgress.child = JSCompiler_temp$jscomp$0),\n (hydrationParentFiber = workInProgress),\n (nextHydratableInstance = null),\n (JSCompiler_temp$jscomp$0 = !0))\n : (JSCompiler_temp$jscomp$0 = !1);\n }\n JSCompiler_temp$jscomp$0 || throwOnHydrationMismatch(workInProgress);\n }\n nextInstance = workInProgress.memoizedState;\n if (\n null !== nextInstance &&\n ((nextInstance = nextInstance.dehydrated), null !== nextInstance)\n )\n return (\n isSuspenseInstanceFallback(nextInstance)\n ? (workInProgress.lanes = 32)\n : (workInProgress.lanes = 536870912),\n null\n );\n popSuspenseHandler(workInProgress);\n }\n nextInstance = nextProps.children;\n nextProps = nextProps.fallback;\n if (showFallback)\n return (\n reuseSuspenseHandlerOnStack(workInProgress),\n (showFallback = workInProgress.mode),\n (nextInstance = mountWorkInProgressOffscreenFiber(\n { mode: \"hidden\", children: nextInstance },\n showFallback\n )),\n (nextProps = createFiberFromFragment(\n nextProps,\n showFallback,\n renderLanes,\n null\n )),\n (nextInstance.return = workInProgress),\n (nextProps.return = workInProgress),\n (nextInstance.sibling = nextProps),\n (workInProgress.child = nextInstance),\n (showFallback = workInProgress.child),\n (showFallback.memoizedState = mountSuspenseOffscreenState(renderLanes)),\n (showFallback.childLanes = getRemainingWorkInPrimaryTree(\n current,\n JSCompiler_temp,\n renderLanes\n )),\n (workInProgress.memoizedState = SUSPENDED_MARKER),\n nextProps\n );\n pushPrimaryTreeSuspenseHandler(workInProgress);\n return mountSuspensePrimaryChildren(workInProgress, nextInstance);\n }\n JSCompiler_temp$jscomp$0 = current.memoizedState;\n if (\n null !== JSCompiler_temp$jscomp$0 &&\n ((nextInstance = JSCompiler_temp$jscomp$0.dehydrated),\n null !== nextInstance)\n ) {\n if (didSuspend)\n workInProgress.flags & 256\n ? (pushPrimaryTreeSuspenseHandler(workInProgress),\n (workInProgress.flags &= -257),\n (workInProgress = retrySuspenseComponentWithoutHydrating(\n current,\n workInProgress,\n renderLanes\n )))\n : null !== workInProgress.memoizedState\n ? (reuseSuspenseHandlerOnStack(workInProgress),\n (workInProgress.child = current.child),\n (workInProgress.flags |= 128),\n (workInProgress = null))\n : (reuseSuspenseHandlerOnStack(workInProgress),\n (showFallback = nextProps.fallback),\n (nextInstance = workInProgress.mode),\n (nextProps = mountWorkInProgressOffscreenFiber(\n { mode: \"visible\", children: nextProps.children },\n nextInstance\n )),\n (showFallback = createFiberFromFragment(\n showFallback,\n nextInstance,\n renderLanes,\n null\n )),\n (showFallback.flags |= 2),\n (nextProps.return = workInProgress),\n (showFallback.return = workInProgress),\n (nextProps.sibling = showFallback),\n (workInProgress.child = nextProps),\n reconcileChildFibers(\n workInProgress,\n current.child,\n null,\n renderLanes\n ),\n (nextProps = workInProgress.child),\n (nextProps.memoizedState =\n mountSuspenseOffscreenState(renderLanes)),\n (nextProps.childLanes = getRemainingWorkInPrimaryTree(\n current,\n JSCompiler_temp,\n renderLanes\n )),\n (workInProgress.memoizedState = SUSPENDED_MARKER),\n (workInProgress = showFallback));\n else if (\n (pushPrimaryTreeSuspenseHandler(workInProgress),\n isSuspenseInstanceFallback(nextInstance))\n ) {\n JSCompiler_temp =\n nextInstance.nextSibling && nextInstance.nextSibling.dataset;\n if (JSCompiler_temp) var digest = JSCompiler_temp.dgst;\n JSCompiler_temp = digest;\n nextProps = Error(formatProdErrorMessage(419));\n nextProps.stack = \"\";\n nextProps.digest = JSCompiler_temp;\n queueHydrationError({ value: nextProps, source: null, stack: null });\n workInProgress = retrySuspenseComponentWithoutHydrating(\n current,\n workInProgress,\n renderLanes\n );\n } else if (\n (didReceiveUpdate ||\n propagateParentContextChanges(current, workInProgress, renderLanes, !1),\n (JSCompiler_temp = 0 !== (renderLanes & current.childLanes)),\n didReceiveUpdate || JSCompiler_temp)\n ) {\n JSCompiler_temp = workInProgressRoot;\n if (\n null !== JSCompiler_temp &&\n ((nextProps = renderLanes & -renderLanes),\n (nextProps =\n 0 !== (nextProps & 42)\n ? 1\n : getBumpedLaneForHydrationByLane(nextProps)),\n (nextProps =\n 0 !== (nextProps & (JSCompiler_temp.suspendedLanes | renderLanes))\n ? 0\n : nextProps),\n 0 !== nextProps && nextProps !== JSCompiler_temp$jscomp$0.retryLane)\n )\n throw (\n ((JSCompiler_temp$jscomp$0.retryLane = nextProps),\n enqueueConcurrentRenderForLane(current, nextProps),\n scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps),\n SelectiveHydrationException)\n );\n \"$?\" === nextInstance.data || renderDidSuspendDelayIfPossible();\n workInProgress = retrySuspenseComponentWithoutHydrating(\n current,\n workInProgress,\n renderLanes\n );\n } else\n \"$?\" === nextInstance.data\n ? ((workInProgress.flags |= 192),\n (workInProgress.child = current.child),\n (workInProgress = null))\n : ((current = JSCompiler_temp$jscomp$0.treeContext),\n (nextHydratableInstance = getNextHydratable(\n nextInstance.nextSibling\n )),\n (hydrationParentFiber = workInProgress),\n (isHydrating = !0),\n (hydrationErrors = null),\n (rootOrSingletonContext = !1),\n null !== current &&\n ((idStack[idStackIndex++] = treeContextId),\n (idStack[idStackIndex++] = treeContextOverflow),\n (idStack[idStackIndex++] = treeContextProvider),\n (treeContextId = current.id),\n (treeContextOverflow = current.overflow),\n (treeContextProvider = workInProgress)),\n (workInProgress = mountSuspensePrimaryChildren(\n workInProgress,\n nextProps.children\n )),\n (workInProgress.flags |= 4096));\n return workInProgress;\n }\n if (showFallback)\n return (\n reuseSuspenseHandlerOnStack(workInProgress),\n (showFallback = nextProps.fallback),\n (nextInstance = workInProgress.mode),\n (JSCompiler_temp$jscomp$0 = current.child),\n (digest = JSCompiler_temp$jscomp$0.sibling),\n (nextProps = createWorkInProgress(JSCompiler_temp$jscomp$0, {\n mode: \"hidden\",\n children: nextProps.children\n })),\n (nextProps.subtreeFlags =\n JSCompiler_temp$jscomp$0.subtreeFlags & 65011712),\n null !== digest\n ? (showFallback = createWorkInProgress(digest, showFallback))\n : ((showFallback = createFiberFromFragment(\n showFallback,\n nextInstance,\n renderLanes,\n null\n )),\n (showFallback.flags |= 2)),\n (showFallback.return = workInProgress),\n (nextProps.return = workInProgress),\n (nextProps.sibling = showFallback),\n (workInProgress.child = nextProps),\n (nextProps = showFallback),\n (showFallback = workInProgress.child),\n (nextInstance = current.child.memoizedState),\n null === nextInstance\n ? (nextInstance = mountSuspenseOffscreenState(renderLanes))\n : ((JSCompiler_temp$jscomp$0 = nextInstance.cachePool),\n null !== JSCompiler_temp$jscomp$0\n ? ((digest = CacheContext._currentValue),\n (JSCompiler_temp$jscomp$0 =\n JSCompiler_temp$jscomp$0.parent !== digest\n ? { parent: digest, pool: digest }\n : JSCompiler_temp$jscomp$0))\n : (JSCompiler_temp$jscomp$0 = getSuspendedCache()),\n (nextInstance = {\n baseLanes: nextInstance.baseLanes | renderLanes,\n cachePool: JSCompiler_temp$jscomp$0\n })),\n (showFallback.memoizedState = nextInstance),\n (showFallback.childLanes = getRemainingWorkInPrimaryTree(\n current,\n JSCompiler_temp,\n renderLanes\n )),\n (workInProgress.memoizedState = SUSPENDED_MARKER),\n nextProps\n );\n pushPrimaryTreeSuspenseHandler(workInProgress);\n renderLanes = current.child;\n current = renderLanes.sibling;\n renderLanes = createWorkInProgress(renderLanes, {\n mode: \"visible\",\n children: nextProps.children\n });\n renderLanes.return = workInProgress;\n renderLanes.sibling = null;\n null !== current &&\n ((JSCompiler_temp = workInProgress.deletions),\n null === JSCompiler_temp\n ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))\n : JSCompiler_temp.push(current));\n workInProgress.child = renderLanes;\n workInProgress.memoizedState = null;\n return renderLanes;\n}\nfunction mountSuspensePrimaryChildren(workInProgress, primaryChildren) {\n primaryChildren = mountWorkInProgressOffscreenFiber(\n { mode: \"visible\", children: primaryChildren },\n workInProgress.mode\n );\n primaryChildren.return = workInProgress;\n return (workInProgress.child = primaryChildren);\n}\nfunction mountWorkInProgressOffscreenFiber(offscreenProps, mode) {\n offscreenProps = createFiberImplClass(22, offscreenProps, null, mode);\n offscreenProps.lanes = 0;\n offscreenProps.stateNode = {\n _visibility: 1,\n _pendingMarkers: null,\n _retryCache: null,\n _transitions: null\n };\n return offscreenProps;\n}\nfunction retrySuspenseComponentWithoutHydrating(\n current,\n workInProgress,\n renderLanes\n) {\n reconcileChildFibers(workInProgress, current.child, null, renderLanes);\n current = mountSuspensePrimaryChildren(\n workInProgress,\n workInProgress.pendingProps.children\n );\n current.flags |= 2;\n workInProgress.memoizedState = null;\n return current;\n}\nfunction scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {\n fiber.lanes |= renderLanes;\n var alternate = fiber.alternate;\n null !== alternate && (alternate.lanes |= renderLanes);\n scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);\n}\nfunction initSuspenseListRenderState(\n workInProgress,\n isBackwards,\n tail,\n lastContentRow,\n tailMode\n) {\n var renderState = workInProgress.memoizedState;\n null === renderState\n ? (workInProgress.memoizedState = {\n isBackwards: isBackwards,\n rendering: null,\n renderingStartTime: 0,\n last: lastContentRow,\n tail: tail,\n tailMode: tailMode\n })\n : ((renderState.isBackwards = isBackwards),\n (renderState.rendering = null),\n (renderState.renderingStartTime = 0),\n (renderState.last = lastContentRow),\n (renderState.tail = tail),\n (renderState.tailMode = tailMode));\n}\nfunction updateSuspenseListComponent(current, workInProgress, renderLanes) {\n var nextProps = workInProgress.pendingProps,\n revealOrder = nextProps.revealOrder,\n tailMode = nextProps.tail;\n reconcileChildren(current, workInProgress, nextProps.children, renderLanes);\n nextProps = suspenseStackCursor.current;\n if (0 !== (nextProps & 2))\n (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);\n else {\n if (null !== current && 0 !== (current.flags & 128))\n a: for (current = workInProgress.child; null !== current; ) {\n if (13 === current.tag)\n null !== current.memoizedState &&\n scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);\n else if (19 === current.tag)\n scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);\n else if (null !== current.child) {\n current.child.return = current;\n current = current.child;\n continue;\n }\n if (current === workInProgress) break a;\n for (; null === current.sibling; ) {\n if (null === current.return || current.return === workInProgress)\n break a;\n current = current.return;\n }\n current.sibling.return = current.return;\n current = current.sibling;\n }\n nextProps &= 1;\n }\n push(suspenseStackCursor, nextProps);\n switch (revealOrder) {\n case \"forwards\":\n renderLanes = workInProgress.child;\n for (revealOrder = null; null !== renderLanes; )\n (current = renderLanes.alternate),\n null !== current &&\n null === findFirstSuspended(current) &&\n (revealOrder = renderLanes),\n (renderLanes = renderLanes.sibling);\n renderLanes = revealOrder;\n null === renderLanes\n ? ((revealOrder = workInProgress.child), (workInProgress.child = null))\n : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));\n initSuspenseListRenderState(\n workInProgress,\n !1,\n revealOrder,\n renderLanes,\n tailMode\n );\n break;\n case \"backwards\":\n renderLanes = null;\n revealOrder = workInProgress.child;\n for (workInProgress.child = null; null !== revealOrder; ) {\n current = revealOrder.alternate;\n if (null !== current && null === findFirstSuspended(current)) {\n workInProgress.child = revealOrder;\n break;\n }\n current = revealOrder.sibling;\n revealOrder.sibling = renderLanes;\n renderLanes = revealOrder;\n revealOrder = current;\n }\n initSuspenseListRenderState(\n workInProgress,\n !0,\n renderLanes,\n null,\n tailMode\n );\n break;\n case \"together\":\n initSuspenseListRenderState(workInProgress, !1, null, null, void 0);\n break;\n default:\n workInProgress.memoizedState = null;\n }\n return workInProgress.child;\n}\nfunction bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {\n null !== current && (workInProgress.dependencies = current.dependencies);\n workInProgressRootSkippedLanes |= workInProgress.lanes;\n if (0 === (renderLanes & workInProgress.childLanes))\n if (null !== current) {\n if (\n (propagateParentContextChanges(\n current,\n workInProgress,\n renderLanes,\n !1\n ),\n 0 === (renderLanes & workInProgress.childLanes))\n )\n return null;\n } else return null;\n if (null !== current && workInProgress.child !== current.child)\n throw Error(formatProdErrorMessage(153));\n if (null !== workInProgress.child) {\n current = workInProgress.child;\n renderLanes = createWorkInProgress(current, current.pendingProps);\n workInProgress.child = renderLanes;\n for (renderLanes.return = workInProgress; null !== current.sibling; )\n (current = current.sibling),\n (renderLanes = renderLanes.sibling =\n createWorkInProgress(current, current.pendingProps)),\n (renderLanes.return = workInProgress);\n renderLanes.sibling = null;\n }\n return workInProgress.child;\n}\nfunction checkScheduledUpdateOrContext(current, renderLanes) {\n if (0 !== (current.lanes & renderLanes)) return !0;\n current = current.dependencies;\n return null !== current && checkIfContextChanged(current) ? !0 : !1;\n}\nfunction attemptEarlyBailoutIfNoScheduledUpdate(\n current,\n workInProgress,\n renderLanes\n) {\n switch (workInProgress.tag) {\n case 3:\n pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);\n pushProvider(workInProgress, CacheContext, current.memoizedState.cache);\n resetHydrationState();\n break;\n case 27:\n case 5:\n pushHostContext(workInProgress);\n break;\n case 4:\n pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);\n break;\n case 10:\n pushProvider(\n workInProgress,\n workInProgress.type,\n workInProgress.memoizedProps.value\n );\n break;\n case 13:\n var state = workInProgress.memoizedState;\n if (null !== state) {\n if (null !== state.dehydrated)\n return (\n pushPrimaryTreeSuspenseHandler(workInProgress),\n (workInProgress.flags |= 128),\n null\n );\n if (0 !== (renderLanes & workInProgress.child.childLanes))\n return updateSuspenseComponent(current, workInProgress, renderLanes);\n pushPrimaryTreeSuspenseHandler(workInProgress);\n current = bailoutOnAlreadyFinishedWork(\n current,\n workInProgress,\n renderLanes\n );\n return null !== current ? current.sibling : null;\n }\n pushPrimaryTreeSuspenseHandler(workInProgress);\n break;\n case 19:\n var didSuspendBefore = 0 !== (current.flags & 128);\n state = 0 !== (renderLanes & workInProgress.childLanes);\n state ||\n (propagateParentContextChanges(\n current,\n workInProgress,\n renderLanes,\n !1\n ),\n (state = 0 !== (renderLanes & workInProgress.childLanes)));\n if (didSuspendBefore) {\n if (state)\n return updateSuspenseListComponent(\n current,\n workInProgress,\n renderLanes\n );\n workInProgress.flags |= 128;\n }\n didSuspendBefore = workInProgress.memoizedState;\n null !== didSuspendBefore &&\n ((didSuspendBefore.rendering = null),\n (didSuspendBefore.tail = null),\n (didSuspendBefore.lastEffect = null));\n push(suspenseStackCursor, suspenseStackCursor.current);\n if (state) break;\n else return null;\n case 22:\n case 23:\n return (\n (workInProgress.lanes = 0),\n updateOffscreenComponent(current, workInProgress, renderLanes)\n );\n case 24:\n pushProvider(workInProgress, CacheContext, current.memoizedState.cache);\n }\n return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n}\nfunction beginWork(current, workInProgress, renderLanes) {\n if (null !== current)\n if (current.memoizedProps !== workInProgress.pendingProps)\n didReceiveUpdate = !0;\n else {\n if (\n !checkScheduledUpdateOrContext(current, renderLanes) &&\n 0 === (workInProgress.flags & 128)\n )\n return (\n (didReceiveUpdate = !1),\n attemptEarlyBailoutIfNoScheduledUpdate(\n current,\n workInProgress,\n renderLanes\n )\n );\n didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;\n }\n else\n (didReceiveUpdate = !1),\n isHydrating &&\n 0 !== (workInProgress.flags & 1048576) &&\n pushTreeId(workInProgress, treeForkCount, workInProgress.index);\n workInProgress.lanes = 0;\n switch (workInProgress.tag) {\n case 16:\n a: {\n current = workInProgress.pendingProps;\n var lazyComponent = workInProgress.elementType,\n init = lazyComponent._init;\n lazyComponent = init(lazyComponent._payload);\n workInProgress.type = lazyComponent;\n if (\"function\" === typeof lazyComponent)\n shouldConstruct(lazyComponent)\n ? ((current = resolveClassComponentProps(lazyComponent, current)),\n (workInProgress.tag = 1),\n (workInProgress = updateClassComponent(\n null,\n workInProgress,\n lazyComponent,\n current,\n renderLanes\n )))\n : ((workInProgress.tag = 0),\n (workInProgress = updateFunctionComponent(\n null,\n workInProgress,\n lazyComponent,\n current,\n renderLanes\n )));\n else {\n if (void 0 !== lazyComponent && null !== lazyComponent)\n if (\n ((init = lazyComponent.$$typeof), init === REACT_FORWARD_REF_TYPE)\n ) {\n workInProgress.tag = 11;\n workInProgress = updateForwardRef(\n null,\n workInProgress,\n lazyComponent,\n current,\n renderLanes\n );\n break a;\n } else if (init === REACT_MEMO_TYPE) {\n workInProgress.tag = 14;\n workInProgress = updateMemoComponent(\n null,\n workInProgress,\n lazyComponent,\n current,\n renderLanes\n );\n break a;\n }\n workInProgress =\n getComponentNameFromType(lazyComponent) || lazyComponent;\n throw Error(formatProdErrorMessage(306, workInProgress, \"\"));\n }\n }\n return workInProgress;\n case 0:\n return updateFunctionComponent(\n current,\n workInProgress,\n workInProgress.type,\n workInProgress.pendingProps,\n renderLanes\n );\n case 1:\n return (\n (lazyComponent = workInProgress.type),\n (init = resolveClassComponentProps(\n lazyComponent,\n workInProgress.pendingProps\n )),\n updateClassComponent(\n current,\n workInProgress,\n lazyComponent,\n init,\n renderLanes\n )\n );\n case 3:\n a: {\n pushHostContainer(\n workInProgress,\n workInProgress.stateNode.containerInfo\n );\n if (null === current) throw Error(formatProdErrorMessage(387));\n lazyComponent = workInProgress.pendingProps;\n var prevState = workInProgress.memoizedState;\n init = prevState.element;\n cloneUpdateQueue(current, workInProgress);\n processUpdateQueue(workInProgress, lazyComponent, null, renderLanes);\n var nextState = workInProgress.memoizedState;\n lazyComponent = nextState.cache;\n pushProvider(workInProgress, CacheContext, lazyComponent);\n lazyComponent !== prevState.cache &&\n propagateContextChanges(\n workInProgress,\n [CacheContext],\n renderLanes,\n !0\n );\n suspendIfUpdateReadFromEntangledAsyncAction();\n lazyComponent = nextState.element;\n if (prevState.isDehydrated)\n if (\n ((prevState = {\n element: lazyComponent,\n isDehydrated: !1,\n cache: nextState.cache\n }),\n (workInProgress.updateQueue.baseState = prevState),\n (workInProgress.memoizedState = prevState),\n workInProgress.flags & 256)\n ) {\n workInProgress = mountHostRootWithoutHydrating(\n current,\n workInProgress,\n lazyComponent,\n renderLanes\n );\n break a;\n } else if (lazyComponent !== init) {\n init = createCapturedValueAtFiber(\n Error(formatProdErrorMessage(424)),\n workInProgress\n );\n queueHydrationError(init);\n workInProgress = mountHostRootWithoutHydrating(\n current,\n workInProgress,\n lazyComponent,\n renderLanes\n );\n break a;\n } else {\n current = workInProgress.stateNode.containerInfo;\n switch (current.nodeType) {\n case 9:\n current = current.body;\n break;\n default:\n current =\n \"HTML\" === current.nodeName\n ? current.ownerDocument.body\n : current;\n }\n nextHydratableInstance = getNextHydratable(current.firstChild);\n hydrationParentFiber = workInProgress;\n isHydrating = !0;\n hydrationErrors = null;\n rootOrSingletonContext = !0;\n renderLanes = mountChildFibers(\n workInProgress,\n null,\n lazyComponent,\n renderLanes\n );\n for (workInProgress.child = renderLanes; renderLanes; )\n (renderLanes.flags = (renderLanes.flags & -3) | 4096),\n (renderLanes = renderLanes.sibling);\n }\n else {\n resetHydrationState();\n if (lazyComponent === init) {\n workInProgress = bailoutOnAlreadyFinishedWork(\n current,\n workInProgress,\n renderLanes\n );\n break a;\n }\n reconcileChildren(\n current,\n workInProgress,\n lazyComponent,\n renderLanes\n );\n }\n workInProgress = workInProgress.child;\n }\n return workInProgress;\n case 26:\n return (\n markRef(current, workInProgress),\n null === current\n ? (renderLanes = getResource(\n workInProgress.type,\n null,\n workInProgress.pendingProps,\n null\n ))\n ? (workInProgress.memoizedState = renderLanes)\n : isHydrating ||\n ((renderLanes = workInProgress.type),\n (current = workInProgress.pendingProps),\n (lazyComponent = getOwnerDocumentFromRootContainer(\n rootInstanceStackCursor.current\n ).createElement(renderLanes)),\n (lazyComponent[internalInstanceKey] = workInProgress),\n (lazyComponent[internalPropsKey] = current),\n setInitialProperties(lazyComponent, renderLanes, current),\n markNodeAsHoistable(lazyComponent),\n (workInProgress.stateNode = lazyComponent))\n : (workInProgress.memoizedState = getResource(\n workInProgress.type,\n current.memoizedProps,\n workInProgress.pendingProps,\n current.memoizedState\n )),\n null\n );\n case 27:\n return (\n pushHostContext(workInProgress),\n null === current &&\n isHydrating &&\n ((lazyComponent = workInProgress.stateNode =\n resolveSingletonInstance(\n workInProgress.type,\n workInProgress.pendingProps,\n rootInstanceStackCursor.current\n )),\n (hydrationParentFiber = workInProgress),\n (rootOrSingletonContext = !0),\n (init = nextHydratableInstance),\n isSingletonScope(workInProgress.type)\n ? ((previousHydratableOnEnteringScopedSingleton = init),\n (nextHydratableInstance = getNextHydratable(\n lazyComponent.firstChild\n )))\n : (nextHydratableInstance = init)),\n reconcileChildren(\n current,\n workInProgress,\n workInProgress.pendingProps.children,\n renderLanes\n ),\n markRef(current, workInProgress),\n null === current && (workInProgress.flags |= 4194304),\n workInProgress.child\n );\n case 5:\n if (null === current && isHydrating) {\n if ((init = lazyComponent = nextHydratableInstance))\n (lazyComponent = canHydrateInstance(\n lazyComponent,\n workInProgress.type,\n workInProgress.pendingProps,\n rootOrSingletonContext\n )),\n null !== lazyComponent\n ? ((workInProgress.stateNode = lazyComponent),\n (hydrationParentFiber = workInProgress),\n (nextHydratableInstance = getNextHydratable(\n lazyComponent.firstChild\n )),\n (rootOrSingletonContext = !1),\n (init = !0))\n : (init = !1);\n init || throwOnHydrationMismatch(workInProgress);\n }\n pushHostContext(workInProgress);\n init = workInProgress.type;\n prevState = workInProgress.pendingProps;\n nextState = null !== current ? current.memoizedProps : null;\n lazyComponent = prevState.children;\n shouldSetTextContent(init, prevState)\n ? (lazyComponent = null)\n : null !== nextState &&\n shouldSetTextContent(init, nextState) &&\n (workInProgress.flags |= 32);\n null !== workInProgress.memoizedState &&\n ((init = renderWithHooks(\n current,\n workInProgress,\n TransitionAwareHostComponent,\n null,\n null,\n renderLanes\n )),\n (HostTransitionContext._currentValue = init));\n markRef(current, workInProgress);\n reconcileChildren(current, workInProgress, lazyComponent, renderLanes);\n return workInProgress.child;\n case 6:\n if (null === current && isHydrating) {\n if ((current = renderLanes = nextHydratableInstance))\n (renderLanes = canHydrateTextInstance(\n renderLanes,\n workInProgress.pendingProps,\n rootOrSingletonContext\n )),\n null !== renderLanes\n ? ((workInProgress.stateNode = renderLanes),\n (hydrationParentFiber = workInProgress),\n (nextHydratableInstance = null),\n (current = !0))\n : (current = !1);\n current || throwOnHydrationMismatch(workInProgress);\n }\n return null;\n case 13:\n return updateSuspenseComponent(current, workInProgress, renderLanes);\n case 4:\n return (\n pushHostContainer(\n workInProgress,\n workInProgress.stateNode.containerInfo\n ),\n (lazyComponent = workInProgress.pendingProps),\n null === current\n ? (workInProgress.child = reconcileChildFibers(\n workInProgress,\n null,\n lazyComponent,\n renderLanes\n ))\n : reconcileChildren(\n current,\n workInProgress,\n lazyComponent,\n renderLanes\n ),\n workInProgress.child\n );\n case 11:\n return updateForwardRef(\n current,\n workInProgress,\n workInProgress.type,\n workInProgress.pendingProps,\n renderLanes\n );\n case 7:\n return (\n reconcileChildren(\n current,\n workInProgress,\n workInProgress.pendingProps,\n renderLanes\n ),\n workInProgress.child\n );\n case 8:\n return (\n reconcileChildren(\n current,\n workInProgress,\n workInProgress.pendingProps.children,\n renderLanes\n ),\n workInProgress.child\n );\n case 12:\n return (\n reconcileChildren(\n current,\n workInProgress,\n workInProgress.pendingProps.children,\n renderLanes\n ),\n workInProgress.child\n );\n case 10:\n return (\n (lazyComponent = workInProgress.pendingProps),\n pushProvider(workInProgress, workInProgress.type, lazyComponent.value),\n reconcileChildren(\n current,\n workInProgress,\n lazyComponent.children,\n renderLanes\n ),\n workInProgress.child\n );\n case 9:\n return (\n (init = workInProgress.type._context),\n (lazyComponent = workInProgress.pendingProps.children),\n prepareToReadContext(workInProgress),\n (init = readContext(init)),\n (lazyComponent = lazyComponent(init)),\n (workInProgress.flags |= 1),\n reconcileChildren(current, workInProgress, lazyComponent, renderLanes),\n workInProgress.child\n );\n case 14:\n return updateMemoComponent(\n current,\n workInProgress,\n workInProgress.type,\n workInProgress.pendingProps,\n renderLanes\n );\n case 15:\n return updateSimpleMemoComponent(\n current,\n workInProgress,\n workInProgress.type,\n workInProgress.pendingProps,\n renderLanes\n );\n case 19:\n return updateSuspenseListComponent(current, workInProgress, renderLanes);\n case 31:\n return (\n (lazyComponent = workInProgress.pendingProps),\n (renderLanes = workInProgress.mode),\n (lazyComponent = {\n mode: lazyComponent.mode,\n children: lazyComponent.children\n }),\n null === current\n ? ((renderLanes = mountWorkInProgressOffscreenFiber(\n lazyComponent,\n renderLanes\n )),\n (renderLanes.ref = workInProgress.ref),\n (workInProgress.child = renderLanes),\n (renderLanes.return = workInProgress),\n (workInProgress = renderLanes))\n : ((renderLanes = createWorkInProgress(current.child, lazyComponent)),\n (renderLanes.ref = workInProgress.ref),\n (workInProgress.child = renderLanes),\n (renderLanes.return = workInProgress),\n (workInProgress = renderLanes)),\n workInProgress\n );\n case 22:\n return updateOffscreenComponent(current, workInProgress, renderLanes);\n case 24:\n return (\n prepareToReadContext(workInProgress),\n (lazyComponent = readContext(CacheContext)),\n null === current\n ? ((init = peekCacheFromPool()),\n null === init &&\n ((init = workInProgressRoot),\n (prevState = createCache()),\n (init.pooledCache = prevState),\n prevState.refCount++,\n null !== prevState && (init.pooledCacheLanes |= renderLanes),\n (init = prevState)),\n (workInProgress.memoizedState = {\n parent: lazyComponent,\n cache: init\n }),\n initializeUpdateQueue(workInProgress),\n pushProvider(workInProgress, CacheContext, init))\n : (0 !== (current.lanes & renderLanes) &&\n (cloneUpdateQueue(current, workInProgress),\n processUpdateQueue(workInProgress, null, null, renderLanes),\n suspendIfUpdateReadFromEntangledAsyncAction()),\n (init = current.memoizedState),\n (prevState = workInProgress.memoizedState),\n init.parent !== lazyComponent\n ? ((init = { parent: lazyComponent, cache: lazyComponent }),\n (workInProgress.memoizedState = init),\n 0 === workInProgress.lanes &&\n (workInProgress.memoizedState =\n workInProgress.updateQueue.baseState =\n init),\n pushProvider(workInProgress, CacheContext, lazyComponent))\n : ((lazyComponent = prevState.cache),\n pushProvider(workInProgress, CacheContext, lazyComponent),\n lazyComponent !== init.cache &&\n propagateContextChanges(\n workInProgress,\n [CacheContext],\n renderLanes,\n !0\n ))),\n reconcileChildren(\n current,\n workInProgress,\n workInProgress.pendingProps.children,\n renderLanes\n ),\n workInProgress.child\n );\n case 29:\n throw workInProgress.pendingProps;\n }\n throw Error(formatProdErrorMessage(156, workInProgress.tag));\n}\nfunction markUpdate(workInProgress) {\n workInProgress.flags |= 4;\n}\nfunction preloadResourceAndSuspendIfNeeded(workInProgress, resource) {\n if (\"stylesheet\" !== resource.type || 0 !== (resource.state.loading & 4))\n workInProgress.flags &= -16777217;\n else if (((workInProgress.flags |= 16777216), !preloadResource(resource))) {\n resource = suspenseHandlerStackCursor.current;\n if (\n null !== resource &&\n ((workInProgressRootRenderLanes & 4194048) ===\n workInProgressRootRenderLanes\n ? null !== shellBoundary\n : ((workInProgressRootRenderLanes & 62914560) !==\n workInProgressRootRenderLanes &&\n 0 === (workInProgressRootRenderLanes & 536870912)) ||\n resource !== shellBoundary)\n )\n throw (\n ((suspendedThenable = noopSuspenseyCommitThenable),\n SuspenseyCommitException)\n );\n workInProgress.flags |= 8192;\n }\n}\nfunction scheduleRetryEffect(workInProgress, retryQueue) {\n null !== retryQueue && (workInProgress.flags |= 4);\n workInProgress.flags & 16384 &&\n ((retryQueue =\n 22 !== workInProgress.tag ? claimNextRetryLane() : 536870912),\n (workInProgress.lanes |= retryQueue),\n (workInProgressSuspendedRetryLanes |= retryQueue));\n}\nfunction cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {\n if (!isHydrating)\n switch (renderState.tailMode) {\n case \"hidden\":\n hasRenderedATailFallback = renderState.tail;\n for (var lastTailNode = null; null !== hasRenderedATailFallback; )\n null !== hasRenderedATailFallback.alternate &&\n (lastTailNode = hasRenderedATailFallback),\n (hasRenderedATailFallback = hasRenderedATailFallback.sibling);\n null === lastTailNode\n ? (renderState.tail = null)\n : (lastTailNode.sibling = null);\n break;\n case \"collapsed\":\n lastTailNode = renderState.tail;\n for (var lastTailNode$113 = null; null !== lastTailNode; )\n null !== lastTailNode.alternate && (lastTailNode$113 = lastTailNode),\n (lastTailNode = lastTailNode.sibling);\n null === lastTailNode$113\n ? hasRenderedATailFallback || null === renderState.tail\n ? (renderState.tail = null)\n : (renderState.tail.sibling = null)\n : (lastTailNode$113.sibling = null);\n }\n}\nfunction bubbleProperties(completedWork) {\n var didBailout =\n null !== completedWork.alternate &&\n completedWork.alternate.child === completedWork.child,\n newChildLanes = 0,\n subtreeFlags = 0;\n if (didBailout)\n for (var child$114 = completedWork.child; null !== child$114; )\n (newChildLanes |= child$114.lanes | child$114.childLanes),\n (subtreeFlags |= child$114.subtreeFlags & 65011712),\n (subtreeFlags |= child$114.flags & 65011712),\n (child$114.return = completedWork),\n (child$114 = child$114.sibling);\n else\n for (child$114 = completedWork.child; null !== child$114; )\n (newChildLanes |= child$114.lanes | child$114.childLanes),\n (subtreeFlags |= child$114.subtreeFlags),\n (subtreeFlags |= child$114.flags),\n (child$114.return = completedWork),\n (child$114 = child$114.sibling);\n completedWork.subtreeFlags |= subtreeFlags;\n completedWork.childLanes = newChildLanes;\n return didBailout;\n}\nfunction completeWork(current, workInProgress, renderLanes) {\n var newProps = workInProgress.pendingProps;\n popTreeContext(workInProgress);\n switch (workInProgress.tag) {\n case 31:\n case 16:\n case 15:\n case 0:\n case 11:\n case 7:\n case 8:\n case 12:\n case 9:\n case 14:\n return bubbleProperties(workInProgress), null;\n case 1:\n return bubbleProperties(workInProgress), null;\n case 3:\n renderLanes = workInProgress.stateNode;\n newProps = null;\n null !== current && (newProps = current.memoizedState.cache);\n workInProgress.memoizedState.cache !== newProps &&\n (workInProgress.flags |= 2048);\n popProvider(CacheContext);\n popHostContainer();\n renderLanes.pendingContext &&\n ((renderLanes.context = renderLanes.pendingContext),\n (renderLanes.pendingContext = null));\n if (null === current || null === current.child)\n popHydrationState(workInProgress)\n ? markUpdate(workInProgress)\n : null === current ||\n (current.memoizedState.isDehydrated &&\n 0 === (workInProgress.flags & 256)) ||\n ((workInProgress.flags |= 1024),\n upgradeHydrationErrorsToRecoverable());\n bubbleProperties(workInProgress);\n return null;\n case 26:\n return (\n (renderLanes = workInProgress.memoizedState),\n null === current\n ? (markUpdate(workInProgress),\n null !== renderLanes\n ? (bubbleProperties(workInProgress),\n preloadResourceAndSuspendIfNeeded(workInProgress, renderLanes))\n : (bubbleProperties(workInProgress),\n (workInProgress.flags &= -16777217)))\n : renderLanes\n ? renderLanes !== current.memoizedState\n ? (markUpdate(workInProgress),\n bubbleProperties(workInProgress),\n preloadResourceAndSuspendIfNeeded(workInProgress, renderLanes))\n : (bubbleProperties(workInProgress),\n (workInProgress.flags &= -16777217))\n : (current.memoizedProps !== newProps && markUpdate(workInProgress),\n bubbleProperties(workInProgress),\n (workInProgress.flags &= -16777217)),\n null\n );\n case 27:\n popHostContext(workInProgress);\n renderLanes = rootInstanceStackCursor.current;\n var type = workInProgress.type;\n if (null !== current && null != workInProgress.stateNode)\n current.memoizedProps !== newProps && markUpdate(workInProgress);\n else {\n if (!newProps) {\n if (null === workInProgress.stateNode)\n throw Error(formatProdErrorMessage(166));\n bubbleProperties(workInProgress);\n return null;\n }\n current = contextStackCursor.current;\n popHydrationState(workInProgress)\n ? prepareToHydrateHostInstance(workInProgress, current)\n : ((current = resolveSingletonInstance(type, newProps, renderLanes)),\n (workInProgress.stateNode = current),\n markUpdate(workInProgress));\n }\n bubbleProperties(workInProgress);\n return null;\n case 5:\n popHostContext(workInProgress);\n renderLanes = workInProgress.type;\n if (null !== current && null != workInProgress.stateNode)\n current.memoizedProps !== newProps && markUpdate(workInProgress);\n else {\n if (!newProps) {\n if (null === workInProgress.stateNode)\n throw Error(formatProdErrorMessage(166));\n bubbleProperties(workInProgress);\n return null;\n }\n current = contextStackCursor.current;\n if (popHydrationState(workInProgress))\n prepareToHydrateHostInstance(workInProgress, current);\n else {\n type = getOwnerDocumentFromRootContainer(\n rootInstanceStackCursor.current\n );\n switch (current) {\n case 1:\n current = type.createElementNS(\n \"http://www.w3.org/2000/svg\",\n renderLanes\n );\n break;\n case 2:\n current = type.createElementNS(\n \"http://www.w3.org/1998/Math/MathML\",\n renderLanes\n );\n break;\n default:\n switch (renderLanes) {\n case \"svg\":\n current = type.createElementNS(\n \"http://www.w3.org/2000/svg\",\n renderLanes\n );\n break;\n case \"math\":\n current = type.createElementNS(\n \"http://www.w3.org/1998/Math/MathML\",\n renderLanes\n );\n break;\n case \"script\":\n current = type.createElement(\"div\");\n current.innerHTML = \" + From 6a8e73e27be631763da8220161a98e157e44a92d Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 13:28:19 -0700 Subject: [PATCH 09/14] Refactor GlobalState to consolidate configuration management under GlobalConfig - Replaced individual configuration properties (pivot, filter, pagination, sort) with a unified GlobalConfig object. - Updated methods to load and save configurations from/to localStorage as a single entity. - Adjusted computed properties to access individual configurations from GlobalConfig. - Enhanced state management for pagination and sorting updates to reflect changes in the new structure. --- vite-app/src/GlobalState.tsx | 231 +++++++++++------------------------ 1 file changed, 72 insertions(+), 159 deletions(-) diff --git a/vite-app/src/GlobalState.tsx b/vite-app/src/GlobalState.tsx index 06db4be2..9442c3f0 100644 --- a/vite-app/src/GlobalState.tsx +++ b/vite-app/src/GlobalState.tsx @@ -49,14 +49,8 @@ export class GlobalState { dataset: Record = {}; // rollout_id -> expanded expandedRows: Record = {}; - // Pivot configuration - pivotConfig: PivotConfig; - // Unified filter configuration for both pivot and table views - filterConfig: FilterGroup[]; - // Pagination configuration - paginationConfig: PaginationConfig; - // Sort configuration - sortConfig: SortConfig; + // Unified global configuration + globalConfig: GlobalConfig; // Debounced, actually applied filter configuration (for performance while typing) appliedFilterConfig: FilterGroup[]; // Loading state @@ -71,27 +65,35 @@ export class GlobalState { private createdAtMsById: Record = {}; // Debounce timers for localStorage saves and filter application - private savePivotConfigTimer: ReturnType | null = null; - private saveFilterConfigTimer: ReturnType | null = null; - private savePaginationConfigTimer: ReturnType | null = - null; + private saveGlobalConfigTimer: ReturnType | null = null; private applyFilterTimer: ReturnType | null = null; constructor() { - // Load pivot config from localStorage or use defaults - this.pivotConfig = this.loadPivotConfig(); - // Load filter config from localStorage or use defaults - this.filterConfig = this.loadFilterConfig(); + // Load global config from localStorage or use defaults + this.globalConfig = this.loadGlobalConfig(); // Initialize applied filter config with current value this.appliedFilterConfig = this.filterConfig.slice(); - // Load pagination config from localStorage or use defaults - this.paginationConfig = this.loadPaginationConfig(); - // Load sort config from localStorage or use defaults - this.sortConfig = this.loadSortConfig(); makeAutoObservable(this); this.queryParamsWatcher = new QueryParamsWatcher(this); } + // Computed getters for individual configs + get pivotConfig(): PivotConfig { + return this.globalConfig.pivotConfig; + } + + get filterConfig(): FilterGroup[] { + return this.globalConfig.filterConfig; + } + + get paginationConfig(): PaginationConfig { + return this.globalConfig.paginationConfig; + } + + get sortConfig(): SortConfig { + return this.globalConfig.sortConfig; + } + // Computed getters for individual pagination properties get currentPage(): number { return this.paginationConfig.currentPage; @@ -110,133 +112,53 @@ export class GlobalState { return this.sortConfig.sortDirection; } - // Load pivot configuration from localStorage - private loadPivotConfig(): PivotConfig { - try { - const stored = localStorage.getItem("pivotConfig"); - if (stored) { - const parsed = JSON.parse(stored); - // Merge with defaults to handle any missing properties - return { ...DEFAULT_PIVOT_CONFIG, ...parsed }; - } - } catch (error) { - console.warn("Failed to load pivot config from localStorage:", error); - } - return { ...DEFAULT_PIVOT_CONFIG }; - } - - // Load filter configuration from localStorage - private loadFilterConfig(): FilterGroup[] { - try { - const stored = localStorage.getItem("filterConfig"); - if (stored) { - const parsed = JSON.parse(stored); - return Array.isArray(parsed) ? parsed : DEFAULT_FILTER_CONFIG; - } - } catch (error) { - console.warn("Failed to load filter config from localStorage:", error); - } - return DEFAULT_FILTER_CONFIG; - } - - // Load pagination configuration from localStorage - private loadPaginationConfig(): PaginationConfig { - try { - const stored = localStorage.getItem("paginationConfig"); - if (stored) { - const parsed = JSON.parse(stored); - // Merge with defaults to handle any missing properties - return { ...DEFAULT_PAGINATION_CONFIG, ...parsed }; - } - } catch (error) { - console.warn( - "Failed to load pagination config from localStorage:", - error - ); - } - return DEFAULT_PAGINATION_CONFIG; - } - - // Load sort configuration from localStorage - private loadSortConfig(): SortConfig { + // Load global configuration from localStorage + private loadGlobalConfig(): GlobalConfig { try { - const stored = localStorage.getItem("sortConfig"); + const stored = localStorage.getItem("globalConfig"); if (stored) { const parsed = JSON.parse(stored); // Merge with defaults to handle any missing properties - return { ...DEFAULT_SORT_CONFIG, ...parsed }; + return { + pivotConfig: { ...DEFAULT_PIVOT_CONFIG, ...parsed.pivotConfig }, + filterConfig: Array.isArray(parsed.filterConfig) + ? parsed.filterConfig + : DEFAULT_FILTER_CONFIG, + paginationConfig: { + ...DEFAULT_PAGINATION_CONFIG, + ...parsed.paginationConfig, + }, + sortConfig: { ...DEFAULT_SORT_CONFIG, ...parsed.sortConfig }, + }; } } catch (error) { - console.warn("Failed to load sort config from localStorage:", error); + console.warn("Failed to load global config from localStorage:", error); } - return DEFAULT_SORT_CONFIG; + return { ...DEFAULT_GLOBAL_CONFIG }; } - // Save pivot configuration to localStorage - private savePivotConfig() { - if (this.savePivotConfigTimer) clearTimeout(this.savePivotConfigTimer); - this.savePivotConfigTimer = setTimeout(() => { + // Save global configuration to localStorage + private saveGlobalConfig() { + if (this.saveGlobalConfigTimer) clearTimeout(this.saveGlobalConfigTimer); + this.saveGlobalConfigTimer = setTimeout(() => { try { - localStorage.setItem("pivotConfig", JSON.stringify(this.pivotConfig)); + localStorage.setItem("globalConfig", JSON.stringify(this.globalConfig)); } catch (error) { - console.warn("Failed to save pivot config to localStorage:", error); - } - }, 200); - } - - // Save filter configuration to localStorage - private saveFilterConfig() { - if (this.saveFilterConfigTimer) clearTimeout(this.saveFilterConfigTimer); - this.saveFilterConfigTimer = setTimeout(() => { - try { - localStorage.setItem("filterConfig", JSON.stringify(this.filterConfig)); - } catch (error) { - console.warn("Failed to save filter config to localStorage:", error); - } - }, 200); - } - - // Save pagination configuration to localStorage - private savePaginationConfig() { - if (this.savePaginationConfigTimer) - clearTimeout(this.savePaginationConfigTimer); - this.savePaginationConfigTimer = setTimeout(() => { - try { - localStorage.setItem( - "paginationConfig", - JSON.stringify(this.paginationConfig) - ); - } catch (error) { - console.warn( - "Failed to save pagination config to localStorage:", - error - ); - } - }, 200); - } - - // Save sort configuration to localStorage - private saveSortConfig() { - if (this.saveFilterConfigTimer) clearTimeout(this.saveFilterConfigTimer); - this.saveFilterConfigTimer = setTimeout(() => { - try { - localStorage.setItem("sortConfig", JSON.stringify(this.sortConfig)); - } catch (error) { - console.warn("Failed to save sort config to localStorage:", error); + console.warn("Failed to save global config to localStorage:", error); } }, 200); } // Update pivot configuration and save to localStorage updatePivotConfig(updates: Partial) { - Object.assign(this.pivotConfig, updates); - this.savePivotConfig(); + Object.assign(this.globalConfig.pivotConfig, updates); + this.saveGlobalConfig(); } // Update filter configuration and save to localStorage updateFilterConfig(filters: FilterGroup[]) { - this.filterConfig = filters; - this.saveFilterConfig(); + this.globalConfig.filterConfig = filters; + this.saveGlobalConfig(); // Debounce application of filters to avoid re-filtering on every keystroke if (this.applyFilterTimer) clearTimeout(this.applyFilterTimer); @@ -247,68 +169,68 @@ export class GlobalState { // Update pagination configuration and save to localStorage updatePaginationConfig(updates: Partial) { - Object.assign(this.paginationConfig, updates); - this.savePaginationConfig(); + Object.assign(this.globalConfig.paginationConfig, updates); + this.saveGlobalConfig(); } // Update sort configuration and save to localStorage updateSortConfig(updates: Partial) { - Object.assign(this.sortConfig, updates); + Object.assign(this.globalConfig.sortConfig, updates); // Reset to first page when sorting changes - this.paginationConfig.currentPage = 1; - this.saveSortConfig(); + this.globalConfig.paginationConfig.currentPage = 1; + this.saveGlobalConfig(); } // Handle sort field click - toggle direction if same field, set to asc if new field handleSortFieldClick(field: string) { if (this.sortConfig.sortField === field) { // Toggle direction for same field - this.sortConfig.sortDirection = + this.globalConfig.sortConfig.sortDirection = this.sortConfig.sortDirection === "asc" ? "desc" : "asc"; } else { // New field, set to ascending - this.sortConfig.sortField = field; - this.sortConfig.sortDirection = "asc"; + this.globalConfig.sortConfig.sortField = field; + this.globalConfig.sortConfig.sortDirection = "asc"; } - this.saveSortConfig(); + this.saveGlobalConfig(); } // Reset pivot configuration to defaults resetPivotConfig() { - this.pivotConfig = { ...DEFAULT_PIVOT_CONFIG }; - this.savePivotConfig(); + this.globalConfig.pivotConfig = { ...DEFAULT_PIVOT_CONFIG }; + this.saveGlobalConfig(); } // Reset filter configuration to defaults resetFilterConfig() { - this.filterConfig = [...DEFAULT_FILTER_CONFIG]; + this.globalConfig.filterConfig = [...DEFAULT_FILTER_CONFIG]; this.appliedFilterConfig = [...DEFAULT_FILTER_CONFIG]; - this.saveFilterConfig(); + this.saveGlobalConfig(); } // Reset pagination configuration to defaults resetPaginationConfig() { - this.paginationConfig = { ...DEFAULT_PAGINATION_CONFIG }; - this.savePaginationConfig(); + this.globalConfig.paginationConfig = { ...DEFAULT_PAGINATION_CONFIG }; + this.saveGlobalConfig(); } // Reset sort configuration to defaults resetSortConfig() { - this.sortConfig = { ...DEFAULT_SORT_CONFIG }; - this.saveSortConfig(); + this.globalConfig.sortConfig = { ...DEFAULT_SORT_CONFIG }; + this.saveGlobalConfig(); } // Set current page setCurrentPage(page: number) { - this.paginationConfig.currentPage = page; - this.savePaginationConfig(); + this.globalConfig.paginationConfig.currentPage = page; + this.saveGlobalConfig(); } // Set page size setPageSize(size: number) { - this.paginationConfig.pageSize = size; - this.paginationConfig.currentPage = 1; // Reset to first page when changing page size - this.savePaginationConfig(); + this.globalConfig.paginationConfig.pageSize = size; + this.globalConfig.paginationConfig.currentPage = 1; // Reset to first page when changing page size + this.saveGlobalConfig(); } // Set loading state @@ -341,10 +263,10 @@ export class GlobalState { runInAction(() => { // Reset to first page when dataset changes - this.paginationConfig.currentPage = 1; + this.globalConfig.paginationConfig.currentPage = 1; this.isLoading = false; }); - this.savePaginationConfig(); + this.saveGlobalConfig(); } toggleRowExpansion(rolloutId?: string) { @@ -371,15 +293,6 @@ export class GlobalState { }); } - get globalConfig(): GlobalConfig { - return { - pivotConfig: this.pivotConfig, - filterConfig: this.filterConfig, - paginationConfig: this.paginationConfig, - sortConfig: this.sortConfig, - }; - } - // Computed values following MobX best practices get sortedIds() { const ids = Object.keys(this.dataset); From 0e143fbd3049288c92fdd02e732fc2cf0762e261 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 13:32:54 -0700 Subject: [PATCH 10/14] query params are applied when provided --- vite-app/src/GlobalState.tsx | 51 ++++++++++++++++++++++++++++++- vite-app/src/util/query-params.ts | 51 +++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+), 1 deletion(-) diff --git a/vite-app/src/GlobalState.tsx b/vite-app/src/GlobalState.tsx index 9442c3f0..ef061b38 100644 --- a/vite-app/src/GlobalState.tsx +++ b/vite-app/src/GlobalState.tsx @@ -11,7 +11,10 @@ import type { import flattenJson from "./util/flatten-json"; import type { FlatJson } from "./util/flatten-json"; import { createFilterFunction } from "./util/filter-utils"; -import { QueryParamsWatcher } from "./util/query-params"; +import { + QueryParamsWatcher, + queryParamsToPartialConfig, +} from "./util/query-params"; // Default pivot configuration const DEFAULT_PIVOT_CONFIG: PivotConfig = { @@ -75,6 +78,9 @@ export class GlobalState { this.appliedFilterConfig = this.filterConfig.slice(); makeAutoObservable(this); this.queryParamsWatcher = new QueryParamsWatcher(this); + + // Apply query params from URL if they exist + this.applyQueryParamsFromUrl(); } // Computed getters for individual configs @@ -243,6 +249,49 @@ export class GlobalState { this.isConnected = connected; } + // Apply query params to global configuration + applyQueryParams(queryParams: Record) { + debugger; + const partialConfig = queryParamsToPartialConfig(queryParams); + + // Apply each section of the partial config + if (partialConfig.pivotConfig) { + this.updatePivotConfig(partialConfig.pivotConfig); + } + + if (partialConfig.filterConfig) { + this.updateFilterConfig(partialConfig.filterConfig); + } + + if (partialConfig.paginationConfig) { + this.updatePaginationConfig(partialConfig.paginationConfig); + } + + if (partialConfig.sortConfig) { + this.updateSortConfig(partialConfig.sortConfig); + } + } + + // Extract query params from URL and apply them to global configuration + private applyQueryParamsFromUrl() { + if (typeof window === "undefined") { + return; // Skip on server-side rendering + } + + const urlParams = new URLSearchParams(window.location.search); + const queryParams: Record = {}; + + // Convert URLSearchParams to Record + for (const [key, value] of urlParams.entries()) { + queryParams[key] = value; + } + + // Only apply if there are query params + if (Object.keys(queryParams).length > 0) { + this.applyQueryParams(queryParams); + } + } + upsertRows(dataset: EvaluationRow[]) { runInAction(() => { this.isLoading = true; diff --git a/vite-app/src/util/query-params.ts b/vite-app/src/util/query-params.ts index 3f2b62d5..6246bd60 100644 --- a/vite-app/src/util/query-params.ts +++ b/vite-app/src/util/query-params.ts @@ -161,6 +161,57 @@ function calculateDifferentValues( return differences; } +/** + * Converts serialized query params back into a partial GlobalConfig + * This is the inverse operation of nonDefaultValues() + * + * @param queryParams - Record where keys are JSON paths and values are JSON-serialized values + * @returns Partial that can be applied to update GlobalConfig + */ +export function queryParamsToPartialConfig( + queryParams: Record +): Partial { + const result: any = {}; + + for (const [path, serializedValue] of Object.entries(queryParams)) { + try { + const value = JSON.parse(serializedValue); + setNestedValue(result, path, value); + } catch (error) { + console.warn( + `Failed to parse query param value for path "${path}":`, + error + ); + } + } + + return result; +} + +/** + * Helper function to set a nested value in an object using dot notation path + * @param obj - The object to modify + * @param path - Dot notation path (e.g., "pivotConfig.selectedRowFields") + * @param value - The value to set + */ +function setNestedValue(obj: any, path: string, value: any): void { + const keys = path.split("."); + let current = obj; + + // Navigate to the parent of the target key + for (let i = 0; i < keys.length - 1; i++) { + const key = keys[i]; + if (!(key in current)) { + current[key] = {}; + } + current = current[key]; + } + + // Set the final value + const finalKey = keys[keys.length - 1]; + current[finalKey] = value; +} + /** * Custom hook that integrates QueryParamsWatcher with React Router's useSearchParams * This hook should be used in components that need to sync global state with URL query params From d495ea5b380973f31e42db07c523c0d6d49d635c Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 13:33:10 -0700 Subject: [PATCH 11/14] vite build --- .../{index-DzSO2_2t.js => index-B3h7Mmhe.js} | 56 +++++++++---------- vite-app/dist/assets/index-B3h7Mmhe.js.map | 1 + vite-app/dist/assets/index-DzSO2_2t.js.map | 1 - vite-app/dist/index.html | 2 +- 4 files changed, 30 insertions(+), 30 deletions(-) rename vite-app/dist/assets/{index-DzSO2_2t.js => index-B3h7Mmhe.js} (65%) create mode 100644 vite-app/dist/assets/index-B3h7Mmhe.js.map delete mode 100644 vite-app/dist/assets/index-DzSO2_2t.js.map diff --git a/vite-app/dist/assets/index-DzSO2_2t.js b/vite-app/dist/assets/index-B3h7Mmhe.js similarity index 65% rename from vite-app/dist/assets/index-DzSO2_2t.js rename to vite-app/dist/assets/index-B3h7Mmhe.js index bfb75c9e..ed823871 100644 --- a/vite-app/dist/assets/index-DzSO2_2t.js +++ b/vite-app/dist/assets/index-B3h7Mmhe.js @@ -1,4 +1,4 @@ -(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const i of document.querySelectorAll('link[rel="modulepreload"]'))n(i);new MutationObserver(i=>{for(const s of i)if(s.type==="childList")for(const o of s.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&n(o)}).observe(document,{childList:!0,subtree:!0});function A(i){const s={};return i.integrity&&(s.integrity=i.integrity),i.referrerPolicy&&(s.referrerPolicy=i.referrerPolicy),i.crossOrigin==="use-credentials"?s.credentials="include":i.crossOrigin==="anonymous"?s.credentials="omit":s.credentials="same-origin",s}function n(i){if(i.ep)return;i.ep=!0;const s=A(i);fetch(i.href,s)}})();function IB(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var Hp={exports:{}},ml={};/** +(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const i of document.querySelectorAll('link[rel="modulepreload"]'))n(i);new MutationObserver(i=>{for(const s of i)if(s.type==="childList")for(const o of s.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&n(o)}).observe(document,{childList:!0,subtree:!0});function A(i){const s={};return i.integrity&&(s.integrity=i.integrity),i.referrerPolicy&&(s.referrerPolicy=i.referrerPolicy),i.crossOrigin==="use-credentials"?s.credentials="include":i.crossOrigin==="anonymous"?s.credentials="omit":s.credentials="same-origin",s}function n(i){if(i.ep)return;i.ep=!0;const s=A(i);fetch(i.href,s)}})();function Im(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var Ep={exports:{}},Bl={};/** * @license React * react-jsx-runtime.production.js * @@ -6,7 +6,7 @@ * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. - */var dy;function MH(){if(dy)return ml;dy=1;var e=Symbol.for("react.transitional.element"),t=Symbol.for("react.fragment");function A(n,i,s){var o=null;if(s!==void 0&&(o=""+s),i.key!==void 0&&(o=""+i.key),"key"in i){s={};for(var c in i)c!=="key"&&(s[c]=i[c])}else s=i;return i=s.ref,{$$typeof:e,type:n,key:o,ref:i!==void 0?i:null,props:s}}return ml.Fragment=t,ml.jsx=A,ml.jsxs=A,ml}var gy;function LH(){return gy||(gy=1,Hp.exports=MH()),Hp.exports}var x=LH(),Op={exports:{}},Ut={};/** + */var dy;function LH(){if(dy)return Bl;dy=1;var e=Symbol.for("react.transitional.element"),t=Symbol.for("react.fragment");function A(n,i,s){var o=null;if(s!==void 0&&(o=""+s),i.key!==void 0&&(o=""+i.key),"key"in i){s={};for(var c in i)c!=="key"&&(s[c]=i[c])}else s=i;return i=s.ref,{$$typeof:e,type:n,key:o,ref:i!==void 0?i:null,props:s}}return Bl.Fragment=t,Bl.jsx=A,Bl.jsxs=A,Bl}var gy;function RH(){return gy||(gy=1,Ep.exports=LH()),Ep.exports}var x=RH(),Fp={exports:{}},Ut={};/** * @license React * react.production.js * @@ -14,7 +14,7 @@ * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. - */var py;function RH(){if(py)return Ut;py=1;var e=Symbol.for("react.transitional.element"),t=Symbol.for("react.portal"),A=Symbol.for("react.fragment"),n=Symbol.for("react.strict_mode"),i=Symbol.for("react.profiler"),s=Symbol.for("react.consumer"),o=Symbol.for("react.context"),c=Symbol.for("react.forward_ref"),u=Symbol.for("react.suspense"),h=Symbol.for("react.memo"),d=Symbol.for("react.lazy"),p=Symbol.iterator;function B(T){return T===null||typeof T!="object"?null:(T=p&&T[p]||T["@@iterator"],typeof T=="function"?T:null)}var v={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},w=Object.assign,b={};function _(T,j,At){this.props=T,this.context=j,this.refs=b,this.updater=At||v}_.prototype.isReactComponent={},_.prototype.setState=function(T,j){if(typeof T!="object"&&typeof T!="function"&&T!=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,T,j,"setState")},_.prototype.forceUpdate=function(T){this.updater.enqueueForceUpdate(this,T,"forceUpdate")};function C(){}C.prototype=_.prototype;function U(T,j,At){this.props=T,this.context=j,this.refs=b,this.updater=At||v}var E=U.prototype=new C;E.constructor=U,w(E,_.prototype),E.isPureReactComponent=!0;var H=Array.isArray,F={H:null,A:null,T:null,S:null,V:null},D=Object.prototype.hasOwnProperty;function R(T,j,At,tt,Y,ut){return At=ut.ref,{$$typeof:e,type:T,key:j,ref:At!==void 0?At:null,props:ut}}function z(T,j){return R(T.type,j,void 0,void 0,void 0,T.props)}function N(T){return typeof T=="object"&&T!==null&&T.$$typeof===e}function J(T){var j={"=":"=0",":":"=2"};return"$"+T.replace(/[=:]/g,function(At){return j[At]})}var et=/\/+/g;function nt(T,j){return typeof T=="object"&&T!==null&&T.key!=null?J(""+T.key):j.toString(36)}function ot(){}function ft(T){switch(T.status){case"fulfilled":return T.value;case"rejected":throw T.reason;default:switch(typeof T.status=="string"?T.then(ot,ot):(T.status="pending",T.then(function(j){T.status==="pending"&&(T.status="fulfilled",T.value=j)},function(j){T.status==="pending"&&(T.status="rejected",T.reason=j)})),T.status){case"fulfilled":return T.value;case"rejected":throw T.reason}}throw T}function st(T,j,At,tt,Y){var ut=typeof T;(ut==="undefined"||ut==="boolean")&&(T=null);var lt=!1;if(T===null)lt=!0;else switch(ut){case"bigint":case"string":case"number":lt=!0;break;case"object":switch(T.$$typeof){case e:case t:lt=!0;break;case d:return lt=T._init,st(lt(T._payload),j,At,tt,Y)}}if(lt)return Y=Y(T),lt=tt===""?"."+nt(T,0):tt,H(Y)?(At="",lt!=null&&(At=lt.replace(et,"$&/")+"/"),st(Y,j,At,"",function(Yt){return Yt})):Y!=null&&(N(Y)&&(Y=z(Y,At+(Y.key==null||T&&T.key===Y.key?"":(""+Y.key).replace(et,"$&/")+"/")+lt)),j.push(Y)),1;lt=0;var he=tt===""?".":tt+":";if(H(T))for(var Kt=0;Kt>>1,T=L[ct];if(0>>1;cti(tt,q))Yi(ut,tt)?(L[ct]=ut,L[Y]=q,ct=Y):(L[ct]=tt,L[At]=q,ct=At);else if(Yi(ut,q))L[ct]=ut,L[Y]=q,ct=Y;else break t}}return G}function i(L,G){var q=L.sortIndex-G.sortIndex;return q!==0?q:L.id-G.id}if(e.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var s=performance;e.unstable_now=function(){return s.now()}}else{var o=Date,c=o.now();e.unstable_now=function(){return o.now()-c}}var u=[],h=[],d=1,p=null,B=3,v=!1,w=!1,b=!1,_=!1,C=typeof setTimeout=="function"?setTimeout:null,U=typeof clearTimeout=="function"?clearTimeout:null,E=typeof setImmediate<"u"?setImmediate:null;function H(L){for(var G=A(h);G!==null;){if(G.callback===null)n(h);else if(G.startTime<=L)n(h),G.sortIndex=G.expirationTime,t(u,G);else break;G=A(h)}}function F(L){if(b=!1,H(L),!w)if(A(u)!==null)w=!0,D||(D=!0,nt());else{var G=A(h);G!==null&&st(F,G.startTime-L)}}var D=!1,R=-1,z=5,N=-1;function J(){return _?!0:!(e.unstable_now()-NL&&J());){var ct=p.callback;if(typeof ct=="function"){p.callback=null,B=p.priorityLevel;var T=ct(p.expirationTime<=L);if(L=e.unstable_now(),typeof T=="function"){p.callback=T,H(L),G=!0;break e}p===A(u)&&n(u),H(L)}else n(u);p=A(u)}if(p!==null)G=!0;else{var j=A(h);j!==null&&st(F,j.startTime-L),G=!1}}break t}finally{p=null,B=q,v=!1}G=void 0}}finally{G?nt():D=!1}}}var nt;if(typeof E=="function")nt=function(){E(et)};else if(typeof MessageChannel<"u"){var ot=new MessageChannel,ft=ot.port2;ot.port1.onmessage=et,nt=function(){ft.postMessage(null)}}else nt=function(){C(et,0)};function st(L,G){R=C(function(){L(e.unstable_now())},G)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(L){L.callback=null},e.unstable_forceFrameRate=function(L){0>L||125ct?(L.sortIndex=q,t(h,L),A(u)===null&&L===A(h)&&(b?(U(R),R=-1):b=!0,st(F,q-ct))):(L.sortIndex=T,t(u,L),w||v||(w=!0,D||(D=!0,nt()))),L},e.unstable_shouldYield=J,e.unstable_wrapCallback=function(L){var G=B;return function(){var q=B;B=G;try{return L.apply(this,arguments)}finally{B=q}}}}(Mp)),Mp}var vy;function NH(){return vy||(vy=1,Dp.exports=IH()),Dp.exports}var Lp={exports:{}},dA={};/** + */var my;function NH(){return my||(my=1,function(e){function t(L,G){var q=L.length;L.push(G);t:for(;0>>1,T=L[ct];if(0>>1;cti(tt,q))Yi(ut,tt)?(L[ct]=ut,L[Y]=q,ct=Y):(L[ct]=tt,L[At]=q,ct=At);else if(Yi(ut,q))L[ct]=ut,L[Y]=q,ct=Y;else break t}}return G}function i(L,G){var q=L.sortIndex-G.sortIndex;return q!==0?q:L.id-G.id}if(e.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var s=performance;e.unstable_now=function(){return s.now()}}else{var o=Date,c=o.now();e.unstable_now=function(){return o.now()-c}}var u=[],h=[],d=1,p=null,m=3,v=!1,w=!1,b=!1,_=!1,C=typeof setTimeout=="function"?setTimeout:null,U=typeof clearTimeout=="function"?clearTimeout:null,E=typeof setImmediate<"u"?setImmediate:null;function H(L){for(var G=A(h);G!==null;){if(G.callback===null)n(h);else if(G.startTime<=L)n(h),G.sortIndex=G.expirationTime,t(u,G);else break;G=A(h)}}function F(L){if(b=!1,H(L),!w)if(A(u)!==null)w=!0,D||(D=!0,nt());else{var G=A(h);G!==null&&st(F,G.startTime-L)}}var D=!1,R=-1,z=5,N=-1;function J(){return _?!0:!(e.unstable_now()-NL&&J());){var ct=p.callback;if(typeof ct=="function"){p.callback=null,m=p.priorityLevel;var T=ct(p.expirationTime<=L);if(L=e.unstable_now(),typeof T=="function"){p.callback=T,H(L),G=!0;break e}p===A(u)&&n(u),H(L)}else n(u);p=A(u)}if(p!==null)G=!0;else{var j=A(h);j!==null&&st(F,j.startTime-L),G=!1}}break t}finally{p=null,m=q,v=!1}G=void 0}}finally{G?nt():D=!1}}}var nt;if(typeof E=="function")nt=function(){E(et)};else if(typeof MessageChannel<"u"){var ot=new MessageChannel,ft=ot.port2;ot.port1.onmessage=et,nt=function(){ft.postMessage(null)}}else nt=function(){C(et,0)};function st(L,G){R=C(function(){L(e.unstable_now())},G)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(L){L.callback=null},e.unstable_forceFrameRate=function(L){0>L||125ct?(L.sortIndex=q,t(h,L),A(u)===null&&L===A(h)&&(b?(U(R),R=-1):b=!0,st(F,q-ct))):(L.sortIndex=T,t(u,L),w||v||(w=!0,D||(D=!0,nt()))),L},e.unstable_shouldYield=J,e.unstable_wrapCallback=function(L){var G=m;return function(){var q=m;m=G;try{return L.apply(this,arguments)}finally{m=q}}}}(Op)),Op}var vy;function kH(){return vy||(vy=1,Hp.exports=NH()),Hp.exports}var Tp={exports:{}},dA={};/** * @license React * react-dom.production.js * @@ -30,7 +30,7 @@ * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. - */var wy;function kH(){if(wy)return dA;wy=1;var e=Kh();function t(u){var h="https://react.dev/errors/"+u;if(1"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e)}catch(t){console.error(t)}}return e(),Lp.exports=kH(),Lp.exports}/** + */var wy;function KH(){if(wy)return dA;wy=1;var e=Ih();function t(u){var h="https://react.dev/errors/"+u;if(1"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e)}catch(t){console.error(t)}}return e(),Tp.exports=KH(),Tp.exports}/** * @license React * react-dom-client.production.js * @@ -38,15 +38,15 @@ * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. - */var yy;function KH(){if(yy)return Bl;yy=1;var e=NH(),t=Kh(),A=bQ();function n(r){var a="https://react.dev/errors/"+r;if(1T||(r.current=ct[T],ct[T]=null,T--)}function tt(r,a){T++,ct[T]=r.current,r.current=a}var Y=j(null),ut=j(null),lt=j(null),he=j(null);function Kt(r,a){switch(tt(lt,a),tt(ut,r),tt(Y,null),a.nodeType){case 9:case 11:r=(r=a.documentElement)&&(r=r.namespaceURI)?zb(r):0;break;default:if(r=a.tagName,a=a.namespaceURI)a=zb(a),r=Vb(a,r);else switch(r){case"svg":r=1;break;case"math":r=2;break;default:r=0}}At(Y),tt(Y,r)}function Yt(){At(Y),At(ut),At(lt)}function An(r){r.memoizedState!==null&&tt(he,r);var a=Y.current,l=Vb(a,r.type);a!==l&&(tt(ut,r),tt(Y,l))}function je(r){ut.current===r&&(At(Y),At(ut)),he.current===r&&(At(he),fl._currentValue=q)}var nA=Object.prototype.hasOwnProperty,FA=e.unstable_scheduleCallback,SA=e.unstable_cancelCallback,ea=e.unstable_shouldYield,yA=e.unstable_requestPaint,CA=e.unstable_now,mi=e.unstable_getCurrentPriorityLevel,Pn=e.unstable_ImmediatePriority,se=e.unstable_UserBlockingPriority,jn=e.unstable_NormalPriority,es=e.unstable_LowPriority,Ar=e.unstable_IdlePriority,As=e.log,Aa=e.unstable_setDisableYieldValue,nn=null,xe=null;function HA(r){if(typeof As=="function"&&Aa(r),xe&&typeof xe.setStrictMode=="function")try{xe.setStrictMode(nn,r)}catch{}}var Se=Math.clz32?Math.clz32:ir,nr=Math.log,yo=Math.LN2;function ir(r){return r>>>=0,r===0?32:31-(nr(r)/yo|0)|0}var rn=256,lA=4194304;function $t(r){var a=r&42;if(a!==0)return a;switch(r&-r){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:case 262144:case 524288:case 1048576:case 2097152:return r&4194048;case 4194304:case 8388608:case 16777216:case 33554432:return r&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return r}}function Bi(r,a,l){var f=r.pendingLanes;if(f===0)return 0;var g=0,m=r.suspendedLanes,y=r.pingedLanes;r=r.warmLanes;var Q=f&134217727;return Q!==0?(f=Q&~m,f!==0?g=$t(f):(y&=Q,y!==0?g=$t(y):l||(l=Q&~r,l!==0&&(g=$t(l))))):(Q=f&~m,Q!==0?g=$t(Q):y!==0?g=$t(y):l||(l=f&~r,l!==0&&(g=$t(l)))),g===0?0:a!==0&&a!==g&&(a&m)===0&&(m=g&-g,l=a&-a,m>=l||m===32&&(l&4194048)!==0)?a:g}function En(r,a){return(r.pendingLanes&~(r.suspendedLanes&~r.pingedLanes)&a)===0}function rr(r,a){switch(r){case 1:case 2:case 4:case 8:case 64:return a+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 a+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 sr(){var r=rn;return rn<<=1,(rn&4194048)===0&&(rn=256),r}function vi(){var r=lA;return lA<<=1,(lA&62914560)===0&&(lA=4194304),r}function Gn(r){for(var a=[],l=0;31>l;l++)a.push(r);return a}function sn(r,a){r.pendingLanes|=a,a!==268435456&&(r.suspendedLanes=0,r.pingedLanes=0,r.warmLanes=0)}function ns(r,a,l,f,g,m){var y=r.pendingLanes;r.pendingLanes=l,r.suspendedLanes=0,r.pingedLanes=0,r.warmLanes=0,r.expiredLanes&=l,r.entangledLanes&=l,r.errorRecoveryDisabledLanes&=l,r.shellSuspendCounter=0;var Q=r.entanglements,O=r.expirationTimes,K=r.hiddenUpdates;for(l=y&~l;0T||(r.current=ct[T],ct[T]=null,T--)}function tt(r,a){T++,ct[T]=r.current,r.current=a}var Y=j(null),ut=j(null),lt=j(null),he=j(null);function Kt(r,a){switch(tt(lt,a),tt(ut,r),tt(Y,null),a.nodeType){case 9:case 11:r=(r=a.documentElement)&&(r=r.namespaceURI)?zb(r):0;break;default:if(r=a.tagName,a=a.namespaceURI)a=zb(a),r=Vb(a,r);else switch(r){case"svg":r=1;break;case"math":r=2;break;default:r=0}}At(Y),tt(Y,r)}function Yt(){At(Y),At(ut),At(lt)}function An(r){r.memoizedState!==null&&tt(he,r);var a=Y.current,l=Vb(a,r.type);a!==l&&(tt(ut,r),tt(Y,l))}function je(r){ut.current===r&&(At(Y),At(ut)),he.current===r&&(At(he),fl._currentValue=q)}var nA=Object.prototype.hasOwnProperty,FA=e.unstable_scheduleCallback,SA=e.unstable_cancelCallback,ea=e.unstable_shouldYield,yA=e.unstable_requestPaint,CA=e.unstable_now,Bi=e.unstable_getCurrentPriorityLevel,Pn=e.unstable_ImmediatePriority,se=e.unstable_UserBlockingPriority,jn=e.unstable_NormalPriority,es=e.unstable_LowPriority,Ar=e.unstable_IdlePriority,As=e.log,Aa=e.unstable_setDisableYieldValue,nn=null,xe=null;function HA(r){if(typeof As=="function"&&Aa(r),xe&&typeof xe.setStrictMode=="function")try{xe.setStrictMode(nn,r)}catch{}}var Se=Math.clz32?Math.clz32:ir,nr=Math.log,yo=Math.LN2;function ir(r){return r>>>=0,r===0?32:31-(nr(r)/yo|0)|0}var rn=256,lA=4194304;function $t(r){var a=r&42;if(a!==0)return a;switch(r&-r){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:case 262144:case 524288:case 1048576:case 2097152:return r&4194048;case 4194304:case 8388608:case 16777216:case 33554432:return r&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return r}}function mi(r,a,l){var f=r.pendingLanes;if(f===0)return 0;var g=0,B=r.suspendedLanes,y=r.pingedLanes;r=r.warmLanes;var Q=f&134217727;return Q!==0?(f=Q&~B,f!==0?g=$t(f):(y&=Q,y!==0?g=$t(y):l||(l=Q&~r,l!==0&&(g=$t(l))))):(Q=f&~B,Q!==0?g=$t(Q):y!==0?g=$t(y):l||(l=f&~r,l!==0&&(g=$t(l)))),g===0?0:a!==0&&a!==g&&(a&B)===0&&(B=g&-g,l=a&-a,B>=l||B===32&&(l&4194048)!==0)?a:g}function En(r,a){return(r.pendingLanes&~(r.suspendedLanes&~r.pingedLanes)&a)===0}function rr(r,a){switch(r){case 1:case 2:case 4:case 8:case 64:return a+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 a+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 sr(){var r=rn;return rn<<=1,(rn&4194048)===0&&(rn=256),r}function vi(){var r=lA;return lA<<=1,(lA&62914560)===0&&(lA=4194304),r}function Gn(r){for(var a=[],l=0;31>l;l++)a.push(r);return a}function sn(r,a){r.pendingLanes|=a,a!==268435456&&(r.suspendedLanes=0,r.pingedLanes=0,r.warmLanes=0)}function ns(r,a,l,f,g,B){var y=r.pendingLanes;r.pendingLanes=l,r.suspendedLanes=0,r.pingedLanes=0,r.warmLanes=0,r.expiredLanes&=l,r.entangledLanes&=l,r.errorRecoveryDisabledLanes&=l,r.shellSuspendCounter=0;var Q=r.entanglements,O=r.expirationTimes,K=r.hiddenUpdates;for(l=y&~l;0)":-1g||O[f]!==K[g]){var X=` -`+O[f].replace(" at new "," at ");return r.displayName&&X.includes("")&&(X=X.replace("",r.displayName)),X}while(1<=f&&0<=g);break}}}finally{Qd=!1,Error.prepareStackTrace=l}return(l=r?r.displayName||r.name:"")?ra(l):""}function FS(r){switch(r.tag){case 26:case 27:case 5:return ra(r.type);case 16:return ra("Lazy");case 13:return ra("Suspense");case 19:return ra("SuspenseList");case 0:case 15:return Ud(r.type,!1);case 11:return Ud(r.type.render,!1);case 1:return Ud(r.type,!0);case 31:return ra("Activity");default:return""}}function Lv(r){try{var a="";do a+=FS(r),r=r.return;while(r);return a}catch(l){return` +`+O[f].replace(" at new "," at ");return r.displayName&&X.includes("")&&(X=X.replace("",r.displayName)),X}while(1<=f&&0<=g);break}}}finally{Cd=!1,Error.prepareStackTrace=l}return(l=r?r.displayName||r.name:"")?ra(l):""}function SS(r){switch(r.tag){case 26:case 27:case 5:return ra(r.type);case 16:return ra("Lazy");case 13:return ra("Suspense");case 19:return ra("SuspenseList");case 0:case 15:return _d(r.type,!1);case 11:return _d(r.type.render,!1);case 1:return _d(r.type,!0);case 31:return ra("Activity");default:return""}}function L0(r){try{var a="";do a+=SS(r),r=r.return;while(r);return a}catch(l){return` Error generating stack: `+l.message+` -`+l.stack}}function ln(r){switch(typeof r){case"bigint":case"boolean":case"number":case"string":case"undefined":return r;case"object":return r;default:return""}}function Rv(r){var a=r.type;return(r=r.nodeName)&&r.toLowerCase()==="input"&&(a==="checkbox"||a==="radio")}function SS(r){var a=Rv(r)?"checked":"value",l=Object.getOwnPropertyDescriptor(r.constructor.prototype,a),f=""+r[a];if(!r.hasOwnProperty(a)&&typeof l<"u"&&typeof l.get=="function"&&typeof l.set=="function"){var g=l.get,m=l.set;return Object.defineProperty(r,a,{configurable:!0,get:function(){return g.call(this)},set:function(y){f=""+y,m.call(this,y)}}),Object.defineProperty(r,a,{enumerable:l.enumerable}),{getValue:function(){return f},setValue:function(y){f=""+y},stopTracking:function(){r._valueTracker=null,delete r[a]}}}}function Rc(r){r._valueTracker||(r._valueTracker=SS(r))}function Iv(r){if(!r)return!1;var a=r._valueTracker;if(!a)return!0;var l=a.getValue(),f="";return r&&(f=Rv(r)?r.checked?"true":"false":r.value),r=f,r!==l?(a.setValue(r),!0):!1}function Ic(r){if(r=r||(typeof document<"u"?document:void 0),typeof r>"u")return null;try{return r.activeElement||r.body}catch{return r.body}}var HS=/[\n"\\]/g;function cn(r){return r.replace(HS,function(a){return"\\"+a.charCodeAt(0).toString(16)+" "})}function Ed(r,a,l,f,g,m,y,Q){r.name="",y!=null&&typeof y!="function"&&typeof y!="symbol"&&typeof y!="boolean"?r.type=y:r.removeAttribute("type"),a!=null?y==="number"?(a===0&&r.value===""||r.value!=a)&&(r.value=""+ln(a)):r.value!==""+ln(a)&&(r.value=""+ln(a)):y!=="submit"&&y!=="reset"||r.removeAttribute("value"),a!=null?Fd(r,y,ln(a)):l!=null?Fd(r,y,ln(l)):f!=null&&r.removeAttribute("value"),g==null&&m!=null&&(r.defaultChecked=!!m),g!=null&&(r.checked=g&&typeof g!="function"&&typeof g!="symbol"),Q!=null&&typeof Q!="function"&&typeof Q!="symbol"&&typeof Q!="boolean"?r.name=""+ln(Q):r.removeAttribute("name")}function Nv(r,a,l,f,g,m,y,Q){if(m!=null&&typeof m!="function"&&typeof m!="symbol"&&typeof m!="boolean"&&(r.type=m),a!=null||l!=null){if(!(m!=="submit"&&m!=="reset"||a!=null))return;l=l!=null?""+ln(l):"",a=a!=null?""+ln(a):l,Q||a===r.value||(r.value=a),r.defaultValue=a}f=f??g,f=typeof f!="function"&&typeof f!="symbol"&&!!f,r.checked=Q?r.checked:!!f,r.defaultChecked=!!f,y!=null&&typeof y!="function"&&typeof y!="symbol"&&typeof y!="boolean"&&(r.name=y)}function Fd(r,a,l){a==="number"&&Ic(r.ownerDocument)===r||r.defaultValue===""+l||(r.defaultValue=""+l)}function sa(r,a,l,f){if(r=r.options,a){a={};for(var g=0;g"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),Dd=!1;if(yi)try{var Qo={};Object.defineProperty(Qo,"passive",{get:function(){Dd=!0}}),window.addEventListener("test",Qo,Qo),window.removeEventListener("test",Qo,Qo)}catch{Dd=!1}var lr=null,Md=null,kc=null;function Gv(){if(kc)return kc;var r,a=Md,l=a.length,f,g="value"in lr?lr.value:lr.textContent,m=g.length;for(r=0;r=Fo),Jv=" ",qv=!1;function t0(r,a){switch(r){case"keyup":return r1.indexOf(a.keyCode)!==-1;case"keydown":return a.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function e0(r){return r=r.detail,typeof r=="object"&&"data"in r?r.data:null}var ca=!1;function a1(r,a){switch(r){case"compositionend":return e0(a);case"keypress":return a.which!==32?null:(qv=!0,Jv);case"textInput":return r=a.data,r===Jv&&qv?null:r;default:return null}}function o1(r,a){if(ca)return r==="compositionend"||!kd&&t0(r,a)?(r=Gv(),kc=Md=lr=null,ca=!1,r):null;switch(r){case"paste":return null;case"keypress":if(!(a.ctrlKey||a.altKey||a.metaKey)||a.ctrlKey&&a.altKey){if(a.char&&1=a)return{node:l,offset:a-r};r=f}t:{for(;l;){if(l.nextSibling){l=l.nextSibling;break t}l=l.parentNode}l=void 0}l=l0(l)}}function u0(r,a){return r&&a?r===a?!0:r&&r.nodeType===3?!1:a&&a.nodeType===3?u0(r,a.parentNode):"contains"in r?r.contains(a):r.compareDocumentPosition?!!(r.compareDocumentPosition(a)&16):!1:!1}function f0(r){r=r!=null&&r.ownerDocument!=null&&r.ownerDocument.defaultView!=null?r.ownerDocument.defaultView:window;for(var a=Ic(r.document);a instanceof r.HTMLIFrameElement;){try{var l=typeof a.contentWindow.location.href=="string"}catch{l=!1}if(l)r=a.contentWindow;else break;a=Ic(r.document)}return a}function Vd(r){var a=r&&r.nodeName&&r.nodeName.toLowerCase();return a&&(a==="input"&&(r.type==="text"||r.type==="search"||r.type==="tel"||r.type==="url"||r.type==="password")||a==="textarea"||r.contentEditable==="true")}var p1=yi&&"documentMode"in document&&11>=document.documentMode,ua=null,Pd=null,To=null,jd=!1;function h0(r,a,l){var f=l.window===l?l.document:l.nodeType===9?l:l.ownerDocument;jd||ua==null||ua!==Ic(f)||(f=ua,"selectionStart"in f&&Vd(f)?f={start:f.selectionStart,end:f.selectionEnd}:(f=(f.ownerDocument&&f.ownerDocument.defaultView||window).getSelection(),f={anchorNode:f.anchorNode,anchorOffset:f.anchorOffset,focusNode:f.focusNode,focusOffset:f.focusOffset}),To&&Oo(To,f)||(To=f,f=Su(Pd,"onSelect"),0>=y,g-=y,_i=1<<32-Se(a)+g|l<m?m:8;var y=L.T,Q={};L.T=Q,Sg(r,!1,a,l);try{var O=g(),K=L.S;if(K!==null&&K(Q,O),O!==null&&typeof O=="object"&&typeof O.then=="function"){var X=x1(O,f);Zo(r,a,X,XA(r))}else Zo(r,a,f,XA(r))}catch(W){Zo(r,a,{then:function(){},status:"rejected",reason:W},XA())}finally{G.p=m,L.T=y}}function S1(){}function Eg(r,a,l,f){if(r.tag!==5)throw Error(n(476));var g=dw(r).queue;hw(r,g,a,q,l===null?S1:function(){return gw(r),l(f)})}function dw(r){var a=r.memoizedState;if(a!==null)return a;a={memoizedState:q,baseState:q,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Ei,lastRenderedState:q},next:null};var l={};return a.next={memoizedState:l,baseState:l,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Ei,lastRenderedState:l},next:null},r.memoizedState=a,r=r.alternate,r!==null&&(r.memoizedState=a),a}function gw(r){var a=dw(r).next.queue;Zo(r,a,{},XA())}function Fg(){return hA(fl)}function pw(){return ke().memoizedState}function mw(){return ke().memoizedState}function H1(r){for(var a=r.return;a!==null;){switch(a.tag){case 24:case 3:var l=XA();r=fr(l);var f=hr(a,r,l);f!==null&&(ZA(f,a,l),zo(f,a,l)),a={cache:rg()},r.payload=a;return}a=a.return}}function O1(r,a,l){var f=XA();l={lane:f,revertLane:0,action:l,hasEagerState:!1,eagerState:null,next:null},cu(r)?vw(a,l):(l=Yd(r,a,l,f),l!==null&&(ZA(l,r,f),ww(l,a,f)))}function Bw(r,a,l){var f=XA();Zo(r,a,l,f)}function Zo(r,a,l,f){var g={lane:f,revertLane:0,action:l,hasEagerState:!1,eagerState:null,next:null};if(cu(r))vw(a,g);else{var m=r.alternate;if(r.lanes===0&&(m===null||m.lanes===0)&&(m=a.lastRenderedReducer,m!==null))try{var y=a.lastRenderedState,Q=m(y,l);if(g.hasEagerState=!0,g.eagerState=Q,zA(Q,y))return Xc(r,a,g,0),ae===null&&Gc(),!1}catch{}finally{}if(l=Yd(r,a,g,f),l!==null)return ZA(l,r,f),ww(l,a,f),!0}return!1}function Sg(r,a,l,f){if(f={lane:2,revertLane:op(),action:f,hasEagerState:!1,eagerState:null,next:null},cu(r)){if(a)throw Error(n(479))}else a=Yd(r,l,f,2),a!==null&&ZA(a,r,2)}function cu(r){var a=r.alternate;return r===Et||a!==null&&a===Et}function vw(r,a){ba=iu=!0;var l=r.pending;l===null?a.next=a:(a.next=l.next,l.next=a),r.pending=a}function ww(r,a,l){if((l&4194048)!==0){var f=a.lanes;f&=r.pendingLanes,l|=f,a.lanes=l,He(r,l)}}var uu={readContext:hA,use:su,useCallback:De,useContext:De,useEffect:De,useImperativeHandle:De,useLayoutEffect:De,useInsertionEffect:De,useMemo:De,useReducer:De,useRef:De,useState:De,useDebugValue:De,useDeferredValue:De,useTransition:De,useSyncExternalStore:De,useId:De,useHostTransitionStatus:De,useFormState:De,useActionState:De,useOptimistic:De,useMemoCache:De,useCacheRefresh:De},bw={readContext:hA,use:su,useCallback:function(r,a){return TA().memoizedState=[r,a===void 0?null:a],r},useContext:hA,useEffect:iw,useImperativeHandle:function(r,a,l){l=l!=null?l.concat([r]):null,lu(4194308,4,ow.bind(null,a,r),l)},useLayoutEffect:function(r,a){return lu(4194308,4,r,a)},useInsertionEffect:function(r,a){lu(4,2,r,a)},useMemo:function(r,a){var l=TA();a=a===void 0?null:a;var f=r();if(Bs){HA(!0);try{r()}finally{HA(!1)}}return l.memoizedState=[f,a],f},useReducer:function(r,a,l){var f=TA();if(l!==void 0){var g=l(a);if(Bs){HA(!0);try{l(a)}finally{HA(!1)}}}else g=a;return f.memoizedState=f.baseState=g,r={pending:null,lanes:0,dispatch:null,lastRenderedReducer:r,lastRenderedState:g},f.queue=r,r=r.dispatch=O1.bind(null,Et,r),[f.memoizedState,r]},useRef:function(r){var a=TA();return r={current:r},a.memoizedState=r},useState:function(r){r=_g(r);var a=r.queue,l=Bw.bind(null,Et,a);return a.dispatch=l,[r.memoizedState,l]},useDebugValue:Qg,useDeferredValue:function(r,a){var l=TA();return Ug(l,r,a)},useTransition:function(){var r=_g(!1);return r=hw.bind(null,Et,r.queue,!0,!1),TA().memoizedState=r,[!1,r]},useSyncExternalStore:function(r,a,l){var f=Et,g=TA();if(Pt){if(l===void 0)throw Error(n(407));l=l()}else{if(l=a(),ae===null)throw Error(n(349));(Lt&124)!==0||z0(f,a,l)}g.memoizedState=l;var m={value:l,getSnapshot:a};return g.queue=m,iw(P0.bind(null,f,m,r),[r]),f.flags|=2048,Ca(9,ou(),V0.bind(null,f,m,l,a),null),l},useId:function(){var r=TA(),a=ae.identifierPrefix;if(Pt){var l=xi,f=_i;l=(f&~(1<<32-Se(f)-1)).toString(32)+l,a="«"+a+"R"+l,l=ru++,0Ct?(Ye=vt,vt=null):Ye=vt.sibling;var It=V(I,vt,k[Ct],$);if(It===null){vt===null&&(vt=Ye);break}r&&vt&&It.alternate===null&&a(I,vt),M=m(It,M,Ct),Ft===null?pt=It:Ft.sibling=It,Ft=It,vt=Ye}if(Ct===k.length)return l(I,vt),Pt&&fs(I,Ct),pt;if(vt===null){for(;CtCt?(Ye=vt,vt=null):Ye=vt.sibling;var Sr=V(I,vt,It.value,$);if(Sr===null){vt===null&&(vt=Ye);break}r&&vt&&Sr.alternate===null&&a(I,vt),M=m(Sr,M,Ct),Ft===null?pt=Sr:Ft.sibling=Sr,Ft=Sr,vt=Ye}if(It.done)return l(I,vt),Pt&&fs(I,Ct),pt;if(vt===null){for(;!It.done;Ct++,It=k.next())It=W(I,It.value,$),It!==null&&(M=m(It,M,Ct),Ft===null?pt=It:Ft.sibling=It,Ft=It);return Pt&&fs(I,Ct),pt}for(vt=f(vt);!It.done;Ct++,It=k.next())It=P(vt,I,Ct,It.value,$),It!==null&&(r&&It.alternate!==null&&vt.delete(It.key===null?Ct:It.key),M=m(It,M,Ct),Ft===null?pt=It:Ft.sibling=It,Ft=It);return r&&vt.forEach(function(DH){return a(I,DH)}),Pt&&fs(I,Ct),pt}function qt(I,M,k,$){if(typeof k=="object"&&k!==null&&k.type===w&&k.key===null&&(k=k.props.children),typeof k=="object"&&k!==null){switch(k.$$typeof){case B:t:{for(var pt=k.key;M!==null;){if(M.key===pt){if(pt=k.type,pt===w){if(M.tag===7){l(I,M.sibling),$=g(M,k.props.children),$.return=I,I=$;break t}}else if(M.elementType===pt||typeof pt=="object"&&pt!==null&&pt.$$typeof===z&&Cw(pt)===M.type){l(I,M.sibling),$=g(M,k.props),$o($,k),$.return=I,I=$;break t}l(I,M);break}else a(I,M);M=M.sibling}k.type===w?($=cs(k.props.children,I.mode,$,k.key),$.return=I,I=$):($=Yc(k.type,k.key,k.props,null,I.mode,$),$o($,k),$.return=I,I=$)}return y(I);case v:t:{for(pt=k.key;M!==null;){if(M.key===pt)if(M.tag===4&&M.stateNode.containerInfo===k.containerInfo&&M.stateNode.implementation===k.implementation){l(I,M.sibling),$=g(M,k.children||[]),$.return=I,I=$;break t}else{l(I,M);break}else a(I,M);M=M.sibling}$=Jd(k,I.mode,$),$.return=I,I=$}return y(I);case z:return pt=k._init,k=pt(k._payload),qt(I,M,k,$)}if(st(k))return _t(I,M,k,$);if(nt(k)){if(pt=nt(k),typeof pt!="function")throw Error(n(150));return k=pt.call(k),bt(I,M,k,$)}if(typeof k.then=="function")return qt(I,M,fu(k),$);if(k.$$typeof===E)return qt(I,M,qc(I,k),$);hu(I,k)}return typeof k=="string"&&k!==""||typeof k=="number"||typeof k=="bigint"?(k=""+k,M!==null&&M.tag===6?(l(I,M.sibling),$=g(M,k),$.return=I,I=$):(l(I,M),$=Wd(k,I.mode,$),$.return=I,I=$),y(I)):l(I,M)}return function(I,M,k,$){try{Yo=0;var pt=qt(I,M,k,$);return _a=null,pt}catch(vt){if(vt===ko||vt===eu)throw vt;var Ft=VA(29,vt,null,I.mode);return Ft.lanes=$,Ft.return=I,Ft}finally{}}}var xa=_w(!0),xw=_w(!1),gn=j(null),Yn=null;function gr(r){var a=r.alternate;tt(ze,ze.current&1),tt(gn,r),Yn===null&&(a===null||wa.current!==null||a.memoizedState!==null)&&(Yn=r)}function Qw(r){if(r.tag===22){if(tt(ze,ze.current),tt(gn,r),Yn===null){var a=r.alternate;a!==null&&a.memoizedState!==null&&(Yn=r)}}else pr()}function pr(){tt(ze,ze.current),tt(gn,gn.current)}function Fi(r){At(gn),Yn===r&&(Yn=null),At(ze)}var ze=j(0);function du(r){for(var a=r;a!==null;){if(a.tag===13){var l=a.memoizedState;if(l!==null&&(l=l.dehydrated,l===null||l.data==="$?"||wp(l)))return a}else if(a.tag===19&&a.memoizedProps.revealOrder!==void 0){if((a.flags&128)!==0)return a}else if(a.child!==null){a.child.return=a,a=a.child;continue}if(a===r)break;for(;a.sibling===null;){if(a.return===null||a.return===r)return null;a=a.return}a.sibling.return=a.return,a=a.sibling}return null}function Hg(r,a,l,f){a=r.memoizedState,l=l(f,a),l=l==null?a:d({},a,l),r.memoizedState=l,r.lanes===0&&(r.updateQueue.baseState=l)}var Og={enqueueSetState:function(r,a,l){r=r._reactInternals;var f=XA(),g=fr(f);g.payload=a,l!=null&&(g.callback=l),a=hr(r,g,f),a!==null&&(ZA(a,r,f),zo(a,r,f))},enqueueReplaceState:function(r,a,l){r=r._reactInternals;var f=XA(),g=fr(f);g.tag=1,g.payload=a,l!=null&&(g.callback=l),a=hr(r,g,f),a!==null&&(ZA(a,r,f),zo(a,r,f))},enqueueForceUpdate:function(r,a){r=r._reactInternals;var l=XA(),f=fr(l);f.tag=2,a!=null&&(f.callback=a),a=hr(r,f,l),a!==null&&(ZA(a,r,l),zo(a,r,l))}};function Uw(r,a,l,f,g,m,y){return r=r.stateNode,typeof r.shouldComponentUpdate=="function"?r.shouldComponentUpdate(f,m,y):a.prototype&&a.prototype.isPureReactComponent?!Oo(l,f)||!Oo(g,m):!0}function Ew(r,a,l,f){r=a.state,typeof a.componentWillReceiveProps=="function"&&a.componentWillReceiveProps(l,f),typeof a.UNSAFE_componentWillReceiveProps=="function"&&a.UNSAFE_componentWillReceiveProps(l,f),a.state!==r&&Og.enqueueReplaceState(a,a.state,null)}function vs(r,a){var l=a;if("ref"in a){l={};for(var f in a)f!=="ref"&&(l[f]=a[f])}if(r=r.defaultProps){l===a&&(l=d({},l));for(var g in r)l[g]===void 0&&(l[g]=r[g])}return l}var gu=typeof reportError=="function"?reportError:function(r){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var a=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof r=="object"&&r!==null&&typeof r.message=="string"?String(r.message):String(r),error:r});if(!window.dispatchEvent(a))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",r);return}console.error(r)};function Fw(r){gu(r)}function Sw(r){console.error(r)}function Hw(r){gu(r)}function pu(r,a){try{var l=r.onUncaughtError;l(a.value,{componentStack:a.stack})}catch(f){setTimeout(function(){throw f})}}function Ow(r,a,l){try{var f=r.onCaughtError;f(l.value,{componentStack:l.stack,errorBoundary:a.tag===1?a.stateNode:null})}catch(g){setTimeout(function(){throw g})}}function Tg(r,a,l){return l=fr(l),l.tag=3,l.payload={element:null},l.callback=function(){pu(r,a)},l}function Tw(r){return r=fr(r),r.tag=3,r}function Dw(r,a,l,f){var g=l.type.getDerivedStateFromError;if(typeof g=="function"){var m=f.value;r.payload=function(){return g(m)},r.callback=function(){Ow(a,l,f)}}var y=l.stateNode;y!==null&&typeof y.componentDidCatch=="function"&&(r.callback=function(){Ow(a,l,f),typeof g!="function"&&(yr===null?yr=new Set([this]):yr.add(this));var Q=f.stack;this.componentDidCatch(f.value,{componentStack:Q!==null?Q:""})})}function D1(r,a,l,f,g){if(l.flags|=32768,f!==null&&typeof f=="object"&&typeof f.then=="function"){if(a=l.alternate,a!==null&&Ro(a,l,g,!0),l=gn.current,l!==null){switch(l.tag){case 13:return Yn===null?np():l.alternate===null&&Ue===0&&(Ue=3),l.flags&=-257,l.flags|=65536,l.lanes=g,f===og?l.flags|=16384:(a=l.updateQueue,a===null?l.updateQueue=new Set([f]):a.add(f),rp(r,f,g)),!1;case 22:return l.flags|=65536,f===og?l.flags|=16384:(a=l.updateQueue,a===null?(a={transitions:null,markerInstances:null,retryQueue:new Set([f])},l.updateQueue=a):(l=a.retryQueue,l===null?a.retryQueue=new Set([f]):l.add(f)),rp(r,f,g)),!1}throw Error(n(435,l.tag))}return rp(r,f,g),np(),!1}if(Pt)return a=gn.current,a!==null?((a.flags&65536)===0&&(a.flags|=256),a.flags|=65536,a.lanes=g,f!==eg&&(r=Error(n(422),{cause:f}),Lo(un(r,l)))):(f!==eg&&(a=Error(n(423),{cause:f}),Lo(un(a,l))),r=r.current.alternate,r.flags|=65536,g&=-g,r.lanes|=g,f=un(f,l),g=Tg(r.stateNode,f,g),ug(r,g),Ue!==4&&(Ue=2)),!1;var m=Error(n(520),{cause:f});if(m=un(m,l),nl===null?nl=[m]:nl.push(m),Ue!==4&&(Ue=2),a===null)return!0;f=un(f,l),l=a;do{switch(l.tag){case 3:return l.flags|=65536,r=g&-g,l.lanes|=r,r=Tg(l.stateNode,f,r),ug(l,r),!1;case 1:if(a=l.type,m=l.stateNode,(l.flags&128)===0&&(typeof a.getDerivedStateFromError=="function"||m!==null&&typeof m.componentDidCatch=="function"&&(yr===null||!yr.has(m))))return l.flags|=65536,g&=-g,l.lanes|=g,g=Tw(g),Dw(g,r,l,f),ug(l,g),!1}l=l.return}while(l!==null);return!1}var Mw=Error(n(461)),Xe=!1;function iA(r,a,l,f){a.child=r===null?xw(a,null,l,f):xa(a,r.child,l,f)}function Lw(r,a,l,f,g){l=l.render;var m=a.ref;if("ref"in f){var y={};for(var Q in f)Q!=="ref"&&(y[Q]=f[Q])}else y=f;return ps(a),f=pg(r,a,l,y,m,g),Q=mg(),r!==null&&!Xe?(Bg(r,a,g),Si(r,a,g)):(Pt&&Q&&qd(a),a.flags|=1,iA(r,a,f,g),a.child)}function Rw(r,a,l,f,g){if(r===null){var m=l.type;return typeof m=="function"&&!$d(m)&&m.defaultProps===void 0&&l.compare===null?(a.tag=15,a.type=m,Iw(r,a,m,f,g)):(r=Yc(l.type,null,f,a,a.mode,g),r.ref=a.ref,r.return=a,a.child=r)}if(m=r.child,!Kg(r,g)){var y=m.memoizedProps;if(l=l.compare,l=l!==null?l:Oo,l(y,f)&&r.ref===a.ref)return Si(r,a,g)}return a.flags|=1,r=Ci(m,f),r.ref=a.ref,r.return=a,a.child=r}function Iw(r,a,l,f,g){if(r!==null){var m=r.memoizedProps;if(Oo(m,f)&&r.ref===a.ref)if(Xe=!1,a.pendingProps=f=m,Kg(r,g))(r.flags&131072)!==0&&(Xe=!0);else return a.lanes=r.lanes,Si(r,a,g)}return Dg(r,a,l,f,g)}function Nw(r,a,l){var f=a.pendingProps,g=f.children,m=r!==null?r.memoizedState:null;if(f.mode==="hidden"){if((a.flags&128)!==0){if(f=m!==null?m.baseLanes|l:l,r!==null){for(g=a.child=r.child,m=0;g!==null;)m=m|g.lanes|g.childLanes,g=g.sibling;a.childLanes=m&~f}else a.childLanes=0,a.child=null;return kw(r,a,f,l)}if((l&536870912)!==0)a.memoizedState={baseLanes:0,cachePool:null},r!==null&&tu(a,m!==null?m.cachePool:null),m!==null?I0(a,m):hg(),Qw(a);else return a.lanes=a.childLanes=536870912,kw(r,a,m!==null?m.baseLanes|l:l,l)}else m!==null?(tu(a,m.cachePool),I0(a,m),pr(),a.memoizedState=null):(r!==null&&tu(a,null),hg(),pr());return iA(r,a,g,l),a.child}function kw(r,a,l,f){var g=ag();return g=g===null?null:{parent:Ke._currentValue,pool:g},a.memoizedState={baseLanes:l,cachePool:g},r!==null&&tu(a,null),hg(),Qw(a),r!==null&&Ro(r,a,f,!0),null}function mu(r,a){var l=a.ref;if(l===null)r!==null&&r.ref!==null&&(a.flags|=4194816);else{if(typeof l!="function"&&typeof l!="object")throw Error(n(284));(r===null||r.ref!==l)&&(a.flags|=4194816)}}function Dg(r,a,l,f,g){return ps(a),l=pg(r,a,l,f,void 0,g),f=mg(),r!==null&&!Xe?(Bg(r,a,g),Si(r,a,g)):(Pt&&f&&qd(a),a.flags|=1,iA(r,a,l,g),a.child)}function Kw(r,a,l,f,g,m){return ps(a),a.updateQueue=null,l=k0(a,f,l,g),N0(r),f=mg(),r!==null&&!Xe?(Bg(r,a,m),Si(r,a,m)):(Pt&&f&&qd(a),a.flags|=1,iA(r,a,l,m),a.child)}function zw(r,a,l,f,g){if(ps(a),a.stateNode===null){var m=ga,y=l.contextType;typeof y=="object"&&y!==null&&(m=hA(y)),m=new l(f,m),a.memoizedState=m.state!==null&&m.state!==void 0?m.state:null,m.updater=Og,a.stateNode=m,m._reactInternals=a,m=a.stateNode,m.props=f,m.state=a.memoizedState,m.refs={},lg(a),y=l.contextType,m.context=typeof y=="object"&&y!==null?hA(y):ga,m.state=a.memoizedState,y=l.getDerivedStateFromProps,typeof y=="function"&&(Hg(a,l,y,f),m.state=a.memoizedState),typeof l.getDerivedStateFromProps=="function"||typeof m.getSnapshotBeforeUpdate=="function"||typeof m.UNSAFE_componentWillMount!="function"&&typeof m.componentWillMount!="function"||(y=m.state,typeof m.componentWillMount=="function"&&m.componentWillMount(),typeof m.UNSAFE_componentWillMount=="function"&&m.UNSAFE_componentWillMount(),y!==m.state&&Og.enqueueReplaceState(m,m.state,null),Po(a,f,m,g),Vo(),m.state=a.memoizedState),typeof m.componentDidMount=="function"&&(a.flags|=4194308),f=!0}else if(r===null){m=a.stateNode;var Q=a.memoizedProps,O=vs(l,Q);m.props=O;var K=m.context,X=l.contextType;y=ga,typeof X=="object"&&X!==null&&(y=hA(X));var W=l.getDerivedStateFromProps;X=typeof W=="function"||typeof m.getSnapshotBeforeUpdate=="function",Q=a.pendingProps!==Q,X||typeof m.UNSAFE_componentWillReceiveProps!="function"&&typeof m.componentWillReceiveProps!="function"||(Q||K!==y)&&Ew(a,m,f,y),ur=!1;var V=a.memoizedState;m.state=V,Po(a,f,m,g),Vo(),K=a.memoizedState,Q||V!==K||ur?(typeof W=="function"&&(Hg(a,l,W,f),K=a.memoizedState),(O=ur||Uw(a,l,O,f,V,K,y))?(X||typeof m.UNSAFE_componentWillMount!="function"&&typeof m.componentWillMount!="function"||(typeof m.componentWillMount=="function"&&m.componentWillMount(),typeof m.UNSAFE_componentWillMount=="function"&&m.UNSAFE_componentWillMount()),typeof m.componentDidMount=="function"&&(a.flags|=4194308)):(typeof m.componentDidMount=="function"&&(a.flags|=4194308),a.memoizedProps=f,a.memoizedState=K),m.props=f,m.state=K,m.context=y,f=O):(typeof m.componentDidMount=="function"&&(a.flags|=4194308),f=!1)}else{m=a.stateNode,cg(r,a),y=a.memoizedProps,X=vs(l,y),m.props=X,W=a.pendingProps,V=m.context,K=l.contextType,O=ga,typeof K=="object"&&K!==null&&(O=hA(K)),Q=l.getDerivedStateFromProps,(K=typeof Q=="function"||typeof m.getSnapshotBeforeUpdate=="function")||typeof m.UNSAFE_componentWillReceiveProps!="function"&&typeof m.componentWillReceiveProps!="function"||(y!==W||V!==O)&&Ew(a,m,f,O),ur=!1,V=a.memoizedState,m.state=V,Po(a,f,m,g),Vo();var P=a.memoizedState;y!==W||V!==P||ur||r!==null&&r.dependencies!==null&&Jc(r.dependencies)?(typeof Q=="function"&&(Hg(a,l,Q,f),P=a.memoizedState),(X=ur||Uw(a,l,X,f,V,P,O)||r!==null&&r.dependencies!==null&&Jc(r.dependencies))?(K||typeof m.UNSAFE_componentWillUpdate!="function"&&typeof m.componentWillUpdate!="function"||(typeof m.componentWillUpdate=="function"&&m.componentWillUpdate(f,P,O),typeof m.UNSAFE_componentWillUpdate=="function"&&m.UNSAFE_componentWillUpdate(f,P,O)),typeof m.componentDidUpdate=="function"&&(a.flags|=4),typeof m.getSnapshotBeforeUpdate=="function"&&(a.flags|=1024)):(typeof m.componentDidUpdate!="function"||y===r.memoizedProps&&V===r.memoizedState||(a.flags|=4),typeof m.getSnapshotBeforeUpdate!="function"||y===r.memoizedProps&&V===r.memoizedState||(a.flags|=1024),a.memoizedProps=f,a.memoizedState=P),m.props=f,m.state=P,m.context=O,f=X):(typeof m.componentDidUpdate!="function"||y===r.memoizedProps&&V===r.memoizedState||(a.flags|=4),typeof m.getSnapshotBeforeUpdate!="function"||y===r.memoizedProps&&V===r.memoizedState||(a.flags|=1024),f=!1)}return m=f,mu(r,a),f=(a.flags&128)!==0,m||f?(m=a.stateNode,l=f&&typeof l.getDerivedStateFromError!="function"?null:m.render(),a.flags|=1,r!==null&&f?(a.child=xa(a,r.child,null,g),a.child=xa(a,null,l,g)):iA(r,a,l,g),a.memoizedState=m.state,r=a.child):r=Si(r,a,g),r}function Vw(r,a,l,f){return Mo(),a.flags|=256,iA(r,a,l,f),a.child}var Mg={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function Lg(r){return{baseLanes:r,cachePool:S0()}}function Rg(r,a,l){return r=r!==null?r.childLanes&~l:0,a&&(r|=pn),r}function Pw(r,a,l){var f=a.pendingProps,g=!1,m=(a.flags&128)!==0,y;if((y=m)||(y=r!==null&&r.memoizedState===null?!1:(ze.current&2)!==0),y&&(g=!0,a.flags&=-129),y=(a.flags&32)!==0,a.flags&=-33,r===null){if(Pt){if(g?gr(a):pr(),Pt){var Q=Qe,O;if(O=Q){t:{for(O=Q,Q=Zn;O.nodeType!==8;){if(!Q){Q=null;break t}if(O=Hn(O.nextSibling),O===null){Q=null;break t}}Q=O}Q!==null?(a.memoizedState={dehydrated:Q,treeContext:us!==null?{id:_i,overflow:xi}:null,retryLane:536870912,hydrationErrors:null},O=VA(18,null,null,0),O.stateNode=Q,O.return=a,a.child=O,xA=a,Qe=null,O=!0):O=!1}O||ds(a)}if(Q=a.memoizedState,Q!==null&&(Q=Q.dehydrated,Q!==null))return wp(Q)?a.lanes=32:a.lanes=536870912,null;Fi(a)}return Q=f.children,f=f.fallback,g?(pr(),g=a.mode,Q=Bu({mode:"hidden",children:Q},g),f=cs(f,g,l,null),Q.return=a,f.return=a,Q.sibling=f,a.child=Q,g=a.child,g.memoizedState=Lg(l),g.childLanes=Rg(r,y,l),a.memoizedState=Mg,f):(gr(a),Ig(a,Q))}if(O=r.memoizedState,O!==null&&(Q=O.dehydrated,Q!==null)){if(m)a.flags&256?(gr(a),a.flags&=-257,a=Ng(r,a,l)):a.memoizedState!==null?(pr(),a.child=r.child,a.flags|=128,a=null):(pr(),g=f.fallback,Q=a.mode,f=Bu({mode:"visible",children:f.children},Q),g=cs(g,Q,l,null),g.flags|=2,f.return=a,g.return=a,f.sibling=g,a.child=f,xa(a,r.child,null,l),f=a.child,f.memoizedState=Lg(l),f.childLanes=Rg(r,y,l),a.memoizedState=Mg,a=g);else if(gr(a),wp(Q)){if(y=Q.nextSibling&&Q.nextSibling.dataset,y)var K=y.dgst;y=K,f=Error(n(419)),f.stack="",f.digest=y,Lo({value:f,source:null,stack:null}),a=Ng(r,a,l)}else if(Xe||Ro(r,a,l,!1),y=(l&r.childLanes)!==0,Xe||y){if(y=ae,y!==null&&(f=l&-l,f=(f&42)!==0?1:cA(f),f=(f&(y.suspendedLanes|l))!==0?0:f,f!==0&&f!==O.retryLane))throw O.retryLane=f,da(r,f),ZA(y,r,f),Mw;Q.data==="$?"||np(),a=Ng(r,a,l)}else Q.data==="$?"?(a.flags|=192,a.child=r.child,a=null):(r=O.treeContext,Qe=Hn(Q.nextSibling),xA=a,Pt=!0,hs=null,Zn=!1,r!==null&&(hn[dn++]=_i,hn[dn++]=xi,hn[dn++]=us,_i=r.id,xi=r.overflow,us=a),a=Ig(a,f.children),a.flags|=4096);return a}return g?(pr(),g=f.fallback,Q=a.mode,O=r.child,K=O.sibling,f=Ci(O,{mode:"hidden",children:f.children}),f.subtreeFlags=O.subtreeFlags&65011712,K!==null?g=Ci(K,g):(g=cs(g,Q,l,null),g.flags|=2),g.return=a,f.return=a,f.sibling=g,a.child=f,f=g,g=a.child,Q=r.child.memoizedState,Q===null?Q=Lg(l):(O=Q.cachePool,O!==null?(K=Ke._currentValue,O=O.parent!==K?{parent:K,pool:K}:O):O=S0(),Q={baseLanes:Q.baseLanes|l,cachePool:O}),g.memoizedState=Q,g.childLanes=Rg(r,y,l),a.memoizedState=Mg,f):(gr(a),l=r.child,r=l.sibling,l=Ci(l,{mode:"visible",children:f.children}),l.return=a,l.sibling=null,r!==null&&(y=a.deletions,y===null?(a.deletions=[r],a.flags|=16):y.push(r)),a.child=l,a.memoizedState=null,l)}function Ig(r,a){return a=Bu({mode:"visible",children:a},r.mode),a.return=r,r.child=a}function Bu(r,a){return r=VA(22,r,null,a),r.lanes=0,r.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null},r}function Ng(r,a,l){return xa(a,r.child,null,l),r=Ig(a,a.pendingProps.children),r.flags|=2,a.memoizedState=null,r}function jw(r,a,l){r.lanes|=a;var f=r.alternate;f!==null&&(f.lanes|=a),ng(r.return,a,l)}function kg(r,a,l,f,g){var m=r.memoizedState;m===null?r.memoizedState={isBackwards:a,rendering:null,renderingStartTime:0,last:f,tail:l,tailMode:g}:(m.isBackwards=a,m.rendering=null,m.renderingStartTime=0,m.last=f,m.tail=l,m.tailMode=g)}function Gw(r,a,l){var f=a.pendingProps,g=f.revealOrder,m=f.tail;if(iA(r,a,f.children,l),f=ze.current,(f&2)!==0)f=f&1|2,a.flags|=128;else{if(r!==null&&(r.flags&128)!==0)t:for(r=a.child;r!==null;){if(r.tag===13)r.memoizedState!==null&&jw(r,l,a);else if(r.tag===19)jw(r,l,a);else if(r.child!==null){r.child.return=r,r=r.child;continue}if(r===a)break t;for(;r.sibling===null;){if(r.return===null||r.return===a)break t;r=r.return}r.sibling.return=r.return,r=r.sibling}f&=1}switch(tt(ze,f),g){case"forwards":for(l=a.child,g=null;l!==null;)r=l.alternate,r!==null&&du(r)===null&&(g=l),l=l.sibling;l=g,l===null?(g=a.child,a.child=null):(g=l.sibling,l.sibling=null),kg(a,!1,g,l,m);break;case"backwards":for(l=null,g=a.child,a.child=null;g!==null;){if(r=g.alternate,r!==null&&du(r)===null){a.child=g;break}r=g.sibling,g.sibling=l,l=g,g=r}kg(a,!0,l,null,m);break;case"together":kg(a,!1,null,null,void 0);break;default:a.memoizedState=null}return a.child}function Si(r,a,l){if(r!==null&&(a.dependencies=r.dependencies),br|=a.lanes,(l&a.childLanes)===0)if(r!==null){if(Ro(r,a,l,!1),(l&a.childLanes)===0)return null}else return null;if(r!==null&&a.child!==r.child)throw Error(n(153));if(a.child!==null){for(r=a.child,l=Ci(r,r.pendingProps),a.child=l,l.return=a;r.sibling!==null;)r=r.sibling,l=l.sibling=Ci(r,r.pendingProps),l.return=a;l.sibling=null}return a.child}function Kg(r,a){return(r.lanes&a)!==0?!0:(r=r.dependencies,!!(r!==null&&Jc(r)))}function M1(r,a,l){switch(a.tag){case 3:Kt(a,a.stateNode.containerInfo),cr(a,Ke,r.memoizedState.cache),Mo();break;case 27:case 5:An(a);break;case 4:Kt(a,a.stateNode.containerInfo);break;case 10:cr(a,a.type,a.memoizedProps.value);break;case 13:var f=a.memoizedState;if(f!==null)return f.dehydrated!==null?(gr(a),a.flags|=128,null):(l&a.child.childLanes)!==0?Pw(r,a,l):(gr(a),r=Si(r,a,l),r!==null?r.sibling:null);gr(a);break;case 19:var g=(r.flags&128)!==0;if(f=(l&a.childLanes)!==0,f||(Ro(r,a,l,!1),f=(l&a.childLanes)!==0),g){if(f)return Gw(r,a,l);a.flags|=128}if(g=a.memoizedState,g!==null&&(g.rendering=null,g.tail=null,g.lastEffect=null),tt(ze,ze.current),f)break;return null;case 22:case 23:return a.lanes=0,Nw(r,a,l);case 24:cr(a,Ke,r.memoizedState.cache)}return Si(r,a,l)}function Xw(r,a,l){if(r!==null)if(r.memoizedProps!==a.pendingProps)Xe=!0;else{if(!Kg(r,l)&&(a.flags&128)===0)return Xe=!1,M1(r,a,l);Xe=(r.flags&131072)!==0}else Xe=!1,Pt&&(a.flags&1048576)!==0&&C0(a,Wc,a.index);switch(a.lanes=0,a.tag){case 16:t:{r=a.pendingProps;var f=a.elementType,g=f._init;if(f=g(f._payload),a.type=f,typeof f=="function")$d(f)?(r=vs(f,r),a.tag=1,a=zw(null,a,f,r,l)):(a.tag=0,a=Dg(null,a,f,r,l));else{if(f!=null){if(g=f.$$typeof,g===H){a.tag=11,a=Lw(null,a,f,r,l);break t}else if(g===R){a.tag=14,a=Rw(null,a,f,r,l);break t}}throw a=ft(f)||f,Error(n(306,a,""))}}return a;case 0:return Dg(r,a,a.type,a.pendingProps,l);case 1:return f=a.type,g=vs(f,a.pendingProps),zw(r,a,f,g,l);case 3:t:{if(Kt(a,a.stateNode.containerInfo),r===null)throw Error(n(387));f=a.pendingProps;var m=a.memoizedState;g=m.element,cg(r,a),Po(a,f,null,l);var y=a.memoizedState;if(f=y.cache,cr(a,Ke,f),f!==m.cache&&ig(a,[Ke],l,!0),Vo(),f=y.element,m.isDehydrated)if(m={element:f,isDehydrated:!1,cache:y.cache},a.updateQueue.baseState=m,a.memoizedState=m,a.flags&256){a=Vw(r,a,f,l);break t}else if(f!==g){g=un(Error(n(424)),a),Lo(g),a=Vw(r,a,f,l);break t}else{switch(r=a.stateNode.containerInfo,r.nodeType){case 9:r=r.body;break;default:r=r.nodeName==="HTML"?r.ownerDocument.body:r}for(Qe=Hn(r.firstChild),xA=a,Pt=!0,hs=null,Zn=!0,l=xw(a,null,f,l),a.child=l;l;)l.flags=l.flags&-3|4096,l=l.sibling}else{if(Mo(),f===g){a=Si(r,a,l);break t}iA(r,a,f,l)}a=a.child}return a;case 26:return mu(r,a),r===null?(l=Wb(a.type,null,a.pendingProps,null))?a.memoizedState=l:Pt||(l=a.type,r=a.pendingProps,f=Ou(lt.current).createElement(l),f[it]=a,f[mt]=r,sA(f,l,r),Te(f),a.stateNode=f):a.memoizedState=Wb(a.type,r.memoizedProps,a.pendingProps,r.memoizedState),null;case 27:return An(a),r===null&&Pt&&(f=a.stateNode=Zb(a.type,a.pendingProps,lt.current),xA=a,Zn=!0,g=Qe,xr(a.type)?(bp=g,Qe=Hn(f.firstChild)):Qe=g),iA(r,a,a.pendingProps.children,l),mu(r,a),r===null&&(a.flags|=4194304),a.child;case 5:return r===null&&Pt&&((g=f=Qe)&&(f=lH(f,a.type,a.pendingProps,Zn),f!==null?(a.stateNode=f,xA=a,Qe=Hn(f.firstChild),Zn=!1,g=!0):g=!1),g||ds(a)),An(a),g=a.type,m=a.pendingProps,y=r!==null?r.memoizedProps:null,f=m.children,mp(g,m)?f=null:y!==null&&mp(g,y)&&(a.flags|=32),a.memoizedState!==null&&(g=pg(r,a,U1,null,null,l),fl._currentValue=g),mu(r,a),iA(r,a,f,l),a.child;case 6:return r===null&&Pt&&((r=l=Qe)&&(l=cH(l,a.pendingProps,Zn),l!==null?(a.stateNode=l,xA=a,Qe=null,r=!0):r=!1),r||ds(a)),null;case 13:return Pw(r,a,l);case 4:return Kt(a,a.stateNode.containerInfo),f=a.pendingProps,r===null?a.child=xa(a,null,f,l):iA(r,a,f,l),a.child;case 11:return Lw(r,a,a.type,a.pendingProps,l);case 7:return iA(r,a,a.pendingProps,l),a.child;case 8:return iA(r,a,a.pendingProps.children,l),a.child;case 12:return iA(r,a,a.pendingProps.children,l),a.child;case 10:return f=a.pendingProps,cr(a,a.type,f.value),iA(r,a,f.children,l),a.child;case 9:return g=a.type._context,f=a.pendingProps.children,ps(a),g=hA(g),f=f(g),a.flags|=1,iA(r,a,f,l),a.child;case 14:return Rw(r,a,a.type,a.pendingProps,l);case 15:return Iw(r,a,a.type,a.pendingProps,l);case 19:return Gw(r,a,l);case 31:return f=a.pendingProps,l=a.mode,f={mode:f.mode,children:f.children},r===null?(l=Bu(f,l),l.ref=a.ref,a.child=l,l.return=a,a=l):(l=Ci(r.child,f),l.ref=a.ref,a.child=l,l.return=a,a=l),a;case 22:return Nw(r,a,l);case 24:return ps(a),f=hA(Ke),r===null?(g=ag(),g===null&&(g=ae,m=rg(),g.pooledCache=m,m.refCount++,m!==null&&(g.pooledCacheLanes|=l),g=m),a.memoizedState={parent:f,cache:g},lg(a),cr(a,Ke,g)):((r.lanes&l)!==0&&(cg(r,a),Po(a,null,null,l),Vo()),g=r.memoizedState,m=a.memoizedState,g.parent!==f?(g={parent:f,cache:f},a.memoizedState=g,a.lanes===0&&(a.memoizedState=a.updateQueue.baseState=g),cr(a,Ke,f)):(f=m.cache,cr(a,Ke,f),f!==g.cache&&ig(a,[Ke],l,!0))),iA(r,a,a.pendingProps.children,l),a.child;case 29:throw a.pendingProps}throw Error(n(156,a.tag))}function Hi(r){r.flags|=4}function Zw(r,a){if(a.type!=="stylesheet"||(a.state.loading&4)!==0)r.flags&=-16777217;else if(r.flags|=16777216,!Ay(a)){if(a=gn.current,a!==null&&((Lt&4194048)===Lt?Yn!==null:(Lt&62914560)!==Lt&&(Lt&536870912)===0||a!==Yn))throw Ko=og,H0;r.flags|=8192}}function vu(r,a){a!==null&&(r.flags|=4),r.flags&16384&&(a=r.tag!==22?vi():536870912,r.lanes|=a,Fa|=a)}function Wo(r,a){if(!Pt)switch(r.tailMode){case"hidden":a=r.tail;for(var l=null;a!==null;)a.alternate!==null&&(l=a),a=a.sibling;l===null?r.tail=null:l.sibling=null;break;case"collapsed":l=r.tail;for(var f=null;l!==null;)l.alternate!==null&&(f=l),l=l.sibling;f===null?a||r.tail===null?r.tail=null:r.tail.sibling=null:f.sibling=null}}function Ce(r){var a=r.alternate!==null&&r.alternate.child===r.child,l=0,f=0;if(a)for(var g=r.child;g!==null;)l|=g.lanes|g.childLanes,f|=g.subtreeFlags&65011712,f|=g.flags&65011712,g.return=r,g=g.sibling;else for(g=r.child;g!==null;)l|=g.lanes|g.childLanes,f|=g.subtreeFlags,f|=g.flags,g.return=r,g=g.sibling;return r.subtreeFlags|=f,r.childLanes=l,a}function L1(r,a,l){var f=a.pendingProps;switch(tg(a),a.tag){case 31:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return Ce(a),null;case 1:return Ce(a),null;case 3:return l=a.stateNode,f=null,r!==null&&(f=r.memoizedState.cache),a.memoizedState.cache!==f&&(a.flags|=2048),Ui(Ke),Yt(),l.pendingContext&&(l.context=l.pendingContext,l.pendingContext=null),(r===null||r.child===null)&&(Do(a)?Hi(a):r===null||r.memoizedState.isDehydrated&&(a.flags&256)===0||(a.flags|=1024,Q0())),Ce(a),null;case 26:return l=a.memoizedState,r===null?(Hi(a),l!==null?(Ce(a),Zw(a,l)):(Ce(a),a.flags&=-16777217)):l?l!==r.memoizedState?(Hi(a),Ce(a),Zw(a,l)):(Ce(a),a.flags&=-16777217):(r.memoizedProps!==f&&Hi(a),Ce(a),a.flags&=-16777217),null;case 27:je(a),l=lt.current;var g=a.type;if(r!==null&&a.stateNode!=null)r.memoizedProps!==f&&Hi(a);else{if(!f){if(a.stateNode===null)throw Error(n(166));return Ce(a),null}r=Y.current,Do(a)?_0(a):(r=Zb(g,f,l),a.stateNode=r,Hi(a))}return Ce(a),null;case 5:if(je(a),l=a.type,r!==null&&a.stateNode!=null)r.memoizedProps!==f&&Hi(a);else{if(!f){if(a.stateNode===null)throw Error(n(166));return Ce(a),null}if(r=Y.current,Do(a))_0(a);else{switch(g=Ou(lt.current),r){case 1:r=g.createElementNS("http://www.w3.org/2000/svg",l);break;case 2:r=g.createElementNS("http://www.w3.org/1998/Math/MathML",l);break;default:switch(l){case"svg":r=g.createElementNS("http://www.w3.org/2000/svg",l);break;case"math":r=g.createElementNS("http://www.w3.org/1998/Math/MathML",l);break;case"script":r=g.createElement("div"),r.innerHTML=" + From 096bb910239c08e6160b22351e89b6af6f255c17 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 13:36:00 -0700 Subject: [PATCH 12/14] remove thing that was causing warnings --- pytest.ini | 2 -- 1 file changed, 2 deletions(-) diff --git a/pytest.ini b/pytest.ini index cd7f77df..b3c84ce1 100644 --- a/pytest.ini +++ b/pytest.ini @@ -5,8 +5,6 @@ asyncio_mode = auto asyncio_default_fixture_loop_scope = function testpaths = tests ./eval_protocol/quickstart python_files = test_*.py llm_judge_*.py -plugins = - eval_protocol.pytest.plugin python_classes = Test* python_functions = test_* # Configure stdout/stderr capture for debugging From f1cbc9768a74944e05e395bc997d9fa18c09a1f4 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 14:01:33 -0700 Subject: [PATCH 13/14] Add show_results_url utility and integrate into evaluation test - Imported show_results_url from utils to display the results URL after postprocessing in evaluation_test. - Updated __init__.py to include show_results_url and related functions in the module exports. --- eval_protocol/pytest/evaluation_test.py | 4 + eval_protocol/utils/__init__.py | 3 +- eval_protocol/utils/check_server_status.py | 77 +++++++ eval_protocol/utils/show_results_url.py | 83 +++++++ tests/test_show_results_url.py | 246 +++++++++++++++++++++ 5 files changed, 412 insertions(+), 1 deletion(-) create mode 100644 eval_protocol/utils/check_server_status.py create mode 100644 eval_protocol/utils/show_results_url.py create mode 100644 tests/test_show_results_url.py diff --git a/eval_protocol/pytest/evaluation_test.py b/eval_protocol/pytest/evaluation_test.py index e51d008b..2e1254d6 100644 --- a/eval_protocol/pytest/evaluation_test.py +++ b/eval_protocol/pytest/evaluation_test.py @@ -59,6 +59,7 @@ parse_ep_passed_threshold, rollout_processor_with_retry, ) +from eval_protocol.utils.show_results_url import show_results_url from ..common_utils import load_jsonl @@ -555,6 +556,9 @@ async def execute_run_with_progress(run_idx: int, config): experiment_duration_seconds, ) + # Show URL for viewing results (after all postprocessing is complete) + show_results_url(invocation_id) + except AssertionError: _log_eval_error( Status.eval_finished(), diff --git a/eval_protocol/utils/__init__.py b/eval_protocol/utils/__init__.py index 1baedea2..32273a43 100644 --- a/eval_protocol/utils/__init__.py +++ b/eval_protocol/utils/__init__.py @@ -9,5 +9,6 @@ # Export ViteServer for easier access from .logs_server import LogsServer +from .show_results_url import show_results_url, is_server_running, generate_invocation_filter_url -__all__ = ["LogsServer"] +__all__ = ["LogsServer", "show_results_url", "is_server_running", "generate_invocation_filter_url"] diff --git a/eval_protocol/utils/check_server_status.py b/eval_protocol/utils/check_server_status.py new file mode 100644 index 00000000..2704ce1e --- /dev/null +++ b/eval_protocol/utils/check_server_status.py @@ -0,0 +1,77 @@ +""" +Utility functions for checking server status and generating UI URLs. +""" + +import socket +import urllib.parse +from typing import List, Dict, Any + + +def is_server_running(host: str = "localhost", port: int = 8000) -> bool: + """ + Check if a server is running on the specified host and port. + + Args: + host: The host to check (default: "localhost") + port: The port to check (default: 8000) + + Returns: + True if server is running, False otherwise + """ + try: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.settimeout(1) + result = s.connect_ex((host, port)) + return result == 0 + except Exception: + return False + + +def generate_invocation_filter_url(invocation_id: str, base_url: str = "http://localhost:8000") -> str: + """ + Generate a URL for viewing results filtered by invocation_id. + + Args: + invocation_id: The invocation ID to filter results by + base_url: The base URL for the UI (default: "http://localhost:8000") + + Returns: + URL-encoded URL with filter configuration + """ + filter_config = [ + { + "logic": "AND", + "filters": [ + { + "field": "$.execution_metadata.invocation_id", + "operator": "equals", + "value": invocation_id, + "type": "text", + } + ], + } + ] + + # URL encode the filter config + filter_config_json = str(filter_config).replace("'", '"') + encoded_filter = urllib.parse.quote(filter_config_json) + + return f"{base_url}/pivot?filterConfig={encoded_filter}" + + +def show_results_url(invocation_id: str) -> None: + """ + Show a URL for viewing evaluation results filtered by invocation_id. + + If the server is not running, prints a message to run "ep logs" to start the local UI. + If the server is running, prints a URL to view results filtered by invocation_id. + + Args: + invocation_id: The invocation ID to filter results by + """ + if is_server_running(): + url = generate_invocation_filter_url(invocation_id) + print(f"View your evaluation results: {url}") + else: + url = generate_invocation_filter_url(invocation_id) + print(f"Start the local UI with 'ep logs', then visit: {url}") diff --git a/eval_protocol/utils/show_results_url.py b/eval_protocol/utils/show_results_url.py new file mode 100644 index 00000000..875a268b --- /dev/null +++ b/eval_protocol/utils/show_results_url.py @@ -0,0 +1,83 @@ +""" +Utility functions for showing evaluation results URLs and checking server status. +""" + +import socket +import urllib.parse +from typing import List, Dict, Any + + +def is_server_running(host: str = "localhost", port: int = 8000) -> bool: + """ + Check if a server is running on the specified host and port. + + Args: + host: The host to check (default: "localhost") + port: The port to check (default: 8000) + + Returns: + True if server is running, False otherwise + """ + try: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.settimeout(1) + result = s.connect_ex((host, port)) + return result == 0 + except Exception: + return False + + +def generate_invocation_filter_url(invocation_id: str, base_url: str = "http://localhost:8000") -> str: + """ + Generate a URL for viewing results filtered by invocation_id. + + Args: + invocation_id: The invocation ID to filter results by + base_url: The base URL for the UI (default: "http://localhost:8000") + + Returns: + URL-encoded URL with filter configuration + """ + filter_config = [ + { + "logic": "AND", + "filters": [ + { + "field": "$.execution_metadata.invocation_id", + "operator": "==", + "value": invocation_id, + "type": "text", + } + ], + } + ] + + # URL encode the filter config + filter_config_json = str(filter_config).replace("'", '"') + encoded_filter = urllib.parse.quote(filter_config_json) + + return f"{base_url}?filterConfig={encoded_filter}" + + +def show_results_url(invocation_id: str) -> None: + """ + Show URLs for viewing evaluation results filtered by invocation_id. + + If the server is not running, prints a message to run "ep logs" to start the local UI. + If the server is running, prints URLs to view results filtered by invocation_id. + + Args: + invocation_id: The invocation ID to filter results by + """ + if is_server_running(): + pivot_url = generate_invocation_filter_url(invocation_id, "http://localhost:8000/pivot") + table_url = generate_invocation_filter_url(invocation_id, "http://localhost:8000/table") + print("View your evaluation results:") + print(f" 📊 Aggregate scores: {pivot_url}") + print(f" 📋 Trajectories: {table_url}") + else: + pivot_url = generate_invocation_filter_url(invocation_id, "http://localhost:8000/pivot") + table_url = generate_invocation_filter_url(invocation_id, "http://localhost:8000/table") + print("Start the local UI with 'ep logs', then visit:") + print(f" 📊 Aggregate scores: {pivot_url}") + print(f" 📋 Trajectories: {table_url}") diff --git a/tests/test_show_results_url.py b/tests/test_show_results_url.py new file mode 100644 index 00000000..c840c4fc --- /dev/null +++ b/tests/test_show_results_url.py @@ -0,0 +1,246 @@ +""" +Tests for eval_protocol.utils.show_results_url module. +""" + +import socket +from unittest.mock import patch, MagicMock +import pytest + +from eval_protocol.utils.show_results_url import ( + is_server_running, + generate_invocation_filter_url, + show_results_url, +) + + +class TestIsServerRunning: + """Test the is_server_running function.""" + + @patch("socket.socket") + def test_server_running(self, mock_socket): + """Test when server is running.""" + # Mock successful connection + mock_socket_instance = MagicMock() + mock_socket_instance.connect_ex.return_value = 0 + mock_socket.return_value.__enter__.return_value = mock_socket_instance + + result = is_server_running("localhost", 8000) + assert result is True + mock_socket_instance.connect_ex.assert_called_once_with(("localhost", 8000)) + + @patch("socket.socket") + def test_server_not_running(self, mock_socket): + """Test when server is not running.""" + # Mock failed connection + mock_socket_instance = MagicMock() + mock_socket_instance.connect_ex.return_value = 1 + mock_socket.return_value.__enter__.return_value = mock_socket_instance + + result = is_server_running("localhost", 8000) + assert result is False + + @patch("socket.socket") + def test_connection_exception(self, mock_socket): + """Test when connection raises an exception.""" + # Mock connection exception + mock_socket.side_effect = Exception("Connection failed") + + result = is_server_running("localhost", 8000) + assert result is False + + def test_default_parameters(self): + """Test with default parameters.""" + with patch("socket.socket") as mock_socket: + mock_socket_instance = MagicMock() + mock_socket_instance.connect_ex.return_value = 0 + mock_socket.return_value.__enter__.return_value = mock_socket_instance + + result = is_server_running() + assert result is True + mock_socket_instance.connect_ex.assert_called_once_with(("localhost", 8000)) + + +class TestGenerateInvocationFilterUrl: + """Test the generate_invocation_filter_url function.""" + + def test_basic_url_generation(self): + """Test basic URL generation with default base URL.""" + invocation_id = "test-123" + result = generate_invocation_filter_url(invocation_id) + + assert "http://localhost:8000" in result + assert "filterConfig=" in result + assert invocation_id in result + + def test_custom_base_url(self): + """Test URL generation with custom base URL.""" + invocation_id = "test-456" + base_url = "http://example.com/pivot" + result = generate_invocation_filter_url(invocation_id, base_url) + + assert base_url in result + assert "filterConfig=" in result + assert invocation_id in result + + def test_url_encoding(self): + """Test that special characters are properly URL encoded.""" + invocation_id = "test with spaces & symbols" + result = generate_invocation_filter_url(invocation_id) + + # Should be URL encoded + assert "%20" in result # spaces + assert "%26" in result # ampersand + + def test_filter_config_structure(self): + """Test that the filter config has the correct structure.""" + invocation_id = "test-789" + result = generate_invocation_filter_url(invocation_id) + + # Decode the URL to check the filter config + from urllib.parse import unquote, parse_qs + + parsed_url = parse_qs(result.split("?")[1]) + filter_config_str = unquote(parsed_url["filterConfig"][0]) + + # Should contain the expected filter structure + assert invocation_id in filter_config_str + assert "execution_metadata.invocation_id" in filter_config_str + assert "==" in filter_config_str # operator + assert "text" in filter_config_str # type + + def test_pivot_and_table_urls(self): + """Test URL generation for both pivot and table views.""" + invocation_id = "test-pivot-table" + + pivot_url = generate_invocation_filter_url(invocation_id, "http://localhost:8000/pivot") + table_url = generate_invocation_filter_url(invocation_id, "http://localhost:8000/table") + + assert "pivot" in pivot_url + assert "table" in table_url + assert invocation_id in pivot_url + assert invocation_id in table_url + # Both should have the same filter config + assert pivot_url.split("?")[1] == table_url.split("?")[1] + + +class TestShowResultsUrl: + """Test the show_results_url function.""" + + @patch("eval_protocol.utils.show_results_url.is_server_running") + @patch("builtins.print") + def test_server_running_pivot_and_table(self, mock_print, mock_is_running): + """Test output when server is running.""" + mock_is_running.return_value = True + + show_results_url("test-invocation") + + # Should print both pivot and table URLs + assert mock_print.call_count == 3 # Header + 2 URLs + calls = [call[0][0] for call in mock_print.call_args_list] + + assert "View your evaluation results:" in calls[0] + assert "📊 Aggregate scores:" in calls[1] + assert "📋 Trajectories:" in calls[2] + assert "pivot" in calls[1] + assert "table" in calls[2] + + @patch("eval_protocol.utils.show_results_url.is_server_running") + @patch("builtins.print") + def test_server_not_running_instructions(self, mock_print, mock_is_running): + """Test output when server is not running.""" + mock_is_running.return_value = False + + show_results_url("test-invocation") + + # Should print instructions and both URLs + assert mock_print.call_count == 3 # Instructions + 2 URLs + calls = [call[0][0] for call in mock_print.call_args_list] + + assert "Start the local UI with 'ep logs'" in calls[0] + assert "📊 Aggregate scores:" in calls[1] + assert "📋 Trajectories:" in calls[2] + assert "pivot" in calls[1] + assert "table" in calls[2] + + @patch("eval_protocol.utils.show_results_url.is_server_running") + @patch("builtins.print") + def test_invocation_id_in_urls(self, mock_print, mock_is_running): + """Test that invocation_id appears in both URLs.""" + mock_is_running.return_value = True + invocation_id = "unique-test-id-123" + + show_results_url(invocation_id) + + calls = [call[0][0] for call in mock_print.call_args_list] + pivot_url = calls[1] + table_url = calls[2] + + assert invocation_id in pivot_url + assert invocation_id in table_url + + @patch("eval_protocol.utils.show_results_url.is_server_running") + @patch("builtins.print") + def test_different_invocation_ids(self, mock_print, mock_is_running): + """Test that different invocation IDs produce different URLs.""" + mock_is_running.return_value = True + + # Test with first invocation ID + show_results_url("id-1") + calls_1 = [call[0][0] for call in mock_print.call_args_list] + mock_print.reset_mock() + + # Test with second invocation ID + show_results_url("id-2") + calls_2 = [call[0][0] for call in mock_print.call_args_list] + + # URLs should be different + assert calls_1[1] != calls_2[1] # Pivot URLs different + assert calls_1[2] != calls_2[2] # Table URLs different + assert "id-1" in calls_1[1] + assert "id-2" in calls_2[1] + + +class TestIntegration: + """Integration tests for the module.""" + + @patch("socket.socket") + @patch("builtins.print") + def test_full_workflow_server_running(self, mock_print, mock_socket): + """Test the full workflow when server is running.""" + # Mock server running + mock_socket_instance = MagicMock() + mock_socket_instance.connect_ex.return_value = 0 + mock_socket.return_value.__enter__.return_value = mock_socket_instance + + show_results_url("integration-test") + + # Verify socket was checked + mock_socket_instance.connect_ex.assert_called_once_with(("localhost", 8000)) + + # Verify output + assert mock_print.call_count == 3 + calls = [call[0][0] for call in mock_print.call_args_list] + assert "View your evaluation results:" in calls[0] + assert "integration-test" in calls[1] + assert "integration-test" in calls[2] + + @patch("socket.socket") + @patch("builtins.print") + def test_full_workflow_server_not_running(self, mock_print, mock_socket): + """Test the full workflow when server is not running.""" + # Mock server not running + mock_socket_instance = MagicMock() + mock_socket_instance.connect_ex.return_value = 1 + mock_socket.return_value.__enter__.return_value = mock_socket_instance + + show_results_url("integration-test") + + # Verify socket was checked + mock_socket_instance.connect_ex.assert_called_once_with(("localhost", 8000)) + + # Verify output + assert mock_print.call_count == 3 + calls = [call[0][0] for call in mock_print.call_args_list] + assert "Start the local UI with 'ep logs'" in calls[0] + assert "integration-test" in calls[1] + assert "integration-test" in calls[2] From 6a11d4e4c30acd9c49175da8751f6362c595b7e7 Mon Sep 17 00:00:00 2001 From: Dylan Huang Date: Sat, 20 Sep 2025 14:32:24 -0700 Subject: [PATCH 14/14] try removing module export --- eval_protocol/utils/__init__.py | 3 +-- eval_protocol/utils/show_results_url.py | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/eval_protocol/utils/__init__.py b/eval_protocol/utils/__init__.py index 32273a43..1baedea2 100644 --- a/eval_protocol/utils/__init__.py +++ b/eval_protocol/utils/__init__.py @@ -9,6 +9,5 @@ # Export ViteServer for easier access from .logs_server import LogsServer -from .show_results_url import show_results_url, is_server_running, generate_invocation_filter_url -__all__ = ["LogsServer", "show_results_url", "is_server_running", "generate_invocation_filter_url"] +__all__ = ["LogsServer"] diff --git a/eval_protocol/utils/show_results_url.py b/eval_protocol/utils/show_results_url.py index 875a268b..409ac858 100644 --- a/eval_protocol/utils/show_results_url.py +++ b/eval_protocol/utils/show_results_url.py @@ -4,7 +4,6 @@ import socket import urllib.parse -from typing import List, Dict, Any def is_server_running(host: str = "localhost", port: int = 8000) -> bool: