Techognito/react-playground
SHA256
1
0
Fork 0
Code Issues Activity

worked on GarageApp stuff

Browse source
This commit is contained in:
Techognito 2025-08-25 17:46:11 +02:00
parent 60aaf17af3
commit eb606572b0
51919 changed files with 2168177 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

76
node_modules/@mui/material/styles/ThemeProvider.d.ts generated vendored Normal file
View file

@ -0,0 +1,76 @@
import * as React from 'react';
import { DefaultTheme } from '@mui/system';
import { StorageManager } from '@mui/system/cssVars';
import { CssThemeVariables } from "./createThemeNoVars.js";
type ThemeProviderCssVariablesProps = CssThemeVariables extends {
enabled: true;
} ? {
/**
* The node for attaching the `theme.colorSchemeSelector`.
* @default document
*/
colorSchemeNode?: Element | null;
/**
* If `true`, the provider creates its own context and generate stylesheet as if it is a root `ThemeProvider`.
*/
disableNestedContext?: boolean;
/**
* If `true`, the style sheet for CSS theme variables won't be generated.
*
* This is useful for controlling nested ThemeProvider behavior.
* @default false
*/
disableStyleSheetGeneration?: boolean;
/**
* If `true`, theme values are recalculated when the mode changes.
* The `theme.colorSchemes.{mode}.*` nodes will be shallow merged to the top-level of the theme.
* @default false
*/
forceThemeRerender?: boolean;
} : {};
export interface ThemeProviderProps<Theme = DefaultTheme> extends ThemeProviderCssVariablesProps {
children?: React.ReactNode;
theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
/**
* The document used to perform `disableTransitionOnChange` feature
* @default document
*/
documentNode?: Document | null;
/**
* The default mode when the local storage has no mode yet,
* requires the theme to have `colorSchemes` with light and dark.
* @default 'system'
*/
defaultMode?: 'light' | 'dark' | 'system';
/**
* The window that attaches the 'storage' event listener
* @default window
*/
storageWindow?: Window | null;
/**
* The storage manager to be used for storing the mode and color scheme
* @default using `window.localStorage`
*/
storageManager?: StorageManager | null;
/**
* localStorage key used to store application `mode`
* @default 'mui-mode'
*/
modeStorageKey?: string;
/**
* localStorage key used to store `colorScheme`
* @default 'mui-color-scheme'
*/
colorSchemeStorageKey?: string;
noSsr?: boolean;
/**
* Disable CSS transitions when switching between modes or color schemes
* @default false
*/
disableTransitionOnChange?: boolean;
}
export default function ThemeProvider<Theme = DefaultTheme>({
theme,
...props
}: ThemeProviderProps<Theme>): React.JSX.Element;
export {};

47
node_modules/@mui/material/styles/ThemeProvider.js generated vendored Normal file
View file

@ -0,0 +1,47 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = ThemeProvider;
var React = _interopRequireWildcard(require("react"));
var _ThemeProviderNoVars = _interopRequireDefault(require("./ThemeProviderNoVars"));
var _ThemeProviderWithVars = require("./ThemeProviderWithVars");
var _identifier = _interopRequireDefault(require("./identifier"));
var _jsxRuntime = require("react/jsx-runtime");
function ThemeProvider({
theme,
...props
}) {
const noVarsTheme = React.useMemo(() => {
if (typeof theme === 'function') {
return theme;
}
const muiTheme = _identifier.default in theme ? theme[_identifier.default] : theme;
if (!('colorSchemes' in muiTheme)) {
if (!('vars' in muiTheme)) {
// For non-CSS variables themes, set `vars` to null to prevent theme inheritance from the upper theme.
// The example use case is the docs demo that uses ThemeProvider to customize the theme while the upper theme is using CSS variables.
return {
...theme,
vars: null
};
}
return theme;
}
return null;
}, [theme]);
if (noVarsTheme) {
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ThemeProviderNoVars.default, {
theme: noVarsTheme,
...props
});
}
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ThemeProviderWithVars.CssVarsProvider, {
theme: theme,
...props
});
}

10
node_modules/@mui/material/styles/ThemeProviderNoVars.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import * as React from 'react';
import { DefaultTheme } from '@mui/system';
export interface ThemeProviderNoVarsProps<Theme = DefaultTheme> {
children?: React.ReactNode;
theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
}
export default function ThemeProviderNoVars<Theme = DefaultTheme>({
theme: themeInput,
...props
}: ThemeProviderNoVarsProps<Theme>): React.ReactElement<ThemeProviderNoVarsProps<Theme>>;

24
node_modules/@mui/material/styles/ThemeProviderNoVars.js generated vendored Normal file
View file

@ -0,0 +1,24 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = ThemeProviderNoVars;
var React = _interopRequireWildcard(require("react"));
var _system = require("@mui/system");
var _identifier = _interopRequireDefault(require("./identifier"));
var _jsxRuntime = require("react/jsx-runtime");
function ThemeProviderNoVars({
theme: themeInput,
...props
}) {
const scopedTheme = _identifier.default in themeInput ? themeInput[_identifier.default] : undefined;
return /*#__PURE__*/(0, _jsxRuntime.jsx)(_system.ThemeProvider, {
...props,
themeId: scopedTheme ? _identifier.default : undefined,
theme: scopedTheme || themeInput
});
}

51
node_modules/@mui/material/styles/ThemeProviderWithVars.d.ts generated vendored Normal file
View file

@ -0,0 +1,51 @@
import * as React from 'react';
import { SupportedColorScheme } from "./createThemeWithVars.js";
declare const useColorScheme: () => import("@mui/system").ColorSchemeContextValue<SupportedColorScheme>, deprecatedGetInitColorSchemeScript: typeof import("@mui/system/InitColorSchemeScript").default;
declare function Experimental_CssVarsProvider(props: any): React.JSX.Element;
declare const getInitColorSchemeScript: typeof deprecatedGetInitColorSchemeScript;
/**
* TODO: remove this export in v7
* @deprecated
* The `CssVarsProvider` component has been deprecated and ported into `ThemeProvider`.
*
* You should use `ThemeProvider` and `createTheme()` instead:
*
* ```diff
* - import { CssVarsProvider, extendTheme } from '@mui/material/styles';
* + import { ThemeProvider, createTheme } from '@mui/material/styles';
*
* - const theme = extendTheme();
* + const theme = createTheme({
* + cssVariables: true,
* + colorSchemes: { light: true, dark: true },
* + });
*
* - <CssVarsProvider theme={theme}>
* + <ThemeProvider theme={theme}>
* ```
*
* To see the full documentation, check out https://mui.com/material-ui/customization/css-theme-variables/usage/.
*/
export declare const CssVarsProvider: (props: React.PropsWithChildren<Partial<import("@mui/system").CssVarsProviderConfig<SupportedColorScheme>> & {
theme?: {
cssVariables?: false;
cssVarPrefix?: string;
colorSchemes: Partial<Record<SupportedColorScheme, any>>;
colorSchemeSelector?: "media" | "class" | "data" | string;
} | {
$$material: {
cssVariables?: false;
cssVarPrefix?: string;
colorSchemes: Partial<Record<SupportedColorScheme, any>>;
colorSchemeSelector?: "media" | "class" | "data" | string;
};
} | undefined;
defaultMode?: "light" | "dark" | "system";
documentNode?: Document | null;
colorSchemeNode?: Element | null;
storageManager?: import("@mui/system").StorageManager | null;
storageWindow?: Window | null;
disableNestedContext?: boolean;
disableStyleSheetGeneration?: boolean;
}>) => React.JSX.Element;
export { useColorScheme, getInitColorSchemeScript, Experimental_CssVarsProvider };

101
node_modules/@mui/material/styles/ThemeProviderWithVars.js generated vendored Normal file
View file

@ -0,0 +1,101 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.CssVarsProvider = void 0;
exports.Experimental_CssVarsProvider = Experimental_CssVarsProvider;
exports.useColorScheme = exports.getInitColorSchemeScript = void 0;
var React = _interopRequireWildcard(require("react"));
var _styleFunctionSx = _interopRequireDefault(require("@mui/system/styleFunctionSx"));
var _system = require("@mui/system");
var _createTheme = _interopRequireDefault(require("./createTheme"));
var _createTypography = _interopRequireDefault(require("./createTypography"));
var _identifier = _interopRequireDefault(require("./identifier"));
var _InitColorSchemeScript = require("../InitColorSchemeScript/InitColorSchemeScript");
var _jsxRuntime = require("react/jsx-runtime");
const {
CssVarsProvider: InternalCssVarsProvider,
useColorScheme,
getInitColorSchemeScript: deprecatedGetInitColorSchemeScript
} = (0, _system.unstable_createCssVarsProvider)({
themeId: _identifier.default,
// @ts-ignore ignore module augmentation tests
theme: () => (0, _createTheme.default)({
cssVariables: true
}),
colorSchemeStorageKey: _InitColorSchemeScript.defaultConfig.colorSchemeStorageKey,
modeStorageKey: _InitColorSchemeScript.defaultConfig.modeStorageKey,
defaultColorScheme: {
light: _InitColorSchemeScript.defaultConfig.defaultLightColorScheme,
dark: _InitColorSchemeScript.defaultConfig.defaultDarkColorScheme
},
resolveTheme: theme => {
const newTheme = {
...theme,
typography: (0, _createTypography.default)(theme.palette, theme.typography)
};
newTheme.unstable_sx = function sx(props) {
return (0, _styleFunctionSx.default)({
sx: props,
theme: this
});
};
return newTheme;
}
});
exports.useColorScheme = useColorScheme;
let warnedOnce = false;
// TODO: remove in v7
// eslint-disable-next-line @typescript-eslint/naming-convention
function Experimental_CssVarsProvider(props) {
if (process.env.NODE_ENV !== 'production') {
if (!warnedOnce) {
console.warn(['MUI: The Experimental_CssVarsProvider component has been ported into ThemeProvider.', '', "You should use `import { ThemeProvider } from '@mui/material/styles'` instead.", 'For more details, check out https://mui.com/material-ui/customization/css-theme-variables/usage/'].join('\n'));
warnedOnce = true;
}
}
return /*#__PURE__*/(0, _jsxRuntime.jsx)(InternalCssVarsProvider, {
...props
});
}
let warnedInitScriptOnce = false;
// TODO: remove in v7
const getInitColorSchemeScript = params => {
if (!warnedInitScriptOnce) {
console.warn(['MUI: The getInitColorSchemeScript function has been deprecated.', '', "You should use `import InitColorSchemeScript from '@mui/material/InitColorSchemeScript'`", 'and replace the function call with `<InitColorSchemeScript />` instead.'].join('\n'));
warnedInitScriptOnce = true;
}
return deprecatedGetInitColorSchemeScript(params);
};
/**
* TODO: remove this export in v7
* @deprecated
* The `CssVarsProvider` component has been deprecated and ported into `ThemeProvider`.
*
* You should use `ThemeProvider` and `createTheme()` instead:
*
* ```diff
* - import { CssVarsProvider, extendTheme } from '@mui/material/styles';
* + import { ThemeProvider, createTheme } from '@mui/material/styles';
*
* - const theme = extendTheme();
* + const theme = createTheme({
* + cssVariables: true,
* + colorSchemes: { light: true, dark: true },
* + });
*
* - <CssVarsProvider theme={theme}>
* + <ThemeProvider theme={theme}>
* ```
*
* To see the full documentation, check out https://mui.com/material-ui/customization/css-theme-variables/usage/.
*/
exports.getInitColorSchemeScript = getInitColorSchemeScript;
const CssVarsProvider = exports.CssVarsProvider = InternalCssVarsProvider;

36
node_modules/@mui/material/styles/adaptV4Theme.d.ts generated vendored Normal file
View file

@ -0,0 +1,36 @@
import { BreakpointsOptions, ShapeOptions, SpacingOptions } from '@mui/system';
import { MixinsOptions } from "./createMixins.js";
import { Palette, PaletteOptions } from "./createPalette.js";
import { TypographyVariantsOptions } from "./createTypography.js";
import { Shadows } from "./shadows.js";
import { TransitionsOptions } from "./createTransitions.js";
import { ZIndexOptions } from "./zIndex.js";
import { ComponentsOverrides } from "./overrides.js";
import { ComponentsVariants } from "./variants.js";
import { ComponentsProps } from "./props.js";
import { Theme } from "./createTheme.js";
export type Direction = 'ltr' | 'rtl';
export interface DeprecatedThemeOptions {
shape?: ShapeOptions;
breakpoints?: BreakpointsOptions;
direction?: Direction;
mixins?: MixinsOptions;
overrides?: ComponentsOverrides;
palette?: PaletteOptions;
props?: ComponentsProps;
shadows?: Shadows;
spacing?: SpacingOptions;
transitions?: TransitionsOptions;
typography?: TypographyVariantsOptions | ((palette: Palette) => TypographyVariantsOptions);
variants?: ComponentsVariants;
zIndex?: ZIndexOptions;
unstable_strictMode?: boolean;
}
/**
* Generate a theme base on the V4 theme options received.
* @deprecated Follow the upgrade guide on https://mui.com/r/migration-v4#theme
* @param options Takes an incomplete theme object and adds the missing parts.
* @returns A complete, ready-to-use theme object.
*/
export default function adaptV4Theme(options?: DeprecatedThemeOptions): Theme;

88
node_modules/@mui/material/styles/adaptV4Theme.js generated vendored Normal file
View file

@ -0,0 +1,88 @@
"use strict";
'use client';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = adaptV4Theme;
var _system = require("@mui/system");
function adaptV4Theme(inputTheme) {
if (process.env.NODE_ENV !== 'production') {
console.warn(['MUI: adaptV4Theme() is deprecated.', 'Follow the upgrade guide on https://mui.com/r/migration-v4#theme.'].join('\n'));
}
const {
defaultProps = {},
mixins = {},
overrides = {},
palette = {},
props = {},
styleOverrides = {},
...other
} = inputTheme;
const theme = {
...other,
components: {}
};
// default props
Object.keys(defaultProps).forEach(component => {
const componentValue = theme.components[component] || {};
componentValue.defaultProps = defaultProps[component];
theme.components[component] = componentValue;
});
Object.keys(props).forEach(component => {
const componentValue = theme.components[component] || {};
componentValue.defaultProps = props[component];
theme.components[component] = componentValue;
});
// CSS overrides
Object.keys(styleOverrides).forEach(component => {
const componentValue = theme.components[component] || {};
componentValue.styleOverrides = styleOverrides[component];
theme.components[component] = componentValue;
});
Object.keys(overrides).forEach(component => {
const componentValue = theme.components[component] || {};
componentValue.styleOverrides = overrides[component];
theme.components[component] = componentValue;
});
// theme.spacing
theme.spacing = (0, _system.createSpacing)(inputTheme.spacing);
// theme.mixins.gutters
const breakpoints = (0, _system.createBreakpoints)(inputTheme.breakpoints || {});
const spacing = theme.spacing;
theme.mixins = {
gutters: (styles = {}) => {
return {
paddingLeft: spacing(2),
paddingRight: spacing(2),
...styles,
[breakpoints.up('sm')]: {
paddingLeft: spacing(3),
paddingRight: spacing(3),
...styles[breakpoints.up('sm')]
}
};
},
...mixins
};
const {
type: typeInput,
mode: modeInput,
...paletteRest
} = palette;
const finalMode = modeInput || typeInput || 'light';
theme.palette = {
// theme.palette.text.hint
text: {
hint: finalMode === 'dark' ? 'rgba(255, 255, 255, 0.5)' : 'rgba(0, 0, 0, 0.38)'
},
mode: finalMode,
type: finalMode,
...paletteRest
};
return theme;
}

605
node_modules/@mui/material/styles/components.d.ts generated vendored Normal file
View file

@ -0,0 +1,605 @@
import { ComponentsProps } from "./props.js";
import { ComponentsOverrides } from "./overrides.js";
import { ComponentsVariants } from "./variants.js";
export interface Components<Theme = unknown> {
/**
* Whether to merge the className and style coming from the component props with the default props.
* @default false
*/
mergeClassNameAndStyle?: boolean;
MuiAlert?: {
defaultProps?: ComponentsProps['MuiAlert'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAlert'];
variants?: ComponentsVariants<Theme>['MuiAlert'];
};
MuiAlertTitle?: {
defaultProps?: ComponentsProps['MuiAlertTitle'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAlertTitle'];
variants?: ComponentsVariants<Theme>['MuiAlertTitle'];
};
MuiAppBar?: {
defaultProps?: ComponentsProps['MuiAppBar'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAppBar'];
variants?: ComponentsVariants<Theme>['MuiAppBar'];
};
MuiAutocomplete?: {
defaultProps?: ComponentsProps['MuiAutocomplete'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAutocomplete'];
variants?: ComponentsVariants<Theme>['MuiAutocomplete'];
};
MuiAvatar?: {
defaultProps?: ComponentsProps['MuiAvatar'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAvatar'];
variants?: ComponentsVariants<Theme>['MuiAvatar'];
};
MuiAvatarGroup?: {
defaultProps?: ComponentsProps['MuiAvatarGroup'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAvatarGroup'];
variants?: ComponentsVariants<Theme>['MuiAvatarGroup'];
};
MuiBackdrop?: {
defaultProps?: ComponentsProps['MuiBackdrop'];
styleOverrides?: ComponentsOverrides<Theme>['MuiBackdrop'];
variants?: ComponentsVariants<Theme>['MuiBackdrop'];
};
MuiBadge?: {
defaultProps?: ComponentsProps['MuiBadge'];
styleOverrides?: ComponentsOverrides<Theme>['MuiBadge'];
variants?: ComponentsVariants<Theme>['MuiBadge'];
};
MuiBottomNavigation?: {
defaultProps?: ComponentsProps['MuiBottomNavigation'];
styleOverrides?: ComponentsOverrides<Theme>['MuiBottomNavigation'];
variants?: ComponentsVariants<Theme>['MuiBottomNavigation'];
};
MuiBottomNavigationAction?: {
defaultProps?: ComponentsProps['MuiBottomNavigationAction'];
styleOverrides?: ComponentsOverrides<Theme>['MuiBottomNavigationAction'];
variants?: ComponentsVariants<Theme>['MuiBottomNavigationAction'];
};
MuiBreadcrumbs?: {
defaultProps?: ComponentsProps['MuiBreadcrumbs'];
styleOverrides?: ComponentsOverrides<Theme>['MuiBreadcrumbs'];
variants?: ComponentsVariants<Theme>['MuiBreadcrumbs'];
};
MuiButton?: {
defaultProps?: ComponentsProps['MuiButton'];
styleOverrides?: ComponentsOverrides<Theme>['MuiButton'];
variants?: ComponentsVariants<Theme>['MuiButton'];
};
MuiButtonBase?: {
defaultProps?: ComponentsProps['MuiButtonBase'];
styleOverrides?: ComponentsOverrides<Theme>['MuiButtonBase'];
variants?: ComponentsVariants<Theme>['MuiButtonBase'];
};
MuiButtonGroup?: {
defaultProps?: ComponentsProps['MuiButtonGroup'];
styleOverrides?: ComponentsOverrides<Theme>['MuiButtonGroup'];
variants?: ComponentsVariants<Theme>['MuiButtonGroup'];
};
MuiCard?: {
defaultProps?: ComponentsProps['MuiCard'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCard'];
variants?: ComponentsVariants<Theme>['MuiCard'];
};
MuiCardActionArea?: {
defaultProps?: ComponentsProps['MuiCardActionArea'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCardActionArea'];
variants?: ComponentsVariants<Theme>['MuiCardActionArea'];
};
MuiCardActions?: {
defaultProps?: ComponentsProps['MuiCardActions'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCardActions'];
variants?: ComponentsVariants<Theme>['MuiCardActions'];
};
MuiCardContent?: {
defaultProps?: ComponentsProps['MuiCardContent'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCardContent'];
variants?: ComponentsVariants<Theme>['MuiCardContent'];
};
MuiCardHeader?: {
defaultProps?: ComponentsProps['MuiCardHeader'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCardHeader'];
variants?: ComponentsVariants<Theme>['MuiCardHeader'];
};
MuiCardMedia?: {
defaultProps?: ComponentsProps['MuiCardMedia'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCardMedia'];
variants?: ComponentsVariants<Theme>['MuiCardMedia'];
};
MuiCheckbox?: {
defaultProps?: ComponentsProps['MuiCheckbox'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCheckbox'];
variants?: ComponentsVariants<Theme>['MuiCheckbox'];
};
MuiChip?: {
defaultProps?: ComponentsProps['MuiChip'];
styleOverrides?: ComponentsOverrides<Theme>['MuiChip'];
variants?: ComponentsVariants<Theme>['MuiChip'];
};
MuiCircularProgress?: {
defaultProps?: ComponentsProps['MuiCircularProgress'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCircularProgress'];
variants?: ComponentsVariants<Theme>['MuiCircularProgress'];
};
MuiCollapse?: {
defaultProps?: ComponentsProps['MuiCollapse'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCollapse'];
variants?: ComponentsVariants<Theme>['MuiCollapse'];
};
MuiContainer?: {
defaultProps?: ComponentsProps['MuiContainer'];
styleOverrides?: ComponentsOverrides<Theme>['MuiContainer'];
variants?: ComponentsVariants<Theme>['MuiContainer'];
};
MuiCssBaseline?: {
defaultProps?: ComponentsProps['MuiCssBaseline'];
styleOverrides?: ComponentsOverrides<Theme>['MuiCssBaseline'];
variants?: ComponentsVariants<Theme>['MuiCssBaseline'];
};
MuiDialog?: {
defaultProps?: ComponentsProps['MuiDialog'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDialog'];
variants?: ComponentsVariants<Theme>['MuiDialog'];
};
MuiDialogActions?: {
defaultProps?: ComponentsProps['MuiDialogActions'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDialogActions'];
variants?: ComponentsVariants<Theme>['MuiDialogActions'];
};
MuiDialogContent?: {
defaultProps?: ComponentsProps['MuiDialogContent'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDialogContent'];
variants?: ComponentsVariants<Theme>['MuiDialogContent'];
};
MuiDialogContentText?: {
defaultProps?: ComponentsProps['MuiDialogContentText'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDialogContentText'];
variants?: ComponentsVariants<Theme>['MuiDialogContentText'];
};
MuiDialogTitle?: {
defaultProps?: ComponentsProps['MuiDialogTitle'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDialogTitle'];
variants?: ComponentsVariants<Theme>['MuiDialogTitle'];
};
MuiDivider?: {
defaultProps?: ComponentsProps['MuiDivider'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDivider'];
variants?: ComponentsVariants<Theme>['MuiDivider'];
};
MuiDrawer?: {
defaultProps?: ComponentsProps['MuiDrawer'];
styleOverrides?: ComponentsOverrides<Theme>['MuiDrawer'];
variants?: ComponentsVariants<Theme>['MuiDrawer'];
};
MuiAccordion?: {
defaultProps?: ComponentsProps['MuiAccordion'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAccordion'];
variants?: ComponentsVariants<Theme>['MuiAccordion'];
};
MuiAccordionActions?: {
defaultProps?: ComponentsProps['MuiAccordionActions'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAccordionActions'];
variants?: ComponentsVariants<Theme>['MuiAccordionActions'];
};
MuiAccordionDetails?: {
defaultProps?: ComponentsProps['MuiAccordionDetails'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAccordionDetails'];
variants?: ComponentsVariants<Theme>['MuiAccordionDetails'];
};
MuiAccordionSummary?: {
defaultProps?: ComponentsProps['MuiAccordionSummary'];
styleOverrides?: ComponentsOverrides<Theme>['MuiAccordionSummary'];
variants?: ComponentsVariants<Theme>['MuiAccordionSummary'];
};
MuiFab?: {
defaultProps?: ComponentsProps['MuiFab'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFab'];
variants?: ComponentsVariants<Theme>['MuiFab'];
};
MuiFilledInput?: {
defaultProps?: ComponentsProps['MuiFilledInput'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFilledInput'];
variants?: ComponentsVariants<Theme>['MuiFilledInput'];
};
MuiFormControl?: {
defaultProps?: ComponentsProps['MuiFormControl'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFormControl'];
variants?: ComponentsVariants<Theme>['MuiFormControl'];
};
MuiFormControlLabel?: {
defaultProps?: ComponentsProps['MuiFormControlLabel'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFormControlLabel'];
variants?: ComponentsVariants<Theme>['MuiFormControlLabel'];
};
MuiFormGroup?: {
defaultProps?: ComponentsProps['MuiFormGroup'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFormGroup'];
variants?: ComponentsVariants<Theme>['MuiFormGroup'];
};
MuiFormHelperText?: {
defaultProps?: ComponentsProps['MuiFormHelperText'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFormHelperText'];
variants?: ComponentsVariants<Theme>['MuiFormHelperText'];
};
MuiFormLabel?: {
defaultProps?: ComponentsProps['MuiFormLabel'];
styleOverrides?: ComponentsOverrides<Theme>['MuiFormLabel'];
variants?: ComponentsVariants<Theme>['MuiFormLabel'];
};
MuiGridLegacy?: {
defaultProps?: ComponentsProps['MuiGridLegacy'];
styleOverrides?: ComponentsOverrides<Theme>['MuiGridLegacy'];
variants?: ComponentsVariants<Theme>['MuiGridLegacy'];
};
MuiGrid?: {
defaultProps?: ComponentsProps['MuiGrid'];
styleOverrides?: ComponentsOverrides<Theme>['MuiGrid'];
variants?: ComponentsVariants<Theme>['MuiGrid'];
};
MuiImageList?: {
defaultProps?: ComponentsProps['MuiImageList'];
styleOverrides?: ComponentsOverrides<Theme>['MuiImageList'];
variants?: ComponentsVariants<Theme>['MuiImageList'];
};
MuiImageListItem?: {
defaultProps?: ComponentsProps['MuiImageListItem'];
styleOverrides?: ComponentsOverrides<Theme>['MuiImageListItem'];
variants?: ComponentsVariants<Theme>['MuiImageListItem'];
};
MuiImageListItemBar?: {
defaultProps?: ComponentsProps['MuiImageListItemBar'];
styleOverrides?: ComponentsOverrides<Theme>['MuiImageListItemBar'];
variants?: ComponentsVariants<Theme>['MuiImageListItemBar'];
};
MuiIcon?: {
defaultProps?: ComponentsProps['MuiIcon'];
styleOverrides?: ComponentsOverrides<Theme>['MuiIcon'];
variants?: ComponentsVariants<Theme>['MuiIcon'];
};
MuiIconButton?: {
defaultProps?: ComponentsProps['MuiIconButton'];
styleOverrides?: ComponentsOverrides<Theme>['MuiIconButton'];
variants?: ComponentsVariants<Theme>['MuiIconButton'];
};
MuiInput?: {
defaultProps?: ComponentsProps['MuiInput'];
styleOverrides?: ComponentsOverrides<Theme>['MuiInput'];
variants?: ComponentsVariants<Theme>['MuiInput'];
};
MuiInputAdornment?: {
defaultProps?: ComponentsProps['MuiInputAdornment'];
styleOverrides?: ComponentsOverrides<Theme>['MuiInputAdornment'];
variants?: ComponentsVariants<Theme>['MuiInputAdornment'];
};
MuiInputBase?: {
defaultProps?: ComponentsProps['MuiInputBase'];
styleOverrides?: ComponentsOverrides<Theme>['MuiInputBase'];
variants?: ComponentsVariants<Theme>['MuiInputBase'];
};
MuiInputLabel?: {
defaultProps?: ComponentsProps['MuiInputLabel'];
styleOverrides?: ComponentsOverrides<Theme>['MuiInputLabel'];
variants?: ComponentsVariants<Theme>['MuiInputLabel'];
};
MuiLinearProgress?: {
defaultProps?: ComponentsProps['MuiLinearProgress'];
styleOverrides?: ComponentsOverrides<Theme>['MuiLinearProgress'];
variants?: ComponentsVariants<Theme>['MuiLinearProgress'];
};
MuiLink?: {
defaultProps?: ComponentsProps['MuiLink'];
styleOverrides?: ComponentsOverrides<Theme>['MuiLink'];
variants?: ComponentsVariants<Theme>['MuiLink'];
};
MuiList?: {
defaultProps?: ComponentsProps['MuiList'];
styleOverrides?: ComponentsOverrides<Theme>['MuiList'];
variants?: ComponentsVariants<Theme>['MuiList'];
};
MuiListItem?: {
defaultProps?: ComponentsProps['MuiListItem'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListItem'];
variants?: ComponentsVariants<Theme>['MuiListItem'];
};
MuiListItemButton?: {
defaultProps?: ComponentsProps['MuiListItemButton'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListItemButton'];
variants?: ComponentsVariants<Theme>['MuiListItemButton'];
};
MuiListItemAvatar?: {
defaultProps?: ComponentsProps['MuiListItemAvatar'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListItemAvatar'];
variants?: ComponentsVariants<Theme>['MuiListItemAvatar'];
};
MuiListItemIcon?: {
defaultProps?: ComponentsProps['MuiListItemIcon'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListItemIcon'];
variants?: ComponentsVariants<Theme>['MuiListItemIcon'];
};
MuiListItemSecondaryAction?: {
defaultProps?: ComponentsProps['MuiListItemSecondaryAction'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListItemSecondaryAction'];
variants?: ComponentsVariants<Theme>['MuiListItemSecondaryAction'];
};
MuiListItemText?: {
defaultProps?: ComponentsProps['MuiListItemText'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListItemText'];
variants?: ComponentsVariants<Theme>['MuiListItemText'];
};
MuiListSubheader?: {
defaultProps?: ComponentsProps['MuiListSubheader'];
styleOverrides?: ComponentsOverrides<Theme>['MuiListSubheader'];
variants?: ComponentsVariants<Theme>['MuiListSubheader'];
};
MuiMenu?: {
defaultProps?: ComponentsProps['MuiMenu'];
styleOverrides?: ComponentsOverrides<Theme>['MuiMenu'];
variants?: ComponentsVariants<Theme>['MuiMenu'];
};
MuiMenuItem?: {
defaultProps?: ComponentsProps['MuiMenuItem'];
styleOverrides?: ComponentsOverrides<Theme>['MuiMenuItem'];
variants?: ComponentsVariants<Theme>['MuiMenuItem'];
};
MuiMenuList?: {
defaultProps?: ComponentsProps['MuiMenuList'];
styleOverrides?: ComponentsOverrides<Theme>['MuiMenuList'];
variants?: ComponentsVariants<Theme>['MuiMenuList'];
};
MuiMobileStepper?: {
defaultProps?: ComponentsProps['MuiMobileStepper'];
styleOverrides?: ComponentsOverrides<Theme>['MuiMobileStepper'];
variants?: ComponentsVariants<Theme>['MuiMobileStepper'];
};
MuiModal?: {
defaultProps?: ComponentsProps['MuiModal'];
styleOverrides?: ComponentsOverrides<Theme>['MuiModal'];
variants?: ComponentsVariants<Theme>['MuiModal'];
};
MuiNativeSelect?: {
defaultProps?: ComponentsProps['MuiNativeSelect'];
styleOverrides?: ComponentsOverrides<Theme>['MuiNativeSelect'];
variants?: ComponentsVariants<Theme>['MuiNativeSelect'];
};
MuiOutlinedInput?: {
defaultProps?: ComponentsProps['MuiOutlinedInput'];
styleOverrides?: ComponentsOverrides<Theme>['MuiOutlinedInput'];
variants?: ComponentsVariants<Theme>['MuiOutlinedInput'];
};
MuiPagination?: {
defaultProps?: ComponentsProps['MuiPagination'];
styleOverrides?: ComponentsOverrides<Theme>['MuiPagination'];
variants?: ComponentsVariants<Theme>['MuiPagination'];
};
MuiPaginationItem?: {
defaultProps?: ComponentsProps['MuiPaginationItem'];
styleOverrides?: ComponentsOverrides<Theme>['MuiPaginationItem'];
variants?: ComponentsVariants<Theme>['MuiPaginationItem'];
};
MuiPaper?: {
defaultProps?: ComponentsProps['MuiPaper'];
styleOverrides?: ComponentsOverrides<Theme>['MuiPaper'];
variants?: ComponentsVariants<Theme>['MuiPaper'];
};
MuiPopper?: {
defaultProps?: ComponentsProps['MuiPopper'];
styleOverrides?: ComponentsOverrides<Theme>['MuiPopper'];
};
MuiPopover?: {
defaultProps?: ComponentsProps['MuiPopover'];
styleOverrides?: ComponentsOverrides<Theme>['MuiPopover'];
variants?: ComponentsVariants<Theme>['MuiPopover'];
};
MuiRadio?: {
defaultProps?: ComponentsProps['MuiRadio'];
styleOverrides?: ComponentsOverrides<Theme>['MuiRadio'];
variants?: ComponentsVariants<Theme>['MuiRadio'];
};
MuiRadioGroup?: {
defaultProps?: ComponentsProps['MuiRadioGroup'];
styleOverrides?: ComponentsOverrides<Theme>['MuiRadioGroup'];
variants?: ComponentsVariants<Theme>['MuiRadioGroup'];
};
MuiRating?: {
defaultProps?: ComponentsProps['MuiRating'];
styleOverrides?: ComponentsOverrides<Theme>['MuiRating'];
variants?: ComponentsVariants<Theme>['MuiRating'];
};
MuiScopedCssBaseline?: {
defaultProps?: ComponentsProps['MuiScopedCssBaseline'];
styleOverrides?: ComponentsOverrides<Theme>['MuiScopedCssBaseline'];
variants?: ComponentsVariants<Theme>['MuiScopedCssBaseline'];
};
MuiSelect?: {
defaultProps?: ComponentsProps['MuiSelect'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSelect'];
variants?: ComponentsVariants<Theme>['MuiSelect'];
};
MuiSkeleton?: {
defaultProps?: ComponentsProps['MuiSkeleton'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSkeleton'];
variants?: ComponentsVariants<Theme>['MuiSkeleton'];
};
MuiSlider?: {
defaultProps?: ComponentsProps['MuiSlider'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSlider'];
variants?: ComponentsVariants<Theme>['MuiSlider'];
};
MuiSnackbar?: {
defaultProps?: ComponentsProps['MuiSnackbar'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSnackbar'];
variants?: ComponentsVariants<Theme>['MuiSnackbar'];
};
MuiSnackbarContent?: {
defaultProps?: ComponentsProps['MuiSnackbarContent'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSnackbarContent'];
variants?: ComponentsVariants<Theme>['MuiSnackbarContent'];
};
MuiSpeedDial?: {
defaultProps?: ComponentsProps['MuiSpeedDial'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSpeedDial'];
variants?: ComponentsVariants<Theme>['MuiSpeedDial'];
};
MuiSpeedDialAction?: {
defaultProps?: ComponentsProps['MuiSpeedDialAction'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSpeedDialAction'];
variants?: ComponentsVariants<Theme>['MuiSpeedDialAction'];
};
MuiSpeedDialIcon?: {
defaultProps?: ComponentsProps['MuiSpeedDialIcon'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSpeedDialIcon'];
variants?: ComponentsVariants<Theme>['MuiSpeedDialIcon'];
};
MuiStack?: {
defaultProps?: ComponentsProps['MuiStack'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStack'];
variants?: ComponentsVariants<Theme>['MuiStack'];
};
MuiStep?: {
defaultProps?: ComponentsProps['MuiStep'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStep'];
variants?: ComponentsVariants<Theme>['MuiStep'];
};
MuiStepButton?: {
defaultProps?: ComponentsProps['MuiStepButton'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStepButton'];
variants?: ComponentsVariants<Theme>['MuiStepButton'];
};
MuiStepConnector?: {
defaultProps?: ComponentsProps['MuiStepConnector'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStepConnector'];
variants?: ComponentsVariants<Theme>['MuiStepConnector'];
};
MuiStepContent?: {
defaultProps?: ComponentsProps['MuiStepContent'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStepContent'];
variants?: ComponentsVariants<Theme>['MuiStepContent'];
};
MuiStepIcon?: {
defaultProps?: ComponentsProps['MuiStepIcon'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStepIcon'];
variants?: ComponentsVariants<Theme>['MuiStepIcon'];
};
MuiStepLabel?: {
defaultProps?: ComponentsProps['MuiStepLabel'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStepLabel'];
variants?: ComponentsVariants<Theme>['MuiStepLabel'];
};
MuiStepper?: {
defaultProps?: ComponentsProps['MuiStepper'];
styleOverrides?: ComponentsOverrides<Theme>['MuiStepper'];
variants?: ComponentsVariants<Theme>['MuiStepper'];
};
MuiSvgIcon?: {
defaultProps?: ComponentsProps['MuiSvgIcon'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSvgIcon'];
variants?: ComponentsVariants<Theme>['MuiSvgIcon'];
};
MuiSwipeableDrawer?: {
defaultProps?: ComponentsProps['MuiSwipeableDrawer'];
};
MuiSwitch?: {
defaultProps?: ComponentsProps['MuiSwitch'];
styleOverrides?: ComponentsOverrides<Theme>['MuiSwitch'];
variants?: ComponentsVariants<Theme>['MuiSwitch'];
};
MuiTab?: {
defaultProps?: ComponentsProps['MuiTab'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTab'];
variants?: ComponentsVariants<Theme>['MuiTab'];
};
MuiTable?: {
defaultProps?: ComponentsProps['MuiTable'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTable'];
variants?: ComponentsVariants<Theme>['MuiTable'];
};
MuiTableBody?: {
defaultProps?: ComponentsProps['MuiTableBody'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableBody'];
variants?: ComponentsVariants<Theme>['MuiTableBody'];
};
MuiTableCell?: {
defaultProps?: ComponentsProps['MuiTableCell'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableCell'];
variants?: ComponentsVariants<Theme>['MuiTableCell'];
};
MuiTableContainer?: {
defaultProps?: ComponentsProps['MuiTableContainer'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableContainer'];
variants?: ComponentsVariants<Theme>['MuiTableContainer'];
};
MuiTableFooter?: {
defaultProps?: ComponentsProps['MuiTableFooter'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableFooter'];
variants?: ComponentsVariants<Theme>['MuiTableFooter'];
};
MuiTableHead?: {
defaultProps?: ComponentsProps['MuiTableHead'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableHead'];
variants?: ComponentsVariants<Theme>['MuiTableHead'];
};
MuiTablePagination?: {
defaultProps?: ComponentsProps['MuiTablePagination'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTablePagination'];
variants?: ComponentsVariants<Theme>['MuiTablePagination'];
};
MuiTablePaginationActions?: {
defaultProps?: ComponentsProps['MuiTablePaginationActions'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTablePaginationActions'];
variants?: ComponentsVariants<Theme>['MuiTablePaginationActions'];
};
MuiTableRow?: {
defaultProps?: ComponentsProps['MuiTableRow'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableRow'];
variants?: ComponentsVariants<Theme>['MuiTableRow'];
};
MuiTableSortLabel?: {
defaultProps?: ComponentsProps['MuiTableSortLabel'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTableSortLabel'];
variants?: ComponentsVariants<Theme>['MuiTableSortLabel'];
};
MuiTabs?: {
defaultProps?: ComponentsProps['MuiTabs'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTabs'];
variants?: ComponentsVariants<Theme>['MuiTabs'];
};
MuiTextField?: {
defaultProps?: ComponentsProps['MuiTextField'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTextField'];
variants?: ComponentsVariants<Theme>['MuiTextField'];
};
MuiToggleButton?: {
defaultProps?: ComponentsProps['MuiToggleButton'];
styleOverrides?: ComponentsOverrides<Theme>['MuiToggleButton'];
variants?: ComponentsVariants<Theme>['MuiToggleButton'];
};
MuiToggleButtonGroup?: {
defaultProps?: ComponentsProps['MuiToggleButtonGroup'];
styleOverrides?: ComponentsOverrides<Theme>['MuiToggleButtonGroup'];
variants?: ComponentsVariants<Theme>['MuiToggleButtonGroup'];
};
MuiToolbar?: {
defaultProps?: ComponentsProps['MuiToolbar'];
styleOverrides?: ComponentsOverrides<Theme>['MuiToolbar'];
variants?: ComponentsVariants<Theme>['MuiToolbar'];
};
MuiTooltip?: {
defaultProps?: ComponentsProps['MuiTooltip'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTooltip'];
variants?: ComponentsVariants<Theme>['MuiTooltip'];
};
MuiTouchRipple?: {
defaultProps?: ComponentsProps['MuiTouchRipple'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTouchRipple'];
variants?: ComponentsVariants<Theme>['MuiTouchRipple'];
};
MuiTypography?: {
defaultProps?: ComponentsProps['MuiTypography'];
styleOverrides?: ComponentsOverrides<Theme>['MuiTypography'];
variants?: ComponentsVariants<Theme>['MuiTypography'];
};
MuiUseMediaQuery?: {
defaultProps?: ComponentsProps['MuiUseMediaQuery'];
};
}

5
node_modules/@mui/material/styles/components.js generated vendored Normal file
View file

@ -0,0 +1,5 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});

11
node_modules/@mui/material/styles/createColorScheme.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import type { ColorSystemOptions } from "./createThemeWithVars.js";
export declare function getOpacity(mode: 'light' | 'dark'): {
inputPlaceholder: number;
inputUnderline: number;
switchTrackDisabled: number;
switchTrack: number;
};
export declare function getOverlays(mode: 'light' | 'dark'): string[];
export default function createColorScheme(options: ColorSystemOptions & {
colorSpace?: string;
}): ColorSystemOptions;

55
node_modules/@mui/material/styles/createColorScheme.js generated vendored Normal file
View file

@ -0,0 +1,55 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createColorScheme;
exports.getOpacity = getOpacity;
exports.getOverlays = getOverlays;
var _createPalette = _interopRequireDefault(require("./createPalette"));
var _getOverlayAlpha = _interopRequireDefault(require("./getOverlayAlpha"));
const defaultDarkOverlays = [...Array(25)].map((_, index) => {
if (index === 0) {
return 'none';
}
const overlay = (0, _getOverlayAlpha.default)(index);
return `linear-gradient(rgba(255 255 255 / ${overlay}), rgba(255 255 255 / ${overlay}))`;
});
function getOpacity(mode) {
return {
inputPlaceholder: mode === 'dark' ? 0.5 : 0.42,
inputUnderline: mode === 'dark' ? 0.7 : 0.42,
switchTrackDisabled: mode === 'dark' ? 0.2 : 0.12,
switchTrack: mode === 'dark' ? 0.3 : 0.38
};
}
function getOverlays(mode) {
return mode === 'dark' ? defaultDarkOverlays : [];
}
function createColorScheme(options) {
const {
palette: paletteInput = {
mode: 'light'
},
// need to cast to avoid module augmentation test
opacity,
overlays,
colorSpace,
...rest
} = options;
// need to cast because `colorSpace` is considered internal at the moment.
const palette = (0, _createPalette.default)({
...paletteInput,
colorSpace
});
return {
palette,
opacity: {
...getOpacity(palette.mode),
...opacity
},
overlays: overlays || getOverlays(palette.mode),
...rest
};
}

16
node_modules/@mui/material/styles/createGetSelector.d.ts generated vendored Normal file
View file

@ -0,0 +1,16 @@
declare const _default: <T extends {
rootSelector?: string;
colorSchemeSelector?: "media" | "class" | "data" | string;
colorSchemes?: Record<string, any>;
defaultColorScheme?: string;
cssVarPrefix?: string;
}>(theme: T) => (colorScheme: keyof T["colorSchemes"] | undefined, css: Record<string, any>) => string | {
[x: string]: Record<string, any>;
"@media (prefers-color-scheme: dark)": {
[x: string]: Record<string, any>;
};
} | {
[x: string]: Record<string, any>;
"@media (prefers-color-scheme: dark)"?: undefined;
};
export default _default;

68
node_modules/@mui/material/styles/createGetSelector.js generated vendored Normal file
View file

@ -0,0 +1,68 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _excludeVariablesFromRoot = _interopRequireDefault(require("./excludeVariablesFromRoot"));
var _default = theme => (colorScheme, css) => {
const root = theme.rootSelector || ':root';
const selector = theme.colorSchemeSelector;
let rule = selector;
if (selector === 'class') {
rule = '.%s';
}
if (selector === 'data') {
rule = '[data-%s]';
}
if (selector?.startsWith('data-') && !selector.includes('%s')) {
// 'data-mui-color-scheme' -> '[data-mui-color-scheme="%s"]'
rule = `[${selector}="%s"]`;
}
if (theme.defaultColorScheme === colorScheme) {
if (colorScheme === 'dark') {
const excludedVariables = {};
(0, _excludeVariablesFromRoot.default)(theme.cssVarPrefix).forEach(cssVar => {
excludedVariables[cssVar] = css[cssVar];
delete css[cssVar];
});
if (rule === 'media') {
return {
[root]: css,
[`@media (prefers-color-scheme: dark)`]: {
[root]: excludedVariables
}
};
}
if (rule) {
return {
[rule.replace('%s', colorScheme)]: excludedVariables,
[`${root}, ${rule.replace('%s', colorScheme)}`]: css
};
}
return {
[root]: {
...css,
...excludedVariables
}
};
}
if (rule && rule !== 'media') {
return `${root}, ${rule.replace('%s', String(colorScheme))}`;
}
} else if (colorScheme) {
if (rule === 'media') {
return {
[`@media (prefers-color-scheme: ${String(colorScheme)})`]: {
[root]: css
}
};
}
if (rule) {
return rule.replace('%s', String(colorScheme));
}
}
return root;
};
exports.default = _default;

32
node_modules/@mui/material/styles/createMixins.d.ts generated vendored Normal file
View file

@ -0,0 +1,32 @@
import * as CSS from 'csstype';
import { Breakpoints } from '@mui/system';
export type NormalCssProperties = CSS.Properties<number | string>;
export type Fontface = CSS.AtRule.FontFace & {
fallbacks?: CSS.AtRule.FontFace[];
};
/**
* Allows the user to augment the properties available
*/
export interface BaseCSSProperties extends NormalCssProperties {
'@font-face'?: Fontface | Fontface[];
}
export interface CSSProperties extends BaseCSSProperties {
// Allow pseudo selectors and media queries
// `unknown` is used since TS does not allow assigning an interface without
// an index signature to one with an index signature. This is to allow type safe
// module augmentation.
// Technically we want any key not typed in `BaseCSSProperties` to be of type
// `CSSProperties` but this doesn't work. The index signature needs to cover
// BaseCSSProperties as well. Usually you would use `BaseCSSProperties[keyof BaseCSSProperties]`
// but this would not allow assigning React.CSSProperties to CSSProperties
[k: string]: unknown | CSSProperties;
}
export interface Mixins {
toolbar: CSSProperties;
// ... use interface declaration merging to add custom mixins
}
export interface MixinsOptions extends Partial<Mixins> {
// ... use interface declaration merging to add custom mixin options
}
export default function createMixins(breakpoints: Breakpoints, mixins: MixinsOptions): Mixins;

22
node_modules/@mui/material/styles/createMixins.js generated vendored Normal file
View file

@ -0,0 +1,22 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createMixins;
function createMixins(breakpoints, mixins) {
return {
toolbar: {
minHeight: 56,
[breakpoints.up('xs')]: {
'@media (orientation: landscape)': {
minHeight: 48
}
},
[breakpoints.up('sm')]: {
minHeight: 64
}
},
...mixins
};
}

14
node_modules/@mui/material/styles/createMuiStrictModeTheme.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createMuiStrictModeTheme;
var _deepmerge = _interopRequireDefault(require("@mui/utils/deepmerge"));
var _createTheme = _interopRequireDefault(require("./createTheme"));
function createMuiStrictModeTheme(options, ...args) {
return (0, _createTheme.default)((0, _deepmerge.default)({
unstable_strictMode: true
}, options), ...args);
}

125
node_modules/@mui/material/styles/createPalette.d.ts generated vendored Normal file
View file

@ -0,0 +1,125 @@
export type PaletteMode = 'light' | 'dark';
export interface Color {
50: string;
100: string;
200: string;
300: string;
400: string;
500: string;
600: string;
700: string;
800: string;
900: string;
A100: string;
A200: string;
A400: string;
A700: string;
}
export {};
// use standalone interface over typeof colors/commons
// to enable module augmentation
export interface CommonColors {
black: string;
white: string;
}
export type ColorPartial = Partial<Color>;
export interface TypeText {
primary: string;
secondary: string;
disabled: string;
}
export interface TypeAction {
active: string;
hover: string;
hoverOpacity: number;
selected: string;
selectedOpacity: number;
disabled: string;
disabledOpacity: number;
disabledBackground: string;
focus: string;
focusOpacity: number;
activatedOpacity: number;
}
export interface TypeBackground {
default: string;
paper: string;
}
export type TypeDivider = string;
export type PaletteColorOptions = SimplePaletteColorOptions | ColorPartial;
export interface SimplePaletteColorOptions {
light?: string;
main: string;
dark?: string;
contrastText?: string;
}
export interface PaletteColor {
light: string;
main: string;
dark: string;
contrastText: string;
}
export interface TypeObject {
text: TypeText;
action: TypeAction;
divider: TypeDivider;
background: TypeBackground;
}
export type PaletteTonalOffset = number | {
light: number;
dark: number;
};
export const light: TypeObject;
export const dark: TypeObject;
export interface PaletteAugmentColorOptions {
color: PaletteColorOptions;
mainShade?: number | string;
lightShade?: number | string;
darkShade?: number | string;
name?: number | string;
}
export interface Palette {
common: CommonColors;
mode: PaletteMode;
contrastThreshold: number;
tonalOffset: PaletteTonalOffset;
primary: PaletteColor;
secondary: PaletteColor;
error: PaletteColor;
warning: PaletteColor;
info: PaletteColor;
success: PaletteColor;
grey: Color;
text: TypeText;
divider: TypeDivider;
action: TypeAction;
background: TypeBackground;
getContrastText: (background: string) => string;
augmentColor: (options: PaletteAugmentColorOptions) => PaletteColor;
}
export interface Channels {
mainChannel: string;
lightChannel: string;
darkChannel: string;
contrastTextChannel: string;
}
export type PartialTypeObject = { [P in keyof TypeObject]?: Partial<TypeObject[P]> };
export interface PaletteOptions {
primary?: PaletteColorOptions;
secondary?: PaletteColorOptions;
error?: PaletteColorOptions;
warning?: PaletteColorOptions;
info?: PaletteColorOptions;
success?: PaletteColorOptions;
mode?: PaletteMode;
tonalOffset?: PaletteTonalOffset;
contrastThreshold?: number;
common?: Partial<CommonColors>;
grey?: ColorPartial;
text?: Partial<TypeText>;
divider?: string;
action?: Partial<TypeAction>;
background?: Partial<TypeBackground>;
getContrastText?: (background: string) => string;
}
export default function createPalette(palette: PaletteOptions): Palette;

339
node_modules/@mui/material/styles/createPalette.js generated vendored Normal file
View file

@ -0,0 +1,339 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.contrastColor = contrastColor;
exports.dark = void 0;
exports.default = createPalette;
exports.light = void 0;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
var _deepmerge = _interopRequireDefault(require("@mui/utils/deepmerge"));
var _colorManipulator = require("@mui/system/colorManipulator");
var _common = _interopRequireDefault(require("../colors/common"));
var _grey = _interopRequireDefault(require("../colors/grey"));
var _purple = _interopRequireDefault(require("../colors/purple"));
var _red = _interopRequireDefault(require("../colors/red"));
var _orange = _interopRequireDefault(require("../colors/orange"));
var _blue = _interopRequireDefault(require("../colors/blue"));
var _lightBlue = _interopRequireDefault(require("../colors/lightBlue"));
var _green = _interopRequireDefault(require("../colors/green"));
function getLight() {
return {
// The colors used to style the text.
text: {
// The most important text.
primary: 'rgba(0, 0, 0, 0.87)',
// Secondary text.
secondary: 'rgba(0, 0, 0, 0.6)',
// Disabled text have even lower visual prominence.
disabled: 'rgba(0, 0, 0, 0.38)'
},
// The color used to divide different elements.
divider: 'rgba(0, 0, 0, 0.12)',
// The background colors used to style the surfaces.
// Consistency between these values is important.
background: {
paper: _common.default.white,
default: _common.default.white
},
// The colors used to style the action elements.
action: {
// The color of an active action like an icon button.
active: 'rgba(0, 0, 0, 0.54)',
// The color of an hovered action.
hover: 'rgba(0, 0, 0, 0.04)',
hoverOpacity: 0.04,
// The color of a selected action.
selected: 'rgba(0, 0, 0, 0.08)',
selectedOpacity: 0.08,
// The color of a disabled action.
disabled: 'rgba(0, 0, 0, 0.26)',
// The background color of a disabled action.
disabledBackground: 'rgba(0, 0, 0, 0.12)',
disabledOpacity: 0.38,
focus: 'rgba(0, 0, 0, 0.12)',
focusOpacity: 0.12,
activatedOpacity: 0.12
}
};
}
const light = exports.light = getLight();
function getDark() {
return {
text: {
primary: _common.default.white,
secondary: 'rgba(255, 255, 255, 0.7)',
disabled: 'rgba(255, 255, 255, 0.5)',
icon: 'rgba(255, 255, 255, 0.5)'
},
divider: 'rgba(255, 255, 255, 0.12)',
background: {
paper: '#121212',
default: '#121212'
},
action: {
active: _common.default.white,
hover: 'rgba(255, 255, 255, 0.08)',
hoverOpacity: 0.08,
selected: 'rgba(255, 255, 255, 0.16)',
selectedOpacity: 0.16,
disabled: 'rgba(255, 255, 255, 0.3)',
disabledBackground: 'rgba(255, 255, 255, 0.12)',
disabledOpacity: 0.38,
focus: 'rgba(255, 255, 255, 0.12)',
focusOpacity: 0.12,
activatedOpacity: 0.24
}
};
}
const dark = exports.dark = getDark();
function addLightOrDark(intent, direction, shade, tonalOffset) {
const tonalOffsetLight = tonalOffset.light || tonalOffset;
const tonalOffsetDark = tonalOffset.dark || tonalOffset * 1.5;
if (!intent[direction]) {
if (intent.hasOwnProperty(shade)) {
intent[direction] = intent[shade];
} else if (direction === 'light') {
intent.light = (0, _colorManipulator.lighten)(intent.main, tonalOffsetLight);
} else if (direction === 'dark') {
intent.dark = (0, _colorManipulator.darken)(intent.main, tonalOffsetDark);
}
}
}
function mixLightOrDark(colorSpace, intent, direction, shade, tonalOffset) {
const tonalOffsetLight = tonalOffset.light || tonalOffset;
const tonalOffsetDark = tonalOffset.dark || tonalOffset * 1.5;
if (!intent[direction]) {
if (intent.hasOwnProperty(shade)) {
intent[direction] = intent[shade];
} else if (direction === 'light') {
intent.light = `color-mix(in ${colorSpace}, ${intent.main}, #fff ${(tonalOffsetLight * 100).toFixed(0)}%)`;
} else if (direction === 'dark') {
intent.dark = `color-mix(in ${colorSpace}, ${intent.main}, #000 ${(tonalOffsetDark * 100).toFixed(0)}%)`;
}
}
}
function getDefaultPrimary(mode = 'light') {
if (mode === 'dark') {
return {
main: _blue.default[200],
light: _blue.default[50],
dark: _blue.default[400]
};
}
return {
main: _blue.default[700],
light: _blue.default[400],
dark: _blue.default[800]
};
}
function getDefaultSecondary(mode = 'light') {
if (mode === 'dark') {
return {
main: _purple.default[200],
light: _purple.default[50],
dark: _purple.default[400]
};
}
return {
main: _purple.default[500],
light: _purple.default[300],
dark: _purple.default[700]
};
}
function getDefaultError(mode = 'light') {
if (mode === 'dark') {
return {
main: _red.default[500],
light: _red.default[300],
dark: _red.default[700]
};
}
return {
main: _red.default[700],
light: _red.default[400],
dark: _red.default[800]
};
}
function getDefaultInfo(mode = 'light') {
if (mode === 'dark') {
return {
main: _lightBlue.default[400],
light: _lightBlue.default[300],
dark: _lightBlue.default[700]
};
}
return {
main: _lightBlue.default[700],
light: _lightBlue.default[500],
dark: _lightBlue.default[900]
};
}
function getDefaultSuccess(mode = 'light') {
if (mode === 'dark') {
return {
main: _green.default[400],
light: _green.default[300],
dark: _green.default[700]
};
}
return {
main: _green.default[800],
light: _green.default[500],
dark: _green.default[900]
};
}
function getDefaultWarning(mode = 'light') {
if (mode === 'dark') {
return {
main: _orange.default[400],
light: _orange.default[300],
dark: _orange.default[700]
};
}
return {
main: '#ed6c02',
// closest to orange[800] that pass 3:1.
light: _orange.default[500],
dark: _orange.default[900]
};
}
// Use the same name as the experimental CSS `contrast-color` function.
function contrastColor(background) {
return `oklch(from ${background} var(--__l) 0 h / var(--__a))`;
}
function createPalette(palette) {
const {
mode = 'light',
contrastThreshold = 3,
tonalOffset = 0.2,
colorSpace,
...other
} = palette;
const primary = palette.primary || getDefaultPrimary(mode);
const secondary = palette.secondary || getDefaultSecondary(mode);
const error = palette.error || getDefaultError(mode);
const info = palette.info || getDefaultInfo(mode);
const success = palette.success || getDefaultSuccess(mode);
const warning = palette.warning || getDefaultWarning(mode);
// Use the same logic as
// Bootstrap: https://github.com/twbs/bootstrap/blob/1d6e3710dd447de1a200f29e8fa521f8a0908f70/scss/_functions.scss#L59
// and material-components-web https://github.com/material-components/material-components-web/blob/ac46b8863c4dab9fc22c4c662dc6bd1b65dd652f/packages/mdc-theme/_functions.scss#L54
function getContrastText(background) {
if (colorSpace) {
return contrastColor(background);
}
const contrastText = (0, _colorManipulator.getContrastRatio)(background, dark.text.primary) >= contrastThreshold ? dark.text.primary : light.text.primary;
if (process.env.NODE_ENV !== 'production') {
const contrast = (0, _colorManipulator.getContrastRatio)(background, contrastText);
if (contrast < 3) {
console.error([`MUI: The contrast ratio of ${contrast}:1 for ${contrastText} on ${background}`, 'falls below the WCAG recommended absolute minimum contrast ratio of 3:1.', 'https://www.w3.org/TR/2008/REC-WCAG20-20081211/#visual-audio-contrast-contrast'].join('\n'));
}
}
return contrastText;
}
const augmentColor = ({
color,
name,
mainShade = 500,
lightShade = 300,
darkShade = 700
}) => {
color = {
...color
};
if (!color.main && color[mainShade]) {
color.main = color[mainShade];
}
if (!color.hasOwnProperty('main')) {
throw new Error(process.env.NODE_ENV !== "production" ? `MUI: The color${name ? ` (${name})` : ''} provided to augmentColor(color) is invalid.\n` + `The color object needs to have a \`main\` property or a \`${mainShade}\` property.` : (0, _formatMuiErrorMessage.default)(11, name ? ` (${name})` : '', mainShade));
}
if (typeof color.main !== 'string') {
throw new Error(process.env.NODE_ENV !== "production" ? `MUI: The color${name ? ` (${name})` : ''} provided to augmentColor(color) is invalid.\n` + `\`color.main\` should be a string, but \`${JSON.stringify(color.main)}\` was provided instead.\n` + '\n' + 'Did you intend to use one of the following approaches?\n' + '\n' + 'import { green } from "@mui/material/colors";\n' + '\n' + 'const theme1 = createTheme({ palette: {\n' + ' primary: green,\n' + '} });\n' + '\n' + 'const theme2 = createTheme({ palette: {\n' + ' primary: { main: green[500] },\n' + '} });' : (0, _formatMuiErrorMessage.default)(12, name ? ` (${name})` : '', JSON.stringify(color.main)));
}
if (colorSpace) {
mixLightOrDark(colorSpace, color, 'light', lightShade, tonalOffset);
mixLightOrDark(colorSpace, color, 'dark', darkShade, tonalOffset);
} else {
addLightOrDark(color, 'light', lightShade, tonalOffset);
addLightOrDark(color, 'dark', darkShade, tonalOffset);
}
if (!color.contrastText) {
color.contrastText = getContrastText(color.main);
}
return color;
};
let modeHydrated;
if (mode === 'light') {
modeHydrated = getLight();
} else if (mode === 'dark') {
modeHydrated = getDark();
}
if (process.env.NODE_ENV !== 'production') {
if (!modeHydrated) {
console.error(`MUI: The palette mode \`${mode}\` is not supported.`);
}
}
const paletteOutput = (0, _deepmerge.default)({
// A collection of common colors.
common: {
..._common.default
},
// prevent mutable object.
// The palette mode, can be light or dark.
mode,
// The colors used to represent primary interface elements for a user.
primary: augmentColor({
color: primary,
name: 'primary'
}),
// The colors used to represent secondary interface elements for a user.
secondary: augmentColor({
color: secondary,
name: 'secondary',
mainShade: 'A400',
lightShade: 'A200',
darkShade: 'A700'
}),
// The colors used to represent interface elements that the user should be made aware of.
error: augmentColor({
color: error,
name: 'error'
}),
// The colors used to represent potentially dangerous actions or important messages.
warning: augmentColor({
color: warning,
name: 'warning'
}),
// The colors used to present information to the user that is neutral and not necessarily important.
info: augmentColor({
color: info,
name: 'info'
}),
// The colors used to indicate the successful completion of an action that user triggered.
success: augmentColor({
color: success,
name: 'success'
}),
// The grey colors.
grey: _grey.default,
// Used by `getContrastText()` to maximize the contrast between
// the background and the text.
contrastThreshold,
// Takes a background color and returns the text color that maximizes the contrast.
getContrastText,
// Generate a rich color object.
augmentColor,
// Used by the functions below to shift a color's luminance by approximately
// two indexes within its tonal palette.
// E.g., shift from Red 500 to Red 300 or Red 700.
tonalOffset,
// The light and dark mode object.
...modeHydrated
}, other);
return paletteOutput;
}

1
node_modules/@mui/material/styles/createStyles.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export default function createStyles(styles: any): never;

16
node_modules/@mui/material/styles/createStyles.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createStyles;
let warnedOnce = false;
// To remove in v6
function createStyles(styles) {
if (!warnedOnce) {
console.warn(['MUI: createStyles from @mui/material/styles is deprecated.', 'Please use @mui/styles/createStyles'].join('\n'));
warnedOnce = true;
}
return styles;
}

14
node_modules/@mui/material/styles/createTheme.d.ts generated vendored Normal file
View file

@ -0,0 +1,14 @@
import { CssVarsThemeOptions } from "./createThemeWithVars.js";
import { Theme, ThemeOptions } from "./createThemeNoVars.js";
export type { ThemeOptions, Theme, CssThemeVariables } from "./createThemeNoVars.js";
/**
* Generate a theme base on the options received.
* @param options Takes an incomplete theme object and adds the missing parts.
* @param args Deep merge the arguments with the about to be returned theme.
* @returns A complete, ready-to-use theme object.
*/
export default function createTheme(options?: Omit<ThemeOptions, 'components'> & Pick<CssVarsThemeOptions, 'defaultColorScheme' | 'colorSchemes' | 'components'> & {
cssVariables?: boolean | Pick<CssVarsThemeOptions, 'colorSchemeSelector' | 'rootSelector' | 'disableCssColorScheme' | 'cssVarPrefix' | 'shouldSkipGeneratingVar' | 'nativeColor'>;
},
// cast type to skip module augmentation test
...args: object[]): Theme;

105
node_modules/@mui/material/styles/createTheme.js generated vendored Normal file
View file

@ -0,0 +1,105 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createTheme;
var _createPalette = _interopRequireDefault(require("./createPalette"));
var _createThemeWithVars = _interopRequireDefault(require("./createThemeWithVars"));
var _createThemeNoVars = _interopRequireDefault(require("./createThemeNoVars"));
// eslint-disable-next-line consistent-return
function attachColorScheme(theme, scheme, colorScheme) {
if (!theme.colorSchemes) {
return undefined;
}
if (colorScheme) {
theme.colorSchemes[scheme] = {
...(colorScheme !== true && colorScheme),
palette: (0, _createPalette.default)({
...(colorScheme === true ? {} : colorScheme.palette),
mode: scheme
}) // cast type to skip module augmentation test
};
}
}
/**
* Generate a theme base on the options received.
* @param options Takes an incomplete theme object and adds the missing parts.
* @param args Deep merge the arguments with the about to be returned theme.
* @returns A complete, ready-to-use theme object.
*/
function createTheme(options = {},
// cast type to skip module augmentation test
...args) {
const {
palette,
cssVariables = false,
colorSchemes: initialColorSchemes = !palette ? {
light: true
} : undefined,
defaultColorScheme: initialDefaultColorScheme = palette?.mode,
...rest
} = options;
const defaultColorSchemeInput = initialDefaultColorScheme || 'light';
const defaultScheme = initialColorSchemes?.[defaultColorSchemeInput];
const colorSchemesInput = {
...initialColorSchemes,
...(palette ? {
[defaultColorSchemeInput]: {
...(typeof defaultScheme !== 'boolean' && defaultScheme),
palette
}
} : undefined)
};
if (cssVariables === false) {
if (!('colorSchemes' in options)) {
// Behaves exactly as v5
return (0, _createThemeNoVars.default)(options, ...args);
}
let paletteOptions = palette;
if (!('palette' in options)) {
if (colorSchemesInput[defaultColorSchemeInput]) {
if (colorSchemesInput[defaultColorSchemeInput] !== true) {
paletteOptions = colorSchemesInput[defaultColorSchemeInput].palette;
} else if (defaultColorSchemeInput === 'dark') {
// @ts-ignore to prevent the module augmentation test from failing
paletteOptions = {
mode: 'dark'
};
}
}
}
const theme = (0, _createThemeNoVars.default)({
...options,
palette: paletteOptions
}, ...args);
theme.defaultColorScheme = defaultColorSchemeInput;
theme.colorSchemes = colorSchemesInput;
if (theme.palette.mode === 'light') {
theme.colorSchemes.light = {
...(colorSchemesInput.light !== true && colorSchemesInput.light),
palette: theme.palette
};
attachColorScheme(theme, 'dark', colorSchemesInput.dark);
}
if (theme.palette.mode === 'dark') {
theme.colorSchemes.dark = {
...(colorSchemesInput.dark !== true && colorSchemesInput.dark),
palette: theme.palette
};
attachColorScheme(theme, 'light', colorSchemesInput.light);
}
return theme;
}
if (!palette && !('light' in colorSchemesInput) && defaultColorSchemeInput === 'light') {
colorSchemesInput.light = true;
}
return (0, _createThemeWithVars.default)({
...rest,
colorSchemes: colorSchemesInput,
defaultColorScheme: defaultColorSchemeInput,
...(typeof cssVariables !== 'boolean' && cssVariables)
}, ...args);
}

74
node_modules/@mui/material/styles/createThemeNoVars.d.ts generated vendored Normal file
View file

@ -0,0 +1,74 @@
import { ThemeOptions as SystemThemeOptions, Theme as SystemTheme, SxProps, CSSObject, SxConfig } from '@mui/system';
import { Mixins, MixinsOptions } from "./createMixins.js";
import { Palette, PaletteOptions } from "./createPalette.js";
import { TypographyVariants, TypographyVariantsOptions } from "./createTypography.js";
import { Shadows } from "./shadows.js";
import { Transitions, TransitionsOptions } from "./createTransitions.js";
import { ZIndex, ZIndexOptions } from "./zIndex.js";
import { Components } from "./components.js";
import { CssVarsTheme, CssVarsPalette, ColorSystemOptions } from "./createThemeWithVars.js";
/**
* To disable custom properties, use module augmentation
*
* @example
* declare module '@mui/material/styles' {
* interface CssThemeVariables {
* enabled: true;
* }
* }
*/
export interface CssThemeVariables {}
type CssVarsOptions = CssThemeVariables extends {
enabled: true;
} ? ColorSystemOptions : {};
export interface ThemeOptions extends Omit<SystemThemeOptions, 'zIndex'>, CssVarsOptions {
mixins?: MixinsOptions;
components?: Components<Omit<Theme, 'components'>>;
palette?: PaletteOptions;
shadows?: Shadows;
transitions?: TransitionsOptions;
typography?: TypographyVariantsOptions | ((palette: Palette) => TypographyVariantsOptions);
zIndex?: ZIndexOptions;
unstable_strictMode?: boolean;
unstable_sxConfig?: SxConfig;
modularCssLayers?: boolean | string;
}
export interface BaseTheme extends SystemTheme {
mixins: Mixins;
palette: Palette & (CssThemeVariables extends {
enabled: true;
} ? CssVarsPalette : {});
shadows: Shadows;
transitions: Transitions;
typography: TypographyVariants;
zIndex: ZIndex;
unstable_strictMode?: boolean;
}
// shut off automatic exporting for the `BaseTheme` above
export {};
type CssVarsProperties = CssThemeVariables extends {
enabled: true;
} ? Pick<CssVarsTheme, 'applyStyles' | 'colorSchemes' | 'colorSchemeSelector' | 'rootSelector' | 'cssVarPrefix' | 'defaultColorScheme' | 'getCssVar' | 'getColorSchemeSelector' | 'generateThemeVars' | 'generateStyleSheets' | 'generateSpacing' | 'shouldSkipGeneratingVar' | 'vars'> : Partial<Pick<CssVarsTheme, 'vars'>>;
/**
* Our [TypeScript guide on theme customization](https://mui.com/material-ui/guides/typescript/#customization-of-theme) explains in detail how you would add custom properties.
*/
export interface Theme extends BaseTheme, CssVarsProperties {
cssVariables?: false;
components?: Components<BaseTheme>;
unstable_sx: (props: SxProps<Theme>) => CSSObject;
unstable_sxConfig: SxConfig;
alpha: (color: string, value: number | string) => string;
lighten: (color: string, coefficient: number | string) => string;
darken: (color: string, coefficient: number | string) => string;
}
/**
* Generate a theme base on the options received.
* @param options Takes an incomplete theme object and adds the missing parts.
* @param args Deep merge the arguments with the about to be returned theme.
* @returns A complete, ready-to-use theme object.
*/
export default function createThemeNoVars(options?: ThemeOptions, ...args: object[]): Theme;

157
node_modules/@mui/material/styles/createThemeNoVars.js generated vendored Normal file
View file

@ -0,0 +1,157 @@
"use strict";
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
var _deepmerge = _interopRequireDefault(require("@mui/utils/deepmerge"));
var _styleFunctionSx = _interopRequireWildcard(require("@mui/system/styleFunctionSx"));
var _createTheme = _interopRequireDefault(require("@mui/system/createTheme"));
var _colorManipulator = require("@mui/system/colorManipulator");
var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
var _createMixins = _interopRequireDefault(require("./createMixins"));
var _createPalette = _interopRequireDefault(require("./createPalette"));
var _createTypography = _interopRequireDefault(require("./createTypography"));
var _shadows = _interopRequireDefault(require("./shadows"));
var _createTransitions = _interopRequireDefault(require("./createTransitions"));
var _zIndex = _interopRequireDefault(require("./zIndex"));
var _stringifyTheme = require("./stringifyTheme");
function coefficientToPercentage(coefficient) {
if (typeof coefficient === 'number') {
return `${(coefficient * 100).toFixed(0)}%`;
}
return `calc((${coefficient}) * 100%)`;
}
// This can be removed when moved to `color-mix()` entirely.
const parseAddition = str => {
if (!Number.isNaN(+str)) {
return +str;
}
const numbers = str.match(/\d*\.?\d+/g);
if (!numbers) {
return 0;
}
let sum = 0;
for (let i = 0; i < numbers.length; i += 1) {
sum += +numbers[i];
}
return sum;
};
function attachColorManipulators(theme) {
Object.assign(theme, {
alpha(color, coefficient) {
const obj = this || theme;
if (obj.colorSpace) {
return `oklch(from ${color} l c h / ${typeof coefficient === 'string' ? `calc(${coefficient})` : coefficient})`;
}
if (obj.vars) {
// To preserve the behavior of the CSS theme variables
// In the future, this could be replaced by `color-mix` (when https://caniuse.com/?search=color-mix reaches 95%).
return `rgba(${color.replace(/var\(--([^,\s)]+)(?:,[^)]+)?\)+/g, 'var(--$1Channel)')} / ${typeof coefficient === 'string' ? `calc(${coefficient})` : coefficient})`;
}
return (0, _colorManipulator.alpha)(color, parseAddition(coefficient));
},
lighten(color, coefficient) {
const obj = this || theme;
if (obj.colorSpace) {
return `color-mix(in ${obj.colorSpace}, ${color}, #fff ${coefficientToPercentage(coefficient)})`;
}
return (0, _colorManipulator.lighten)(color, coefficient);
},
darken(color, coefficient) {
const obj = this || theme;
if (obj.colorSpace) {
return `color-mix(in ${obj.colorSpace}, ${color}, #000 ${coefficientToPercentage(coefficient)})`;
}
return (0, _colorManipulator.darken)(color, coefficient);
}
});
}
function createThemeNoVars(options = {}, ...args) {
const {
breakpoints: breakpointsInput,
mixins: mixinsInput = {},
spacing: spacingInput,
palette: paletteInput = {},
transitions: transitionsInput = {},
typography: typographyInput = {},
shape: shapeInput,
colorSpace,
...other
} = options;
if (options.vars &&
// The error should throw only for the root theme creation because user is not allowed to use a custom node `vars`.
// `generateThemeVars` is the closest identifier for checking that the `options` is a result of `createTheme` with CSS variables so that user can create new theme for nested ThemeProvider.
options.generateThemeVars === undefined) {
throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: `vars` is a private field used for CSS variables support.\n' +
// #host-reference
'Please use another name or follow the [docs](https://mui.com/material-ui/customization/css-theme-variables/usage/) to enable the feature.' : (0, _formatMuiErrorMessage.default)(20));
}
const palette = (0, _createPalette.default)({
...paletteInput,
colorSpace
});
const systemTheme = (0, _createTheme.default)(options);
let muiTheme = (0, _deepmerge.default)(systemTheme, {
mixins: (0, _createMixins.default)(systemTheme.breakpoints, mixinsInput),
palette,
// Don't use [...shadows] until you've verified its transpiled code is not invoking the iterator protocol.
shadows: _shadows.default.slice(),
typography: (0, _createTypography.default)(palette, typographyInput),
transitions: (0, _createTransitions.default)(transitionsInput),
zIndex: {
..._zIndex.default
}
});
muiTheme = (0, _deepmerge.default)(muiTheme, other);
muiTheme = args.reduce((acc, argument) => (0, _deepmerge.default)(acc, argument), muiTheme);
if (process.env.NODE_ENV !== 'production') {
// TODO v6: Refactor to use globalStateClassesMapping from @mui/utils once `readOnly` state class is used in Rating component.
const stateClasses = ['active', 'checked', 'completed', 'disabled', 'error', 'expanded', 'focused', 'focusVisible', 'required', 'selected'];
const traverse = (node, component) => {
let key;
// eslint-disable-next-line guard-for-in
for (key in node) {
const child = node[key];
if (stateClasses.includes(key) && Object.keys(child).length > 0) {
if (process.env.NODE_ENV !== 'production') {
const stateClass = (0, _generateUtilityClass.default)('', key);
console.error([`MUI: The \`${component}\` component increases ` + `the CSS specificity of the \`${key}\` internal state.`, 'You can not override it like this: ', JSON.stringify(node, null, 2), '', `Instead, you need to use the '&.${stateClass}' syntax:`, JSON.stringify({
root: {
[`&.${stateClass}`]: child
}
}, null, 2), '', 'https://mui.com/r/state-classes-guide'].join('\n'));
}
// Remove the style to prevent global conflicts.
node[key] = {};
}
}
};
Object.keys(muiTheme.components).forEach(component => {
const styleOverrides = muiTheme.components[component].styleOverrides;
if (styleOverrides && component.startsWith('Mui')) {
traverse(styleOverrides, component);
}
});
}
muiTheme.unstable_sxConfig = {
..._styleFunctionSx.unstable_defaultSxConfig,
...other?.unstable_sxConfig
};
muiTheme.unstable_sx = function sx(props) {
return (0, _styleFunctionSx.default)({
sx: props,
theme: this
});
};
muiTheme.toRuntimeSource = _stringifyTheme.stringifyTheme; // for Pigment CSS integration
attachColorManipulators(muiTheme);
return muiTheme;
}
var _default = exports.default = createThemeNoVars;

354
node_modules/@mui/material/styles/createThemeWithVars.d.ts generated vendored Normal file
View file

@ -0,0 +1,354 @@
import { OverridableStringUnion } from '@mui/types';
import { SxConfig, SxProps, CSSObject, ApplyStyles } from '@mui/system';
import { ExtractTypographyTokens } from '@mui/system/cssVars';
import { ThemeOptions, Theme } from "./createThemeNoVars.js";
import { Palette, PaletteOptions } from "./createPalette.js";
import { Shadows } from "./shadows.js";
import { ZIndex } from "./zIndex.js";
import { Components } from "./components.js";
/**
* default MD color-schemes
*/
export type DefaultColorScheme = 'light' | 'dark';
/**
* The application can add more color-scheme by extending this interface via module augmentation
*
* Ex.
* declare module @mui/material/styles {
* interface ColorSchemeOverrides {
* foo: true;
* }
* }
*
* // SupportedColorScheme = 'light' | 'dark' | 'foo';
*/
export interface ColorSchemeOverrides {}
export type ExtendedColorScheme = OverridableStringUnion<never, ColorSchemeOverrides>;
/**
* All color-schemes that the application has
*/
export type SupportedColorScheme = DefaultColorScheme | ExtendedColorScheme;
export interface Opacity {
inputPlaceholder: number;
inputUnderline: number;
switchTrackDisabled: number;
switchTrack: number;
}
export type Overlays = [string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined, string | undefined];
export interface PaletteBackgroundChannel {
defaultChannel: string;
paperChannel: string;
}
export interface PaletteCommonChannel {
background: string;
backgroundChannel: string;
onBackground: string;
onBackgroundChannel: string;
}
export interface PaletteColorChannel {
mainChannel: string;
lightChannel: string;
darkChannel: string;
contrastTextChannel: string;
}
export interface PaletteActionChannel {
activeChannel: string;
selectedChannel: string;
}
export interface PaletteTextChannel {
primaryChannel: string;
secondaryChannel: string;
}
export interface PaletteAlert {
errorColor: string;
infoColor: string;
successColor: string;
warningColor: string;
errorFilledBg: string;
infoFilledBg: string;
successFilledBg: string;
warningFilledBg: string;
errorFilledColor: string;
infoFilledColor: string;
successFilledColor: string;
warningFilledColor: string;
errorStandardBg: string;
infoStandardBg: string;
successStandardBg: string;
warningStandardBg: string;
errorIconColor: string;
infoIconColor: string;
successIconColor: string;
warningIconColor: string;
}
export interface PaletteAppBar {
defaultBg: string;
darkBg: string;
darkColor: string;
}
export interface PaletteAvatar {
defaultBg: string;
}
export interface PaletteButton {
inheritContainedBg: string;
inheritContainedHoverBg: string;
}
export interface PaletteChip {
defaultBorder: string;
defaultAvatarColor: string;
defaultIconColor: string;
}
export interface PaletteFilledInput {
bg: string;
hoverBg: string;
disabledBg: string;
}
export interface PaletteLinearProgress {
primaryBg: string;
secondaryBg: string;
errorBg: string;
infoBg: string;
successBg: string;
warningBg: string;
}
export interface PaletteSkeleton {
bg: string;
}
export interface PaletteSlider {
primaryTrack: string;
secondaryTrack: string;
errorTrack: string;
infoTrack: string;
successTrack: string;
warningTrack: string;
}
export interface PaletteSnackbarContent {
bg: string;
color: string;
}
export interface PaletteSpeedDialAction {
fabHoverBg: string;
}
export interface PaletteStepConnector {
border: string;
}
export interface PaletteStepContent {
border: string;
}
export interface PaletteSwitch {
defaultColor: string;
defaultDisabledColor: string;
primaryDisabledColor: string;
secondaryDisabledColor: string;
errorDisabledColor: string;
infoDisabledColor: string;
successDisabledColor: string;
warningDisabledColor: string;
}
export interface PaletteTableCell {
border: string;
}
export interface PaletteTooltip {
bg: string;
}
// The Palette should be sync with `../themeCssVarsAugmentation/index.d.ts`
export interface ColorSystemOptions {
palette?: PaletteOptions & {
background?: Partial<PaletteBackgroundChannel>;
common?: Partial<PaletteCommonChannel>;
primary?: Partial<PaletteColorChannel>;
secondary?: Partial<PaletteColorChannel>;
error?: Partial<PaletteColorChannel>;
info?: Partial<PaletteColorChannel>;
success?: Partial<PaletteColorChannel>;
text?: Partial<PaletteTextChannel>;
dividerChannel?: Partial<string>;
action?: Partial<PaletteActionChannel>;
Alert?: Partial<PaletteAlert>;
AppBar?: Partial<PaletteAppBar>;
Avatar?: Partial<PaletteAvatar>;
Button?: Partial<PaletteButton>;
Chip?: Partial<PaletteChip>;
FilledInput?: Partial<PaletteFilledInput>;
LinearProgress?: Partial<PaletteLinearProgress>;
Skeleton?: Partial<PaletteSkeleton>;
Slider?: Partial<PaletteSlider>;
SnackbarContent?: Partial<PaletteSnackbarContent>;
SpeedDialAction?: Partial<PaletteSpeedDialAction>;
StepConnector?: Partial<PaletteStepConnector>;
StepContent?: Partial<PaletteStepContent>;
Switch?: Partial<PaletteSwitch>;
TableCell?: Partial<PaletteTableCell>;
Tooltip?: Partial<PaletteTooltip>;
};
opacity?: Partial<Opacity>;
overlays?: Overlays;
}
export interface CssVarsPalette {
common: PaletteCommonChannel;
primary: PaletteColorChannel;
secondary: PaletteColorChannel;
error: PaletteColorChannel;
info: PaletteColorChannel;
success: PaletteColorChannel;
warning: PaletteColorChannel;
text: PaletteTextChannel;
background: PaletteBackgroundChannel;
dividerChannel: string;
action: PaletteActionChannel;
Alert: PaletteAlert;
AppBar: PaletteAppBar;
Avatar: PaletteAvatar;
Button: PaletteButton;
Chip: PaletteChip;
FilledInput: PaletteFilledInput;
LinearProgress: PaletteLinearProgress;
Skeleton: PaletteSkeleton;
Slider: PaletteSlider;
SnackbarContent: PaletteSnackbarContent;
SpeedDialAction: PaletteSpeedDialAction;
StepConnector: PaletteStepConnector;
StepContent: PaletteStepContent;
Switch: PaletteSwitch;
TableCell: PaletteTableCell;
Tooltip: PaletteTooltip;
}
export interface ColorSystem {
palette: Palette & CssVarsPalette;
opacity: Opacity;
overlays: Overlays;
}
export interface CssVarsThemeOptions extends Omit<ThemeOptions, 'palette' | 'components'> {
/**
* @default 'light'
*/
defaultColorScheme?: SupportedColorScheme;
/**
* Prefix of the generated CSS variables
* @default 'mui'
*/
cssVarPrefix?: string;
/**
* Theme components
*/
components?: Components<Omit<Theme, 'components' | 'palette'> & CssVarsTheme>;
/**
* Color schemes configuration
*/
colorSchemes?: Partial<Record<DefaultColorScheme, boolean | ColorSystemOptions>> & (ExtendedColorScheme extends string ? Record<ExtendedColorScheme, ColorSystemOptions> : {});
/**
* The strategy to generate CSS variables
*
* @example 'media'
* Generate CSS variables using [prefers-color-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
*
* @example '.mode-%s'
* Generate CSS variables within a class .mode-light, .mode-dark
*
* @example '[data-mode-%s]'
* Generate CSS variables within a data attribute [data-mode-light], [data-mode-dark]
*/
colorSchemeSelector?: 'media' | 'class' | 'data' | string;
/**
* The selector to generate the global CSS variables (non-color-scheme related)
* @default ':root'
* @example ':host' // (for shadow DOM)
* @see https://mui.com/material-ui/customization/shadow-dom/#3-css-theme-variables-optional
*/
rootSelector?: string;
/**
* If `true`, the CSS color-scheme will not be set.
* https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme
* @default false
*/
disableCssColorScheme?: boolean;
/**
* If `true`, the CSS relative color will be used.
*/
nativeColor?: boolean;
/**
* A function to determine if the key, value should be attached as CSS Variable
* `keys` is an array that represents the object path keys.
* Ex, if the theme is { foo: { bar: 'var(--test)' } }
* then, keys = ['foo', 'bar']
* value = 'var(--test)'
*/
shouldSkipGeneratingVar?: (keys: string[], value: string | number) => boolean;
}
// should not include keys defined in `shouldSkipGeneratingVar` and have value typeof function
export interface ThemeVars {
font: ExtractTypographyTokens<Theme['typography']>;
palette: Omit<ColorSystem['palette'], 'colorScheme' | 'mode' | 'contrastThreshold' | 'tonalOffset' | 'getContrastText' | 'augmentColor'>;
opacity: Opacity;
overlays: Overlays;
shadows: Shadows;
shape: Theme['shape'];
spacing: string;
zIndex: ZIndex;
}
type Split<T, K extends keyof T = keyof T> = K extends string | number ? { [k in K]: Exclude<T[K], undefined> } : never;
type ConcatDeep<T> = T extends Record<string | number, infer V> ? keyof T extends string | number ? V extends string | number ? keyof T : keyof V extends string | number ? `${keyof T}-${ConcatDeep<Split<V>>}` : never : never : never;
/**
* Does not work for these cases:
* - { borderRadius: string | number } // the value can't be a union
* - { shadows: [string, string, ..., string] } // the value can't be an array
*/
type NormalizeVars<T> = ConcatDeep<Split<T>>;
// shut off automatic exporting for the Generics above
export {};
export interface ThemeCssVarOverrides {}
export type ThemeCssVar = OverridableStringUnion<NormalizeVars<Omit<ThemeVars, 'overlays' | 'shadows' | 'shape'>> | 'shape-borderRadius' | 'shadows-0' | 'shadows-1' | 'shadows-2' | 'shadows-3' | 'shadows-4' | 'shadows-5' | 'shadows-6' | 'shadows-7' | 'shadows-8' | 'shadows-9' | 'shadows-10' | 'shadows-11' | 'shadows-12' | 'shadows-13' | 'shadows-14' | 'shadows-15' | 'shadows-16' | 'shadows-17' | 'shadows-18' | 'shadows-19' | 'shadows-20' | 'shadows-21' | 'shadows-22' | 'shadows-23' | 'shadows-24' | 'overlays-0' | 'overlays-1' | 'overlays-2' | 'overlays-3' | 'overlays-4' | 'overlays-5' | 'overlays-6' | 'overlays-7' | 'overlays-8' | 'overlays-9' | 'overlays-10' | 'overlays-11' | 'overlays-12' | 'overlays-13' | 'overlays-14' | 'overlays-15' | 'overlays-16' | 'overlays-17' | 'overlays-18' | 'overlays-19' | 'overlays-20' | 'overlays-21' | 'overlays-22' | 'overlays-23' | 'overlays-24', ThemeCssVarOverrides>;
/**
* Theme properties generated by extendTheme and CssVarsProvider
*/
export interface CssVarsTheme extends ColorSystem {
colorSchemes: Partial<Record<SupportedColorScheme, ColorSystem>>;
rootSelector: string;
colorSchemeSelector: 'media' | 'class' | 'data' | string;
cssVarPrefix: string;
defaultColorScheme: SupportedColorScheme;
vars: ThemeVars;
getCssVar: (field: ThemeCssVar, ...vars: ThemeCssVar[]) => string;
getColorSchemeSelector: (colorScheme: SupportedColorScheme) => string;
generateThemeVars: () => ThemeVars;
generateStyleSheets: () => Array<Record<string, any>>;
generateSpacing: () => Theme['spacing'];
// Default theme tokens
spacing: Theme['spacing'];
breakpoints: Theme['breakpoints'];
shape: Theme['shape'];
typography: Theme['typography'];
transitions: Theme['transitions'];
shadows: Theme['shadows'];
mixins: Theme['mixins'];
zIndex: Theme['zIndex'];
direction: Theme['direction'];
/**
* A function to determine if the key, value should be attached as CSS Variable
* `keys` is an array that represents the object path keys.
* Ex, if the theme is { foo: { bar: 'var(--test)' } }
* then, keys = ['foo', 'bar']
* value = 'var(--test)'
*/
shouldSkipGeneratingVar: (keys: string[], value: string | number) => boolean;
unstable_sxConfig: SxConfig;
unstable_sx: (props: SxProps<CssVarsTheme>) => CSSObject;
applyStyles: ApplyStyles<SupportedColorScheme>;
}
/**
* Generate a theme base on the options received.
* @param options Takes an incomplete theme object and adds the missing parts.
* @param args Deep merge the arguments with the about to be returned theme.
* @returns A complete, ready-to-use theme object.
*/
export default function createThemeWithVars(options?: CssVarsThemeOptions, ...args: object[]): Omit<Theme, 'applyStyles'> & CssVarsTheme;

425
node_modules/@mui/material/styles/createThemeWithVars.js generated vendored Normal file
View file

@ -0,0 +1,425 @@
"use strict";
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createGetCssVar = void 0;
exports.default = createThemeWithVars;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
var _deepmerge = _interopRequireDefault(require("@mui/utils/deepmerge"));
var _system = require("@mui/system");
var _spacing = require("@mui/system/spacing");
var _cssVars = require("@mui/system/cssVars");
var _styleFunctionSx = _interopRequireWildcard(require("@mui/system/styleFunctionSx"));
var _colorManipulator = require("@mui/system/colorManipulator");
var _createThemeNoVars = _interopRequireDefault(require("./createThemeNoVars"));
var _createColorScheme = _interopRequireWildcard(require("./createColorScheme"));
var _shouldSkipGeneratingVar = _interopRequireDefault(require("./shouldSkipGeneratingVar"));
var _createGetSelector = _interopRequireDefault(require("./createGetSelector"));
var _stringifyTheme = require("./stringifyTheme");
var _createPalette = require("./createPalette");
function assignNode(obj, keys) {
keys.forEach(k => {
if (!obj[k]) {
obj[k] = {};
}
});
}
function setColor(obj, key, defaultValue) {
if (!obj[key] && defaultValue) {
obj[key] = defaultValue;
}
}
function toRgb(color) {
if (typeof color !== 'string' || !color.startsWith('hsl')) {
return color;
}
return (0, _colorManipulator.hslToRgb)(color);
}
function setColorChannel(obj, key) {
if (!(`${key}Channel` in obj)) {
// custom channel token is not provided, generate one.
// if channel token can't be generated, show a warning.
obj[`${key}Channel`] = (0, _colorManipulator.private_safeColorChannel)(toRgb(obj[key]), `MUI: Can't create \`palette.${key}Channel\` because \`palette.${key}\` is not one of these formats: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().` + '\n' + `To suppress this warning, you need to explicitly provide the \`palette.${key}Channel\` as a string (in rgb format, for example "12 12 12") or undefined if you want to remove the channel token.`);
}
}
function getSpacingVal(spacingInput) {
if (typeof spacingInput === 'number') {
return `${spacingInput}px`;
}
if (typeof spacingInput === 'string' || typeof spacingInput === 'function' || Array.isArray(spacingInput)) {
return spacingInput;
}
return '8px';
}
const silent = fn => {
try {
return fn();
} catch (error) {
// ignore error
}
return undefined;
};
const createGetCssVar = (cssVarPrefix = 'mui') => (0, _system.unstable_createGetCssVar)(cssVarPrefix);
exports.createGetCssVar = createGetCssVar;
function attachColorScheme(colorSpace, colorSchemes, scheme, restTheme, colorScheme) {
if (!scheme) {
return undefined;
}
scheme = scheme === true ? {} : scheme;
const mode = colorScheme === 'dark' ? 'dark' : 'light';
if (!restTheme) {
colorSchemes[colorScheme] = (0, _createColorScheme.default)({
...scheme,
palette: {
mode,
...scheme?.palette
},
colorSpace
});
return undefined;
}
const {
palette,
...muiTheme
} = (0, _createThemeNoVars.default)({
...restTheme,
palette: {
mode,
...scheme?.palette
},
colorSpace
});
colorSchemes[colorScheme] = {
...scheme,
palette,
opacity: {
...(0, _createColorScheme.getOpacity)(mode),
...scheme?.opacity
},
overlays: scheme?.overlays || (0, _createColorScheme.getOverlays)(mode)
};
return muiTheme;
}
/**
* A default `createThemeWithVars` comes with a single color scheme, either `light` or `dark` based on the `defaultColorScheme`.
* This is better suited for apps that only need a single color scheme.
*
* To enable built-in `light` and `dark` color schemes, either:
* 1. provide a `colorSchemeSelector` to define how the color schemes will change.
* 2. provide `colorSchemes.dark` will set `colorSchemeSelector: 'media'` by default.
*/
function createThemeWithVars(options = {}, ...args) {
const {
colorSchemes: colorSchemesInput = {
light: true
},
defaultColorScheme: defaultColorSchemeInput,
disableCssColorScheme = false,
cssVarPrefix = 'mui',
nativeColor = false,
shouldSkipGeneratingVar = _shouldSkipGeneratingVar.default,
colorSchemeSelector: selector = colorSchemesInput.light && colorSchemesInput.dark ? 'media' : undefined,
rootSelector = ':root',
...input
} = options;
const firstColorScheme = Object.keys(colorSchemesInput)[0];
const defaultColorScheme = defaultColorSchemeInput || (colorSchemesInput.light && firstColorScheme !== 'light' ? 'light' : firstColorScheme);
const getCssVar = createGetCssVar(cssVarPrefix);
const {
[defaultColorScheme]: defaultSchemeInput,
light: builtInLight,
dark: builtInDark,
...customColorSchemes
} = colorSchemesInput;
const colorSchemes = {
...customColorSchemes
};
let defaultScheme = defaultSchemeInput;
// For built-in light and dark color schemes, ensure that the value is valid if they are the default color scheme.
if (defaultColorScheme === 'dark' && !('dark' in colorSchemesInput) || defaultColorScheme === 'light' && !('light' in colorSchemesInput)) {
defaultScheme = true;
}
if (!defaultScheme) {
throw new Error(process.env.NODE_ENV !== "production" ? `MUI: The \`colorSchemes.${defaultColorScheme}\` option is either missing or invalid.` : (0, _formatMuiErrorMessage.default)(21, defaultColorScheme));
}
// The reason to use `oklch` is that it is the most perceptually uniform color space and widely supported.
let colorSpace;
if (nativeColor) {
colorSpace = 'oklch';
}
// Create the palette for the default color scheme, either `light`, `dark`, or custom color scheme.
const muiTheme = attachColorScheme(colorSpace, colorSchemes, defaultScheme, input, defaultColorScheme);
if (builtInLight && !colorSchemes.light) {
attachColorScheme(colorSpace, colorSchemes, builtInLight, undefined, 'light');
}
if (builtInDark && !colorSchemes.dark) {
attachColorScheme(colorSpace, colorSchemes, builtInDark, undefined, 'dark');
}
let theme = {
defaultColorScheme,
...muiTheme,
cssVarPrefix,
colorSchemeSelector: selector,
rootSelector,
getCssVar,
colorSchemes,
font: {
...(0, _cssVars.prepareTypographyVars)(muiTheme.typography),
...muiTheme.font
},
spacing: getSpacingVal(input.spacing)
};
Object.keys(theme.colorSchemes).forEach(key => {
const palette = theme.colorSchemes[key].palette;
const setCssVarColor = cssVar => {
const tokens = cssVar.split('-');
const color = tokens[1];
const colorToken = tokens[2];
return getCssVar(cssVar, palette[color][colorToken]);
};
// attach black & white channels to common node
if (palette.mode === 'light') {
setColor(palette.common, 'background', '#fff');
setColor(palette.common, 'onBackground', '#000');
}
if (palette.mode === 'dark') {
setColor(palette.common, 'background', '#000');
setColor(palette.common, 'onBackground', '#fff');
}
function colorMix(method, color, coefficient) {
if (colorSpace) {
let mixer;
if (method === _colorManipulator.private_safeAlpha) {
mixer = `transparent ${((1 - coefficient) * 100).toFixed(0)}%`;
}
if (method === _colorManipulator.private_safeDarken) {
mixer = `#000 ${(coefficient * 100).toFixed(0)}%`;
}
if (method === _colorManipulator.private_safeLighten) {
mixer = `#fff ${(coefficient * 100).toFixed(0)}%`;
}
return `color-mix(in ${colorSpace}, ${color}, ${mixer})`;
}
return method(color, coefficient);
}
// assign component variables
assignNode(palette, ['Alert', 'AppBar', 'Avatar', 'Button', 'Chip', 'FilledInput', 'LinearProgress', 'Skeleton', 'Slider', 'SnackbarContent', 'SpeedDialAction', 'StepConnector', 'StepContent', 'Switch', 'TableCell', 'Tooltip']);
if (palette.mode === 'light') {
setColor(palette.Alert, 'errorColor', colorMix(_colorManipulator.private_safeDarken, palette.error.light, 0.6));
setColor(palette.Alert, 'infoColor', colorMix(_colorManipulator.private_safeDarken, palette.info.light, 0.6));
setColor(palette.Alert, 'successColor', colorMix(_colorManipulator.private_safeDarken, palette.success.light, 0.6));
setColor(palette.Alert, 'warningColor', colorMix(_colorManipulator.private_safeDarken, palette.warning.light, 0.6));
setColor(palette.Alert, 'errorFilledBg', setCssVarColor('palette-error-main'));
setColor(palette.Alert, 'infoFilledBg', setCssVarColor('palette-info-main'));
setColor(palette.Alert, 'successFilledBg', setCssVarColor('palette-success-main'));
setColor(palette.Alert, 'warningFilledBg', setCssVarColor('palette-warning-main'));
setColor(palette.Alert, 'errorFilledColor', silent(() => palette.getContrastText(palette.error.main)));
setColor(palette.Alert, 'infoFilledColor', silent(() => palette.getContrastText(palette.info.main)));
setColor(palette.Alert, 'successFilledColor', silent(() => palette.getContrastText(palette.success.main)));
setColor(palette.Alert, 'warningFilledColor', silent(() => palette.getContrastText(palette.warning.main)));
setColor(palette.Alert, 'errorStandardBg', colorMix(_colorManipulator.private_safeLighten, palette.error.light, 0.9));
setColor(palette.Alert, 'infoStandardBg', colorMix(_colorManipulator.private_safeLighten, palette.info.light, 0.9));
setColor(palette.Alert, 'successStandardBg', colorMix(_colorManipulator.private_safeLighten, palette.success.light, 0.9));
setColor(palette.Alert, 'warningStandardBg', colorMix(_colorManipulator.private_safeLighten, palette.warning.light, 0.9));
setColor(palette.Alert, 'errorIconColor', setCssVarColor('palette-error-main'));
setColor(palette.Alert, 'infoIconColor', setCssVarColor('palette-info-main'));
setColor(palette.Alert, 'successIconColor', setCssVarColor('palette-success-main'));
setColor(palette.Alert, 'warningIconColor', setCssVarColor('palette-warning-main'));
setColor(palette.AppBar, 'defaultBg', setCssVarColor('palette-grey-100'));
setColor(palette.Avatar, 'defaultBg', setCssVarColor('palette-grey-400'));
setColor(palette.Button, 'inheritContainedBg', setCssVarColor('palette-grey-300'));
setColor(palette.Button, 'inheritContainedHoverBg', setCssVarColor('palette-grey-A100'));
setColor(palette.Chip, 'defaultBorder', setCssVarColor('palette-grey-400'));
setColor(palette.Chip, 'defaultAvatarColor', setCssVarColor('palette-grey-700'));
setColor(palette.Chip, 'defaultIconColor', setCssVarColor('palette-grey-700'));
setColor(palette.FilledInput, 'bg', 'rgba(0, 0, 0, 0.06)');
setColor(palette.FilledInput, 'hoverBg', 'rgba(0, 0, 0, 0.09)');
setColor(palette.FilledInput, 'disabledBg', 'rgba(0, 0, 0, 0.12)');
setColor(palette.LinearProgress, 'primaryBg', colorMix(_colorManipulator.private_safeLighten, palette.primary.main, 0.62));
setColor(palette.LinearProgress, 'secondaryBg', colorMix(_colorManipulator.private_safeLighten, palette.secondary.main, 0.62));
setColor(palette.LinearProgress, 'errorBg', colorMix(_colorManipulator.private_safeLighten, palette.error.main, 0.62));
setColor(palette.LinearProgress, 'infoBg', colorMix(_colorManipulator.private_safeLighten, palette.info.main, 0.62));
setColor(palette.LinearProgress, 'successBg', colorMix(_colorManipulator.private_safeLighten, palette.success.main, 0.62));
setColor(palette.LinearProgress, 'warningBg', colorMix(_colorManipulator.private_safeLighten, palette.warning.main, 0.62));
setColor(palette.Skeleton, 'bg', colorSpace ? colorMix(_colorManipulator.private_safeAlpha, palette.text.primary, 0.11) : `rgba(${setCssVarColor('palette-text-primaryChannel')} / 0.11)`);
setColor(palette.Slider, 'primaryTrack', colorMix(_colorManipulator.private_safeLighten, palette.primary.main, 0.62));
setColor(palette.Slider, 'secondaryTrack', colorMix(_colorManipulator.private_safeLighten, palette.secondary.main, 0.62));
setColor(palette.Slider, 'errorTrack', colorMix(_colorManipulator.private_safeLighten, palette.error.main, 0.62));
setColor(palette.Slider, 'infoTrack', colorMix(_colorManipulator.private_safeLighten, palette.info.main, 0.62));
setColor(palette.Slider, 'successTrack', colorMix(_colorManipulator.private_safeLighten, palette.success.main, 0.62));
setColor(palette.Slider, 'warningTrack', colorMix(_colorManipulator.private_safeLighten, palette.warning.main, 0.62));
const snackbarContentBackground = colorSpace ? colorMix(_colorManipulator.private_safeDarken, palette.background.default, 0.6825) // use `0.6825` instead of `0.8` to match the contrast ratio of JS implementation
: (0, _colorManipulator.private_safeEmphasize)(palette.background.default, 0.8);
setColor(palette.SnackbarContent, 'bg', snackbarContentBackground);
setColor(palette.SnackbarContent, 'color', silent(() => colorSpace ? _createPalette.dark.text.primary : palette.getContrastText(snackbarContentBackground)));
setColor(palette.SpeedDialAction, 'fabHoverBg', (0, _colorManipulator.private_safeEmphasize)(palette.background.paper, 0.15));
setColor(palette.StepConnector, 'border', setCssVarColor('palette-grey-400'));
setColor(palette.StepContent, 'border', setCssVarColor('palette-grey-400'));
setColor(palette.Switch, 'defaultColor', setCssVarColor('palette-common-white'));
setColor(palette.Switch, 'defaultDisabledColor', setCssVarColor('palette-grey-100'));
setColor(palette.Switch, 'primaryDisabledColor', colorMix(_colorManipulator.private_safeLighten, palette.primary.main, 0.62));
setColor(palette.Switch, 'secondaryDisabledColor', colorMix(_colorManipulator.private_safeLighten, palette.secondary.main, 0.62));
setColor(palette.Switch, 'errorDisabledColor', colorMix(_colorManipulator.private_safeLighten, palette.error.main, 0.62));
setColor(palette.Switch, 'infoDisabledColor', colorMix(_colorManipulator.private_safeLighten, palette.info.main, 0.62));
setColor(palette.Switch, 'successDisabledColor', colorMix(_colorManipulator.private_safeLighten, palette.success.main, 0.62));
setColor(palette.Switch, 'warningDisabledColor', colorMix(_colorManipulator.private_safeLighten, palette.warning.main, 0.62));
setColor(palette.TableCell, 'border', colorMix(_colorManipulator.private_safeLighten, colorMix(_colorManipulator.private_safeAlpha, palette.divider, 1), 0.88));
setColor(palette.Tooltip, 'bg', colorMix(_colorManipulator.private_safeAlpha, palette.grey[700], 0.92));
}
if (palette.mode === 'dark') {
setColor(palette.Alert, 'errorColor', colorMix(_colorManipulator.private_safeLighten, palette.error.light, 0.6));
setColor(palette.Alert, 'infoColor', colorMix(_colorManipulator.private_safeLighten, palette.info.light, 0.6));
setColor(palette.Alert, 'successColor', colorMix(_colorManipulator.private_safeLighten, palette.success.light, 0.6));
setColor(palette.Alert, 'warningColor', colorMix(_colorManipulator.private_safeLighten, palette.warning.light, 0.6));
setColor(palette.Alert, 'errorFilledBg', setCssVarColor('palette-error-dark'));
setColor(palette.Alert, 'infoFilledBg', setCssVarColor('palette-info-dark'));
setColor(palette.Alert, 'successFilledBg', setCssVarColor('palette-success-dark'));
setColor(palette.Alert, 'warningFilledBg', setCssVarColor('palette-warning-dark'));
setColor(palette.Alert, 'errorFilledColor', silent(() => palette.getContrastText(palette.error.dark)));
setColor(palette.Alert, 'infoFilledColor', silent(() => palette.getContrastText(palette.info.dark)));
setColor(palette.Alert, 'successFilledColor', silent(() => palette.getContrastText(palette.success.dark)));
setColor(palette.Alert, 'warningFilledColor', silent(() => palette.getContrastText(palette.warning.dark)));
setColor(palette.Alert, 'errorStandardBg', colorMix(_colorManipulator.private_safeDarken, palette.error.light, 0.9));
setColor(palette.Alert, 'infoStandardBg', colorMix(_colorManipulator.private_safeDarken, palette.info.light, 0.9));
setColor(palette.Alert, 'successStandardBg', colorMix(_colorManipulator.private_safeDarken, palette.success.light, 0.9));
setColor(palette.Alert, 'warningStandardBg', colorMix(_colorManipulator.private_safeDarken, palette.warning.light, 0.9));
setColor(palette.Alert, 'errorIconColor', setCssVarColor('palette-error-main'));
setColor(palette.Alert, 'infoIconColor', setCssVarColor('palette-info-main'));
setColor(palette.Alert, 'successIconColor', setCssVarColor('palette-success-main'));
setColor(palette.Alert, 'warningIconColor', setCssVarColor('palette-warning-main'));
setColor(palette.AppBar, 'defaultBg', setCssVarColor('palette-grey-900'));
setColor(palette.AppBar, 'darkBg', setCssVarColor('palette-background-paper')); // specific for dark mode
setColor(palette.AppBar, 'darkColor', setCssVarColor('palette-text-primary')); // specific for dark mode
setColor(palette.Avatar, 'defaultBg', setCssVarColor('palette-grey-600'));
setColor(palette.Button, 'inheritContainedBg', setCssVarColor('palette-grey-800'));
setColor(palette.Button, 'inheritContainedHoverBg', setCssVarColor('palette-grey-700'));
setColor(palette.Chip, 'defaultBorder', setCssVarColor('palette-grey-700'));
setColor(palette.Chip, 'defaultAvatarColor', setCssVarColor('palette-grey-300'));
setColor(palette.Chip, 'defaultIconColor', setCssVarColor('palette-grey-300'));
setColor(palette.FilledInput, 'bg', 'rgba(255, 255, 255, 0.09)');
setColor(palette.FilledInput, 'hoverBg', 'rgba(255, 255, 255, 0.13)');
setColor(palette.FilledInput, 'disabledBg', 'rgba(255, 255, 255, 0.12)');
setColor(palette.LinearProgress, 'primaryBg', colorMix(_colorManipulator.private_safeDarken, palette.primary.main, 0.5));
setColor(palette.LinearProgress, 'secondaryBg', colorMix(_colorManipulator.private_safeDarken, palette.secondary.main, 0.5));
setColor(palette.LinearProgress, 'errorBg', colorMix(_colorManipulator.private_safeDarken, palette.error.main, 0.5));
setColor(palette.LinearProgress, 'infoBg', colorMix(_colorManipulator.private_safeDarken, palette.info.main, 0.5));
setColor(palette.LinearProgress, 'successBg', colorMix(_colorManipulator.private_safeDarken, palette.success.main, 0.5));
setColor(palette.LinearProgress, 'warningBg', colorMix(_colorManipulator.private_safeDarken, palette.warning.main, 0.5));
setColor(palette.Skeleton, 'bg', colorSpace ? colorMix(_colorManipulator.private_safeAlpha, palette.text.primary, 0.13) : `rgba(${setCssVarColor('palette-text-primaryChannel')} / 0.13)`);
setColor(palette.Slider, 'primaryTrack', colorMix(_colorManipulator.private_safeDarken, palette.primary.main, 0.5));
setColor(palette.Slider, 'secondaryTrack', colorMix(_colorManipulator.private_safeDarken, palette.secondary.main, 0.5));
setColor(palette.Slider, 'errorTrack', colorMix(_colorManipulator.private_safeDarken, palette.error.main, 0.5));
setColor(palette.Slider, 'infoTrack', colorMix(_colorManipulator.private_safeDarken, palette.info.main, 0.5));
setColor(palette.Slider, 'successTrack', colorMix(_colorManipulator.private_safeDarken, palette.success.main, 0.5));
setColor(palette.Slider, 'warningTrack', colorMix(_colorManipulator.private_safeDarken, palette.warning.main, 0.5));
const snackbarContentBackground = colorSpace ? colorMix(_colorManipulator.private_safeLighten, palette.background.default, 0.985) // use `0.985` instead of `0.98` to match the contrast ratio of JS implementation
: (0, _colorManipulator.private_safeEmphasize)(palette.background.default, 0.98);
setColor(palette.SnackbarContent, 'bg', snackbarContentBackground);
setColor(palette.SnackbarContent, 'color', silent(() => colorSpace ? _createPalette.light.text.primary : palette.getContrastText(snackbarContentBackground)));
setColor(palette.SpeedDialAction, 'fabHoverBg', (0, _colorManipulator.private_safeEmphasize)(palette.background.paper, 0.15));
setColor(palette.StepConnector, 'border', setCssVarColor('palette-grey-600'));
setColor(palette.StepContent, 'border', setCssVarColor('palette-grey-600'));
setColor(palette.Switch, 'defaultColor', setCssVarColor('palette-grey-300'));
setColor(palette.Switch, 'defaultDisabledColor', setCssVarColor('palette-grey-600'));
setColor(palette.Switch, 'primaryDisabledColor', colorMix(_colorManipulator.private_safeDarken, palette.primary.main, 0.55));
setColor(palette.Switch, 'secondaryDisabledColor', colorMix(_colorManipulator.private_safeDarken, palette.secondary.main, 0.55));
setColor(palette.Switch, 'errorDisabledColor', colorMix(_colorManipulator.private_safeDarken, palette.error.main, 0.55));
setColor(palette.Switch, 'infoDisabledColor', colorMix(_colorManipulator.private_safeDarken, palette.info.main, 0.55));
setColor(palette.Switch, 'successDisabledColor', colorMix(_colorManipulator.private_safeDarken, palette.success.main, 0.55));
setColor(palette.Switch, 'warningDisabledColor', colorMix(_colorManipulator.private_safeDarken, palette.warning.main, 0.55));
setColor(palette.TableCell, 'border', colorMix(_colorManipulator.private_safeDarken, colorMix(_colorManipulator.private_safeAlpha, palette.divider, 1), 0.68));
setColor(palette.Tooltip, 'bg', colorMix(_colorManipulator.private_safeAlpha, palette.grey[700], 0.92));
}
// MUI X - DataGrid needs this token.
setColorChannel(palette.background, 'default');
// added for consistency with the `background.default` token
setColorChannel(palette.background, 'paper');
setColorChannel(palette.common, 'background');
setColorChannel(palette.common, 'onBackground');
setColorChannel(palette, 'divider');
Object.keys(palette).forEach(color => {
const colors = palette[color];
// The default palettes (primary, secondary, error, info, success, and warning) errors are handled by the above `createTheme(...)`.
if (color !== 'tonalOffset' && colors && typeof colors === 'object') {
// Silent the error for custom palettes.
if (colors.main) {
setColor(palette[color], 'mainChannel', (0, _colorManipulator.private_safeColorChannel)(toRgb(colors.main)));
}
if (colors.light) {
setColor(palette[color], 'lightChannel', (0, _colorManipulator.private_safeColorChannel)(toRgb(colors.light)));
}
if (colors.dark) {
setColor(palette[color], 'darkChannel', (0, _colorManipulator.private_safeColorChannel)(toRgb(colors.dark)));
}
if (colors.contrastText) {
setColor(palette[color], 'contrastTextChannel', (0, _colorManipulator.private_safeColorChannel)(toRgb(colors.contrastText)));
}
if (color === 'text') {
// Text colors: text.primary, text.secondary
setColorChannel(palette[color], 'primary');
setColorChannel(palette[color], 'secondary');
}
if (color === 'action') {
// Action colors: action.active, action.selected
if (colors.active) {
setColorChannel(palette[color], 'active');
}
if (colors.selected) {
setColorChannel(palette[color], 'selected');
}
}
}
});
});
theme = args.reduce((acc, argument) => (0, _deepmerge.default)(acc, argument), theme);
const parserConfig = {
prefix: cssVarPrefix,
disableCssColorScheme,
shouldSkipGeneratingVar,
getSelector: (0, _createGetSelector.default)(theme),
enableContrastVars: nativeColor
};
const {
vars,
generateThemeVars,
generateStyleSheets
} = (0, _cssVars.prepareCssVars)(theme, parserConfig);
theme.vars = vars;
Object.entries(theme.colorSchemes[theme.defaultColorScheme]).forEach(([key, value]) => {
theme[key] = value;
});
theme.generateThemeVars = generateThemeVars;
theme.generateStyleSheets = generateStyleSheets;
theme.generateSpacing = function generateSpacing() {
return (0, _system.createSpacing)(input.spacing, (0, _spacing.createUnarySpacing)(this));
};
theme.getColorSchemeSelector = (0, _cssVars.createGetColorSchemeSelector)(selector);
theme.spacing = theme.generateSpacing();
theme.shouldSkipGeneratingVar = shouldSkipGeneratingVar;
theme.unstable_sxConfig = {
..._styleFunctionSx.unstable_defaultSxConfig,
...input?.unstable_sxConfig
};
theme.unstable_sx = function sx(props) {
return (0, _styleFunctionSx.default)({
sx: props,
theme: this
});
};
theme.toRuntimeSource = _stringifyTheme.stringifyTheme; // for Pigment CSS integration
return theme;
}

51
node_modules/@mui/material/styles/createTransitions.d.ts generated vendored Normal file
View file

@ -0,0 +1,51 @@
export interface Easing {
easeInOut: string;
easeOut: string;
easeIn: string;
sharp: string;
}
export const easing: Easing;
export interface Duration {
shortest: number;
shorter: number;
short: number;
standard: number;
complex: number;
enteringScreen: number;
leavingScreen: number;
}
export const duration: Duration;
export interface TransitionsOptions {
easing?: Partial<Easing>;
duration?: Partial<Duration>;
create?: (props: string | string[], options?: Partial<{
duration: number | string;
easing: string;
delay: number | string;
}>) => string;
getAutoHeightDuration?: (height: number) => number;
}
/**
* @internal
* @param props
* @param options
*/
export function create(props: string | string[], options?: Partial<{
duration: number | string;
easing: string;
delay: number | string;
}>): string;
/**
* @internal
* @param height
*/
export function getAutoHeightDuration(height: number): number;
export interface Transitions {
easing: Easing;
duration: Duration;
create: typeof create;
getAutoHeightDuration: typeof getAutoHeightDuration;
}
export default function createTransitions(inputTransitions: TransitionsOptions): Transitions;

96
node_modules/@mui/material/styles/createTransitions.js generated vendored Normal file
View file

@ -0,0 +1,96 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createTransitions;
exports.easing = exports.duration = void 0;
// Follow https://material.google.com/motion/duration-easing.html#duration-easing-natural-easing-curves
// to learn the context in which each easing should be used.
const easing = exports.easing = {
// This is the most common easing curve.
easeInOut: 'cubic-bezier(0.4, 0, 0.2, 1)',
// Objects enter the screen at full velocity from off-screen and
// slowly decelerate to a resting point.
easeOut: 'cubic-bezier(0.0, 0, 0.2, 1)',
// Objects leave the screen at full velocity. They do not decelerate when off-screen.
easeIn: 'cubic-bezier(0.4, 0, 1, 1)',
// The sharp curve is used by objects that may return to the screen at any time.
sharp: 'cubic-bezier(0.4, 0, 0.6, 1)'
};
// Follow https://m2.material.io/guidelines/motion/duration-easing.html#duration-easing-common-durations
// to learn when use what timing
const duration = exports.duration = {
shortest: 150,
shorter: 200,
short: 250,
// most basic recommended timing
standard: 300,
// this is to be used in complex animations
complex: 375,
// recommended when something is entering screen
enteringScreen: 225,
// recommended when something is leaving screen
leavingScreen: 195
};
function formatMs(milliseconds) {
return `${Math.round(milliseconds)}ms`;
}
function getAutoHeightDuration(height) {
if (!height) {
return 0;
}
const constant = height / 36;
// https://www.desmos.com/calculator/vbrp3ggqet
return Math.min(Math.round((4 + 15 * constant ** 0.25 + constant / 5) * 10), 3000);
}
function createTransitions(inputTransitions) {
const mergedEasing = {
...easing,
...inputTransitions.easing
};
const mergedDuration = {
...duration,
...inputTransitions.duration
};
const create = (props = ['all'], options = {}) => {
const {
duration: durationOption = mergedDuration.standard,
easing: easingOption = mergedEasing.easeInOut,
delay = 0,
...other
} = options;
if (process.env.NODE_ENV !== 'production') {
const isString = value => typeof value === 'string';
const isNumber = value => !Number.isNaN(parseFloat(value));
if (!isString(props) && !Array.isArray(props)) {
console.error('MUI: Argument "props" must be a string or Array.');
}
if (!isNumber(durationOption) && !isString(durationOption)) {
console.error(`MUI: Argument "duration" must be a number or a string but found ${durationOption}.`);
}
if (!isString(easingOption)) {
console.error('MUI: Argument "easing" must be a string.');
}
if (!isNumber(delay) && !isString(delay)) {
console.error('MUI: Argument "delay" must be a number or a string.');
}
if (typeof options !== 'object') {
console.error(['MUI: Secong argument of transition.create must be an object.', "Arguments should be either `create('prop1', options)` or `create(['prop1', 'prop2'], options)`"].join('\n'));
}
if (Object.keys(other).length !== 0) {
console.error(`MUI: Unrecognized argument(s) [${Object.keys(other).join(',')}].`);
}
}
return (Array.isArray(props) ? props : [props]).map(animatedProp => `${animatedProp} ${typeof durationOption === 'string' ? durationOption : formatMs(durationOption)} ${easingOption} ${typeof delay === 'string' ? delay : formatMs(delay)}`).join(',');
};
return {
getAutoHeightDuration,
create,
...inputTransitions,
easing: mergedEasing,
duration: mergedDuration
};
}

28
node_modules/@mui/material/styles/createTypography.d.ts generated vendored Normal file
View file

@ -0,0 +1,28 @@
import * as React from 'react';
import { CSSProperties } from "./createMixins.js";
import { Palette } from "./createPalette.js";
export type TypographyVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'subtitle1' | 'subtitle2' | 'body1' | 'body2' | 'caption' | 'button' | 'overline';
export interface FontStyle {
fontFamily: React.CSSProperties['fontFamily'];
fontSize: number;
fontWeightLight: React.CSSProperties['fontWeight'];
fontWeightRegular: React.CSSProperties['fontWeight'];
fontWeightMedium: React.CSSProperties['fontWeight'];
fontWeightBold: React.CSSProperties['fontWeight'];
htmlFontSize: number;
}
export interface FontStyleOptions extends Partial<FontStyle> {
allVariants?: React.CSSProperties;
}
// TODO: which one should actually be allowed to be subject to module augmentation?
// current type vs interface decision is kept for historical reasons until we
// made a decision
export type TypographyStyle = CSSProperties;
export interface TypographyStyleOptions extends TypographyStyle {}
export interface TypographyUtils {
pxToRem: (px: number) => string;
}
export interface TypographyVariants extends Record<TypographyVariant, TypographyStyle>, FontStyle, TypographyUtils {}
export interface TypographyVariantsOptions extends Partial<Record<TypographyVariant, TypographyStyleOptions> & FontStyleOptions> {}
export default function createTypography(palette: Palette, typography: TypographyVariantsOptions | ((palette: Palette) => TypographyVariantsOptions)): TypographyVariants;

99
node_modules/@mui/material/styles/createTypography.js generated vendored Normal file
View file

@ -0,0 +1,99 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createTypography;
var _deepmerge = _interopRequireDefault(require("@mui/utils/deepmerge"));
function round(value) {
return Math.round(value * 1e5) / 1e5;
}
const caseAllCaps = {
textTransform: 'uppercase'
};
const defaultFontFamily = '"Roboto", "Helvetica", "Arial", sans-serif';
/**
* @see @link{https://m2.material.io/design/typography/the-type-system.html}
* @see @link{https://m2.material.io/design/typography/understanding-typography.html}
*/
function createTypography(palette, typography) {
const {
fontFamily = defaultFontFamily,
// The default font size of the Material Specification.
fontSize = 14,
// px
fontWeightLight = 300,
fontWeightRegular = 400,
fontWeightMedium = 500,
fontWeightBold = 700,
// Tell MUI what's the font-size on the html element.
// 16px is the default font-size used by browsers.
htmlFontSize = 16,
// Apply the CSS properties to all the variants.
allVariants,
pxToRem: pxToRem2,
...other
} = typeof typography === 'function' ? typography(palette) : typography;
if (process.env.NODE_ENV !== 'production') {
if (typeof fontSize !== 'number') {
console.error('MUI: `fontSize` is required to be a number.');
}
if (typeof htmlFontSize !== 'number') {
console.error('MUI: `htmlFontSize` is required to be a number.');
}
}
const coef = fontSize / 14;
const pxToRem = pxToRem2 || (size => `${size / htmlFontSize * coef}rem`);
const buildVariant = (fontWeight, size, lineHeight, letterSpacing, casing) => ({
fontFamily,
fontWeight,
fontSize: pxToRem(size),
// Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/
lineHeight,
// The letter spacing was designed for the Roboto font-family. Using the same letter-spacing
// across font-families can cause issues with the kerning.
...(fontFamily === defaultFontFamily ? {
letterSpacing: `${round(letterSpacing / size)}em`
} : {}),
...casing,
...allVariants
});
const variants = {
h1: buildVariant(fontWeightLight, 96, 1.167, -1.5),
h2: buildVariant(fontWeightLight, 60, 1.2, -0.5),
h3: buildVariant(fontWeightRegular, 48, 1.167, 0),
h4: buildVariant(fontWeightRegular, 34, 1.235, 0.25),
h5: buildVariant(fontWeightRegular, 24, 1.334, 0),
h6: buildVariant(fontWeightMedium, 20, 1.6, 0.15),
subtitle1: buildVariant(fontWeightRegular, 16, 1.75, 0.15),
subtitle2: buildVariant(fontWeightMedium, 14, 1.57, 0.1),
body1: buildVariant(fontWeightRegular, 16, 1.5, 0.15),
body2: buildVariant(fontWeightRegular, 14, 1.43, 0.15),
button: buildVariant(fontWeightMedium, 14, 1.75, 0.4, caseAllCaps),
caption: buildVariant(fontWeightRegular, 12, 1.66, 0.4),
overline: buildVariant(fontWeightRegular, 12, 2.66, 1, caseAllCaps),
// TODO v6: Remove handling of 'inherit' variant from the theme as it is already handled in Material UI's Typography component. Also, remember to remove the associated types.
inherit: {
fontFamily: 'inherit',
fontWeight: 'inherit',
fontSize: 'inherit',
lineHeight: 'inherit',
letterSpacing: 'inherit'
}
};
return (0, _deepmerge.default)({
htmlFontSize,
pxToRem,
fontFamily,
fontSize,
fontWeightLight,
fontWeightRegular,
fontWeightMedium,
fontWeightBold,
...variants
}, other, {
clone: false // No need to clone deep
});
}

25
node_modules/@mui/material/styles/cssUtils.d.ts generated vendored Normal file
View file

@ -0,0 +1,25 @@
import { CSSProperties } from "./createMixins.js";
export function isUnitless(value: string): boolean;
export function getUnit(input: string): string;
export function toUnitless(value: string): number;
export function convertLength(baseFontSize: string): (length: string, toUnit: string) => string;
export interface AlignPropertyParams {
size: number;
grid: number;
}
export function alignProperty(params: AlignPropertyParams): number;
export interface FontGridParams {
lineHeight: number;
pixels: number;
htmlFontSize: number;
}
export function fontGrid(params: FontGridParams): number;
export interface ResponsivePropertyParams {
cssProperty: string;
min: number;
max: number;
unit?: string;
breakpoints?: number[];
transform?: (value: number) => number;
}
export function responsiveProperty(params: ResponsivePropertyParams): CSSProperties;

137
node_modules/@mui/material/styles/cssUtils.js generated vendored Normal file
View file

@ -0,0 +1,137 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.alignProperty = alignProperty;
exports.convertLength = convertLength;
exports.fontGrid = fontGrid;
exports.getUnit = getUnit;
exports.isUnitless = isUnitless;
exports.responsiveProperty = responsiveProperty;
exports.toUnitless = toUnitless;
function isUnitless(value) {
return String(parseFloat(value)).length === String(value).length;
}
// Ported from Compass
// https://github.com/Compass/compass/blob/master/core/stylesheets/compass/typography/_units.scss
// Emulate the sass function "unit"
function getUnit(input) {
return String(input).match(/[\d.\-+]*\s*(.*)/)[1] || '';
}
// Emulate the sass function "unitless"
function toUnitless(length) {
return parseFloat(length);
}
// Convert any CSS <length> or <percentage> value to any another.
// From https://github.com/KyleAMathews/convert-css-length
function convertLength(baseFontSize) {
return (length, toUnit) => {
const fromUnit = getUnit(length);
// Optimize for cases where `from` and `to` units are accidentally the same.
if (fromUnit === toUnit) {
return length;
}
// Convert input length to pixels.
let pxLength = toUnitless(length);
if (fromUnit !== 'px') {
if (fromUnit === 'em') {
pxLength = toUnitless(length) * toUnitless(baseFontSize);
} else if (fromUnit === 'rem') {
pxLength = toUnitless(length) * toUnitless(baseFontSize);
}
}
// Convert length in pixels to the output unit
let outputLength = pxLength;
if (toUnit !== 'px') {
if (toUnit === 'em') {
outputLength = pxLength / toUnitless(baseFontSize);
} else if (toUnit === 'rem') {
outputLength = pxLength / toUnitless(baseFontSize);
} else {
return length;
}
}
return parseFloat(outputLength.toFixed(5)) + toUnit;
};
}
function alignProperty({
size,
grid
}) {
const sizeBelow = size - size % grid;
const sizeAbove = sizeBelow + grid;
return size - sizeBelow < sizeAbove - size ? sizeBelow : sizeAbove;
}
// fontGrid finds a minimal grid (in rem) for the fontSize values so that the
// lineHeight falls under a x pixels grid, 4px in the case of Material Design,
// without changing the relative line height
function fontGrid({
lineHeight,
pixels,
htmlFontSize
}) {
return pixels / (lineHeight * htmlFontSize);
}
/**
* generate a responsive version of a given CSS property
* @example
* responsiveProperty({
* cssProperty: 'fontSize',
* min: 15,
* max: 20,
* unit: 'px',
* breakpoints: [300, 600],
* })
*
* // this returns
*
* {
* fontSize: '15px',
* '@media (min-width:300px)': {
* fontSize: '17.5px',
* },
* '@media (min-width:600px)': {
* fontSize: '20px',
* },
* }
* @param {Object} params
* @param {string} params.cssProperty - The CSS property to be made responsive
* @param {number} params.min - The smallest value of the CSS property
* @param {number} params.max - The largest value of the CSS property
* @param {string} [params.unit] - The unit to be used for the CSS property
* @param {Array.number} [params.breakpoints] - An array of breakpoints
* @param {number} [params.alignStep] - Round scaled value to fall under this grid
* @returns {Object} responsive styles for {params.cssProperty}
*/
function responsiveProperty({
cssProperty,
min,
max,
unit = 'rem',
breakpoints = [600, 900, 1200],
transform = null
}) {
const output = {
[cssProperty]: `${min}${unit}`
};
const factor = (max - min) / breakpoints[breakpoints.length - 1];
breakpoints.forEach(breakpoint => {
let value = min + factor * breakpoint;
if (transform !== null) {
value = transform(value);
}
output[`@media (min-width:${breakpoint}px)`] = {
[cssProperty]: `${Math.round(value * 10000) / 10000}${unit}`
};
});
return output;
}

11
node_modules/@mui/material/styles/defaultTheme.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _createTheme = _interopRequireDefault(require("./createTheme"));
const defaultTheme = (0, _createTheme.default)();
var _default = exports.default = defaultTheme;

5
node_modules/@mui/material/styles/excludeVariablesFromRoot.d.ts generated vendored Normal file
View file

@ -0,0 +1,5 @@
/**
* @internal These variables should not appear in the :root stylesheet when the `defaultColorScheme="dark"`
*/
declare const excludeVariablesFromRoot: (cssVarPrefix?: string) => string[];
export default excludeVariablesFromRoot;

11
node_modules/@mui/material/styles/excludeVariablesFromRoot.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
/**
* @internal These variables should not appear in the :root stylesheet when the `defaultColorScheme="dark"`
*/
const excludeVariablesFromRoot = cssVarPrefix => [...[...Array(25)].map((_, index) => `--${cssVarPrefix ? `${cssVarPrefix}-` : ''}overlays-${index}`), `--${cssVarPrefix ? `${cssVarPrefix}-` : ''}palette-AppBar-darkBg`, `--${cssVarPrefix ? `${cssVarPrefix}-` : ''}palette-AppBar-darkColor`];
var _default = exports.default = excludeVariablesFromRoot;

16
node_modules/@mui/material/styles/experimental_extendTheme.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = deprecatedExtendTheme;
var _createThemeWithVars = _interopRequireDefault(require("./createThemeWithVars"));
let warnedOnce = false;
function deprecatedExtendTheme(...args) {
if (!warnedOnce) {
console.warn(['MUI: The `experimental_extendTheme` has been stabilized.', '', "You should use `import { extendTheme } from '@mui/material/styles'`"].join('\n'));
warnedOnce = true;
}
return (0, _createThemeWithVars.default)(...args);
}

1
node_modules/@mui/material/styles/getOverlayAlpha.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export default function getOverlayAlpha(elevation: number): number;

16
node_modules/@mui/material/styles/getOverlayAlpha.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = getOverlayAlpha;
// Inspired by https://github.com/material-components/material-components-ios/blob/bca36107405594d5b7b16265a5b0ed698f85a5ee/components/Elevation/src/UIColor%2BMaterialElevation.m#L61
function getOverlayAlpha(elevation) {
let alphaValue;
if (elevation < 1) {
alphaValue = 5.11916 * elevation ** 2;
} else {
alphaValue = 4.5 * Math.log(elevation + 1) + 2;
}
return Math.round(alphaValue * 10) / 1000;
}

2
node_modules/@mui/material/styles/identifier.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const _default: "$$material";
export default _default;

7
node_modules/@mui/material/styles/identifier.js generated vendored Normal file
View file

@ -0,0 +1,7 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _default = exports.default = '$$material';

68
node_modules/@mui/material/styles/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,68 @@
import { DistributiveOmit } from '@mui/types';
export { default as THEME_ID } from "./identifier.js";
export { default as createTheme, default as unstable_createMuiStrictModeTheme, ThemeOptions, Theme, CssThemeVariables } from "./createTheme.js";
export { default as adaptV4Theme, DeprecatedThemeOptions } from "./adaptV4Theme.js";
export { Shadows } from "./shadows.js";
export { ZIndex } from "./zIndex.js";
export { CommonColors, Palette, PaletteColor, PaletteColorOptions, PaletteOptions, SimplePaletteColorOptions, TypeText, TypeAction, TypeBackground, PaletteMode, Color } from "./createPalette.js";
export { default as createColorScheme } from "./createColorScheme.js";
export { default as createStyles } from "./createStyles.js";
export { TypographyVariants, TypographyVariantsOptions, TypographyStyle, TypographyVariant } from "./createTypography.js";
export { default as responsiveFontSizes } from "./responsiveFontSizes.js";
export { Duration, Easing, Transitions, TransitionsOptions, duration, easing } from "./createTransitions.js";
export { Mixins, CSSProperties, MixinsOptions } from "./createMixins.js";
export { Direction, Breakpoint, BreakpointOverrides, Breakpoints, BreakpointsOptions, CreateMUIStyled, Interpolation, CSSInterpolation, CSSObject, css, keyframes,
// color manipulators
hexToRgb, rgbToHex, hslToRgb, decomposeColor, recomposeColor, getContrastRatio, getLuminance, emphasize, alpha, darken, lighten, ColorFormat, ColorObject, StyledEngineProvider, SxProps } from '@mui/system';
export { unstable_createBreakpoints } from '@mui/system/createBreakpoints';
// TODO: Remove this function in v6.
// eslint-disable-next-line @typescript-eslint/naming-convention
export function experimental_sx(): any;
export { default as useTheme } from "./useTheme.js";
export { default as useThemeProps } from "./useThemeProps.js";
export * from "./useThemeProps.js";
export { default as styled } from "./styled.js";
export { default as ThemeProvider, ThemeProviderProps } from "./ThemeProvider.js";
export { ComponentsProps, ComponentsPropsList } from "./props.js";
export { ComponentsVariants } from "./variants.js";
export { ComponentsOverrides, ComponentNameToClassKey } from "./overrides.js";
export { Components } from "./components.js";
export { getUnit as unstable_getUnit, toUnitless as unstable_toUnitless } from "./cssUtils.js";
export type ClassNameMap<ClassKey extends string = string> = Record<ClassKey, string>;
export interface StyledComponentProps<ClassKey extends string = string> {
/**
* Override or extend the styles applied to the component.
*/
classes?: Partial<ClassNameMap<ClassKey>>;
}
/**
* All standard components exposed by `material-ui` are `StyledComponents` with
* certain `classes`, on which one can also set a top-level `className` and inline
* `style`.
* @deprecated will be removed in v5 for internal usage only
*/
export type StandardProps<ComponentProps, ClassKey extends string, Removals extends keyof ComponentProps = never> = DistributiveOmit<ComponentProps, 'classes' | Removals> & StyledComponentProps<ClassKey> & {
className?: string;
ref?: ComponentProps extends {
ref?: infer RefType;
} ? RefType : React.Ref<unknown>;
style?: React.CSSProperties;
};
export namespace PropTypes {
// keeping the type structure for backwards compat
type Color = 'inherit' | 'primary' | 'secondary' | 'default';
}
export { default as makeStyles } from "./makeStyles.js";
export { default as withStyles } from "./withStyles.js";
export { default as withTheme } from "./withTheme.js";
export * from "./ThemeProviderWithVars.js";
export type { StorageManager } from '@mui/system/cssVars';
export { default as extendTheme } from "./createThemeWithVars.js";
export type { ColorSchemeOverrides, SupportedColorScheme, ColorSystem, CssVarsPalette, Opacity, Overlays, PaletteAlert, PaletteActionChannel, PaletteAppBar, PaletteAvatar, PaletteChip, PaletteColorChannel, PaletteCommonChannel, PaletteFilledInput, PaletteLinearProgress, PaletteSkeleton, PaletteSlider, PaletteSnackbarContent, PaletteSpeedDialAction, PaletteStepConnector, PaletteStepContent, PaletteSwitch, PaletteTableCell, PaletteTextChannel, PaletteTooltip, CssVarsThemeOptions, CssVarsTheme, ThemeVars, ThemeCssVar, ThemeCssVarOverrides, ColorSystemOptions } from "./createThemeWithVars.js";
export { default as getOverlayAlpha } from "./getOverlayAlpha.js";
export { default as shouldSkipGeneratingVar } from "./shouldSkipGeneratingVar.js";
// Private methods for creating parts of the theme
export { default as private_createTypography } from "./createTypography.js";
export { default as private_excludeVariablesFromRoot } from "./excludeVariablesFromRoot.js";

348
node_modules/@mui/material/styles/index.js generated vendored Normal file
View file

@ -0,0 +1,348 @@
"use strict";
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _exportNames = {
experimental_sx: true,
THEME_ID: true,
adaptV4Theme: true,
hexToRgb: true,
rgbToHex: true,
hslToRgb: true,
decomposeColor: true,
recomposeColor: true,
getContrastRatio: true,
getLuminance: true,
emphasize: true,
alpha: true,
darken: true,
lighten: true,
css: true,
keyframes: true,
StyledEngineProvider: true,
unstable_createBreakpoints: true,
createTheme: true,
unstable_createMuiStrictModeTheme: true,
createStyles: true,
unstable_getUnit: true,
unstable_toUnitless: true,
responsiveFontSizes: true,
createTransitions: true,
duration: true,
easing: true,
createColorScheme: true,
useTheme: true,
useThemeProps: true,
styled: true,
ThemeProvider: true,
makeStyles: true,
withStyles: true,
withTheme: true,
extendTheme: true,
experimental_extendTheme: true,
getOverlayAlpha: true,
shouldSkipGeneratingVar: true,
private_createTypography: true,
private_createMixins: true,
private_excludeVariablesFromRoot: true
};
Object.defineProperty(exports, "StyledEngineProvider", {
enumerable: true,
get: function () {
return _system.StyledEngineProvider;
}
});
Object.defineProperty(exports, "THEME_ID", {
enumerable: true,
get: function () {
return _identifier.default;
}
});
Object.defineProperty(exports, "ThemeProvider", {
enumerable: true,
get: function () {
return _ThemeProvider.default;
}
});
Object.defineProperty(exports, "adaptV4Theme", {
enumerable: true,
get: function () {
return _adaptV4Theme.default;
}
});
Object.defineProperty(exports, "alpha", {
enumerable: true,
get: function () {
return _system.alpha;
}
});
Object.defineProperty(exports, "createColorScheme", {
enumerable: true,
get: function () {
return _createColorScheme.default;
}
});
Object.defineProperty(exports, "createStyles", {
enumerable: true,
get: function () {
return _createStyles.default;
}
});
Object.defineProperty(exports, "createTheme", {
enumerable: true,
get: function () {
return _createTheme.default;
}
});
Object.defineProperty(exports, "createTransitions", {
enumerable: true,
get: function () {
return _createTransitions.default;
}
});
Object.defineProperty(exports, "css", {
enumerable: true,
get: function () {
return _system.css;
}
});
Object.defineProperty(exports, "darken", {
enumerable: true,
get: function () {
return _system.darken;
}
});
Object.defineProperty(exports, "decomposeColor", {
enumerable: true,
get: function () {
return _system.decomposeColor;
}
});
Object.defineProperty(exports, "duration", {
enumerable: true,
get: function () {
return _createTransitions.duration;
}
});
Object.defineProperty(exports, "easing", {
enumerable: true,
get: function () {
return _createTransitions.easing;
}
});
Object.defineProperty(exports, "emphasize", {
enumerable: true,
get: function () {
return _system.emphasize;
}
});
Object.defineProperty(exports, "experimental_extendTheme", {
enumerable: true,
get: function () {
return _experimental_extendTheme.default;
}
});
exports.experimental_sx = experimental_sx;
Object.defineProperty(exports, "extendTheme", {
enumerable: true,
get: function () {
return _createThemeWithVars.default;
}
});
Object.defineProperty(exports, "getContrastRatio", {
enumerable: true,
get: function () {
return _system.getContrastRatio;
}
});
Object.defineProperty(exports, "getLuminance", {
enumerable: true,
get: function () {
return _system.getLuminance;
}
});
Object.defineProperty(exports, "getOverlayAlpha", {
enumerable: true,
get: function () {
return _getOverlayAlpha.default;
}
});
Object.defineProperty(exports, "hexToRgb", {
enumerable: true,
get: function () {
return _system.hexToRgb;
}
});
Object.defineProperty(exports, "hslToRgb", {
enumerable: true,
get: function () {
return _system.hslToRgb;
}
});
Object.defineProperty(exports, "keyframes", {
enumerable: true,
get: function () {
return _system.keyframes;
}
});
Object.defineProperty(exports, "lighten", {
enumerable: true,
get: function () {
return _system.lighten;
}
});
Object.defineProperty(exports, "makeStyles", {
enumerable: true,
get: function () {
return _makeStyles.default;
}
});
Object.defineProperty(exports, "private_createMixins", {
enumerable: true,
get: function () {
return _createMixins.default;
}
});
Object.defineProperty(exports, "private_createTypography", {
enumerable: true,
get: function () {
return _createTypography.default;
}
});
Object.defineProperty(exports, "private_excludeVariablesFromRoot", {
enumerable: true,
get: function () {
return _excludeVariablesFromRoot.default;
}
});
Object.defineProperty(exports, "recomposeColor", {
enumerable: true,
get: function () {
return _system.recomposeColor;
}
});
Object.defineProperty(exports, "responsiveFontSizes", {
enumerable: true,
get: function () {
return _responsiveFontSizes.default;
}
});
Object.defineProperty(exports, "rgbToHex", {
enumerable: true,
get: function () {
return _system.rgbToHex;
}
});
Object.defineProperty(exports, "shouldSkipGeneratingVar", {
enumerable: true,
get: function () {
return _shouldSkipGeneratingVar.default;
}
});
Object.defineProperty(exports, "styled", {
enumerable: true,
get: function () {
return _styled.default;
}
});
Object.defineProperty(exports, "unstable_createBreakpoints", {
enumerable: true,
get: function () {
return _createBreakpoints.unstable_createBreakpoints;
}
});
Object.defineProperty(exports, "unstable_createMuiStrictModeTheme", {
enumerable: true,
get: function () {
return _createMuiStrictModeTheme.default;
}
});
Object.defineProperty(exports, "unstable_getUnit", {
enumerable: true,
get: function () {
return _cssUtils.getUnit;
}
});
Object.defineProperty(exports, "unstable_toUnitless", {
enumerable: true,
get: function () {
return _cssUtils.toUnitless;
}
});
Object.defineProperty(exports, "useTheme", {
enumerable: true,
get: function () {
return _useTheme.default;
}
});
Object.defineProperty(exports, "useThemeProps", {
enumerable: true,
get: function () {
return _useThemeProps.default;
}
});
Object.defineProperty(exports, "withStyles", {
enumerable: true,
get: function () {
return _withStyles.default;
}
});
Object.defineProperty(exports, "withTheme", {
enumerable: true,
get: function () {
return _withTheme.default;
}
});
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
var _identifier = _interopRequireDefault(require("./identifier"));
var _adaptV4Theme = _interopRequireDefault(require("./adaptV4Theme"));
var _system = require("@mui/system");
var _createBreakpoints = require("@mui/system/createBreakpoints");
var _createTheme = _interopRequireDefault(require("./createTheme"));
var _createMuiStrictModeTheme = _interopRequireDefault(require("./createMuiStrictModeTheme"));
var _createStyles = _interopRequireDefault(require("./createStyles"));
var _cssUtils = require("./cssUtils");
var _responsiveFontSizes = _interopRequireDefault(require("./responsiveFontSizes"));
var _createTransitions = _interopRequireWildcard(require("./createTransitions"));
var _createColorScheme = _interopRequireDefault(require("./createColorScheme"));
var _useTheme = _interopRequireDefault(require("./useTheme"));
var _useThemeProps = _interopRequireDefault(require("./useThemeProps"));
var _styled = _interopRequireDefault(require("./styled"));
var _ThemeProvider = _interopRequireDefault(require("./ThemeProvider"));
var _makeStyles = _interopRequireDefault(require("./makeStyles"));
var _withStyles = _interopRequireDefault(require("./withStyles"));
var _withTheme = _interopRequireDefault(require("./withTheme"));
var _ThemeProviderWithVars = require("./ThemeProviderWithVars");
Object.keys(_ThemeProviderWithVars).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _ThemeProviderWithVars[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _ThemeProviderWithVars[key];
}
});
});
var _createThemeWithVars = _interopRequireDefault(require("./createThemeWithVars"));
var _experimental_extendTheme = _interopRequireDefault(require("./experimental_extendTheme"));
var _getOverlayAlpha = _interopRequireDefault(require("./getOverlayAlpha"));
var _shouldSkipGeneratingVar = _interopRequireDefault(require("./shouldSkipGeneratingVar"));
var _createTypography = _interopRequireDefault(require("./createTypography"));
var _createMixins = _interopRequireDefault(require("./createMixins"));
var _excludeVariablesFromRoot = _interopRequireDefault(require("./excludeVariablesFromRoot"));
// TODO: Remove this function in v6.
// eslint-disable-next-line @typescript-eslint/naming-convention
function experimental_sx() {
throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: The `experimental_sx` has been moved to `theme.unstable_sx`.' + 'For more details, see https://github.com/mui/material-ui/pull/35150.' : (0, _formatMuiErrorMessage.default)(19));
}
// The legacy utilities from @mui/styles
// These are just empty functions that throws when invoked
// TODO: Remove in v7
// Private methods for creating parts of the theme

1
node_modules/@mui/material/styles/makeStyles.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export default function makeStyles(stylesCreator: any, options?: object): never;

11
node_modules/@mui/material/styles/makeStyles.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = makeStyles;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
function makeStyles() {
throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: makeStyles is no longer exported from @mui/material/styles.\n' + 'You have to import it from @mui/styles.\n' + 'See https://mui.com/r/migration-v4/#mui-material-styles for more details.' : (0, _formatMuiErrorMessage.default)(14));
}

246
node_modules/@mui/material/styles/overrides.d.ts generated vendored Normal file
View file

@ -0,0 +1,246 @@
import { CSSObject, CSSInterpolation, Interpolation } from '@mui/system';
import { PopperClassKey } from "../Popper/index.js";
import { ComponentsPropsList } from "./props.js";
import { AccordionActionsClassKey } from "../AccordionActions/index.js";
import { AccordionClassKey } from "../Accordion/index.js";
import { AccordionDetailsClassKey } from "../AccordionDetails/index.js";
import { AccordionSummaryClassKey } from "../AccordionSummary/index.js";
import { AlertClassKey } from "../Alert/index.js";
import { AlertTitleClassKey } from "../AlertTitle/index.js";
import { AppBarClassKey } from "../AppBar/index.js";
import { AutocompleteClassKey } from "../Autocomplete/index.js";
import { AvatarClassKey } from "../Avatar/index.js";
import { AvatarGroupClassKey } from "../AvatarGroup/index.js";
import { BackdropClassKey } from "../Backdrop/index.js";
import { BadgeClassKey } from "../Badge/index.js";
import { BottomNavigationActionClassKey } from "../BottomNavigationAction/index.js";
import { BottomNavigationClassKey } from "../BottomNavigation/index.js";
import { BreadcrumbsClassKey } from "../Breadcrumbs/index.js";
import { ButtonBaseClassKey } from "../ButtonBase/index.js";
import { ButtonClassKey } from "../Button/index.js";
import { ButtonGroupClassKey } from "../ButtonGroup/index.js";
import { CardActionAreaClassKey } from "../CardActionArea/index.js";
import { CardActionsClassKey } from "../CardActions/index.js";
import { CardClassKey } from "../Card/index.js";
import { CardContentClassKey } from "../CardContent/index.js";
import { CardHeaderClassKey } from "../CardHeader/index.js";
import { CardMediaClassKey } from "../CardMedia/index.js";
import { CheckboxClassKey } from "../Checkbox/index.js";
import { ChipClassKey } from "../Chip/index.js";
import { CircularProgressClassKey } from "../CircularProgress/index.js";
import { CollapseClassKey } from "../Collapse/index.js";
import { ContainerClassKey } from "../Container/index.js";
import { DialogActionsClassKey } from "../DialogActions/index.js";
import { DialogClassKey } from "../Dialog/index.js";
import { DialogContentClassKey } from "../DialogContent/index.js";
import { DialogContentTextClassKey } from "../DialogContentText/index.js";
import { DialogTitleClassKey } from "../DialogTitle/index.js";
import { DividerClassKey } from "../Divider/index.js";
import { DrawerClassKey } from "../Drawer/index.js";
import { FabClassKey } from "../Fab/index.js";
import { FilledInputClassKey } from "../FilledInput/index.js";
import { FormControlClassKey } from "../FormControl/index.js";
import { FormControlLabelClassKey } from "../FormControlLabel/index.js";
import { FormGroupClassKey } from "../FormGroup/index.js";
import { FormHelperTextClassKey } from "../FormHelperText/index.js";
import { FormLabelClassKey } from "../FormLabel/index.js";
import { GridLegacyClassKey } from "../GridLegacy/index.js";
import { GridClassKey } from "../Grid/index.js";
import { IconButtonClassKey } from "../IconButton/index.js";
import { IconClassKey } from "../Icon/index.js";
import { ImageListClassKey } from "../ImageList/index.js";
import { ImageListItemBarClassKey } from "../ImageListItemBar/index.js";
import { ImageListItemClassKey } from "../ImageListItem/index.js";
import { InputAdornmentClassKey } from "../InputAdornment/index.js";
import { InputBaseClassKey } from "../InputBase/index.js";
import { InputClassKey } from "../Input/index.js";
import { InputLabelClassKey } from "../InputLabel/index.js";
import { LinearProgressClassKey } from "../LinearProgress/index.js";
import { LinkClassKey } from "../Link/index.js";
import { ListClassKey } from "../List/index.js";
import { ListItemAvatarClassKey } from "../ListItemAvatar/index.js";
import { ListItemClassKey } from "../ListItem/index.js";
import { ListItemButtonClassKey } from "../ListItemButton/index.js";
import { ListItemIconClassKey } from "../ListItemIcon/index.js";
import { ListItemSecondaryActionClassKey } from "../ListItemSecondaryAction/index.js";
import { ListItemTextClassKey } from "../ListItemText/index.js";
import { ListSubheaderClassKey } from "../ListSubheader/index.js";
import { MenuClassKey } from "../Menu/index.js";
import { MenuItemClassKey } from "../MenuItem/index.js";
import { MenuListClassKey } from "../MenuList/index.js";
import { MobileStepperClassKey } from "../MobileStepper/index.js";
import { ModalClassKey } from "../Modal/index.js";
import { NativeSelectClassKey } from "../NativeSelect/index.js";
import { OutlinedInputClassKey } from "../OutlinedInput/index.js";
import { PaginationClassKey } from "../Pagination/index.js";
import { PaginationItemClassKey } from "../PaginationItem/index.js";
import { PaperClassKey } from "../Paper/index.js";
import { PopoverClassKey } from "../Popover/index.js";
import { RadioClassKey } from "../Radio/index.js";
import { RadioGroupClassKey } from "../RadioGroup/index.js";
import { RatingClassKey } from "../Rating/index.js";
import { ScopedCssBaselineClassKey } from "../ScopedCssBaseline/index.js";
import { SelectClassKey } from "../Select/index.js";
import { SkeletonClassKey } from "../Skeleton/index.js";
import { SliderClassKey } from "../Slider/index.js";
import { SnackbarClassKey } from "../Snackbar/index.js";
import { SnackbarContentClassKey } from "../SnackbarContent/index.js";
import { SpeedDialClassKey } from "../SpeedDial/index.js";
import { SpeedDialActionClassKey } from "../SpeedDialAction/index.js";
import { SpeedDialIconClassKey } from "../SpeedDialIcon/index.js";
import { StackClassKey } from "../Stack/index.js";
import { StepButtonClasskey } from "../StepButton/index.js";
import { StepClasskey } from "../Step/index.js";
import { StepConnectorClasskey } from "../StepConnector/index.js";
import { StepContentClasskey } from "../StepContent/index.js";
import { StepIconClasskey } from "../StepIcon/index.js";
import { StepLabelClasskey } from "../StepLabel/index.js";
import { StepperClasskey } from "../Stepper/index.js";
import { SvgIconClassKey } from "../SvgIcon/index.js";
import { SwitchClassKey } from "../Switch/index.js";
import { TabClassKey } from "../Tab/index.js";
import { TableBodyClassKey } from "../TableBody/index.js";
import { TableCellClassKey } from "../TableCell/index.js";
import { TableClassKey } from "../Table/index.js";
import { TableContainerClassKey } from "../TableContainer/index.js";
import { TableFooterClassKey } from "../TableFooter/index.js";
import { TableHeadClassKey } from "../TableHead/index.js";
import { TablePaginationClassKey } from "../TablePagination/index.js";
import { TablePaginationActionsClassKey } from "../TablePaginationActions/index.js";
import { TableRowClassKey } from "../TableRow/index.js";
import { TableSortLabelClassKey } from "../TableSortLabel/index.js";
import { TabsClassKey } from "../Tabs/index.js";
import { TextFieldClassKey } from "../TextField/index.js";
import { ToggleButtonClassKey } from "../ToggleButton/index.js";
import { ToggleButtonGroupClassKey } from "../ToggleButtonGroup/index.js";
import { ToolbarClassKey } from "../Toolbar/index.js";
import { TooltipClassKey } from "../Tooltip/index.js";
import { TouchRippleClassKey } from "../ButtonBase/TouchRipple.js";
import { TypographyClassKey } from "../Typography/index.js";
export type OverridesStyleRules<ClassKey extends string = string, ComponentName = keyof ComponentsPropsList, Theme = unknown> = Record<ClassKey, Interpolation<(ComponentName extends keyof ComponentsPropsList ? ComponentsPropsList[ComponentName] & Record<string, unknown> & {
ownerState: ComponentsPropsList[ComponentName] & Record<string, unknown>;
} : {}) & {
theme: Theme;
} & Record<string, unknown>>>;
export type ComponentsOverrides<Theme = unknown> = { [Name in keyof ComponentNameToClassKey]?: Partial<OverridesStyleRules<ComponentNameToClassKey[Name], Name, Theme>> } & {
MuiCssBaseline?: CSSObject | string | ((theme: Theme) => CSSInterpolation);
};
export interface ComponentNameToClassKey {
MuiAlert: AlertClassKey;
MuiAlertTitle: AlertTitleClassKey;
MuiAppBar: AppBarClassKey;
MuiAutocomplete: AutocompleteClassKey;
MuiAvatar: AvatarClassKey;
MuiAvatarGroup: AvatarGroupClassKey;
MuiBackdrop: BackdropClassKey;
MuiBadge: BadgeClassKey;
MuiBottomNavigation: BottomNavigationClassKey;
MuiBottomNavigationAction: BottomNavigationActionClassKey;
MuiBreadcrumbs: BreadcrumbsClassKey;
MuiButton: ButtonClassKey;
MuiButtonBase: ButtonBaseClassKey;
MuiButtonGroup: ButtonGroupClassKey;
MuiCard: CardClassKey;
MuiCardActionArea: CardActionAreaClassKey;
MuiCardActions: CardActionsClassKey;
MuiCardContent: CardContentClassKey;
MuiCardHeader: CardHeaderClassKey;
MuiCardMedia: CardMediaClassKey;
MuiCheckbox: CheckboxClassKey;
MuiChip: ChipClassKey;
MuiCircularProgress: CircularProgressClassKey;
MuiCollapse: CollapseClassKey;
MuiContainer: ContainerClassKey;
MuiDialog: DialogClassKey;
MuiDialogActions: DialogActionsClassKey;
MuiDialogContent: DialogContentClassKey;
MuiDialogContentText: DialogContentTextClassKey;
MuiDialogTitle: DialogTitleClassKey;
MuiDivider: DividerClassKey;
MuiDrawer: DrawerClassKey;
MuiAccordion: AccordionClassKey;
MuiAccordionActions: AccordionActionsClassKey;
MuiAccordionDetails: AccordionDetailsClassKey;
MuiAccordionSummary: AccordionSummaryClassKey;
MuiFab: FabClassKey;
MuiFilledInput: FilledInputClassKey;
MuiFormControl: FormControlClassKey;
MuiFormControlLabel: FormControlLabelClassKey;
MuiFormGroup: FormGroupClassKey;
MuiFormHelperText: FormHelperTextClassKey;
MuiFormLabel: FormLabelClassKey;
MuiGridLegacy: GridLegacyClassKey;
MuiGrid: GridClassKey;
MuiIcon: IconClassKey;
MuiIconButton: IconButtonClassKey;
MuiImageList: ImageListClassKey;
MuiImageListItem: ImageListItemClassKey;
MuiImageListItemBar: ImageListItemBarClassKey;
MuiInput: InputClassKey;
MuiInputAdornment: InputAdornmentClassKey;
MuiInputBase: InputBaseClassKey;
MuiInputLabel: InputLabelClassKey;
MuiLinearProgress: LinearProgressClassKey;
MuiLink: LinkClassKey;
MuiList: ListClassKey;
MuiListItem: ListItemClassKey;
MuiListItemButton: ListItemButtonClassKey;
MuiListItemAvatar: ListItemAvatarClassKey;
MuiListItemIcon: ListItemIconClassKey;
MuiListItemSecondaryAction: ListItemSecondaryActionClassKey;
MuiListItemText: ListItemTextClassKey;
MuiListSubheader: ListSubheaderClassKey;
MuiMenu: MenuClassKey;
MuiMenuItem: MenuItemClassKey;
MuiMenuList: MenuListClassKey;
MuiMobileStepper: MobileStepperClassKey;
MuiModal: ModalClassKey;
MuiNativeSelect: NativeSelectClassKey;
MuiOutlinedInput: OutlinedInputClassKey;
MuiPagination: PaginationClassKey;
MuiPaginationItem: PaginationItemClassKey;
MuiPaper: PaperClassKey;
MuiPopover: PopoverClassKey;
MuiPopper: PopperClassKey;
MuiRadio: RadioClassKey;
MuiRadioGroup: RadioGroupClassKey;
MuiRating: RatingClassKey;
MuiScopedCssBaseline: ScopedCssBaselineClassKey;
MuiSelect: SelectClassKey;
MuiSkeleton: SkeletonClassKey;
MuiSlider: SliderClassKey;
MuiSnackbar: SnackbarClassKey;
MuiSnackbarContent: SnackbarContentClassKey;
MuiSpeedDial: SpeedDialClassKey;
MuiSpeedDialAction: SpeedDialActionClassKey;
MuiSpeedDialIcon: SpeedDialIconClassKey;
MuiStack: StackClassKey;
MuiStep: StepClasskey;
MuiStepButton: StepButtonClasskey;
MuiStepConnector: StepConnectorClasskey;
MuiStepContent: StepContentClasskey;
MuiStepIcon: StepIconClasskey;
MuiStepLabel: StepLabelClasskey;
MuiStepper: StepperClasskey;
MuiSvgIcon: SvgIconClassKey;
MuiSwitch: SwitchClassKey;
MuiTab: TabClassKey;
MuiTable: TableClassKey;
MuiTableBody: TableBodyClassKey;
MuiTableCell: TableCellClassKey;
MuiTableContainer: TableContainerClassKey;
MuiTableFooter: TableFooterClassKey;
MuiTableHead: TableHeadClassKey;
MuiTablePagination: TablePaginationClassKey;
MuiTablePaginationActions: TablePaginationActionsClassKey;
MuiTableRow: TableRowClassKey;
MuiTableSortLabel: TableSortLabelClassKey;
MuiTabs: TabsClassKey;
MuiTextField: TextFieldClassKey;
MuiToggleButton: ToggleButtonClassKey;
MuiToggleButtonGroup: ToggleButtonGroupClassKey;
MuiToolbar: ToolbarClassKey;
MuiTooltip: TooltipClassKey;
MuiTouchRipple: TouchRippleClassKey;
MuiTypography: TypographyClassKey;
}

5
node_modules/@mui/material/styles/overrides.js generated vendored Normal file
View file

@ -0,0 +1,5 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});

243
node_modules/@mui/material/styles/props.d.ts generated vendored Normal file
View file

@ -0,0 +1,243 @@
import { AlertProps } from "../Alert/index.js";
import { AlertTitleProps } from "../AlertTitle/index.js";
import { AppBarProps } from "../AppBar/index.js";
import { AutocompleteProps } from "../Autocomplete/index.js";
import { AvatarProps } from "../Avatar/index.js";
import { AvatarGroupProps } from "../AvatarGroup/index.js";
import { BackdropProps } from "../Backdrop/index.js";
import { BadgeProps } from "../Badge/index.js";
import { BottomNavigationActionProps } from "../BottomNavigationAction/index.js";
import { BottomNavigationProps } from "../BottomNavigation/index.js";
import { BreadcrumbsProps } from "../Breadcrumbs/index.js";
import { ButtonBaseProps } from "../ButtonBase/index.js";
import { ButtonGroupProps } from "../ButtonGroup/index.js";
import { ButtonProps } from "../Button/index.js";
import { CardActionAreaProps } from "../CardActionArea/index.js";
import { CardActionsProps } from "../CardActions/index.js";
import { CardContentProps } from "../CardContent/index.js";
import { CardHeaderProps } from "../CardHeader/index.js";
import { CardMediaProps } from "../CardMedia/index.js";
import { CardProps } from "../Card/index.js";
import { CheckboxProps } from "../Checkbox/index.js";
import { ChipProps } from "../Chip/index.js";
import { CircularProgressProps } from "../CircularProgress/index.js";
import { CollapseProps } from "../Collapse/index.js";
import { ContainerProps } from "../Container/index.js";
import { CssBaselineProps } from "../CssBaseline/index.js";
import { DialogActionsProps } from "../DialogActions/index.js";
import { DialogContentProps } from "../DialogContent/index.js";
import { DialogContentTextProps } from "../DialogContentText/index.js";
import { DialogProps } from "../Dialog/index.js";
import { DialogTitleProps } from "../DialogTitle/index.js";
import { DividerProps } from "../Divider/index.js";
import { DrawerProps } from "../Drawer/index.js";
import { AccordionActionsProps } from "../AccordionActions/index.js";
import { AccordionDetailsProps } from "../AccordionDetails/index.js";
import { AccordionProps } from "../Accordion/index.js";
import { AccordionSummaryProps } from "../AccordionSummary/index.js";
import { FabProps } from "../Fab/index.js";
import { FilledInputProps } from "../FilledInput/index.js";
import { FormControlLabelProps } from "../FormControlLabel/index.js";
import { FormControlProps } from "../FormControl/index.js";
import { FormGroupProps } from "../FormGroup/index.js";
import { FormHelperTextProps } from "../FormHelperText/index.js";
import { FormLabelProps } from "../FormLabel/index.js";
import { GridLegacyProps } from "../GridLegacy/index.js";
import { GridProps } from "../Grid/index.js";
import { IconButtonProps } from "../IconButton/index.js";
import { IconProps } from "../Icon/index.js";
import { ImageListProps } from "../ImageList/index.js";
import { ImageListItemBarProps } from "../ImageListItemBar/index.js";
import { ImageListItemProps } from "../ImageListItem/index.js";
import { InputAdornmentProps } from "../InputAdornment/index.js";
import { InputBaseProps } from "../InputBase/index.js";
import { InputLabelProps } from "../InputLabel/index.js";
import { InputProps } from "../Input/index.js";
import { LinearProgressProps } from "../LinearProgress/index.js";
import { LinkProps } from "../Link/index.js";
import { ListItemAvatarProps } from "../ListItemAvatar/index.js";
import { ListItemIconProps } from "../ListItemIcon/index.js";
import { ListItemProps } from "../ListItem/index.js";
import { ListItemButtonProps } from "../ListItemButton/index.js";
import { ListItemSecondaryActionProps } from "../ListItemSecondaryAction/index.js";
import { ListItemTextProps } from "../ListItemText/index.js";
import { ListProps } from "../List/index.js";
import { ListSubheaderProps } from "../ListSubheader/index.js";
import { MenuItemProps } from "../MenuItem/index.js";
import { MenuListProps } from "../MenuList/index.js";
import { MenuProps } from "../Menu/index.js";
import { MobileStepperProps } from "../MobileStepper/index.js";
import { ModalProps } from "../Modal/index.js";
import { NativeSelectProps } from "../NativeSelect/index.js";
import { UseMediaQueryOptions } from "../useMediaQuery/index.js";
import { OutlinedInputProps } from "../OutlinedInput/index.js";
import { PaginationProps } from "../Pagination/index.js";
import { PaginationItemProps } from "../PaginationItem/index.js";
import { PaperProps } from "../Paper/index.js";
import { PopoverProps } from "../Popover/index.js";
import { RadioGroupProps } from "../RadioGroup/index.js";
import { RadioProps } from "../Radio/index.js";
import { RatingProps } from "../Rating/index.js";
import { ScopedCssBaselineProps } from "../ScopedCssBaseline/index.js";
import { SelectProps } from "../Select/index.js";
import { SkeletonProps } from "../Skeleton/index.js";
import { SliderProps } from "../Slider/index.js";
import { SnackbarContentProps } from "../SnackbarContent/index.js";
import { SnackbarProps } from "../Snackbar/index.js";
import { SpeedDialProps } from "../SpeedDial/index.js";
import { SpeedDialActionProps } from "../SpeedDialAction/index.js";
import { SpeedDialIconProps } from "../SpeedDialIcon/index.js";
import { StackProps } from "../Stack/index.js";
import { StepButtonProps } from "../StepButton/index.js";
import { StepConnectorProps } from "../StepConnector/index.js";
import { StepContentProps } from "../StepContent/index.js";
import { StepIconProps } from "../StepIcon/index.js";
import { StepLabelProps } from "../StepLabel/index.js";
import { StepperProps } from "../Stepper/index.js";
import { StepProps } from "../Step/index.js";
import { SvgIconProps } from "../SvgIcon/index.js";
import { SwipeableDrawerProps } from "../SwipeableDrawer/index.js";
import { SwitchProps } from "../Switch/index.js";
import { TableBodyProps } from "../TableBody/index.js";
import { TableCellProps } from "../TableCell/index.js";
import { TableContainerProps } from "../TableContainer/index.js";
import { TableHeadProps } from "../TableHead/index.js";
import { TablePaginationProps } from "../TablePagination/index.js";
import { TablePaginationActionsProps } from "../TablePaginationActions/index.js";
import { TableProps } from "../Table/index.js";
import { TableRowProps } from "../TableRow/index.js";
import { TableSortLabelProps } from "../TableSortLabel/index.js";
import { TableFooterProps } from "../TableFooter/index.js";
import { TabProps } from "../Tab/index.js";
import { TabsProps } from "../Tabs/index.js";
import { TextFieldProps } from "../TextField/index.js";
import { ToggleButtonProps } from "../ToggleButton/index.js";
import { ToggleButtonGroupProps } from "../ToggleButtonGroup/index.js";
import { ToolbarProps } from "../Toolbar/index.js";
import { TooltipProps } from "../Tooltip/index.js";
import { TouchRippleProps } from "../ButtonBase/TouchRipple.js";
import { TypographyProps } from "../Typography/index.js";
import { PopperProps } from "../Popper/index.js";
export type ComponentsProps = { [Name in keyof ComponentsPropsList]?: Partial<ComponentsPropsList[Name]> };
export interface ComponentsPropsList {
MuiAlert: AlertProps;
MuiAlertTitle: AlertTitleProps;
MuiAppBar: AppBarProps;
MuiAutocomplete: AutocompleteProps<any, any, any, any>;
MuiAvatar: AvatarProps;
MuiAvatarGroup: AvatarGroupProps;
MuiBackdrop: BackdropProps;
MuiBadge: BadgeProps;
MuiBottomNavigation: BottomNavigationProps;
MuiBottomNavigationAction: BottomNavigationActionProps;
MuiBreadcrumbs: BreadcrumbsProps;
MuiButton: ButtonProps;
MuiButtonBase: ButtonBaseProps;
MuiButtonGroup: ButtonGroupProps;
MuiCard: CardProps;
MuiCardActionArea: CardActionAreaProps;
MuiCardActions: CardActionsProps;
MuiCardContent: CardContentProps;
MuiCardHeader: CardHeaderProps;
MuiCardMedia: CardMediaProps;
MuiCheckbox: CheckboxProps;
MuiChip: ChipProps;
MuiCircularProgress: CircularProgressProps;
MuiCollapse: CollapseProps;
MuiContainer: ContainerProps;
MuiCssBaseline: CssBaselineProps;
MuiDialog: DialogProps;
MuiDialogActions: DialogActionsProps;
MuiDialogContent: DialogContentProps;
MuiDialogContentText: DialogContentTextProps;
MuiDialogTitle: DialogTitleProps;
MuiDivider: DividerProps;
MuiDrawer: DrawerProps;
MuiAccordion: AccordionProps;
MuiAccordionActions: AccordionActionsProps;
MuiAccordionDetails: AccordionDetailsProps;
MuiAccordionSummary: AccordionSummaryProps;
MuiFab: FabProps;
MuiFilledInput: FilledInputProps;
MuiFormControl: FormControlProps;
MuiFormControlLabel: FormControlLabelProps;
MuiFormGroup: FormGroupProps;
MuiFormHelperText: FormHelperTextProps;
MuiFormLabel: FormLabelProps;
MuiGridLegacy: GridLegacyProps;
MuiGrid: GridProps;
MuiImageList: ImageListProps;
MuiImageListItem: ImageListItemProps;
MuiImageListItemBar: ImageListItemBarProps;
MuiIcon: IconProps;
MuiIconButton: IconButtonProps;
MuiInput: InputProps;
MuiInputAdornment: InputAdornmentProps;
MuiInputBase: InputBaseProps;
MuiInputLabel: InputLabelProps;
MuiLinearProgress: LinearProgressProps;
MuiLink: LinkProps;
MuiList: ListProps;
MuiListItem: ListItemProps;
MuiListItemButton: ListItemButtonProps;
MuiListItemAvatar: ListItemAvatarProps;
MuiListItemIcon: ListItemIconProps;
MuiListItemSecondaryAction: ListItemSecondaryActionProps;
MuiListItemText: ListItemTextProps;
MuiListSubheader: ListSubheaderProps;
MuiMenu: MenuProps;
MuiMenuItem: MenuItemProps;
MuiMenuList: MenuListProps;
MuiMobileStepper: MobileStepperProps;
MuiModal: ModalProps;
MuiNativeSelect: NativeSelectProps;
MuiOutlinedInput: OutlinedInputProps;
MuiPagination: PaginationProps;
MuiPaginationItem: PaginationItemProps;
MuiPaper: PaperProps;
MuiPopper: PopperProps;
MuiPopover: PopoverProps;
MuiRadio: RadioProps;
MuiRadioGroup: RadioGroupProps;
MuiRating: RatingProps;
MuiScopedCssBaseline: ScopedCssBaselineProps;
MuiSelect: SelectProps;
MuiSkeleton: SkeletonProps;
MuiSlider: SliderProps;
MuiSnackbar: SnackbarProps;
MuiSnackbarContent: SnackbarContentProps;
MuiSpeedDial: SpeedDialProps;
MuiSpeedDialAction: SpeedDialActionProps;
MuiSpeedDialIcon: SpeedDialIconProps;
MuiStack: StackProps;
MuiStep: StepProps;
MuiStepButton: StepButtonProps;
MuiStepConnector: StepConnectorProps;
MuiStepContent: StepContentProps;
MuiStepIcon: StepIconProps;
MuiStepLabel: StepLabelProps;
MuiStepper: StepperProps;
MuiSvgIcon: SvgIconProps;
MuiSwipeableDrawer: SwipeableDrawerProps;
MuiSwitch: SwitchProps;
MuiTab: TabProps;
MuiTable: TableProps;
MuiTableBody: TableBodyProps;
MuiTableCell: TableCellProps;
MuiTableContainer: TableContainerProps;
MuiTableFooter: TableFooterProps;
MuiTableHead: TableHeadProps;
MuiTablePagination: TablePaginationProps;
MuiTablePaginationActions: TablePaginationActionsProps;
MuiTableRow: TableRowProps;
MuiTableSortLabel: TableSortLabelProps;
MuiTabs: TabsProps;
MuiTextField: TextFieldProps;
MuiToggleButton: ToggleButtonProps;
MuiToggleButtonGroup: ToggleButtonGroupProps;
MuiToolbar: ToolbarProps;
MuiTooltip: TooltipProps;
MuiTouchRipple: TouchRippleProps;
MuiTypography: TypographyProps;
MuiUseMediaQuery: UseMediaQueryOptions;
}

5
node_modules/@mui/material/styles/props.js generated vendored Normal file
View file

@ -0,0 +1,5 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});

11
node_modules/@mui/material/styles/responsiveFontSizes.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import { Breakpoint } from '@mui/system';
import { TypographyVariants } from "./createTypography.js";
export interface ResponsiveFontSizesOptions {
breakpoints?: Breakpoint[];
disableAlign?: boolean;
factor?: number;
variants?: Array<keyof TypographyVariants>;
}
export default function responsiveFontSizes<T extends {
typography: TypographyVariants;
}>(theme: T, options?: ResponsiveFontSizesOptions): T;

74
node_modules/@mui/material/styles/responsiveFontSizes.js generated vendored Normal file
View file

@ -0,0 +1,74 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = responsiveFontSizes;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
var _cssUtils = require("./cssUtils");
function responsiveFontSizes(themeInput, options = {}) {
const {
breakpoints = ['sm', 'md', 'lg'],
disableAlign = false,
factor = 2,
variants = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'subtitle1', 'subtitle2', 'body1', 'body2', 'caption', 'button', 'overline']
} = options;
const theme = {
...themeInput
};
theme.typography = {
...theme.typography
};
const typography = theme.typography;
// Convert between CSS lengths e.g. em->px or px->rem
// Set the baseFontSize for your project. Defaults to 16px (also the browser default).
const convert = (0, _cssUtils.convertLength)(typography.htmlFontSize);
const breakpointValues = breakpoints.map(x => theme.breakpoints.values[x]);
variants.forEach(variant => {
const style = typography[variant];
if (!style) {
return;
}
const remFontSize = parseFloat(convert(style.fontSize, 'rem'));
if (remFontSize <= 1) {
return;
}
const maxFontSize = remFontSize;
const minFontSize = 1 + (maxFontSize - 1) / factor;
let {
lineHeight
} = style;
if (!(0, _cssUtils.isUnitless)(lineHeight) && !disableAlign) {
throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: Unsupported non-unitless line height with grid alignment.\n' + 'Use unitless line heights instead.' : (0, _formatMuiErrorMessage.default)(6));
}
if (!(0, _cssUtils.isUnitless)(lineHeight)) {
// make it unitless
lineHeight = parseFloat(convert(lineHeight, 'rem')) / parseFloat(remFontSize);
}
let transform = null;
if (!disableAlign) {
transform = value => (0, _cssUtils.alignProperty)({
size: value,
grid: (0, _cssUtils.fontGrid)({
pixels: 4,
lineHeight,
htmlFontSize: typography.htmlFontSize
})
});
}
typography[variant] = {
...style,
...(0, _cssUtils.responsiveProperty)({
cssProperty: 'fontSize',
min: minFontSize,
max: maxFontSize,
unit: 'rem',
breakpoints: breakpointValues,
transform
})
};
});
return theme;
}

2
node_modules/@mui/material/styles/rootShouldForwardProp.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const rootShouldForwardProp: (prop: string) => boolean;
export default rootShouldForwardProp;

10
node_modules/@mui/material/styles/rootShouldForwardProp.js generated vendored Normal file
View file

@ -0,0 +1,10 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _slotShouldForwardProp = _interopRequireDefault(require("./slotShouldForwardProp"));
const rootShouldForwardProp = prop => (0, _slotShouldForwardProp.default)(prop) && prop !== 'classes';
var _default = exports.default = rootShouldForwardProp;

3
node_modules/@mui/material/styles/shadows.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
export type Shadows = ['none', string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string];
declare const shadows: Shadows;
export default shadows;

16
node_modules/@mui/material/styles/shadows.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
const shadowKeyUmbraOpacity = 0.2;
const shadowKeyPenumbraOpacity = 0.14;
const shadowAmbientShadowOpacity = 0.12;
function createShadow(...px) {
return [`${px[0]}px ${px[1]}px ${px[2]}px ${px[3]}px rgba(0,0,0,${shadowKeyUmbraOpacity})`, `${px[4]}px ${px[5]}px ${px[6]}px ${px[7]}px rgba(0,0,0,${shadowKeyPenumbraOpacity})`, `${px[8]}px ${px[9]}px ${px[10]}px ${px[11]}px rgba(0,0,0,${shadowAmbientShadowOpacity})`].join(',');
}
// Values from https://github.com/material-components/material-components-web/blob/be8747f94574669cb5e7add1a7c54fa41a89cec7/packages/mdc-elevation/_variables.scss
const shadows = ['none', createShadow(0, 2, 1, -1, 0, 1, 1, 0, 0, 1, 3, 0), createShadow(0, 3, 1, -2, 0, 2, 2, 0, 0, 1, 5, 0), createShadow(0, 3, 3, -2, 0, 3, 4, 0, 0, 1, 8, 0), createShadow(0, 2, 4, -1, 0, 4, 5, 0, 0, 1, 10, 0), createShadow(0, 3, 5, -1, 0, 5, 8, 0, 0, 1, 14, 0), createShadow(0, 3, 5, -1, 0, 6, 10, 0, 0, 1, 18, 0), createShadow(0, 4, 5, -2, 0, 7, 10, 1, 0, 2, 16, 1), createShadow(0, 5, 5, -3, 0, 8, 10, 1, 0, 3, 14, 2), createShadow(0, 5, 6, -3, 0, 9, 12, 1, 0, 3, 16, 2), createShadow(0, 6, 6, -3, 0, 10, 14, 1, 0, 4, 18, 3), createShadow(0, 6, 7, -4, 0, 11, 15, 1, 0, 4, 20, 3), createShadow(0, 7, 8, -4, 0, 12, 17, 2, 0, 5, 22, 4), createShadow(0, 7, 8, -4, 0, 13, 19, 2, 0, 5, 24, 4), createShadow(0, 7, 9, -4, 0, 14, 21, 2, 0, 5, 26, 4), createShadow(0, 8, 9, -5, 0, 15, 22, 2, 0, 6, 28, 5), createShadow(0, 8, 10, -5, 0, 16, 24, 2, 0, 6, 30, 5), createShadow(0, 8, 11, -5, 0, 17, 26, 2, 0, 6, 32, 5), createShadow(0, 9, 11, -5, 0, 18, 28, 2, 0, 7, 34, 6), createShadow(0, 9, 12, -6, 0, 19, 29, 2, 0, 7, 36, 6), createShadow(0, 10, 13, -6, 0, 20, 31, 3, 0, 8, 38, 7), createShadow(0, 10, 13, -6, 0, 21, 33, 3, 0, 8, 40, 7), createShadow(0, 10, 14, -6, 0, 22, 35, 3, 0, 8, 42, 7), createShadow(0, 11, 14, -7, 0, 23, 36, 3, 0, 9, 44, 8), createShadow(0, 11, 15, -7, 0, 24, 38, 3, 0, 9, 46, 8)];
var _default = exports.default = shadows;

1
node_modules/@mui/material/styles/shouldSkipGeneratingVar.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export default function shouldSkipGeneratingVar(keys: string[]): boolean;

11
node_modules/@mui/material/styles/shouldSkipGeneratingVar.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = shouldSkipGeneratingVar;
function shouldSkipGeneratingVar(keys) {
return !!keys[0].match(/(cssVarPrefix|colorSchemeSelector|modularCssLayers|rootSelector|typography|mixins|breakpoints|direction|transitions)/) || !!keys[0].match(/sxConfig$/) ||
// ends with sxConfig
keys[0] === 'palette' && !!keys[1]?.match(/(mode|contrastThreshold|tonalOffset)/);
}

2
node_modules/@mui/material/styles/slotShouldForwardProp.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare function slotShouldForwardProp(prop: string): boolean;
export default slotShouldForwardProp;

11
node_modules/@mui/material/styles/slotShouldForwardProp.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
// copied from @mui/system/createStyled
function slotShouldForwardProp(prop) {
return prop !== 'ownerState' && prop !== 'theme' && prop !== 'sx' && prop !== 'as';
}
var _default = exports.default = slotShouldForwardProp;

20
node_modules/@mui/material/styles/stringifyTheme.d.ts generated vendored Normal file
View file

@ -0,0 +1,20 @@
/**
* `baseTheme` usually comes from `createTheme()` or `extendTheme()`.
*
* This function is intended to be used with zero-runtime CSS-in-JS like Pigment CSS
* For example, in a Next.js project:
*
* ```js
* // next.config.js
* const { extendTheme } = require('@mui/material/styles');
*
* const theme = extendTheme();
* // `.toRuntimeSource` is Pigment CSS specific to create a theme that is available at runtime.
* theme.toRuntimeSource = stringifyTheme;
*
* module.exports = withPigment({
* theme,
* });
* ```
*/
export declare function stringifyTheme(baseTheme?: Record<string, any>): string;

61
node_modules/@mui/material/styles/stringifyTheme.js generated vendored Normal file
View file

@ -0,0 +1,61 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.stringifyTheme = stringifyTheme;
var _deepmerge = require("@mui/utils/deepmerge");
/* eslint-disable import/prefer-default-export */
function isSerializable(val) {
return (0, _deepmerge.isPlainObject)(val) || typeof val === 'undefined' || typeof val === 'string' || typeof val === 'boolean' || typeof val === 'number' || Array.isArray(val);
}
/**
* `baseTheme` usually comes from `createTheme()` or `extendTheme()`.
*
* This function is intended to be used with zero-runtime CSS-in-JS like Pigment CSS
* For example, in a Next.js project:
*
* ```js
* // next.config.js
* const { extendTheme } = require('@mui/material/styles');
*
* const theme = extendTheme();
* // `.toRuntimeSource` is Pigment CSS specific to create a theme that is available at runtime.
* theme.toRuntimeSource = stringifyTheme;
*
* module.exports = withPigment({
* theme,
* });
* ```
*/
function stringifyTheme(baseTheme = {}) {
const serializableTheme = {
...baseTheme
};
function serializeTheme(object) {
const array = Object.entries(object);
// eslint-disable-next-line no-plusplus
for (let index = 0; index < array.length; index++) {
const [key, value] = array[index];
if (!isSerializable(value) || key.startsWith('unstable_')) {
delete object[key];
} else if ((0, _deepmerge.isPlainObject)(value)) {
object[key] = {
...value
};
serializeTheme(object[key]);
}
}
}
serializeTheme(serializableTheme);
return `import { unstable_createBreakpoints as createBreakpoints, createTransitions } from '@mui/material/styles';
const theme = ${JSON.stringify(serializableTheme, null, 2)};
theme.breakpoints = createBreakpoints(theme.breakpoints || {});
theme.transitions = createTransitions(theme.transitions || {});
export default theme;`;
}

13
node_modules/@mui/material/styles/styled.d.ts generated vendored Normal file
View file

@ -0,0 +1,13 @@
import { CreateMUIStyled } from '@mui/system';
import { Theme } from "./createTheme.js";
export { default as slotShouldForwardProp } from "./slotShouldForwardProp.js";
export { default as rootShouldForwardProp } from "./rootShouldForwardProp.js";
/**
* Custom styled utility that has a default MUI theme.
* @param tag HTML tag or component that should serve as base.
* @param options Styled options for the created component.
* @returns React component that has styles attached to it.
*/
declare const styled: CreateMUIStyled<Theme>;
export default styled;

31
node_modules/@mui/material/styles/styled.js generated vendored Normal file
View file

@ -0,0 +1,31 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
Object.defineProperty(exports, "rootShouldForwardProp", {
enumerable: true,
get: function () {
return _rootShouldForwardProp.default;
}
});
Object.defineProperty(exports, "slotShouldForwardProp", {
enumerable: true,
get: function () {
return _slotShouldForwardProp.default;
}
});
var _createStyled = _interopRequireDefault(require("@mui/system/createStyled"));
var _defaultTheme = _interopRequireDefault(require("./defaultTheme"));
var _identifier = _interopRequireDefault(require("./identifier"));
var _rootShouldForwardProp = _interopRequireDefault(require("./rootShouldForwardProp"));
var _slotShouldForwardProp = _interopRequireDefault(require("./slotShouldForwardProp"));
const styled = (0, _createStyled.default)({
themeId: _identifier.default,
defaultTheme: _defaultTheme.default,
rootShouldForwardProp: _rootShouldForwardProp.default
});
var _default = exports.default = styled;

2
node_modules/@mui/material/styles/useTheme.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
import { Theme } from "./createTheme.js";
export default function useTheme<T = Theme>(): T;

22
node_modules/@mui/material/styles/useTheme.js generated vendored Normal file
View file

@ -0,0 +1,22 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = useTheme;
var React = _interopRequireWildcard(require("react"));
var _system = require("@mui/system");
var _defaultTheme = _interopRequireDefault(require("./defaultTheme"));
var _identifier = _interopRequireDefault(require("./identifier"));
function useTheme() {
const theme = (0, _system.useTheme)(_defaultTheme.default);
if (process.env.NODE_ENV !== 'production') {
// TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler
// eslint-disable-next-line react-hooks/rules-of-hooks
React.useDebugValue(theme);
}
return theme[_identifier.default] || theme;
}

42
node_modules/@mui/material/styles/useThemeProps.d.ts generated vendored Normal file
View file

@ -0,0 +1,42 @@
import { Theme } from "./createTheme.js";
import { Components } from "./components.js";
export interface ThemeWithProps {
components?: Components<Omit<Theme, 'components'>>;
}
export type ThemedProps<Theme, Name extends keyof any> = Theme extends {
components: Record<Name, {
defaultProps: infer Props;
}>;
} ? Props : {};
/**
* Merges input `props` with the `defaultProps` for a component that were defined in the theme.
*
* The `defaultProps` are defined in the theme under `theme.components[componentName].defaultProps`.
*
* @example
*
* ```tsx
* const createTheme = () => ({
* components: {
* MuiStat: {
* defaultProps: {
* variant: 'outlined',
* },
* },
* },
* });
*
* function Stat(props) {
* const themeProps = useThemeProps({ props, name: 'MuiStat' });
* return <div {...themeProps} />;
* }
* ```
*
* @param params.props The input props
* @param params.name The name of the component as defined in the theme
*/
export default function useThemeProps<Theme extends ThemeWithProps, Props, Name extends keyof any>(params: {
props: Props;
name: Name;
}): Props & ThemedProps<Theme, Name>;

22
node_modules/@mui/material/styles/useThemeProps.js generated vendored Normal file
View file

@ -0,0 +1,22 @@
"use strict";
'use client';
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = useThemeProps;
var _useThemeProps = _interopRequireDefault(require("@mui/system/useThemeProps"));
var _defaultTheme = _interopRequireDefault(require("./defaultTheme"));
var _identifier = _interopRequireDefault(require("./identifier"));
function useThemeProps({
props,
name
}) {
return (0, _useThemeProps.default)({
props,
name,
defaultTheme: _defaultTheme.default,
themeId: _identifier.default
});
}

10
node_modules/@mui/material/styles/variants.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import { Interpolation } from '@mui/system';
import { ComponentsPropsList } from "./props.js";
export type ComponentsVariants<Theme = unknown> = { [Name in keyof ComponentsPropsList]?: Array<{
props: Partial<ComponentsPropsList[Name]> | ((props: Partial<ComponentsPropsList[Name]> & {
ownerState: Partial<ComponentsPropsList[Name]>;
}) => boolean);
style: Interpolation<{
theme: Theme;
}>;
}> };

5
node_modules/@mui/material/styles/variants.js generated vendored Normal file
View file

@ -0,0 +1,5 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});

1
node_modules/@mui/material/styles/withStyles.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export default function withStyles(stylesCreator: any, options?: object): never;

11
node_modules/@mui/material/styles/withStyles.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = withStyles;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
function withStyles() {
throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: withStyles is no longer exported from @mui/material/styles.\n' + 'You have to import it from @mui/styles.\n' + 'See https://mui.com/r/migration-v4/#mui-material-styles for more details.' : (0, _formatMuiErrorMessage.default)(15));
}

1
node_modules/@mui/material/styles/withTheme.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export default function withTheme(Component: any): never;

11
node_modules/@mui/material/styles/withTheme.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = withTheme;
var _formatMuiErrorMessage = _interopRequireDefault(require("@mui/utils/formatMuiErrorMessage"));
function withTheme() {
throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: withTheme is no longer exported from @mui/material/styles.\n' + 'You have to import it from @mui/styles.\n' + 'See https://mui.com/r/migration-v4/#mui-material-styles for more details.' : (0, _formatMuiErrorMessage.default)(16));
}

13
node_modules/@mui/material/styles/zIndex.d.ts generated vendored Normal file
View file

@ -0,0 +1,13 @@
export interface ZIndex {
mobileStepper: number;
speedDial: number;
appBar: number;
drawer: number;
modal: number;
snackbar: number;
tooltip: number;
fab: number;
}
export type ZIndexOptions = Partial<ZIndex>;
declare const zIndex: ZIndex;
export default zIndex;

19
node_modules/@mui/material/styles/zIndex.js generated vendored Normal file
View file

@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
// We need to centralize the zIndex definitions as they work
// like global values in the browser.
const zIndex = {
mobileStepper: 1000,
fab: 1050,
speedDial: 1050,
appBar: 1100,
drawer: 1200,
modal: 1300,
snackbar: 1400,
tooltip: 1500
};
var _default = exports.default = zIndex;