From 48e8081f7547986a9f8ccf38f59b839a79f846a7 Mon Sep 17 00:00:00 2001 From: Chris Beer Date: Mon, 16 Dec 2024 11:04:58 -0800 Subject: [PATCH] Update for Mirador 4 + Vite --- .eslintignore | 4 - .eslintrc | 83 +- __tests__/MiradorShareDialog.test.js | 85 +- __tests__/MiradorShareEmbed.test.js | 1 - __tests__/miradorSharePlugin.test.js | 16 +- __tests__/utils/test-utils.js | 54 + babel.config.js | 13 - demo/src/index.html | 52 + demo/src/index.js | 33 - dist/mirador-share-plugin.es.js | 44044 +++++++++++++++++++++++++ dist/mirador-share-plugin.es.js.map | 1 + dist/mirador-share-plugin.js | 426 + dist/mirador-share-plugin.js.map | 1 + jest.config.js | 17 - netlify.toml | 9 + nwb.config.js | 22 - package.json | 78 +- setupJest.js | 4 - setupTest.js | 2 + src/EmbedSizeIcon.js | 8 +- src/IiifIcon.js | 2 +- src/MiradorShareDialog.js | 160 +- src/MiradorShareEmbed.js | 196 +- src/miradorSharePlugin.js | 14 +- vite.config.js | 87 + vitest.config.ts | 49 + 26 files changed, 45027 insertions(+), 434 deletions(-) create mode 100644 __tests__/utils/test-utils.js delete mode 100644 babel.config.js create mode 100644 demo/src/index.html delete mode 100644 demo/src/index.js create mode 100644 dist/mirador-share-plugin.es.js create mode 100644 dist/mirador-share-plugin.es.js.map create mode 100644 dist/mirador-share-plugin.js create mode 100644 dist/mirador-share-plugin.js.map delete mode 100644 jest.config.js create mode 100644 netlify.toml delete mode 100644 nwb.config.js delete mode 100644 setupJest.js create mode 100644 setupTest.js create mode 100644 vite.config.js create mode 100644 vitest.config.ts diff --git a/.eslintignore b/.eslintignore index a0a3ac6..0cdbd50 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1,7 +1,3 @@ dist/ config/ coverage/ -node_modules/ -lib/ -es/ -umd/ diff --git a/.eslintrc b/.eslintrc index 54bfc3a..926617e 100644 --- a/.eslintrc +++ b/.eslintrc @@ -1,16 +1,87 @@ { - "env": { - "jest/globals": true + "parserOptions": { + "ecmaVersion": 2022, + "sourceType": "module", + "ecmaFeatures": { + "jsx": true + } }, - "extends": ["airbnb"], + "extends": [ + "airbnb", + "plugin:react/recommended", + "plugin:react-hooks/recommended", + "plugin:testing-library/react" + ], "globals": { "page": true, - "document": true + "document": true, + "vi": true }, - "parser": "babel-eslint", - "plugins": ["jest"], + "plugins": [ + "react", + "react-hooks", + "testing-library" + ], "rules": { + "import/no-unresolved": [ + 2, { "ignore": ["test-utils"] } + ], + "import/prefer-default-export": "off", + "no-console": "off", + "no-unused-expressions": ["error", { "allowShortCircuit": true, "allowTernary": true }], + "no-unused-vars": "off", + "no-undef": "off", + "no-restricted-syntax": ["warn", "WithStatement"], + "no-restricted-globals": ["error"], + "eqeqeq": ["warn", "smart"], + "no-use-before-define": [ + "warn", + { + "functions": false, + "classes": false, + "variables": false + }, + ], + "no-mixed-operators": [ + "warn", + { + "groups": [ + ["&", "|", "^", "~", "<<", ">>", ">>>"], + ["==", "!=", "===", "!==", ">", ">=", "<", "<="], + ["&&", "||"], + ["in", "instanceof"], + ], + "allowSamePrecedence": false, + }, + ], "react/jsx-filename-extension": [1, { "extensions": [".js", ".jsx"] }], + "no-underscore-dangle": "off", "react/prefer-stateless-function": "off", + "react/jsx-props-no-spreading": "off", + "react/function-component-definition": "off", + "default-param-last": "off", + "arrow-parens": "off", + "import/no-anonymous-default-export": "off", + "import/no-extraneous-dependencies": "off", + "max-len": ["error", { + "code": 120, + "ignoreComments": true, + "ignoreStrings": true, + "ignoreTemplateLiterals": true, + "ignoreRegExpLiterals": true + }], + "react/jsx-uses-react": "off", + "react/react-in-jsx-scope": "off", + "react/require-default-props": [2, { + "functions": "defaultArguments" + }], + "react-hooks/exhaustive-deps": "error", + "testing-library/render-result-naming-convention": "off", + "testing-library/no-render-in-lifecycle": [ + "error", + { + "allowTestingFrameworkSetupHook": "beforeEach" + } + ] } } diff --git a/__tests__/MiradorShareDialog.test.js b/__tests__/MiradorShareDialog.test.js index ddac29f..297cbe8 100644 --- a/__tests__/MiradorShareDialog.test.js +++ b/__tests__/MiradorShareDialog.test.js @@ -1,9 +1,10 @@ import React from 'react'; -import { shallow } from 'enzyme'; +import userEvent from '@testing-library/user-event'; +import { render, screen } from './utils/test-utils'; import miradorShareDialog from '../src/MiradorShareDialog'; function createWrapper(props) { - return shallow( + return render( {}} containerId="container-123" @@ -13,102 +14,100 @@ function createWrapper(props) { open {...props} />, - ).dive(); + ); } describe('Dialog', () => { let wrapper; it('renders a dialog based on the passed in open prop', () => { wrapper = createWrapper(); - expect(wrapper.find('WithStyles(ForwardRef(Dialog))').props().open).toBe(true); + expect(screen.getByRole('dialog')).toBeInTheDocument(); + }); + + it('does not render a dialog when the open prop is false', () => { wrapper = createWrapper({ open: false }); - expect(wrapper.find('WithStyles(ForwardRef(Dialog))').length).toBe(0); + expect(screen.queryByRole('dialog')).not.toBeInTheDocument(); }); it('renders the section headings in an h3', () => { wrapper = createWrapper(); - expect(wrapper.find('WithStyles(ForwardRef(Typography))[variant="h3"]').get(0).props.children).toEqual('Share link'); - expect(wrapper.find('WithStyles(ForwardRef(Typography))[variant="h3"]').get(1).props.children).toEqual('Embed'); - expect(wrapper.find('WithStyles(ForwardRef(Typography))[variant="h3"]').get(2).props.children).toEqual('Add to another viewer'); + + expect(screen.getByText('Share link', { selector: 'h3' })).toBeInTheDocument(); + expect(screen.getByText('Embed', { selector: 'h3' })).toBeInTheDocument(); + expect(screen.getByText('Add to another viewer', { selector: 'h3' })).toBeInTheDocument(); }); it('has a close button that calls closeShareDialog on click', () => { - const closeShareDialog = jest.fn(); + const closeShareDialog = vi.fn(); wrapper = createWrapper({ closeShareDialog }); - wrapper.find('WithStyles(ForwardRef(DialogActions)) WithStyles(ForwardRef(Button))').simulate('click'); + screen.getByRole('button', { name: 'Close' }).click(); expect(closeShareDialog).toHaveBeenCalled(); }); - it('has dividers', () => { - wrapper = createWrapper(); - expect(wrapper.find('WithStyles(ForwardRef(Divider))').length).toEqual(2); - }); - describe('Share link section', () => { it('renders the section w/ a TextField and a Copy Button', () => { wrapper = createWrapper(); - expect(wrapper.find('WithStyles(ForwardRef(TextField))').length).toBe(1); - expect(wrapper.find('CopyToClipboard WithStyles(ForwardRef(Button))').get(0).props.children).toEqual('Copy'); + expect(screen.getByLabelText('Share link URL', { selector: 'input' })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Copy link to clipboard' })).toBeInTheDocument(); }); - it('renders the TextField & CopyToClipboard components w/ the shareLinkText state value', () => { + it.skip('renders the TextField & CopyToClipboard components w/ the shareLinkText state value', async () => { + const mockedWriteText = vi.spyOn(navigator.clipboard, 'writeText'); wrapper = createWrapper(); - wrapper.setState({ shareLinkText: 'http://example.com/iiif/manifest' }); - expect(wrapper.find('WithStyles(ForwardRef(TextField))').props().defaultValue).toEqual('http://example.com/iiif/manifest'); - expect(wrapper.find('CopyToClipboard').get(0).props.text).toEqual('http://example.com/iiif/manifest'); + await userEvent.type(screen.getByLabelText('Share link URL', { selector: 'input' }), '?xyz'); + + await userEvent.click(screen.getByRole('button', { name: 'Copy link to clipboard' })); + expect(mockedWriteText).toHaveBeenCalledTimes(1); + expect(mockedWriteText).toHaveBeenCalledWith('your copied data'); }); - it("sets the component's shareLinkText on TextField change", () => { + it('allows the user to change the embed URL', async () => { wrapper = createWrapper(); - wrapper.find('WithStyles(ForwardRef(TextField))').props().onChange({ target: { value: 'http://example.com/iiif/manifest.json' } }); - expect(wrapper.state().shareLinkText).toEqual('http://example.com/iiif/manifest.json'); + + await userEvent.type(screen.getByLabelText('Share link URL', { selector: 'input' }), '?xyz'); + + expect(screen.getByLabelText('Share link URL', { selector: 'input' }).value).toEqual('http://example.com/abc/iiif/manifest?xyz'); }); it('does not render the section if the displayShareLink prop is falsey', () => { wrapper = createWrapper({ displayShareLink: false }); - - expect(wrapper.find('WithStyles(ForwardRef(TextField))').length).toBe(0); - expect(wrapper.find('CopyToClipboard').length).toBe(1); + expect(screen.queryByLabelText('Share link URL', { selector: 'input' })).not.toBeInTheDocument(); }); }); describe('embed section', () => { it('is rendered when the displayEmbedOption is true', () => { wrapper = createWrapper({ displayEmbedOption: false }); - expect(wrapper.find('WithStyles(MiradorShareEmbed)').length).toBe(0); + expect(screen.queryByText('Embed', { selector: 'h3' })).not.toBeInTheDocument(); + expect(screen.queryByLabelText('Select viewer size')).not.toBeInTheDocument(); wrapper = createWrapper({ displayEmbedOption: true }); - expect(wrapper.find('WithStyles(MiradorShareEmbed)').length).toBe(1); + expect(screen.getByText('Embed', { selector: 'h3' })).toBeInTheDocument(); + expect(screen.getByLabelText('Select viewer size')).toBeInTheDocument(); }); }); describe('Add to another viewer section', () => { - it('renders a link, icon, button, and text', () => { + it('renders text', () => { wrapper = createWrapper(); - expect(wrapper.find('WithStyles(ForwardRef(Grid)) WithStyles(ForwardRef(Link)) IiifIcon').length).toBe(1); - expect(wrapper.find('WithStyles(ForwardRef(Grid)) CopyToClipboard WithStyles(ForwardRef(Button))').length).toBe(1); - expect(wrapper.find('WithStyles(ForwardRef(Grid)) WithStyles(ForwardRef(Typography))[variant="body1"]').get(0).props.children).toEqual( - 'Drag & drop IIIF icon to add this resource to any IIIF viewer.', - ); - expect(wrapper.find('WithStyles(ForwardRef(Grid)) WithStyles(ForwardRef(Typography))[variant="body1"]').get(2).props.children).toEqual( - 'Copy & paste the resource\'s manifest into any IIIF viewer.', - ); + expect(screen.getByText(/Drag & drop/)).toBeInTheDocument(); + expect(screen.getByText(/Copy & paste the resource/)).toBeInTheDocument(); }); it('renders the link with IIIF Drag & Drop Compliant URL (passing the manifest in a param)', () => { - const link = wrapper.find('WithStyles(ForwardRef(Grid)) WithStyles(ForwardRef(Link))').at(0); - expect(link.props().href).toEqual('http://example.com/abc/iiif/manifest?manifest=http://example.com/abc/iiif/manifest'); + wrapper = createWrapper(); + + expect(screen.getByLabelText('Drag icon to any IIIF viewer.')).toHaveAttribute('href', 'http://example.com/abc/iiif/manifest?manifest=http://example.com/abc/iiif/manifest'); }); describe('when an info link is configured/passed in as a prop', () => { it('renders a "What is IIIF" link', () => { wrapper = createWrapper({ iiifInfoLink: 'http://iiif.io/' }); - const link = wrapper.find('WithStyles(ForwardRef(Typography))[variant="body1"] WithStyles(ForwardRef(Link))'); - expect(link.props().children).toEqual('What is IIIF?'); - expect(link.props().href).toEqual('http://iiif.io/'); + + expect(screen.getByText('What is IIIF?')).toHaveAttribute('href', 'http://iiif.io/'); }); }); }); diff --git a/__tests__/MiradorShareEmbed.test.js b/__tests__/MiradorShareEmbed.test.js index 5dea496..9a5c36f 100644 --- a/__tests__/MiradorShareEmbed.test.js +++ b/__tests__/MiradorShareEmbed.test.js @@ -1,5 +1,4 @@ import React from 'react'; -import { shallow } from 'enzyme'; import MiradorShareEmbed from '../src/MiradorShareEmbed'; /** Utility function to wrap */ diff --git a/__tests__/miradorSharePlugin.test.js b/__tests__/miradorSharePlugin.test.js index 39d3ccf..8a9a6aa 100644 --- a/__tests__/miradorSharePlugin.test.js +++ b/__tests__/miradorSharePlugin.test.js @@ -1,9 +1,9 @@ import React from 'react'; -import { shallow } from 'enzyme'; +import { render, screen } from './utils/test-utils'; import miradorSharePlugin from '../src/miradorSharePlugin'; function createWrapper(props) { - return shallow( + return render( {}} openShareDialog={() => {}} @@ -18,17 +18,17 @@ describe('miradorSharePlugin', () => { }); describe('renders a component', () => { it('renders a thing', () => { - const wrapper = createWrapper(); - expect(wrapper.find('WithStyles(ForwardRef(ListItemText))').props().children).toEqual('Share'); + createWrapper(); + expect(screen.getByText('Share')).toBeInTheDocument(); }); }); describe('MenuItem', () => { it('calls the openShareDialog and handleClose props when clicked', () => { - const handleClose = jest.fn(); - const openShareDialog = jest.fn(); - const wrapper = createWrapper({ handleClose, openShareDialog }); - wrapper.find('WithStyles(ForwardRef(MenuItem))').simulate('click'); + const handleClose = vi.fn(); + const openShareDialog = vi.fn(); + createWrapper({ handleClose, openShareDialog }); + screen.getByText('Share').click(); expect(handleClose).toHaveBeenCalled(); expect(openShareDialog).toHaveBeenCalled(); }); diff --git a/__tests__/utils/test-utils.js b/__tests__/utils/test-utils.js new file mode 100644 index 0000000..baa7c76 --- /dev/null +++ b/__tests__/utils/test-utils.js @@ -0,0 +1,54 @@ +import React from 'react'; +import { Provider } from 'react-redux'; +import { render } from '@testing-library/react'; +import PropTypes from 'prop-types'; +import { createStore, applyMiddleware } from 'redux'; +import { thunk } from 'redux-thunk'; +import { createTheme, ThemeProvider, StyledEngineProvider } from '@mui/material/styles'; +import { rootReducer as createRootReducer, settings } from 'mirador'; + +const rootReducer = createRootReducer(); +const theme = createTheme(settings.theme); + +/** + * Hook up our rendered object to redux + */ +function renderWithProviders( + ui, + { + preloadedState = {}, + // Automatically create a store instance if no store was passed in + store = createStore(rootReducer, preloadedState, applyMiddleware(thunk)), + ...renderOptions + } = {}, +) { + /** :nodoc: */ + function Wrapper({ children }) { + return ( + + + {children} + + + ); + } + + Wrapper.propTypes = { + children: PropTypes.node.isRequired, + }; + + const rendered = render(ui, { wrapper: Wrapper, ...renderOptions }); + + // Return an object with the store and all of RTL's query functions + return { + store, + ...rendered, + rerender: (newUi, options) => render( + newUi, + { container: rendered.container, wrapper: Wrapper, ...options }, + ), + }; +} + +export * from '@testing-library/react'; +export { renderWithProviders as render }; diff --git a/babel.config.js b/babel.config.js deleted file mode 100644 index 6779626..0000000 --- a/babel.config.js +++ /dev/null @@ -1,13 +0,0 @@ -module.exports = { - presets: [ - [ - '@babel/preset-env', - { - targets: { - node: 'current', - }, - }, - ], - '@babel/preset-react', - ], -}; diff --git a/demo/src/index.html b/demo/src/index.html new file mode 100644 index 0000000..c029612 --- /dev/null +++ b/demo/src/index.html @@ -0,0 +1,52 @@ + + + + + + + + Mirador + + + + +
+ + + + + diff --git a/demo/src/index.js b/demo/src/index.js deleted file mode 100644 index 95ffeaf..0000000 --- a/demo/src/index.js +++ /dev/null @@ -1,33 +0,0 @@ -import Mirador from 'mirador/dist/es/src/index'; -import miradorSharePlugins from '../../src'; - -const config = { - id: 'demo', - windows: [{ - loadedManifest: 'https://purl.stanford.edu/sn904cj3429/iiif/manifest', - }], - miradorSharePlugin: { - iiifInfoLink: 'https://iiif.io', - embedOption: { - enabled: true, - embedUrlReplacePattern: [ - /.*\.edu\/(\w+)\/iiif\/manifest/, - 'https://embed.stanford.edu/iframe?url=https://purl.stanford.edu/$1', - ], - syncIframeDimensions: { - height: { param: 'maxheight' }, - }, - }, - shareLink: { - enabled: true, - manifestIdReplacePattern: [ - /\/iiif\/manifest/, - '', - ], - }, - }, -}; - -Mirador.viewer(config, [ - ...miradorSharePlugins, -]); diff --git a/dist/mirador-share-plugin.es.js b/dist/mirador-share-plugin.es.js new file mode 100644 index 0000000..3aad329 --- /dev/null +++ b/dist/mirador-share-plugin.es.js @@ -0,0 +1,44044 @@ +function _3(t, r) { + for (var i = 0; i < r.length; i++) { + const s = r[i]; + if (typeof s != "string" && !Array.isArray(s)) { + for (const u in s) + if (u !== "default" && !(u in t)) { + const f = Object.getOwnPropertyDescriptor(s, u); + f && Object.defineProperty(t, u, f.get ? f : { + enumerable: !0, + get: () => s[u] + }); + } + } + } + return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" })); +} +var Hb = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}; +function Hs(t) { + return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t; +} +function Ql(t) { + if (t.__esModule) return t; + var r = t.default; + if (typeof r == "function") { + var i = function s() { + return this instanceof s ? Reflect.construct(r, arguments, this.constructor) : r.apply(this, arguments); + }; + i.prototype = r.prototype; + } else i = {}; + return Object.defineProperty(i, "__esModule", { value: !0 }), Object.keys(t).forEach(function(s) { + var u = Object.getOwnPropertyDescriptor(t, s); + Object.defineProperty(i, s, u.get ? u : { + enumerable: !0, + get: function() { + return t[s]; + } + }); + }), i; +} +var qb = { exports: {} }, am = {}, Wb = { exports: {} }, ln = {}; +/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var qM; +function x3() { + if (qM) return ln; + qM = 1; + var t = Symbol.for("react.element"), r = Symbol.for("react.portal"), i = Symbol.for("react.fragment"), s = Symbol.for("react.strict_mode"), u = Symbol.for("react.profiler"), f = Symbol.for("react.provider"), p = Symbol.for("react.context"), g = Symbol.for("react.forward_ref"), b = Symbol.for("react.suspense"), S = Symbol.for("react.memo"), x = Symbol.for("react.lazy"), R = Symbol.iterator; + function w(W) { + return W === null || typeof W != "object" ? null : (W = R && W[R] || W["@@iterator"], typeof W == "function" ? W : null); + } + var A = { isMounted: function() { + return !1; + }, enqueueForceUpdate: function() { + }, enqueueReplaceState: function() { + }, enqueueSetState: function() { + } }, I = Object.assign, N = {}; + function P(W, ae, Oe) { + this.props = W, this.context = ae, this.refs = N, this.updater = Oe || A; + } + P.prototype.isReactComponent = {}, P.prototype.setState = function(W, ae) { + if (typeof W != "object" && typeof W != "function" && W != null) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables."); + this.updater.enqueueSetState(this, W, ae, "setState"); + }, P.prototype.forceUpdate = function(W) { + this.updater.enqueueForceUpdate(this, W, "forceUpdate"); + }; + function F() { + } + F.prototype = P.prototype; + function z(W, ae, Oe) { + this.props = W, this.context = ae, this.refs = N, this.updater = Oe || A; + } + var j = z.prototype = new F(); + j.constructor = z, I(j, P.prototype), j.isPureReactComponent = !0; + var U = Array.isArray, O = Object.prototype.hasOwnProperty, H = { current: null }, M = { key: !0, ref: !0, __self: !0, __source: !0 }; + function q(W, ae, Oe) { + var Ce, Ae = {}, Me = null, Ue = null; + if (ae != null) for (Ce in ae.ref !== void 0 && (Ue = ae.ref), ae.key !== void 0 && (Me = "" + ae.key), ae) O.call(ae, Ce) && !M.hasOwnProperty(Ce) && (Ae[Ce] = ae[Ce]); + var De = arguments.length - 2; + if (De === 1) Ae.children = Oe; + else if (1 < De) { + for (var Ne = Array(De), Ge = 0; Ge < De; Ge++) Ne[Ge] = arguments[Ge + 2]; + Ae.children = Ne; + } + if (W && W.defaultProps) for (Ce in De = W.defaultProps, De) Ae[Ce] === void 0 && (Ae[Ce] = De[Ce]); + return { $$typeof: t, type: W, key: Me, ref: Ue, props: Ae, _owner: H.current }; + } + function Y(W, ae) { + return { $$typeof: t, type: W.type, key: ae, ref: W.ref, props: W.props, _owner: W._owner }; + } + function Z(W) { + return typeof W == "object" && W !== null && W.$$typeof === t; + } + function oe(W) { + var ae = { "=": "=0", ":": "=2" }; + return "$" + W.replace(/[=:]/g, function(Oe) { + return ae[Oe]; + }); + } + var xe = /\/+/g; + function se(W, ae) { + return typeof W == "object" && W !== null && W.key != null ? oe("" + W.key) : ae.toString(36); + } + function be(W, ae, Oe, Ce, Ae) { + var Me = typeof W; + (Me === "undefined" || Me === "boolean") && (W = null); + var Ue = !1; + if (W === null) Ue = !0; + else switch (Me) { + case "string": + case "number": + Ue = !0; + break; + case "object": + switch (W.$$typeof) { + case t: + case r: + Ue = !0; + } + } + if (Ue) return Ue = W, Ae = Ae(Ue), W = Ce === "" ? "." + se(Ue, 0) : Ce, U(Ae) ? (Oe = "", W != null && (Oe = W.replace(xe, "$&/") + "/"), be(Ae, ae, Oe, "", function(Ge) { + return Ge; + })) : Ae != null && (Z(Ae) && (Ae = Y(Ae, Oe + (!Ae.key || Ue && Ue.key === Ae.key ? "" : ("" + Ae.key).replace(xe, "$&/") + "/") + W)), ae.push(Ae)), 1; + if (Ue = 0, Ce = Ce === "" ? "." : Ce + ":", U(W)) for (var De = 0; De < W.length; De++) { + Me = W[De]; + var Ne = Ce + se(Me, De); + Ue += be(Me, ae, Oe, Ne, Ae); + } + else if (Ne = w(W), typeof Ne == "function") for (W = Ne.call(W), De = 0; !(Me = W.next()).done; ) Me = Me.value, Ne = Ce + se(Me, De++), Ue += be(Me, ae, Oe, Ne, Ae); + else if (Me === "object") throw ae = String(W), Error("Objects are not valid as a React child (found: " + (ae === "[object Object]" ? "object with keys {" + Object.keys(W).join(", ") + "}" : ae) + "). If you meant to render a collection of children, use an array instead."); + return Ue; + } + function Ee(W, ae, Oe) { + if (W == null) return W; + var Ce = [], Ae = 0; + return be(W, Ce, "", "", function(Me) { + return ae.call(Oe, Me, Ae++); + }), Ce; + } + function Se(W) { + if (W._status === -1) { + var ae = W._result; + ae = ae(), ae.then(function(Oe) { + (W._status === 0 || W._status === -1) && (W._status = 1, W._result = Oe); + }, function(Oe) { + (W._status === 0 || W._status === -1) && (W._status = 2, W._result = Oe); + }), W._status === -1 && (W._status = 0, W._result = ae); + } + if (W._status === 1) return W._result.default; + throw W._result; + } + var me = { current: null }, ie = { transition: null }, Ie = { ReactCurrentDispatcher: me, ReactCurrentBatchConfig: ie, ReactCurrentOwner: H }; + function ee() { + throw Error("act(...) is not supported in production builds of React."); + } + return ln.Children = { map: Ee, forEach: function(W, ae, Oe) { + Ee(W, function() { + ae.apply(this, arguments); + }, Oe); + }, count: function(W) { + var ae = 0; + return Ee(W, function() { + ae++; + }), ae; + }, toArray: function(W) { + return Ee(W, function(ae) { + return ae; + }) || []; + }, only: function(W) { + if (!Z(W)) throw Error("React.Children.only expected to receive a single React element child."); + return W; + } }, ln.Component = P, ln.Fragment = i, ln.Profiler = u, ln.PureComponent = z, ln.StrictMode = s, ln.Suspense = b, ln.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Ie, ln.act = ee, ln.cloneElement = function(W, ae, Oe) { + if (W == null) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + W + "."); + var Ce = I({}, W.props), Ae = W.key, Me = W.ref, Ue = W._owner; + if (ae != null) { + if (ae.ref !== void 0 && (Me = ae.ref, Ue = H.current), ae.key !== void 0 && (Ae = "" + ae.key), W.type && W.type.defaultProps) var De = W.type.defaultProps; + for (Ne in ae) O.call(ae, Ne) && !M.hasOwnProperty(Ne) && (Ce[Ne] = ae[Ne] === void 0 && De !== void 0 ? De[Ne] : ae[Ne]); + } + var Ne = arguments.length - 2; + if (Ne === 1) Ce.children = Oe; + else if (1 < Ne) { + De = Array(Ne); + for (var Ge = 0; Ge < Ne; Ge++) De[Ge] = arguments[Ge + 2]; + Ce.children = De; + } + return { $$typeof: t, type: W.type, key: Ae, ref: Me, props: Ce, _owner: Ue }; + }, ln.createContext = function(W) { + return W = { $$typeof: p, _currentValue: W, _currentValue2: W, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null }, W.Provider = { $$typeof: f, _context: W }, W.Consumer = W; + }, ln.createElement = q, ln.createFactory = function(W) { + var ae = q.bind(null, W); + return ae.type = W, ae; + }, ln.createRef = function() { + return { current: null }; + }, ln.forwardRef = function(W) { + return { $$typeof: g, render: W }; + }, ln.isValidElement = Z, ln.lazy = function(W) { + return { $$typeof: x, _payload: { _status: -1, _result: W }, _init: Se }; + }, ln.memo = function(W, ae) { + return { $$typeof: S, type: W, compare: ae === void 0 ? null : ae }; + }, ln.startTransition = function(W) { + var ae = ie.transition; + ie.transition = {}; + try { + W(); + } finally { + ie.transition = ae; + } + }, ln.unstable_act = ee, ln.useCallback = function(W, ae) { + return me.current.useCallback(W, ae); + }, ln.useContext = function(W) { + return me.current.useContext(W); + }, ln.useDebugValue = function() { + }, ln.useDeferredValue = function(W) { + return me.current.useDeferredValue(W); + }, ln.useEffect = function(W, ae) { + return me.current.useEffect(W, ae); + }, ln.useId = function() { + return me.current.useId(); + }, ln.useImperativeHandle = function(W, ae, Oe) { + return me.current.useImperativeHandle(W, ae, Oe); + }, ln.useInsertionEffect = function(W, ae) { + return me.current.useInsertionEffect(W, ae); + }, ln.useLayoutEffect = function(W, ae) { + return me.current.useLayoutEffect(W, ae); + }, ln.useMemo = function(W, ae) { + return me.current.useMemo(W, ae); + }, ln.useReducer = function(W, ae, Oe) { + return me.current.useReducer(W, ae, Oe); + }, ln.useRef = function(W) { + return me.current.useRef(W); + }, ln.useState = function(W) { + return me.current.useState(W); + }, ln.useSyncExternalStore = function(W, ae, Oe) { + return me.current.useSyncExternalStore(W, ae, Oe); + }, ln.useTransition = function() { + return me.current.useTransition(); + }, ln.version = "18.3.1", ln; +} +var Em = { exports: {} }; +/** + * @license React + * react.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +Em.exports; +var WM; +function T3() { + return WM || (WM = 1, function(t, r) { + process.env.NODE_ENV !== "production" && function() { + typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + var i = "18.3.1", s = Symbol.for("react.element"), u = Symbol.for("react.portal"), f = Symbol.for("react.fragment"), p = Symbol.for("react.strict_mode"), g = Symbol.for("react.profiler"), b = Symbol.for("react.provider"), S = Symbol.for("react.context"), x = Symbol.for("react.forward_ref"), R = Symbol.for("react.suspense"), w = Symbol.for("react.suspense_list"), A = Symbol.for("react.memo"), I = Symbol.for("react.lazy"), N = Symbol.for("react.offscreen"), P = Symbol.iterator, F = "@@iterator"; + function z(D) { + if (D === null || typeof D != "object") + return null; + var Q = P && D[P] || D[F]; + return typeof Q == "function" ? Q : null; + } + var j = { + /** + * @internal + * @type {ReactComponent} + */ + current: null + }, U = { + transition: null + }, O = { + current: null, + // Used to reproduce behavior of `batchedUpdates` in legacy mode. + isBatchingLegacy: !1, + didScheduleLegacyUpdate: !1 + }, H = { + /** + * @internal + * @type {ReactComponent} + */ + current: null + }, M = {}, q = null; + function Y(D) { + q = D; + } + M.setExtraStackFrame = function(D) { + q = D; + }, M.getCurrentStack = null, M.getStackAddendum = function() { + var D = ""; + q && (D += q); + var Q = M.getCurrentStack; + return Q && (D += Q() || ""), D; + }; + var Z = !1, oe = !1, xe = !1, se = !1, be = !1, Ee = { + ReactCurrentDispatcher: j, + ReactCurrentBatchConfig: U, + ReactCurrentOwner: H + }; + Ee.ReactDebugCurrentFrame = M, Ee.ReactCurrentActQueue = O; + function Se(D) { + { + for (var Q = arguments.length, he = new Array(Q > 1 ? Q - 1 : 0), _e = 1; _e < Q; _e++) + he[_e - 1] = arguments[_e]; + ie("warn", D, he); + } + } + function me(D) { + { + for (var Q = arguments.length, he = new Array(Q > 1 ? Q - 1 : 0), _e = 1; _e < Q; _e++) + he[_e - 1] = arguments[_e]; + ie("error", D, he); + } + } + function ie(D, Q, he) { + { + var _e = Ee.ReactDebugCurrentFrame, Be = _e.getStackAddendum(); + Be !== "" && (Q += "%s", he = he.concat([Be])); + var wt = he.map(function(Ze) { + return String(Ze); + }); + wt.unshift("Warning: " + Q), Function.prototype.apply.call(console[D], console, wt); + } + } + var Ie = {}; + function ee(D, Q) { + { + var he = D.constructor, _e = he && (he.displayName || he.name) || "ReactClass", Be = _e + "." + Q; + if (Ie[Be]) + return; + me("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", Q, _e), Ie[Be] = !0; + } + } + var W = { + /** + * Checks whether or not this composite component is mounted. + * @param {ReactClass} publicInstance The instance we want to test. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ + isMounted: function(D) { + return !1; + }, + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueForceUpdate: function(D, Q, he) { + ee(D, "forceUpdate"); + }, + /** + * Replaces all of the state. Always use this or `setState` to mutate state. + * You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} completeState Next state. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueReplaceState: function(D, Q, he, _e) { + ee(D, "replaceState"); + }, + /** + * Sets a subset of the state. This only exists because _pendingState is + * internal. This provides a merging strategy that is not available to deep + * properties which is confusing. TODO: Expose pendingState or don't use it + * during the merge. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} partialState Next partial state to be merged with state. + * @param {?function} callback Called after component is updated. + * @param {?string} Name of the calling function in the public API. + * @internal + */ + enqueueSetState: function(D, Q, he, _e) { + ee(D, "setState"); + } + }, ae = Object.assign, Oe = {}; + Object.freeze(Oe); + function Ce(D, Q, he) { + this.props = D, this.context = Q, this.refs = Oe, this.updater = he || W; + } + Ce.prototype.isReactComponent = {}, Ce.prototype.setState = function(D, Q) { + if (typeof D != "object" && typeof D != "function" && D != null) + throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables."); + this.updater.enqueueSetState(this, D, Q, "setState"); + }, Ce.prototype.forceUpdate = function(D) { + this.updater.enqueueForceUpdate(this, D, "forceUpdate"); + }; + { + var Ae = { + isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."], + replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."] + }, Me = function(D, Q) { + Object.defineProperty(Ce.prototype, D, { + get: function() { + Se("%s(...) is deprecated in plain JavaScript React classes. %s", Q[0], Q[1]); + } + }); + }; + for (var Ue in Ae) + Ae.hasOwnProperty(Ue) && Me(Ue, Ae[Ue]); + } + function De() { + } + De.prototype = Ce.prototype; + function Ne(D, Q, he) { + this.props = D, this.context = Q, this.refs = Oe, this.updater = he || W; + } + var Ge = Ne.prototype = new De(); + Ge.constructor = Ne, ae(Ge, Ce.prototype), Ge.isPureReactComponent = !0; + function Je() { + var D = { + current: null + }; + return Object.seal(D), D; + } + var ue = Array.isArray; + function Ye(D) { + return ue(D); + } + function Te(D) { + { + var Q = typeof Symbol == "function" && Symbol.toStringTag, he = Q && D[Symbol.toStringTag] || D.constructor.name || "Object"; + return he; + } + } + function ot(D) { + try { + return jt(D), !1; + } catch { + return !0; + } + } + function jt(D) { + return "" + D; + } + function Ht(D) { + if (ot(D)) + return me("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Te(D)), jt(D); + } + function Dn(D, Q, he) { + var _e = D.displayName; + if (_e) + return _e; + var Be = Q.displayName || Q.name || ""; + return Be !== "" ? he + "(" + Be + ")" : he; + } + function Ln(D) { + return D.displayName || "Context"; + } + function Sn(D) { + if (D == null) + return null; + if (typeof D.tag == "number" && me("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof D == "function") + return D.displayName || D.name || null; + if (typeof D == "string") + return D; + switch (D) { + case f: + return "Fragment"; + case u: + return "Portal"; + case g: + return "Profiler"; + case p: + return "StrictMode"; + case R: + return "Suspense"; + case w: + return "SuspenseList"; + } + if (typeof D == "object") + switch (D.$$typeof) { + case S: + var Q = D; + return Ln(Q) + ".Consumer"; + case b: + var he = D; + return Ln(he._context) + ".Provider"; + case x: + return Dn(D, D.render, "ForwardRef"); + case A: + var _e = D.displayName || null; + return _e !== null ? _e : Sn(D.type) || "Memo"; + case I: { + var Be = D, wt = Be._payload, Ze = Be._init; + try { + return Sn(Ze(wt)); + } catch { + return null; + } + } + } + return null; + } + var Yt = Object.prototype.hasOwnProperty, qn = { + key: !0, + ref: !0, + __self: !0, + __source: !0 + }, Cn, Jt, xn; + xn = {}; + function dr(D) { + if (Yt.call(D, "ref")) { + var Q = Object.getOwnPropertyDescriptor(D, "ref").get; + if (Q && Q.isReactWarning) + return !1; + } + return D.ref !== void 0; + } + function dn(D) { + if (Yt.call(D, "key")) { + var Q = Object.getOwnPropertyDescriptor(D, "key").get; + if (Q && Q.isReactWarning) + return !1; + } + return D.key !== void 0; + } + function Pt(D, Q) { + var he = function() { + Cn || (Cn = !0, me("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", Q)); + }; + he.isReactWarning = !0, Object.defineProperty(D, "key", { + get: he, + configurable: !0 + }); + } + function bt(D, Q) { + var he = function() { + Jt || (Jt = !0, me("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", Q)); + }; + he.isReactWarning = !0, Object.defineProperty(D, "ref", { + get: he, + configurable: !0 + }); + } + function ir(D) { + if (typeof D.ref == "string" && H.current && D.__self && H.current.stateNode !== D.__self) { + var Q = Sn(H.current.type); + xn[Q] || (me('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', Q, D.ref), xn[Q] = !0); + } + } + var qe = function(D, Q, he, _e, Be, wt, Ze) { + var Tt = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: s, + // Built-in properties that belong on the element + type: D, + key: Q, + ref: he, + props: Ze, + // Record the component responsible for creating this element. + _owner: wt + }; + return Tt._store = {}, Object.defineProperty(Tt._store, "validated", { + configurable: !1, + enumerable: !1, + writable: !0, + value: !1 + }), Object.defineProperty(Tt, "_self", { + configurable: !1, + enumerable: !1, + writable: !1, + value: _e + }), Object.defineProperty(Tt, "_source", { + configurable: !1, + enumerable: !1, + writable: !1, + value: Be + }), Object.freeze && (Object.freeze(Tt.props), Object.freeze(Tt)), Tt; + }; + function lt(D, Q, he) { + var _e, Be = {}, wt = null, Ze = null, Tt = null, Xt = null; + if (Q != null) { + dr(Q) && (Ze = Q.ref, ir(Q)), dn(Q) && (Ht(Q.key), wt = "" + Q.key), Tt = Q.__self === void 0 ? null : Q.__self, Xt = Q.__source === void 0 ? null : Q.__source; + for (_e in Q) + Yt.call(Q, _e) && !qn.hasOwnProperty(_e) && (Be[_e] = Q[_e]); + } + var cn = arguments.length - 2; + if (cn === 1) + Be.children = he; + else if (cn > 1) { + for (var Gn = Array(cn), Nn = 0; Nn < cn; Nn++) + Gn[Nn] = arguments[Nn + 2]; + Object.freeze && Object.freeze(Gn), Be.children = Gn; + } + if (D && D.defaultProps) { + var Yn = D.defaultProps; + for (_e in Yn) + Be[_e] === void 0 && (Be[_e] = Yn[_e]); + } + if (wt || Ze) { + var Qn = typeof D == "function" ? D.displayName || D.name || "Unknown" : D; + wt && Pt(Be, Qn), Ze && bt(Be, Qn); + } + return qe(D, wt, Ze, Tt, Xt, H.current, Be); + } + function $t(D, Q) { + var he = qe(D.type, Q, D.ref, D._self, D._source, D._owner, D.props); + return he; + } + function We(D, Q, he) { + if (D == null) + throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + D + "."); + var _e, Be = ae({}, D.props), wt = D.key, Ze = D.ref, Tt = D._self, Xt = D._source, cn = D._owner; + if (Q != null) { + dr(Q) && (Ze = Q.ref, cn = H.current), dn(Q) && (Ht(Q.key), wt = "" + Q.key); + var Gn; + D.type && D.type.defaultProps && (Gn = D.type.defaultProps); + for (_e in Q) + Yt.call(Q, _e) && !qn.hasOwnProperty(_e) && (Q[_e] === void 0 && Gn !== void 0 ? Be[_e] = Gn[_e] : Be[_e] = Q[_e]); + } + var Nn = arguments.length - 2; + if (Nn === 1) + Be.children = he; + else if (Nn > 1) { + for (var Yn = Array(Nn), Qn = 0; Qn < Nn; Qn++) + Yn[Qn] = arguments[Qn + 2]; + Be.children = Yn; + } + return qe(D.type, wt, Ze, Tt, Xt, cn, Be); + } + function ft(D) { + return typeof D == "object" && D !== null && D.$$typeof === s; + } + var Qt = ".", Tn = ":"; + function Ar(D) { + var Q = /[=:]/g, he = { + "=": "=0", + ":": "=2" + }, _e = D.replace(Q, function(Be) { + return he[Be]; + }); + return "$" + _e; + } + var An = !1, di = /\/+/g; + function Rn(D) { + return D.replace(di, "$&/"); + } + function wn(D, Q) { + return typeof D == "object" && D !== null && D.key != null ? (Ht(D.key), Ar("" + D.key)) : Q.toString(36); + } + function Ho(D, Q, he, _e, Be) { + var wt = typeof D; + (wt === "undefined" || wt === "boolean") && (D = null); + var Ze = !1; + if (D === null) + Ze = !0; + else + switch (wt) { + case "string": + case "number": + Ze = !0; + break; + case "object": + switch (D.$$typeof) { + case s: + case u: + Ze = !0; + } + } + if (Ze) { + var Tt = D, Xt = Be(Tt), cn = _e === "" ? Qt + wn(Tt, 0) : _e; + if (Ye(Xt)) { + var Gn = ""; + cn != null && (Gn = Rn(cn) + "/"), Ho(Xt, Q, Gn, "", function(ov) { + return ov; + }); + } else Xt != null && (ft(Xt) && (Xt.key && (!Tt || Tt.key !== Xt.key) && Ht(Xt.key), Xt = $t( + Xt, + // Keep both the (mapped) and old keys if they differ, just as + // traverseAllChildren used to do for objects as children + he + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key + (Xt.key && (!Tt || Tt.key !== Xt.key) ? ( + // $FlowFixMe Flow incorrectly thinks existing element's key can be a number + // eslint-disable-next-line react-internal/safe-string-coercion + Rn("" + Xt.key) + "/" + ) : "") + cn + )), Q.push(Xt)); + return 1; + } + var Nn, Yn, Qn = 0, an = _e === "" ? Qt : _e + Tn; + if (Ye(D)) + for (var Ia = 0; Ia < D.length; Ia++) + Nn = D[Ia], Yn = an + wn(Nn, Ia), Qn += Ho(Nn, Q, he, Yn, Be); + else { + var ou = z(D); + if (typeof ou == "function") { + var yc = D; + ou === yc.entries && (An || Se("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), An = !0); + for (var iv = ou.call(yc), Yo, gc = 0; !(Yo = iv.next()).done; ) + Nn = Yo.value, Yn = an + wn(Nn, gc++), Qn += Ho(Nn, Q, he, Yn, Be); + } else if (wt === "object") { + var bc = String(D); + throw new Error("Objects are not valid as a React child (found: " + (bc === "[object Object]" ? "object with keys {" + Object.keys(D).join(", ") + "}" : bc) + "). If you meant to render a collection of children, use an array instead."); + } + } + return Qn; + } + function mo(D, Q, he) { + if (D == null) + return D; + var _e = [], Be = 0; + return Ho(D, _e, "", "", function(wt) { + return Q.call(he, wt, Be++); + }), _e; + } + function ll(D) { + var Q = 0; + return mo(D, function() { + Q++; + }), Q; + } + function Jl(D, Q, he) { + mo(D, function() { + Q.apply(this, arguments); + }, he); + } + function Ys(D) { + return mo(D, function(Q) { + return Q; + }) || []; + } + function Da(D) { + if (!ft(D)) + throw new Error("React.Children.only expected to receive a single React element child."); + return D; + } + function sl(D) { + var Q = { + $$typeof: S, + // As a workaround to support multiple concurrent renderers, we categorize + // some renderers as primary and others as secondary. We only expect + // there to be two concurrent renderers at most: React Native (primary) and + // Fabric (secondary); React DOM (primary) and React ART (secondary). + // Secondary renderers store their context values on separate fields. + _currentValue: D, + _currentValue2: D, + // Used to track how many concurrent renderers this context currently + // supports within in a single renderer. Such as parallel server rendering. + _threadCount: 0, + // These are circular + Provider: null, + Consumer: null, + // Add these to use same hidden class in VM as ServerContext + _defaultValue: null, + _globalName: null + }; + Q.Provider = { + $$typeof: b, + _context: Q + }; + var he = !1, _e = !1, Be = !1; + { + var wt = { + $$typeof: S, + _context: Q + }; + Object.defineProperties(wt, { + Provider: { + get: function() { + return _e || (_e = !0, me("Rendering is not supported and will be removed in a future major release. Did you mean to render instead?")), Q.Provider; + }, + set: function(Ze) { + Q.Provider = Ze; + } + }, + _currentValue: { + get: function() { + return Q._currentValue; + }, + set: function(Ze) { + Q._currentValue = Ze; + } + }, + _currentValue2: { + get: function() { + return Q._currentValue2; + }, + set: function(Ze) { + Q._currentValue2 = Ze; + } + }, + _threadCount: { + get: function() { + return Q._threadCount; + }, + set: function(Ze) { + Q._threadCount = Ze; + } + }, + Consumer: { + get: function() { + return he || (he = !0, me("Rendering is not supported and will be removed in a future major release. Did you mean to render instead?")), Q.Consumer; + } + }, + displayName: { + get: function() { + return Q.displayName; + }, + set: function(Ze) { + Be || (Se("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", Ze), Be = !0); + } + } + }), Q.Consumer = wt; + } + return Q._currentRenderer = null, Q._currentRenderer2 = null, Q; + } + var eo = -1, oa = 0, to = 1, qo = 2; + function pi(D) { + if (D._status === eo) { + var Q = D._result, he = Q(); + if (he.then(function(wt) { + if (D._status === oa || D._status === eo) { + var Ze = D; + Ze._status = to, Ze._result = wt; + } + }, function(wt) { + if (D._status === oa || D._status === eo) { + var Ze = D; + Ze._status = qo, Ze._result = wt; + } + }), D._status === eo) { + var _e = D; + _e._status = oa, _e._result = he; + } + } + if (D._status === to) { + var Be = D._result; + return Be === void 0 && me(`lazy: Expected the result of a dynamic import() call. Instead received: %s + +Your code should look like: + const MyComponent = lazy(() => import('./MyComponent')) + +Did you accidentally put curly braces around the import?`, Be), "default" in Be || me(`lazy: Expected the result of a dynamic import() call. Instead received: %s + +Your code should look like: + const MyComponent = lazy(() => import('./MyComponent'))`, Be), Be.default; + } else + throw D._result; + } + function no(D) { + var Q = { + // We use these fields to store the result. + _status: eo, + _result: D + }, he = { + $$typeof: I, + _payload: Q, + _init: pi + }; + { + var _e, Be; + Object.defineProperties(he, { + defaultProps: { + configurable: !0, + get: function() { + return _e; + }, + set: function(wt) { + me("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), _e = wt, Object.defineProperty(he, "defaultProps", { + enumerable: !0 + }); + } + }, + propTypes: { + configurable: !0, + get: function() { + return Be; + }, + set: function(wt) { + me("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), Be = wt, Object.defineProperty(he, "propTypes", { + enumerable: !0 + }); + } + } + }); + } + return he; + } + function aa(D) { + D != null && D.$$typeof === A ? me("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof D != "function" ? me("forwardRef requires a render function but was given %s.", D === null ? "null" : typeof D) : D.length !== 0 && D.length !== 2 && me("forwardRef render functions accept exactly two parameters: props and ref. %s", D.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."), D != null && (D.defaultProps != null || D.propTypes != null) && me("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?"); + var Q = { + $$typeof: x, + render: D + }; + { + var he; + Object.defineProperty(Q, "displayName", { + enumerable: !1, + configurable: !0, + get: function() { + return he; + }, + set: function(_e) { + he = _e, !D.name && !D.displayName && (D.displayName = _e); + } + }); + } + return Q; + } + var la; + la = Symbol.for("react.module.reference"); + function X(D) { + return !!(typeof D == "string" || typeof D == "function" || D === f || D === g || be || D === p || D === R || D === w || se || D === N || Z || oe || xe || typeof D == "object" && D !== null && (D.$$typeof === I || D.$$typeof === A || D.$$typeof === b || D.$$typeof === S || D.$$typeof === x || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + D.$$typeof === la || D.getModuleId !== void 0)); + } + function je(D, Q) { + X(D) || me("memo: The first argument must be a component. Instead received: %s", D === null ? "null" : typeof D); + var he = { + $$typeof: A, + type: D, + compare: Q === void 0 ? null : Q + }; + { + var _e; + Object.defineProperty(he, "displayName", { + enumerable: !1, + configurable: !0, + get: function() { + return _e; + }, + set: function(Be) { + _e = Be, !D.name && !D.displayName && (D.displayName = Be); + } + }); + } + return he; + } + function Ve() { + var D = j.current; + return D === null && me(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons: +1. You might have mismatching versions of React and the renderer (such as React DOM) +2. You might be breaking the Rules of Hooks +3. You might have more than one copy of React in the same app +See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.`), D; + } + function ht(D) { + var Q = Ve(); + if (D._context !== void 0) { + var he = D._context; + he.Consumer === D ? me("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?") : he.Provider === D && me("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?"); + } + return Q.useContext(D); + } + function en(D) { + var Q = Ve(); + return Q.useState(D); + } + function rn(D, Q, he) { + var _e = Ve(); + return _e.useReducer(D, Q, he); + } + function Rt(D) { + var Q = Ve(); + return Q.useRef(D); + } + function qt(D, Q) { + var he = Ve(); + return he.useEffect(D, Q); + } + function Tr(D, Q) { + var he = Ve(); + return he.useInsertionEffect(D, Q); + } + function Wn(D, Q) { + var he = Ve(); + return he.useLayoutEffect(D, Q); + } + function Jn(D, Q) { + var he = Ve(); + return he.useCallback(D, Q); + } + function ai(D, Q) { + var he = Ve(); + return he.useMemo(D, Q); + } + function sa(D, Q, he) { + var _e = Ve(); + return _e.useImperativeHandle(D, Q, he); + } + function pn(D, Q) { + { + var he = Ve(); + return he.useDebugValue(D, Q); + } + } + function zr() { + var D = Ve(); + return D.useTransition(); + } + function vi(D) { + var Q = Ve(); + return Q.useDeferredValue(D); + } + function Wt() { + var D = Ve(); + return D.useId(); + } + function yo(D, Q, he) { + var _e = Ve(); + return _e.useSyncExternalStore(D, Q, he); + } + var ul = 0, Ks, cl, Ai, pc, hi, vc, hc; + function If() { + } + If.__reactDisabledLog = !0; + function Qs() { + { + if (ul === 0) { + Ks = console.log, cl = console.info, Ai = console.warn, pc = console.error, hi = console.group, vc = console.groupCollapsed, hc = console.groupEnd; + var D = { + configurable: !0, + enumerable: !0, + value: If, + writable: !0 + }; + Object.defineProperties(console, { + info: D, + log: D, + warn: D, + error: D, + group: D, + groupCollapsed: D, + groupEnd: D + }); + } + ul++; + } + } + function fl() { + { + if (ul--, ul === 0) { + var D = { + configurable: !0, + enumerable: !0, + writable: !0 + }; + Object.defineProperties(console, { + log: ae({}, D, { + value: Ks + }), + info: ae({}, D, { + value: cl + }), + warn: ae({}, D, { + value: Ai + }), + error: ae({}, D, { + value: pc + }), + group: ae({}, D, { + value: hi + }), + groupCollapsed: ae({}, D, { + value: vc + }), + groupEnd: ae({}, D, { + value: hc + }) + }); + } + ul < 0 && me("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + var Wo = Ee.ReactCurrentDispatcher, mi; + function dl(D, Q, he) { + { + if (mi === void 0) + try { + throw Error(); + } catch (Be) { + var _e = Be.stack.trim().match(/\n( *(at )?)/); + mi = _e && _e[1] || ""; + } + return ` +` + mi + D; + } + } + var pl = !1, vl; + { + var Xs = typeof WeakMap == "function" ? WeakMap : Map; + vl = new Xs(); + } + function Zs(D, Q) { + if (!D || pl) + return ""; + { + var he = vl.get(D); + if (he !== void 0) + return he; + } + var _e; + pl = !0; + var Be = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var wt; + wt = Wo.current, Wo.current = null, Qs(); + try { + if (Q) { + var Ze = function() { + throw Error(); + }; + if (Object.defineProperty(Ze.prototype, "props", { + set: function() { + throw Error(); + } + }), typeof Reflect == "object" && Reflect.construct) { + try { + Reflect.construct(Ze, []); + } catch (an) { + _e = an; + } + Reflect.construct(D, [], Ze); + } else { + try { + Ze.call(); + } catch (an) { + _e = an; + } + D.call(Ze.prototype); + } + } else { + try { + throw Error(); + } catch (an) { + _e = an; + } + D(); + } + } catch (an) { + if (an && _e && typeof an.stack == "string") { + for (var Tt = an.stack.split(` +`), Xt = _e.stack.split(` +`), cn = Tt.length - 1, Gn = Xt.length - 1; cn >= 1 && Gn >= 0 && Tt[cn] !== Xt[Gn]; ) + Gn--; + for (; cn >= 1 && Gn >= 0; cn--, Gn--) + if (Tt[cn] !== Xt[Gn]) { + if (cn !== 1 || Gn !== 1) + do + if (cn--, Gn--, Gn < 0 || Tt[cn] !== Xt[Gn]) { + var Nn = ` +` + Tt[cn].replace(" at new ", " at "); + return D.displayName && Nn.includes("") && (Nn = Nn.replace("", D.displayName)), typeof D == "function" && vl.set(D, Nn), Nn; + } + while (cn >= 1 && Gn >= 0); + break; + } + } + } finally { + pl = !1, Wo.current = wt, fl(), Error.prepareStackTrace = Be; + } + var Yn = D ? D.displayName || D.name : "", Qn = Yn ? dl(Yn) : ""; + return typeof D == "function" && vl.set(D, Qn), Qn; + } + function Aa(D, Q, he) { + return Zs(D, !1); + } + function rv(D) { + var Q = D.prototype; + return !!(Q && Q.isReactComponent); + } + function ua(D, Q, he) { + if (D == null) + return ""; + if (typeof D == "function") + return Zs(D, rv(D)); + if (typeof D == "string") + return dl(D); + switch (D) { + case R: + return dl("Suspense"); + case w: + return dl("SuspenseList"); + } + if (typeof D == "object") + switch (D.$$typeof) { + case x: + return Aa(D.render); + case A: + return ua(D.type, Q, he); + case I: { + var _e = D, Be = _e._payload, wt = _e._init; + try { + return ua(wt(Be), Q, he); + } catch { + } + } + } + return ""; + } + var vn = {}, Js = Ee.ReactDebugCurrentFrame; + function es(D) { + if (D) { + var Q = D._owner, he = ua(D.type, D._source, Q ? Q.type : null); + Js.setExtraStackFrame(he); + } else + Js.setExtraStackFrame(null); + } + function eu(D, Q, he, _e, Be) { + { + var wt = Function.call.bind(Yt); + for (var Ze in D) + if (wt(D, Ze)) { + var Tt = void 0; + try { + if (typeof D[Ze] != "function") { + var Xt = Error((_e || "React class") + ": " + he + " type `" + Ze + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof D[Ze] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."); + throw Xt.name = "Invariant Violation", Xt; + } + Tt = D[Ze](Q, Ze, _e, he, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"); + } catch (cn) { + Tt = cn; + } + Tt && !(Tt instanceof Error) && (es(Be), me("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", _e || "React class", he, Ze, typeof Tt), es(null)), Tt instanceof Error && !(Tt.message in vn) && (vn[Tt.message] = !0, es(Be), me("Failed %s type: %s", he, Tt.message), es(null)); + } + } + } + function on(D) { + if (D) { + var Q = D._owner, he = ua(D.type, D._source, Q ? Q.type : null); + Y(he); + } else + Y(null); + } + var tu; + tu = !1; + function nu() { + if (H.current) { + var D = Sn(H.current.type); + if (D) + return ` + +Check the render method of \`` + D + "`."; + } + return ""; + } + function It(D) { + if (D !== void 0) { + var Q = D.fileName.replace(/^.*[\\\/]/, ""), he = D.lineNumber; + return ` + +Check your code at ` + Q + ":" + he + "."; + } + return ""; + } + function ts(D) { + return D != null ? It(D.__source) : ""; + } + var sr = {}; + function Ni(D) { + var Q = nu(); + if (!Q) { + var he = typeof D == "string" ? D : D.displayName || D.name; + he && (Q = ` + +Check the top-level render call using <` + he + ">."); + } + return Q; + } + function yi(D, Q) { + if (!(!D._store || D._store.validated || D.key != null)) { + D._store.validated = !0; + var he = Ni(Q); + if (!sr[he]) { + sr[he] = !0; + var _e = ""; + D && D._owner && D._owner !== H.current && (_e = " It was passed a child from " + Sn(D._owner.type) + "."), on(D), me('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', he, _e), on(null); + } + } + } + function hl(D, Q) { + if (typeof D == "object") { + if (Ye(D)) + for (var he = 0; he < D.length; he++) { + var _e = D[he]; + ft(_e) && yi(_e, Q); + } + else if (ft(D)) + D._store && (D._store.validated = !0); + else if (D) { + var Be = z(D); + if (typeof Be == "function" && Be !== D.entries) + for (var wt = Be.call(D), Ze; !(Ze = wt.next()).done; ) + ft(Ze.value) && yi(Ze.value, Q); + } + } + } + function pr(D) { + { + var Q = D.type; + if (Q == null || typeof Q == "string") + return; + var he; + if (typeof Q == "function") + he = Q.propTypes; + else if (typeof Q == "object" && (Q.$$typeof === x || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + Q.$$typeof === A)) + he = Q.propTypes; + else + return; + if (he) { + var _e = Sn(Q); + eu(he, D.props, "prop", _e, D); + } else if (Q.PropTypes !== void 0 && !tu) { + tu = !0; + var Be = Sn(Q); + me("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", Be || "Unknown"); + } + typeof Q.getDefaultProps == "function" && !Q.getDefaultProps.isReactClassApproved && me("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead."); + } + } + function On(D) { + { + for (var Q = Object.keys(D.props), he = 0; he < Q.length; he++) { + var _e = Q[he]; + if (_e !== "children" && _e !== "key") { + on(D), me("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", _e), on(null); + break; + } + } + D.ref !== null && (on(D), me("Invalid attribute `ref` supplied to `React.Fragment`."), on(null)); + } + } + function Lf(D, Q, he) { + var _e = X(D); + if (!_e) { + var Be = ""; + (D === void 0 || typeof D == "object" && D !== null && Object.keys(D).length === 0) && (Be += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports."); + var wt = ts(Q); + wt ? Be += wt : Be += nu(); + var Ze; + D === null ? Ze = "null" : Ye(D) ? Ze = "array" : D !== void 0 && D.$$typeof === s ? (Ze = "<" + (Sn(D.type) || "Unknown") + " />", Be = " Did you accidentally export a JSX literal instead of a component?") : Ze = typeof D, me("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", Ze, Be); + } + var Tt = lt.apply(this, arguments); + if (Tt == null) + return Tt; + if (_e) + for (var Xt = 2; Xt < arguments.length; Xt++) + hl(arguments[Xt], D); + return D === f ? On(Tt) : pr(Tt), Tt; + } + var Pi = !1; + function Ur(D) { + var Q = Lf.bind(null, D); + return Q.type = D, Pi || (Pi = !0, Se("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")), Object.defineProperty(Q, "type", { + enumerable: !1, + get: function() { + return Se("Factory.type is deprecated. Access the class directly before passing it to createFactory."), Object.defineProperty(this, "type", { + value: D + }), D; + } + }), Q; + } + function ca(D, Q, he) { + for (var _e = We.apply(this, arguments), Be = 2; Be < arguments.length; Be++) + hl(arguments[Be], _e.type); + return pr(_e), _e; + } + function jf(D, Q) { + var he = U.transition; + U.transition = {}; + var _e = U.transition; + U.transition._updatedFibers = /* @__PURE__ */ new Set(); + try { + D(); + } finally { + if (U.transition = he, he === null && _e._updatedFibers) { + var Be = _e._updatedFibers.size; + Be > 10 && Se("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."), _e._updatedFibers.clear(); + } + } + } + var Na = !1, ml = null; + function $f(D) { + if (ml === null) + try { + var Q = ("require" + Math.random()).slice(0, 7), he = t && t[Q]; + ml = he.call(t, "timers").setImmediate; + } catch { + ml = function(Be) { + Na === !1 && (Na = !0, typeof MessageChannel > "u" && me("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning.")); + var wt = new MessageChannel(); + wt.port1.onmessage = Be, wt.port2.postMessage(void 0); + }; + } + return ml(D); + } + var go = 0, yl = !1; + function Pa(D) { + { + var Q = go; + go++, O.current === null && (O.current = []); + var he = O.isBatchingLegacy, _e; + try { + if (O.isBatchingLegacy = !0, _e = D(), !he && O.didScheduleLegacyUpdate) { + var Be = O.current; + Be !== null && (O.didScheduleLegacyUpdate = !1, bl(Be)); + } + } catch (Yn) { + throw bo(Q), Yn; + } finally { + O.isBatchingLegacy = he; + } + if (_e !== null && typeof _e == "object" && typeof _e.then == "function") { + var wt = _e, Ze = !1, Tt = { + then: function(Yn, Qn) { + Ze = !0, wt.then(function(an) { + bo(Q), go === 0 ? ru(an, Yn, Qn) : Yn(an); + }, function(an) { + bo(Q), Qn(an); + }); + } + }; + return !yl && typeof Promise < "u" && Promise.resolve().then(function() { + }).then(function() { + Ze || (yl = !0, me("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);")); + }), Tt; + } else { + var Xt = _e; + if (bo(Q), go === 0) { + var cn = O.current; + cn !== null && (bl(cn), O.current = null); + var Gn = { + then: function(Yn, Qn) { + O.current === null ? (O.current = [], ru(Xt, Yn, Qn)) : Yn(Xt); + } + }; + return Gn; + } else { + var Nn = { + then: function(Yn, Qn) { + Yn(Xt); + } + }; + return Nn; + } + } + } + } + function bo(D) { + D !== go - 1 && me("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "), go = D; + } + function ru(D, Q, he) { + { + var _e = O.current; + if (_e !== null) + try { + bl(_e), $f(function() { + _e.length === 0 ? (O.current = null, Q(D)) : ru(D, Q, he); + }); + } catch (Be) { + he(Be); + } + else + Q(D); + } + } + var gl = !1; + function bl(D) { + if (!gl) { + gl = !0; + var Q = 0; + try { + for (; Q < D.length; Q++) { + var he = D[Q]; + do + he = he(!0); + while (he !== null); + } + D.length = 0; + } catch (_e) { + throw D = D.slice(Q + 1), _e; + } finally { + gl = !1; + } + } + } + var ns = Lf, iu = ca, mc = Ur, Go = { + map: mo, + forEach: Jl, + count: ll, + toArray: Ys, + only: Da + }; + r.Children = Go, r.Component = Ce, r.Fragment = f, r.Profiler = g, r.PureComponent = Ne, r.StrictMode = p, r.Suspense = R, r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Ee, r.act = Pa, r.cloneElement = iu, r.createContext = sl, r.createElement = ns, r.createFactory = mc, r.createRef = Je, r.forwardRef = aa, r.isValidElement = ft, r.lazy = no, r.memo = je, r.startTransition = jf, r.unstable_act = Pa, r.useCallback = Jn, r.useContext = ht, r.useDebugValue = pn, r.useDeferredValue = vi, r.useEffect = qt, r.useId = Wt, r.useImperativeHandle = sa, r.useInsertionEffect = Tr, r.useLayoutEffect = Wn, r.useMemo = ai, r.useReducer = rn, r.useRef = Rt, r.useState = en, r.useSyncExternalStore = yo, r.useTransition = zr, r.version = i, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); + }(); + }(Em, Em.exports)), Em.exports; +} +var GM; +function Xp() { + return GM || (GM = 1, process.env.NODE_ENV === "production" ? Wb.exports = x3() : Wb.exports = T3()), Wb.exports; +} +/** + * @license React + * react-jsx-runtime.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var YM; +function R3() { + if (YM) return am; + YM = 1; + var t = Xp(), r = Symbol.for("react.element"), i = Symbol.for("react.fragment"), s = Object.prototype.hasOwnProperty, u = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, f = { key: !0, ref: !0, __self: !0, __source: !0 }; + function p(g, b, S) { + var x, R = {}, w = null, A = null; + S !== void 0 && (w = "" + S), b.key !== void 0 && (w = "" + b.key), b.ref !== void 0 && (A = b.ref); + for (x in b) s.call(b, x) && !f.hasOwnProperty(x) && (R[x] = b[x]); + if (g && g.defaultProps) for (x in b = g.defaultProps, b) R[x] === void 0 && (R[x] = b[x]); + return { $$typeof: r, type: g, key: w, ref: A, props: R, _owner: u.current }; + } + return am.Fragment = i, am.jsx = p, am.jsxs = p, am; +} +var lm = {}; +/** + * @license React + * react-jsx-runtime.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var KM; +function w3() { + return KM || (KM = 1, process.env.NODE_ENV !== "production" && function() { + var t = Xp(), r = Symbol.for("react.element"), i = Symbol.for("react.portal"), s = Symbol.for("react.fragment"), u = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), p = Symbol.for("react.provider"), g = Symbol.for("react.context"), b = Symbol.for("react.forward_ref"), S = Symbol.for("react.suspense"), x = Symbol.for("react.suspense_list"), R = Symbol.for("react.memo"), w = Symbol.for("react.lazy"), A = Symbol.for("react.offscreen"), I = Symbol.iterator, N = "@@iterator"; + function P(X) { + if (X === null || typeof X != "object") + return null; + var je = I && X[I] || X[N]; + return typeof je == "function" ? je : null; + } + var F = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + function z(X) { + { + for (var je = arguments.length, Ve = new Array(je > 1 ? je - 1 : 0), ht = 1; ht < je; ht++) + Ve[ht - 1] = arguments[ht]; + j("error", X, Ve); + } + } + function j(X, je, Ve) { + { + var ht = F.ReactDebugCurrentFrame, en = ht.getStackAddendum(); + en !== "" && (je += "%s", Ve = Ve.concat([en])); + var rn = Ve.map(function(Rt) { + return String(Rt); + }); + rn.unshift("Warning: " + je), Function.prototype.apply.call(console[X], console, rn); + } + } + var U = !1, O = !1, H = !1, M = !1, q = !1, Y; + Y = Symbol.for("react.module.reference"); + function Z(X) { + return !!(typeof X == "string" || typeof X == "function" || X === s || X === f || q || X === u || X === S || X === x || M || X === A || U || O || H || typeof X == "object" && X !== null && (X.$$typeof === w || X.$$typeof === R || X.$$typeof === p || X.$$typeof === g || X.$$typeof === b || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + X.$$typeof === Y || X.getModuleId !== void 0)); + } + function oe(X, je, Ve) { + var ht = X.displayName; + if (ht) + return ht; + var en = je.displayName || je.name || ""; + return en !== "" ? Ve + "(" + en + ")" : Ve; + } + function xe(X) { + return X.displayName || "Context"; + } + function se(X) { + if (X == null) + return null; + if (typeof X.tag == "number" && z("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof X == "function") + return X.displayName || X.name || null; + if (typeof X == "string") + return X; + switch (X) { + case s: + return "Fragment"; + case i: + return "Portal"; + case f: + return "Profiler"; + case u: + return "StrictMode"; + case S: + return "Suspense"; + case x: + return "SuspenseList"; + } + if (typeof X == "object") + switch (X.$$typeof) { + case g: + var je = X; + return xe(je) + ".Consumer"; + case p: + var Ve = X; + return xe(Ve._context) + ".Provider"; + case b: + return oe(X, X.render, "ForwardRef"); + case R: + var ht = X.displayName || null; + return ht !== null ? ht : se(X.type) || "Memo"; + case w: { + var en = X, rn = en._payload, Rt = en._init; + try { + return se(Rt(rn)); + } catch { + return null; + } + } + } + return null; + } + var be = Object.assign, Ee = 0, Se, me, ie, Ie, ee, W, ae; + function Oe() { + } + Oe.__reactDisabledLog = !0; + function Ce() { + { + if (Ee === 0) { + Se = console.log, me = console.info, ie = console.warn, Ie = console.error, ee = console.group, W = console.groupCollapsed, ae = console.groupEnd; + var X = { + configurable: !0, + enumerable: !0, + value: Oe, + writable: !0 + }; + Object.defineProperties(console, { + info: X, + log: X, + warn: X, + error: X, + group: X, + groupCollapsed: X, + groupEnd: X + }); + } + Ee++; + } + } + function Ae() { + { + if (Ee--, Ee === 0) { + var X = { + configurable: !0, + enumerable: !0, + writable: !0 + }; + Object.defineProperties(console, { + log: be({}, X, { + value: Se + }), + info: be({}, X, { + value: me + }), + warn: be({}, X, { + value: ie + }), + error: be({}, X, { + value: Ie + }), + group: be({}, X, { + value: ee + }), + groupCollapsed: be({}, X, { + value: W + }), + groupEnd: be({}, X, { + value: ae + }) + }); + } + Ee < 0 && z("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + var Me = F.ReactCurrentDispatcher, Ue; + function De(X, je, Ve) { + { + if (Ue === void 0) + try { + throw Error(); + } catch (en) { + var ht = en.stack.trim().match(/\n( *(at )?)/); + Ue = ht && ht[1] || ""; + } + return ` +` + Ue + X; + } + } + var Ne = !1, Ge; + { + var Je = typeof WeakMap == "function" ? WeakMap : Map; + Ge = new Je(); + } + function ue(X, je) { + if (!X || Ne) + return ""; + { + var Ve = Ge.get(X); + if (Ve !== void 0) + return Ve; + } + var ht; + Ne = !0; + var en = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var rn; + rn = Me.current, Me.current = null, Ce(); + try { + if (je) { + var Rt = function() { + throw Error(); + }; + if (Object.defineProperty(Rt.prototype, "props", { + set: function() { + throw Error(); + } + }), typeof Reflect == "object" && Reflect.construct) { + try { + Reflect.construct(Rt, []); + } catch (zr) { + ht = zr; + } + Reflect.construct(X, [], Rt); + } else { + try { + Rt.call(); + } catch (zr) { + ht = zr; + } + X.call(Rt.prototype); + } + } else { + try { + throw Error(); + } catch (zr) { + ht = zr; + } + X(); + } + } catch (zr) { + if (zr && ht && typeof zr.stack == "string") { + for (var qt = zr.stack.split(` +`), Tr = ht.stack.split(` +`), Wn = qt.length - 1, Jn = Tr.length - 1; Wn >= 1 && Jn >= 0 && qt[Wn] !== Tr[Jn]; ) + Jn--; + for (; Wn >= 1 && Jn >= 0; Wn--, Jn--) + if (qt[Wn] !== Tr[Jn]) { + if (Wn !== 1 || Jn !== 1) + do + if (Wn--, Jn--, Jn < 0 || qt[Wn] !== Tr[Jn]) { + var ai = ` +` + qt[Wn].replace(" at new ", " at "); + return X.displayName && ai.includes("") && (ai = ai.replace("", X.displayName)), typeof X == "function" && Ge.set(X, ai), ai; + } + while (Wn >= 1 && Jn >= 0); + break; + } + } + } finally { + Ne = !1, Me.current = rn, Ae(), Error.prepareStackTrace = en; + } + var sa = X ? X.displayName || X.name : "", pn = sa ? De(sa) : ""; + return typeof X == "function" && Ge.set(X, pn), pn; + } + function Ye(X, je, Ve) { + return ue(X, !1); + } + function Te(X) { + var je = X.prototype; + return !!(je && je.isReactComponent); + } + function ot(X, je, Ve) { + if (X == null) + return ""; + if (typeof X == "function") + return ue(X, Te(X)); + if (typeof X == "string") + return De(X); + switch (X) { + case S: + return De("Suspense"); + case x: + return De("SuspenseList"); + } + if (typeof X == "object") + switch (X.$$typeof) { + case b: + return Ye(X.render); + case R: + return ot(X.type, je, Ve); + case w: { + var ht = X, en = ht._payload, rn = ht._init; + try { + return ot(rn(en), je, Ve); + } catch { + } + } + } + return ""; + } + var jt = Object.prototype.hasOwnProperty, Ht = {}, Dn = F.ReactDebugCurrentFrame; + function Ln(X) { + if (X) { + var je = X._owner, Ve = ot(X.type, X._source, je ? je.type : null); + Dn.setExtraStackFrame(Ve); + } else + Dn.setExtraStackFrame(null); + } + function Sn(X, je, Ve, ht, en) { + { + var rn = Function.call.bind(jt); + for (var Rt in X) + if (rn(X, Rt)) { + var qt = void 0; + try { + if (typeof X[Rt] != "function") { + var Tr = Error((ht || "React class") + ": " + Ve + " type `" + Rt + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof X[Rt] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."); + throw Tr.name = "Invariant Violation", Tr; + } + qt = X[Rt](je, Rt, ht, Ve, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"); + } catch (Wn) { + qt = Wn; + } + qt && !(qt instanceof Error) && (Ln(en), z("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", ht || "React class", Ve, Rt, typeof qt), Ln(null)), qt instanceof Error && !(qt.message in Ht) && (Ht[qt.message] = !0, Ln(en), z("Failed %s type: %s", Ve, qt.message), Ln(null)); + } + } + } + var Yt = Array.isArray; + function qn(X) { + return Yt(X); + } + function Cn(X) { + { + var je = typeof Symbol == "function" && Symbol.toStringTag, Ve = je && X[Symbol.toStringTag] || X.constructor.name || "Object"; + return Ve; + } + } + function Jt(X) { + try { + return xn(X), !1; + } catch { + return !0; + } + } + function xn(X) { + return "" + X; + } + function dr(X) { + if (Jt(X)) + return z("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Cn(X)), xn(X); + } + var dn = F.ReactCurrentOwner, Pt = { + key: !0, + ref: !0, + __self: !0, + __source: !0 + }, bt, ir, qe; + qe = {}; + function lt(X) { + if (jt.call(X, "ref")) { + var je = Object.getOwnPropertyDescriptor(X, "ref").get; + if (je && je.isReactWarning) + return !1; + } + return X.ref !== void 0; + } + function $t(X) { + if (jt.call(X, "key")) { + var je = Object.getOwnPropertyDescriptor(X, "key").get; + if (je && je.isReactWarning) + return !1; + } + return X.key !== void 0; + } + function We(X, je) { + if (typeof X.ref == "string" && dn.current && je && dn.current.stateNode !== je) { + var Ve = se(dn.current.type); + qe[Ve] || (z('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', se(dn.current.type), X.ref), qe[Ve] = !0); + } + } + function ft(X, je) { + { + var Ve = function() { + bt || (bt = !0, z("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", je)); + }; + Ve.isReactWarning = !0, Object.defineProperty(X, "key", { + get: Ve, + configurable: !0 + }); + } + } + function Qt(X, je) { + { + var Ve = function() { + ir || (ir = !0, z("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", je)); + }; + Ve.isReactWarning = !0, Object.defineProperty(X, "ref", { + get: Ve, + configurable: !0 + }); + } + } + var Tn = function(X, je, Ve, ht, en, rn, Rt) { + var qt = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: r, + // Built-in properties that belong on the element + type: X, + key: je, + ref: Ve, + props: Rt, + // Record the component responsible for creating this element. + _owner: rn + }; + return qt._store = {}, Object.defineProperty(qt._store, "validated", { + configurable: !1, + enumerable: !1, + writable: !0, + value: !1 + }), Object.defineProperty(qt, "_self", { + configurable: !1, + enumerable: !1, + writable: !1, + value: ht + }), Object.defineProperty(qt, "_source", { + configurable: !1, + enumerable: !1, + writable: !1, + value: en + }), Object.freeze && (Object.freeze(qt.props), Object.freeze(qt)), qt; + }; + function Ar(X, je, Ve, ht, en) { + { + var rn, Rt = {}, qt = null, Tr = null; + Ve !== void 0 && (dr(Ve), qt = "" + Ve), $t(je) && (dr(je.key), qt = "" + je.key), lt(je) && (Tr = je.ref, We(je, en)); + for (rn in je) + jt.call(je, rn) && !Pt.hasOwnProperty(rn) && (Rt[rn] = je[rn]); + if (X && X.defaultProps) { + var Wn = X.defaultProps; + for (rn in Wn) + Rt[rn] === void 0 && (Rt[rn] = Wn[rn]); + } + if (qt || Tr) { + var Jn = typeof X == "function" ? X.displayName || X.name || "Unknown" : X; + qt && ft(Rt, Jn), Tr && Qt(Rt, Jn); + } + return Tn(X, qt, Tr, en, ht, dn.current, Rt); + } + } + var An = F.ReactCurrentOwner, di = F.ReactDebugCurrentFrame; + function Rn(X) { + if (X) { + var je = X._owner, Ve = ot(X.type, X._source, je ? je.type : null); + di.setExtraStackFrame(Ve); + } else + di.setExtraStackFrame(null); + } + var wn; + wn = !1; + function Ho(X) { + return typeof X == "object" && X !== null && X.$$typeof === r; + } + function mo() { + { + if (An.current) { + var X = se(An.current.type); + if (X) + return ` + +Check the render method of \`` + X + "`."; + } + return ""; + } + } + function ll(X) { + return ""; + } + var Jl = {}; + function Ys(X) { + { + var je = mo(); + if (!je) { + var Ve = typeof X == "string" ? X : X.displayName || X.name; + Ve && (je = ` + +Check the top-level render call using <` + Ve + ">."); + } + return je; + } + } + function Da(X, je) { + { + if (!X._store || X._store.validated || X.key != null) + return; + X._store.validated = !0; + var Ve = Ys(je); + if (Jl[Ve]) + return; + Jl[Ve] = !0; + var ht = ""; + X && X._owner && X._owner !== An.current && (ht = " It was passed a child from " + se(X._owner.type) + "."), Rn(X), z('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', Ve, ht), Rn(null); + } + } + function sl(X, je) { + { + if (typeof X != "object") + return; + if (qn(X)) + for (var Ve = 0; Ve < X.length; Ve++) { + var ht = X[Ve]; + Ho(ht) && Da(ht, je); + } + else if (Ho(X)) + X._store && (X._store.validated = !0); + else if (X) { + var en = P(X); + if (typeof en == "function" && en !== X.entries) + for (var rn = en.call(X), Rt; !(Rt = rn.next()).done; ) + Ho(Rt.value) && Da(Rt.value, je); + } + } + } + function eo(X) { + { + var je = X.type; + if (je == null || typeof je == "string") + return; + var Ve; + if (typeof je == "function") + Ve = je.propTypes; + else if (typeof je == "object" && (je.$$typeof === b || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + je.$$typeof === R)) + Ve = je.propTypes; + else + return; + if (Ve) { + var ht = se(je); + Sn(Ve, X.props, "prop", ht, X); + } else if (je.PropTypes !== void 0 && !wn) { + wn = !0; + var en = se(je); + z("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", en || "Unknown"); + } + typeof je.getDefaultProps == "function" && !je.getDefaultProps.isReactClassApproved && z("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead."); + } + } + function oa(X) { + { + for (var je = Object.keys(X.props), Ve = 0; Ve < je.length; Ve++) { + var ht = je[Ve]; + if (ht !== "children" && ht !== "key") { + Rn(X), z("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", ht), Rn(null); + break; + } + } + X.ref !== null && (Rn(X), z("Invalid attribute `ref` supplied to `React.Fragment`."), Rn(null)); + } + } + var to = {}; + function qo(X, je, Ve, ht, en, rn) { + { + var Rt = Z(X); + if (!Rt) { + var qt = ""; + (X === void 0 || typeof X == "object" && X !== null && Object.keys(X).length === 0) && (qt += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports."); + var Tr = ll(); + Tr ? qt += Tr : qt += mo(); + var Wn; + X === null ? Wn = "null" : qn(X) ? Wn = "array" : X !== void 0 && X.$$typeof === r ? (Wn = "<" + (se(X.type) || "Unknown") + " />", qt = " Did you accidentally export a JSX literal instead of a component?") : Wn = typeof X, z("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", Wn, qt); + } + var Jn = Ar(X, je, Ve, en, rn); + if (Jn == null) + return Jn; + if (Rt) { + var ai = je.children; + if (ai !== void 0) + if (ht) + if (qn(ai)) { + for (var sa = 0; sa < ai.length; sa++) + sl(ai[sa], X); + Object.freeze && Object.freeze(ai); + } else + z("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."); + else + sl(ai, X); + } + if (jt.call(je, "key")) { + var pn = se(X), zr = Object.keys(je).filter(function(yo) { + return yo !== "key"; + }), vi = zr.length > 0 ? "{key: someKey, " + zr.join(": ..., ") + ": ...}" : "{key: someKey}"; + if (!to[pn + vi]) { + var Wt = zr.length > 0 ? "{" + zr.join(": ..., ") + ": ...}" : "{}"; + z(`A props object containing a "key" prop is being spread into JSX: + let props = %s; + <%s {...props} /> +React keys must be passed directly to JSX without using spread: + let props = %s; + <%s key={someKey} {...props} />`, vi, pn, Wt, pn), to[pn + vi] = !0; + } + } + return X === s ? oa(Jn) : eo(Jn), Jn; + } + } + function pi(X, je, Ve) { + return qo(X, je, Ve, !0); + } + function no(X, je, Ve) { + return qo(X, je, Ve, !1); + } + var aa = no, la = pi; + lm.Fragment = s, lm.jsx = aa, lm.jsxs = la; + }()), lm; +} +var QM; +function SI() { + return QM || (QM = 1, process.env.NODE_ENV === "production" ? qb.exports = R3() : qb.exports = w3()), qb.exports; +} +var le = SI(), B = Xp(); +const Kt = /* @__PURE__ */ Hs(B), WT = /* @__PURE__ */ _3({ + __proto__: null, + default: Kt +}, [B]); +var Gb = { exports: {} }, Yb = { exports: {} }, Fn = {}; +/** @license React v16.13.1 + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var XM; +function O3() { + if (XM) return Fn; + XM = 1; + var t = typeof Symbol == "function" && Symbol.for, r = t ? Symbol.for("react.element") : 60103, i = t ? Symbol.for("react.portal") : 60106, s = t ? Symbol.for("react.fragment") : 60107, u = t ? Symbol.for("react.strict_mode") : 60108, f = t ? Symbol.for("react.profiler") : 60114, p = t ? Symbol.for("react.provider") : 60109, g = t ? Symbol.for("react.context") : 60110, b = t ? Symbol.for("react.async_mode") : 60111, S = t ? Symbol.for("react.concurrent_mode") : 60111, x = t ? Symbol.for("react.forward_ref") : 60112, R = t ? Symbol.for("react.suspense") : 60113, w = t ? Symbol.for("react.suspense_list") : 60120, A = t ? Symbol.for("react.memo") : 60115, I = t ? Symbol.for("react.lazy") : 60116, N = t ? Symbol.for("react.block") : 60121, P = t ? Symbol.for("react.fundamental") : 60117, F = t ? Symbol.for("react.responder") : 60118, z = t ? Symbol.for("react.scope") : 60119; + function j(O) { + if (typeof O == "object" && O !== null) { + var H = O.$$typeof; + switch (H) { + case r: + switch (O = O.type, O) { + case b: + case S: + case s: + case f: + case u: + case R: + return O; + default: + switch (O = O && O.$$typeof, O) { + case g: + case x: + case I: + case A: + case p: + return O; + default: + return H; + } + } + case i: + return H; + } + } + } + function U(O) { + return j(O) === S; + } + return Fn.AsyncMode = b, Fn.ConcurrentMode = S, Fn.ContextConsumer = g, Fn.ContextProvider = p, Fn.Element = r, Fn.ForwardRef = x, Fn.Fragment = s, Fn.Lazy = I, Fn.Memo = A, Fn.Portal = i, Fn.Profiler = f, Fn.StrictMode = u, Fn.Suspense = R, Fn.isAsyncMode = function(O) { + return U(O) || j(O) === b; + }, Fn.isConcurrentMode = U, Fn.isContextConsumer = function(O) { + return j(O) === g; + }, Fn.isContextProvider = function(O) { + return j(O) === p; + }, Fn.isElement = function(O) { + return typeof O == "object" && O !== null && O.$$typeof === r; + }, Fn.isForwardRef = function(O) { + return j(O) === x; + }, Fn.isFragment = function(O) { + return j(O) === s; + }, Fn.isLazy = function(O) { + return j(O) === I; + }, Fn.isMemo = function(O) { + return j(O) === A; + }, Fn.isPortal = function(O) { + return j(O) === i; + }, Fn.isProfiler = function(O) { + return j(O) === f; + }, Fn.isStrictMode = function(O) { + return j(O) === u; + }, Fn.isSuspense = function(O) { + return j(O) === R; + }, Fn.isValidElementType = function(O) { + return typeof O == "string" || typeof O == "function" || O === s || O === S || O === f || O === u || O === R || O === w || typeof O == "object" && O !== null && (O.$$typeof === I || O.$$typeof === A || O.$$typeof === p || O.$$typeof === g || O.$$typeof === x || O.$$typeof === P || O.$$typeof === F || O.$$typeof === z || O.$$typeof === N); + }, Fn.typeOf = j, Fn; +} +var zn = {}; +/** @license React v16.13.1 + * react-is.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var ZM; +function k3() { + return ZM || (ZM = 1, process.env.NODE_ENV !== "production" && function() { + var t = typeof Symbol == "function" && Symbol.for, r = t ? Symbol.for("react.element") : 60103, i = t ? Symbol.for("react.portal") : 60106, s = t ? Symbol.for("react.fragment") : 60107, u = t ? Symbol.for("react.strict_mode") : 60108, f = t ? Symbol.for("react.profiler") : 60114, p = t ? Symbol.for("react.provider") : 60109, g = t ? Symbol.for("react.context") : 60110, b = t ? Symbol.for("react.async_mode") : 60111, S = t ? Symbol.for("react.concurrent_mode") : 60111, x = t ? Symbol.for("react.forward_ref") : 60112, R = t ? Symbol.for("react.suspense") : 60113, w = t ? Symbol.for("react.suspense_list") : 60120, A = t ? Symbol.for("react.memo") : 60115, I = t ? Symbol.for("react.lazy") : 60116, N = t ? Symbol.for("react.block") : 60121, P = t ? Symbol.for("react.fundamental") : 60117, F = t ? Symbol.for("react.responder") : 60118, z = t ? Symbol.for("react.scope") : 60119; + function j(ue) { + return typeof ue == "string" || typeof ue == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. + ue === s || ue === S || ue === f || ue === u || ue === R || ue === w || typeof ue == "object" && ue !== null && (ue.$$typeof === I || ue.$$typeof === A || ue.$$typeof === p || ue.$$typeof === g || ue.$$typeof === x || ue.$$typeof === P || ue.$$typeof === F || ue.$$typeof === z || ue.$$typeof === N); + } + function U(ue) { + if (typeof ue == "object" && ue !== null) { + var Ye = ue.$$typeof; + switch (Ye) { + case r: + var Te = ue.type; + switch (Te) { + case b: + case S: + case s: + case f: + case u: + case R: + return Te; + default: + var ot = Te && Te.$$typeof; + switch (ot) { + case g: + case x: + case I: + case A: + case p: + return ot; + default: + return Ye; + } + } + case i: + return Ye; + } + } + } + var O = b, H = S, M = g, q = p, Y = r, Z = x, oe = s, xe = I, se = A, be = i, Ee = f, Se = u, me = R, ie = !1; + function Ie(ue) { + return ie || (ie = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), ee(ue) || U(ue) === b; + } + function ee(ue) { + return U(ue) === S; + } + function W(ue) { + return U(ue) === g; + } + function ae(ue) { + return U(ue) === p; + } + function Oe(ue) { + return typeof ue == "object" && ue !== null && ue.$$typeof === r; + } + function Ce(ue) { + return U(ue) === x; + } + function Ae(ue) { + return U(ue) === s; + } + function Me(ue) { + return U(ue) === I; + } + function Ue(ue) { + return U(ue) === A; + } + function De(ue) { + return U(ue) === i; + } + function Ne(ue) { + return U(ue) === f; + } + function Ge(ue) { + return U(ue) === u; + } + function Je(ue) { + return U(ue) === R; + } + zn.AsyncMode = O, zn.ConcurrentMode = H, zn.ContextConsumer = M, zn.ContextProvider = q, zn.Element = Y, zn.ForwardRef = Z, zn.Fragment = oe, zn.Lazy = xe, zn.Memo = se, zn.Portal = be, zn.Profiler = Ee, zn.StrictMode = Se, zn.Suspense = me, zn.isAsyncMode = Ie, zn.isConcurrentMode = ee, zn.isContextConsumer = W, zn.isContextProvider = ae, zn.isElement = Oe, zn.isForwardRef = Ce, zn.isFragment = Ae, zn.isLazy = Me, zn.isMemo = Ue, zn.isPortal = De, zn.isProfiler = Ne, zn.isStrictMode = Ge, zn.isSuspense = Je, zn.isValidElementType = j, zn.typeOf = U; + }()), zn; +} +var JM; +function CI() { + return JM || (JM = 1, process.env.NODE_ENV === "production" ? Yb.exports = O3() : Yb.exports = k3()), Yb.exports; +} +/* +object-assign +(c) Sindre Sorhus +@license MIT +*/ +var BC, eD; +function M3() { + if (eD) return BC; + eD = 1; + var t = Object.getOwnPropertySymbols, r = Object.prototype.hasOwnProperty, i = Object.prototype.propertyIsEnumerable; + function s(f) { + if (f == null) + throw new TypeError("Object.assign cannot be called with null or undefined"); + return Object(f); + } + function u() { + try { + if (!Object.assign) + return !1; + var f = new String("abc"); + if (f[5] = "de", Object.getOwnPropertyNames(f)[0] === "5") + return !1; + for (var p = {}, g = 0; g < 10; g++) + p["_" + String.fromCharCode(g)] = g; + var b = Object.getOwnPropertyNames(p).map(function(x) { + return p[x]; + }); + if (b.join("") !== "0123456789") + return !1; + var S = {}; + return "abcdefghijklmnopqrst".split("").forEach(function(x) { + S[x] = x; + }), Object.keys(Object.assign({}, S)).join("") === "abcdefghijklmnopqrst"; + } catch { + return !1; + } + } + return BC = u() ? Object.assign : function(f, p) { + for (var g, b = s(f), S, x = 1; x < arguments.length; x++) { + g = Object(arguments[x]); + for (var R in g) + r.call(g, R) && (b[R] = g[R]); + if (t) { + S = t(g); + for (var w = 0; w < S.length; w++) + i.call(g, S[w]) && (b[S[w]] = g[S[w]]); + } + } + return b; + }, BC; +} +var HC, tD; +function hR() { + if (tD) return HC; + tD = 1; + var t = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"; + return HC = t, HC; +} +var qC, nD; +function _I() { + return nD || (nD = 1, qC = Function.call.bind(Object.prototype.hasOwnProperty)), qC; +} +var WC, rD; +function D3() { + if (rD) return WC; + rD = 1; + var t = function() { + }; + if (process.env.NODE_ENV !== "production") { + var r = /* @__PURE__ */ hR(), i = {}, s = /* @__PURE__ */ _I(); + t = function(f) { + var p = "Warning: " + f; + typeof console < "u" && console.error(p); + try { + throw new Error(p); + } catch { + } + }; + } + function u(f, p, g, b, S) { + if (process.env.NODE_ENV !== "production") { + for (var x in f) + if (s(f, x)) { + var R; + try { + if (typeof f[x] != "function") { + var w = Error( + (b || "React class") + ": " + g + " type `" + x + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof f[x] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`." + ); + throw w.name = "Invariant Violation", w; + } + R = f[x](p, x, b, g, null, r); + } catch (I) { + R = I; + } + if (R && !(R instanceof Error) && t( + (b || "React class") + ": type specification of " + g + " `" + x + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof R + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)." + ), R instanceof Error && !(R.message in i)) { + i[R.message] = !0; + var A = S ? S() : ""; + t( + "Failed " + g + " type: " + R.message + (A ?? "") + ); + } + } + } + } + return u.resetWarningCache = function() { + process.env.NODE_ENV !== "production" && (i = {}); + }, WC = u, WC; +} +var GC, iD; +function A3() { + if (iD) return GC; + iD = 1; + var t = CI(), r = M3(), i = /* @__PURE__ */ hR(), s = /* @__PURE__ */ _I(), u = /* @__PURE__ */ D3(), f = function() { + }; + process.env.NODE_ENV !== "production" && (f = function(g) { + var b = "Warning: " + g; + typeof console < "u" && console.error(b); + try { + throw new Error(b); + } catch { + } + }); + function p() { + return null; + } + return GC = function(g, b) { + var S = typeof Symbol == "function" && Symbol.iterator, x = "@@iterator"; + function R(ee) { + var W = ee && (S && ee[S] || ee[x]); + if (typeof W == "function") + return W; + } + var w = "<>", A = { + array: F("array"), + bigint: F("bigint"), + bool: F("boolean"), + func: F("function"), + number: F("number"), + object: F("object"), + string: F("string"), + symbol: F("symbol"), + any: z(), + arrayOf: j, + element: U(), + elementType: O(), + instanceOf: H, + node: Z(), + objectOf: q, + oneOf: M, + oneOfType: Y, + shape: xe, + exact: se + }; + function I(ee, W) { + return ee === W ? ee !== 0 || 1 / ee === 1 / W : ee !== ee && W !== W; + } + function N(ee, W) { + this.message = ee, this.data = W && typeof W == "object" ? W : {}, this.stack = ""; + } + N.prototype = Error.prototype; + function P(ee) { + if (process.env.NODE_ENV !== "production") + var W = {}, ae = 0; + function Oe(Ae, Me, Ue, De, Ne, Ge, Je) { + if (De = De || w, Ge = Ge || Ue, Je !== i) { + if (b) { + var ue = new Error( + "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types" + ); + throw ue.name = "Invariant Violation", ue; + } else if (process.env.NODE_ENV !== "production" && typeof console < "u") { + var Ye = De + ":" + Ue; + !W[Ye] && // Avoid spamming the console because they are often not actionable except for lib authors + ae < 3 && (f( + "You are manually calling a React.PropTypes validation function for the `" + Ge + "` prop on `" + De + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details." + ), W[Ye] = !0, ae++); + } + } + return Me[Ue] == null ? Ae ? Me[Ue] === null ? new N("The " + Ne + " `" + Ge + "` is marked as required " + ("in `" + De + "`, but its value is `null`.")) : new N("The " + Ne + " `" + Ge + "` is marked as required in " + ("`" + De + "`, but its value is `undefined`.")) : null : ee(Me, Ue, De, Ne, Ge); + } + var Ce = Oe.bind(null, !1); + return Ce.isRequired = Oe.bind(null, !0), Ce; + } + function F(ee) { + function W(ae, Oe, Ce, Ae, Me, Ue) { + var De = ae[Oe], Ne = Se(De); + if (Ne !== ee) { + var Ge = me(De); + return new N( + "Invalid " + Ae + " `" + Me + "` of type " + ("`" + Ge + "` supplied to `" + Ce + "`, expected ") + ("`" + ee + "`."), + { expectedType: ee } + ); + } + return null; + } + return P(W); + } + function z() { + return P(p); + } + function j(ee) { + function W(ae, Oe, Ce, Ae, Me) { + if (typeof ee != "function") + return new N("Property `" + Me + "` of component `" + Ce + "` has invalid PropType notation inside arrayOf."); + var Ue = ae[Oe]; + if (!Array.isArray(Ue)) { + var De = Se(Ue); + return new N("Invalid " + Ae + " `" + Me + "` of type " + ("`" + De + "` supplied to `" + Ce + "`, expected an array.")); + } + for (var Ne = 0; Ne < Ue.length; Ne++) { + var Ge = ee(Ue, Ne, Ce, Ae, Me + "[" + Ne + "]", i); + if (Ge instanceof Error) + return Ge; + } + return null; + } + return P(W); + } + function U() { + function ee(W, ae, Oe, Ce, Ae) { + var Me = W[ae]; + if (!g(Me)) { + var Ue = Se(Me); + return new N("Invalid " + Ce + " `" + Ae + "` of type " + ("`" + Ue + "` supplied to `" + Oe + "`, expected a single ReactElement.")); + } + return null; + } + return P(ee); + } + function O() { + function ee(W, ae, Oe, Ce, Ae) { + var Me = W[ae]; + if (!t.isValidElementType(Me)) { + var Ue = Se(Me); + return new N("Invalid " + Ce + " `" + Ae + "` of type " + ("`" + Ue + "` supplied to `" + Oe + "`, expected a single ReactElement type.")); + } + return null; + } + return P(ee); + } + function H(ee) { + function W(ae, Oe, Ce, Ae, Me) { + if (!(ae[Oe] instanceof ee)) { + var Ue = ee.name || w, De = Ie(ae[Oe]); + return new N("Invalid " + Ae + " `" + Me + "` of type " + ("`" + De + "` supplied to `" + Ce + "`, expected ") + ("instance of `" + Ue + "`.")); + } + return null; + } + return P(W); + } + function M(ee) { + if (!Array.isArray(ee)) + return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? f( + "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])." + ) : f("Invalid argument supplied to oneOf, expected an array.")), p; + function W(ae, Oe, Ce, Ae, Me) { + for (var Ue = ae[Oe], De = 0; De < ee.length; De++) + if (I(Ue, ee[De])) + return null; + var Ne = JSON.stringify(ee, function(Je, ue) { + var Ye = me(ue); + return Ye === "symbol" ? String(ue) : ue; + }); + return new N("Invalid " + Ae + " `" + Me + "` of value `" + String(Ue) + "` " + ("supplied to `" + Ce + "`, expected one of " + Ne + ".")); + } + return P(W); + } + function q(ee) { + function W(ae, Oe, Ce, Ae, Me) { + if (typeof ee != "function") + return new N("Property `" + Me + "` of component `" + Ce + "` has invalid PropType notation inside objectOf."); + var Ue = ae[Oe], De = Se(Ue); + if (De !== "object") + return new N("Invalid " + Ae + " `" + Me + "` of type " + ("`" + De + "` supplied to `" + Ce + "`, expected an object.")); + for (var Ne in Ue) + if (s(Ue, Ne)) { + var Ge = ee(Ue, Ne, Ce, Ae, Me + "." + Ne, i); + if (Ge instanceof Error) + return Ge; + } + return null; + } + return P(W); + } + function Y(ee) { + if (!Array.isArray(ee)) + return process.env.NODE_ENV !== "production" && f("Invalid argument supplied to oneOfType, expected an instance of array."), p; + for (var W = 0; W < ee.length; W++) { + var ae = ee[W]; + if (typeof ae != "function") + return f( + "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ie(ae) + " at index " + W + "." + ), p; + } + function Oe(Ce, Ae, Me, Ue, De) { + for (var Ne = [], Ge = 0; Ge < ee.length; Ge++) { + var Je = ee[Ge], ue = Je(Ce, Ae, Me, Ue, De, i); + if (ue == null) + return null; + ue.data && s(ue.data, "expectedType") && Ne.push(ue.data.expectedType); + } + var Ye = Ne.length > 0 ? ", expected one of type [" + Ne.join(", ") + "]" : ""; + return new N("Invalid " + Ue + " `" + De + "` supplied to " + ("`" + Me + "`" + Ye + ".")); + } + return P(Oe); + } + function Z() { + function ee(W, ae, Oe, Ce, Ae) { + return be(W[ae]) ? null : new N("Invalid " + Ce + " `" + Ae + "` supplied to " + ("`" + Oe + "`, expected a ReactNode.")); + } + return P(ee); + } + function oe(ee, W, ae, Oe, Ce) { + return new N( + (ee || "React class") + ": " + W + " type `" + ae + "." + Oe + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + Ce + "`." + ); + } + function xe(ee) { + function W(ae, Oe, Ce, Ae, Me) { + var Ue = ae[Oe], De = Se(Ue); + if (De !== "object") + return new N("Invalid " + Ae + " `" + Me + "` of type `" + De + "` " + ("supplied to `" + Ce + "`, expected `object`.")); + for (var Ne in ee) { + var Ge = ee[Ne]; + if (typeof Ge != "function") + return oe(Ce, Ae, Me, Ne, me(Ge)); + var Je = Ge(Ue, Ne, Ce, Ae, Me + "." + Ne, i); + if (Je) + return Je; + } + return null; + } + return P(W); + } + function se(ee) { + function W(ae, Oe, Ce, Ae, Me) { + var Ue = ae[Oe], De = Se(Ue); + if (De !== "object") + return new N("Invalid " + Ae + " `" + Me + "` of type `" + De + "` " + ("supplied to `" + Ce + "`, expected `object`.")); + var Ne = r({}, ae[Oe], ee); + for (var Ge in Ne) { + var Je = ee[Ge]; + if (s(ee, Ge) && typeof Je != "function") + return oe(Ce, Ae, Me, Ge, me(Je)); + if (!Je) + return new N( + "Invalid " + Ae + " `" + Me + "` key `" + Ge + "` supplied to `" + Ce + "`.\nBad object: " + JSON.stringify(ae[Oe], null, " ") + ` +Valid keys: ` + JSON.stringify(Object.keys(ee), null, " ") + ); + var ue = Je(Ue, Ge, Ce, Ae, Me + "." + Ge, i); + if (ue) + return ue; + } + return null; + } + return P(W); + } + function be(ee) { + switch (typeof ee) { + case "number": + case "string": + case "undefined": + return !0; + case "boolean": + return !ee; + case "object": + if (Array.isArray(ee)) + return ee.every(be); + if (ee === null || g(ee)) + return !0; + var W = R(ee); + if (W) { + var ae = W.call(ee), Oe; + if (W !== ee.entries) { + for (; !(Oe = ae.next()).done; ) + if (!be(Oe.value)) + return !1; + } else + for (; !(Oe = ae.next()).done; ) { + var Ce = Oe.value; + if (Ce && !be(Ce[1])) + return !1; + } + } else + return !1; + return !0; + default: + return !1; + } + } + function Ee(ee, W) { + return ee === "symbol" ? !0 : W ? W["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && W instanceof Symbol : !1; + } + function Se(ee) { + var W = typeof ee; + return Array.isArray(ee) ? "array" : ee instanceof RegExp ? "object" : Ee(W, ee) ? "symbol" : W; + } + function me(ee) { + if (typeof ee > "u" || ee === null) + return "" + ee; + var W = Se(ee); + if (W === "object") { + if (ee instanceof Date) + return "date"; + if (ee instanceof RegExp) + return "regexp"; + } + return W; + } + function ie(ee) { + var W = me(ee); + switch (W) { + case "array": + case "object": + return "an " + W; + case "boolean": + case "date": + case "regexp": + return "a " + W; + default: + return W; + } + } + function Ie(ee) { + return !ee.constructor || !ee.constructor.name ? w : ee.constructor.name; + } + return A.checkPropTypes = u, A.resetWarningCache = u.resetWarningCache, A.PropTypes = A, A; + }, GC; +} +var YC, oD; +function N3() { + if (oD) return YC; + oD = 1; + var t = /* @__PURE__ */ hR(); + function r() { + } + function i() { + } + return i.resetWarningCache = r, YC = function() { + function s(p, g, b, S, x, R) { + if (R !== t) { + var w = new Error( + "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types" + ); + throw w.name = "Invariant Violation", w; + } + } + s.isRequired = s; + function u() { + return s; + } + var f = { + array: s, + bigint: s, + bool: s, + func: s, + number: s, + object: s, + string: s, + symbol: s, + any: s, + arrayOf: u, + element: s, + elementType: s, + instanceOf: u, + node: s, + objectOf: u, + oneOf: u, + oneOfType: u, + shape: u, + exact: u, + checkPropTypes: i, + resetWarningCache: r + }; + return f.PropTypes = f, f; + }, YC; +} +var aD; +function P3() { + if (aD) return Gb.exports; + if (aD = 1, process.env.NODE_ENV !== "production") { + var t = CI(), r = !0; + Gb.exports = /* @__PURE__ */ A3()(t.isElement, r); + } else + Gb.exports = /* @__PURE__ */ N3()(); + return Gb.exports; +} +var I3 = /* @__PURE__ */ P3(); +const v = /* @__PURE__ */ Hs(I3); +function Ct(t, r) { + if (t == null) return {}; + var i = {}; + for (var s in t) if ({}.hasOwnProperty.call(t, s)) { + if (r.includes(s)) continue; + i[s] = t[s]; + } + return i; +} +function K() { + return K = Object.assign ? Object.assign.bind() : function(t) { + for (var r = 1; r < arguments.length; r++) { + var i = arguments[r]; + for (var s in i) ({}).hasOwnProperty.call(i, s) && (t[s] = i[s]); + } + return t; + }, K.apply(null, arguments); +} +function xI(t) { + var r, i, s = ""; + if (typeof t == "string" || typeof t == "number") s += t; + else if (typeof t == "object") if (Array.isArray(t)) { + var u = t.length; + for (r = 0; r < u; r++) t[r] && (i = xI(t[r])) && (s && (s += " "), s += i); + } else for (i in t) t[i] && (s && (s += " "), s += i); + return s; +} +function Nt() { + for (var t, r, i = 0, s = "", u = arguments.length; i < u; i++) (t = arguments[i]) && (r = xI(t)) && (s && (s += " "), s += r); + return s; +} +function gn(t, r, i = void 0) { + const s = {}; + return Object.keys(t).forEach( + // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`. + // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208 + (u) => { + s[u] = t[u].reduce((f, p) => { + if (p) { + const g = r(p); + g !== "" && f.push(g), i && i[p] && f.push(i[p]); + } + return f; + }, []).join(" "); + } + ), s; +} +var Ef = {}, KC = { exports: {} }, lD; +function mR() { + return lD || (lD = 1, function(t) { + function r(i) { + return i && i.__esModule ? i : { + default: i + }; + } + t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports; + }(KC)), KC.exports; +} +var QC = { exports: {} }, sD; +function L3() { + return sD || (sD = 1, function(t) { + function r() { + return t.exports = r = Object.assign ? Object.assign.bind() : function(i) { + for (var s = 1; s < arguments.length; s++) { + var u = arguments[s]; + for (var f in u) ({}).hasOwnProperty.call(u, f) && (i[f] = u[f]); + } + return i; + }, t.exports.__esModule = !0, t.exports.default = t.exports, r.apply(null, arguments); + } + t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports; + }(QC)), QC.exports; +} +var XC = { exports: {} }, uD; +function j3() { + return uD || (uD = 1, function(t) { + function r(i, s) { + if (i == null) return {}; + var u = {}; + for (var f in i) if ({}.hasOwnProperty.call(i, f)) { + if (s.includes(f)) continue; + u[f] = i[f]; + } + return u; + } + t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports; + }(XC)), XC.exports; +} +var $3 = !1; +function F3(t) { + if (t.sheet) + return t.sheet; + for (var r = 0; r < document.styleSheets.length; r++) + if (document.styleSheets[r].ownerNode === t) + return document.styleSheets[r]; +} +function z3(t) { + var r = document.createElement("style"); + return r.setAttribute("data-emotion", t.key), t.nonce !== void 0 && r.setAttribute("nonce", t.nonce), r.appendChild(document.createTextNode("")), r.setAttribute("data-s", ""), r; +} +var U3 = /* @__PURE__ */ function() { + function t(i) { + var s = this; + this._insertTag = function(u) { + var f; + s.tags.length === 0 ? s.insertionPoint ? f = s.insertionPoint.nextSibling : s.prepend ? f = s.container.firstChild : f = s.before : f = s.tags[s.tags.length - 1].nextSibling, s.container.insertBefore(u, f), s.tags.push(u); + }, this.isSpeedy = i.speedy === void 0 ? !$3 : i.speedy, this.tags = [], this.ctr = 0, this.nonce = i.nonce, this.key = i.key, this.container = i.container, this.prepend = i.prepend, this.insertionPoint = i.insertionPoint, this.before = null; + } + var r = t.prototype; + return r.hydrate = function(s) { + s.forEach(this._insertTag); + }, r.insert = function(s) { + this.ctr % (this.isSpeedy ? 65e3 : 1) === 0 && this._insertTag(z3(this)); + var u = this.tags[this.tags.length - 1]; + if (this.isSpeedy) { + var f = F3(u); + try { + f.insertRule(s, f.cssRules.length); + } catch { + } + } else + u.appendChild(document.createTextNode(s)); + this.ctr++; + }, r.flush = function() { + this.tags.forEach(function(s) { + var u; + return (u = s.parentNode) == null ? void 0 : u.removeChild(s); + }), this.tags = [], this.ctr = 0; + }, t; +}(), Xi = "-ms-", g0 = "-moz-", Pn = "-webkit-", TI = "comm", yR = "rule", gR = "decl", V3 = "@import", RI = "@keyframes", B3 = "@layer", H3 = Math.abs, j0 = String.fromCharCode, q3 = Object.assign; +function W3(t, r) { + return Mi(t, 0) ^ 45 ? (((r << 2 ^ Mi(t, 0)) << 2 ^ Mi(t, 1)) << 2 ^ Mi(t, 2)) << 2 ^ Mi(t, 3) : 0; +} +function wI(t) { + return t.trim(); +} +function G3(t, r) { + return (t = r.exec(t)) ? t[0] : t; +} +function In(t, r, i) { + return t.replace(r, i); +} +function GT(t, r) { + return t.indexOf(r); +} +function Mi(t, r) { + return t.charCodeAt(r) | 0; +} +function Dm(t, r, i) { + return t.slice(r, i); +} +function Wl(t) { + return t.length; +} +function bR(t) { + return t.length; +} +function Kb(t, r) { + return r.push(t), t; +} +function Y3(t, r) { + return t.map(r).join(""); +} +var $0 = 1, Bp = 1, OI = 0, Vo = 0, Yr = 0, Zp = ""; +function F0(t, r, i, s, u, f, p) { + return { value: t, root: r, parent: i, type: s, props: u, children: f, line: $0, column: Bp, length: p, return: "" }; +} +function sm(t, r) { + return q3(F0("", null, null, "", null, null, 0), t, { length: -t.length }, r); +} +function K3() { + return Yr; +} +function Q3() { + return Yr = Vo > 0 ? Mi(Zp, --Vo) : 0, Bp--, Yr === 10 && (Bp = 1, $0--), Yr; +} +function ra() { + return Yr = Vo < OI ? Mi(Zp, Vo++) : 0, Bp++, Yr === 10 && (Bp = 1, $0++), Yr; +} +function Yl() { + return Mi(Zp, Vo); +} +function d0() { + return Vo; +} +function zm(t, r) { + return Dm(Zp, t, r); +} +function Am(t) { + switch (t) { + // \0 \t \n \r \s whitespace token + case 0: + case 9: + case 10: + case 13: + case 32: + return 5; + // ! + , / > @ ~ isolate token + case 33: + case 43: + case 44: + case 47: + case 62: + case 64: + case 126: + // ; { } breakpoint token + case 59: + case 123: + case 125: + return 4; + // : accompanied token + case 58: + return 3; + // " ' ( [ opening delimit token + case 34: + case 39: + case 40: + case 91: + return 2; + // ) ] closing delimit token + case 41: + case 93: + return 1; + } + return 0; +} +function kI(t) { + return $0 = Bp = 1, OI = Wl(Zp = t), Vo = 0, []; +} +function MI(t) { + return Zp = "", t; +} +function p0(t) { + return wI(zm(Vo - 1, YT(t === 91 ? t + 2 : t === 40 ? t + 1 : t))); +} +function X3(t) { + for (; (Yr = Yl()) && Yr < 33; ) + ra(); + return Am(t) > 2 || Am(Yr) > 3 ? "" : " "; +} +function Z3(t, r) { + for (; --r && ra() && !(Yr < 48 || Yr > 102 || Yr > 57 && Yr < 65 || Yr > 70 && Yr < 97); ) + ; + return zm(t, d0() + (r < 6 && Yl() == 32 && ra() == 32)); +} +function YT(t) { + for (; ra(); ) + switch (Yr) { + // ] ) " ' + case t: + return Vo; + // " ' + case 34: + case 39: + t !== 34 && t !== 39 && YT(Yr); + break; + // ( + case 40: + t === 41 && YT(t); + break; + // \ + case 92: + ra(); + break; + } + return Vo; +} +function J3(t, r) { + for (; ra() && t + Yr !== 57; ) + if (t + Yr === 84 && Yl() === 47) + break; + return "/*" + zm(r, Vo - 1) + "*" + j0(t === 47 ? t : ra()); +} +function e5(t) { + for (; !Am(Yl()); ) + ra(); + return zm(t, Vo); +} +function t5(t) { + return MI(v0("", null, null, null, [""], t = kI(t), 0, [0], t)); +} +function v0(t, r, i, s, u, f, p, g, b) { + for (var S = 0, x = 0, R = p, w = 0, A = 0, I = 0, N = 1, P = 1, F = 1, z = 0, j = "", U = u, O = f, H = s, M = j; P; ) + switch (I = z, z = ra()) { + // ( + case 40: + if (I != 108 && Mi(M, R - 1) == 58) { + GT(M += In(p0(z), "&", "&\f"), "&\f") != -1 && (F = -1); + break; + } + // " ' [ + case 34: + case 39: + case 91: + M += p0(z); + break; + // \t \n \r \s + case 9: + case 10: + case 13: + case 32: + M += X3(I); + break; + // \ + case 92: + M += Z3(d0() - 1, 7); + continue; + // / + case 47: + switch (Yl()) { + case 42: + case 47: + Kb(n5(J3(ra(), d0()), r, i), b); + break; + default: + M += "/"; + } + break; + // { + case 123 * N: + g[S++] = Wl(M) * F; + // } ; \0 + case 125 * N: + case 59: + case 0: + switch (z) { + // \0 } + case 0: + case 125: + P = 0; + // ; + case 59 + x: + F == -1 && (M = In(M, /\f/g, "")), A > 0 && Wl(M) - R && Kb(A > 32 ? fD(M + ";", s, i, R - 1) : fD(In(M, " ", "") + ";", s, i, R - 2), b); + break; + // @ ; + case 59: + M += ";"; + // { rule/at-rule + default: + if (Kb(H = cD(M, r, i, S, x, u, g, j, U = [], O = [], R), f), z === 123) + if (x === 0) + v0(M, r, H, H, U, f, R, g, O); + else + switch (w === 99 && Mi(M, 3) === 110 ? 100 : w) { + // d l m s + case 100: + case 108: + case 109: + case 115: + v0(t, H, H, s && Kb(cD(t, H, H, 0, 0, u, g, j, u, U = [], R), O), u, O, R, g, s ? U : O); + break; + default: + v0(M, H, H, H, [""], O, 0, g, O); + } + } + S = x = A = 0, N = F = 1, j = M = "", R = p; + break; + // : + case 58: + R = 1 + Wl(M), A = I; + default: + if (N < 1) { + if (z == 123) + --N; + else if (z == 125 && N++ == 0 && Q3() == 125) + continue; + } + switch (M += j0(z), z * N) { + // & + case 38: + F = x > 0 ? 1 : (M += "\f", -1); + break; + // , + case 44: + g[S++] = (Wl(M) - 1) * F, F = 1; + break; + // @ + case 64: + Yl() === 45 && (M += p0(ra())), w = Yl(), x = R = Wl(j = M += e5(d0())), z++; + break; + // - + case 45: + I === 45 && Wl(M) == 2 && (N = 0); + } + } + return f; +} +function cD(t, r, i, s, u, f, p, g, b, S, x) { + for (var R = u - 1, w = u === 0 ? f : [""], A = bR(w), I = 0, N = 0, P = 0; I < s; ++I) + for (var F = 0, z = Dm(t, R + 1, R = H3(N = p[I])), j = t; F < A; ++F) + (j = wI(N > 0 ? w[F] + " " + z : In(z, /&\f/g, w[F]))) && (b[P++] = j); + return F0(t, r, i, u === 0 ? yR : g, b, S, x); +} +function n5(t, r, i) { + return F0(t, r, i, TI, j0(K3()), Dm(t, 2, -2), 0); +} +function fD(t, r, i, s) { + return F0(t, r, i, gR, Dm(t, 0, s), Dm(t, s + 1, -1), s); +} +function zp(t, r) { + for (var i = "", s = bR(t), u = 0; u < s; u++) + i += r(t[u], u, t, r) || ""; + return i; +} +function r5(t, r, i, s) { + switch (t.type) { + case B3: + if (t.children.length) break; + case V3: + case gR: + return t.return = t.return || t.value; + case TI: + return ""; + case RI: + return t.return = t.value + "{" + zp(t.children, s) + "}"; + case yR: + t.value = t.props.join(","); + } + return Wl(i = zp(t.children, s)) ? t.return = t.value + "{" + i + "}" : ""; +} +function i5(t) { + var r = bR(t); + return function(i, s, u, f) { + for (var p = "", g = 0; g < r; g++) + p += t[g](i, s, u, f) || ""; + return p; + }; +} +function o5(t) { + return function(r) { + r.root || (r = r.return) && t(r); + }; +} +function DI(t) { + var r = /* @__PURE__ */ Object.create(null); + return function(i) { + return r[i] === void 0 && (r[i] = t(i)), r[i]; + }; +} +var a5 = function(r, i, s) { + for (var u = 0, f = 0; u = f, f = Yl(), u === 38 && f === 12 && (i[s] = 1), !Am(f); ) + ra(); + return zm(r, Vo); +}, l5 = function(r, i) { + var s = -1, u = 44; + do + switch (Am(u)) { + case 0: + u === 38 && Yl() === 12 && (i[s] = 1), r[s] += a5(Vo - 1, i, s); + break; + case 2: + r[s] += p0(u); + break; + case 4: + if (u === 44) { + r[++s] = Yl() === 58 ? "&\f" : "", i[s] = r[s].length; + break; + } + // fallthrough + default: + r[s] += j0(u); + } + while (u = ra()); + return r; +}, s5 = function(r, i) { + return MI(l5(kI(r), i)); +}, dD = /* @__PURE__ */ new WeakMap(), u5 = function(r) { + if (!(r.type !== "rule" || !r.parent || // positive .length indicates that this rule contains pseudo + // negative .length indicates that this rule has been already prefixed + r.length < 1)) { + for (var i = r.value, s = r.parent, u = r.column === s.column && r.line === s.line; s.type !== "rule"; ) + if (s = s.parent, !s) return; + if (!(r.props.length === 1 && i.charCodeAt(0) !== 58 && !dD.get(s)) && !u) { + dD.set(r, !0); + for (var f = [], p = s5(i, f), g = s.props, b = 0, S = 0; b < p.length; b++) + for (var x = 0; x < g.length; x++, S++) + r.props[S] = f[b] ? p[b].replace(/&\f/g, g[x]) : g[x] + " " + p[b]; + } + } +}, c5 = function(r) { + if (r.type === "decl") { + var i = r.value; + // charcode for l + i.charCodeAt(0) === 108 && // charcode for b + i.charCodeAt(2) === 98 && (r.return = "", r.value = ""); + } +}; +function AI(t, r) { + switch (W3(t, r)) { + // color-adjust + case 5103: + return Pn + "print-" + t + t; + // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function) + case 5737: + case 4201: + case 3177: + case 3433: + case 1641: + case 4457: + case 2921: + // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break + case 5572: + case 6356: + case 5844: + case 3191: + case 6645: + case 3005: + // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite, + case 6391: + case 5879: + case 5623: + case 6135: + case 4599: + case 4855: + // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width) + case 4215: + case 6389: + case 5109: + case 5365: + case 5621: + case 3829: + return Pn + t + t; + // appearance, user-select, transform, hyphens, text-size-adjust + case 5349: + case 4246: + case 4810: + case 6968: + case 2756: + return Pn + t + g0 + t + Xi + t + t; + // flex, flex-direction + case 6828: + case 4268: + return Pn + t + Xi + t + t; + // order + case 6165: + return Pn + t + Xi + "flex-" + t + t; + // align-items + case 5187: + return Pn + t + In(t, /(\w+).+(:[^]+)/, Pn + "box-$1$2" + Xi + "flex-$1$2") + t; + // align-self + case 5443: + return Pn + t + Xi + "flex-item-" + In(t, /flex-|-self/, "") + t; + // align-content + case 4675: + return Pn + t + Xi + "flex-line-pack" + In(t, /align-content|flex-|-self/, "") + t; + // flex-shrink + case 5548: + return Pn + t + Xi + In(t, "shrink", "negative") + t; + // flex-basis + case 5292: + return Pn + t + Xi + In(t, "basis", "preferred-size") + t; + // flex-grow + case 6060: + return Pn + "box-" + In(t, "-grow", "") + Pn + t + Xi + In(t, "grow", "positive") + t; + // transition + case 4554: + return Pn + In(t, /([^-])(transform)/g, "$1" + Pn + "$2") + t; + // cursor + case 6187: + return In(In(In(t, /(zoom-|grab)/, Pn + "$1"), /(image-set)/, Pn + "$1"), t, "") + t; + // background, background-image + case 5495: + case 3959: + return In(t, /(image-set\([^]*)/, Pn + "$1$`$1"); + // justify-content + case 4968: + return In(In(t, /(.+:)(flex-)?(.*)/, Pn + "box-pack:$3" + Xi + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + Pn + t + t; + // (margin|padding)-inline-(start|end) + case 4095: + case 3583: + case 4068: + case 2532: + return In(t, /(.+)-inline(.+)/, Pn + "$1$2") + t; + // (min|max)?(width|height|inline-size|block-size) + case 8116: + case 7059: + case 5753: + case 5535: + case 5445: + case 5701: + case 4933: + case 4677: + case 5533: + case 5789: + case 5021: + case 4765: + if (Wl(t) - 1 - r > 6) switch (Mi(t, r + 1)) { + // (m)ax-content, (m)in-content + case 109: + if (Mi(t, r + 4) !== 45) break; + // (f)ill-available, (f)it-content + case 102: + return In(t, /(.+:)(.+)-([^]+)/, "$1" + Pn + "$2-$3$1" + g0 + (Mi(t, r + 3) == 108 ? "$3" : "$2-$3")) + t; + // (s)tretch + case 115: + return ~GT(t, "stretch") ? AI(In(t, "stretch", "fill-available"), r) + t : t; + } + break; + // position: sticky + case 4949: + if (Mi(t, r + 1) !== 115) break; + // display: (flex|inline-flex) + case 6444: + switch (Mi(t, Wl(t) - 3 - (~GT(t, "!important") && 10))) { + // stic(k)y + case 107: + return In(t, ":", ":" + Pn) + t; + // (inline-)?fl(e)x + case 101: + return In(t, /(.+:)([^;!]+)(;|!.+)?/, "$1" + Pn + (Mi(t, 14) === 45 ? "inline-" : "") + "box$3$1" + Pn + "$2$3$1" + Xi + "$2box$3") + t; + } + break; + // writing-mode + case 5936: + switch (Mi(t, r + 11)) { + // vertical-l(r) + case 114: + return Pn + t + Xi + In(t, /[svh]\w+-[tblr]{2}/, "tb") + t; + // vertical-r(l) + case 108: + return Pn + t + Xi + In(t, /[svh]\w+-[tblr]{2}/, "tb-rl") + t; + // horizontal(-)tb + case 45: + return Pn + t + Xi + In(t, /[svh]\w+-[tblr]{2}/, "lr") + t; + } + return Pn + t + Xi + t + t; + } + return t; +} +var f5 = function(r, i, s, u) { + if (r.length > -1 && !r.return) switch (r.type) { + case gR: + r.return = AI(r.value, r.length); + break; + case RI: + return zp([sm(r, { + value: In(r.value, "@", "@" + Pn) + })], u); + case yR: + if (r.length) return Y3(r.props, function(f) { + switch (G3(f, /(::plac\w+|:read-\w+)/)) { + // :read-(only|write) + case ":read-only": + case ":read-write": + return zp([sm(r, { + props: [In(f, /:(read-\w+)/, ":" + g0 + "$1")] + })], u); + // :placeholder + case "::placeholder": + return zp([sm(r, { + props: [In(f, /:(plac\w+)/, ":" + Pn + "input-$1")] + }), sm(r, { + props: [In(f, /:(plac\w+)/, ":" + g0 + "$1")] + }), sm(r, { + props: [In(f, /:(plac\w+)/, Xi + "input-$1")] + })], u); + } + return ""; + }); + } +}, d5 = [f5], NI = function(r) { + var i = r.key; + if (i === "css") { + var s = document.querySelectorAll("style[data-emotion]:not([data-s])"); + Array.prototype.forEach.call(s, function(N) { + var P = N.getAttribute("data-emotion"); + P.indexOf(" ") !== -1 && (document.head.appendChild(N), N.setAttribute("data-s", "")); + }); + } + var u = r.stylisPlugins || d5, f = {}, p, g = []; + p = r.container || document.head, Array.prototype.forEach.call( + // this means we will ignore elements which don't have a space in them which + // means that the style elements we're looking at are only Emotion 11 server-rendered style elements + document.querySelectorAll('style[data-emotion^="' + i + ' "]'), + function(N) { + for (var P = N.getAttribute("data-emotion").split(" "), F = 1; F < P.length; F++) + f[P[F]] = !0; + g.push(N); + } + ); + var b, S = [u5, c5]; + { + var x, R = [r5, o5(function(N) { + x.insert(N); + })], w = i5(S.concat(u, R)), A = function(P) { + return zp(t5(P), w); + }; + b = function(P, F, z, j) { + x = z, A(P ? P + "{" + F.styles + "}" : F.styles), j && (I.inserted[F.name] = !0); + }; + } + var I = { + key: i, + sheet: new U3({ + key: i, + container: p, + nonce: r.nonce, + speedy: r.speedy, + prepend: r.prepend, + insertionPoint: r.insertionPoint + }), + nonce: r.nonce, + inserted: f, + registered: {}, + insert: b + }; + return I.sheet.hydrate(g), I; +}, Qb = { exports: {} }, Un = {}; +/** @license React v16.13.1 + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var pD; +function p5() { + if (pD) return Un; + pD = 1; + var t = typeof Symbol == "function" && Symbol.for, r = t ? Symbol.for("react.element") : 60103, i = t ? Symbol.for("react.portal") : 60106, s = t ? Symbol.for("react.fragment") : 60107, u = t ? Symbol.for("react.strict_mode") : 60108, f = t ? Symbol.for("react.profiler") : 60114, p = t ? Symbol.for("react.provider") : 60109, g = t ? Symbol.for("react.context") : 60110, b = t ? Symbol.for("react.async_mode") : 60111, S = t ? Symbol.for("react.concurrent_mode") : 60111, x = t ? Symbol.for("react.forward_ref") : 60112, R = t ? Symbol.for("react.suspense") : 60113, w = t ? Symbol.for("react.suspense_list") : 60120, A = t ? Symbol.for("react.memo") : 60115, I = t ? Symbol.for("react.lazy") : 60116, N = t ? Symbol.for("react.block") : 60121, P = t ? Symbol.for("react.fundamental") : 60117, F = t ? Symbol.for("react.responder") : 60118, z = t ? Symbol.for("react.scope") : 60119; + function j(O) { + if (typeof O == "object" && O !== null) { + var H = O.$$typeof; + switch (H) { + case r: + switch (O = O.type, O) { + case b: + case S: + case s: + case f: + case u: + case R: + return O; + default: + switch (O = O && O.$$typeof, O) { + case g: + case x: + case I: + case A: + case p: + return O; + default: + return H; + } + } + case i: + return H; + } + } + } + function U(O) { + return j(O) === S; + } + return Un.AsyncMode = b, Un.ConcurrentMode = S, Un.ContextConsumer = g, Un.ContextProvider = p, Un.Element = r, Un.ForwardRef = x, Un.Fragment = s, Un.Lazy = I, Un.Memo = A, Un.Portal = i, Un.Profiler = f, Un.StrictMode = u, Un.Suspense = R, Un.isAsyncMode = function(O) { + return U(O) || j(O) === b; + }, Un.isConcurrentMode = U, Un.isContextConsumer = function(O) { + return j(O) === g; + }, Un.isContextProvider = function(O) { + return j(O) === p; + }, Un.isElement = function(O) { + return typeof O == "object" && O !== null && O.$$typeof === r; + }, Un.isForwardRef = function(O) { + return j(O) === x; + }, Un.isFragment = function(O) { + return j(O) === s; + }, Un.isLazy = function(O) { + return j(O) === I; + }, Un.isMemo = function(O) { + return j(O) === A; + }, Un.isPortal = function(O) { + return j(O) === i; + }, Un.isProfiler = function(O) { + return j(O) === f; + }, Un.isStrictMode = function(O) { + return j(O) === u; + }, Un.isSuspense = function(O) { + return j(O) === R; + }, Un.isValidElementType = function(O) { + return typeof O == "string" || typeof O == "function" || O === s || O === S || O === f || O === u || O === R || O === w || typeof O == "object" && O !== null && (O.$$typeof === I || O.$$typeof === A || O.$$typeof === p || O.$$typeof === g || O.$$typeof === x || O.$$typeof === P || O.$$typeof === F || O.$$typeof === z || O.$$typeof === N); + }, Un.typeOf = j, Un; +} +var Vn = {}; +/** @license React v16.13.1 + * react-is.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var vD; +function v5() { + return vD || (vD = 1, process.env.NODE_ENV !== "production" && function() { + var t = typeof Symbol == "function" && Symbol.for, r = t ? Symbol.for("react.element") : 60103, i = t ? Symbol.for("react.portal") : 60106, s = t ? Symbol.for("react.fragment") : 60107, u = t ? Symbol.for("react.strict_mode") : 60108, f = t ? Symbol.for("react.profiler") : 60114, p = t ? Symbol.for("react.provider") : 60109, g = t ? Symbol.for("react.context") : 60110, b = t ? Symbol.for("react.async_mode") : 60111, S = t ? Symbol.for("react.concurrent_mode") : 60111, x = t ? Symbol.for("react.forward_ref") : 60112, R = t ? Symbol.for("react.suspense") : 60113, w = t ? Symbol.for("react.suspense_list") : 60120, A = t ? Symbol.for("react.memo") : 60115, I = t ? Symbol.for("react.lazy") : 60116, N = t ? Symbol.for("react.block") : 60121, P = t ? Symbol.for("react.fundamental") : 60117, F = t ? Symbol.for("react.responder") : 60118, z = t ? Symbol.for("react.scope") : 60119; + function j(ue) { + return typeof ue == "string" || typeof ue == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. + ue === s || ue === S || ue === f || ue === u || ue === R || ue === w || typeof ue == "object" && ue !== null && (ue.$$typeof === I || ue.$$typeof === A || ue.$$typeof === p || ue.$$typeof === g || ue.$$typeof === x || ue.$$typeof === P || ue.$$typeof === F || ue.$$typeof === z || ue.$$typeof === N); + } + function U(ue) { + if (typeof ue == "object" && ue !== null) { + var Ye = ue.$$typeof; + switch (Ye) { + case r: + var Te = ue.type; + switch (Te) { + case b: + case S: + case s: + case f: + case u: + case R: + return Te; + default: + var ot = Te && Te.$$typeof; + switch (ot) { + case g: + case x: + case I: + case A: + case p: + return ot; + default: + return Ye; + } + } + case i: + return Ye; + } + } + } + var O = b, H = S, M = g, q = p, Y = r, Z = x, oe = s, xe = I, se = A, be = i, Ee = f, Se = u, me = R, ie = !1; + function Ie(ue) { + return ie || (ie = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), ee(ue) || U(ue) === b; + } + function ee(ue) { + return U(ue) === S; + } + function W(ue) { + return U(ue) === g; + } + function ae(ue) { + return U(ue) === p; + } + function Oe(ue) { + return typeof ue == "object" && ue !== null && ue.$$typeof === r; + } + function Ce(ue) { + return U(ue) === x; + } + function Ae(ue) { + return U(ue) === s; + } + function Me(ue) { + return U(ue) === I; + } + function Ue(ue) { + return U(ue) === A; + } + function De(ue) { + return U(ue) === i; + } + function Ne(ue) { + return U(ue) === f; + } + function Ge(ue) { + return U(ue) === u; + } + function Je(ue) { + return U(ue) === R; + } + Vn.AsyncMode = O, Vn.ConcurrentMode = H, Vn.ContextConsumer = M, Vn.ContextProvider = q, Vn.Element = Y, Vn.ForwardRef = Z, Vn.Fragment = oe, Vn.Lazy = xe, Vn.Memo = se, Vn.Portal = be, Vn.Profiler = Ee, Vn.StrictMode = Se, Vn.Suspense = me, Vn.isAsyncMode = Ie, Vn.isConcurrentMode = ee, Vn.isContextConsumer = W, Vn.isContextProvider = ae, Vn.isElement = Oe, Vn.isForwardRef = Ce, Vn.isFragment = Ae, Vn.isLazy = Me, Vn.isMemo = Ue, Vn.isPortal = De, Vn.isProfiler = Ne, Vn.isStrictMode = Ge, Vn.isSuspense = Je, Vn.isValidElementType = j, Vn.typeOf = U; + }()), Vn; +} +var hD; +function h5() { + return hD || (hD = 1, process.env.NODE_ENV === "production" ? Qb.exports = p5() : Qb.exports = v5()), Qb.exports; +} +var ZC, mD; +function m5() { + if (mD) return ZC; + mD = 1; + var t = h5(), r = { + childContextTypes: !0, + contextType: !0, + contextTypes: !0, + defaultProps: !0, + displayName: !0, + getDefaultProps: !0, + getDerivedStateFromError: !0, + getDerivedStateFromProps: !0, + mixins: !0, + propTypes: !0, + type: !0 + }, i = { + name: !0, + length: !0, + prototype: !0, + caller: !0, + callee: !0, + arguments: !0, + arity: !0 + }, s = { + $$typeof: !0, + render: !0, + defaultProps: !0, + displayName: !0, + propTypes: !0 + }, u = { + $$typeof: !0, + compare: !0, + defaultProps: !0, + displayName: !0, + propTypes: !0, + type: !0 + }, f = {}; + f[t.ForwardRef] = s, f[t.Memo] = u; + function p(I) { + return t.isMemo(I) ? u : f[I.$$typeof] || r; + } + var g = Object.defineProperty, b = Object.getOwnPropertyNames, S = Object.getOwnPropertySymbols, x = Object.getOwnPropertyDescriptor, R = Object.getPrototypeOf, w = Object.prototype; + function A(I, N, P) { + if (typeof N != "string") { + if (w) { + var F = R(N); + F && F !== w && A(I, F, P); + } + var z = b(N); + S && (z = z.concat(S(N))); + for (var j = p(I), U = p(N), O = 0; O < z.length; ++O) { + var H = z[O]; + if (!i[H] && !(P && P[H]) && !(U && U[H]) && !(j && j[H])) { + var M = x(N, H); + try { + g(I, H, M); + } catch { + } + } + } + } + return I; + } + return ZC = A, ZC; +} +m5(); +var y5 = !0; +function PI(t, r, i) { + var s = ""; + return i.split(" ").forEach(function(u) { + t[u] !== void 0 ? r.push(t[u] + ";") : u && (s += u + " "); + }), s; +} +var ER = function(r, i, s) { + var u = r.key + "-" + i.name; + // we only need to add the styles to the registered cache if the + // class name could be used further down + // the tree but if it's a string tag, we know it won't + // so we don't have to add it to registered cache. + // this improves memory usage since we can avoid storing the whole style string + (s === !1 || // we need to always store it if we're in compat mode and + // in node since emotion-server relies on whether a style is in + // the registered cache to know whether a style is global or not + // also, note that this check will be dead code eliminated in the browser + y5 === !1) && r.registered[u] === void 0 && (r.registered[u] = i.styles); +}, SR = function(r, i, s) { + ER(r, i, s); + var u = r.key + "-" + i.name; + if (r.inserted[i.name] === void 0) { + var f = i; + do + r.insert(i === f ? "." + u : "", f, r.sheet, !0), f = f.next; + while (f !== void 0); + } +}; +function g5(t) { + for (var r = 0, i, s = 0, u = t.length; u >= 4; ++s, u -= 4) + i = t.charCodeAt(s) & 255 | (t.charCodeAt(++s) & 255) << 8 | (t.charCodeAt(++s) & 255) << 16 | (t.charCodeAt(++s) & 255) << 24, i = /* Math.imul(k, m): */ + (i & 65535) * 1540483477 + ((i >>> 16) * 59797 << 16), i ^= /* k >>> r: */ + i >>> 24, r = /* Math.imul(k, m): */ + (i & 65535) * 1540483477 + ((i >>> 16) * 59797 << 16) ^ /* Math.imul(h, m): */ + (r & 65535) * 1540483477 + ((r >>> 16) * 59797 << 16); + switch (u) { + case 3: + r ^= (t.charCodeAt(s + 2) & 255) << 16; + case 2: + r ^= (t.charCodeAt(s + 1) & 255) << 8; + case 1: + r ^= t.charCodeAt(s) & 255, r = /* Math.imul(h, m): */ + (r & 65535) * 1540483477 + ((r >>> 16) * 59797 << 16); + } + return r ^= r >>> 13, r = /* Math.imul(h, m): */ + (r & 65535) * 1540483477 + ((r >>> 16) * 59797 << 16), ((r ^ r >>> 15) >>> 0).toString(36); +} +var b5 = { + animationIterationCount: 1, + aspectRatio: 1, + borderImageOutset: 1, + borderImageSlice: 1, + borderImageWidth: 1, + boxFlex: 1, + boxFlexGroup: 1, + boxOrdinalGroup: 1, + columnCount: 1, + columns: 1, + flex: 1, + flexGrow: 1, + flexPositive: 1, + flexShrink: 1, + flexNegative: 1, + flexOrder: 1, + gridRow: 1, + gridRowEnd: 1, + gridRowSpan: 1, + gridRowStart: 1, + gridColumn: 1, + gridColumnEnd: 1, + gridColumnSpan: 1, + gridColumnStart: 1, + msGridRow: 1, + msGridRowSpan: 1, + msGridColumn: 1, + msGridColumnSpan: 1, + fontWeight: 1, + lineHeight: 1, + opacity: 1, + order: 1, + orphans: 1, + scale: 1, + tabSize: 1, + widows: 1, + zIndex: 1, + zoom: 1, + WebkitLineClamp: 1, + // SVG-related properties + fillOpacity: 1, + floodOpacity: 1, + stopOpacity: 1, + strokeDasharray: 1, + strokeDashoffset: 1, + strokeMiterlimit: 1, + strokeOpacity: 1, + strokeWidth: 1 +}, E5 = !1, S5 = /[A-Z]|^ms/g, C5 = /_EMO_([^_]+?)_([^]*?)_EMO_/g, II = function(r) { + return r.charCodeAt(1) === 45; +}, yD = function(r) { + return r != null && typeof r != "boolean"; +}, JC = /* @__PURE__ */ DI(function(t) { + return II(t) ? t : t.replace(S5, "-$&").toLowerCase(); +}), gD = function(r, i) { + switch (r) { + case "animation": + case "animationName": + if (typeof i == "string") + return i.replace(C5, function(s, u, f) { + return Gl = { + name: u, + styles: f, + next: Gl + }, u; + }); + } + return b5[r] !== 1 && !II(r) && typeof i == "number" && i !== 0 ? i + "px" : i; +}, _5 = "Component selectors can only be used in conjunction with @emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware compiler transform."; +function Nm(t, r, i) { + if (i == null) + return ""; + var s = i; + if (s.__emotion_styles !== void 0) + return s; + switch (typeof i) { + case "boolean": + return ""; + case "object": { + var u = i; + if (u.anim === 1) + return Gl = { + name: u.name, + styles: u.styles, + next: Gl + }, u.name; + var f = i; + if (f.styles !== void 0) { + var p = f.next; + if (p !== void 0) + for (; p !== void 0; ) + Gl = { + name: p.name, + styles: p.styles, + next: Gl + }, p = p.next; + var g = f.styles + ";"; + return g; + } + return x5(t, r, i); + } + case "function": { + if (t !== void 0) { + var b = Gl, S = i(t); + return Gl = b, Nm(t, r, S); + } + break; + } + } + var x = i; + if (r == null) + return x; + var R = r[x]; + return R !== void 0 ? R : x; +} +function x5(t, r, i) { + var s = ""; + if (Array.isArray(i)) + for (var u = 0; u < i.length; u++) + s += Nm(t, r, i[u]) + ";"; + else + for (var f in i) { + var p = i[f]; + if (typeof p != "object") { + var g = p; + r != null && r[g] !== void 0 ? s += f + "{" + r[g] + "}" : yD(g) && (s += JC(f) + ":" + gD(f, g) + ";"); + } else { + if (f === "NO_COMPONENT_SELECTOR" && E5) + throw new Error(_5); + if (Array.isArray(p) && typeof p[0] == "string" && (r == null || r[p[0]] === void 0)) + for (var b = 0; b < p.length; b++) + yD(p[b]) && (s += JC(f) + ":" + gD(f, p[b]) + ";"); + else { + var S = Nm(t, r, p); + switch (f) { + case "animation": + case "animationName": { + s += JC(f) + ":" + S + ";"; + break; + } + default: + s += f + "{" + S + "}"; + } + } + } + } + return s; +} +var bD = /label:\s*([^\s;{]+)\s*(;|$)/g, Gl; +function z0(t, r, i) { + if (t.length === 1 && typeof t[0] == "object" && t[0] !== null && t[0].styles !== void 0) + return t[0]; + var s = !0, u = ""; + Gl = void 0; + var f = t[0]; + if (f == null || f.raw === void 0) + s = !1, u += Nm(i, r, f); + else { + var p = f; + u += p[0]; + } + for (var g = 1; g < t.length; g++) + if (u += Nm(i, r, t[g]), s) { + var b = f; + u += b[g]; + } + bD.lastIndex = 0; + for (var S = "", x; (x = bD.exec(u)) !== null; ) + S += "-" + x[1]; + var R = g5(u) + S; + return { + name: R, + styles: u, + next: Gl + }; +} +var T5 = function(r) { + return r(); +}, LI = WT.useInsertionEffect ? WT.useInsertionEffect : !1, jI = LI || T5, ED = LI || B.useLayoutEffect, R5 = !1, $I = /* @__PURE__ */ B.createContext( + // we're doing this to avoid preconstruct's dead code elimination in this one case + // because this module is primarily intended for the browser and node + // but it's also required in react native and similar environments sometimes + // and we could have a special build just for that + // but this is much easier and the native packages + // might use a different theme context in the future anyway + typeof HTMLElement < "u" ? /* @__PURE__ */ NI({ + key: "css" + }) : null +), w5 = $I.Provider, CR = function(r) { + return /* @__PURE__ */ B.forwardRef(function(i, s) { + var u = B.useContext($I); + return r(i, u, s); + }); +}, Um = /* @__PURE__ */ B.createContext({}), _R = {}.hasOwnProperty, KT = "__EMOTION_TYPE_PLEASE_DO_NOT_USE__", O5 = function(r, i) { + var s = {}; + for (var u in i) + _R.call(i, u) && (s[u] = i[u]); + return s[KT] = r, s; +}, k5 = function(r) { + var i = r.cache, s = r.serialized, u = r.isStringTag; + return ER(i, s, u), jI(function() { + return SR(i, s, u); + }), null; +}, M5 = /* @__PURE__ */ CR(function(t, r, i) { + var s = t.css; + typeof s == "string" && r.registered[s] !== void 0 && (s = r.registered[s]); + var u = t[KT], f = [s], p = ""; + typeof t.className == "string" ? p = PI(r.registered, f, t.className) : t.className != null && (p = t.className + " "); + var g = z0(f, void 0, B.useContext(Um)); + p += r.key + "-" + g.name; + var b = {}; + for (var S in t) + _R.call(t, S) && S !== "css" && S !== KT && !R5 && (b[S] = t[S]); + return b.className = p, i && (b.ref = i), /* @__PURE__ */ B.createElement(B.Fragment, null, /* @__PURE__ */ B.createElement(k5, { + cache: r, + serialized: g, + isStringTag: typeof u == "string" + }), /* @__PURE__ */ B.createElement(u, b)); +}), D5 = M5, SD = function(r, i) { + var s = arguments; + if (i == null || !_R.call(i, "css")) + return B.createElement.apply(void 0, s); + var u = s.length, f = new Array(u); + f[0] = D5, f[1] = O5(r, i); + for (var p = 2; p < u; p++) + f[p] = s[p]; + return B.createElement.apply(null, f); +}; +(function(t) { + var r; + r || (r = t.JSX || (t.JSX = {})); +})(SD || (SD = {})); +var A5 = /* @__PURE__ */ CR(function(t, r) { + var i = t.styles, s = z0([i], void 0, B.useContext(Um)), u = B.useRef(); + return ED(function() { + var f = r.key + "-global", p = new r.sheet.constructor({ + key: f, + nonce: r.sheet.nonce, + container: r.sheet.container, + speedy: r.sheet.isSpeedy + }), g = !1, b = document.querySelector('style[data-emotion="' + f + " " + s.name + '"]'); + return r.sheet.tags.length && (p.before = r.sheet.tags[0]), b !== null && (g = !0, b.setAttribute("data-emotion", f), p.hydrate([b])), u.current = [p, g], function() { + p.flush(); + }; + }, [r]), ED(function() { + var f = u.current, p = f[0], g = f[1]; + if (g) { + f[1] = !1; + return; + } + if (s.next !== void 0 && SR(r, s.next, !0), p.tags.length) { + var b = p.tags[p.tags.length - 1].nextElementSibling; + p.before = b, p.flush(); + } + r.insert("", s, p, !1); + }, [r, s.name]), null; +}); +function FI() { + for (var t = arguments.length, r = new Array(t), i = 0; i < t; i++) + r[i] = arguments[i]; + return z0(r); +} +function U0() { + var t = FI.apply(void 0, arguments), r = "animation-" + t.name; + return { + name: r, + styles: "@keyframes " + r + "{" + t.styles + "}", + anim: 1, + toString: function() { + return "_EMO_" + this.name + "_" + this.styles + "_EMO_"; + } + }; +} +var N5 = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/, P5 = /* @__PURE__ */ DI( + function(t) { + return N5.test(t) || t.charCodeAt(0) === 111 && t.charCodeAt(1) === 110 && t.charCodeAt(2) < 91; + } + /* Z+1 */ +), I5 = !1, L5 = P5, j5 = function(r) { + return r !== "theme"; +}, CD = function(r) { + return typeof r == "string" && // 96 is one less than the char code + // for "a" so this is checking that + // it's a lowercase character + r.charCodeAt(0) > 96 ? L5 : j5; +}, _D = function(r, i, s) { + var u; + if (i) { + var f = i.shouldForwardProp; + u = r.__emotion_forwardProp && f ? function(p) { + return r.__emotion_forwardProp(p) && f(p); + } : f; + } + return typeof u != "function" && s && (u = r.__emotion_forwardProp), u; +}, $5 = function(r) { + var i = r.cache, s = r.serialized, u = r.isStringTag; + return ER(i, s, u), jI(function() { + return SR(i, s, u); + }), null; +}, F5 = function t(r, i) { + var s = r.__emotion_real === r, u = s && r.__emotion_base || r, f, p; + i !== void 0 && (f = i.label, p = i.target); + var g = _D(r, i, s), b = g || CD(u), S = !b("as"); + return function() { + var x = arguments, R = s && r.__emotion_styles !== void 0 ? r.__emotion_styles.slice(0) : []; + if (f !== void 0 && R.push("label:" + f + ";"), x[0] == null || x[0].raw === void 0) + R.push.apply(R, x); + else { + var w = x[0]; + R.push(w[0]); + for (var A = x.length, I = 1; I < A; I++) + R.push(x[I], w[I]); + } + var N = CR(function(P, F, z) { + var j = S && P.as || u, U = "", O = [], H = P; + if (P.theme == null) { + H = {}; + for (var M in P) + H[M] = P[M]; + H.theme = B.useContext(Um); + } + typeof P.className == "string" ? U = PI(F.registered, O, P.className) : P.className != null && (U = P.className + " "); + var q = z0(R.concat(O), F.registered, H); + U += F.key + "-" + q.name, p !== void 0 && (U += " " + p); + var Y = S && g === void 0 ? CD(j) : b, Z = {}; + for (var oe in P) + S && oe === "as" || Y(oe) && (Z[oe] = P[oe]); + return Z.className = U, z && (Z.ref = z), /* @__PURE__ */ B.createElement(B.Fragment, null, /* @__PURE__ */ B.createElement($5, { + cache: F, + serialized: q, + isStringTag: typeof j == "string" + }), /* @__PURE__ */ B.createElement(j, Z)); + }); + return N.displayName = f !== void 0 ? f : "Styled(" + (typeof u == "string" ? u : u.displayName || u.name || "Component") + ")", N.defaultProps = r.defaultProps, N.__emotion_real = N, N.__emotion_base = u, N.__emotion_styles = R, N.__emotion_forwardProp = g, Object.defineProperty(N, "toString", { + value: function() { + return p === void 0 && I5 ? "NO_COMPONENT_SELECTOR" : "." + p; + } + }), N.withComponent = function(P, F) { + var z = t(P, K({}, i, F, { + shouldForwardProp: _D(N, F, !0) + })); + return z.apply(void 0, R); + }, N; + }; +}, z5 = [ + "a", + "abbr", + "address", + "area", + "article", + "aside", + "audio", + "b", + "base", + "bdi", + "bdo", + "big", + "blockquote", + "body", + "br", + "button", + "canvas", + "caption", + "cite", + "code", + "col", + "colgroup", + "data", + "datalist", + "dd", + "del", + "details", + "dfn", + "dialog", + "div", + "dl", + "dt", + "em", + "embed", + "fieldset", + "figcaption", + "figure", + "footer", + "form", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "head", + "header", + "hgroup", + "hr", + "html", + "i", + "iframe", + "img", + "input", + "ins", + "kbd", + "keygen", + "label", + "legend", + "li", + "link", + "main", + "map", + "mark", + "marquee", + "menu", + "menuitem", + "meta", + "meter", + "nav", + "noscript", + "object", + "ol", + "optgroup", + "option", + "output", + "p", + "param", + "picture", + "pre", + "progress", + "q", + "rp", + "rt", + "ruby", + "s", + "samp", + "script", + "section", + "select", + "small", + "source", + "span", + "strong", + "style", + "sub", + "summary", + "sup", + "table", + "tbody", + "td", + "textarea", + "tfoot", + "th", + "thead", + "time", + "title", + "tr", + "track", + "u", + "ul", + "var", + "video", + "wbr", + // SVG + "circle", + "clipPath", + "defs", + "ellipse", + "foreignObject", + "g", + "image", + "line", + "linearGradient", + "mask", + "path", + "pattern", + "polygon", + "polyline", + "radialGradient", + "rect", + "stop", + "svg", + "text", + "tspan" +], QT = F5.bind(null); +z5.forEach(function(t) { + QT[t] = QT(t); +}); +let XT; +typeof document == "object" && (XT = NI({ + key: "css", + prepend: !0 +})); +function zI(t) { + const { + injectFirst: r, + children: i + } = t; + return r && XT ? /* @__PURE__ */ le.jsx(w5, { + value: XT, + children: i + }) : i; +} +process.env.NODE_ENV !== "production" && (zI.propTypes = { + /** + * Your component tree. + */ + children: v.node, + /** + * By default, the styles are injected last in the element of the page. + * As a result, they gain more specificity than any other style sheet. + * If you want to override MUI's styles, set this prop. + */ + injectFirst: v.bool +}); +function U5(t) { + return t == null || Object.keys(t).length === 0; +} +function xR(t) { + const { + styles: r, + defaultTheme: i = {} + } = t, s = typeof r == "function" ? (u) => r(U5(u) ? i : u) : r; + return /* @__PURE__ */ le.jsx(A5, { + styles: s + }); +} +process.env.NODE_ENV !== "production" && (xR.propTypes = { + defaultTheme: v.object, + styles: v.oneOfType([v.array, v.string, v.object, v.func]) +}); +/** + * @mui/styled-engine v5.16.8 + * + * @license MIT + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +function UI(t, r) { + const i = QT(t, r); + return process.env.NODE_ENV !== "production" ? (...s) => { + const u = typeof t == "string" ? `"${t}"` : "component"; + return s.length === 0 ? console.error([`MUI: Seems like you called \`styled(${u})()\` without a \`style\` argument.`, 'You must provide a `styles` argument: `styled("div")(styleYouForgotToPass)`.'].join(` +`)) : s.some((f) => f === void 0) && console.error(`MUI: the styled(${u})(...args) API requires all its args to be defined.`), i(...s); + } : i; +} +const VI = (t, r) => { + Array.isArray(t.__emotion_styles) && (t.__emotion_styles = r(t.__emotion_styles)); +}, V5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + GlobalStyles: xR, + StyledEngineProvider: zI, + ThemeContext: Um, + css: FI, + default: UI, + internal_processStyles: VI, + keyframes: U0 +}, Symbol.toStringTag, { value: "Module" })), B5 = /* @__PURE__ */ Ql(V5); +function Us(t) { + if (typeof t != "object" || t === null) + return !1; + const r = Object.getPrototypeOf(t); + return (r === null || r === Object.prototype || Object.getPrototypeOf(r) === null) && !(Symbol.toStringTag in t) && !(Symbol.iterator in t); +} +function BI(t) { + if (/* @__PURE__ */ B.isValidElement(t) || !Us(t)) + return t; + const r = {}; + return Object.keys(t).forEach((i) => { + r[i] = BI(t[i]); + }), r; +} +function ho(t, r, i = { + clone: !0 +}) { + const s = i.clone ? K({}, t) : t; + return Us(t) && Us(r) && Object.keys(r).forEach((u) => { + /* @__PURE__ */ B.isValidElement(r[u]) ? s[u] = r[u] : Us(r[u]) && // Avoid prototype pollution + Object.prototype.hasOwnProperty.call(t, u) && Us(t[u]) ? s[u] = ho(t[u], r[u], i) : i.clone ? s[u] = Us(r[u]) ? BI(r[u]) : r[u] : s[u] = r[u]; + }), s; +} +const H5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: ho, + isPlainObject: Us +}, Symbol.toStringTag, { value: "Module" })), q5 = /* @__PURE__ */ Ql(H5); +function Vs(t) { + let r = "https://mui.com/production-error/?code=" + t; + for (let i = 1; i < arguments.length; i += 1) + r += "&args[]=" + encodeURIComponent(arguments[i]); + return "Minified MUI error #" + t + "; visit " + r + " for the full message."; +} +const W5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: Vs +}, Symbol.toStringTag, { value: "Module" })); +function zt(t) { + if (typeof t != "string") + throw new Error(process.env.NODE_ENV !== "production" ? "MUI: `capitalize(string)` expects a string argument." : Vs(7)); + return t.charAt(0).toUpperCase() + t.slice(1); +} +const G5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: zt +}, Symbol.toStringTag, { value: "Module" })), Y5 = /* @__PURE__ */ Ql(G5); +var Xb = { exports: {} }, Bn = {}; +/** + * @license React + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var xD; +function K5() { + if (xD) return Bn; + xD = 1; + var t = Symbol.for("react.element"), r = Symbol.for("react.portal"), i = Symbol.for("react.fragment"), s = Symbol.for("react.strict_mode"), u = Symbol.for("react.profiler"), f = Symbol.for("react.provider"), p = Symbol.for("react.context"), g = Symbol.for("react.server_context"), b = Symbol.for("react.forward_ref"), S = Symbol.for("react.suspense"), x = Symbol.for("react.suspense_list"), R = Symbol.for("react.memo"), w = Symbol.for("react.lazy"), A = Symbol.for("react.offscreen"), I; + I = Symbol.for("react.module.reference"); + function N(P) { + if (typeof P == "object" && P !== null) { + var F = P.$$typeof; + switch (F) { + case t: + switch (P = P.type, P) { + case i: + case u: + case s: + case S: + case x: + return P; + default: + switch (P = P && P.$$typeof, P) { + case g: + case p: + case b: + case w: + case R: + case f: + return P; + default: + return F; + } + } + case r: + return F; + } + } + } + return Bn.ContextConsumer = p, Bn.ContextProvider = f, Bn.Element = t, Bn.ForwardRef = b, Bn.Fragment = i, Bn.Lazy = w, Bn.Memo = R, Bn.Portal = r, Bn.Profiler = u, Bn.StrictMode = s, Bn.Suspense = S, Bn.SuspenseList = x, Bn.isAsyncMode = function() { + return !1; + }, Bn.isConcurrentMode = function() { + return !1; + }, Bn.isContextConsumer = function(P) { + return N(P) === p; + }, Bn.isContextProvider = function(P) { + return N(P) === f; + }, Bn.isElement = function(P) { + return typeof P == "object" && P !== null && P.$$typeof === t; + }, Bn.isForwardRef = function(P) { + return N(P) === b; + }, Bn.isFragment = function(P) { + return N(P) === i; + }, Bn.isLazy = function(P) { + return N(P) === w; + }, Bn.isMemo = function(P) { + return N(P) === R; + }, Bn.isPortal = function(P) { + return N(P) === r; + }, Bn.isProfiler = function(P) { + return N(P) === u; + }, Bn.isStrictMode = function(P) { + return N(P) === s; + }, Bn.isSuspense = function(P) { + return N(P) === S; + }, Bn.isSuspenseList = function(P) { + return N(P) === x; + }, Bn.isValidElementType = function(P) { + return typeof P == "string" || typeof P == "function" || P === i || P === u || P === s || P === S || P === x || P === A || typeof P == "object" && P !== null && (P.$$typeof === w || P.$$typeof === R || P.$$typeof === f || P.$$typeof === p || P.$$typeof === b || P.$$typeof === I || P.getModuleId !== void 0); + }, Bn.typeOf = N, Bn; +} +var Hn = {}; +/** + * @license React + * react-is.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var TD; +function Q5() { + return TD || (TD = 1, process.env.NODE_ENV !== "production" && function() { + var t = Symbol.for("react.element"), r = Symbol.for("react.portal"), i = Symbol.for("react.fragment"), s = Symbol.for("react.strict_mode"), u = Symbol.for("react.profiler"), f = Symbol.for("react.provider"), p = Symbol.for("react.context"), g = Symbol.for("react.server_context"), b = Symbol.for("react.forward_ref"), S = Symbol.for("react.suspense"), x = Symbol.for("react.suspense_list"), R = Symbol.for("react.memo"), w = Symbol.for("react.lazy"), A = Symbol.for("react.offscreen"), I = !1, N = !1, P = !1, F = !1, z = !1, j; + j = Symbol.for("react.module.reference"); + function U(Te) { + return !!(typeof Te == "string" || typeof Te == "function" || Te === i || Te === u || z || Te === s || Te === S || Te === x || F || Te === A || I || N || P || typeof Te == "object" && Te !== null && (Te.$$typeof === w || Te.$$typeof === R || Te.$$typeof === f || Te.$$typeof === p || Te.$$typeof === b || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + Te.$$typeof === j || Te.getModuleId !== void 0)); + } + function O(Te) { + if (typeof Te == "object" && Te !== null) { + var ot = Te.$$typeof; + switch (ot) { + case t: + var jt = Te.type; + switch (jt) { + case i: + case u: + case s: + case S: + case x: + return jt; + default: + var Ht = jt && jt.$$typeof; + switch (Ht) { + case g: + case p: + case b: + case w: + case R: + case f: + return Ht; + default: + return ot; + } + } + case r: + return ot; + } + } + } + var H = p, M = f, q = t, Y = b, Z = i, oe = w, xe = R, se = r, be = u, Ee = s, Se = S, me = x, ie = !1, Ie = !1; + function ee(Te) { + return ie || (ie = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1; + } + function W(Te) { + return Ie || (Ie = !0, console.warn("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.")), !1; + } + function ae(Te) { + return O(Te) === p; + } + function Oe(Te) { + return O(Te) === f; + } + function Ce(Te) { + return typeof Te == "object" && Te !== null && Te.$$typeof === t; + } + function Ae(Te) { + return O(Te) === b; + } + function Me(Te) { + return O(Te) === i; + } + function Ue(Te) { + return O(Te) === w; + } + function De(Te) { + return O(Te) === R; + } + function Ne(Te) { + return O(Te) === r; + } + function Ge(Te) { + return O(Te) === u; + } + function Je(Te) { + return O(Te) === s; + } + function ue(Te) { + return O(Te) === S; + } + function Ye(Te) { + return O(Te) === x; + } + Hn.ContextConsumer = H, Hn.ContextProvider = M, Hn.Element = q, Hn.ForwardRef = Y, Hn.Fragment = Z, Hn.Lazy = oe, Hn.Memo = xe, Hn.Portal = se, Hn.Profiler = be, Hn.StrictMode = Ee, Hn.Suspense = Se, Hn.SuspenseList = me, Hn.isAsyncMode = ee, Hn.isConcurrentMode = W, Hn.isContextConsumer = ae, Hn.isContextProvider = Oe, Hn.isElement = Ce, Hn.isForwardRef = Ae, Hn.isFragment = Me, Hn.isLazy = Ue, Hn.isMemo = De, Hn.isPortal = Ne, Hn.isProfiler = Ge, Hn.isStrictMode = Je, Hn.isSuspense = ue, Hn.isSuspenseList = Ye, Hn.isValidElementType = U, Hn.typeOf = O; + }()), Hn; +} +var RD; +function X5() { + return RD || (RD = 1, process.env.NODE_ENV === "production" ? Xb.exports = K5() : Xb.exports = Q5()), Xb.exports; +} +var Hp = X5(); +const Z5 = /^\s*function(?:\s|\s*\/\*.*\*\/\s*)+([^(\s/]*)\s*/; +function HI(t) { + const r = `${t}`.match(Z5); + return r && r[1] || ""; +} +function qI(t, r = "") { + return t.displayName || t.name || HI(t) || r; +} +function wD(t, r, i) { + const s = qI(r); + return t.displayName || (s !== "" ? `${i}(${s})` : i); +} +function WI(t) { + if (t != null) { + if (typeof t == "string") + return t; + if (typeof t == "function") + return qI(t, "Component"); + if (typeof t == "object") + switch (t.$$typeof) { + case Hp.ForwardRef: + return wD(t, t.render, "ForwardRef"); + case Hp.Memo: + return wD(t, t.type, "memo"); + default: + return; + } + } +} +const J5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: WI, + getFunctionName: HI +}, Symbol.toStringTag, { value: "Module" })), e4 = /* @__PURE__ */ Ql(J5), t4 = ["values", "unit", "step"], n4 = (t) => { + const r = Object.keys(t).map((i) => ({ + key: i, + val: t[i] + })) || []; + return r.sort((i, s) => i.val - s.val), r.reduce((i, s) => K({}, i, { + [s.key]: s.val + }), {}); +}; +function GI(t) { + const { + // The breakpoint **start** at this value. + // For instance with the first breakpoint xs: [xs, sm). + values: r = { + xs: 0, + // phone + sm: 600, + // tablet + md: 900, + // small laptop + lg: 1200, + // desktop + xl: 1536 + // large screen + }, + unit: i = "px", + step: s = 5 + } = t, u = Ct(t, t4), f = n4(r), p = Object.keys(f); + function g(w) { + return `@media (min-width:${typeof r[w] == "number" ? r[w] : w}${i})`; + } + function b(w) { + return `@media (max-width:${(typeof r[w] == "number" ? r[w] : w) - s / 100}${i})`; + } + function S(w, A) { + const I = p.indexOf(A); + return `@media (min-width:${typeof r[w] == "number" ? r[w] : w}${i}) and (max-width:${(I !== -1 && typeof r[p[I]] == "number" ? r[p[I]] : A) - s / 100}${i})`; + } + function x(w) { + return p.indexOf(w) + 1 < p.length ? S(w, p[p.indexOf(w) + 1]) : g(w); + } + function R(w) { + const A = p.indexOf(w); + return A === 0 ? g(p[1]) : A === p.length - 1 ? b(p[A]) : S(w, p[p.indexOf(w) + 1]).replace("@media", "@media not all and"); + } + return K({ + keys: p, + values: f, + up: g, + down: b, + between: S, + only: x, + not: R, + unit: i + }, u); +} +const r4 = { + borderRadius: 4 +}, fc = process.env.NODE_ENV !== "production" ? v.oneOfType([v.number, v.string, v.object, v.array]) : {}; +function Tm(t, r) { + return r ? ho(t, r, { + clone: !1 + // No need to clone deep, it's way faster. + }) : t; +} +const TR = { + xs: 0, + // phone + sm: 600, + // tablet + md: 900, + // small laptop + lg: 1200, + // desktop + xl: 1536 + // large screen +}, OD = { + // Sorted ASC by size. That's important. + // It can't be configured as it's used statically for propTypes. + keys: ["xs", "sm", "md", "lg", "xl"], + up: (t) => `@media (min-width:${TR[t]}px)` +}; +function Bo(t, r, i) { + const s = t.theme || {}; + if (Array.isArray(r)) { + const f = s.breakpoints || OD; + return r.reduce((p, g, b) => (p[f.up(f.keys[b])] = i(r[b]), p), {}); + } + if (typeof r == "object") { + const f = s.breakpoints || OD; + return Object.keys(r).reduce((p, g) => { + if (Object.keys(f.values || TR).indexOf(g) !== -1) { + const b = f.up(g); + p[b] = i(r[g], g); + } else { + const b = g; + p[b] = r[b]; + } + return p; + }, {}); + } + return i(r); +} +function YI(t = {}) { + var r; + return ((r = t.keys) == null ? void 0 : r.reduce((s, u) => { + const f = t.up(u); + return s[f] = {}, s; + }, {})) || {}; +} +function KI(t, r) { + return t.reduce((i, s) => { + const u = i[s]; + return (!u || Object.keys(u).length === 0) && delete i[s], i; + }, r); +} +function i4(t, ...r) { + const i = YI(t), s = [i, ...r].reduce((u, f) => ho(u, f), {}); + return KI(Object.keys(i), s); +} +function o4(t, r) { + if (typeof t != "object") + return {}; + const i = {}, s = Object.keys(r); + return Array.isArray(t) ? s.forEach((u, f) => { + f < t.length && (i[u] = !0); + }) : s.forEach((u) => { + t[u] != null && (i[u] = !0); + }), i; +} +function Of({ + values: t, + breakpoints: r, + base: i +}) { + const s = i || o4(t, r), u = Object.keys(s); + if (u.length === 0) + return t; + let f; + return u.reduce((p, g, b) => (Array.isArray(t) ? (p[g] = t[b] != null ? t[b] : t[f], f = b) : typeof t == "object" ? (p[g] = t[g] != null ? t[g] : t[f], f = g) : p[g] = t, p), {}); +} +function qp(t, r, i = !0) { + if (!r || typeof r != "string") + return null; + if (t && t.vars && i) { + const s = `vars.${r}`.split(".").reduce((u, f) => u && u[f] ? u[f] : null, t); + if (s != null) + return s; + } + return r.split(".").reduce((s, u) => s && s[u] != null ? s[u] : null, t); +} +function b0(t, r, i, s = i) { + let u; + return typeof t == "function" ? u = t(i) : Array.isArray(t) ? u = t[i] || s : u = qp(t, i) || s, r && (u = r(u, s, t)), u; +} +function Fr(t) { + const { + prop: r, + cssProperty: i = t.prop, + themeKey: s, + transform: u + } = t, f = (p) => { + if (p[r] == null) + return null; + const g = p[r], b = p.theme, S = qp(b, s) || {}; + return Bo(p, g, (R) => { + let w = b0(S, u, R); + return R === w && typeof R == "string" && (w = b0(S, u, `${r}${R === "default" ? "" : zt(R)}`, R)), i === !1 ? w : { + [i]: w + }; + }); + }; + return f.propTypes = process.env.NODE_ENV !== "production" ? { + [r]: fc + } : {}, f.filterProps = [r], f; +} +function a4(t) { + const r = {}; + return (i) => (r[i] === void 0 && (r[i] = t(i)), r[i]); +} +const l4 = { + m: "margin", + p: "padding" +}, s4 = { + t: "Top", + r: "Right", + b: "Bottom", + l: "Left", + x: ["Left", "Right"], + y: ["Top", "Bottom"] +}, kD = { + marginX: "mx", + marginY: "my", + paddingX: "px", + paddingY: "py" +}, u4 = a4((t) => { + if (t.length > 2) + if (kD[t]) + t = kD[t]; + else + return [t]; + const [r, i] = t.split(""), s = l4[r], u = s4[i] || ""; + return Array.isArray(u) ? u.map((f) => s + f) : [s + u]; +}), V0 = ["m", "mt", "mr", "mb", "ml", "mx", "my", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "marginX", "marginY", "marginInline", "marginInlineStart", "marginInlineEnd", "marginBlock", "marginBlockStart", "marginBlockEnd"], B0 = ["p", "pt", "pr", "pb", "pl", "px", "py", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "paddingX", "paddingY", "paddingInline", "paddingInlineStart", "paddingInlineEnd", "paddingBlock", "paddingBlockStart", "paddingBlockEnd"], c4 = [...V0, ...B0]; +function Vm(t, r, i, s) { + var u; + const f = (u = qp(t, r, !1)) != null ? u : i; + return typeof f == "number" ? (p) => typeof p == "string" ? p : (process.env.NODE_ENV !== "production" && typeof p != "number" && console.error(`MUI: Expected ${s} argument to be a number or a string, got ${p}.`), f * p) : Array.isArray(f) ? (p) => typeof p == "string" ? p : (process.env.NODE_ENV !== "production" && (Number.isInteger(p) ? p > f.length - 1 && console.error([`MUI: The value provided (${p}) overflows.`, `The supported values are: ${JSON.stringify(f)}.`, `${p} > ${f.length - 1}, you need to add the missing values.`].join(` +`)) : console.error([`MUI: The \`theme.${r}\` array type cannot be combined with non integer values.You should either use an integer value that can be used as index, or define the \`theme.${r}\` as a number.`].join(` +`))), f[p]) : typeof f == "function" ? f : (process.env.NODE_ENV !== "production" && console.error([`MUI: The \`theme.${r}\` value (${f}) is invalid.`, "It should be a number, an array or a function."].join(` +`)), () => { + }); +} +function RR(t) { + return Vm(t, "spacing", 8, "spacing"); +} +function Df(t, r) { + if (typeof r == "string" || r == null) + return r; + const i = Math.abs(r), s = t(i); + return r >= 0 ? s : typeof s == "number" ? -s : `-${s}`; +} +function f4(t, r) { + return (i) => t.reduce((s, u) => (s[u] = Df(r, i), s), {}); +} +function d4(t, r, i, s) { + if (r.indexOf(i) === -1) + return null; + const u = u4(i), f = f4(u, s), p = t[i]; + return Bo(t, p, f); +} +function QI(t, r) { + const i = RR(t.theme); + return Object.keys(t).map((s) => d4(t, r, s, i)).reduce(Tm, {}); +} +function Mr(t) { + return QI(t, V0); +} +Mr.propTypes = process.env.NODE_ENV !== "production" ? V0.reduce((t, r) => (t[r] = fc, t), {}) : {}; +Mr.filterProps = V0; +function Dr(t) { + return QI(t, B0); +} +Dr.propTypes = process.env.NODE_ENV !== "production" ? B0.reduce((t, r) => (t[r] = fc, t), {}) : {}; +Dr.filterProps = B0; +process.env.NODE_ENV !== "production" && c4.reduce((t, r) => (t[r] = fc, t), {}); +function p4(t = 8) { + if (t.mui) + return t; + const r = RR({ + spacing: t + }), i = (...s) => (process.env.NODE_ENV !== "production" && (s.length <= 4 || console.error(`MUI: Too many arguments provided, expected between 0 and 4, got ${s.length}`)), (s.length === 0 ? [1] : s).map((f) => { + const p = r(f); + return typeof p == "number" ? `${p}px` : p; + }).join(" ")); + return i.mui = !0, i; +} +function H0(...t) { + const r = t.reduce((s, u) => (u.filterProps.forEach((f) => { + s[f] = u; + }), s), {}), i = (s) => Object.keys(s).reduce((u, f) => r[f] ? Tm(u, r[f](s)) : u, {}); + return i.propTypes = process.env.NODE_ENV !== "production" ? t.reduce((s, u) => Object.assign(s, u.propTypes), {}) : {}, i.filterProps = t.reduce((s, u) => s.concat(u.filterProps), []), i; +} +function Oa(t) { + return typeof t != "number" ? t : `${t}px solid`; +} +function ka(t, r) { + return Fr({ + prop: t, + themeKey: "borders", + transform: r + }); +} +const v4 = ka("border", Oa), h4 = ka("borderTop", Oa), m4 = ka("borderRight", Oa), y4 = ka("borderBottom", Oa), g4 = ka("borderLeft", Oa), b4 = ka("borderColor"), E4 = ka("borderTopColor"), S4 = ka("borderRightColor"), C4 = ka("borderBottomColor"), _4 = ka("borderLeftColor"), x4 = ka("outline", Oa), T4 = ka("outlineColor"), q0 = (t) => { + if (t.borderRadius !== void 0 && t.borderRadius !== null) { + const r = Vm(t.theme, "shape.borderRadius", 4, "borderRadius"), i = (s) => ({ + borderRadius: Df(r, s) + }); + return Bo(t, t.borderRadius, i); + } + return null; +}; +q0.propTypes = process.env.NODE_ENV !== "production" ? { + borderRadius: fc +} : {}; +q0.filterProps = ["borderRadius"]; +H0(v4, h4, m4, y4, g4, b4, E4, S4, C4, _4, q0, x4, T4); +const W0 = (t) => { + if (t.gap !== void 0 && t.gap !== null) { + const r = Vm(t.theme, "spacing", 8, "gap"), i = (s) => ({ + gap: Df(r, s) + }); + return Bo(t, t.gap, i); + } + return null; +}; +W0.propTypes = process.env.NODE_ENV !== "production" ? { + gap: fc +} : {}; +W0.filterProps = ["gap"]; +const G0 = (t) => { + if (t.columnGap !== void 0 && t.columnGap !== null) { + const r = Vm(t.theme, "spacing", 8, "columnGap"), i = (s) => ({ + columnGap: Df(r, s) + }); + return Bo(t, t.columnGap, i); + } + return null; +}; +G0.propTypes = process.env.NODE_ENV !== "production" ? { + columnGap: fc +} : {}; +G0.filterProps = ["columnGap"]; +const Y0 = (t) => { + if (t.rowGap !== void 0 && t.rowGap !== null) { + const r = Vm(t.theme, "spacing", 8, "rowGap"), i = (s) => ({ + rowGap: Df(r, s) + }); + return Bo(t, t.rowGap, i); + } + return null; +}; +Y0.propTypes = process.env.NODE_ENV !== "production" ? { + rowGap: fc +} : {}; +Y0.filterProps = ["rowGap"]; +const R4 = Fr({ + prop: "gridColumn" +}), w4 = Fr({ + prop: "gridRow" +}), O4 = Fr({ + prop: "gridAutoFlow" +}), k4 = Fr({ + prop: "gridAutoColumns" +}), M4 = Fr({ + prop: "gridAutoRows" +}), D4 = Fr({ + prop: "gridTemplateColumns" +}), A4 = Fr({ + prop: "gridTemplateRows" +}), N4 = Fr({ + prop: "gridTemplateAreas" +}), P4 = Fr({ + prop: "gridArea" +}); +H0(W0, G0, Y0, R4, w4, O4, k4, M4, D4, A4, N4, P4); +function Up(t, r) { + return r === "grey" ? r : t; +} +const I4 = Fr({ + prop: "color", + themeKey: "palette", + transform: Up +}), L4 = Fr({ + prop: "bgcolor", + cssProperty: "backgroundColor", + themeKey: "palette", + transform: Up +}), j4 = Fr({ + prop: "backgroundColor", + themeKey: "palette", + transform: Up +}); +H0(I4, L4, j4); +function na(t) { + return t <= 1 && t !== 0 ? `${t * 100}%` : t; +} +const $4 = Fr({ + prop: "width", + transform: na +}), wR = (t) => { + if (t.maxWidth !== void 0 && t.maxWidth !== null) { + const r = (i) => { + var s, u; + const f = ((s = t.theme) == null || (s = s.breakpoints) == null || (s = s.values) == null ? void 0 : s[i]) || TR[i]; + return f ? ((u = t.theme) == null || (u = u.breakpoints) == null ? void 0 : u.unit) !== "px" ? { + maxWidth: `${f}${t.theme.breakpoints.unit}` + } : { + maxWidth: f + } : { + maxWidth: na(i) + }; + }; + return Bo(t, t.maxWidth, r); + } + return null; +}; +wR.filterProps = ["maxWidth"]; +const F4 = Fr({ + prop: "minWidth", + transform: na +}), z4 = Fr({ + prop: "height", + transform: na +}), U4 = Fr({ + prop: "maxHeight", + transform: na +}), V4 = Fr({ + prop: "minHeight", + transform: na +}); +Fr({ + prop: "size", + cssProperty: "width", + transform: na +}); +Fr({ + prop: "size", + cssProperty: "height", + transform: na +}); +const B4 = Fr({ + prop: "boxSizing" +}); +H0($4, wR, F4, z4, U4, V4, B4); +const Bm = { + // borders + border: { + themeKey: "borders", + transform: Oa + }, + borderTop: { + themeKey: "borders", + transform: Oa + }, + borderRight: { + themeKey: "borders", + transform: Oa + }, + borderBottom: { + themeKey: "borders", + transform: Oa + }, + borderLeft: { + themeKey: "borders", + transform: Oa + }, + borderColor: { + themeKey: "palette" + }, + borderTopColor: { + themeKey: "palette" + }, + borderRightColor: { + themeKey: "palette" + }, + borderBottomColor: { + themeKey: "palette" + }, + borderLeftColor: { + themeKey: "palette" + }, + outline: { + themeKey: "borders", + transform: Oa + }, + outlineColor: { + themeKey: "palette" + }, + borderRadius: { + themeKey: "shape.borderRadius", + style: q0 + }, + // palette + color: { + themeKey: "palette", + transform: Up + }, + bgcolor: { + themeKey: "palette", + cssProperty: "backgroundColor", + transform: Up + }, + backgroundColor: { + themeKey: "palette", + transform: Up + }, + // spacing + p: { + style: Dr + }, + pt: { + style: Dr + }, + pr: { + style: Dr + }, + pb: { + style: Dr + }, + pl: { + style: Dr + }, + px: { + style: Dr + }, + py: { + style: Dr + }, + padding: { + style: Dr + }, + paddingTop: { + style: Dr + }, + paddingRight: { + style: Dr + }, + paddingBottom: { + style: Dr + }, + paddingLeft: { + style: Dr + }, + paddingX: { + style: Dr + }, + paddingY: { + style: Dr + }, + paddingInline: { + style: Dr + }, + paddingInlineStart: { + style: Dr + }, + paddingInlineEnd: { + style: Dr + }, + paddingBlock: { + style: Dr + }, + paddingBlockStart: { + style: Dr + }, + paddingBlockEnd: { + style: Dr + }, + m: { + style: Mr + }, + mt: { + style: Mr + }, + mr: { + style: Mr + }, + mb: { + style: Mr + }, + ml: { + style: Mr + }, + mx: { + style: Mr + }, + my: { + style: Mr + }, + margin: { + style: Mr + }, + marginTop: { + style: Mr + }, + marginRight: { + style: Mr + }, + marginBottom: { + style: Mr + }, + marginLeft: { + style: Mr + }, + marginX: { + style: Mr + }, + marginY: { + style: Mr + }, + marginInline: { + style: Mr + }, + marginInlineStart: { + style: Mr + }, + marginInlineEnd: { + style: Mr + }, + marginBlock: { + style: Mr + }, + marginBlockStart: { + style: Mr + }, + marginBlockEnd: { + style: Mr + }, + // display + displayPrint: { + cssProperty: !1, + transform: (t) => ({ + "@media print": { + display: t + } + }) + }, + display: {}, + overflow: {}, + textOverflow: {}, + visibility: {}, + whiteSpace: {}, + // flexbox + flexBasis: {}, + flexDirection: {}, + flexWrap: {}, + justifyContent: {}, + alignItems: {}, + alignContent: {}, + order: {}, + flex: {}, + flexGrow: {}, + flexShrink: {}, + alignSelf: {}, + justifyItems: {}, + justifySelf: {}, + // grid + gap: { + style: W0 + }, + rowGap: { + style: Y0 + }, + columnGap: { + style: G0 + }, + gridColumn: {}, + gridRow: {}, + gridAutoFlow: {}, + gridAutoColumns: {}, + gridAutoRows: {}, + gridTemplateColumns: {}, + gridTemplateRows: {}, + gridTemplateAreas: {}, + gridArea: {}, + // positions + position: {}, + zIndex: { + themeKey: "zIndex" + }, + top: {}, + right: {}, + bottom: {}, + left: {}, + // shadows + boxShadow: { + themeKey: "shadows" + }, + // sizing + width: { + transform: na + }, + maxWidth: { + style: wR + }, + minWidth: { + transform: na + }, + height: { + transform: na + }, + maxHeight: { + transform: na + }, + minHeight: { + transform: na + }, + boxSizing: {}, + // typography + fontFamily: { + themeKey: "typography" + }, + fontSize: { + themeKey: "typography" + }, + fontStyle: { + themeKey: "typography" + }, + fontWeight: { + themeKey: "typography" + }, + letterSpacing: {}, + textTransform: {}, + lineHeight: {}, + textAlign: {}, + typography: { + cssProperty: !1, + themeKey: "typography" + } +}; +function H4(...t) { + const r = t.reduce((s, u) => s.concat(Object.keys(u)), []), i = new Set(r); + return t.every((s) => i.size === Object.keys(s).length); +} +function q4(t, r) { + return typeof t == "function" ? t(r) : t; +} +function XI() { + function t(i, s, u, f) { + const p = { + [i]: s, + theme: u + }, g = f[i]; + if (!g) + return { + [i]: s + }; + const { + cssProperty: b = i, + themeKey: S, + transform: x, + style: R + } = g; + if (s == null) + return null; + if (S === "typography" && s === "inherit") + return { + [i]: s + }; + const w = qp(u, S) || {}; + return R ? R(p) : Bo(p, s, (I) => { + let N = b0(w, x, I); + return I === N && typeof I == "string" && (N = b0(w, x, `${i}${I === "default" ? "" : zt(I)}`, I)), b === !1 ? N : { + [b]: N + }; + }); + } + function r(i) { + var s; + const { + sx: u, + theme: f = {} + } = i || {}; + if (!u) + return null; + const p = (s = f.unstable_sxConfig) != null ? s : Bm; + function g(b) { + let S = b; + if (typeof b == "function") + S = b(f); + else if (typeof b != "object") + return b; + if (!S) + return null; + const x = YI(f.breakpoints), R = Object.keys(x); + let w = x; + return Object.keys(S).forEach((A) => { + const I = q4(S[A], f); + if (I != null) + if (typeof I == "object") + if (p[A]) + w = Tm(w, t(A, I, f, p)); + else { + const N = Bo({ + theme: f + }, I, (P) => ({ + [A]: P + })); + H4(N, I) ? w[A] = r({ + sx: I, + theme: f + }) : w = Tm(w, N); + } + else + w = Tm(w, t(A, I, f, p)); + }), KI(R, w); + } + return Array.isArray(u) ? u.map(g) : g(u); + } + return r; +} +const Hm = XI(); +Hm.filterProps = ["sx"]; +function ZI(t, r) { + const i = this; + return i.vars && typeof i.getColorSchemeSelector == "function" ? { + [i.getColorSchemeSelector(t).replace(/(\[[^\]]+\])/, "*:where($1)")]: r + } : i.palette.mode === t ? r : {}; +} +const W4 = ["breakpoints", "palette", "spacing", "shape"]; +function qm(t = {}, ...r) { + const { + breakpoints: i = {}, + palette: s = {}, + spacing: u, + shape: f = {} + } = t, p = Ct(t, W4), g = GI(i), b = p4(u); + let S = ho({ + breakpoints: g, + direction: "ltr", + components: {}, + // Inject component definitions. + palette: K({ + mode: "light" + }, s), + spacing: b, + shape: K({}, r4, f) + }, p); + return S.applyStyles = ZI, S = r.reduce((x, R) => ho(x, R), S), S.unstable_sxConfig = K({}, Bm, p == null ? void 0 : p.unstable_sxConfig), S.unstable_sx = function(R) { + return Hm({ + sx: R, + theme: this + }); + }, S; +} +const G4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: qm, + private_createBreakpoints: GI, + unstable_applyStyles: ZI +}, Symbol.toStringTag, { value: "Module" })), Y4 = /* @__PURE__ */ Ql(G4), K4 = ["sx"], Q4 = (t) => { + var r, i; + const s = { + systemProps: {}, + otherProps: {} + }, u = (r = t == null || (i = t.theme) == null ? void 0 : i.unstable_sxConfig) != null ? r : Bm; + return Object.keys(t).forEach((f) => { + u[f] ? s.systemProps[f] = t[f] : s.otherProps[f] = t[f]; + }), s; +}; +function K0(t) { + const { + sx: r + } = t, i = Ct(t, K4), { + systemProps: s, + otherProps: u + } = Q4(i); + let f; + return Array.isArray(r) ? f = [s, ...r] : typeof r == "function" ? f = (...p) => { + const g = r(...p); + return Us(g) ? K({}, s, g) : s; + } : f = K({}, s, r), K({}, u, { + sx: f + }); +} +const X4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: Hm, + extendSxProp: K0, + unstable_createStyleFunctionSx: XI, + unstable_defaultSxConfig: Bm +}, Symbol.toStringTag, { value: "Module" })), Z4 = /* @__PURE__ */ Ql(X4); +var MD; +function J4() { + if (MD) return Ef; + MD = 1; + var t = mR(); + Object.defineProperty(Ef, "__esModule", { + value: !0 + }), Ef.default = H, Ef.shouldForwardProp = P, Ef.systemDefaultTheme = void 0; + var r = t(L3()), i = t(j3()), s = A(B5), u = q5, f = t(Y5), p = t(e4), g = t(Y4), b = t(Z4); + const S = ["ownerState"], x = ["variants"], R = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"]; + function w(M) { + if (typeof WeakMap != "function") return null; + var q = /* @__PURE__ */ new WeakMap(), Y = /* @__PURE__ */ new WeakMap(); + return (w = function(Z) { + return Z ? Y : q; + })(M); + } + function A(M, q) { + if (M && M.__esModule) return M; + if (M === null || typeof M != "object" && typeof M != "function") return { default: M }; + var Y = w(q); + if (Y && Y.has(M)) return Y.get(M); + var Z = { __proto__: null }, oe = Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var xe in M) if (xe !== "default" && Object.prototype.hasOwnProperty.call(M, xe)) { + var se = oe ? Object.getOwnPropertyDescriptor(M, xe) : null; + se && (se.get || se.set) ? Object.defineProperty(Z, xe, se) : Z[xe] = M[xe]; + } + return Z.default = M, Y && Y.set(M, Z), Z; + } + function I(M) { + return Object.keys(M).length === 0; + } + function N(M) { + return typeof M == "string" && // 96 is one less than the char code + // for "a" so this is checking that + // it's a lowercase character + M.charCodeAt(0) > 96; + } + function P(M) { + return M !== "ownerState" && M !== "theme" && M !== "sx" && M !== "as"; + } + const F = Ef.systemDefaultTheme = (0, g.default)(), z = (M) => M && M.charAt(0).toLowerCase() + M.slice(1); + function j({ + defaultTheme: M, + theme: q, + themeId: Y + }) { + return I(q) ? M : q[Y] || q; + } + function U(M) { + return M ? (q, Y) => Y[M] : null; + } + function O(M, q) { + let { + ownerState: Y + } = q, Z = (0, i.default)(q, S); + const oe = typeof M == "function" ? M((0, r.default)({ + ownerState: Y + }, Z)) : M; + if (Array.isArray(oe)) + return oe.flatMap((xe) => O(xe, (0, r.default)({ + ownerState: Y + }, Z))); + if (oe && typeof oe == "object" && Array.isArray(oe.variants)) { + const { + variants: xe = [] + } = oe; + let be = (0, i.default)(oe, x); + return xe.forEach((Ee) => { + let Se = !0; + typeof Ee.props == "function" ? Se = Ee.props((0, r.default)({ + ownerState: Y + }, Z, Y)) : Object.keys(Ee.props).forEach((me) => { + (Y == null ? void 0 : Y[me]) !== Ee.props[me] && Z[me] !== Ee.props[me] && (Se = !1); + }), Se && (Array.isArray(be) || (be = [be]), be.push(typeof Ee.style == "function" ? Ee.style((0, r.default)({ + ownerState: Y + }, Z, Y)) : Ee.style)); + }), be; + } + return oe; + } + function H(M = {}) { + const { + themeId: q, + defaultTheme: Y = F, + rootShouldForwardProp: Z = P, + slotShouldForwardProp: oe = P + } = M, xe = (se) => (0, b.default)((0, r.default)({}, se, { + theme: j((0, r.default)({}, se, { + defaultTheme: Y, + themeId: q + })) + })); + return xe.__mui_systemSx = !0, (se, be = {}) => { + (0, s.internal_processStyles)(se, (De) => De.filter((Ne) => !(Ne != null && Ne.__mui_systemSx))); + const { + name: Ee, + slot: Se, + skipVariantsResolver: me, + skipSx: ie, + // TODO v6: remove `lowercaseFirstLetter()` in the next major release + // For more details: https://github.com/mui/material-ui/pull/37908 + overridesResolver: Ie = U(z(Se)) + } = be, ee = (0, i.default)(be, R), W = me !== void 0 ? me : ( + // TODO v6: remove `Root` in the next major release + // For more details: https://github.com/mui/material-ui/pull/37908 + Se && Se !== "Root" && Se !== "root" || !1 + ), ae = ie || !1; + let Oe; + process.env.NODE_ENV !== "production" && Ee && (Oe = `${Ee}-${z(Se || "Root")}`); + let Ce = P; + Se === "Root" || Se === "root" ? Ce = Z : Se ? Ce = oe : N(se) && (Ce = void 0); + const Ae = (0, s.default)(se, (0, r.default)({ + shouldForwardProp: Ce, + label: Oe + }, ee)), Me = (De) => typeof De == "function" && De.__emotion_real !== De || (0, u.isPlainObject)(De) ? (Ne) => O(De, (0, r.default)({}, Ne, { + theme: j({ + theme: Ne.theme, + defaultTheme: Y, + themeId: q + }) + })) : De, Ue = (De, ...Ne) => { + let Ge = Me(De); + const Je = Ne ? Ne.map(Me) : []; + Ee && Ie && Je.push((Te) => { + const ot = j((0, r.default)({}, Te, { + defaultTheme: Y, + themeId: q + })); + if (!ot.components || !ot.components[Ee] || !ot.components[Ee].styleOverrides) + return null; + const jt = ot.components[Ee].styleOverrides, Ht = {}; + return Object.entries(jt).forEach(([Dn, Ln]) => { + Ht[Dn] = O(Ln, (0, r.default)({}, Te, { + theme: ot + })); + }), Ie(Te, Ht); + }), Ee && !W && Je.push((Te) => { + var ot; + const jt = j((0, r.default)({}, Te, { + defaultTheme: Y, + themeId: q + })), Ht = jt == null || (ot = jt.components) == null || (ot = ot[Ee]) == null ? void 0 : ot.variants; + return O({ + variants: Ht + }, (0, r.default)({}, Te, { + theme: jt + })); + }), ae || Je.push(xe); + const ue = Je.length - Ne.length; + if (Array.isArray(De) && ue > 0) { + const Te = new Array(ue).fill(""); + Ge = [...De, ...Te], Ge.raw = [...De.raw, ...Te]; + } + const Ye = Ae(Ge, ...Je); + if (process.env.NODE_ENV !== "production") { + let Te; + Ee && (Te = `${Ee}${(0, f.default)(Se || "")}`), Te === void 0 && (Te = `Styled(${(0, p.default)(se)})`), Ye.displayName = Te; + } + return se.muiName && (Ye.muiName = se.muiName), Ye; + }; + return Ae.withConfig && (Ue.withConfig = Ae.withConfig), Ue; + }; + } + return Ef; +} +var eV = /* @__PURE__ */ J4(); +const tV = /* @__PURE__ */ Hs(eV), DD = (t) => t, nV = () => { + let t = DD; + return { + configure(r) { + t = r; + }, + generate(r) { + return t(r); + }, + reset() { + t = DD; + } + }; +}, JI = nV(), rV = { + active: "active", + checked: "checked", + completed: "completed", + disabled: "disabled", + error: "error", + expanded: "expanded", + focused: "focused", + focusVisible: "focusVisible", + open: "open", + readOnly: "readOnly", + required: "required", + selected: "selected" +}; +function fn(t, r, i = "Mui") { + const s = rV[r]; + return s ? `${i}-${s}` : `${JI.generate(t)}-${r}`; +} +function iV(t, r) { + return K({ + toolbar: { + minHeight: 56, + [t.up("xs")]: { + "@media (orientation: landscape)": { + minHeight: 48 + } + }, + [t.up("sm")]: { + minHeight: 64 + } + } + }, r); +} +var xr = {}; +const oV = /* @__PURE__ */ Ql(W5); +function eL(t, r = Number.MIN_SAFE_INTEGER, i = Number.MAX_SAFE_INTEGER) { + return Math.max(r, Math.min(t, i)); +} +const aV = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: eL +}, Symbol.toStringTag, { value: "Module" })), lV = /* @__PURE__ */ Ql(aV); +var AD; +function sV() { + if (AD) return xr; + AD = 1; + var t = mR(); + Object.defineProperty(xr, "__esModule", { + value: !0 + }), xr.alpha = I, xr.blend = H, xr.colorChannel = void 0, xr.darken = P, xr.decomposeColor = p, xr.emphasize = U, xr.getContrastRatio = A, xr.getLuminance = w, xr.hexToRgb = u, xr.hslToRgb = R, xr.lighten = z, xr.private_safeAlpha = N, xr.private_safeColorChannel = void 0, xr.private_safeDarken = F, xr.private_safeEmphasize = O, xr.private_safeLighten = j, xr.recomposeColor = S, xr.rgbToHex = x; + var r = t(oV), i = t(lV); + function s(M, q = 0, Y = 1) { + return process.env.NODE_ENV !== "production" && (M < q || M > Y) && console.error(`MUI: The value provided ${M} is out of range [${q}, ${Y}].`), (0, i.default)(M, q, Y); + } + function u(M) { + M = M.slice(1); + const q = new RegExp(`.{1,${M.length >= 6 ? 2 : 1}}`, "g"); + let Y = M.match(q); + return Y && Y[0].length === 1 && (Y = Y.map((Z) => Z + Z)), Y ? `rgb${Y.length === 4 ? "a" : ""}(${Y.map((Z, oe) => oe < 3 ? parseInt(Z, 16) : Math.round(parseInt(Z, 16) / 255 * 1e3) / 1e3).join(", ")})` : ""; + } + function f(M) { + const q = M.toString(16); + return q.length === 1 ? `0${q}` : q; + } + function p(M) { + if (M.type) + return M; + if (M.charAt(0) === "#") + return p(u(M)); + const q = M.indexOf("("), Y = M.substring(0, q); + if (["rgb", "rgba", "hsl", "hsla", "color"].indexOf(Y) === -1) + throw new Error(process.env.NODE_ENV !== "production" ? `MUI: Unsupported \`${M}\` color. +The following formats are supported: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().` : (0, r.default)(9, M)); + let Z = M.substring(q + 1, M.length - 1), oe; + if (Y === "color") { + if (Z = Z.split(" "), oe = Z.shift(), Z.length === 4 && Z[3].charAt(0) === "/" && (Z[3] = Z[3].slice(1)), ["srgb", "display-p3", "a98-rgb", "prophoto-rgb", "rec-2020"].indexOf(oe) === -1) + throw new Error(process.env.NODE_ENV !== "production" ? `MUI: unsupported \`${oe}\` color space. +The following color spaces are supported: srgb, display-p3, a98-rgb, prophoto-rgb, rec-2020.` : (0, r.default)(10, oe)); + } else + Z = Z.split(","); + return Z = Z.map((xe) => parseFloat(xe)), { + type: Y, + values: Z, + colorSpace: oe + }; + } + const g = (M) => { + const q = p(M); + return q.values.slice(0, 3).map((Y, Z) => q.type.indexOf("hsl") !== -1 && Z !== 0 ? `${Y}%` : Y).join(" "); + }; + xr.colorChannel = g; + const b = (M, q) => { + try { + return g(M); + } catch { + return q && process.env.NODE_ENV !== "production" && console.warn(q), M; + } + }; + xr.private_safeColorChannel = b; + function S(M) { + const { + type: q, + colorSpace: Y + } = M; + let { + values: Z + } = M; + return q.indexOf("rgb") !== -1 ? Z = Z.map((oe, xe) => xe < 3 ? parseInt(oe, 10) : oe) : q.indexOf("hsl") !== -1 && (Z[1] = `${Z[1]}%`, Z[2] = `${Z[2]}%`), q.indexOf("color") !== -1 ? Z = `${Y} ${Z.join(" ")}` : Z = `${Z.join(", ")}`, `${q}(${Z})`; + } + function x(M) { + if (M.indexOf("#") === 0) + return M; + const { + values: q + } = p(M); + return `#${q.map((Y, Z) => f(Z === 3 ? Math.round(255 * Y) : Y)).join("")}`; + } + function R(M) { + M = p(M); + const { + values: q + } = M, Y = q[0], Z = q[1] / 100, oe = q[2] / 100, xe = Z * Math.min(oe, 1 - oe), se = (Se, me = (Se + Y / 30) % 12) => oe - xe * Math.max(Math.min(me - 3, 9 - me, 1), -1); + let be = "rgb"; + const Ee = [Math.round(se(0) * 255), Math.round(se(8) * 255), Math.round(se(4) * 255)]; + return M.type === "hsla" && (be += "a", Ee.push(q[3])), S({ + type: be, + values: Ee + }); + } + function w(M) { + M = p(M); + let q = M.type === "hsl" || M.type === "hsla" ? p(R(M)).values : M.values; + return q = q.map((Y) => (M.type !== "color" && (Y /= 255), Y <= 0.03928 ? Y / 12.92 : ((Y + 0.055) / 1.055) ** 2.4)), Number((0.2126 * q[0] + 0.7152 * q[1] + 0.0722 * q[2]).toFixed(3)); + } + function A(M, q) { + const Y = w(M), Z = w(q); + return (Math.max(Y, Z) + 0.05) / (Math.min(Y, Z) + 0.05); + } + function I(M, q) { + return M = p(M), q = s(q), (M.type === "rgb" || M.type === "hsl") && (M.type += "a"), M.type === "color" ? M.values[3] = `/${q}` : M.values[3] = q, S(M); + } + function N(M, q, Y) { + try { + return I(M, q); + } catch { + return Y && process.env.NODE_ENV !== "production" && console.warn(Y), M; + } + } + function P(M, q) { + if (M = p(M), q = s(q), M.type.indexOf("hsl") !== -1) + M.values[2] *= 1 - q; + else if (M.type.indexOf("rgb") !== -1 || M.type.indexOf("color") !== -1) + for (let Y = 0; Y < 3; Y += 1) + M.values[Y] *= 1 - q; + return S(M); + } + function F(M, q, Y) { + try { + return P(M, q); + } catch { + return Y && process.env.NODE_ENV !== "production" && console.warn(Y), M; + } + } + function z(M, q) { + if (M = p(M), q = s(q), M.type.indexOf("hsl") !== -1) + M.values[2] += (100 - M.values[2]) * q; + else if (M.type.indexOf("rgb") !== -1) + for (let Y = 0; Y < 3; Y += 1) + M.values[Y] += (255 - M.values[Y]) * q; + else if (M.type.indexOf("color") !== -1) + for (let Y = 0; Y < 3; Y += 1) + M.values[Y] += (1 - M.values[Y]) * q; + return S(M); + } + function j(M, q, Y) { + try { + return z(M, q); + } catch { + return Y && process.env.NODE_ENV !== "production" && console.warn(Y), M; + } + } + function U(M, q = 0.15) { + return w(M) > 0.5 ? P(M, q) : z(M, q); + } + function O(M, q, Y) { + try { + return U(M, q); + } catch { + return Y && process.env.NODE_ENV !== "production" && console.warn(Y), M; + } + } + function H(M, q, Y, Z = 1) { + const oe = (Ee, Se) => Math.round((Ee ** (1 / Z) * (1 - Y) + Se ** (1 / Z) * Y) ** Z), xe = p(M), se = p(q), be = [oe(xe.values[0], se.values[0]), oe(xe.values[1], se.values[1]), oe(xe.values[2], se.values[2])]; + return S({ + type: "rgb", + values: be + }); + } + return xr; +} +var Zi = /* @__PURE__ */ sV(); +const Pm = { + black: "#000", + white: "#fff" +}, uV = { + 50: "#fafafa", + 100: "#f5f5f5", + 200: "#eeeeee", + 300: "#e0e0e0", + 400: "#bdbdbd", + 500: "#9e9e9e", + 600: "#757575", + 700: "#616161", + 800: "#424242", + 900: "#212121", + A100: "#f5f5f5", + A200: "#eeeeee", + A400: "#bdbdbd", + A700: "#616161" +}, Tp = { + 50: "#f3e5f5", + 100: "#e1bee7", + 200: "#ce93d8", + 300: "#ba68c8", + 400: "#ab47bc", + 500: "#9c27b0", + 600: "#8e24aa", + 700: "#7b1fa2", + 800: "#6a1b9a", + 900: "#4a148c", + A100: "#ea80fc", + A200: "#e040fb", + A400: "#d500f9", + A700: "#aa00ff" +}, Rp = { + 50: "#ffebee", + 100: "#ffcdd2", + 200: "#ef9a9a", + 300: "#e57373", + 400: "#ef5350", + 500: "#f44336", + 600: "#e53935", + 700: "#d32f2f", + 800: "#c62828", + 900: "#b71c1c", + A100: "#ff8a80", + A200: "#ff5252", + A400: "#ff1744", + A700: "#d50000" +}, um = { + 50: "#fff3e0", + 100: "#ffe0b2", + 200: "#ffcc80", + 300: "#ffb74d", + 400: "#ffa726", + 500: "#ff9800", + 600: "#fb8c00", + 700: "#f57c00", + 800: "#ef6c00", + 900: "#e65100", + A100: "#ffd180", + A200: "#ffab40", + A400: "#ff9100", + A700: "#ff6d00" +}, wp = { + 50: "#e3f2fd", + 100: "#bbdefb", + 200: "#90caf9", + 300: "#64b5f6", + 400: "#42a5f5", + 500: "#2196f3", + 600: "#1e88e5", + 700: "#1976d2", + 800: "#1565c0", + 900: "#0d47a1", + A100: "#82b1ff", + A200: "#448aff", + A400: "#2979ff", + A700: "#2962ff" +}, Op = { + 50: "#e1f5fe", + 100: "#b3e5fc", + 200: "#81d4fa", + 300: "#4fc3f7", + 400: "#29b6f6", + 500: "#03a9f4", + 600: "#039be5", + 700: "#0288d1", + 800: "#0277bd", + 900: "#01579b", + A100: "#80d8ff", + A200: "#40c4ff", + A400: "#00b0ff", + A700: "#0091ea" +}, kp = { + 50: "#e8f5e9", + 100: "#c8e6c9", + 200: "#a5d6a7", + 300: "#81c784", + 400: "#66bb6a", + 500: "#4caf50", + 600: "#43a047", + 700: "#388e3c", + 800: "#2e7d32", + 900: "#1b5e20", + A100: "#b9f6ca", + A200: "#69f0ae", + A400: "#00e676", + A700: "#00c853" +}, cV = ["mode", "contrastThreshold", "tonalOffset"], ND = { + // The colors used to style the text. + text: { + // The most important text. + primary: "rgba(0, 0, 0, 0.87)", + // Secondary text. + secondary: "rgba(0, 0, 0, 0.6)", + // Disabled text have even lower visual prominence. + disabled: "rgba(0, 0, 0, 0.38)" + }, + // The color used to divide different elements. + divider: "rgba(0, 0, 0, 0.12)", + // The background colors used to style the surfaces. + // Consistency between these values is important. + background: { + paper: Pm.white, + default: Pm.white + }, + // The colors used to style the action elements. + action: { + // The color of an active action like an icon button. + active: "rgba(0, 0, 0, 0.54)", + // The color of an hovered action. + hover: "rgba(0, 0, 0, 0.04)", + hoverOpacity: 0.04, + // The color of a selected action. + selected: "rgba(0, 0, 0, 0.08)", + selectedOpacity: 0.08, + // The color of a disabled action. + disabled: "rgba(0, 0, 0, 0.26)", + // The background color of a disabled action. + disabledBackground: "rgba(0, 0, 0, 0.12)", + disabledOpacity: 0.38, + focus: "rgba(0, 0, 0, 0.12)", + focusOpacity: 0.12, + activatedOpacity: 0.12 + } +}, e_ = { + text: { + primary: Pm.white, + secondary: "rgba(255, 255, 255, 0.7)", + disabled: "rgba(255, 255, 255, 0.5)", + icon: "rgba(255, 255, 255, 0.5)" + }, + divider: "rgba(255, 255, 255, 0.12)", + background: { + paper: "#121212", + default: "#121212" + }, + action: { + active: Pm.white, + hover: "rgba(255, 255, 255, 0.08)", + hoverOpacity: 0.08, + selected: "rgba(255, 255, 255, 0.16)", + selectedOpacity: 0.16, + disabled: "rgba(255, 255, 255, 0.3)", + disabledBackground: "rgba(255, 255, 255, 0.12)", + disabledOpacity: 0.38, + focus: "rgba(255, 255, 255, 0.12)", + focusOpacity: 0.12, + activatedOpacity: 0.24 + } +}; +function PD(t, r, i, s) { + const u = s.light || s, f = s.dark || s * 1.5; + t[r] || (t.hasOwnProperty(i) ? t[r] = t[i] : r === "light" ? t.light = Zi.lighten(t.main, u) : r === "dark" && (t.dark = Zi.darken(t.main, f))); +} +function fV(t = "light") { + return t === "dark" ? { + main: wp[200], + light: wp[50], + dark: wp[400] + } : { + main: wp[700], + light: wp[400], + dark: wp[800] + }; +} +function dV(t = "light") { + return t === "dark" ? { + main: Tp[200], + light: Tp[50], + dark: Tp[400] + } : { + main: Tp[500], + light: Tp[300], + dark: Tp[700] + }; +} +function pV(t = "light") { + return t === "dark" ? { + main: Rp[500], + light: Rp[300], + dark: Rp[700] + } : { + main: Rp[700], + light: Rp[400], + dark: Rp[800] + }; +} +function vV(t = "light") { + return t === "dark" ? { + main: Op[400], + light: Op[300], + dark: Op[700] + } : { + main: Op[700], + light: Op[500], + dark: Op[900] + }; +} +function hV(t = "light") { + return t === "dark" ? { + main: kp[400], + light: kp[300], + dark: kp[700] + } : { + main: kp[800], + light: kp[500], + dark: kp[900] + }; +} +function mV(t = "light") { + return t === "dark" ? { + main: um[400], + light: um[300], + dark: um[700] + } : { + main: "#ed6c02", + // closest to orange[800] that pass 3:1. + light: um[500], + dark: um[900] + }; +} +function yV(t) { + const { + mode: r = "light", + contrastThreshold: i = 3, + tonalOffset: s = 0.2 + } = t, u = Ct(t, cV), f = t.primary || fV(r), p = t.secondary || dV(r), g = t.error || pV(r), b = t.info || vV(r), S = t.success || hV(r), x = t.warning || mV(r); + function R(N) { + const P = Zi.getContrastRatio(N, e_.text.primary) >= i ? e_.text.primary : ND.text.primary; + if (process.env.NODE_ENV !== "production") { + const F = Zi.getContrastRatio(N, P); + F < 3 && console.error([`MUI: The contrast ratio of ${F}:1 for ${P} on ${N}`, "falls below the WCAG recommended absolute minimum contrast ratio of 3:1.", "https://www.w3.org/TR/2008/REC-WCAG20-20081211/#visual-audio-contrast-contrast"].join(` +`)); + } + return P; + } + const w = ({ + color: N, + name: P, + mainShade: F = 500, + lightShade: z = 300, + darkShade: j = 700 + }) => { + if (N = K({}, N), !N.main && N[F] && (N.main = N[F]), !N.hasOwnProperty("main")) + throw new Error(process.env.NODE_ENV !== "production" ? `MUI: The color${P ? ` (${P})` : ""} provided to augmentColor(color) is invalid. +The color object needs to have a \`main\` property or a \`${F}\` property.` : Vs(11, P ? ` (${P})` : "", F)); + if (typeof N.main != "string") + throw new Error(process.env.NODE_ENV !== "production" ? `MUI: The color${P ? ` (${P})` : ""} provided to augmentColor(color) is invalid. +\`color.main\` should be a string, but \`${JSON.stringify(N.main)}\` was provided instead. + +Did you intend to use one of the following approaches? + +import { green } from "@mui/material/colors"; + +const theme1 = createTheme({ palette: { + primary: green, +} }); + +const theme2 = createTheme({ palette: { + primary: { main: green[500] }, +} });` : Vs(12, P ? ` (${P})` : "", JSON.stringify(N.main))); + return PD(N, "light", z, s), PD(N, "dark", j, s), N.contrastText || (N.contrastText = R(N.main)), N; + }, A = { + dark: e_, + light: ND + }; + return process.env.NODE_ENV !== "production" && (A[r] || console.error(`MUI: The palette mode \`${r}\` is not supported.`)), ho(K({ + // A collection of common colors. + common: K({}, Pm), + // prevent mutable object. + // The palette mode, can be light or dark. + mode: r, + // The colors used to represent primary interface elements for a user. + primary: w({ + color: f, + name: "primary" + }), + // The colors used to represent secondary interface elements for a user. + secondary: w({ + color: p, + name: "secondary", + mainShade: "A400", + lightShade: "A200", + darkShade: "A700" + }), + // The colors used to represent interface elements that the user should be made aware of. + error: w({ + color: g, + name: "error" + }), + // The colors used to represent potentially dangerous actions or important messages. + warning: w({ + color: x, + name: "warning" + }), + // The colors used to present information to the user that is neutral and not necessarily important. + info: w({ + color: b, + name: "info" + }), + // The colors used to indicate the successful completion of an action that user triggered. + success: w({ + color: S, + name: "success" + }), + // The grey colors. + grey: uV, + // Used by `getContrastText()` to maximize the contrast between + // the background and the text. + contrastThreshold: i, + // Takes a background color and returns the text color that maximizes the contrast. + getContrastText: R, + // Generate a rich color object. + augmentColor: w, + // Used by the functions below to shift a color's luminance by approximately + // two indexes within its tonal palette. + // E.g., shift from Red 500 to Red 300 or Red 700. + tonalOffset: s + }, A[r]), u); +} +const gV = ["fontFamily", "fontSize", "fontWeightLight", "fontWeightRegular", "fontWeightMedium", "fontWeightBold", "htmlFontSize", "allVariants", "pxToRem"]; +function bV(t) { + return Math.round(t * 1e5) / 1e5; +} +const ID = { + textTransform: "uppercase" +}, LD = '"Roboto", "Helvetica", "Arial", sans-serif'; +function EV(t, r) { + const i = typeof r == "function" ? r(t) : r, { + fontFamily: s = LD, + // The default font size of the Material Specification. + fontSize: u = 14, + // px + fontWeightLight: f = 300, + fontWeightRegular: p = 400, + fontWeightMedium: g = 500, + fontWeightBold: b = 700, + // Tell MUI what's the font-size on the html element. + // 16px is the default font-size used by browsers. + htmlFontSize: S = 16, + // Apply the CSS properties to all the variants. + allVariants: x, + pxToRem: R + } = i, w = Ct(i, gV); + process.env.NODE_ENV !== "production" && (typeof u != "number" && console.error("MUI: `fontSize` is required to be a number."), typeof S != "number" && console.error("MUI: `htmlFontSize` is required to be a number.")); + const A = u / 14, I = R || ((F) => `${F / S * A}rem`), N = (F, z, j, U, O) => K({ + fontFamily: s, + fontWeight: F, + fontSize: I(z), + // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/ + lineHeight: j + }, s === LD ? { + letterSpacing: `${bV(U / z)}em` + } : {}, O, x), P = { + h1: N(f, 96, 1.167, -1.5), + h2: N(f, 60, 1.2, -0.5), + h3: N(p, 48, 1.167, 0), + h4: N(p, 34, 1.235, 0.25), + h5: N(p, 24, 1.334, 0), + h6: N(g, 20, 1.6, 0.15), + subtitle1: N(p, 16, 1.75, 0.15), + subtitle2: N(g, 14, 1.57, 0.1), + body1: N(p, 16, 1.5, 0.15), + body2: N(p, 14, 1.43, 0.15), + button: N(g, 14, 1.75, 0.4, ID), + caption: N(p, 12, 1.66, 0.4), + overline: N(p, 12, 2.66, 1, ID), + // TODO v6: Remove handling of 'inherit' variant from the theme as it is already handled in Material UI's Typography component. Also, remember to remove the associated types. + inherit: { + fontFamily: "inherit", + fontWeight: "inherit", + fontSize: "inherit", + lineHeight: "inherit", + letterSpacing: "inherit" + } + }; + return ho(K({ + htmlFontSize: S, + pxToRem: I, + fontFamily: s, + fontSize: u, + fontWeightLight: f, + fontWeightRegular: p, + fontWeightMedium: g, + fontWeightBold: b + }, P), w, { + clone: !1 + // No need to clone deep + }); +} +const SV = 0.2, CV = 0.14, _V = 0.12; +function gr(...t) { + return [`${t[0]}px ${t[1]}px ${t[2]}px ${t[3]}px rgba(0,0,0,${SV})`, `${t[4]}px ${t[5]}px ${t[6]}px ${t[7]}px rgba(0,0,0,${CV})`, `${t[8]}px ${t[9]}px ${t[10]}px ${t[11]}px rgba(0,0,0,${_V})`].join(","); +} +const xV = ["none", gr(0, 2, 1, -1, 0, 1, 1, 0, 0, 1, 3, 0), gr(0, 3, 1, -2, 0, 2, 2, 0, 0, 1, 5, 0), gr(0, 3, 3, -2, 0, 3, 4, 0, 0, 1, 8, 0), gr(0, 2, 4, -1, 0, 4, 5, 0, 0, 1, 10, 0), gr(0, 3, 5, -1, 0, 5, 8, 0, 0, 1, 14, 0), gr(0, 3, 5, -1, 0, 6, 10, 0, 0, 1, 18, 0), gr(0, 4, 5, -2, 0, 7, 10, 1, 0, 2, 16, 1), gr(0, 5, 5, -3, 0, 8, 10, 1, 0, 3, 14, 2), gr(0, 5, 6, -3, 0, 9, 12, 1, 0, 3, 16, 2), gr(0, 6, 6, -3, 0, 10, 14, 1, 0, 4, 18, 3), gr(0, 6, 7, -4, 0, 11, 15, 1, 0, 4, 20, 3), gr(0, 7, 8, -4, 0, 12, 17, 2, 0, 5, 22, 4), gr(0, 7, 8, -4, 0, 13, 19, 2, 0, 5, 24, 4), gr(0, 7, 9, -4, 0, 14, 21, 2, 0, 5, 26, 4), gr(0, 8, 9, -5, 0, 15, 22, 2, 0, 6, 28, 5), gr(0, 8, 10, -5, 0, 16, 24, 2, 0, 6, 30, 5), gr(0, 8, 11, -5, 0, 17, 26, 2, 0, 6, 32, 5), gr(0, 9, 11, -5, 0, 18, 28, 2, 0, 7, 34, 6), gr(0, 9, 12, -6, 0, 19, 29, 2, 0, 7, 36, 6), gr(0, 10, 13, -6, 0, 20, 31, 3, 0, 8, 38, 7), gr(0, 10, 13, -6, 0, 21, 33, 3, 0, 8, 40, 7), gr(0, 10, 14, -6, 0, 22, 35, 3, 0, 8, 42, 7), gr(0, 11, 14, -7, 0, 23, 36, 3, 0, 9, 44, 8), gr(0, 11, 15, -7, 0, 24, 38, 3, 0, 9, 46, 8)], TV = ["duration", "easing", "delay"], RV = { + // This is the most common easing curve. + easeInOut: "cubic-bezier(0.4, 0, 0.2, 1)", + // Objects enter the screen at full velocity from off-screen and + // slowly decelerate to a resting point. + easeOut: "cubic-bezier(0.0, 0, 0.2, 1)", + // Objects leave the screen at full velocity. They do not decelerate when off-screen. + easeIn: "cubic-bezier(0.4, 0, 1, 1)", + // The sharp curve is used by objects that may return to the screen at any time. + sharp: "cubic-bezier(0.4, 0, 0.6, 1)" +}, wV = { + shortest: 150, + shorter: 200, + short: 250, + // most basic recommended timing + standard: 300, + // this is to be used in complex animations + complex: 375, + // recommended when something is entering screen + enteringScreen: 225, + // recommended when something is leaving screen + leavingScreen: 195 +}; +function jD(t) { + return `${Math.round(t)}ms`; +} +function OV(t) { + if (!t) + return 0; + const r = t / 36; + return Math.round((4 + 15 * r ** 0.25 + r / 5) * 10); +} +function kV(t) { + const r = K({}, RV, t.easing), i = K({}, wV, t.duration); + return K({ + getAutoHeightDuration: OV, + create: (u = ["all"], f = {}) => { + const { + duration: p = i.standard, + easing: g = r.easeInOut, + delay: b = 0 + } = f, S = Ct(f, TV); + if (process.env.NODE_ENV !== "production") { + const x = (w) => typeof w == "string", R = (w) => !isNaN(parseFloat(w)); + !x(u) && !Array.isArray(u) && console.error('MUI: Argument "props" must be a string or Array.'), !R(p) && !x(p) && console.error(`MUI: Argument "duration" must be a number or a string but found ${p}.`), x(g) || console.error('MUI: Argument "easing" must be a string.'), !R(b) && !x(b) && console.error('MUI: Argument "delay" must be a number or a string.'), typeof f != "object" && console.error(["MUI: Secong argument of transition.create must be an object.", "Arguments should be either `create('prop1', options)` or `create(['prop1', 'prop2'], options)`"].join(` +`)), Object.keys(S).length !== 0 && console.error(`MUI: Unrecognized argument(s) [${Object.keys(S).join(",")}].`); + } + return (Array.isArray(u) ? u : [u]).map((x) => `${x} ${typeof p == "string" ? p : jD(p)} ${g} ${typeof b == "string" ? b : jD(b)}`).join(","); + } + }, t, { + easing: r, + duration: i + }); +} +const MV = { + mobileStepper: 1e3, + fab: 1050, + speedDial: 1050, + appBar: 1100, + drawer: 1200, + modal: 1300, + snackbar: 1400, + tooltip: 1500 +}, DV = ["breakpoints", "mixins", "spacing", "palette", "transitions", "typography", "shape"]; +function AV(t = {}, ...r) { + const { + mixins: i = {}, + palette: s = {}, + transitions: u = {}, + typography: f = {} + } = t, p = Ct(t, DV); + if (t.vars) + throw new Error(process.env.NODE_ENV !== "production" ? "MUI: `vars` is a private field used for CSS variables support.\nPlease use another name." : Vs(18)); + const g = yV(s), b = qm(t); + let S = ho(b, { + mixins: iV(b.breakpoints, i), + palette: g, + // Don't use [...shadows] until you've verified its transpiled code is not invoking the iterator protocol. + shadows: xV.slice(), + typography: EV(g, f), + transitions: kV(u), + zIndex: K({}, MV) + }); + if (S = ho(S, p), S = r.reduce((x, R) => ho(x, R), S), process.env.NODE_ENV !== "production") { + const x = ["active", "checked", "completed", "disabled", "error", "expanded", "focused", "focusVisible", "required", "selected"], R = (w, A) => { + let I; + for (I in w) { + const N = w[I]; + if (x.indexOf(I) !== -1 && Object.keys(N).length > 0) { + if (process.env.NODE_ENV !== "production") { + const P = fn("", I); + console.error([`MUI: The \`${A}\` component increases the CSS specificity of the \`${I}\` internal state.`, "You can not override it like this: ", JSON.stringify(w, null, 2), "", `Instead, you need to use the '&.${P}' syntax:`, JSON.stringify({ + root: { + [`&.${P}`]: N + } + }, null, 2), "", "https://mui.com/r/state-classes-guide"].join(` +`)); + } + w[I] = {}; + } + } + }; + Object.keys(S.components).forEach((w) => { + const A = S.components[w].styleOverrides; + A && w.indexOf("Mui") === 0 && R(A, w); + }); + } + return S.unstable_sxConfig = K({}, Bm, p == null ? void 0 : p.unstable_sxConfig), S.unstable_sx = function(R) { + return Hm({ + sx: R, + theme: this + }); + }, S; +} +const OR = AV(), kR = "$$material"; +function tL(t) { + return t !== "ownerState" && t !== "theme" && t !== "sx" && t !== "as"; +} +const Ma = (t) => tL(t) && t !== "classes", gt = tV({ + themeId: kR, + defaultTheme: OR, + rootShouldForwardProp: Ma +}); +function Wp(t, r) { + const i = K({}, r); + return Object.keys(t).forEach((s) => { + if (s.toString().match(/^(components|slots)$/)) + i[s] = K({}, t[s], i[s]); + else if (s.toString().match(/^(componentsProps|slotProps)$/)) { + const u = t[s] || {}, f = r[s]; + i[s] = {}, !f || !Object.keys(f) ? i[s] = u : !u || !Object.keys(u) ? i[s] = f : (i[s] = K({}, f), Object.keys(u).forEach((p) => { + i[s][p] = Wp(u[p], f[p]); + })); + } else i[s] === void 0 && (i[s] = t[s]); + }), i; +} +const NV = /* @__PURE__ */ B.createContext(void 0); +process.env.NODE_ENV !== "production" && (v.node, v.object); +function PV(t) { + const { + theme: r, + name: i, + props: s + } = t; + if (!r || !r.components || !r.components[i]) + return s; + const u = r.components[i]; + return u.defaultProps ? Wp(u.defaultProps, s) : !u.styleOverrides && !u.variants ? Wp(u, s) : s; +} +function IV({ + props: t, + name: r +}) { + const i = B.useContext(NV); + return PV({ + props: t, + name: r, + theme: { + components: i + } + }); +} +process.env.NODE_ENV !== "production" && (v.node, v.object.isRequired); +function bn(t) { + return IV(t); +} +function En(t, r, i = "Mui") { + const s = {}; + return r.forEach((u) => { + s[u] = fn(t, u, i); + }), s; +} +function LV(t) { + return fn("MuiListItemIcon", t); +} +const $D = En("MuiListItemIcon", ["root", "alignItemsFlexStart"]), Gp = /* @__PURE__ */ B.createContext({}); +process.env.NODE_ENV !== "production" && (Gp.displayName = "ListContext"); +const jV = ["className"], $V = (t) => { + const { + alignItems: r, + classes: i + } = t; + return gn({ + root: ["root", r === "flex-start" && "alignItemsFlexStart"] + }, LV, i); +}, FV = gt("div", { + name: "MuiListItemIcon", + slot: "Root", + overridesResolver: (t, r) => { + const { + ownerState: i + } = t; + return [r.root, i.alignItems === "flex-start" && r.alignItemsFlexStart]; + } +})(({ + theme: t, + ownerState: r +}) => K({ + minWidth: 56, + color: (t.vars || t).palette.action.active, + flexShrink: 0, + display: "inline-flex" +}, r.alignItems === "flex-start" && { + marginTop: 8 +})), nL = /* @__PURE__ */ B.forwardRef(function(r, i) { + const s = bn({ + props: r, + name: "MuiListItemIcon" + }), { + className: u + } = s, f = Ct(s, jV), p = B.useContext(Gp), g = K({}, s, { + alignItems: p.alignItems + }), b = $V(g); + return /* @__PURE__ */ le.jsx(FV, K({ + className: Nt(b.root, u), + ownerState: g, + ref: i + }, f)); +}); +process.env.NODE_ENV !== "production" && (nL.propTypes = { + // ┌────────────────────────────── Warning ──────────────────────────────┐ + // │ These PropTypes are generated from the TypeScript type definitions. │ + // │ To update them, edit the d.ts file and run `pnpm proptypes`. │ + // └─────────────────────────────────────────────────────────────────────┘ + /** + * The content of the component, normally `Icon`, `SvgIcon`, + * or a `@mui/icons-material` SVG icon element. + */ + children: v.node, + /** + * Override or extend the styles applied to the component. + */ + classes: v.object, + /** + * @ignore + */ + className: v.string, + /** + * The system prop that allows defining system overrides as well as additional CSS styles. + */ + sx: v.oneOfType([v.arrayOf(v.oneOfType([v.func, v.object, v.bool])), v.func, v.object]) +}); +function zV(t) { + return fn("MuiTypography", t); +} +En("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]); +const UV = ["align", "className", "component", "gutterBottom", "noWrap", "paragraph", "variant", "variantMapping"], VV = (t) => { + const { + align: r, + gutterBottom: i, + noWrap: s, + paragraph: u, + variant: f, + classes: p + } = t, g = { + root: ["root", f, t.align !== "inherit" && `align${zt(r)}`, i && "gutterBottom", s && "noWrap", u && "paragraph"] + }; + return gn(g, zV, p); +}, BV = gt("span", { + name: "MuiTypography", + slot: "Root", + overridesResolver: (t, r) => { + const { + ownerState: i + } = t; + return [r.root, i.variant && r[i.variant], i.align !== "inherit" && r[`align${zt(i.align)}`], i.noWrap && r.noWrap, i.gutterBottom && r.gutterBottom, i.paragraph && r.paragraph]; + } +})(({ + theme: t, + ownerState: r +}) => K({ + margin: 0 +}, r.variant === "inherit" && { + // Some elements, like