` by default. You can change this\n * behavior by providing a `component` prop.\n * If you use React v16+ and would like to avoid a wrapping `
` element\n * you can pass in `component={null}`. This is useful if the wrapping div\n * borks your css styles.\n */\n component: PropTypes.any,\n\n /**\n * A set of `` components, that are toggled `in` and out as they\n * leave. the `` will inject specific transition props, so\n * remember to spread them through if you are wrapping the `` as\n * with our `` example.\n *\n * While this component is meant for multiple `Transition` or `CSSTransition`\n * children, sometimes you may want to have a single transition child with\n * content that you want to be transitioned out and in when you change it\n * (e.g. routes, images etc.) In that case you can change the `key` prop of\n * the transition child as you change its content, this will cause\n * `TransitionGroup` to transition the child out and back in.\n */\n children: PropTypes.node,\n\n /**\n * A convenience prop that enables or disables appear animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n appear: PropTypes.bool,\n\n /**\n * A convenience prop that enables or disables enter animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n enter: PropTypes.bool,\n\n /**\n * A convenience prop that enables or disables exit animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n exit: PropTypes.bool,\n\n /**\n * You may need to apply reactive updates to a child as it is exiting.\n * This is generally done by using `cloneElement` however in the case of an exiting\n * child the element has already been removed and not accessible to the consumer.\n *\n * If you do need to update a child as it leaves you can provide a `childFactory`\n * to wrap every child, even the ones that are leaving.\n *\n * @type Function(child: ReactElement) -> ReactElement\n */\n childFactory: PropTypes.func\n} : {};\nTransitionGroup.defaultProps = defaultProps;\nexport default TransitionGroup;","import React from 'react';\nexport default React.createContext(null);","export var forceReflow = function forceReflow(node) {\n return node.scrollTop;\n};","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HistoryRouter = void 0;\n/* eslint-disable react/no-children-prop */\nvar react_1 = __importDefault(require(\"react\"));\nvar react_router_1 = require(\"react-router\");\nfunction HistoryRouter(_a) {\n var basename = _a.basename, children = _a.children, history = _a.history;\n var _b = react_1.default.useState({\n action: history.action,\n location: history.location,\n }), state = _b[0], setState = _b[1];\n react_1.default.useLayoutEffect(function () { return history.listen(setState); }, [history]);\n return react_1.default.createElement(react_router_1.Router, {\n basename: basename,\n children: children,\n location: state.location,\n navigationType: state.action,\n navigator: history,\n });\n}\nexports.HistoryRouter = HistoryRouter;","import { assert } from \"./assert\";\nimport { typeGuard } from \"./typeGuard\";\n/** Copy pasted from\n * https://github.com/emotion-js/emotion/blob/23f43ab9f24d44219b0b007a00f4ac681fe8712e/packages/react/src/class-names.js#L17-L63\n **/\nexport const classnames = (args) => {\n const len = args.length;\n let i = 0;\n let cls = \"\";\n for (; i < len; i++) {\n const arg = args[i];\n if (arg == null)\n continue;\n let toAdd;\n switch (typeof arg) {\n case \"boolean\":\n break;\n case \"object\": {\n if (Array.isArray(arg)) {\n toAdd = classnames(arg);\n }\n else {\n assert(!typeGuard(arg, false));\n if (process.env.NODE_ENV !== \"production\" &&\n arg.styles !== undefined &&\n arg.name !== undefined) {\n console.error(\"You have passed styles created with `css` from `@emotion/react` package to the `cx`.\\n\" +\n \"`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from component.\");\n }\n toAdd = \"\";\n for (const k in arg) {\n if (arg[k] && k) {\n toAdd && (toAdd += \" \");\n toAdd += k;\n }\n }\n }\n break;\n }\n default: {\n toAdd = arg;\n }\n }\n if (toAdd) {\n cls && (cls += \" \");\n cls += toAdd;\n }\n }\n return cls;\n};\n","import { classnames } from \"./tools/classnames\";\nimport { serializeStyles } from \"@emotion/serialize\";\nimport { insertStyles, getRegisteredStyles } from \"@emotion/utils\";\nimport { useGuaranteedMemo } from \"./tools/useGuaranteedMemo\";\nimport { matchCSSObject } from \"./types\";\nexport const { createCssAndCx } = (() => {\n function merge(registered, css, className) {\n const registeredStyles = [];\n const rawClassName = getRegisteredStyles(registered, registeredStyles, className);\n if (registeredStyles.length < 2) {\n return className;\n }\n return rawClassName + css(registeredStyles);\n }\n function createCssAndCx(params) {\n const { cache } = params;\n const css = (...args) => {\n const serialized = serializeStyles(args, cache.registered);\n insertStyles(cache, serialized, false);\n const className = `${cache.key}-${serialized.name}`;\n scope: {\n const arg = args[0];\n if (!matchCSSObject(arg)) {\n break scope;\n }\n increaseSpecificityToTakePrecedenceOverMediaQueries.saveClassNameCSSObjectMapping(cache, className, arg);\n }\n return className;\n };\n const cx = (...args) => {\n const className = classnames(args);\n const feat27FixedClassnames = increaseSpecificityToTakePrecedenceOverMediaQueries.fixClassName(cache, className, css);\n return merge(cache.registered, css, feat27FixedClassnames);\n //return merge(cache.registered, css, className);\n };\n return { css, cx };\n }\n return { createCssAndCx };\n})();\nexport function createUseCssAndCx(params) {\n const { useCache } = params;\n function useCssAndCx() {\n const cache = useCache();\n const { css, cx } = useGuaranteedMemo(() => createCssAndCx({ cache }), [cache]);\n return { css, cx };\n }\n return { useCssAndCx };\n}\n// https://github.com/garronej/tss-react/issues/27\nconst increaseSpecificityToTakePrecedenceOverMediaQueries = (() => {\n const cssObjectMapByCache = new WeakMap();\n return {\n \"saveClassNameCSSObjectMapping\": (cache, className, cssObject) => {\n let cssObjectMap = cssObjectMapByCache.get(cache);\n if (cssObjectMap === undefined) {\n cssObjectMap = new Map();\n cssObjectMapByCache.set(cache, cssObjectMap);\n }\n cssObjectMap.set(className, cssObject);\n },\n \"fixClassName\": (() => {\n function fix(classNameCSSObjects) {\n let isThereAnyMediaQueriesInPreviousClasses = false;\n return classNameCSSObjects.map(([className, cssObject]) => {\n if (cssObject === undefined) {\n return className;\n }\n let out;\n if (!isThereAnyMediaQueriesInPreviousClasses) {\n out = className;\n for (const key in cssObject) {\n if (key.startsWith(\"@media\")) {\n isThereAnyMediaQueriesInPreviousClasses = true;\n break;\n }\n }\n }\n else {\n out = {\n \"&&\": cssObject\n };\n }\n return out;\n });\n }\n return (cache, className, css) => {\n const cssObjectMap = cssObjectMapByCache.get(cache);\n return classnames(fix(className\n .split(\" \")\n .map(className => [\n className,\n cssObjectMap === null || cssObjectMap === void 0 ? void 0 : cssObjectMap.get(className)\n ])).map(classNameOrCSSObject => typeof classNameOrCSSObject === \"string\"\n ? classNameOrCSSObject\n : css(classNameOrCSSObject)));\n };\n })()\n };\n})();\n","export function matchCSSObject(arg) {\n return (arg instanceof Object &&\n !(\"styles\" in arg) &&\n !(\"length\" in arg) &&\n !(\"__emotion_styles\" in arg));\n}\n","import { useRef } from \"react\";\n/** Like react's useMemo but with guarantee that the fn\n * won't be invoked again if deps hasn't change */\nexport function useGuaranteedMemo(fn, deps) {\n var _a;\n const ref = useRef();\n if (!ref.current ||\n deps.length !== ((_a = ref.current.prevDeps) === null || _a === void 0 ? void 0 : _a.length) ||\n ref.current.prevDeps.map((v, i) => v === deps[i]).indexOf(false) >= 0) {\n ref.current = {\n \"v\": fn(),\n \"prevDeps\": [...deps]\n };\n }\n return ref.current.v;\n}\n","/** @see */\nexport function capitalize(str) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return (str.charAt(0).toUpperCase() + str.slice(1));\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport React, { forwardRef, createElement } from \"react\";\nimport { createMakeStyles } from \"./makeStyles\";\nimport { capitalize } from \"./tools/capitalize\";\nexport function createWithStyles(params) {\n const { useTheme, cache } = params;\n const { makeStyles } = createMakeStyles({ useTheme, cache });\n function withStyles(Component, cssObjectByRuleNameOrGetCssObjectByRuleName, params) {\n const Component_ = typeof Component === \"string\"\n ? (() => {\n const tag = Component;\n const Out = function ({ children, ...props }) {\n return createElement(tag, props, children);\n };\n Object.defineProperty(Out, \"name\", {\n \"value\": capitalize(tag)\n });\n return Out;\n })()\n : Component;\n /**\n * Get component name for wrapping\n * @see https://reactjs.org/docs/higher-order-components.html#convention-wrap-the-display-name-for-easy-debugging\n */\n const name = (() => {\n {\n const { name: nameOrWrappedName } = params !== null && params !== void 0 ? params : {};\n if (nameOrWrappedName !== undefined) {\n return typeof nameOrWrappedName !== \"object\"\n ? nameOrWrappedName\n : Object.keys(nameOrWrappedName)[0];\n }\n }\n let name = undefined;\n displayName: {\n const displayName = Component_.displayName;\n if (typeof displayName !== \"string\" || displayName === \"\") {\n break displayName;\n }\n name = displayName;\n }\n functionName: {\n if (name !== undefined) {\n break functionName;\n }\n const functionName = Component_.name;\n if (typeof functionName !== \"string\" || functionName === \"\") {\n break functionName;\n }\n name = functionName;\n }\n if (name === undefined) {\n return undefined;\n }\n // Special case for dollar sign\n name = name.replace(/\\$/g, \"usd\");\n // Replacing open and close parentheses\n name = name.replace(/\\(/g, \"_\").replace(/\\)/g, \"_\");\n // Catch-all replacement for characters not allowed in CSS class names\n name = name.replace(/[^a-zA-Z0-9-_]/g, \"_\");\n return name;\n })();\n const useStyles = makeStyles({ ...params, name })(typeof cssObjectByRuleNameOrGetCssObjectByRuleName === \"function\"\n ? (theme, props, classes) => incorporateMediaQueries(cssObjectByRuleNameOrGetCssObjectByRuleName(theme, props, classes))\n : incorporateMediaQueries(cssObjectByRuleNameOrGetCssObjectByRuleName));\n function getHasNonRootClasses(classes) {\n for (const name in classes) {\n if (name === \"root\") {\n continue;\n }\n return true;\n }\n return false;\n }\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const Out = forwardRef(function (props, ref) {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n const { className, classes: _classes, ...rest } = props;\n const { classes, cx } = useStyles(props, { props });\n const rootClassName = cx(classes.root, className);\n fixedClassesByClasses.set(classes, {\n ...classes,\n \"root\": rootClassName\n });\n return (React.createElement(Component_, { ref: ref, className: getHasNonRootClasses(classes)\n ? className\n : rootClassName, ...(typeof Component === \"string\" ? {} : { classes }), ...rest }));\n });\n if (name !== undefined) {\n Out.displayName = `${capitalize(name)}WithStyles`;\n Object.defineProperty(Out, \"name\", { \"value\": Out.displayName });\n }\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return Out;\n }\n withStyles.getClasses = getClasses;\n return { withStyles };\n}\nconst fixedClassesByClasses = new WeakMap();\nconst errorMessageGetClasses = \"getClasses should only be used in conjunction with withStyles\";\nfunction getClasses(props) {\n const classesIn = props.classes;\n if (classesIn === undefined) {\n throw new Error(errorMessageGetClasses);\n }\n const classes = fixedClassesByClasses.get(classesIn);\n if (classes === undefined) {\n throw new Error(errorMessageGetClasses);\n }\n return classes;\n}\nfunction incorporateMediaQueries(cssObjectByRuleNameWithMediaQueries) {\n const cssObjectByRuleName = {};\n const cssObjectByRuleNameWithMediaQueriesByMediaQuery = {};\n Object.keys(cssObjectByRuleNameWithMediaQueries).forEach(ruleNameOrMediaQuery => ((ruleNameOrMediaQuery.startsWith(\"@media\")\n ? cssObjectByRuleNameWithMediaQueriesByMediaQuery\n : cssObjectByRuleName)[ruleNameOrMediaQuery] =\n cssObjectByRuleNameWithMediaQueries[ruleNameOrMediaQuery]));\n Object.keys(cssObjectByRuleNameWithMediaQueriesByMediaQuery).forEach(mediaQuery => {\n const cssObjectByRuleNameBis = cssObjectByRuleNameWithMediaQueriesByMediaQuery[mediaQuery];\n Object.keys(cssObjectByRuleNameBis).forEach(ruleName => {\n var _a;\n return (cssObjectByRuleName[ruleName] = {\n ...((_a = cssObjectByRuleName[ruleName]) !== null && _a !== void 0 ? _a : {}),\n [mediaQuery]: cssObjectByRuleNameBis[ruleName]\n });\n });\n });\n return cssObjectByRuleName;\n}\n","\"use client\";\nimport React from \"react\";\nimport * as reactEmotion from \"@emotion/react\";\nexport function GlobalStyles(props) {\n const { styles } = props;\n return React.createElement(reactEmotion.Global, { styles: reactEmotion.css(styles) });\n}\n","\"use client\";\nimport { createMakeStyles, TssCacheProvider } from \"./makeStyles\";\nexport { createMakeStyles, TssCacheProvider };\nimport { createWithStyles } from \"./withStyles\";\nexport { createWithStyles };\nimport { createTss } from \"./tss\";\nexport { createTss };\n/** @see */\nexport { keyframes } from \"@emotion/react\";\n/** @see */\nexport { GlobalStyles } from \"./GlobalStyles\";\n/** @see */\nexport function createMakeAndWithStyles(params) {\n return {\n ...createMakeStyles(params),\n ...createWithStyles(params)\n };\n}\nexport const { tss } = createTss({\n \"useContext\": () => ({})\n});\nexport const useStyles = tss.create({});\n","\"use client\";\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport React, { useMemo } from \"react\";\nimport { objectFromEntries } from \"./tools/polyfills/Object.fromEntries\";\nimport { objectKeys } from \"./tools/objectKeys\";\nimport { createUseCssAndCx } from \"./cssAndCx\";\nimport { getDependencyArrayRef } from \"./tools/getDependencyArrayRef\";\nimport { typeGuard } from \"./tools/typeGuard\";\nimport { assert } from \"./tools/assert\";\nimport { mergeClasses } from \"./mergeClasses\";\nimport { createContext, useContext } from \"react\";\nimport { useMuiThemeStyleOverridesPlugin } from \"./mui/themeStyleOverridesPlugin\";\nimport { __unsafe_useEmotionCache as useContextualCache } from \"@emotion/react\";\nlet counter = 0;\nexport function createMakeStyles(params) {\n const { useTheme, cache: cacheProvidedAtInception } = params;\n const { useCache } = createUseCache({ cacheProvidedAtInception });\n const { useCssAndCx } = createUseCssAndCx({ useCache });\n /** returns useStyle. */\n function makeStyles(params) {\n const { name: nameOrWrappedName, uniqId = `${counter++}` } = params !== null && params !== void 0 ? params : {};\n const name = typeof nameOrWrappedName !== \"object\"\n ? nameOrWrappedName\n : Object.keys(nameOrWrappedName)[0];\n return function (cssObjectByRuleNameOrGetCssObjectByRuleName) {\n const getCssObjectByRuleName = typeof cssObjectByRuleNameOrGetCssObjectByRuleName ===\n \"function\"\n ? cssObjectByRuleNameOrGetCssObjectByRuleName\n : () => cssObjectByRuleNameOrGetCssObjectByRuleName;\n return function useStyles(params, muiStyleOverridesParams) {\n const theme = useTheme();\n let { css, cx } = useCssAndCx();\n const cache = useCache();\n let classes = useMemo(() => {\n const refClassesCache = {};\n const refClasses = typeof Proxy !== \"undefined\" &&\n new Proxy({}, {\n \"get\": (_target, propertyKey) => {\n if (typeof propertyKey === \"symbol\") {\n assert(false);\n }\n return (refClassesCache[propertyKey] = `${cache.key}-${uniqId}${name !== undefined ? `-${name}` : \"\"}-${propertyKey}-ref`);\n }\n });\n const cssObjectByRuleName = getCssObjectByRuleName(theme, params, refClasses || {});\n const classes = objectFromEntries(objectKeys(cssObjectByRuleName).map(ruleName => {\n const cssObject = cssObjectByRuleName[ruleName];\n if (!cssObject.label) {\n cssObject.label = `${name !== undefined ? `${name}-` : \"\"}${ruleName}`;\n }\n return [\n ruleName,\n `${css(cssObject)}${typeGuard(ruleName, ruleName in refClassesCache)\n ? ` ${refClassesCache[ruleName]}`\n : \"\"}`\n ];\n }));\n objectKeys(refClassesCache).forEach(ruleName => {\n if (ruleName in classes) {\n return;\n }\n classes[ruleName] =\n refClassesCache[ruleName];\n });\n return classes;\n }, [cache, css, cx, theme, getDependencyArrayRef(params)]);\n {\n const propsClasses = muiStyleOverridesParams === null || muiStyleOverridesParams === void 0 ? void 0 : muiStyleOverridesParams.props.classes;\n classes = useMemo(() => mergeClasses(classes, propsClasses, cx), [classes, getDependencyArrayRef(propsClasses), cx]);\n }\n {\n const pluginResultWrap = useMuiThemeStyleOverridesPlugin({\n classes,\n css,\n cx,\n \"name\": name !== null && name !== void 0 ? name : \"makeStyle no name\",\n \"idOfUseStyles\": uniqId,\n muiStyleOverridesParams,\n // NOTE: If it's not a Mui Theme the plugin is resilient, it will not crash\n \"theme\": theme\n });\n if (pluginResultWrap.classes !== undefined) {\n classes = pluginResultWrap.classes;\n }\n if (pluginResultWrap.css !== undefined) {\n css = pluginResultWrap.css;\n }\n if (pluginResultWrap.cx !== undefined) {\n cx = pluginResultWrap.cx;\n }\n }\n return {\n classes,\n theme,\n css,\n cx\n };\n };\n };\n }\n function useStyles() {\n const theme = useTheme();\n const { css, cx } = useCssAndCx();\n return { theme, css, cx };\n }\n return { makeStyles, useStyles };\n}\nconst reactContext = createContext(undefined);\nexport function TssCacheProvider(props) {\n const { children, value } = props;\n return (React.createElement(reactContext.Provider, { value: value }, children));\n}\nexport const { createUseCache } = (() => {\n function useCacheProvidedByProvider() {\n const cacheExplicitlyProvidedForTss = useContext(reactContext);\n return cacheExplicitlyProvidedForTss;\n }\n function createUseCache(params) {\n const { cacheProvidedAtInception } = params;\n function useCache() {\n var _a;\n const contextualCache = useContextualCache();\n const cacheExplicitlyProvidedForTss = useCacheProvidedByProvider();\n const cacheToBeUsed = (_a = cacheProvidedAtInception !== null && cacheProvidedAtInception !== void 0 ? cacheProvidedAtInception : cacheExplicitlyProvidedForTss) !== null && _a !== void 0 ? _a : contextualCache;\n if (cacheToBeUsed === null) {\n throw new Error([\n \"In order to get SSR working with tss-react you need to explicitly provide an Emotion cache.\",\n \"MUI users be aware: This is not an error strictly related to tss-react, with or without tss-react,\",\n \"MUI needs an Emotion cache to be provided for SSR to work.\",\n \"Here is the MUI documentation related to SSR setup: https://mui.com/material-ui/guides/server-rendering/\",\n \"TSS provides helper that makes the process of setting up SSR easier: https://docs.tss-react.dev/ssr\"\n ].join(\"\\n\"));\n }\n return cacheToBeUsed;\n }\n return { useCache };\n }\n return { createUseCache };\n})();\n","/* eslint-disable @typescript-eslint/ban-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { objectKeys } from \"./tools/objectKeys\";\nexport function mergeClasses(classesFromUseStyles, classesOverrides, cx) {\n //NOTE: We use this test to be resilient in case classesOverrides is not of the expected type.\n if (!(classesOverrides instanceof Object)) {\n return classesFromUseStyles;\n }\n const out = {};\n objectKeys(classesFromUseStyles).forEach(ruleName => (out[ruleName] = cx(classesFromUseStyles[ruleName], classesOverrides[ruleName])));\n objectKeys(classesOverrides).forEach(ruleName => {\n if (ruleName in classesFromUseStyles) {\n return;\n }\n const className = classesOverrides[ruleName];\n //...Same here, that why we don't do className === undefined\n if (typeof className !== \"string\") {\n return;\n }\n out[ruleName] = className;\n });\n return out;\n}\n","import { useTheme } from \"@mui/material/styles\";\nimport { createMakeAndWithStyles } from \"../index\";\nimport { createTss } from \"../tss\";\nimport { useMuiThemeStyleOverridesPlugin } from \"./themeStyleOverridesPlugin\";\n/** @see */\nexport const { makeStyles, withStyles } = createMakeAndWithStyles({\n useTheme\n});\nexport const { tss } = createTss({\n \"useContext\": function useContext() {\n const theme = useTheme();\n return { theme };\n },\n \"usePlugin\": useMuiThemeStyleOverridesPlugin\n});\nexport const useStyles = tss.create({});\n","import { useMemo } from \"react\";\nimport { getDependencyArrayRef } from \"../tools/getDependencyArrayRef\";\nimport { mergeClasses } from \"../mergeClasses\";\nexport const useMuiThemeStyleOverridesPlugin = ({ classes, theme, muiStyleOverridesParams, css, cx, name }) => {\n var _a, _b;\n require_named: {\n // NOTE: Hack for backwards compatibility with the makeStyles API.\n if (name === \"makeStyle no name\") {\n name = undefined;\n break require_named;\n }\n if (muiStyleOverridesParams !== undefined && name === undefined) {\n throw new Error(\"To use muiStyleOverridesParams, you must specify a name using .withName('MyComponent')\");\n }\n }\n let styleOverrides = undefined;\n try {\n styleOverrides =\n name === undefined\n ? undefined\n : ((_b = (_a = theme.components) === null || _a === void 0 ? void 0 : _a[name /*example*/]) === null || _b === void 0 ? void 0 : _b.styleOverrides) || undefined;\n // eslint-disable-next-line no-empty\n }\n catch (_c) { }\n const classesFromThemeStyleOverrides = useMemo(() => {\n if (styleOverrides === undefined) {\n return undefined;\n }\n const themeClasses = {};\n for (const ruleName in styleOverrides) {\n const cssObjectOrGetCssObject = styleOverrides[ruleName];\n if (!(cssObjectOrGetCssObject instanceof Object)) {\n continue;\n }\n themeClasses[ruleName] = css(typeof cssObjectOrGetCssObject === \"function\"\n ? cssObjectOrGetCssObject({\n theme,\n \"ownerState\": muiStyleOverridesParams === null || muiStyleOverridesParams === void 0 ? void 0 : muiStyleOverridesParams.ownerState,\n ...muiStyleOverridesParams === null || muiStyleOverridesParams === void 0 ? void 0 : muiStyleOverridesParams.props\n })\n : cssObjectOrGetCssObject);\n }\n return themeClasses;\n }, [\n styleOverrides,\n getDependencyArrayRef(muiStyleOverridesParams === null || muiStyleOverridesParams === void 0 ? void 0 : muiStyleOverridesParams.props),\n getDependencyArrayRef(muiStyleOverridesParams === null || muiStyleOverridesParams === void 0 ? void 0 : muiStyleOverridesParams.ownerState),\n css\n ]);\n classes = useMemo(() => mergeClasses(classes, classesFromThemeStyleOverrides, cx), [classes, classesFromThemeStyleOverrides, cx]);\n return { classes };\n};\n","/** https://docs.tsafe.dev/assert */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function assert(condition, msg) {\n if (!condition) {\n throw new Error(msg);\n }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * useEffect(\n * ()=> { ... },\n * [ { \"foo\": \"bar\" } ]\n * )\n * => The callback will be invoked every render.\n * because { \"foo\": \"bar\" } is a new instance every render.\n *\n * useEffect(\n * ()=> { ... },\n * [ getDependencyArrayRef({ \"foo\": \"bar\" }) ]\n * );\n * => The callback will only be invoked once.\n *\n * The optimization will be enabled only if obj is\n * of the form Record\n * otherwise the object is returned (the function is the identity function).\n */\nexport function getDependencyArrayRef(obj) {\n if (!(obj instanceof Object) || typeof obj === \"function\") {\n return obj;\n }\n const arr = [];\n for (const key in obj) {\n const value = obj[key];\n const typeofValue = typeof value;\n if (!(typeofValue === \"string\" ||\n (typeofValue === \"number\" && !isNaN(value)) ||\n typeofValue === \"boolean\" ||\n value === undefined ||\n value === null)) {\n return obj;\n }\n arr.push(`${key}:${typeofValue}_${value}`);\n }\n return \"xSqLiJdLMd9s\" + arr.join(\"|\");\n}\n","/** Object.keys() with types */\nexport function objectKeys(o) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return Object.keys(o);\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nexport const objectFromEntries = !Object\n .fromEntries\n ? (entries) => {\n if (!entries || !entries[Symbol.iterator]) {\n throw new Error(\"Object.fromEntries() requires a single iterable argument\");\n }\n const o = {};\n Object.keys(entries).forEach(key => {\n const [k, v] = entries[key];\n o[k] = v;\n });\n return o;\n }\n : Object.fromEntries;\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/** https://docs.tsafe.dev/typeguard */\nexport function typeGuard(_value, isMatched) {\n return isMatched;\n}\n","export const isSSR = (() => {\n const isBrowser = typeof document === \"object\" &&\n typeof (document === null || document === void 0 ? void 0 : document.getElementById) === \"function\";\n // Check for common testing framework global variables\n const isJest = typeof jest !== \"undefined\";\n const isMocha = typeof mocha !== \"undefined\";\n const isVitest = typeof __vitest_worker__ !== \"undefined\";\n return !isBrowser && !isJest && !isMocha && !isVitest;\n})();\n","/* eslint-disable @typescript-eslint/ban-types */\nimport { createUseCache } from \"./makeStyles\";\nimport { createUseCssAndCx } from \"./cssAndCx\";\nimport { assert } from \"./tools/assert\";\nimport { objectFromEntries } from \"./tools/polyfills/Object.fromEntries\";\nimport { objectKeys } from \"./tools/objectKeys\";\nimport { typeGuard } from \"./tools/typeGuard\";\nimport { getDependencyArrayRef } from \"./tools/getDependencyArrayRef\";\nimport { mergeClasses } from \"./mergeClasses\";\nimport { isSSR } from \"./tools/isSSR\";\nexport function createTss(params) {\n counter = 0;\n nestedSelectorUsageTrackRecord.splice(0, nestedSelectorUsageTrackRecord.length);\n const { useContext, usePlugin, cache: cacheProvidedAtInception } = params;\n const { useCache } = createUseCache({ cacheProvidedAtInception });\n const { useCssAndCx } = createUseCssAndCx({ useCache });\n const usePluginDefault = ({ classes, cx, css }) => ({ classes, cx, css });\n const tss = createTss_internal({\n useContext,\n useCache,\n useCssAndCx,\n \"usePlugin\": usePlugin !== null && usePlugin !== void 0 ? usePlugin : usePluginDefault,\n \"name\": undefined,\n \"doesUseNestedSelectors\": false\n });\n return { tss };\n}\nlet counter = 0;\nconst nestedSelectorUsageTrackRecord = [];\nfunction createTss_internal(params) {\n const { useContext, useCache, useCssAndCx, usePlugin, name, doesUseNestedSelectors } = params;\n return {\n \"withParams\": () => createTss_internal({ ...params }),\n \"withName\": nameOrWrappedName => createTss_internal({\n ...params,\n \"name\": typeof nameOrWrappedName !== \"object\"\n ? nameOrWrappedName\n : Object.keys(nameOrWrappedName)[0]\n }),\n \"withNestedSelectors\": () => createTss_internal({\n ...params,\n \"doesUseNestedSelectors\": true\n }),\n \"create\": (cssObjectByRuleNameOrGetCssObjectByRuleName) => {\n // NOTE: Not isomorphic. Not guaranteed to be the same on client and server.\n // Do not attempt to 'simplify' the code without taking this fact into account.\n const idOfUseStyles = `x${counter++}`;\n // NOTE: Cleanup for hot module reloading.\n if (name !== undefined) {\n // eslint-disable-next-line no-constant-condition\n while (true) {\n const wrap = nestedSelectorUsageTrackRecord.find(wrap => wrap.name === name);\n if (wrap === undefined) {\n break;\n }\n nestedSelectorUsageTrackRecord.splice(nestedSelectorUsageTrackRecord.indexOf(wrap), 1);\n }\n }\n const getCssObjectByRuleName = typeof cssObjectByRuleNameOrGetCssObjectByRuleName ===\n \"function\"\n ? cssObjectByRuleNameOrGetCssObjectByRuleName\n : () => cssObjectByRuleNameOrGetCssObjectByRuleName;\n return function useStyles(params) {\n var _a, _b, _c;\n const { classesOverrides, ...paramsAndPluginParams } = (params !== null && params !== void 0 ? params : {});\n const context = useContext();\n const { css, cx } = useCssAndCx();\n const cache = useCache();\n const getClasses = () => {\n const refClassesCache = {};\n // @ts-expect-error: Type safety non achievable.\n const cssObjectByRuleName = getCssObjectByRuleName({\n ...params,\n ...context,\n ...(!doesUseNestedSelectors\n ? {}\n : {\n \"classes\": typeof Proxy === \"undefined\"\n ? {}\n : new Proxy({}, {\n \"get\": (_target, ruleName) => {\n /* prettier-ignore */\n if (typeof ruleName === \"symbol\") {\n assert(false);\n }\n if (isSSR &&\n name === undefined) {\n throw new Error([\n `tss-react: In SSR setups, in order to use nested selectors, you must also give a unique name to the useStyle function.`,\n `Solution: Use tss.withName(\"ComponentName\").withNestedSelectors<...>()... to set a name.`\n ].join(\"\\n\"));\n }\n update_nested_selector_usage_track_record: {\n if (name === undefined) {\n break update_nested_selector_usage_track_record;\n }\n /* prettier-ignore */\n let wrap = nestedSelectorUsageTrackRecord.find(wrap => wrap.name === name && wrap.idOfUseStyles === idOfUseStyles);\n /* prettier-ignore */\n if (wrap === undefined) {\n /* prettier-ignore */\n wrap = { name, idOfUseStyles, \"nestedSelectorRuleNames\": new Set() };\n /* prettier-ignore */\n nestedSelectorUsageTrackRecord.push(wrap);\n }\n /* prettier-ignore */\n wrap.nestedSelectorRuleNames.add(ruleName);\n }\n detect_potential_conflicts: {\n if (name === undefined) {\n break detect_potential_conflicts;\n }\n const hasPotentialConflict = nestedSelectorUsageTrackRecord.find(wrap => wrap.name ===\n name &&\n wrap.idOfUseStyles !==\n idOfUseStyles &&\n wrap.nestedSelectorRuleNames.has(ruleName)) !== undefined;\n if (!hasPotentialConflict) {\n break detect_potential_conflicts;\n }\n throw new Error([\n `tss-react: There are in your codebase two different useStyles named \"${name}\" that`,\n `both use use the nested selector ${ruleName}.\\n`,\n `This may lead to CSS class name collisions, causing nested selectors to target elements outside of the intended scope.\\n`,\n `Solution: Ensure each useStyles using nested selectors has a unique name.\\n`,\n `Use: tss.withName(\"UniqueName\").withNestedSelectors<...>()...`\n ].join(\" \"));\n }\n /* prettier-ignore */\n return (refClassesCache[ruleName] = `${cache.key}-${name !== undefined ? name : idOfUseStyles}-${ruleName}-ref`);\n }\n })\n })\n });\n let classes = objectFromEntries(objectKeys(cssObjectByRuleName).map(ruleName => {\n const cssObject = cssObjectByRuleName[ruleName];\n if (!cssObject.label) {\n cssObject.label = `${name !== undefined ? `${name}-` : \"\"}${ruleName}`;\n }\n return [\n ruleName,\n `${css(cssObject)}${typeGuard(ruleName, ruleName in refClassesCache)\n ? ` ${refClassesCache[ruleName]}`\n : \"\"}`\n ];\n }));\n objectKeys(refClassesCache).forEach(ruleName => {\n if (ruleName in classes) {\n return;\n }\n classes[ruleName] =\n refClassesCache[ruleName];\n });\n classes = mergeClasses(classes, classesOverrides, cx);\n return classes;\n };\n const classes = runGetClassesOrUseCache({\n cache,\n cssObjectByRuleNameOrGetCssObjectByRuleName,\n \"classesOverridesRef\": getDependencyArrayRef(classesOverrides),\n \"paramsAndPluginParamsRef\": getDependencyArrayRef(paramsAndPluginParams),\n idOfUseStyles,\n context,\n getClasses\n });\n // @ts-expect-error: Type safety non achievable.\n const pluginResultWrap = usePlugin({\n classes,\n css,\n cx,\n idOfUseStyles,\n name,\n ...context,\n ...paramsAndPluginParams\n });\n return {\n \"classes\": (_a = pluginResultWrap.classes) !== null && _a !== void 0 ? _a : classes,\n \"css\": (_b = pluginResultWrap.css) !== null && _b !== void 0 ? _b : css,\n \"cx\": (_c = pluginResultWrap.cx) !== null && _c !== void 0 ? _c : cx,\n ...context\n };\n };\n }\n };\n}\nconst mapCache = new WeakMap();\nfunction runGetClassesOrUseCache(params) {\n const { cache, cssObjectByRuleNameOrGetCssObjectByRuleName, classesOverridesRef, paramsAndPluginParamsRef, idOfUseStyles, context, getClasses } = params;\n use_cache: {\n const mapCache_in = mapCache.get(cache);\n if (mapCache_in === undefined) {\n break use_cache;\n }\n const mapCache_in_in = mapCache_in.get(cssObjectByRuleNameOrGetCssObjectByRuleName);\n if (mapCache_in_in === undefined) {\n break use_cache;\n }\n const mapCache_in_in_in = mapCache_in_in.get(classesOverridesRef);\n if (mapCache_in_in_in === undefined) {\n break use_cache;\n }\n const arr = mapCache_in_in_in.get(paramsAndPluginParamsRef);\n if (arr === undefined) {\n break use_cache;\n }\n const entry = arr.find(({ context: context_i }) => {\n if (context_i === context) {\n return true;\n }\n if (objectKeys(context_i).length !== objectKeys(context).length) {\n return false;\n }\n for (const key in context_i) {\n if (getDependencyArrayRef(context_i[key]) !==\n getDependencyArrayRef(context[key])) {\n return false;\n }\n }\n return true;\n });\n if (entry === undefined) {\n break use_cache;\n }\n if ((entry === null || entry === void 0 ? void 0 : entry.idOfUseStyles) !== idOfUseStyles) {\n arr.splice(arr.indexOf(entry), 1);\n break use_cache;\n }\n return entry.result;\n }\n const result = getClasses();\n {\n if (!mapCache.has(cache)) {\n mapCache.set(cache, new WeakMap());\n }\n const mapCache_in = mapCache.get(cache);\n assert(mapCache_in !== undefined);\n if (!mapCache_in.has(cssObjectByRuleNameOrGetCssObjectByRuleName)) {\n mapCache_in.set(cssObjectByRuleNameOrGetCssObjectByRuleName, new Map());\n }\n const mapCache_in_in = mapCache_in.get(cssObjectByRuleNameOrGetCssObjectByRuleName);\n assert(mapCache_in_in !== undefined);\n if (!mapCache_in_in.has(classesOverridesRef)) {\n if (mapCache_in_in.size > 200) {\n mapCache_in_in.clear();\n }\n mapCache_in_in.set(classesOverridesRef, new Map());\n }\n const mapCache_in_in_in = mapCache_in_in.get(classesOverridesRef);\n assert(mapCache_in_in_in !== undefined);\n if (!mapCache_in_in_in.has(paramsAndPluginParamsRef)) {\n clear_cache: {\n const threshold = typeof paramsAndPluginParamsRef === \"string\" ? 257 : 5;\n if (mapCache_in_in_in.size < threshold) {\n break clear_cache;\n }\n mapCache_in_in_in.clear();\n }\n mapCache_in_in_in.set(paramsAndPluginParamsRef, []);\n }\n let arr = mapCache_in_in_in.get(paramsAndPluginParamsRef);\n assert(arr !== undefined);\n if (arr.length > 5) {\n arr = [];\n }\n arr.push({ idOfUseStyles, context, result });\n }\n return result;\n}\n","function _arrayLikeToArray(r, a) {\n (null == a || a > r.length) && (a = r.length);\n for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n return n;\n}\nexport { _arrayLikeToArray as default };","function _assertThisInitialized(e) {\n if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n return e;\n}\nexport { _assertThisInitialized as default };","function _classCallCheck(a, n) {\n if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nexport { _classCallCheck as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(e, r) {\n for (var t = 0; t < r.length; t++) {\n var o = r[t];\n o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n }\n}\nfunction _createClass(e, r, t) {\n return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n writable: !1\n }), e;\n}\nexport { _createClass as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inherits(t, e) {\n if (\"function\" != typeof e && null !== e) throw new TypeError(\"Super expression must either be null or a function\");\n t.prototype = Object.create(e && e.prototype, {\n constructor: {\n value: t,\n writable: !0,\n configurable: !0\n }\n }), Object.defineProperty(t, \"prototype\", {\n writable: !1\n }), e && setPrototypeOf(t, e);\n}\nexport { _inherits as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inheritsLoose(t, o) {\n t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);\n}\nexport { _inheritsLoose as default };","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nfunction _objectWithoutProperties(e, t) {\n if (null == e) return {};\n var o,\n r,\n i = objectWithoutPropertiesLoose(e, t);\n if (Object.getOwnPropertySymbols) {\n var s = Object.getOwnPropertySymbols(e);\n for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);\n }\n return i;\n}\nexport { _objectWithoutProperties as default };","function _setPrototypeOf(t, e) {\n return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n return t.__proto__ = e, t;\n }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nfunction _slicedToArray(r, e) {\n return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();\n}\nexport { _slicedToArray as default };","function _arrayWithHoles(r) {\n if (Array.isArray(r)) return r;\n}\nexport { _arrayWithHoles as default };","function _iterableToArrayLimit(r, l) {\n var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n if (null != t) {\n var e,\n n,\n i,\n u,\n a = [],\n f = !0,\n o = !1;\n try {\n if (i = (t = t.call(r)).next, 0 === l) {\n if (Object(t) !== t) return;\n f = !1;\n } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);\n } catch (r) {\n o = !0, n = r;\n } finally {\n try {\n if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return;\n } finally {\n if (o) throw n;\n }\n }\n return a;\n }\n}\nexport { _iterableToArrayLimit as default };","function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableRest as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _iterableToArray(r) {\n if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n if (r) {\n if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n var t = {}.toString.call(r).slice(8, -1);\n return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n }\n}\nexport { _unsupportedIterableToArray as default };","function r(e){var t,f,n=\"\";if(\"string\"==typeof e||\"number\"==typeof e)n+=e;else if(\"object\"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t