import { exactProp, init_exactProp, init_useEnhancedEffect, init_utils, useEnhancedEffect_default } from "./chunk-VA2N3UVE.js"; import { init_isMuiElement, isMuiElement } from "./chunk-MOF6LDJM.js"; import { ClassNameGenerator_default, GlobalStyles, ThemeContext, _extends, _objectWithoutPropertiesLoose, borders_default, capitalize, clamp_default, composeClasses, compose_default, createTheme_default, createUnarySpacing, cssGrid_default, deepmerge, extendSxProp, generateUtilityClass, generateUtilityClasses, getDisplayName, getThemeProps, getValue, handleBreakpoints, init_ClassNameGenerator, init_borders, init_breakpoints, init_capitalize, init_clamp, init_compose, init_composeClasses, init_createBreakpoints, init_createSpacing, init_createTheme, init_cssGrid, init_deepmerge, init_extends, init_formatMuiErrorMessage, init_generateUtilityClass, init_generateUtilityClasses, init_getDisplayName, init_objectWithoutPropertiesLoose, init_palette, init_responsivePropType, init_shape, init_sizing, init_spacing, init_style, init_styleFunctionSx, init_styled_engine, init_useTheme, init_useThemeProps, init_useThemeWithoutDefault, internal_processStyles, isPlainObject, mergeBreakpointsInOrder, palette_default, resolveBreakpointValues, sizing_default, spacing_default, styleFunctionSx_default, style_default, styled, useThemeProps, useThemeWithoutDefault_default, useTheme_default } from "./chunk-7JF2SDS5.js"; import { require_prop_types } from "./chunk-4CB2EIFM.js"; import { clsx_default, init_clsx } from "./chunk-AX45CUQC.js"; import { require_jsx_runtime } from "./chunk-DT77FM6J.js"; import { require_react } from "./chunk-4D5CYJYK.js"; import { __toESM } from "./chunk-CEQRFMJQ.js"; // node_modules/@mui/system/esm/useMediaQuery/useMediaQuery.js var React = __toESM(require_react()); init_useEnhancedEffect(); init_useThemeProps(); init_useThemeWithoutDefault(); function useMediaQueryOld(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr) { const [match, setMatch] = React.useState(() => { if (noSsr && matchMedia) { return matchMedia(query).matches; } if (ssrMatchMedia) { return ssrMatchMedia(query).matches; } return defaultMatches; }); useEnhancedEffect_default(() => { let active = true; if (!matchMedia) { return void 0; } const queryList = matchMedia(query); const updateMatch = () => { if (active) { setMatch(queryList.matches); } }; updateMatch(); queryList.addListener(updateMatch); return () => { active = false; queryList.removeListener(updateMatch); }; }, [query, matchMedia]); return match; } var maybeReactUseSyncExternalStore = React["useSyncExternalStore"]; function useMediaQueryNew(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr) { const getDefaultSnapshot = React.useCallback(() => defaultMatches, [defaultMatches]); const getServerSnapshot = React.useMemo(() => { if (noSsr && matchMedia) { return () => matchMedia(query).matches; } if (ssrMatchMedia !== null) { const { matches } = ssrMatchMedia(query); return () => matches; } return getDefaultSnapshot; }, [getDefaultSnapshot, query, ssrMatchMedia, noSsr, matchMedia]); const [getSnapshot, subscribe] = React.useMemo(() => { if (matchMedia === null) { return [getDefaultSnapshot, () => () => { }]; } const mediaQueryList = matchMedia(query); return [() => mediaQueryList.matches, (notify) => { mediaQueryList.addListener(notify); return () => { mediaQueryList.removeListener(notify); }; }]; }, [getDefaultSnapshot, matchMedia, query]); const match = maybeReactUseSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); return match; } function useMediaQuery(queryInput, options = {}) { const theme = useThemeWithoutDefault_default(); const supportMatchMedia = typeof window !== "undefined" && typeof window.matchMedia !== "undefined"; const { defaultMatches = false, matchMedia = supportMatchMedia ? window.matchMedia : null, ssrMatchMedia = null, noSsr = false } = getThemeProps({ name: "MuiUseMediaQuery", props: options, theme }); if (true) { if (typeof queryInput === "function" && theme === null) { console.error(["MUI: The `query` argument provided is invalid.", "You are providing a function without a theme in the context.", "One of the parent elements needs to use a ThemeProvider."].join("\n")); } } let query = typeof queryInput === "function" ? queryInput(theme) : queryInput; query = query.replace(/^@media( ?)/m, ""); const useMediaQueryImplementation = maybeReactUseSyncExternalStore !== void 0 ? useMediaQueryNew : useMediaQueryOld; const match = useMediaQueryImplementation(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr); if (true) { React.useDebugValue({ query, match }); } return match; } // node_modules/@mui/system/esm/colorManipulator.js init_formatMuiErrorMessage(); init_clamp(); function clampWrapper(value, min = 0, max = 1) { if (true) { if (value < min || value > max) { console.error(`MUI: The value provided ${value} is out of range [${min}, ${max}].`); } } return clamp_default(value, min, max); } function hexToRgb(color) { color = color.slice(1); const re = new RegExp(`.{1,${color.length >= 6 ? 2 : 1}}`, "g"); let colors = color.match(re); if (colors && colors[0].length === 1) { colors = colors.map((n) => n + n); } return colors ? `rgb${colors.length === 4 ? "a" : ""}(${colors.map((n, index) => { return index < 3 ? parseInt(n, 16) : Math.round(parseInt(n, 16) / 255 * 1e3) / 1e3; }).join(", ")})` : ""; } function intToHex(int) { const hex = int.toString(16); return hex.length === 1 ? `0${hex}` : hex; } function decomposeColor(color) { if (color.type) { return color; } if (color.charAt(0) === "#") { return decomposeColor(hexToRgb(color)); } const marker = color.indexOf("("); const type = color.substring(0, marker); if (["rgb", "rgba", "hsl", "hsla", "color"].indexOf(type) === -1) { throw new Error(true ? `MUI: Unsupported \`${color}\` color. The following formats are supported: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().` : formatMuiErrorMessage(9, color)); } let values = color.substring(marker + 1, color.length - 1); let colorSpace; if (type === "color") { values = values.split(" "); colorSpace = values.shift(); if (values.length === 4 && values[3].charAt(0) === "/") { values[3] = values[3].slice(1); } if (["srgb", "display-p3", "a98-rgb", "prophoto-rgb", "rec-2020"].indexOf(colorSpace) === -1) { throw new Error(true ? `MUI: unsupported \`${colorSpace}\` color space. The following color spaces are supported: srgb, display-p3, a98-rgb, prophoto-rgb, rec-2020.` : formatMuiErrorMessage(10, colorSpace)); } } else { values = values.split(","); } values = values.map((value) => parseFloat(value)); return { type, values, colorSpace }; } function recomposeColor(color) { const { type, colorSpace } = color; let { values } = color; if (type.indexOf("rgb") !== -1) { values = values.map((n, i) => i < 3 ? parseInt(n, 10) : n); } else if (type.indexOf("hsl") !== -1) { values[1] = `${values[1]}%`; values[2] = `${values[2]}%`; } if (type.indexOf("color") !== -1) { values = `${colorSpace} ${values.join(" ")}`; } else { values = `${values.join(", ")}`; } return `${type}(${values})`; } function rgbToHex(color) { if (color.indexOf("#") === 0) { return color; } const { values } = decomposeColor(color); return `#${values.map((n, i) => intToHex(i === 3 ? Math.round(255 * n) : n)).join("")}`; } function hslToRgb(color) { color = decomposeColor(color); const { values } = color; const h = values[0]; const s = values[1] / 100; const l = values[2] / 100; const a = s * Math.min(l, 1 - l); const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1); let type = "rgb"; const rgb = [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)]; if (color.type === "hsla") { type += "a"; rgb.push(values[3]); } return recomposeColor({ type, values: rgb }); } function getLuminance(color) { color = decomposeColor(color); let rgb = color.type === "hsl" || color.type === "hsla" ? decomposeColor(hslToRgb(color)).values : color.values; rgb = rgb.map((val) => { if (color.type !== "color") { val /= 255; } return val <= 0.03928 ? val / 12.92 : ((val + 0.055) / 1.055) ** 2.4; }); return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3)); } function getContrastRatio(foreground, background) { const lumA = getLuminance(foreground); const lumB = getLuminance(background); return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05); } function alpha(color, value) { color = decomposeColor(color); value = clampWrapper(value); if (color.type === "rgb" || color.type === "hsl") { color.type += "a"; } if (color.type === "color") { color.values[3] = `/${value}`; } else { color.values[3] = value; } return recomposeColor(color); } function darken(color, coefficient) { color = decomposeColor(color); coefficient = clampWrapper(coefficient); if (color.type.indexOf("hsl") !== -1) { color.values[2] *= 1 - coefficient; } else if (color.type.indexOf("rgb") !== -1 || color.type.indexOf("color") !== -1) { for (let i = 0; i < 3; i += 1) { color.values[i] *= 1 - coefficient; } } return recomposeColor(color); } function lighten(color, coefficient) { color = decomposeColor(color); coefficient = clampWrapper(coefficient); if (color.type.indexOf("hsl") !== -1) { color.values[2] += (100 - color.values[2]) * coefficient; } else if (color.type.indexOf("rgb") !== -1) { for (let i = 0; i < 3; i += 1) { color.values[i] += (255 - color.values[i]) * coefficient; } } else if (color.type.indexOf("color") !== -1) { for (let i = 0; i < 3; i += 1) { color.values[i] += (1 - color.values[i]) * coefficient; } } return recomposeColor(color); } function emphasize(color, coefficient = 0.15) { return getLuminance(color) > 0.5 ? darken(color, coefficient) : lighten(color, coefficient); } // node_modules/@mui/system/esm/index.js init_formatMuiErrorMessage(); init_styled_engine(); // node_modules/@mui/system/esm/GlobalStyles/GlobalStyles.js var React2 = __toESM(require_react()); var import_prop_types = __toESM(require_prop_types()); init_styled_engine(); init_useTheme(); var import_jsx_runtime = __toESM(require_jsx_runtime()); function GlobalStyles2({ styles, themeId, defaultTheme: defaultTheme4 = {} }) { const upperTheme = useTheme_default(defaultTheme4); const globalStyles = typeof styles === "function" ? styles(themeId ? upperTheme[themeId] || upperTheme : upperTheme) : styles; return (0, import_jsx_runtime.jsx)(GlobalStyles, { styles: globalStyles }); } true ? GlobalStyles2.propTypes = { // ┌────────────────────────────── Warning ──────────────────────────────┐ // │ These PropTypes are generated from the TypeScript type definitions. │ // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │ // └─────────────────────────────────────────────────────────────────────┘ /** * @ignore */ defaultTheme: import_prop_types.default.object, /** * @ignore */ styles: import_prop_types.default.oneOfType([import_prop_types.default.array, import_prop_types.default.func, import_prop_types.default.number, import_prop_types.default.object, import_prop_types.default.string, import_prop_types.default.bool]), /** * @ignore */ themeId: import_prop_types.default.string } : void 0; var GlobalStyles_default = GlobalStyles2; // node_modules/@mui/system/esm/index.js init_borders(); init_borders(); init_breakpoints(); init_breakpoints(); init_compose(); // node_modules/@mui/system/esm/display.js init_style(); init_compose(); var displayPrint = style_default({ prop: "displayPrint", cssProperty: false, transform: (value) => ({ "@media print": { display: value } }) }); var displayRaw = style_default({ prop: "display" }); var overflow = style_default({ prop: "overflow" }); var textOverflow = style_default({ prop: "textOverflow" }); var visibility = style_default({ prop: "visibility" }); var whiteSpace = style_default({ prop: "whiteSpace" }); var display_default = compose_default(displayPrint, displayRaw, overflow, textOverflow, visibility, whiteSpace); // node_modules/@mui/system/esm/flexbox.js init_style(); init_compose(); var flexBasis = style_default({ prop: "flexBasis" }); var flexDirection = style_default({ prop: "flexDirection" }); var flexWrap = style_default({ prop: "flexWrap" }); var justifyContent = style_default({ prop: "justifyContent" }); var alignItems = style_default({ prop: "alignItems" }); var alignContent = style_default({ prop: "alignContent" }); var order = style_default({ prop: "order" }); var flex = style_default({ prop: "flex" }); var flexGrow = style_default({ prop: "flexGrow" }); var flexShrink = style_default({ prop: "flexShrink" }); var alignSelf = style_default({ prop: "alignSelf" }); var justifyItems = style_default({ prop: "justifyItems" }); var justifySelf = style_default({ prop: "justifySelf" }); var flexbox = compose_default(flexBasis, flexDirection, flexWrap, justifyContent, alignItems, alignContent, order, flex, flexGrow, flexShrink, alignSelf, justifyItems, justifySelf); var flexbox_default = flexbox; // node_modules/@mui/system/esm/index.js init_cssGrid(); init_cssGrid(); init_palette(); init_palette(); // node_modules/@mui/system/esm/positions.js init_style(); init_compose(); var position = style_default({ prop: "position" }); var zIndex = style_default({ prop: "zIndex", themeKey: "zIndex" }); var top = style_default({ prop: "top" }); var right = style_default({ prop: "right" }); var bottom = style_default({ prop: "bottom" }); var left = style_default({ prop: "left" }); var positions_default = compose_default(position, zIndex, top, right, bottom, left); // node_modules/@mui/system/esm/shadows.js init_style(); var boxShadow = style_default({ prop: "boxShadow", themeKey: "shadows" }); var shadows_default = boxShadow; // node_modules/@mui/system/esm/index.js init_sizing(); init_sizing(); init_spacing(); init_spacing(); init_style(); // node_modules/@mui/system/esm/typography.js init_style(); init_compose(); var fontFamily = style_default({ prop: "fontFamily", themeKey: "typography" }); var fontSize = style_default({ prop: "fontSize", themeKey: "typography" }); var fontStyle = style_default({ prop: "fontStyle", themeKey: "typography" }); var fontWeight = style_default({ prop: "fontWeight", themeKey: "typography" }); var letterSpacing = style_default({ prop: "letterSpacing" }); var textTransform = style_default({ prop: "textTransform" }); var lineHeight = style_default({ prop: "lineHeight" }); var textAlign = style_default({ prop: "textAlign" }); var typographyVariant = style_default({ prop: "typography", cssProperty: false, themeKey: "typography" }); var typography = compose_default(typographyVariant, fontFamily, fontSize, fontStyle, fontWeight, letterSpacing, lineHeight, textAlign, textTransform); var typography_default = typography; // node_modules/@mui/system/esm/index.js init_styleFunctionSx(); // node_modules/@mui/system/esm/getThemeValue.js init_borders(); init_cssGrid(); init_palette(); init_sizing(); init_spacing(); var filterPropsMapping = { borders: borders_default.filterProps, display: display_default.filterProps, flexbox: flexbox_default.filterProps, grid: cssGrid_default.filterProps, positions: positions_default.filterProps, palette: palette_default.filterProps, shadows: shadows_default.filterProps, sizing: sizing_default.filterProps, spacing: spacing_default.filterProps, typography: typography_default.filterProps }; var styleFunctionMapping = { borders: borders_default, display: display_default, flexbox: flexbox_default, grid: cssGrid_default, positions: positions_default, palette: palette_default, shadows: shadows_default, sizing: sizing_default, spacing: spacing_default, typography: typography_default }; var propToStyleFunction = Object.keys(filterPropsMapping).reduce((acc, styleFnName) => { filterPropsMapping[styleFnName].forEach((propName) => { acc[propName] = styleFunctionMapping[styleFnName]; }); return acc; }, {}); // node_modules/@mui/system/esm/Box/Box.js var import_prop_types2 = __toESM(require_prop_types()); init_ClassNameGenerator(); // node_modules/@mui/system/esm/createBox.js init_extends(); init_objectWithoutPropertiesLoose(); var React3 = __toESM(require_react()); init_clsx(); init_styled_engine(); init_styleFunctionSx(); init_useTheme(); var import_jsx_runtime2 = __toESM(require_jsx_runtime()); var _excluded = ["className", "component"]; function createBox(options = {}) { const { themeId, defaultTheme: defaultTheme4, defaultClassName = "MuiBox-root", generateClassName } = options; const BoxRoot = styled("div", { shouldForwardProp: (prop) => prop !== "theme" && prop !== "sx" && prop !== "as" })(styleFunctionSx_default); const Box2 = React3.forwardRef(function Box3(inProps, ref) { const theme = useTheme_default(defaultTheme4); const _extendSxProp = extendSxProp(inProps), { className, component = "div" } = _extendSxProp, other = _objectWithoutPropertiesLoose(_extendSxProp, _excluded); return (0, import_jsx_runtime2.jsx)(BoxRoot, _extends({ as: component, ref, className: clsx_default(className, generateClassName ? generateClassName(defaultClassName) : defaultClassName), theme: themeId ? theme[themeId] || theme : theme }, other)); }); return Box2; } // node_modules/@mui/system/esm/Box/boxClasses.js init_generateUtilityClasses(); var boxClasses = generateUtilityClasses("MuiBox", ["root"]); var boxClasses_default = boxClasses; // node_modules/@mui/system/esm/Box/Box.js var Box = createBox({ defaultClassName: boxClasses_default.root, generateClassName: ClassNameGenerator_default.generate }); true ? Box.propTypes = { // ┌────────────────────────────── Warning ──────────────────────────────┐ // │ These PropTypes are generated from the TypeScript type definitions. │ // │ To update them, edit the d.ts file and run `pnpm proptypes`. │ // └─────────────────────────────────────────────────────────────────────┘ /** * @ignore */ children: import_prop_types2.default.node, /** * The component used for the root node. * Either a string to use a HTML element or a component. */ component: import_prop_types2.default.elementType, /** * The system prop that allows defining system overrides as well as additional CSS styles. */ sx: import_prop_types2.default.oneOfType([import_prop_types2.default.arrayOf(import_prop_types2.default.oneOfType([import_prop_types2.default.func, import_prop_types2.default.object, import_prop_types2.default.bool])), import_prop_types2.default.func, import_prop_types2.default.object]) } : void 0; // node_modules/@mui/system/esm/createStyled.js init_extends(); init_objectWithoutPropertiesLoose(); init_styled_engine(); init_deepmerge(); init_capitalize(); init_getDisplayName(); init_createTheme(); init_styleFunctionSx(); var _excluded2 = ["ownerState"]; var _excluded22 = ["variants"]; var _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"]; function isEmpty(obj) { return Object.keys(obj).length === 0; } function isStringTag(tag) { return typeof tag === "string" && // 96 is one less than the char code // for "a" so this is checking that // it's a lowercase character tag.charCodeAt(0) > 96; } function shouldForwardProp(prop) { return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as"; } var systemDefaultTheme = createTheme_default(); var lowercaseFirstLetter = (string) => { if (!string) { return string; } return string.charAt(0).toLowerCase() + string.slice(1); }; function resolveTheme({ defaultTheme: defaultTheme4, theme, themeId }) { return isEmpty(theme) ? defaultTheme4 : theme[themeId] || theme; } function defaultOverridesResolver(slot) { if (!slot) { return null; } return (props, styles) => styles[slot]; } function processStyleArg(callableStyle, _ref) { let { ownerState } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded2); const resolvedStylesArg = typeof callableStyle === "function" ? callableStyle(_extends({ ownerState }, props)) : callableStyle; if (Array.isArray(resolvedStylesArg)) { return resolvedStylesArg.flatMap((resolvedStyle) => processStyleArg(resolvedStyle, _extends({ ownerState }, props))); } if (!!resolvedStylesArg && typeof resolvedStylesArg === "object" && Array.isArray(resolvedStylesArg.variants)) { const { variants = [] } = resolvedStylesArg, otherStyles = _objectWithoutPropertiesLoose(resolvedStylesArg, _excluded22); let result = otherStyles; variants.forEach((variant) => { let isMatch = true; if (typeof variant.props === "function") { isMatch = variant.props(_extends({ ownerState }, props, ownerState)); } else { Object.keys(variant.props).forEach((key) => { if ((ownerState == null ? void 0 : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) { isMatch = false; } }); } if (isMatch) { if (!Array.isArray(result)) { result = [result]; } result.push(typeof variant.style === "function" ? variant.style(_extends({ ownerState }, props, ownerState)) : variant.style); } }); return result; } return resolvedStylesArg; } function createStyled(input = {}) { const { themeId, defaultTheme: defaultTheme4 = systemDefaultTheme, rootShouldForwardProp = shouldForwardProp, slotShouldForwardProp = shouldForwardProp } = input; const systemSx = (props) => { return styleFunctionSx_default(_extends({}, props, { theme: resolveTheme(_extends({}, props, { defaultTheme: defaultTheme4, themeId })) })); }; systemSx.__mui_systemSx = true; return (tag, inputOptions = {}) => { internal_processStyles(tag, (styles) => styles.filter((style2) => !(style2 != null && style2.__mui_systemSx))); const { name: componentName, slot: componentSlot, skipVariantsResolver: inputSkipVariantsResolver, skipSx: inputSkipSx, // TODO v6: remove `lowercaseFirstLetter()` in the next major release // For more details: https://github.com/mui/material-ui/pull/37908 overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(componentSlot)) } = inputOptions, options = _objectWithoutPropertiesLoose(inputOptions, _excluded3); const skipVariantsResolver = inputSkipVariantsResolver !== void 0 ? inputSkipVariantsResolver : ( // TODO v6: remove `Root` in the next major release // For more details: https://github.com/mui/material-ui/pull/37908 componentSlot && componentSlot !== "Root" && componentSlot !== "root" || false ); const skipSx = inputSkipSx || false; let label; if (true) { if (componentName) { label = `${componentName}-${lowercaseFirstLetter(componentSlot || "Root")}`; } } let shouldForwardPropOption = shouldForwardProp; if (componentSlot === "Root" || componentSlot === "root") { shouldForwardPropOption = rootShouldForwardProp; } else if (componentSlot) { shouldForwardPropOption = slotShouldForwardProp; } else if (isStringTag(tag)) { shouldForwardPropOption = void 0; } const defaultStyledResolver = styled(tag, _extends({ shouldForwardProp: shouldForwardPropOption, label }, options)); const transformStyleArg = (stylesArg) => { if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || isPlainObject(stylesArg)) { return (props) => processStyleArg(stylesArg, _extends({}, props, { theme: resolveTheme({ theme: props.theme, defaultTheme: defaultTheme4, themeId }) })); } return stylesArg; }; const muiStyledResolver = (styleArg, ...expressions) => { let transformedStyleArg = transformStyleArg(styleArg); const expressionsWithDefaultTheme = expressions ? expressions.map(transformStyleArg) : []; if (componentName && overridesResolver) { expressionsWithDefaultTheme.push((props) => { const theme = resolveTheme(_extends({}, props, { defaultTheme: defaultTheme4, themeId })); if (!theme.components || !theme.components[componentName] || !theme.components[componentName].styleOverrides) { return null; } const styleOverrides = theme.components[componentName].styleOverrides; const resolvedStyleOverrides = {}; Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => { resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, _extends({}, props, { theme })); }); return overridesResolver(props, resolvedStyleOverrides); }); } if (componentName && !skipVariantsResolver) { expressionsWithDefaultTheme.push((props) => { var _theme$components; const theme = resolveTheme(_extends({}, props, { defaultTheme: defaultTheme4, themeId })); const themeVariants = theme == null || (_theme$components = theme.components) == null || (_theme$components = _theme$components[componentName]) == null ? void 0 : _theme$components.variants; return processStyleArg({ variants: themeVariants }, _extends({}, props, { theme })); }); } if (!skipSx) { expressionsWithDefaultTheme.push(systemSx); } const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length; if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) { const placeholders = new Array(numOfCustomFnsApplied).fill(""); transformedStyleArg = [...styleArg, ...placeholders]; transformedStyleArg.raw = [...styleArg.raw, ...placeholders]; } const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme); if (true) { let displayName; if (componentName) { displayName = `${componentName}${capitalize(componentSlot || "")}`; } if (displayName === void 0) { displayName = `Styled(${getDisplayName(tag)})`; } Component.displayName = displayName; } if (tag.muiName) { Component.muiName = tag.muiName; } return Component; }; if (defaultStyledResolver.withConfig) { muiStyledResolver.withConfig = defaultStyledResolver.withConfig; } return muiStyledResolver; }; } // node_modules/@mui/system/esm/styled.js var styled2 = createStyled(); var styled_default = styled2; // node_modules/@mui/system/esm/index.js init_createTheme(); init_createBreakpoints(); init_createSpacing(); init_shape(); init_useThemeProps(); init_useTheme(); init_useThemeWithoutDefault(); // node_modules/@mui/system/esm/ThemeProvider/ThemeProvider.js init_extends(); var React8 = __toESM(require_react()); var import_prop_types5 = __toESM(require_prop_types()); // node_modules/@mui/private-theming/ThemeProvider/ThemeProvider.js init_extends(); var React6 = __toESM(require_react()); var import_prop_types3 = __toESM(require_prop_types()); init_utils(); // node_modules/@mui/private-theming/useTheme/ThemeContext.js var React4 = __toESM(require_react()); var ThemeContext2 = React4.createContext(null); if (true) { ThemeContext2.displayName = "ThemeContext"; } var ThemeContext_default = ThemeContext2; // node_modules/@mui/private-theming/useTheme/useTheme.js var React5 = __toESM(require_react()); function useTheme() { const theme = React5.useContext(ThemeContext_default); if (true) { React5.useDebugValue(theme); } return theme; } // node_modules/@mui/private-theming/ThemeProvider/nested.js var hasSymbol = typeof Symbol === "function" && Symbol.for; var nested_default = hasSymbol ? Symbol.for("mui.nested") : "__THEME_NESTED__"; // node_modules/@mui/private-theming/ThemeProvider/ThemeProvider.js var import_jsx_runtime3 = __toESM(require_jsx_runtime()); function mergeOuterLocalTheme(outerTheme, localTheme) { if (typeof localTheme === "function") { const mergedTheme = localTheme(outerTheme); if (true) { if (!mergedTheme) { console.error(["MUI: You should return an object from your theme function, i.e.", " ({})} />"].join("\n")); } } return mergedTheme; } return _extends({}, outerTheme, localTheme); } function ThemeProvider(props) { const { children, theme: localTheme } = props; const outerTheme = useTheme(); if (true) { if (outerTheme === null && typeof localTheme === "function") { console.error(["MUI: You are providing a theme function prop to the ThemeProvider component:", " outerTheme} />", "", "However, no outer theme is present.", "Make sure a theme is already injected higher in the React tree or provide a theme object."].join("\n")); } } const theme = React6.useMemo(() => { const output = outerTheme === null ? localTheme : mergeOuterLocalTheme(outerTheme, localTheme); if (output != null) { output[nested_default] = outerTheme !== null; } return output; }, [localTheme, outerTheme]); return (0, import_jsx_runtime3.jsx)(ThemeContext_default.Provider, { value: theme, children }); } true ? ThemeProvider.propTypes = { /** * Your component tree. */ children: import_prop_types3.default.node, /** * A theme object. You can provide a function to extend the outer theme. */ theme: import_prop_types3.default.oneOfType([import_prop_types3.default.object, import_prop_types3.default.func]).isRequired } : void 0; if (true) { true ? ThemeProvider.propTypes = exactProp(ThemeProvider.propTypes) : void 0; } var ThemeProvider_default = ThemeProvider; // node_modules/@mui/system/esm/ThemeProvider/ThemeProvider.js init_exactProp(); init_styled_engine(); init_useThemeWithoutDefault(); // node_modules/@mui/system/esm/RtlProvider/index.js init_extends(); init_objectWithoutPropertiesLoose(); var React7 = __toESM(require_react()); var import_prop_types4 = __toESM(require_prop_types()); var import_jsx_runtime4 = __toESM(require_jsx_runtime()); var _excluded4 = ["value"]; var RtlContext = React7.createContext(); function RtlProvider(_ref) { let { value } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded4); return (0, import_jsx_runtime4.jsx)(RtlContext.Provider, _extends({ value: value != null ? value : true }, props)); } true ? RtlProvider.propTypes = { children: import_prop_types4.default.node, value: import_prop_types4.default.bool } : void 0; var useRtl = () => { const value = React7.useContext(RtlContext); return value != null ? value : false; }; var RtlProvider_default = RtlProvider; // node_modules/@mui/system/esm/ThemeProvider/ThemeProvider.js var import_jsx_runtime5 = __toESM(require_jsx_runtime()); var EMPTY_THEME = {}; function useThemeScoping(themeId, upperTheme, localTheme, isPrivate = false) { return React8.useMemo(() => { const resolvedTheme = themeId ? upperTheme[themeId] || upperTheme : upperTheme; if (typeof localTheme === "function") { const mergedTheme = localTheme(resolvedTheme); const result = themeId ? _extends({}, upperTheme, { [themeId]: mergedTheme }) : mergedTheme; if (isPrivate) { return () => result; } return result; } return themeId ? _extends({}, upperTheme, { [themeId]: localTheme }) : _extends({}, upperTheme, localTheme); }, [themeId, upperTheme, localTheme, isPrivate]); } function ThemeProvider2(props) { const { children, theme: localTheme, themeId } = props; const upperTheme = useThemeWithoutDefault_default(EMPTY_THEME); const upperPrivateTheme = useTheme() || EMPTY_THEME; if (true) { if (upperTheme === null && typeof localTheme === "function" || themeId && upperTheme && !upperTheme[themeId] && typeof localTheme === "function") { console.error(["MUI: You are providing a theme function prop to the ThemeProvider component:", " outerTheme} />", "", "However, no outer theme is present.", "Make sure a theme is already injected higher in the React tree or provide a theme object."].join("\n")); } } const engineTheme = useThemeScoping(themeId, upperTheme, localTheme); const privateTheme = useThemeScoping(themeId, upperPrivateTheme, localTheme, true); const rtlValue = engineTheme.direction === "rtl"; return (0, import_jsx_runtime5.jsx)(ThemeProvider_default, { theme: privateTheme, children: (0, import_jsx_runtime5.jsx)(ThemeContext.Provider, { value: engineTheme, children: (0, import_jsx_runtime5.jsx)(RtlProvider_default, { value: rtlValue, children }) }) }); } true ? ThemeProvider2.propTypes = { // ┌────────────────────────────── Warning ──────────────────────────────┐ // │ These PropTypes are generated from the TypeScript type definitions. │ // │ To update them, edit the d.ts file and run `pnpm proptypes`. │ // └─────────────────────────────────────────────────────────────────────┘ /** * Your component tree. */ children: import_prop_types5.default.node, /** * A theme object. You can provide a function to extend the outer theme. */ theme: import_prop_types5.default.oneOfType([import_prop_types5.default.func, import_prop_types5.default.object]).isRequired, /** * The design system's unique id for getting the corresponded theme when there are multiple design systems. */ themeId: import_prop_types5.default.string } : void 0; if (true) { true ? ThemeProvider2.propTypes = exactProp(ThemeProvider2.propTypes) : void 0; } var ThemeProvider_default2 = ThemeProvider2; // node_modules/@mui/system/esm/cssVars/createCssVarsProvider.js init_extends(); init_objectWithoutPropertiesLoose(); init_formatMuiErrorMessage(); var React11 = __toESM(require_react()); var import_prop_types6 = __toESM(require_prop_types()); init_deepmerge(); init_styled_engine(); // node_modules/@mui/system/esm/cssVars/getInitColorSchemeScript.js var React9 = __toESM(require_react()); var import_jsx_runtime6 = __toESM(require_jsx_runtime()); var DEFAULT_MODE_STORAGE_KEY = "mode"; var DEFAULT_COLOR_SCHEME_STORAGE_KEY = "color-scheme"; var DEFAULT_ATTRIBUTE = "data-color-scheme"; function getInitColorSchemeScript(options) { const { defaultMode = "light", defaultLightColorScheme = "light", defaultDarkColorScheme = "dark", modeStorageKey = DEFAULT_MODE_STORAGE_KEY, colorSchemeStorageKey = DEFAULT_COLOR_SCHEME_STORAGE_KEY, attribute = DEFAULT_ATTRIBUTE, colorSchemeNode = "document.documentElement" } = options || {}; return (0, import_jsx_runtime6.jsx)("script", { // eslint-disable-next-line react/no-danger dangerouslySetInnerHTML: { __html: `(function() { try { var mode = localStorage.getItem('${modeStorageKey}') || '${defaultMode}'; var colorScheme = ''; if (mode === 'system') { // handle system mode var mql = window.matchMedia('(prefers-color-scheme: dark)'); if (mql.matches) { colorScheme = localStorage.getItem('${colorSchemeStorageKey}-dark') || '${defaultDarkColorScheme}'; } else { colorScheme = localStorage.getItem('${colorSchemeStorageKey}-light') || '${defaultLightColorScheme}'; } } if (mode === 'light') { colorScheme = localStorage.getItem('${colorSchemeStorageKey}-light') || '${defaultLightColorScheme}'; } if (mode === 'dark') { colorScheme = localStorage.getItem('${colorSchemeStorageKey}-dark') || '${defaultDarkColorScheme}'; } if (colorScheme) { ${colorSchemeNode}.setAttribute('${attribute}', colorScheme); } } catch(e){}})();` } }, "mui-color-scheme-init"); } // node_modules/@mui/system/esm/cssVars/useCurrentColorScheme.js init_extends(); var React10 = __toESM(require_react()); function getSystemMode(mode) { if (typeof window !== "undefined" && mode === "system") { const mql = window.matchMedia("(prefers-color-scheme: dark)"); if (mql.matches) { return "dark"; } return "light"; } return void 0; } function processState(state, callback) { if (state.mode === "light" || state.mode === "system" && state.systemMode === "light") { return callback("light"); } if (state.mode === "dark" || state.mode === "system" && state.systemMode === "dark") { return callback("dark"); } return void 0; } function getColorScheme(state) { return processState(state, (mode) => { if (mode === "light") { return state.lightColorScheme; } if (mode === "dark") { return state.darkColorScheme; } return void 0; }); } function initializeValue(key, defaultValue) { if (typeof window === "undefined") { return void 0; } let value; try { value = localStorage.getItem(key) || void 0; if (!value) { localStorage.setItem(key, defaultValue); } } catch (e) { } return value || defaultValue; } function useCurrentColorScheme(options) { const { defaultMode = "light", defaultLightColorScheme, defaultDarkColorScheme, supportedColorSchemes = [], modeStorageKey = DEFAULT_MODE_STORAGE_KEY, colorSchemeStorageKey = DEFAULT_COLOR_SCHEME_STORAGE_KEY, storageWindow = typeof window === "undefined" ? void 0 : window } = options; const joinedColorSchemes = supportedColorSchemes.join(","); const [state, setState] = React10.useState(() => { const initialMode = initializeValue(modeStorageKey, defaultMode); const lightColorScheme = initializeValue(`${colorSchemeStorageKey}-light`, defaultLightColorScheme); const darkColorScheme = initializeValue(`${colorSchemeStorageKey}-dark`, defaultDarkColorScheme); return { mode: initialMode, systemMode: getSystemMode(initialMode), lightColorScheme, darkColorScheme }; }); const colorScheme = getColorScheme(state); const setMode = React10.useCallback((mode) => { setState((currentState) => { if (mode === currentState.mode) { return currentState; } const newMode = !mode ? defaultMode : mode; try { localStorage.setItem(modeStorageKey, newMode); } catch (e) { } return _extends({}, currentState, { mode: newMode, systemMode: getSystemMode(newMode) }); }); }, [modeStorageKey, defaultMode]); const setColorScheme = React10.useCallback((value) => { if (!value) { setState((currentState) => { try { localStorage.setItem(`${colorSchemeStorageKey}-light`, defaultLightColorScheme); localStorage.setItem(`${colorSchemeStorageKey}-dark`, defaultDarkColorScheme); } catch (e) { } return _extends({}, currentState, { lightColorScheme: defaultLightColorScheme, darkColorScheme: defaultDarkColorScheme }); }); } else if (typeof value === "string") { if (value && !joinedColorSchemes.includes(value)) { console.error(`\`${value}\` does not exist in \`theme.colorSchemes\`.`); } else { setState((currentState) => { const newState = _extends({}, currentState); processState(currentState, (mode) => { try { localStorage.setItem(`${colorSchemeStorageKey}-${mode}`, value); } catch (e) { } if (mode === "light") { newState.lightColorScheme = value; } if (mode === "dark") { newState.darkColorScheme = value; } }); return newState; }); } } else { setState((currentState) => { const newState = _extends({}, currentState); const newLightColorScheme = value.light === null ? defaultLightColorScheme : value.light; const newDarkColorScheme = value.dark === null ? defaultDarkColorScheme : value.dark; if (newLightColorScheme) { if (!joinedColorSchemes.includes(newLightColorScheme)) { console.error(`\`${newLightColorScheme}\` does not exist in \`theme.colorSchemes\`.`); } else { newState.lightColorScheme = newLightColorScheme; try { localStorage.setItem(`${colorSchemeStorageKey}-light`, newLightColorScheme); } catch (error) { } } } if (newDarkColorScheme) { if (!joinedColorSchemes.includes(newDarkColorScheme)) { console.error(`\`${newDarkColorScheme}\` does not exist in \`theme.colorSchemes\`.`); } else { newState.darkColorScheme = newDarkColorScheme; try { localStorage.setItem(`${colorSchemeStorageKey}-dark`, newDarkColorScheme); } catch (error) { } } } return newState; }); } }, [joinedColorSchemes, colorSchemeStorageKey, defaultLightColorScheme, defaultDarkColorScheme]); const handleMediaQuery = React10.useCallback((e) => { if (state.mode === "system") { setState((currentState) => _extends({}, currentState, { systemMode: e != null && e.matches ? "dark" : "light" })); } }, [state.mode]); const mediaListener = React10.useRef(handleMediaQuery); mediaListener.current = handleMediaQuery; React10.useEffect(() => { const handler = (...args) => mediaListener.current(...args); const media = window.matchMedia("(prefers-color-scheme: dark)"); media.addListener(handler); handler(media); return () => media.removeListener(handler); }, []); React10.useEffect(() => { const handleStorage = (event) => { const value = event.newValue; if (typeof event.key === "string" && event.key.startsWith(colorSchemeStorageKey) && (!value || joinedColorSchemes.match(value))) { if (event.key.endsWith("light")) { setColorScheme({ light: value }); } if (event.key.endsWith("dark")) { setColorScheme({ dark: value }); } } if (event.key === modeStorageKey && (!value || ["light", "dark", "system"].includes(value))) { setMode(value || defaultMode); } }; if (storageWindow) { storageWindow.addEventListener("storage", handleStorage); return () => storageWindow.removeEventListener("storage", handleStorage); } return void 0; }, [setColorScheme, setMode, modeStorageKey, colorSchemeStorageKey, joinedColorSchemes, defaultMode, storageWindow]); return _extends({}, state, { colorScheme, setMode, setColorScheme }); } // node_modules/@mui/system/esm/cssVars/createCssVarsProvider.js var import_jsx_runtime7 = __toESM(require_jsx_runtime()); var import_jsx_runtime8 = __toESM(require_jsx_runtime()); var _excluded5 = ["colorSchemes", "components", "generateCssVars", "cssVarPrefix"]; var DISABLE_CSS_TRANSITION = "*{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}"; function createCssVarsProvider(options) { const { themeId, /** * This `theme` object needs to follow a certain structure to * be used correctly by the finel `CssVarsProvider`. It should have a * `colorSchemes` key with the light and dark (and any other) palette. * It should also ideally have a vars object created using `prepareCssVars`. */ theme: defaultTheme4 = {}, attribute: defaultAttribute = DEFAULT_ATTRIBUTE, modeStorageKey: defaultModeStorageKey = DEFAULT_MODE_STORAGE_KEY, colorSchemeStorageKey: defaultColorSchemeStorageKey = DEFAULT_COLOR_SCHEME_STORAGE_KEY, defaultMode: designSystemMode = "light", defaultColorScheme: designSystemColorScheme, disableTransitionOnChange: designSystemTransitionOnChange = false, resolveTheme: resolveTheme2, excludeVariablesFromRoot } = options; if (!defaultTheme4.colorSchemes || typeof designSystemColorScheme === "string" && !defaultTheme4.colorSchemes[designSystemColorScheme] || typeof designSystemColorScheme === "object" && !defaultTheme4.colorSchemes[designSystemColorScheme == null ? void 0 : designSystemColorScheme.light] || typeof designSystemColorScheme === "object" && !defaultTheme4.colorSchemes[designSystemColorScheme == null ? void 0 : designSystemColorScheme.dark]) { console.error(`MUI: \`${designSystemColorScheme}\` does not exist in \`theme.colorSchemes\`.`); } const ColorSchemeContext = React11.createContext(void 0); if (true) { ColorSchemeContext.displayName = "ColorSchemeContext"; } const useColorScheme = () => { const value = React11.useContext(ColorSchemeContext); if (!value) { throw new Error(true ? `MUI: \`useColorScheme\` must be called under ` : formatMuiErrorMessage(19)); } return value; }; function CssVarsProvider({ children, theme: themeProp = defaultTheme4, modeStorageKey = defaultModeStorageKey, colorSchemeStorageKey = defaultColorSchemeStorageKey, attribute = defaultAttribute, defaultMode = designSystemMode, defaultColorScheme = designSystemColorScheme, disableTransitionOnChange = designSystemTransitionOnChange, storageWindow = typeof window === "undefined" ? void 0 : window, documentNode = typeof document === "undefined" ? void 0 : document, colorSchemeNode = typeof document === "undefined" ? void 0 : document.documentElement, colorSchemeSelector = ":root", disableNestedContext = false, disableStyleSheetGeneration = false }) { const hasMounted = React11.useRef(false); const upperTheme = useTheme(); const ctx = React11.useContext(ColorSchemeContext); const nested = !!ctx && !disableNestedContext; const scopedTheme = themeProp[themeId]; const _ref = scopedTheme || themeProp, { colorSchemes = {}, components = {}, generateCssVars = () => ({ vars: {}, css: {} }), cssVarPrefix } = _ref, restThemeProp = _objectWithoutPropertiesLoose(_ref, _excluded5); const allColorSchemes = Object.keys(colorSchemes); const defaultLightColorScheme2 = typeof defaultColorScheme === "string" ? defaultColorScheme : defaultColorScheme.light; const defaultDarkColorScheme2 = typeof defaultColorScheme === "string" ? defaultColorScheme : defaultColorScheme.dark; const { mode: stateMode, setMode, systemMode, lightColorScheme, darkColorScheme, colorScheme: stateColorScheme, setColorScheme } = useCurrentColorScheme({ supportedColorSchemes: allColorSchemes, defaultLightColorScheme: defaultLightColorScheme2, defaultDarkColorScheme: defaultDarkColorScheme2, modeStorageKey, colorSchemeStorageKey, defaultMode, storageWindow }); let mode = stateMode; let colorScheme = stateColorScheme; if (nested) { mode = ctx.mode; colorScheme = ctx.colorScheme; } const calculatedMode = (() => { if (mode) { return mode; } if (defaultMode === "system") { return designSystemMode; } return defaultMode; })(); const calculatedColorScheme = (() => { if (!colorScheme) { if (calculatedMode === "dark") { return defaultDarkColorScheme2; } return defaultLightColorScheme2; } return colorScheme; })(); const { css: rootCss, vars: rootVars } = generateCssVars(); const theme = _extends({}, restThemeProp, { components, colorSchemes, cssVarPrefix, vars: rootVars, getColorSchemeSelector: (targetColorScheme) => `[${attribute}="${targetColorScheme}"] &` }); const defaultColorSchemeStyleSheet = {}; const otherColorSchemesStyleSheet = {}; Object.entries(colorSchemes).forEach(([key, scheme]) => { const { css: css2, vars } = generateCssVars(key); theme.vars = deepmerge(theme.vars, vars); if (key === calculatedColorScheme) { Object.keys(scheme).forEach((schemeKey) => { if (scheme[schemeKey] && typeof scheme[schemeKey] === "object") { theme[schemeKey] = _extends({}, theme[schemeKey], scheme[schemeKey]); } else { theme[schemeKey] = scheme[schemeKey]; } }); if (theme.palette) { theme.palette.colorScheme = key; } } const resolvedDefaultColorScheme = (() => { if (typeof defaultColorScheme === "string") { return defaultColorScheme; } if (defaultMode === "dark") { return defaultColorScheme.dark; } return defaultColorScheme.light; })(); if (key === resolvedDefaultColorScheme) { if (excludeVariablesFromRoot) { const excludedVariables = {}; excludeVariablesFromRoot(cssVarPrefix).forEach((cssVar) => { excludedVariables[cssVar] = css2[cssVar]; delete css2[cssVar]; }); defaultColorSchemeStyleSheet[`[${attribute}="${key}"]`] = excludedVariables; } defaultColorSchemeStyleSheet[`${colorSchemeSelector}, [${attribute}="${key}"]`] = css2; } else { otherColorSchemesStyleSheet[`${colorSchemeSelector === ":root" ? "" : colorSchemeSelector}[${attribute}="${key}"]`] = css2; } }); theme.vars = deepmerge(theme.vars, rootVars); React11.useEffect(() => { if (colorScheme && colorSchemeNode) { colorSchemeNode.setAttribute(attribute, colorScheme); } }, [colorScheme, attribute, colorSchemeNode]); React11.useEffect(() => { let timer; if (disableTransitionOnChange && hasMounted.current && documentNode) { const css2 = documentNode.createElement("style"); css2.appendChild(documentNode.createTextNode(DISABLE_CSS_TRANSITION)); documentNode.head.appendChild(css2); (() => window.getComputedStyle(documentNode.body))(); timer = setTimeout(() => { documentNode.head.removeChild(css2); }, 1); } return () => { clearTimeout(timer); }; }, [colorScheme, disableTransitionOnChange, documentNode]); React11.useEffect(() => { hasMounted.current = true; return () => { hasMounted.current = false; }; }, []); const contextValue = React11.useMemo(() => ({ mode, systemMode, setMode, lightColorScheme, darkColorScheme, colorScheme, setColorScheme, allColorSchemes }), [allColorSchemes, colorScheme, darkColorScheme, lightColorScheme, mode, setColorScheme, setMode, systemMode]); let shouldGenerateStyleSheet = true; if (disableStyleSheetGeneration || nested && (upperTheme == null ? void 0 : upperTheme.cssVarPrefix) === cssVarPrefix) { shouldGenerateStyleSheet = false; } const element = (0, import_jsx_runtime8.jsxs)(React11.Fragment, { children: [shouldGenerateStyleSheet && (0, import_jsx_runtime8.jsxs)(React11.Fragment, { children: [(0, import_jsx_runtime7.jsx)(GlobalStyles, { styles: { [colorSchemeSelector]: rootCss } }), (0, import_jsx_runtime7.jsx)(GlobalStyles, { styles: defaultColorSchemeStyleSheet }), (0, import_jsx_runtime7.jsx)(GlobalStyles, { styles: otherColorSchemesStyleSheet })] }), (0, import_jsx_runtime7.jsx)(ThemeProvider_default2, { themeId: scopedTheme ? themeId : void 0, theme: resolveTheme2 ? resolveTheme2(theme) : theme, children })] }); if (nested) { return element; } return (0, import_jsx_runtime7.jsx)(ColorSchemeContext.Provider, { value: contextValue, children: element }); } true ? CssVarsProvider.propTypes = { /** * The body attribute name to attach colorScheme. */ attribute: import_prop_types6.default.string, /** * The component tree. */ children: import_prop_types6.default.node, /** * The node used to attach the color-scheme attribute */ colorSchemeNode: import_prop_types6.default.any, /** * The CSS selector for attaching the generated custom properties */ colorSchemeSelector: import_prop_types6.default.string, /** * localStorage key used to store `colorScheme` */ colorSchemeStorageKey: import_prop_types6.default.string, /** * The initial color scheme used. */ defaultColorScheme: import_prop_types6.default.oneOfType([import_prop_types6.default.string, import_prop_types6.default.object]), /** * The initial mode used. */ defaultMode: import_prop_types6.default.string, /** * If `true`, the provider creates its own context and generate stylesheet as if it is a root `CssVarsProvider`. */ disableNestedContext: import_prop_types6.default.bool, /** * If `true`, the style sheet won't be generated. * * This is useful for controlling nested CssVarsProvider behavior. */ disableStyleSheetGeneration: import_prop_types6.default.bool, /** * Disable CSS transitions when switching between modes or color schemes. */ disableTransitionOnChange: import_prop_types6.default.bool, /** * The document to attach the attribute to. */ documentNode: import_prop_types6.default.any, /** * The key in the local storage used to store current color scheme. */ modeStorageKey: import_prop_types6.default.string, /** * The window that attaches the 'storage' event listener. * @default window */ storageWindow: import_prop_types6.default.any, /** * The calculated theme object that will be passed through context. */ theme: import_prop_types6.default.object } : void 0; const defaultLightColorScheme = typeof designSystemColorScheme === "string" ? designSystemColorScheme : designSystemColorScheme.light; const defaultDarkColorScheme = typeof designSystemColorScheme === "string" ? designSystemColorScheme : designSystemColorScheme.dark; const getInitColorSchemeScript2 = (params) => getInitColorSchemeScript(_extends({ attribute: defaultAttribute, colorSchemeStorageKey: defaultColorSchemeStorageKey, defaultMode: designSystemMode, defaultLightColorScheme, defaultDarkColorScheme, modeStorageKey: defaultModeStorageKey }, params)); return { CssVarsProvider, useColorScheme, getInitColorSchemeScript: getInitColorSchemeScript2 }; } // node_modules/@mui/system/esm/cssVars/createGetCssVar.js function createGetCssVar(prefix = "") { function appendVar(...vars) { if (!vars.length) { return ""; } const value = vars[0]; if (typeof value === "string" && !value.match(/(#|\(|\)|(-?(\d*\.)?\d+)(px|em|%|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc))|^(-?(\d*\.)?\d+)$|(\d+ \d+ \d+)/)) { return `, var(--${prefix ? `${prefix}-` : ""}${value}${appendVar(...vars.slice(1))})`; } return `, ${value}`; } const getCssVar = (field, ...fallbacks) => { return `var(--${prefix ? `${prefix}-` : ""}${field}${appendVar(...fallbacks)})`; }; return getCssVar; } // node_modules/@mui/system/esm/cssVars/cssVarsParser.js var assignNestedKeys = (obj, keys, value, arrayKeys = []) => { let temp = obj; keys.forEach((k, index) => { if (index === keys.length - 1) { if (Array.isArray(temp)) { temp[Number(k)] = value; } else if (temp && typeof temp === "object") { temp[k] = value; } } else if (temp && typeof temp === "object") { if (!temp[k]) { temp[k] = arrayKeys.includes(k) ? [] : {}; } temp = temp[k]; } }); }; var walkObjectDeep = (obj, callback, shouldSkipPaths) => { function recurse(object, parentKeys = [], arrayKeys = []) { Object.entries(object).forEach(([key, value]) => { if (!shouldSkipPaths || shouldSkipPaths && !shouldSkipPaths([...parentKeys, key])) { if (value !== void 0 && value !== null) { if (typeof value === "object" && Object.keys(value).length > 0) { recurse(value, [...parentKeys, key], Array.isArray(value) ? [...arrayKeys, key] : arrayKeys); } else { callback([...parentKeys, key], value, arrayKeys); } } } }); } recurse(obj); }; var getCssValue = (keys, value) => { if (typeof value === "number") { if (["lineHeight", "fontWeight", "opacity", "zIndex"].some((prop) => keys.includes(prop))) { return value; } const lastKey = keys[keys.length - 1]; if (lastKey.toLowerCase().indexOf("opacity") >= 0) { return value; } return `${value}px`; } return value; }; function cssVarsParser(theme, options) { const { prefix, shouldSkipGeneratingVar } = options || {}; const css2 = {}; const vars = {}; const varsWithDefaults = {}; walkObjectDeep( theme, (keys, value, arrayKeys) => { if (typeof value === "string" || typeof value === "number") { if (!shouldSkipGeneratingVar || !shouldSkipGeneratingVar(keys, value)) { const cssVar = `--${prefix ? `${prefix}-` : ""}${keys.join("-")}`; Object.assign(css2, { [cssVar]: getCssValue(keys, value) }); assignNestedKeys(vars, keys, `var(${cssVar})`, arrayKeys); assignNestedKeys(varsWithDefaults, keys, `var(${cssVar}, ${value})`, arrayKeys); } } }, (keys) => keys[0] === "vars" // skip 'vars/*' paths ); return { css: css2, vars, varsWithDefaults }; } // node_modules/@mui/system/esm/cssVars/prepareCssVars.js init_extends(); // node_modules/@babel/runtime/helpers/esm/typeof.js function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) { return typeof o2; } : function(o2) { return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2; }, _typeof(o); } // node_modules/@babel/runtime/helpers/esm/toPrimitive.js function toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // node_modules/@babel/runtime/helpers/esm/toPropertyKey.js function toPropertyKey(t) { var i = toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); } // node_modules/@mui/system/esm/cssVars/prepareCssVars.js init_objectWithoutPropertiesLoose(); init_deepmerge(); var _excluded6 = ["colorSchemes", "components", "defaultColorScheme"]; function prepareCssVars(theme, parserConfig) { const { colorSchemes = {}, defaultColorScheme = "light" } = theme, otherTheme = _objectWithoutPropertiesLoose(theme, _excluded6); const { vars: rootVars, css: rootCss, varsWithDefaults: rootVarsWithDefaults } = cssVarsParser(otherTheme, parserConfig); let themeVars = rootVarsWithDefaults; const colorSchemesMap = {}; const { [defaultColorScheme]: light } = colorSchemes, otherColorSchemes = _objectWithoutPropertiesLoose(colorSchemes, [defaultColorScheme].map(toPropertyKey)); Object.entries(otherColorSchemes || {}).forEach(([key, scheme]) => { const { vars, css: css2, varsWithDefaults } = cssVarsParser(scheme, parserConfig); themeVars = deepmerge(themeVars, varsWithDefaults); colorSchemesMap[key] = { css: css2, vars }; }); if (light) { const { css: css2, vars, varsWithDefaults } = cssVarsParser(light, parserConfig); themeVars = deepmerge(themeVars, varsWithDefaults); colorSchemesMap[defaultColorScheme] = { css: css2, vars }; } const generateCssVars = (colorScheme) => { var _parserConfig$getSele2; if (!colorScheme) { var _parserConfig$getSele; const css3 = _extends({}, rootCss); return { css: css3, vars: rootVars, selector: (parserConfig == null || (_parserConfig$getSele = parserConfig.getSelector) == null ? void 0 : _parserConfig$getSele.call(parserConfig, colorScheme, css3)) || ":root" }; } const css2 = _extends({}, colorSchemesMap[colorScheme].css); return { css: css2, vars: colorSchemesMap[colorScheme].vars, selector: (parserConfig == null || (_parserConfig$getSele2 = parserConfig.getSelector) == null ? void 0 : _parserConfig$getSele2.call(parserConfig, colorScheme, css2)) || ":root" }; }; return { vars: themeVars, generateCssVars }; } var prepareCssVars_default = prepareCssVars; // node_modules/@mui/system/esm/cssVars/createCssVarsTheme.js init_extends(); init_objectWithoutPropertiesLoose(); // node_modules/@mui/system/esm/index.js init_responsivePropType(); // node_modules/@mui/system/esm/Container/createContainer.js init_objectWithoutPropertiesLoose(); init_extends(); var React12 = __toESM(require_react()); var import_prop_types7 = __toESM(require_prop_types()); init_clsx(); init_generateUtilityClass(); init_composeClasses(); init_capitalize(); init_useThemeProps(); init_createTheme(); var import_jsx_runtime9 = __toESM(require_jsx_runtime()); var _excluded7 = ["className", "component", "disableGutters", "fixed", "maxWidth", "classes"]; var defaultTheme = createTheme_default(); var defaultCreateStyledComponent = styled_default("div", { name: "MuiContainer", slot: "Root", overridesResolver: (props, styles) => { const { ownerState } = props; return [styles.root, styles[`maxWidth${capitalize(String(ownerState.maxWidth))}`], ownerState.fixed && styles.fixed, ownerState.disableGutters && styles.disableGutters]; } }); var useThemePropsDefault = (inProps) => useThemeProps({ props: inProps, name: "MuiContainer", defaultTheme }); var useUtilityClasses = (ownerState, componentName) => { const getContainerUtilityClass = (slot) => { return generateUtilityClass(componentName, slot); }; const { classes, fixed, disableGutters, maxWidth } = ownerState; const slots = { root: ["root", maxWidth && `maxWidth${capitalize(String(maxWidth))}`, fixed && "fixed", disableGutters && "disableGutters"] }; return composeClasses(slots, getContainerUtilityClass, classes); }; function createContainer(options = {}) { const { // This will allow adding custom styled fn (for example for custom sx style function) createStyledComponent = defaultCreateStyledComponent, useThemeProps: useThemeProps2 = useThemePropsDefault, componentName = "MuiContainer" } = options; const ContainerRoot = createStyledComponent(({ theme, ownerState }) => _extends({ width: "100%", marginLeft: "auto", boxSizing: "border-box", marginRight: "auto", display: "block" }, !ownerState.disableGutters && { paddingLeft: theme.spacing(2), paddingRight: theme.spacing(2), // @ts-ignore module augmentation fails if custom breakpoints are used [theme.breakpoints.up("sm")]: { paddingLeft: theme.spacing(3), paddingRight: theme.spacing(3) } }), ({ theme, ownerState }) => ownerState.fixed && Object.keys(theme.breakpoints.values).reduce((acc, breakpointValueKey) => { const breakpoint = breakpointValueKey; const value = theme.breakpoints.values[breakpoint]; if (value !== 0) { acc[theme.breakpoints.up(breakpoint)] = { maxWidth: `${value}${theme.breakpoints.unit}` }; } return acc; }, {}), ({ theme, ownerState }) => _extends({}, ownerState.maxWidth === "xs" && { // @ts-ignore module augmentation fails if custom breakpoints are used [theme.breakpoints.up("xs")]: { // @ts-ignore module augmentation fails if custom breakpoints are used maxWidth: Math.max(theme.breakpoints.values.xs, 444) } }, ownerState.maxWidth && // @ts-ignore module augmentation fails if custom breakpoints are used ownerState.maxWidth !== "xs" && { // @ts-ignore module augmentation fails if custom breakpoints are used [theme.breakpoints.up(ownerState.maxWidth)]: { // @ts-ignore module augmentation fails if custom breakpoints are used maxWidth: `${theme.breakpoints.values[ownerState.maxWidth]}${theme.breakpoints.unit}` } })); const Container2 = React12.forwardRef(function Container3(inProps, ref) { const props = useThemeProps2(inProps); const { className, component = "div", disableGutters = false, fixed = false, maxWidth = "lg" } = props, other = _objectWithoutPropertiesLoose(props, _excluded7); const ownerState = _extends({}, props, { component, disableGutters, fixed, maxWidth }); const classes = useUtilityClasses(ownerState, componentName); return ( // @ts-ignore theme is injected by the styled util (0, import_jsx_runtime9.jsx)(ContainerRoot, _extends({ as: component, ownerState, className: clsx_default(classes.root, className), ref }, other)) ); }); true ? Container2.propTypes = { children: import_prop_types7.default.node, classes: import_prop_types7.default.object, className: import_prop_types7.default.string, component: import_prop_types7.default.elementType, disableGutters: import_prop_types7.default.bool, fixed: import_prop_types7.default.bool, maxWidth: import_prop_types7.default.oneOfType([import_prop_types7.default.oneOf(["xs", "sm", "md", "lg", "xl", false]), import_prop_types7.default.string]), sx: import_prop_types7.default.oneOfType([import_prop_types7.default.arrayOf(import_prop_types7.default.oneOfType([import_prop_types7.default.func, import_prop_types7.default.object, import_prop_types7.default.bool])), import_prop_types7.default.func, import_prop_types7.default.object]) } : void 0; return Container2; } // node_modules/@mui/system/esm/Container/Container.js var import_prop_types8 = __toESM(require_prop_types()); var Container = createContainer(); true ? Container.propTypes = { // ┌────────────────────────────── Warning ──────────────────────────────┐ // │ These PropTypes are generated from the TypeScript type definitions. │ // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │ // └─────────────────────────────────────────────────────────────────────┘ /** * @ignore */ children: import_prop_types8.default.node, /** * Override or extend the styles applied to the component. */ classes: import_prop_types8.default.object, /** * The component used for the root node. * Either a string to use a HTML element or a component. */ component: import_prop_types8.default.elementType, /** * If `true`, the left and right padding is removed. * @default false */ disableGutters: import_prop_types8.default.bool, /** * Set the max-width to match the min-width of the current breakpoint. * This is useful if you'd prefer to design for a fixed set of sizes * instead of trying to accommodate a fully fluid viewport. * It's fluid by default. * @default false */ fixed: import_prop_types8.default.bool, /** * Determine the max-width of the container. * The container width grows with the size of the screen. * Set to `false` to disable `maxWidth`. * @default 'lg' */ maxWidth: import_prop_types8.default.oneOfType([import_prop_types8.default.oneOf(["xs", "sm", "md", "lg", "xl", false]), import_prop_types8.default.string]), /** * The system prop that allows defining system overrides as well as additional CSS styles. */ sx: import_prop_types8.default.oneOfType([import_prop_types8.default.arrayOf(import_prop_types8.default.oneOfType([import_prop_types8.default.func, import_prop_types8.default.object, import_prop_types8.default.bool])), import_prop_types8.default.func, import_prop_types8.default.object]) } : void 0; // node_modules/@mui/system/esm/Container/containerClasses.js init_generateUtilityClasses(); init_generateUtilityClass(); var containerClasses = generateUtilityClasses("MuiContainer", ["root", "disableGutters", "fixed", "maxWidthXs", "maxWidthSm", "maxWidthMd", "maxWidthLg", "maxWidthXl"]); // node_modules/@mui/system/esm/Unstable_Grid/Grid.js var import_prop_types10 = __toESM(require_prop_types()); // node_modules/@mui/system/esm/Unstable_Grid/createGrid.js init_extends(); init_objectWithoutPropertiesLoose(); var React13 = __toESM(require_react()); var import_prop_types9 = __toESM(require_prop_types()); init_clsx(); init_isMuiElement(); init_generateUtilityClass(); init_composeClasses(); init_useThemeProps(); init_useTheme(); init_styleFunctionSx(); init_createTheme(); // node_modules/@mui/system/esm/Unstable_Grid/gridGenerator.js init_extends(); // node_modules/@mui/system/esm/Unstable_Grid/traverseBreakpoints.js var filterBreakpointKeys = (breakpointsKeys, responsiveKeys) => breakpointsKeys.filter((key) => responsiveKeys.includes(key)); var traverseBreakpoints = (breakpoints, responsive, iterator) => { const smallestBreakpoint = breakpoints.keys[0]; if (Array.isArray(responsive)) { responsive.forEach((breakpointValue, index) => { iterator((responsiveStyles, style2) => { if (index <= breakpoints.keys.length - 1) { if (index === 0) { Object.assign(responsiveStyles, style2); } else { responsiveStyles[breakpoints.up(breakpoints.keys[index])] = style2; } } }, breakpointValue); }); } else if (responsive && typeof responsive === "object") { const keys = Object.keys(responsive).length > breakpoints.keys.length ? breakpoints.keys : filterBreakpointKeys(breakpoints.keys, Object.keys(responsive)); keys.forEach((key) => { if (breakpoints.keys.indexOf(key) !== -1) { const breakpointValue = responsive[key]; if (breakpointValue !== void 0) { iterator((responsiveStyles, style2) => { if (smallestBreakpoint === key) { Object.assign(responsiveStyles, style2); } else { responsiveStyles[breakpoints.up(key)] = style2; } }, breakpointValue); } } }); } else if (typeof responsive === "number" || typeof responsive === "string") { iterator((responsiveStyles, style2) => { Object.assign(responsiveStyles, style2); }, responsive); } }; // node_modules/@mui/system/esm/Unstable_Grid/gridGenerator.js function appendLevel(level) { if (!level) { return ""; } return `Level${level}`; } function isNestedContainer(ownerState) { return ownerState.unstable_level > 0 && ownerState.container; } function createGetSelfSpacing(ownerState) { return function getSelfSpacing(axis) { return `var(--Grid-${axis}Spacing${appendLevel(ownerState.unstable_level)})`; }; } function createGetParentSpacing(ownerState) { return function getParentSpacing(axis) { if (ownerState.unstable_level === 0) { return `var(--Grid-${axis}Spacing)`; } return `var(--Grid-${axis}Spacing${appendLevel(ownerState.unstable_level - 1)})`; }; } function getParentColumns(ownerState) { if (ownerState.unstable_level === 0) { return `var(--Grid-columns)`; } return `var(--Grid-columns${appendLevel(ownerState.unstable_level - 1)})`; } var generateGridSizeStyles = ({ theme, ownerState }) => { const getSelfSpacing = createGetSelfSpacing(ownerState); const styles = {}; traverseBreakpoints(theme.breakpoints, ownerState.gridSize, (appendStyle, value) => { let style2 = {}; if (value === true) { style2 = { flexBasis: 0, flexGrow: 1, maxWidth: "100%" }; } if (value === "auto") { style2 = { flexBasis: "auto", flexGrow: 0, flexShrink: 0, maxWidth: "none", width: "auto" }; } if (typeof value === "number") { style2 = { flexGrow: 0, flexBasis: "auto", width: `calc(100% * ${value} / ${getParentColumns(ownerState)}${isNestedContainer(ownerState) ? ` + ${getSelfSpacing("column")}` : ""})` }; } appendStyle(styles, style2); }); return styles; }; var generateGridOffsetStyles = ({ theme, ownerState }) => { const styles = {}; traverseBreakpoints(theme.breakpoints, ownerState.gridOffset, (appendStyle, value) => { let style2 = {}; if (value === "auto") { style2 = { marginLeft: "auto" }; } if (typeof value === "number") { style2 = { marginLeft: value === 0 ? "0px" : `calc(100% * ${value} / ${getParentColumns(ownerState)})` }; } appendStyle(styles, style2); }); return styles; }; var generateGridColumnsStyles = ({ theme, ownerState }) => { if (!ownerState.container) { return {}; } const styles = isNestedContainer(ownerState) ? { [`--Grid-columns${appendLevel(ownerState.unstable_level)}`]: getParentColumns(ownerState) } : { "--Grid-columns": 12 }; traverseBreakpoints(theme.breakpoints, ownerState.columns, (appendStyle, value) => { appendStyle(styles, { [`--Grid-columns${appendLevel(ownerState.unstable_level)}`]: value }); }); return styles; }; var generateGridRowSpacingStyles = ({ theme, ownerState }) => { if (!ownerState.container) { return {}; } const getParentSpacing = createGetParentSpacing(ownerState); const styles = isNestedContainer(ownerState) ? { // Set the default spacing as its parent spacing. // It will be overridden if spacing props are provided [`--Grid-rowSpacing${appendLevel(ownerState.unstable_level)}`]: getParentSpacing("row") } : {}; traverseBreakpoints(theme.breakpoints, ownerState.rowSpacing, (appendStyle, value) => { var _theme$spacing; appendStyle(styles, { [`--Grid-rowSpacing${appendLevel(ownerState.unstable_level)}`]: typeof value === "string" ? value : (_theme$spacing = theme.spacing) == null ? void 0 : _theme$spacing.call(theme, value) }); }); return styles; }; var generateGridColumnSpacingStyles = ({ theme, ownerState }) => { if (!ownerState.container) { return {}; } const getParentSpacing = createGetParentSpacing(ownerState); const styles = isNestedContainer(ownerState) ? { // Set the default spacing as its parent spacing. // It will be overridden if spacing props are provided [`--Grid-columnSpacing${appendLevel(ownerState.unstable_level)}`]: getParentSpacing("column") } : {}; traverseBreakpoints(theme.breakpoints, ownerState.columnSpacing, (appendStyle, value) => { var _theme$spacing2; appendStyle(styles, { [`--Grid-columnSpacing${appendLevel(ownerState.unstable_level)}`]: typeof value === "string" ? value : (_theme$spacing2 = theme.spacing) == null ? void 0 : _theme$spacing2.call(theme, value) }); }); return styles; }; var generateGridDirectionStyles = ({ theme, ownerState }) => { if (!ownerState.container) { return {}; } const styles = {}; traverseBreakpoints(theme.breakpoints, ownerState.direction, (appendStyle, value) => { appendStyle(styles, { flexDirection: value }); }); return styles; }; var generateGridStyles = ({ ownerState }) => { const getSelfSpacing = createGetSelfSpacing(ownerState); const getParentSpacing = createGetParentSpacing(ownerState); return _extends({ minWidth: 0, boxSizing: "border-box" }, ownerState.container && _extends({ display: "flex", flexWrap: "wrap" }, ownerState.wrap && ownerState.wrap !== "wrap" && { flexWrap: ownerState.wrap }, { margin: `calc(${getSelfSpacing("row")} / -2) calc(${getSelfSpacing("column")} / -2)` }, ownerState.disableEqualOverflow && { margin: `calc(${getSelfSpacing("row")} * -1) 0px 0px calc(${getSelfSpacing("column")} * -1)` }), (!ownerState.container || isNestedContainer(ownerState)) && _extends({ padding: `calc(${getParentSpacing("row")} / 2) calc(${getParentSpacing("column")} / 2)` }, (ownerState.disableEqualOverflow || ownerState.parentDisableEqualOverflow) && { padding: `${getParentSpacing("row")} 0px 0px ${getParentSpacing("column")}` })); }; var generateSizeClassNames = (gridSize) => { const classNames = []; Object.entries(gridSize).forEach(([key, value]) => { if (value !== false && value !== void 0) { classNames.push(`grid-${key}-${String(value)}`); } }); return classNames; }; var generateSpacingClassNames = (spacing, smallestBreakpoint = "xs") => { function isValidSpacing(val) { if (val === void 0) { return false; } return typeof val === "string" && !Number.isNaN(Number(val)) || typeof val === "number" && val > 0; } if (isValidSpacing(spacing)) { return [`spacing-${smallestBreakpoint}-${String(spacing)}`]; } if (typeof spacing === "object" && !Array.isArray(spacing)) { const classNames = []; Object.entries(spacing).forEach(([key, value]) => { if (isValidSpacing(value)) { classNames.push(`spacing-${key}-${String(value)}`); } }); return classNames; } return []; }; var generateDirectionClasses = (direction) => { if (direction === void 0) { return []; } if (typeof direction === "object") { return Object.entries(direction).map(([key, value]) => `direction-${key}-${value}`); } return [`direction-xs-${String(direction)}`]; }; // node_modules/@mui/system/esm/Unstable_Grid/createGrid.js var import_jsx_runtime10 = __toESM(require_jsx_runtime()); var _excluded8 = ["className", "children", "columns", "container", "component", "direction", "wrap", "spacing", "rowSpacing", "columnSpacing", "disableEqualOverflow", "unstable_level"]; var defaultTheme2 = createTheme_default(); var defaultCreateStyledComponent2 = styled_default("div", { name: "MuiGrid", slot: "Root", overridesResolver: (props, styles) => styles.root }); function useThemePropsDefault2(props) { return useThemeProps({ props, name: "MuiGrid", defaultTheme: defaultTheme2 }); } function createGrid(options = {}) { const { // This will allow adding custom styled fn (for example for custom sx style function) createStyledComponent = defaultCreateStyledComponent2, useThemeProps: useThemeProps2 = useThemePropsDefault2, componentName = "MuiGrid" } = options; const GridOverflowContext = React13.createContext(void 0); if (true) { GridOverflowContext.displayName = "GridOverflowContext"; } const useUtilityClasses2 = (ownerState, theme) => { const { container, direction, spacing, wrap, gridSize } = ownerState; const slots = { root: ["root", container && "container", wrap !== "wrap" && `wrap-xs-${String(wrap)}`, ...generateDirectionClasses(direction), ...generateSizeClassNames(gridSize), ...container ? generateSpacingClassNames(spacing, theme.breakpoints.keys[0]) : []] }; return composeClasses(slots, (slot) => generateUtilityClass(componentName, slot), {}); }; const GridRoot = createStyledComponent(generateGridColumnsStyles, generateGridColumnSpacingStyles, generateGridRowSpacingStyles, generateGridSizeStyles, generateGridDirectionStyles, generateGridStyles, generateGridOffsetStyles); const Grid2 = React13.forwardRef(function Grid3(inProps, ref) { var _inProps$columns, _inProps$spacing, _ref, _inProps$rowSpacing, _ref2, _inProps$columnSpacin, _ref3, _disableEqualOverflow; const theme = useTheme_default(); const themeProps = useThemeProps2(inProps); const props = extendSxProp(themeProps); const overflow2 = React13.useContext(GridOverflowContext); const { className, children, columns: columnsProp = 12, container = false, component = "div", direction = "row", wrap = "wrap", spacing: spacingProp = 0, rowSpacing: rowSpacingProp = spacingProp, columnSpacing: columnSpacingProp = spacingProp, disableEqualOverflow: themeDisableEqualOverflow, unstable_level: level = 0 } = props, rest = _objectWithoutPropertiesLoose(props, _excluded8); let disableEqualOverflow = themeDisableEqualOverflow; if (level && themeDisableEqualOverflow !== void 0) { disableEqualOverflow = inProps.disableEqualOverflow; } const gridSize = {}; const gridOffset = {}; const other = {}; Object.entries(rest).forEach(([key, val]) => { if (theme.breakpoints.values[key] !== void 0) { gridSize[key] = val; } else if (theme.breakpoints.values[key.replace("Offset", "")] !== void 0) { gridOffset[key.replace("Offset", "")] = val; } else { other[key] = val; } }); const columns = (_inProps$columns = inProps.columns) != null ? _inProps$columns : level ? void 0 : columnsProp; const spacing = (_inProps$spacing = inProps.spacing) != null ? _inProps$spacing : level ? void 0 : spacingProp; const rowSpacing = (_ref = (_inProps$rowSpacing = inProps.rowSpacing) != null ? _inProps$rowSpacing : inProps.spacing) != null ? _ref : level ? void 0 : rowSpacingProp; const columnSpacing = (_ref2 = (_inProps$columnSpacin = inProps.columnSpacing) != null ? _inProps$columnSpacin : inProps.spacing) != null ? _ref2 : level ? void 0 : columnSpacingProp; const ownerState = _extends({}, props, { level, columns, container, direction, wrap, spacing, rowSpacing, columnSpacing, gridSize, gridOffset, disableEqualOverflow: (_ref3 = (_disableEqualOverflow = disableEqualOverflow) != null ? _disableEqualOverflow : overflow2) != null ? _ref3 : false, // use context value if exists. parentDisableEqualOverflow: overflow2 // for nested grid }); const classes = useUtilityClasses2(ownerState, theme); let result = (0, import_jsx_runtime10.jsx)(GridRoot, _extends({ ref, as: component, ownerState, className: clsx_default(classes.root, className) }, other, { children: React13.Children.map(children, (child) => { if (React13.isValidElement(child) && isMuiElement(child, ["Grid"])) { var _child$props$unstable; return React13.cloneElement(child, { unstable_level: (_child$props$unstable = child.props.unstable_level) != null ? _child$props$unstable : level + 1 }); } return child; }) })); if (disableEqualOverflow !== void 0 && disableEqualOverflow !== (overflow2 != null ? overflow2 : false)) { result = (0, import_jsx_runtime10.jsx)(GridOverflowContext.Provider, { value: disableEqualOverflow, children: result }); } return result; }); true ? Grid2.propTypes = { children: import_prop_types9.default.node, className: import_prop_types9.default.string, columns: import_prop_types9.default.oneOfType([import_prop_types9.default.arrayOf(import_prop_types9.default.number), import_prop_types9.default.number, import_prop_types9.default.object]), columnSpacing: import_prop_types9.default.oneOfType([import_prop_types9.default.arrayOf(import_prop_types9.default.oneOfType([import_prop_types9.default.number, import_prop_types9.default.string])), import_prop_types9.default.number, import_prop_types9.default.object, import_prop_types9.default.string]), component: import_prop_types9.default.elementType, container: import_prop_types9.default.bool, direction: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["column-reverse", "column", "row-reverse", "row"]), import_prop_types9.default.arrayOf(import_prop_types9.default.oneOf(["column-reverse", "column", "row-reverse", "row"])), import_prop_types9.default.object]), disableEqualOverflow: import_prop_types9.default.bool, lg: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number, import_prop_types9.default.bool]), lgOffset: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number]), md: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number, import_prop_types9.default.bool]), mdOffset: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number]), rowSpacing: import_prop_types9.default.oneOfType([import_prop_types9.default.arrayOf(import_prop_types9.default.oneOfType([import_prop_types9.default.number, import_prop_types9.default.string])), import_prop_types9.default.number, import_prop_types9.default.object, import_prop_types9.default.string]), sm: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number, import_prop_types9.default.bool]), smOffset: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number]), spacing: import_prop_types9.default.oneOfType([import_prop_types9.default.arrayOf(import_prop_types9.default.oneOfType([import_prop_types9.default.number, import_prop_types9.default.string])), import_prop_types9.default.number, import_prop_types9.default.object, import_prop_types9.default.string]), sx: import_prop_types9.default.oneOfType([import_prop_types9.default.arrayOf(import_prop_types9.default.oneOfType([import_prop_types9.default.func, import_prop_types9.default.object, import_prop_types9.default.bool])), import_prop_types9.default.func, import_prop_types9.default.object]), wrap: import_prop_types9.default.oneOf(["nowrap", "wrap-reverse", "wrap"]), xl: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number, import_prop_types9.default.bool]), xlOffset: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number]), xs: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number, import_prop_types9.default.bool]), xsOffset: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["auto"]), import_prop_types9.default.number]) } : void 0; Grid2.muiName = "Grid"; return Grid2; } // node_modules/@mui/system/esm/Unstable_Grid/Grid.js var Grid = createGrid(); true ? Grid.propTypes = { // ┌────────────────────────────── Warning ──────────────────────────────┐ // │ These PropTypes are generated from the TypeScript type definitions. │ // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │ // └─────────────────────────────────────────────────────────────────────┘ /** * The content of the component. */ children: import_prop_types10.default.node, /** * The number of columns. * @default 12 */ columns: import_prop_types10.default.oneOfType([import_prop_types10.default.arrayOf(import_prop_types10.default.number), import_prop_types10.default.number, import_prop_types10.default.object]), /** * Defines the horizontal space between the type `item` components. * It overrides the value of the `spacing` prop. */ columnSpacing: import_prop_types10.default.oneOfType([import_prop_types10.default.arrayOf(import_prop_types10.default.oneOfType([import_prop_types10.default.number, import_prop_types10.default.string])), import_prop_types10.default.number, import_prop_types10.default.object, import_prop_types10.default.string]), /** * If `true`, the component will have the flex *container* behavior. * You should be wrapping *items* with a *container*. * @default false */ container: import_prop_types10.default.bool, /** * Defines the `flex-direction` style property. * It is applied for all screen sizes. * @default 'row' */ direction: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["column-reverse", "column", "row-reverse", "row"]), import_prop_types10.default.arrayOf(import_prop_types10.default.oneOf(["column-reverse", "column", "row-reverse", "row"])), import_prop_types10.default.object]), /** * If `true`, the negative margin and padding are apply only to the top and left sides of the grid. */ disableEqualOverflow: import_prop_types10.default.bool, /** * If a number, it sets the number of columns the grid item uses. * It can't be greater than the total number of columns of the container (12 by default). * If 'auto', the grid item's width matches its content. * If false, the prop is ignored. * If true, the grid item's width grows to use the space available in the grid container. * The value is applied for the `lg` breakpoint and wider screens if not overridden. * @default false */ lg: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number, import_prop_types10.default.bool]), /** * If a number, it sets the margin-left equals to the number of columns the grid item uses. * If 'auto', the grid item push itself to the right-end of the container. * The value is applied for the `lg` breakpoint and wider screens if not overridden. */ lgOffset: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number]), /** * If a number, it sets the number of columns the grid item uses. * It can't be greater than the total number of columns of the container (12 by default). * If 'auto', the grid item's width matches its content. * If false, the prop is ignored. * If true, the grid item's width grows to use the space available in the grid container. * The value is applied for the `md` breakpoint and wider screens if not overridden. * @default false */ md: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number, import_prop_types10.default.bool]), /** * If a number, it sets the margin-left equals to the number of columns the grid item uses. * If 'auto', the grid item push itself to the right-end of the container. * The value is applied for the `md` breakpoint and wider screens if not overridden. */ mdOffset: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number]), /** * Defines the vertical space between the type `item` components. * It overrides the value of the `spacing` prop. */ rowSpacing: import_prop_types10.default.oneOfType([import_prop_types10.default.arrayOf(import_prop_types10.default.oneOfType([import_prop_types10.default.number, import_prop_types10.default.string])), import_prop_types10.default.number, import_prop_types10.default.object, import_prop_types10.default.string]), /** * If a number, it sets the number of columns the grid item uses. * It can't be greater than the total number of columns of the container (12 by default). * If 'auto', the grid item's width matches its content. * If false, the prop is ignored. * If true, the grid item's width grows to use the space available in the grid container. * The value is applied for the `sm` breakpoint and wider screens if not overridden. * @default false */ sm: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number, import_prop_types10.default.bool]), /** * If a number, it sets the margin-left equals to the number of columns the grid item uses. * If 'auto', the grid item push itself to the right-end of the container. * The value is applied for the `sm` breakpoint and wider screens if not overridden. */ smOffset: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number]), /** * Defines the space between the type `item` components. * It can only be used on a type `container` component. * @default 0 */ spacing: import_prop_types10.default.oneOfType([import_prop_types10.default.arrayOf(import_prop_types10.default.oneOfType([import_prop_types10.default.number, import_prop_types10.default.string])), import_prop_types10.default.number, import_prop_types10.default.object, import_prop_types10.default.string]), /** * @ignore */ sx: import_prop_types10.default.oneOfType([import_prop_types10.default.arrayOf(import_prop_types10.default.oneOfType([import_prop_types10.default.func, import_prop_types10.default.object, import_prop_types10.default.bool])), import_prop_types10.default.func, import_prop_types10.default.object]), /** * @internal * The level of the grid starts from `0` * and increases when the grid nests inside another grid regardless of container or item. * * ```js * // level 0 * // level 1 * // level 2 * // level 1 * ``` * * Only consecutive grid is considered nesting. * A grid container will start at `0` if there are non-Grid element above it. * * ```js * // level 0 *
* // level 0 * // level 1 * ``` */ unstable_level: import_prop_types10.default.number, /** * Defines the `flex-wrap` style property. * It's applied for all screen sizes. * @default 'wrap' */ wrap: import_prop_types10.default.oneOf(["nowrap", "wrap-reverse", "wrap"]), /** * If a number, it sets the number of columns the grid item uses. * It can't be greater than the total number of columns of the container (12 by default). * If 'auto', the grid item's width matches its content. * If false, the prop is ignored. * If true, the grid item's width grows to use the space available in the grid container. * The value is applied for the `xl` breakpoint and wider screens if not overridden. * @default false */ xl: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number, import_prop_types10.default.bool]), /** * If a number, it sets the margin-left equals to the number of columns the grid item uses. * If 'auto', the grid item push itself to the right-end of the container. * The value is applied for the `xl` breakpoint and wider screens if not overridden. */ xlOffset: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number]), /** * If a number, it sets the number of columns the grid item uses. * It can't be greater than the total number of columns of the container (12 by default). * If 'auto', the grid item's width matches its content. * If false, the prop is ignored. * If true, the grid item's width grows to use the space available in the grid container. * The value is applied for all the screen sizes with the lowest priority. * @default false */ xs: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number, import_prop_types10.default.bool]), /** * If a number, it sets the margin-left equals to the number of columns the grid item uses. * If 'auto', the grid item push itself to the right-end of the container. * The value is applied for the `xs` breakpoint and wider screens if not overridden. */ xsOffset: import_prop_types10.default.oneOfType([import_prop_types10.default.oneOf(["auto"]), import_prop_types10.default.number]) } : void 0; // node_modules/@mui/system/esm/Unstable_Grid/gridClasses.js init_generateUtilityClasses(); init_generateUtilityClass(); var SPACINGS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var DIRECTIONS = ["column-reverse", "column", "row-reverse", "row"]; var WRAPS = ["nowrap", "wrap-reverse", "wrap"]; var GRID_SIZES = ["auto", true, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; var gridClasses = generateUtilityClasses("MuiGrid", [ "root", "container", "item", // spacings ...SPACINGS.map((spacing) => `spacing-xs-${spacing}`), // direction values ...DIRECTIONS.map((direction) => `direction-xs-${direction}`), // wrap values ...WRAPS.map((wrap) => `wrap-xs-${wrap}`), // grid sizes for all breakpoints ...GRID_SIZES.map((size) => `grid-xs-${size}`), ...GRID_SIZES.map((size) => `grid-sm-${size}`), ...GRID_SIZES.map((size) => `grid-md-${size}`), ...GRID_SIZES.map((size) => `grid-lg-${size}`), ...GRID_SIZES.map((size) => `grid-xl-${size}`) ]); // node_modules/@mui/system/esm/Stack/Stack.js var import_prop_types12 = __toESM(require_prop_types()); // node_modules/@mui/system/esm/Stack/createStack.js init_objectWithoutPropertiesLoose(); init_extends(); var React14 = __toESM(require_react()); var import_prop_types11 = __toESM(require_prop_types()); init_clsx(); init_deepmerge(); init_generateUtilityClass(); init_composeClasses(); init_useThemeProps(); init_styleFunctionSx(); init_createTheme(); init_breakpoints(); init_spacing(); var import_jsx_runtime11 = __toESM(require_jsx_runtime()); var _excluded9 = ["component", "direction", "spacing", "divider", "children", "className", "useFlexGap"]; var defaultTheme3 = createTheme_default(); var defaultCreateStyledComponent3 = styled_default("div", { name: "MuiStack", slot: "Root", overridesResolver: (props, styles) => styles.root }); function useThemePropsDefault3(props) { return useThemeProps({ props, name: "MuiStack", defaultTheme: defaultTheme3 }); } function joinChildren(children, separator) { const childrenArray = React14.Children.toArray(children).filter(Boolean); return childrenArray.reduce((output, child, index) => { output.push(child); if (index < childrenArray.length - 1) { output.push(React14.cloneElement(separator, { key: `separator-${index}` })); } return output; }, []); } var getSideFromDirection = (direction) => { return { row: "Left", "row-reverse": "Right", column: "Top", "column-reverse": "Bottom" }[direction]; }; var style = ({ ownerState, theme }) => { let styles = _extends({ display: "flex", flexDirection: "column" }, handleBreakpoints({ theme }, resolveBreakpointValues({ values: ownerState.direction, breakpoints: theme.breakpoints.values }), (propValue) => ({ flexDirection: propValue }))); if (ownerState.spacing) { const transformer = createUnarySpacing(theme); const base = Object.keys(theme.breakpoints.values).reduce((acc, breakpoint) => { if (typeof ownerState.spacing === "object" && ownerState.spacing[breakpoint] != null || typeof ownerState.direction === "object" && ownerState.direction[breakpoint] != null) { acc[breakpoint] = true; } return acc; }, {}); const directionValues = resolveBreakpointValues({ values: ownerState.direction, base }); const spacingValues = resolveBreakpointValues({ values: ownerState.spacing, base }); if (typeof directionValues === "object") { Object.keys(directionValues).forEach((breakpoint, index, breakpoints) => { const directionValue = directionValues[breakpoint]; if (!directionValue) { const previousDirectionValue = index > 0 ? directionValues[breakpoints[index - 1]] : "column"; directionValues[breakpoint] = previousDirectionValue; } }); } const styleFromPropValue = (propValue, breakpoint) => { if (ownerState.useFlexGap) { return { gap: getValue(transformer, propValue) }; } return { // The useFlexGap={false} implement relies on each child to give up control of the margin. // We need to reset the margin to avoid double spacing. "& > :not(style):not(style)": { margin: 0 }, "& > :not(style) ~ :not(style)": { [`margin${getSideFromDirection(breakpoint ? directionValues[breakpoint] : ownerState.direction)}`]: getValue(transformer, propValue) } }; }; styles = deepmerge(styles, handleBreakpoints({ theme }, spacingValues, styleFromPropValue)); } styles = mergeBreakpointsInOrder(theme.breakpoints, styles); return styles; }; function createStack(options = {}) { const { // This will allow adding custom styled fn (for example for custom sx style function) createStyledComponent = defaultCreateStyledComponent3, useThemeProps: useThemeProps2 = useThemePropsDefault3, componentName = "MuiStack" } = options; const useUtilityClasses2 = () => { const slots = { root: ["root"] }; return composeClasses(slots, (slot) => generateUtilityClass(componentName, slot), {}); }; const StackRoot = createStyledComponent(style); const Stack2 = React14.forwardRef(function Grid2(inProps, ref) { const themeProps = useThemeProps2(inProps); const props = extendSxProp(themeProps); const { component = "div", direction = "column", spacing = 0, divider, children, className, useFlexGap = false } = props, other = _objectWithoutPropertiesLoose(props, _excluded9); const ownerState = { direction, spacing, useFlexGap }; const classes = useUtilityClasses2(); return (0, import_jsx_runtime11.jsx)(StackRoot, _extends({ as: component, ownerState, ref, className: clsx_default(classes.root, className) }, other, { children: divider ? joinChildren(children, divider) : children })); }); true ? Stack2.propTypes = { children: import_prop_types11.default.node, direction: import_prop_types11.default.oneOfType([import_prop_types11.default.oneOf(["column-reverse", "column", "row-reverse", "row"]), import_prop_types11.default.arrayOf(import_prop_types11.default.oneOf(["column-reverse", "column", "row-reverse", "row"])), import_prop_types11.default.object]), divider: import_prop_types11.default.node, spacing: import_prop_types11.default.oneOfType([import_prop_types11.default.arrayOf(import_prop_types11.default.oneOfType([import_prop_types11.default.number, import_prop_types11.default.string])), import_prop_types11.default.number, import_prop_types11.default.object, import_prop_types11.default.string]), sx: import_prop_types11.default.oneOfType([import_prop_types11.default.arrayOf(import_prop_types11.default.oneOfType([import_prop_types11.default.func, import_prop_types11.default.object, import_prop_types11.default.bool])), import_prop_types11.default.func, import_prop_types11.default.object]) } : void 0; return Stack2; } // node_modules/@mui/system/esm/Stack/Stack.js var Stack = createStack(); true ? Stack.propTypes = { // ┌────────────────────────────── Warning ──────────────────────────────┐ // │ These PropTypes are generated from the TypeScript type definitions. │ // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │ // └─────────────────────────────────────────────────────────────────────┘ /** * The content of the component. */ children: import_prop_types12.default.node, /** * The component used for the root node. * Either a string to use a HTML element or a component. */ component: import_prop_types12.default.elementType, /** * Defines the `flex-direction` style property. * It is applied for all screen sizes. * @default 'column' */ direction: import_prop_types12.default.oneOfType([import_prop_types12.default.oneOf(["column-reverse", "column", "row-reverse", "row"]), import_prop_types12.default.arrayOf(import_prop_types12.default.oneOf(["column-reverse", "column", "row-reverse", "row"])), import_prop_types12.default.object]), /** * Add an element between each child. */ divider: import_prop_types12.default.node, /** * Defines the space between immediate children. * @default 0 */ spacing: import_prop_types12.default.oneOfType([import_prop_types12.default.arrayOf(import_prop_types12.default.oneOfType([import_prop_types12.default.number, import_prop_types12.default.string])), import_prop_types12.default.number, import_prop_types12.default.object, import_prop_types12.default.string]), /** * The system prop, which allows defining system overrides as well as additional CSS styles. */ sx: import_prop_types12.default.oneOfType([import_prop_types12.default.arrayOf(import_prop_types12.default.oneOfType([import_prop_types12.default.func, import_prop_types12.default.object, import_prop_types12.default.bool])), import_prop_types12.default.func, import_prop_types12.default.object]), /** * If `true`, the CSS flexbox `gap` is used instead of applying `margin` to children. * * While CSS `gap` removes the [known limitations](https://mui.com/joy-ui/react-stack/#limitations), * it is not fully supported in some browsers. We recommend checking https://caniuse.com/?search=flex%20gap before using this flag. * * To enable this flag globally, follow the theme's default props configuration. * @default false */ useFlexGap: import_prop_types12.default.bool } : void 0; // node_modules/@mui/system/esm/Stack/stackClasses.js init_generateUtilityClasses(); init_generateUtilityClass(); var stackClasses = generateUtilityClasses("MuiStack", ["root"]); export { GlobalStyles_default, createBox, useMediaQuery, hexToRgb, decomposeColor, recomposeColor, rgbToHex, hslToRgb, getLuminance, getContrastRatio, alpha, darken, lighten, emphasize, useRtl, ThemeProvider_default2 as ThemeProvider_default, createCssVarsProvider, createGetCssVar, prepareCssVars_default, createContainer, createGrid, createStack }; /*! Bundled license information: @mui/private-theming/index.js: (** * @mui/private-theming v5.15.13 * * @license MIT * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. *) */ //# sourceMappingURL=chunk-CYFOGIOB.js.map