Initial commit: Crypto trader application

frontend/node_modules/@mui/material/styles/CssVarsProvider.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { SupportedColorScheme } from './experimental_extendTheme';
+declare const CssVarsProvider: (props: React.PropsWithChildren<Partial<import("@mui/system").CssVarsProviderConfig<SupportedColorScheme>> & {
+    theme?: {
+        cssVarPrefix?: string;
+        colorSchemes: Record<SupportedColorScheme, Record<string, any>>;
+    } | {
+        $$material: {
+            cssVarPrefix?: string;
+            colorSchemes: Record<SupportedColorScheme, Record<string, any>>;
+        };
+    } | undefined;
+    documentNode?: Document | null;
+    colorSchemeNode?: Element | null;
+    colorSchemeSelector?: string;
+    storageWindow?: Window | null;
+    disableNestedContext?: boolean;
+    disableStyleSheetGeneration?: boolean;
+}>) => React.JSX.Element, useColorScheme: () => import("@mui/system").ColorSchemeContextValue<SupportedColorScheme>;
+/**
+ * @deprecated Use `InitColorSchemeScript` instead
+ * ```diff
+ * - import { getInitColorSchemeScript } from '@mui/material/styles';
+ * + import InitColorSchemeScript from '@mui/material/InitColorSchemeScript';
+ *
+ * - getInitColorSchemeScript();
+ * + <InitColorSchemeScript />;
+ * ```
+ */
+export declare const getInitColorSchemeScript: typeof import("@mui/system/InitColorSchemeScript").default;
+export { useColorScheme, CssVarsProvider as Experimental_CssVarsProvider };

frontend/node_modules/@mui/material/styles/CssVarsProvider.js

@@ -0,0 +1,55 @@
+'use client';
+
+// do not remove the following import (https://github.com/microsoft/TypeScript/issues/29808#issuecomment-1320713018)
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// @ts-ignore
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { unstable_createCssVarsProvider as createCssVarsProvider } from '@mui/system';
+import styleFunctionSx from '@mui/system/styleFunctionSx';
+import experimental_extendTheme from './experimental_extendTheme';
+import createTypography from './createTypography';
+import excludeVariablesFromRoot from './excludeVariablesFromRoot';
+import THEME_ID from './identifier';
+import { defaultConfig } from '../InitColorSchemeScript/InitColorSchemeScript';
+const defaultTheme = experimental_extendTheme();
+const {
+  CssVarsProvider,
+  useColorScheme,
+  getInitColorSchemeScript: getInitColorSchemeScriptSystem
+} = createCssVarsProvider({
+  themeId: THEME_ID,
+  theme: defaultTheme,
+  attribute: defaultConfig.attribute,
+  colorSchemeStorageKey: defaultConfig.colorSchemeStorageKey,
+  modeStorageKey: defaultConfig.modeStorageKey,
+  defaultColorScheme: {
+    light: defaultConfig.defaultLightColorScheme,
+    dark: defaultConfig.defaultDarkColorScheme
+  },
+  resolveTheme: theme => {
+    const newTheme = _extends({}, theme, {
+      typography: createTypography(theme.palette, theme.typography)
+    });
+    newTheme.unstable_sx = function sx(props) {
+      return styleFunctionSx({
+        sx: props,
+        theme: this
+      });
+    };
+    return newTheme;
+  },
+  excludeVariablesFromRoot
+});
+
+/**
+ * @deprecated Use `InitColorSchemeScript` instead
+ * ```diff
+ * - import { getInitColorSchemeScript } from '@mui/material/styles';
+ * + import InitColorSchemeScript from '@mui/material/InitColorSchemeScript';
+ *
+ * - getInitColorSchemeScript();
+ * + <InitColorSchemeScript />;
+ * ```
+ */
+export const getInitColorSchemeScript = getInitColorSchemeScriptSystem;
+export { useColorScheme, CssVarsProvider as Experimental_CssVarsProvider };

frontend/node_modules/@mui/material/styles/ThemeProvider.d.ts

@@ -0,0 +1,17 @@
+import { DefaultTheme } from '@mui/system';
+
+export interface ThemeProviderProps<Theme = DefaultTheme> {
+  children?: React.ReactNode;
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
+}
+
+/**
+ * This component makes the `theme` available down the React tree.
+ * It should preferably be used at **the root of your component tree**.
+ * API:
+ *
+ * - [ThemeProvider API](https://mui.com/material-ui/customization/theming/#themeprovider)
+ */
+export default function ThemeProvider<Theme = DefaultTheme>(
+  props: ThemeProviderProps<Theme>,
+): React.ReactElement<ThemeProviderProps<Theme>>;

frontend/node_modules/@mui/material/styles/ThemeProvider.js

@@ -0,0 +1,43 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["theme"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { ThemeProvider as SystemThemeProvider } from '@mui/system';
+import THEME_ID from './identifier';
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function ThemeProvider(_ref) {
+  let {
+      theme: themeInput
+    } = _ref,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const scopedTheme = themeInput[THEME_ID];
+  let finalTheme = scopedTheme || themeInput;
+  if (typeof themeInput !== 'function') {
+    if (scopedTheme && !scopedTheme.vars) {
+      finalTheme = _extends({}, scopedTheme, {
+        vars: null
+      });
+    } else if (themeInput && !themeInput.vars) {
+      finalTheme = _extends({}, themeInput, {
+        vars: null
+      });
+    }
+  }
+  return /*#__PURE__*/_jsx(SystemThemeProvider, _extends({}, props, {
+    themeId: scopedTheme ? THEME_ID : undefined,
+    theme: finalTheme
+  }));
+}
+process.env.NODE_ENV !== "production" ? ThemeProvider.propTypes = {
+  /**
+   * Your component tree.
+   */
+  children: PropTypes.node,
+  /**
+   * A theme object. You can provide a function to extend the outer theme.
+   */
+  theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired
+} : void 0;

frontend/node_modules/@mui/material/styles/adaptV4Theme.d.ts

@@ -0,0 +1,38 @@
+import { BreakpointsOptions, ShapeOptions, SpacingOptions } from '@mui/system';
+import { MixinsOptions } from './createMixins';
+import { Palette, PaletteOptions } from './createPalette';
+import { TypographyOptions } from './createTypography';
+import { Shadows } from './shadows';
+import { TransitionsOptions } from './createTransitions';
+import { ZIndexOptions } from './zIndex';
+import { ComponentsOverrides } from './overrides';
+import { ComponentsVariants } from './variants';
+import { ComponentsProps } from './props';
+import { Theme } from './createTheme';
+
+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?: TypographyOptions | ((palette: Palette) => TypographyOptions);
+  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;

frontend/node_modules/@mui/material/styles/adaptV4Theme.js

@@ -0,0 +1,81 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["defaultProps", "mixins", "overrides", "palette", "props", "styleOverrides"],
+  _excluded2 = ["type", "mode"];
+import { createBreakpoints, createSpacing } from '@mui/system';
+export default 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 = {}
+    } = inputTheme,
+    other = _objectWithoutPropertiesLoose(inputTheme, _excluded);
+  const theme = _extends({}, 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 = createSpacing(inputTheme.spacing);
+
+  // theme.mixins.gutters
+  const breakpoints = createBreakpoints(inputTheme.breakpoints || {});
+  const spacing = theme.spacing;
+  theme.mixins = _extends({
+    gutters: (styles = {}) => {
+      return _extends({
+        paddingLeft: spacing(2),
+        paddingRight: spacing(2)
+      }, styles, {
+        [breakpoints.up('sm')]: _extends({
+          paddingLeft: spacing(3),
+          paddingRight: spacing(3)
+        }, styles[breakpoints.up('sm')])
+      });
+    }
+  }, mixins);
+  const {
+      type: typeInput,
+      mode: modeInput
+    } = palette,
+    paletteRest = _objectWithoutPropertiesLoose(palette, _excluded2);
+  const finalMode = modeInput || typeInput || 'light';
+  theme.palette = _extends({
+    // 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;
+}

frontend/node_modules/@mui/material/styles/components.d.ts

@@ -0,0 +1,596 @@
+import { ComponentsProps } from './props';
+import { ComponentsOverrides } from './overrides';
+import { ComponentsVariants } from './variants';
+
+export interface Components<Theme = unknown> {
+  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'];
+  };
+  MuiGrid?: {
+    defaultProps?: ComponentsProps['MuiGrid'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiGrid'];
+    variants?: ComponentsVariants<Theme>['MuiGrid'];
+  };
+  MuiGrid2?: {
+    defaultProps?: ComponentsProps['MuiGrid2'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiGrid2'];
+    variants?: ComponentsVariants<Theme>['MuiGrid2'];
+  };
+  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'];
+  };
+  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'];
+  };
+}

frontend/node_modules/@mui/material/styles/createMixins.d.ts

@@ -0,0 +1,35 @@
+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;

frontend/node_modules/@mui/material/styles/createMixins.js

@@ -0,0 +1,16 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export default function createMixins(breakpoints, mixins) {
+  return _extends({
+    toolbar: {
+      minHeight: 56,
+      [breakpoints.up('xs')]: {
+        '@media (orientation: landscape)': {
+          minHeight: 48
+        }
+      },
+      [breakpoints.up('sm')]: {
+        minHeight: 64
+      }
+    }
+  }, mixins);
+}

frontend/node_modules/@mui/material/styles/createMuiStrictModeTheme.js

@@ -0,0 +1,7 @@
+import deepmerge from '@mui/utils/deepmerge';
+import createTheme from './createTheme';
+export default function createMuiStrictModeTheme(options, ...args) {
+  return createTheme(deepmerge({
+    unstable_strictMode: true
+  }, options), ...args);
+}

frontend/node_modules/@mui/material/styles/createPalette.d.ts

@@ -0,0 +1,129 @@
+import { Color, PaletteMode } from '..';
+
+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;

frontend/node_modules/@mui/material/styles/createPalette.js

@@ -0,0 +1,305 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+const _excluded = ["mode", "contrastThreshold", "tonalOffset"];
+import deepmerge from '@mui/utils/deepmerge';
+import { darken, getContrastRatio, lighten } from '@mui/system/colorManipulator';
+import common from '../colors/common';
+import grey from '../colors/grey';
+import purple from '../colors/purple';
+import red from '../colors/red';
+import orange from '../colors/orange';
+import blue from '../colors/blue';
+import lightBlue from '../colors/lightBlue';
+import green from '../colors/green';
+export const light = {
+  // 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.white,
+    default: common.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
+  }
+};
+export const dark = {
+  text: {
+    primary: common.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.white,
+    hover: 'rgba(255, 255, 255, 0.08)',
+    hoverOpacity: 0.08,
+    selected: 'rgba(255, 255, 255, 0.16)',
+    selectedOpacity: 0.16,
+    disabled: 'rgba(255, 255, 255, 0.3)',
+    disabledBackground: 'rgba(255, 255, 255, 0.12)',
+    disabledOpacity: 0.38,
+    focus: 'rgba(255, 255, 255, 0.12)',
+    focusOpacity: 0.12,
+    activatedOpacity: 0.24
+  }
+};
+function 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 = lighten(intent.main, tonalOffsetLight);
+    } else if (direction === 'dark') {
+      intent.dark = darken(intent.main, tonalOffsetDark);
+    }
+  }
+}
+function getDefaultPrimary(mode = 'light') {
+  if (mode === 'dark') {
+    return {
+      main: blue[200],
+      light: blue[50],
+      dark: blue[400]
+    };
+  }
+  return {
+    main: blue[700],
+    light: blue[400],
+    dark: blue[800]
+  };
+}
+function getDefaultSecondary(mode = 'light') {
+  if (mode === 'dark') {
+    return {
+      main: purple[200],
+      light: purple[50],
+      dark: purple[400]
+    };
+  }
+  return {
+    main: purple[500],
+    light: purple[300],
+    dark: purple[700]
+  };
+}
+function getDefaultError(mode = 'light') {
+  if (mode === 'dark') {
+    return {
+      main: red[500],
+      light: red[300],
+      dark: red[700]
+    };
+  }
+  return {
+    main: red[700],
+    light: red[400],
+    dark: red[800]
+  };
+}
+function getDefaultInfo(mode = 'light') {
+  if (mode === 'dark') {
+    return {
+      main: lightBlue[400],
+      light: lightBlue[300],
+      dark: lightBlue[700]
+    };
+  }
+  return {
+    main: lightBlue[700],
+    light: lightBlue[500],
+    dark: lightBlue[900]
+  };
+}
+function getDefaultSuccess(mode = 'light') {
+  if (mode === 'dark') {
+    return {
+      main: green[400],
+      light: green[300],
+      dark: green[700]
+    };
+  }
+  return {
+    main: green[800],
+    light: green[500],
+    dark: green[900]
+  };
+}
+function getDefaultWarning(mode = 'light') {
+  if (mode === 'dark') {
+    return {
+      main: orange[400],
+      light: orange[300],
+      dark: orange[700]
+    };
+  }
+  return {
+    main: '#ed6c02',
+    // closest to orange[800] that pass 3:1.
+    light: orange[500],
+    dark: orange[900]
+  };
+}
+export default function createPalette(palette) {
+  const {
+      mode = 'light',
+      contrastThreshold = 3,
+      tonalOffset = 0.2
+    } = palette,
+    other = _objectWithoutPropertiesLoose(palette, _excluded);
+  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) {
+    const contrastText = getContrastRatio(background, dark.text.primary) >= contrastThreshold ? dark.text.primary : light.text.primary;
+    if (process.env.NODE_ENV !== 'production') {
+      const contrast = 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 = _extends({}, 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.
+The color object needs to have a \`main\` property or a \`${mainShade}\` property.` : _formatMuiErrorMessage(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.
+\`color.main\` should be a string, but \`${JSON.stringify(color.main)}\` was provided instead.
+
+Did you intend to use one of the following approaches?
+
+import { green } from "@mui/material/colors";
+
+const theme1 = createTheme({ palette: {
+  primary: green,
+} });
+
+const theme2 = createTheme({ palette: {
+  primary: { main: green[500] },
+} });` : _formatMuiErrorMessage(12, name ? ` (${name})` : '', JSON.stringify(color.main)));
+    }
+    addLightOrDark(color, 'light', lightShade, tonalOffset);
+    addLightOrDark(color, 'dark', darkShade, tonalOffset);
+    if (!color.contrastText) {
+      color.contrastText = getContrastText(color.main);
+    }
+    return color;
+  };
+  const modes = {
+    dark,
+    light
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    if (!modes[mode]) {
+      console.error(`MUI: The palette mode \`${mode}\` is not supported.`);
+    }
+  }
+  const paletteOutput = deepmerge(_extends({
+    // A collection of common colors.
+    common: _extends({}, common),
+    // 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,
+    // 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
+  }, modes[mode]), other);
+  return paletteOutput;
+}

frontend/node_modules/@mui/material/styles/createStyles.d.ts

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

frontend/node_modules/@mui/material/styles/createStyles.js

@@ -0,0 +1,10 @@
+let warnedOnce = false;
+
+// To remove in v6
+export default 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;
+}

frontend/node_modules/@mui/material/styles/createTheme.d.ts

@@ -0,0 +1,63 @@
+import {
+  ThemeOptions as SystemThemeOptions,
+  Theme as SystemTheme,
+  SxProps,
+  CSSObject,
+  SxConfig,
+} from '@mui/system';
+import { Mixins, MixinsOptions } from './createMixins';
+import { Palette, PaletteOptions } from './createPalette';
+import { Typography, TypographyOptions } from './createTypography';
+import { Shadows } from './shadows';
+import { Transitions, TransitionsOptions } from './createTransitions';
+import { ZIndex, ZIndexOptions } from './zIndex';
+import { Components } from './components';
+
+export interface ThemeOptions extends Omit<SystemThemeOptions, 'zIndex'> {
+  mixins?: MixinsOptions;
+  components?: Components<Omit<Theme, 'components'>>;
+  palette?: PaletteOptions;
+  shadows?: Shadows;
+  transitions?: TransitionsOptions;
+  typography?: TypographyOptions | ((palette: Palette) => TypographyOptions);
+  zIndex?: ZIndexOptions;
+  unstable_strictMode?: boolean;
+  unstable_sxConfig?: SxConfig;
+  modularCssLayers?: boolean | string;
+}
+
+interface BaseTheme extends SystemTheme {
+  mixins: Mixins;
+  palette: Palette;
+  shadows: Shadows;
+  transitions: Transitions;
+  typography: Typography;
+  zIndex: ZIndex;
+  unstable_strictMode?: boolean;
+}
+
+// shut off automatic exporting for the `BaseTheme` above
+export {};
+
+/**
+ * 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 {
+  components?: Components<BaseTheme>;
+  unstable_sx: (props: SxProps<Theme>) => CSSObject;
+  unstable_sxConfig: SxConfig;
+}
+
+/**
+ * @deprecated
+ * Use `import { createTheme } from '@mui/material/styles'` instead.
+ */
+export function createMuiTheme(options?: ThemeOptions, ...args: object[]): Theme;
+
+/**
+ * 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?: ThemeOptions, ...args: object[]): Theme;

frontend/node_modules/@mui/material/styles/createTheme.js

@@ -0,0 +1,92 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+const _excluded = ["breakpoints", "mixins", "spacing", "palette", "transitions", "typography", "shape"];
+import deepmerge from '@mui/utils/deepmerge';
+import styleFunctionSx, { unstable_defaultSxConfig as defaultSxConfig } from '@mui/system/styleFunctionSx';
+import systemCreateTheme from '@mui/system/createTheme';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import createMixins from './createMixins';
+import createPalette from './createPalette';
+import createTypography from './createTypography';
+import shadows from './shadows';
+import createTransitions from './createTransitions';
+import zIndex from './zIndex';
+function createTheme(options = {}, ...args) {
+  const {
+      mixins: mixinsInput = {},
+      palette: paletteInput = {},
+      transitions: transitionsInput = {},
+      typography: typographyInput = {}
+    } = options,
+    other = _objectWithoutPropertiesLoose(options, _excluded);
+  if (options.vars &&
+  // The error should throw only for the root theme creation because user is not allowed to use a custom node `vars`.
+  // `generateCssVars` is the closest identifier for checking that the `options` is a result of `extendTheme` with CSS variables so that user can create new theme for nested ThemeProvider.
+  options.generateCssVars === undefined) {
+    throw new Error(process.env.NODE_ENV !== "production" ? `MUI: \`vars\` is a private field used for CSS variables support.
+Please use another name.` : _formatMuiErrorMessage(18));
+  }
+  const palette = createPalette(paletteInput);
+  const systemTheme = systemCreateTheme(options);
+  let muiTheme = deepmerge(systemTheme, {
+    mixins: createMixins(systemTheme.breakpoints, mixinsInput),
+    palette,
+    // Don't use [...shadows] until you've verified its transpiled code is not invoking the iterator protocol.
+    shadows: shadows.slice(),
+    typography: createTypography(palette, typographyInput),
+    transitions: createTransitions(transitionsInput),
+    zIndex: _extends({}, zIndex)
+  });
+  muiTheme = deepmerge(muiTheme, other);
+  muiTheme = args.reduce((acc, argument) => deepmerge(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, no-restricted-syntax
+      for (key in node) {
+        const child = node[key];
+        if (stateClasses.indexOf(key) !== -1 && Object.keys(child).length > 0) {
+          if (process.env.NODE_ENV !== 'production') {
+            const stateClass = generateUtilityClass('', 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.indexOf('Mui') === 0) {
+        traverse(styleOverrides, component);
+      }
+    });
+  }
+  muiTheme.unstable_sxConfig = _extends({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig);
+  muiTheme.unstable_sx = function sx(props) {
+    return styleFunctionSx({
+      sx: props,
+      theme: this
+    });
+  };
+  return muiTheme;
+}
+let warnedOnce = false;
+export function createMuiTheme(...args) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!warnedOnce) {
+      warnedOnce = true;
+      console.error(['MUI: the createMuiTheme function was renamed to createTheme.', '', "You should use `import { createTheme } from '@mui/material/styles'`"].join('\n'));
+    }
+  }
+  return createTheme(...args);
+}
+export default createTheme;

frontend/node_modules/@mui/material/styles/createTransitions.d.ts

@@ -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;
+}

frontend/node_modules/@mui/material/styles/createTransitions.js

@@ -0,0 +1,88 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["duration", "easing", "delay"];
+// 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.
+export const 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
+export const 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.wolframalpha.com/input/?i=(4+%2B+15+*+(x+%2F+36+)+**+0.25+%2B+(x+%2F+36)+%2F+5)+*+10
+  return Math.round((4 + 15 * constant ** 0.25 + constant / 5) * 10);
+}
+export default function createTransitions(inputTransitions) {
+  const mergedEasing = _extends({}, easing, inputTransitions.easing);
+  const mergedDuration = _extends({}, duration, inputTransitions.duration);
+  const create = (props = ['all'], options = {}) => {
+    const {
+        duration: durationOption = mergedDuration.standard,
+        easing: easingOption = mergedEasing.easeInOut,
+        delay = 0
+      } = options,
+      other = _objectWithoutPropertiesLoose(options, _excluded);
+    if (process.env.NODE_ENV !== 'production') {
+      const isString = value => typeof value === 'string';
+      // IE11 support, replace with Number.isNaN
+      // eslint-disable-next-line no-restricted-globals
+      const isNumber = value => !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 _extends({
+    getAutoHeightDuration,
+    create
+  }, inputTransitions, {
+    easing: mergedEasing,
+    duration: mergedDuration
+  });
+}

frontend/node_modules/@mui/material/styles/createTypography.d.ts

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import * as CSS from 'csstype';
+import { Palette } from './createPalette';
+
+export type Variant =
+  | '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 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 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 Typography extends Record<Variant, TypographyStyle>, FontStyle, TypographyUtils {}
+
+export interface TypographyOptions
+  extends Partial<Record<Variant, TypographyStyleOptions> & FontStyleOptions> {}
+
+export default function createTypography(
+  palette: Palette,
+  typography: TypographyOptions | ((palette: Palette) => TypographyOptions),
+): Typography;

frontend/node_modules/@mui/material/styles/createTypography.js

@@ -0,0 +1,90 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["fontFamily", "fontSize", "fontWeightLight", "fontWeightRegular", "fontWeightMedium", "fontWeightBold", "htmlFontSize", "allVariants", "pxToRem"];
+import deepmerge from '@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}
+ */
+export default function createTypography(palette, typography) {
+  const _ref = typeof typography === 'function' ? typography(palette) : typography,
+    {
+      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
+    } = _ref,
+    other = _objectWithoutPropertiesLoose(_ref, _excluded);
+  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) => _extends({
+    fontFamily,
+    fontWeight,
+    fontSize: pxToRem(size),
+    // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/
+    lineHeight
+  }, 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 deepmerge(_extends({
+    htmlFontSize,
+    pxToRem,
+    fontFamily,
+    fontSize,
+    fontWeightLight,
+    fontWeightRegular,
+    fontWeightMedium,
+    fontWeightBold
+  }, variants), other, {
+    clone: false // No need to clone deep
+  });
+}

frontend/node_modules/@mui/material/styles/cssUtils.d.ts

@@ -0,0 +1,32 @@
+import { CSSProperties } from './createTypography';
+
+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;

frontend/node_modules/@mui/material/styles/cssUtils.js

@@ -0,0 +1,125 @@
+export 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"
+export function getUnit(input) {
+  return String(input).match(/[\d.\-+]*\s*(.*)/)[1] || '';
+}
+
+// Emulate the sass function "unitless"
+export function toUnitless(length) {
+  return parseFloat(length);
+}
+
+// Convert any CSS <length> or <percentage> value to any another.
+// From https://github.com/KyleAMathews/convert-css-length
+export 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;
+  };
+}
+export 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
+export 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}
+ */
+export 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;
+}

frontend/node_modules/@mui/material/styles/defaultTheme.js

@@ -0,0 +1,5 @@
+'use client';
+
+import createTheme from './createTheme';
+const defaultTheme = createTheme();
+export default defaultTheme;

frontend/node_modules/@mui/material/styles/excludeVariablesFromRoot.d.ts

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

frontend/node_modules/@mui/material/styles/excludeVariablesFromRoot.js

@@ -0,0 +1,5 @@
+/**
+ * @internal These variables should not appear in the :root stylesheet when the `defaultMode="dark"`
+ */
+const excludeVariablesFromRoot = cssVarPrefix => [...[...Array(24)].map((_, index) => `--${cssVarPrefix ? `${cssVarPrefix}-` : ''}overlays-${index + 1}`), `--${cssVarPrefix ? `${cssVarPrefix}-` : ''}palette-AppBar-darkBg`, `--${cssVarPrefix ? `${cssVarPrefix}-` : ''}palette-AppBar-darkColor`];
+export default excludeVariablesFromRoot;

frontend/node_modules/@mui/material/styles/experimental_extendTheme.d.ts

@@ -0,0 +1,454 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { OverridableStringUnion } from '@mui/types';
+import { SxConfig, SxProps, CSSObject, ApplyStyles } from '@mui/system';
+import { ThemeOptions, Theme } from './createTheme';
+import { Palette, PaletteOptions } from './createPalette';
+import { Shadows } from './shadows';
+import { ZIndex } from './zIndex';
+import { Components } from './components';
+
+/**
+ * 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 {
+  colorScheme: SupportedColorScheme;
+  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'> {
+  /**
+   * 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<SupportedColorScheme, ColorSystemOptions>>;
+  /**
+   * 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;
+  /**
+   * Whether to use modular CSS layers.
+   * @default false
+   */
+  modularCssLayers?: boolean | string;
+}
+
+// should not include keys defined in `shouldSkipGeneratingVar` and have value typeof function
+export interface ThemeVars {
+  palette: Omit<
+    ColorSystem['palette'],
+    | 'colorScheme'
+    | 'mode'
+    | 'contrastThreshold'
+    | 'tonalOffset'
+    | 'getContrastText'
+    | 'augmentColor'
+  >;
+  opacity: Opacity;
+  overlays: Overlays;
+  shadows: Shadows;
+  shape: Theme['shape'];
+  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: Record<SupportedColorScheme, ColorSystem>;
+  cssVarPrefix: string;
+  vars: ThemeVars;
+  getCssVar: (field: ThemeCssVar, ...vars: ThemeCssVar[]) => string;
+  getColorSchemeSelector: (colorScheme: SupportedColorScheme) => string;
+  generateCssVars: (colorScheme?: SupportedColorScheme) => {
+    css: Record<string, string | number>;
+    vars: ThemeVars;
+  };
+
+  // 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 experimental_extendTheme(
+  options?: CssVarsThemeOptions,
+  ...args: object[]
+): Omit<Theme, 'palette' | 'applyStyles'> & CssVarsTheme;

frontend/node_modules/@mui/material/styles/experimental_extendTheme.js

@@ -0,0 +1,310 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["colorSchemes", "cssVarPrefix", "shouldSkipGeneratingVar"],
+  _excluded2 = ["palette"];
+import deepmerge from '@mui/utils/deepmerge';
+import { unstable_createGetCssVar as systemCreateGetCssVar, unstable_prepareCssVars as prepareCssVars } from '@mui/system';
+import styleFunctionSx, { unstable_defaultSxConfig as defaultSxConfig } from '@mui/system/styleFunctionSx';
+import { private_safeColorChannel as safeColorChannel, private_safeAlpha as safeAlpha, private_safeDarken as safeDarken, private_safeLighten as safeLighten, private_safeEmphasize as safeEmphasize, hslToRgb } from '@mui/system/colorManipulator';
+import defaultShouldSkipGeneratingVar from './shouldSkipGeneratingVar';
+import createThemeWithoutVars from './createTheme';
+import getOverlayAlpha from './getOverlayAlpha';
+const defaultDarkOverlays = [...Array(25)].map((_, index) => {
+  if (index === 0) {
+    return undefined;
+  }
+  const overlay = getOverlayAlpha(index);
+  return `linear-gradient(rgba(255 255 255 / ${overlay}), rgba(255 255 255 / ${overlay}))`;
+});
+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 (!color || !color.startsWith('hsl')) {
+    return color;
+  }
+  return 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`] = 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.`);
+  }
+}
+const silent = fn => {
+  try {
+    return fn();
+  } catch (error) {
+    // ignore error
+  }
+  return undefined;
+};
+export const createGetCssVar = (cssVarPrefix = 'mui') => systemCreateGetCssVar(cssVarPrefix);
+export default function extendTheme(options = {}, ...args) {
+  var _colorSchemesInput$li, _colorSchemesInput$da, _colorSchemesInput$li2, _colorSchemesInput$li3, _colorSchemesInput$da2, _colorSchemesInput$da3;
+  const {
+      colorSchemes: colorSchemesInput = {},
+      cssVarPrefix = 'mui',
+      shouldSkipGeneratingVar = defaultShouldSkipGeneratingVar
+    } = options,
+    input = _objectWithoutPropertiesLoose(options, _excluded);
+  const getCssVar = createGetCssVar(cssVarPrefix);
+  const _createThemeWithoutVa = createThemeWithoutVars(_extends({}, input, colorSchemesInput.light && {
+      palette: (_colorSchemesInput$li = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li.palette
+    })),
+    {
+      palette: lightPalette
+    } = _createThemeWithoutVa,
+    muiTheme = _objectWithoutPropertiesLoose(_createThemeWithoutVa, _excluded2);
+  const {
+    palette: darkPalette
+  } = createThemeWithoutVars({
+    palette: _extends({
+      mode: 'dark'
+    }, (_colorSchemesInput$da = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da.palette)
+  });
+  let theme = _extends({}, muiTheme, {
+    cssVarPrefix,
+    getCssVar,
+    colorSchemes: _extends({}, colorSchemesInput, {
+      light: _extends({}, colorSchemesInput.light, {
+        palette: lightPalette,
+        opacity: _extends({
+          inputPlaceholder: 0.42,
+          inputUnderline: 0.42,
+          switchTrackDisabled: 0.12,
+          switchTrack: 0.38
+        }, (_colorSchemesInput$li2 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li2.opacity),
+        overlays: ((_colorSchemesInput$li3 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li3.overlays) || []
+      }),
+      dark: _extends({}, colorSchemesInput.dark, {
+        palette: darkPalette,
+        opacity: _extends({
+          inputPlaceholder: 0.5,
+          inputUnderline: 0.7,
+          switchTrackDisabled: 0.2,
+          switchTrack: 0.3
+        }, (_colorSchemesInput$da2 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da2.opacity),
+        overlays: ((_colorSchemesInput$da3 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da3.overlays) || defaultDarkOverlays
+      })
+    })
+  });
+  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 (key === 'light') {
+      setColor(palette.common, 'background', '#fff');
+      setColor(palette.common, 'onBackground', '#000');
+    } else {
+      setColor(palette.common, 'background', '#000');
+      setColor(palette.common, 'onBackground', '#fff');
+    }
+
+    // assign component variables
+    assignNode(palette, ['Alert', 'AppBar', 'Avatar', 'Button', 'Chip', 'FilledInput', 'LinearProgress', 'Skeleton', 'Slider', 'SnackbarContent', 'SpeedDialAction', 'StepConnector', 'StepContent', 'Switch', 'TableCell', 'Tooltip']);
+    if (key === 'light') {
+      setColor(palette.Alert, 'errorColor', safeDarken(palette.error.light, 0.6));
+      setColor(palette.Alert, 'infoColor', safeDarken(palette.info.light, 0.6));
+      setColor(palette.Alert, 'successColor', safeDarken(palette.success.light, 0.6));
+      setColor(palette.Alert, 'warningColor', 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(() => lightPalette.getContrastText(palette.error.main)));
+      setColor(palette.Alert, 'infoFilledColor', silent(() => lightPalette.getContrastText(palette.info.main)));
+      setColor(palette.Alert, 'successFilledColor', silent(() => lightPalette.getContrastText(palette.success.main)));
+      setColor(palette.Alert, 'warningFilledColor', silent(() => lightPalette.getContrastText(palette.warning.main)));
+      setColor(palette.Alert, 'errorStandardBg', safeLighten(palette.error.light, 0.9));
+      setColor(palette.Alert, 'infoStandardBg', safeLighten(palette.info.light, 0.9));
+      setColor(palette.Alert, 'successStandardBg', safeLighten(palette.success.light, 0.9));
+      setColor(palette.Alert, 'warningStandardBg', 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', safeLighten(palette.primary.main, 0.62));
+      setColor(palette.LinearProgress, 'secondaryBg', safeLighten(palette.secondary.main, 0.62));
+      setColor(palette.LinearProgress, 'errorBg', safeLighten(palette.error.main, 0.62));
+      setColor(palette.LinearProgress, 'infoBg', safeLighten(palette.info.main, 0.62));
+      setColor(palette.LinearProgress, 'successBg', safeLighten(palette.success.main, 0.62));
+      setColor(palette.LinearProgress, 'warningBg', safeLighten(palette.warning.main, 0.62));
+      setColor(palette.Skeleton, 'bg', `rgba(${setCssVarColor('palette-text-primaryChannel')} / 0.11)`);
+      setColor(palette.Slider, 'primaryTrack', safeLighten(palette.primary.main, 0.62));
+      setColor(palette.Slider, 'secondaryTrack', safeLighten(palette.secondary.main, 0.62));
+      setColor(palette.Slider, 'errorTrack', safeLighten(palette.error.main, 0.62));
+      setColor(palette.Slider, 'infoTrack', safeLighten(palette.info.main, 0.62));
+      setColor(palette.Slider, 'successTrack', safeLighten(palette.success.main, 0.62));
+      setColor(palette.Slider, 'warningTrack', safeLighten(palette.warning.main, 0.62));
+      const snackbarContentBackground = safeEmphasize(palette.background.default, 0.8);
+      setColor(palette.SnackbarContent, 'bg', snackbarContentBackground);
+      setColor(palette.SnackbarContent, 'color', silent(() => lightPalette.getContrastText(snackbarContentBackground)));
+      setColor(palette.SpeedDialAction, 'fabHoverBg', 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', safeLighten(palette.primary.main, 0.62));
+      setColor(palette.Switch, 'secondaryDisabledColor', safeLighten(palette.secondary.main, 0.62));
+      setColor(palette.Switch, 'errorDisabledColor', safeLighten(palette.error.main, 0.62));
+      setColor(palette.Switch, 'infoDisabledColor', safeLighten(palette.info.main, 0.62));
+      setColor(palette.Switch, 'successDisabledColor', safeLighten(palette.success.main, 0.62));
+      setColor(palette.Switch, 'warningDisabledColor', safeLighten(palette.warning.main, 0.62));
+      setColor(palette.TableCell, 'border', safeLighten(safeAlpha(palette.divider, 1), 0.88));
+      setColor(palette.Tooltip, 'bg', safeAlpha(palette.grey[700], 0.92));
+    } else {
+      setColor(palette.Alert, 'errorColor', safeLighten(palette.error.light, 0.6));
+      setColor(palette.Alert, 'infoColor', safeLighten(palette.info.light, 0.6));
+      setColor(palette.Alert, 'successColor', safeLighten(palette.success.light, 0.6));
+      setColor(palette.Alert, 'warningColor', 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(() => darkPalette.getContrastText(palette.error.dark)));
+      setColor(palette.Alert, 'infoFilledColor', silent(() => darkPalette.getContrastText(palette.info.dark)));
+      setColor(palette.Alert, 'successFilledColor', silent(() => darkPalette.getContrastText(palette.success.dark)));
+      setColor(palette.Alert, 'warningFilledColor', silent(() => darkPalette.getContrastText(palette.warning.dark)));
+      setColor(palette.Alert, 'errorStandardBg', safeDarken(palette.error.light, 0.9));
+      setColor(palette.Alert, 'infoStandardBg', safeDarken(palette.info.light, 0.9));
+      setColor(palette.Alert, 'successStandardBg', safeDarken(palette.success.light, 0.9));
+      setColor(palette.Alert, 'warningStandardBg', 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', safeDarken(palette.primary.main, 0.5));
+      setColor(palette.LinearProgress, 'secondaryBg', safeDarken(palette.secondary.main, 0.5));
+      setColor(palette.LinearProgress, 'errorBg', safeDarken(palette.error.main, 0.5));
+      setColor(palette.LinearProgress, 'infoBg', safeDarken(palette.info.main, 0.5));
+      setColor(palette.LinearProgress, 'successBg', safeDarken(palette.success.main, 0.5));
+      setColor(palette.LinearProgress, 'warningBg', safeDarken(palette.warning.main, 0.5));
+      setColor(palette.Skeleton, 'bg', `rgba(${setCssVarColor('palette-text-primaryChannel')} / 0.13)`);
+      setColor(palette.Slider, 'primaryTrack', safeDarken(palette.primary.main, 0.5));
+      setColor(palette.Slider, 'secondaryTrack', safeDarken(palette.secondary.main, 0.5));
+      setColor(palette.Slider, 'errorTrack', safeDarken(palette.error.main, 0.5));
+      setColor(palette.Slider, 'infoTrack', safeDarken(palette.info.main, 0.5));
+      setColor(palette.Slider, 'successTrack', safeDarken(palette.success.main, 0.5));
+      setColor(palette.Slider, 'warningTrack', safeDarken(palette.warning.main, 0.5));
+      const snackbarContentBackground = safeEmphasize(palette.background.default, 0.98);
+      setColor(palette.SnackbarContent, 'bg', snackbarContentBackground);
+      setColor(palette.SnackbarContent, 'color', silent(() => darkPalette.getContrastText(snackbarContentBackground)));
+      setColor(palette.SpeedDialAction, 'fabHoverBg', 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', safeDarken(palette.primary.main, 0.55));
+      setColor(palette.Switch, 'secondaryDisabledColor', safeDarken(palette.secondary.main, 0.55));
+      setColor(palette.Switch, 'errorDisabledColor', safeDarken(palette.error.main, 0.55));
+      setColor(palette.Switch, 'infoDisabledColor', safeDarken(palette.info.main, 0.55));
+      setColor(palette.Switch, 'successDisabledColor', safeDarken(palette.success.main, 0.55));
+      setColor(palette.Switch, 'warningDisabledColor', safeDarken(palette.warning.main, 0.55));
+      setColor(palette.TableCell, 'border', safeDarken(safeAlpha(palette.divider, 1), 0.68));
+      setColor(palette.Tooltip, 'bg', 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 (colors && typeof colors === 'object') {
+        // Silent the error for custom palettes.
+        if (colors.main) {
+          setColor(palette[color], 'mainChannel', safeColorChannel(toRgb(colors.main)));
+        }
+        if (colors.light) {
+          setColor(palette[color], 'lightChannel', safeColorChannel(toRgb(colors.light)));
+        }
+        if (colors.dark) {
+          setColor(palette[color], 'darkChannel', safeColorChannel(toRgb(colors.dark)));
+        }
+        if (colors.contrastText) {
+          setColor(palette[color], 'contrastTextChannel', 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) => deepmerge(acc, argument), theme);
+  const parserConfig = {
+    prefix: cssVarPrefix,
+    shouldSkipGeneratingVar
+  };
+  const {
+    vars: themeVars,
+    generateCssVars
+  } = prepareCssVars(theme, parserConfig);
+  theme.vars = themeVars;
+  theme.generateCssVars = generateCssVars;
+  theme.shouldSkipGeneratingVar = shouldSkipGeneratingVar;
+  theme.unstable_sxConfig = _extends({}, defaultSxConfig, input == null ? void 0 : input.unstable_sxConfig);
+  theme.unstable_sx = function sx(props) {
+    return styleFunctionSx({
+      sx: props,
+      theme: this
+    });
+  };
+  return theme;
+}

frontend/node_modules/@mui/material/styles/getOverlayAlpha.d.ts

@@ -0,0 +1,2 @@
+declare const getOverlayAlpha: (elevation: number) => string;
+export default getOverlayAlpha;

frontend/node_modules/@mui/material/styles/getOverlayAlpha.js

@@ -0,0 +1,11 @@
+// Inspired by https://github.com/material-components/material-components-ios/blob/bca36107405594d5b7b16265a5b0ed698f85a5ee/components/Elevation/src/UIColor%2BMaterialElevation.m#L61
+const getOverlayAlpha = elevation => {
+  let alphaValue;
+  if (elevation < 1) {
+    alphaValue = 5.11916 * elevation ** 2;
+  } else {
+    alphaValue = 4.5 * Math.log(elevation + 1) + 2;
+  }
+  return (alphaValue / 100).toFixed(2);
+};
+export default getOverlayAlpha;

frontend/node_modules/@mui/material/styles/identifier.d.ts

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

frontend/node_modules/@mui/material/styles/identifier.js

@@ -0,0 +1 @@
+export default '$$material';

frontend/node_modules/@mui/material/styles/index.d.ts

@@ -0,0 +1,141 @@
+export { default as THEME_ID } from './identifier';
+export {
+  default as createTheme,
+  default as unstable_createMuiStrictModeTheme,
+  createMuiTheme,
+  ThemeOptions,
+  Theme,
+} from './createTheme';
+export { default as adaptV4Theme, DeprecatedThemeOptions } from './adaptV4Theme';
+export { Shadows } from './shadows';
+export { ZIndex } from './zIndex';
+export {
+  CommonColors,
+  Palette,
+  PaletteColor,
+  PaletteColorOptions,
+  PaletteOptions,
+  SimplePaletteColorOptions,
+  TypeText,
+  TypeAction,
+  TypeBackground,
+} from './createPalette';
+export { default as createStyles } from './createStyles';
+export {
+  Typography as TypographyVariants,
+  TypographyOptions as TypographyVariantsOptions,
+  TypographyStyle,
+  Variant as TypographyVariant,
+} from './createTypography';
+export { default as responsiveFontSizes } from './responsiveFontSizes';
+export {
+  Duration,
+  Easing,
+  Transitions,
+  TransitionsOptions,
+  duration,
+  easing,
+} from './createTransitions';
+export { Mixins } from './createMixins';
+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';
+// 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';
+export { default as useThemeProps } from './useThemeProps';
+export * from './useThemeProps';
+export { default as styled } from './styled';
+/**
+ * @deprecated will be removed in v5.beta, please use styled from @mui/material/styles instead
+ */
+export { default as experimentalStyled } from './styled';
+export { default as ThemeProvider } from './ThemeProvider';
+export { ComponentsProps, ComponentsPropsList } from './props';
+export { ComponentsVariants } from './variants';
+export { ComponentsOverrides, ComponentNameToClassKey } from './overrides';
+export { Components } from './components';
+export { getUnit as unstable_getUnit, toUnitless as unstable_toUnitless } from './cssUtils';
+
+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>>;
+}
+
+export { default as makeStyles } from './makeStyles';
+export { default as withStyles } from './withStyles';
+export { default as withTheme } from './withTheme';
+
+export * from './CssVarsProvider';
+
+export { default as experimental_extendTheme } from './experimental_extendTheme';
+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 './experimental_extendTheme';
+export { default as getOverlayAlpha } from './getOverlayAlpha';
+export { default as shouldSkipGeneratingVar } from './shouldSkipGeneratingVar';
+
+// Private methods for creating parts of the theme
+export { default as private_createTypography } from './createTypography';
+export { default as private_excludeVariablesFromRoot } from './excludeVariablesFromRoot';

frontend/node_modules/@mui/material/styles/index.js

@@ -0,0 +1,37 @@
+'use client';
+
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+export { default as THEME_ID } from './identifier';
+export { default as adaptV4Theme } from './adaptV4Theme';
+export { hexToRgb, rgbToHex, hslToRgb, decomposeColor, recomposeColor, getContrastRatio, getLuminance, emphasize, alpha, darken, lighten, css, keyframes } from '@mui/system';
+// TODO: Remove this function in v6.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export 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.` : _formatMuiErrorMessage(20));
+}
+export { default as createTheme, createMuiTheme } from './createTheme';
+export { default as unstable_createMuiStrictModeTheme } from './createMuiStrictModeTheme';
+export { default as createStyles } from './createStyles';
+export { getUnit as unstable_getUnit, toUnitless as unstable_toUnitless } from './cssUtils';
+export { default as responsiveFontSizes } from './responsiveFontSizes';
+export { duration, easing } from './createTransitions';
+export { default as useTheme } from './useTheme';
+export { default as useThemeProps } from './useThemeProps';
+export { default as styled } from './styled';
+export { default as experimentalStyled } from './styled';
+export { default as ThemeProvider } from './ThemeProvider';
+export { StyledEngineProvider } from '@mui/system';
+// The legacy utilities from @mui/styles
+// These are just empty functions that throws when invoked
+export { default as makeStyles } from './makeStyles';
+export { default as withStyles } from './withStyles';
+export { default as withTheme } from './withTheme';
+export * from './CssVarsProvider';
+export { default as experimental_extendTheme } from './experimental_extendTheme';
+export { default as getOverlayAlpha } from './getOverlayAlpha';
+export { default as shouldSkipGeneratingVar } from './shouldSkipGeneratingVar';
+
+// Private methods for creating parts of the theme
+export { default as private_createTypography } from './createTypography';
+export { default as private_createMixins } from './createMixins';
+export { default as private_excludeVariablesFromRoot } from './excludeVariablesFromRoot';

frontend/node_modules/@mui/material/styles/makeStyles.d.ts

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

frontend/node_modules/@mui/material/styles/makeStyles.js

@@ -0,0 +1,6 @@
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+export default function makeStyles() {
+  throw new Error(process.env.NODE_ENV !== "production" ? `MUI: makeStyles is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : _formatMuiErrorMessage(14));
+}

frontend/node_modules/@mui/material/styles/overrides.d.ts

@@ -0,0 +1,265 @@
+import { CSSObject, CSSInterpolation, Interpolation } from '@mui/system';
+import { PopperClassKey } from '../Popper';
+import { ComponentsPropsList } from './props';
+import { AccordionActionsClassKey } from '../AccordionActions';
+import { AccordionClassKey } from '../Accordion';
+import { AccordionDetailsClassKey } from '../AccordionDetails';
+import { AccordionSummaryClassKey } from '../AccordionSummary';
+import { AlertClassKey } from '../Alert';
+import { AlertTitleClassKey } from '../AlertTitle';
+import { AppBarClassKey } from '../AppBar';
+import { AutocompleteClassKey } from '../Autocomplete';
+import { AvatarClassKey } from '../Avatar';
+import { AvatarGroupClassKey } from '../AvatarGroup';
+import { BackdropClassKey } from '../Backdrop';
+import { BadgeClassKey } from '../Badge';
+import { BottomNavigationActionClassKey } from '../BottomNavigationAction';
+import { BottomNavigationClassKey } from '../BottomNavigation';
+import { BreadcrumbsClassKey } from '../Breadcrumbs';
+import { ButtonBaseClassKey } from '../ButtonBase';
+import { ButtonClassKey } from '../Button';
+import { ButtonGroupClassKey } from '../ButtonGroup';
+import { CardActionAreaClassKey } from '../CardActionArea';
+import { CardActionsClassKey } from '../CardActions';
+import { CardClassKey } from '../Card';
+import { CardContentClassKey } from '../CardContent';
+import { CardHeaderClassKey } from '../CardHeader';
+import { CardMediaClassKey } from '../CardMedia';
+import { CheckboxClassKey } from '../Checkbox';
+import { ChipClassKey } from '../Chip';
+import { CircularProgressClassKey } from '../CircularProgress';
+import { CollapseClassKey } from '../Collapse';
+import { ContainerClassKey } from '../Container';
+import { DialogActionsClassKey } from '../DialogActions';
+import { DialogClassKey } from '../Dialog';
+import { DialogContentClassKey } from '../DialogContent';
+import { DialogContentTextClassKey } from '../DialogContentText';
+import { DialogTitleClassKey } from '../DialogTitle';
+import { DividerClassKey } from '../Divider';
+import { DrawerClassKey } from '../Drawer';
+import { FabClassKey } from '../Fab';
+import { FilledInputClassKey } from '../FilledInput';
+import { FormControlClassKey } from '../FormControl';
+import { FormControlLabelClassKey } from '../FormControlLabel';
+import { FormGroupClassKey } from '../FormGroup';
+import { FormHelperTextClassKey } from '../FormHelperText';
+import { FormLabelClassKey } from '../FormLabel';
+import { GridClassKey } from '../Grid';
+import { Grid2Slot } from '../Unstable_Grid2';
+import { IconButtonClassKey } from '../IconButton';
+import { IconClassKey } from '../Icon';
+import { ImageListClassKey } from '../ImageList';
+import { ImageListItemBarClassKey } from '../ImageListItemBar';
+import { ImageListItemClassKey } from '../ImageListItem';
+import { InputAdornmentClassKey } from '../InputAdornment';
+import { InputBaseClassKey } from '../InputBase';
+import { InputClassKey } from '../Input';
+import { InputLabelClassKey } from '../InputLabel';
+import { LinearProgressClassKey } from '../LinearProgress';
+import { LinkClassKey } from '../Link';
+import { ListClassKey } from '../List';
+import { ListItemAvatarClassKey } from '../ListItemAvatar';
+import { ListItemClassKey } from '../ListItem';
+import { ListItemButtonClassKey } from '../ListItemButton';
+import { ListItemIconClassKey } from '../ListItemIcon';
+import { ListItemSecondaryActionClassKey } from '../ListItemSecondaryAction';
+import { ListItemTextClassKey } from '../ListItemText';
+import { ListSubheaderClassKey } from '../ListSubheader';
+import { MenuClassKey } from '../Menu';
+import { MenuItemClassKey } from '../MenuItem';
+import { MenuListClassKey } from '../MenuList';
+import { MobileStepperClassKey } from '../MobileStepper';
+import { ModalClassKey } from '../Modal';
+import { NativeSelectClassKey } from '../NativeSelect';
+import { OutlinedInputClassKey } from '../OutlinedInput';
+import { PaginationClassKey } from '../Pagination';
+import { PaginationItemClassKey } from '../PaginationItem';
+import { PaperClassKey } from '../Paper';
+import { PopoverClassKey } from '../Popover';
+import { RadioClassKey } from '../Radio';
+import { RadioGroupClassKey } from '../RadioGroup';
+import { RatingClassKey } from '../Rating';
+import { ScopedCssBaselineClassKey } from '../ScopedCssBaseline';
+import { SelectClassKey } from '../Select';
+import { SkeletonClassKey } from '../Skeleton';
+import { SliderClassKey } from '../Slider';
+import { SnackbarClassKey } from '../Snackbar';
+import { SnackbarContentClassKey } from '../SnackbarContent';
+import { SpeedDialClassKey } from '../SpeedDial';
+import { SpeedDialActionClassKey } from '../SpeedDialAction';
+import { SpeedDialIconClassKey } from '../SpeedDialIcon';
+import { StackClassKey } from '../Stack';
+import { StepButtonClasskey } from '../StepButton';
+import { StepClasskey } from '../Step';
+import { StepConnectorClasskey } from '../StepConnector';
+import { StepContentClasskey } from '../StepContent';
+import { StepIconClasskey } from '../StepIcon';
+import { StepLabelClasskey } from '../StepLabel';
+import { StepperClasskey } from '../Stepper';
+import { SvgIconClassKey } from '../SvgIcon';
+import { SwitchClassKey } from '../Switch';
+import { TabClassKey } from '../Tab';
+import { TableBodyClassKey } from '../TableBody';
+import { TableCellClassKey } from '../TableCell';
+import { TableClassKey } from '../Table';
+import { TableContainerClassKey } from '../TableContainer';
+import { TableFooterClassKey } from '../TableFooter';
+import { TableHeadClassKey } from '../TableHead';
+import { TablePaginationClassKey } from '../TablePagination';
+import { TableRowClassKey } from '../TableRow';
+import { TableSortLabelClassKey } from '../TableSortLabel';
+import { TabsClassKey } from '../Tabs';
+import { TextFieldClassKey } from '../TextField';
+import { ToggleButtonClassKey } from '../ToggleButton';
+import { ToggleButtonGroupClassKey } from '../ToggleButtonGroup';
+import { ToolbarClassKey } from '../Toolbar';
+import { TooltipClassKey } from '../Tooltip';
+import { TouchRippleClassKey } from '../ButtonBase/TouchRipple';
+import { TypographyClassKey } from '../Typography';
+
+export type OverridesStyleRules<
+  ClassKey extends string = string,
+  ComponentName = keyof ComponentsPropsList,
+  Theme = unknown,
+> = Record<
+  ClassKey,
+  Interpolation<
+    // Record<string, unknown> is for other props that the slot receive internally
+    // Documenting all ownerStates could be a huge work, let's wait until we have a real needs from developers.
+    (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;
+  MuiGrid: GridClassKey;
+  MuiGrid2: Grid2Slot;
+  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;
+  MuiTableRow: TableRowClassKey;
+  MuiTableSortLabel: TableSortLabelClassKey;
+  MuiTabs: TabsClassKey;
+  MuiTextField: TextFieldClassKey;
+  MuiToggleButton: ToggleButtonClassKey;
+  MuiToggleButtonGroup: ToggleButtonGroupClassKey;
+  MuiToolbar: ToolbarClassKey;
+  MuiTooltip: TooltipClassKey;
+  MuiTouchRipple: TouchRippleClassKey;
+  MuiTypography: TypographyClassKey;
+}

frontend/node_modules/@mui/material/styles/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/styles/index.js",
+  "types": "./index.d.ts"
+}

frontend/node_modules/@mui/material/styles/props.d.ts

@@ -0,0 +1,245 @@
+import { AlertProps } from '../Alert';
+import { AlertTitleProps } from '../AlertTitle';
+import { AppBarProps } from '../AppBar';
+import { AutocompleteProps } from '../Autocomplete';
+import { AvatarProps } from '../Avatar';
+import { AvatarGroupProps } from '../AvatarGroup';
+import { BackdropProps } from '../Backdrop';
+import { BadgeProps } from '../Badge';
+import { BottomNavigationActionProps } from '../BottomNavigationAction';
+import { BottomNavigationProps } from '../BottomNavigation';
+import { BreadcrumbsProps } from '../Breadcrumbs';
+import { ButtonBaseProps } from '../ButtonBase';
+import { ButtonGroupProps } from '../ButtonGroup';
+import { ButtonProps } from '../Button';
+import { CardActionAreaProps } from '../CardActionArea';
+import { CardActionsProps } from '../CardActions';
+import { CardContentProps } from '../CardContent';
+import { CardHeaderProps } from '../CardHeader';
+import { CardMediaProps } from '../CardMedia';
+import { CardProps } from '../Card';
+import { CheckboxProps } from '../Checkbox';
+import { ChipProps } from '../Chip';
+import { CircularProgressProps } from '../CircularProgress';
+import { CollapseProps } from '../Collapse';
+import { ContainerProps } from '../Container';
+import { CssBaselineProps } from '../CssBaseline';
+import { DialogActionsProps } from '../DialogActions';
+import { DialogContentProps } from '../DialogContent';
+import { DialogContentTextProps } from '../DialogContentText';
+import { DialogProps } from '../Dialog';
+import { DialogTitleProps } from '../DialogTitle';
+import { DividerProps } from '../Divider';
+import { DrawerProps } from '../Drawer';
+import { AccordionActionsProps } from '../AccordionActions';
+import { AccordionDetailsProps } from '../AccordionDetails';
+import { AccordionProps } from '../Accordion';
+import { AccordionSummaryProps } from '../AccordionSummary';
+import { FabProps } from '../Fab';
+import { FilledInputProps } from '../FilledInput';
+import { FormControlLabelProps } from '../FormControlLabel';
+import { FormControlProps } from '../FormControl';
+import { FormGroupProps } from '../FormGroup';
+import { FormHelperTextProps } from '../FormHelperText';
+import { FormLabelProps } from '../FormLabel';
+import { GridProps } from '../Grid';
+import { Grid2Props } from '../Unstable_Grid2';
+import { IconButtonProps } from '../IconButton';
+import { IconProps } from '../Icon';
+import { ImageListProps } from '../ImageList';
+import { ImageListItemBarProps } from '../ImageListItemBar';
+import { ImageListItemProps } from '../ImageListItem';
+import { InputAdornmentProps } from '../InputAdornment';
+import { InputBaseProps } from '../InputBase';
+import { InputLabelProps } from '../InputLabel';
+import { InputProps } from '../Input';
+import { LinearProgressProps } from '../LinearProgress';
+import { LinkProps } from '../Link';
+import { ListItemAvatarProps } from '../ListItemAvatar';
+import { ListItemIconProps } from '../ListItemIcon';
+import { ListItemProps } from '../ListItem';
+import { ListItemButtonProps } from '../ListItemButton';
+import { ListItemSecondaryActionProps } from '../ListItemSecondaryAction';
+import { ListItemTextProps } from '../ListItemText';
+import { ListProps } from '../List';
+import { ListSubheaderProps } from '../ListSubheader';
+import { MenuItemProps } from '../MenuItem';
+import { MenuListProps } from '../MenuList';
+import { MenuProps } from '../Menu';
+import { MobileStepperProps } from '../MobileStepper';
+import { ModalProps } from '../Modal';
+import { NativeSelectProps } from '../NativeSelect';
+import { UseMediaQueryOptions } from '../useMediaQuery';
+import { OutlinedInputProps } from '../OutlinedInput';
+import { PaginationProps } from '../Pagination';
+import { PaginationItemProps } from '../PaginationItem';
+import { PaperProps } from '../Paper';
+import { PopoverProps } from '../Popover';
+import { RadioGroupProps } from '../RadioGroup';
+import { RadioProps } from '../Radio';
+import { RatingProps } from '../Rating';
+import { ScopedCssBaselineProps } from '../ScopedCssBaseline';
+import { SelectProps } from '../Select';
+import { SkeletonProps } from '../Skeleton';
+import { SliderProps } from '../Slider';
+import { SnackbarContentProps } from '../SnackbarContent';
+import { SnackbarProps } from '../Snackbar';
+import { SpeedDialProps } from '../SpeedDial';
+import { SpeedDialActionProps } from '../SpeedDialAction';
+import { SpeedDialIconProps } from '../SpeedDialIcon';
+import { StackProps } from '../Stack';
+import { StepButtonProps } from '../StepButton';
+import { StepConnectorProps } from '../StepConnector';
+import { StepContentProps } from '../StepContent';
+import { StepIconProps } from '../StepIcon';
+import { StepLabelProps } from '../StepLabel';
+import { StepperProps } from '../Stepper';
+import { StepProps } from '../Step';
+import { SvgIconProps } from '../SvgIcon';
+import { SwipeableDrawerProps } from '../SwipeableDrawer';
+import { SwitchProps } from '../Switch';
+import { TableBodyProps } from '../TableBody';
+import { TableCellProps } from '../TableCell';
+import { TableContainerProps } from '../TableContainer';
+import { TableHeadProps } from '../TableHead';
+import { TablePaginationProps } from '../TablePagination';
+import { TableProps } from '../Table';
+import { TableRowProps } from '../TableRow';
+import { TableSortLabelProps } from '../TableSortLabel';
+import { TableFooterProps } from '../TableFooter';
+import { TabProps } from '../Tab';
+import { TabsProps } from '../Tabs';
+import { TextFieldProps } from '../TextField';
+import { ToggleButtonProps } from '../ToggleButton';
+import { ToggleButtonGroupProps } from '../ToggleButtonGroup';
+import { ToolbarProps } from '../Toolbar';
+import { TooltipProps } from '../Tooltip';
+import { TouchRippleProps } from '../ButtonBase/TouchRipple';
+import { TypographyProps } from '../Typography';
+import { PopperProps } from '../Popper';
+
+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;
+  MuiGrid: GridProps;
+  MuiGrid2: Grid2Props;
+  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;
+  MuiTableRow: TableRowProps;
+  MuiTableSortLabel: TableSortLabelProps;
+  MuiTabs: TabsProps;
+  MuiTextField: TextFieldProps;
+  MuiToggleButton: ToggleButtonProps;
+  MuiToggleButtonGroup: ToggleButtonGroupProps;
+  MuiToolbar: ToolbarProps;
+  MuiTooltip: TooltipProps;
+  MuiTouchRipple: TouchRippleProps;
+  MuiTypography: TypographyProps;
+  MuiUseMediaQuery: UseMediaQueryOptions;
+}

frontend/node_modules/@mui/material/styles/responsiveFontSizes.d.ts

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

frontend/node_modules/@mui/material/styles/responsiveFontSizes.js

@@ -0,0 +1,62 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+import { isUnitless, convertLength, responsiveProperty, alignProperty, fontGrid } from './cssUtils';
+export default 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 = _extends({}, themeInput);
+  theme.typography = _extends({}, 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 = 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 (!isUnitless(lineHeight) && !disableAlign) {
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI: Unsupported non-unitless line height with grid alignment.
+Use unitless line heights instead.` : _formatMuiErrorMessage(6));
+    }
+    if (!isUnitless(lineHeight)) {
+      // make it unitless
+      lineHeight = parseFloat(convert(lineHeight, 'rem')) / parseFloat(remFontSize);
+    }
+    let transform = null;
+    if (!disableAlign) {
+      transform = value => alignProperty({
+        size: value,
+        grid: fontGrid({
+          pixels: 4,
+          lineHeight,
+          htmlFontSize: typography.htmlFontSize
+        })
+      });
+    }
+    typography[variant] = _extends({}, style, responsiveProperty({
+      cssProperty: 'fontSize',
+      min: minFontSize,
+      max: maxFontSize,
+      unit: 'rem',
+      breakpoints: breakpointValues,
+      transform
+    }));
+  });
+  return theme;
+}

frontend/node_modules/@mui/material/styles/rootShouldForwardProp.d.ts

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

frontend/node_modules/@mui/material/styles/rootShouldForwardProp.js

@@ -0,0 +1,3 @@
+import slotShouldForwardProp from './slotShouldForwardProp';
+const rootShouldForwardProp = prop => slotShouldForwardProp(prop) && prop !== 'classes';
+export default rootShouldForwardProp;

frontend/node_modules/@mui/material/styles/shadows.d.ts

@@ -0,0 +1,29 @@
+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;

frontend/node_modules/@mui/material/styles/shadows.js

@@ -0,0 +1,10 @@
+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)];
+export default shadows;

frontend/node_modules/@mui/material/styles/shouldSkipGeneratingVar.d.ts

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

frontend/node_modules/@mui/material/styles/shouldSkipGeneratingVar.js

@@ -0,0 +1,6 @@
+export default function shouldSkipGeneratingVar(keys) {
+  var _keys$;
+  return !!keys[0].match(/(cssVarPrefix|modularCssLayers|typography|mixins|breakpoints|direction|transitions)/) || !!keys[0].match(/sxConfig$/) ||
+  // ends with sxConfig
+  keys[0] === 'palette' && !!((_keys$ = keys[1]) != null && _keys$.match(/(mode|contrastThreshold|tonalOffset)/));
+}

frontend/node_modules/@mui/material/styles/slotShouldForwardProp.d.ts

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

frontend/node_modules/@mui/material/styles/slotShouldForwardProp.js

@@ -0,0 +1,5 @@
+// copied from @mui/system/createStyled
+function slotShouldForwardProp(prop) {
+  return prop !== 'ownerState' && prop !== 'theme' && prop !== 'sx' && prop !== 'as';
+}
+export default slotShouldForwardProp;

frontend/node_modules/@mui/material/styles/styled.d.ts

@@ -0,0 +1,15 @@
+import { CreateMUIStyled } from '@mui/system';
+import { Theme } from './createTheme';
+
+export { default as slotShouldForwardProp } from './slotShouldForwardProp';
+export { default as rootShouldForwardProp } from './rootShouldForwardProp';
+
+/**
+ * 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;

frontend/node_modules/@mui/material/styles/styled.js

@@ -0,0 +1,14 @@
+'use client';
+
+import createStyled from '@mui/system/createStyled';
+import defaultTheme from './defaultTheme';
+import THEME_ID from './identifier';
+import rootShouldForwardProp from './rootShouldForwardProp';
+export { default as slotShouldForwardProp } from './slotShouldForwardProp';
+export { default as rootShouldForwardProp } from './rootShouldForwardProp';
+const styled = createStyled({
+  themeId: THEME_ID,
+  defaultTheme,
+  rootShouldForwardProp
+});
+export default styled;

frontend/node_modules/@mui/material/styles/useTheme.d.ts

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

frontend/node_modules/@mui/material/styles/useTheme.js

@@ -0,0 +1,14 @@
+'use client';
+
+import * as React from 'react';
+import { useTheme as useThemeSystem } from '@mui/system';
+import defaultTheme from './defaultTheme';
+import THEME_ID from './identifier';
+export default function useTheme() {
+  const theme = useThemeSystem(defaultTheme);
+  if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    React.useDebugValue(theme);
+  }
+  return theme[THEME_ID] || theme;
+}

frontend/node_modules/@mui/material/styles/useThemeProps.d.ts

@@ -0,0 +1,18 @@
+import { Theme } from './createTheme';
+import { Components } from './components';
+
+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
+  : {};
+
+export default function useThemeProps<
+  Theme extends ThemeWithProps,
+  Props,
+  Name extends keyof any,
+>(params: { props: Props; name: Name }): Props & ThemedProps<Theme, Name>;

frontend/node_modules/@mui/material/styles/useThemeProps.js

@@ -0,0 +1,16 @@
+'use client';
+
+import systemUseThemeProps from '@mui/system/useThemeProps';
+import defaultTheme from './defaultTheme';
+import THEME_ID from './identifier';
+export default function useThemeProps({
+  props,
+  name
+}) {
+  return systemUseThemeProps({
+    props,
+    name,
+    defaultTheme,
+    themeId: THEME_ID
+  });
+}

frontend/node_modules/@mui/material/styles/variants.d.ts

@@ -0,0 +1,15 @@
+import { Interpolation } from '@mui/system';
+import { ComponentsPropsList } from './props';
+
+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 }>;
+  }>;
+};

frontend/node_modules/@mui/material/styles/withStyles.d.ts

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

frontend/node_modules/@mui/material/styles/withStyles.js

@@ -0,0 +1,6 @@
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+export default function withStyles() {
+  throw new Error(process.env.NODE_ENV !== "production" ? `MUI: withStyles is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : _formatMuiErrorMessage(15));
+}

frontend/node_modules/@mui/material/styles/withTheme.d.ts

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

frontend/node_modules/@mui/material/styles/withTheme.js

@@ -0,0 +1,6 @@
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+export default function withTheme() {
+  throw new Error(process.env.NODE_ENV !== "production" ? `MUI: withTheme is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : _formatMuiErrorMessage(16));
+}

frontend/node_modules/@mui/material/styles/zIndex.d.ts

@@ -0,0 +1,16 @@
+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;

frontend/node_modules/@mui/material/styles/zIndex.js

@@ -0,0 +1,13 @@
+// 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
+};
+export default zIndex;