Jesus sucks

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

@@ -0,0 +1,53 @@
+'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';
+var defaultTheme = experimental_extendTheme();
+var _createCssVarsProvide = createCssVarsProvider({
+    themeId: THEME_ID,
+    theme: defaultTheme,
+    attribute: defaultConfig.attribute,
+    colorSchemeStorageKey: defaultConfig.colorSchemeStorageKey,
+    modeStorageKey: defaultConfig.modeStorageKey,
+    defaultColorScheme: {
+      light: defaultConfig.defaultLightColorScheme,
+      dark: defaultConfig.defaultDarkColorScheme
+    },
+    resolveTheme: function resolveTheme(theme) {
+      var newTheme = _extends({}, theme, {
+        typography: createTypography(theme.palette, theme.typography)
+      });
+      newTheme.unstable_sx = function sx(props) {
+        return styleFunctionSx({
+          sx: props,
+          theme: this
+        });
+      };
+      return newTheme;
+    },
+    excludeVariablesFromRoot: excludeVariablesFromRoot
+  }),
+  CssVarsProvider = _createCssVarsProvide.CssVarsProvider,
+  useColorScheme = _createCssVarsProvide.useColorScheme,
+  getInitColorSchemeScriptSystem = _createCssVarsProvide.getInitColorSchemeScript;
+/**
+ * @deprecated Use `InitColorSchemeScript` instead
+ * ```diff
+ * - import { getInitColorSchemeScript } from '@mui/material/styles';
+ * + import InitColorSchemeScript from '@mui/material/InitColorSchemeScript';
+ *
+ * - getInitColorSchemeScript();
+ * + <InitColorSchemeScript />;
+ * ```
+ */
+export var getInitColorSchemeScript = getInitColorSchemeScriptSystem;
+export { useColorScheme, CssVarsProvider as Experimental_CssVarsProvider };

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

@@ -0,0 +1,28 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+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) {
+  var themeInput = _ref.theme,
+    props = _objectWithoutProperties(_ref, ["theme"]);
+  var scopedTheme = themeInput[THEME_ID];
+  return /*#__PURE__*/_jsx(SystemThemeProvider, _extends({}, props, {
+    themeId: scopedTheme ? THEME_ID : undefined,
+    theme: scopedTheme || themeInput
+  }));
+}
+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;

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

@@ -0,0 +1,81 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+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'));
+  }
+  var _inputTheme$defaultPr = inputTheme.defaultProps,
+    defaultProps = _inputTheme$defaultPr === void 0 ? {} : _inputTheme$defaultPr,
+    _inputTheme$mixins = inputTheme.mixins,
+    mixins = _inputTheme$mixins === void 0 ? {} : _inputTheme$mixins,
+    _inputTheme$overrides = inputTheme.overrides,
+    overrides = _inputTheme$overrides === void 0 ? {} : _inputTheme$overrides,
+    _inputTheme$palette = inputTheme.palette,
+    palette = _inputTheme$palette === void 0 ? {} : _inputTheme$palette,
+    _inputTheme$props = inputTheme.props,
+    props = _inputTheme$props === void 0 ? {} : _inputTheme$props,
+    _inputTheme$styleOver = inputTheme.styleOverrides,
+    styleOverrides = _inputTheme$styleOver === void 0 ? {} : _inputTheme$styleOver,
+    other = _objectWithoutProperties(inputTheme, ["defaultProps", "mixins", "overrides", "palette", "props", "styleOverrides"]);
+  var theme = _extends({}, other, {
+    components: {}
+  });
+
+  // default props
+  Object.keys(defaultProps).forEach(function (component) {
+    var componentValue = theme.components[component] || {};
+    componentValue.defaultProps = defaultProps[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(props).forEach(function (component) {
+    var componentValue = theme.components[component] || {};
+    componentValue.defaultProps = props[component];
+    theme.components[component] = componentValue;
+  });
+
+  // CSS overrides
+  Object.keys(styleOverrides).forEach(function (component) {
+    var componentValue = theme.components[component] || {};
+    componentValue.styleOverrides = styleOverrides[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(overrides).forEach(function (component) {
+    var componentValue = theme.components[component] || {};
+    componentValue.styleOverrides = overrides[component];
+    theme.components[component] = componentValue;
+  });
+
+  // theme.spacing
+  theme.spacing = createSpacing(inputTheme.spacing);
+
+  // theme.mixins.gutters
+  var breakpoints = createBreakpoints(inputTheme.breakpoints || {});
+  var spacing = theme.spacing;
+  theme.mixins = _extends({
+    gutters: function gutters() {
+      var styles = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return _extends({
+        paddingLeft: spacing(2),
+        paddingRight: spacing(2)
+      }, styles, _defineProperty({}, breakpoints.up('sm'), _extends({
+        paddingLeft: spacing(3),
+        paddingRight: spacing(3)
+      }, styles[breakpoints.up('sm')])));
+    }
+  }, mixins);
+  var typeInput = palette.type,
+    modeInput = palette.mode,
+    paletteRest = _objectWithoutProperties(palette, ["type", "mode"]);
+  var 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;
+}

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

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

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

@@ -0,0 +1,10 @@
+import deepmerge from '@mui/utils/deepmerge';
+import createTheme from './createTheme';
+export default function createMuiStrictModeTheme(options) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  return createTheme.apply(void 0, [deepmerge({
+    unstable_strictMode: true
+  }, options)].concat(args));
+}

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

@@ -0,0 +1,299 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+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 var 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 var 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) {
+  var tonalOffsetLight = tonalOffset.light || tonalOffset;
+  var 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() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '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() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '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() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '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() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '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() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '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() {
+  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '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) {
+  var _palette$mode = palette.mode,
+    mode = _palette$mode === void 0 ? 'light' : _palette$mode,
+    _palette$contrastThre = palette.contrastThreshold,
+    contrastThreshold = _palette$contrastThre === void 0 ? 3 : _palette$contrastThre,
+    _palette$tonalOffset = palette.tonalOffset,
+    tonalOffset = _palette$tonalOffset === void 0 ? 0.2 : _palette$tonalOffset,
+    other = _objectWithoutProperties(palette, ["mode", "contrastThreshold", "tonalOffset"]);
+  var primary = palette.primary || getDefaultPrimary(mode);
+  var secondary = palette.secondary || getDefaultSecondary(mode);
+  var error = palette.error || getDefaultError(mode);
+  var info = palette.info || getDefaultInfo(mode);
+  var success = palette.success || getDefaultSuccess(mode);
+  var 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) {
+    var contrastText = getContrastRatio(background, dark.text.primary) >= contrastThreshold ? dark.text.primary : light.text.primary;
+    if (process.env.NODE_ENV !== 'production') {
+      var contrast = getContrastRatio(background, contrastText);
+      if (contrast < 3) {
+        console.error(["MUI: The contrast ratio of ".concat(contrast, ":1 for ").concat(contrastText, " on ").concat(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;
+  }
+  var augmentColor = function augmentColor(_ref) {
+    var color = _ref.color,
+      name = _ref.name,
+      _ref$mainShade = _ref.mainShade,
+      mainShade = _ref$mainShade === void 0 ? 500 : _ref$mainShade,
+      _ref$lightShade = _ref.lightShade,
+      lightShade = _ref$lightShade === void 0 ? 300 : _ref$lightShade,
+      _ref$darkShade = _ref.darkShade,
+      darkShade = _ref$darkShade === void 0 ? 700 : _ref$darkShade;
+    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".concat(name ? " (".concat(name, ")") : '', " provided to augmentColor(color) is invalid.\nThe color object needs to have a `main` property or a `").concat(mainShade, "` property.") : _formatMuiErrorMessage(11, name ? " (".concat(name, ")") : '', mainShade));
+    }
+    if (typeof color.main !== 'string') {
+      throw new Error(process.env.NODE_ENV !== "production" ? "MUI: The color".concat(name ? " (".concat(name, ")") : '', " provided to augmentColor(color) is invalid.\n`color.main` should be a string, but `").concat(JSON.stringify(color.main), "` was provided instead.\n\nDid you intend to use one of the following approaches?\n\nimport { green } from \"@mui/material/colors\";\n\nconst theme1 = createTheme({ palette: {\n  primary: green,\n} });\n\nconst theme2 = createTheme({ palette: {\n  primary: { main: green[500] },\n} });") : _formatMuiErrorMessage(12, name ? " (".concat(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;
+  };
+  var modes = {
+    dark: dark,
+    light: light
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    if (!modes[mode]) {
+      console.error("MUI: The palette mode `".concat(mode, "` is not supported."));
+    }
+  }
+  var paletteOutput = deepmerge(_extends({
+    // A collection of common colors.
+    common: _extends({}, common),
+    // prevent mutable object.
+    // The palette mode, can be light or dark.
+    mode: mode,
+    // The colors used to represent primary interface elements for a user.
+    primary: augmentColor({
+      color: primary,
+      name: 'primary'
+    }),
+    // The colors used to represent secondary interface elements for a user.
+    secondary: augmentColor({
+      color: secondary,
+      name: 'secondary',
+      mainShade: 'A400',
+      lightShade: 'A200',
+      darkShade: 'A700'
+    }),
+    // The colors used to represent interface elements that the user should be made aware of.
+    error: augmentColor({
+      color: error,
+      name: 'error'
+    }),
+    // The colors used to represent potentially dangerous actions or important messages.
+    warning: augmentColor({
+      color: warning,
+      name: 'warning'
+    }),
+    // The colors used to present information to the user that is neutral and not necessarily important.
+    info: augmentColor({
+      color: info,
+      name: 'info'
+    }),
+    // The colors used to indicate the successful completion of an action that user triggered.
+    success: augmentColor({
+      color: success,
+      name: 'success'
+    }),
+    // The grey colors.
+    grey: grey,
+    // Used by `getContrastText()` to maximize the contrast between
+    // the background and the text.
+    contrastThreshold: contrastThreshold,
+    // Takes a background color and returns the text color that maximizes the contrast.
+    getContrastText: getContrastText,
+    // Generate a rich color object.
+    augmentColor: 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: tonalOffset
+  }, modes[mode]), other);
+  return paletteOutput;
+}

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

@@ -0,0 +1,10 @@
+var 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;
+}

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

@@ -0,0 +1,97 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _formatMuiErrorMessage from "@mui/utils/formatMuiErrorMessage";
+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() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var breakpointsInput = options.breakpoints,
+    _options$mixins = options.mixins,
+    mixinsInput = _options$mixins === void 0 ? {} : _options$mixins,
+    spacingInput = options.spacing,
+    _options$palette = options.palette,
+    paletteInput = _options$palette === void 0 ? {} : _options$palette,
+    _options$transitions = options.transitions,
+    transitionsInput = _options$transitions === void 0 ? {} : _options$transitions,
+    _options$typography = options.typography,
+    typographyInput = _options$typography === void 0 ? {} : _options$typography,
+    shapeInput = options.shape,
+    other = _objectWithoutProperties(options, ["breakpoints", "mixins", "spacing", "palette", "transitions", "typography", "shape"]);
+  if (options.vars) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "MUI: `vars` is a private field used for CSS variables support.\nPlease use another name." : _formatMuiErrorMessage(18));
+  }
+  var palette = createPalette(paletteInput);
+  var systemTheme = systemCreateTheme(options);
+  var muiTheme = deepmerge(systemTheme, {
+    mixins: createMixins(systemTheme.breakpoints, mixinsInput),
+    palette: 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);
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  muiTheme = args.reduce(function (acc, argument) {
+    return 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.
+    var stateClasses = ['active', 'checked', 'completed', 'disabled', 'error', 'expanded', 'focused', 'focusVisible', 'required', 'selected'];
+    var traverse = function traverse(node, component) {
+      var key;
+
+      // eslint-disable-next-line guard-for-in, no-restricted-syntax
+      for (key in node) {
+        var child = node[key];
+        if (stateClasses.indexOf(key) !== -1 && Object.keys(child).length > 0) {
+          if (process.env.NODE_ENV !== 'production') {
+            var stateClass = generateUtilityClass('', key);
+            console.error(["MUI: The `".concat(component, "` component increases ") + "the CSS specificity of the `".concat(key, "` internal state."), 'You can not override it like this: ', JSON.stringify(node, null, 2), '', "Instead, you need to use the '&.".concat(stateClass, "' syntax:"), JSON.stringify({
+              root: _defineProperty({}, "&.".concat(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(function (component) {
+      var 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;
+}
+var warnedOnce = false;
+export function createMuiTheme() {
+  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.apply(void 0, arguments);
+}
+export default createTheme;

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

@@ -0,0 +1,97 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _extends from "@babel/runtime/helpers/esm/extends";
+// 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 var 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 var 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 "".concat(Math.round(milliseconds), "ms");
+}
+function getAutoHeightDuration(height) {
+  if (!height) {
+    return 0;
+  }
+  var 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 * Math.pow(constant, 0.25) + constant / 5) * 10);
+}
+export default function createTransitions(inputTransitions) {
+  var mergedEasing = _extends({}, easing, inputTransitions.easing);
+  var mergedDuration = _extends({}, duration, inputTransitions.duration);
+  var create = function create() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['all'];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _options$duration = options.duration,
+      durationOption = _options$duration === void 0 ? mergedDuration.standard : _options$duration,
+      _options$easing = options.easing,
+      easingOption = _options$easing === void 0 ? mergedEasing.easeInOut : _options$easing,
+      _options$delay = options.delay,
+      delay = _options$delay === void 0 ? 0 : _options$delay,
+      other = _objectWithoutProperties(options, ["duration", "easing", "delay"]);
+    if (process.env.NODE_ENV !== 'production') {
+      var isString = function isString(value) {
+        return typeof value === 'string';
+      };
+      // IE11 support, replace with Number.isNaN
+      // eslint-disable-next-line no-restricted-globals
+      var isNumber = function isNumber(value) {
+        return !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 ".concat(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) [".concat(Object.keys(other).join(','), "]."));
+      }
+    }
+    return (Array.isArray(props) ? props : [props]).map(function (animatedProp) {
+      return "".concat(animatedProp, " ").concat(typeof durationOption === 'string' ? durationOption : formatMs(durationOption), " ").concat(easingOption, " ").concat(typeof delay === 'string' ? delay : formatMs(delay));
+    }).join(',');
+  };
+  return _extends({
+    getAutoHeightDuration: getAutoHeightDuration,
+    create: create
+  }, inputTransitions, {
+    easing: mergedEasing,
+    duration: mergedDuration
+  });
+}

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

@@ -0,0 +1,93 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import deepmerge from '@mui/utils/deepmerge';
+function round(value) {
+  return Math.round(value * 1e5) / 1e5;
+}
+var caseAllCaps = {
+  textTransform: 'uppercase'
+};
+var 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) {
+  var _ref = typeof typography === 'function' ? typography(palette) : typography,
+    _ref$fontFamily = _ref.fontFamily,
+    fontFamily = _ref$fontFamily === void 0 ? defaultFontFamily : _ref$fontFamily,
+    _ref$fontSize = _ref.fontSize,
+    fontSize = _ref$fontSize === void 0 ? 14 : _ref$fontSize,
+    _ref$fontWeightLight = _ref.fontWeightLight,
+    fontWeightLight = _ref$fontWeightLight === void 0 ? 300 : _ref$fontWeightLight,
+    _ref$fontWeightRegula = _ref.fontWeightRegular,
+    fontWeightRegular = _ref$fontWeightRegula === void 0 ? 400 : _ref$fontWeightRegula,
+    _ref$fontWeightMedium = _ref.fontWeightMedium,
+    fontWeightMedium = _ref$fontWeightMedium === void 0 ? 500 : _ref$fontWeightMedium,
+    _ref$fontWeightBold = _ref.fontWeightBold,
+    fontWeightBold = _ref$fontWeightBold === void 0 ? 700 : _ref$fontWeightBold,
+    _ref$htmlFontSize = _ref.htmlFontSize,
+    htmlFontSize = _ref$htmlFontSize === void 0 ? 16 : _ref$htmlFontSize,
+    allVariants = _ref.allVariants,
+    pxToRem2 = _ref.pxToRem,
+    other = _objectWithoutProperties(_ref, ["fontFamily", "fontSize", "fontWeightLight", "fontWeightRegular", "fontWeightMedium", "fontWeightBold", "htmlFontSize", "allVariants", "pxToRem"]);
+  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.');
+    }
+  }
+  var coef = fontSize / 14;
+  var pxToRem = pxToRem2 || function (size) {
+    return "".concat(size / htmlFontSize * coef, "rem");
+  };
+  var buildVariant = function buildVariant(fontWeight, size, lineHeight, letterSpacing, casing) {
+    return _extends({
+      fontFamily: fontFamily,
+      fontWeight: fontWeight,
+      fontSize: pxToRem(size),
+      // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/
+      lineHeight: lineHeight
+    }, fontFamily === defaultFontFamily ? {
+      letterSpacing: "".concat(round(letterSpacing / size), "em")
+    } : {}, casing, allVariants);
+  };
+  var 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: htmlFontSize,
+    pxToRem: pxToRem,
+    fontFamily: fontFamily,
+    fontSize: fontSize,
+    fontWeightLight: fontWeightLight,
+    fontWeightRegular: fontWeightRegular,
+    fontWeightMedium: fontWeightMedium,
+    fontWeightBold: fontWeightBold
+  }, variants), other, {
+    clone: false // No need to clone deep
+  });
+}

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

@@ -0,0 +1,122 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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 function (length, toUnit) {
+    var 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.
+    var 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
+    var 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(_ref) {
+  var size = _ref.size,
+    grid = _ref.grid;
+  var sizeBelow = size - size % grid;
+  var 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(_ref2) {
+  var lineHeight = _ref2.lineHeight,
+    pixels = _ref2.pixels,
+    htmlFontSize = _ref2.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(_ref3) {
+  var cssProperty = _ref3.cssProperty,
+    min = _ref3.min,
+    max = _ref3.max,
+    _ref3$unit = _ref3.unit,
+    unit = _ref3$unit === void 0 ? 'rem' : _ref3$unit,
+    _ref3$breakpoints = _ref3.breakpoints,
+    breakpoints = _ref3$breakpoints === void 0 ? [600, 900, 1200] : _ref3$breakpoints,
+    _ref3$transform = _ref3.transform,
+    transform = _ref3$transform === void 0 ? null : _ref3$transform;
+  var output = _defineProperty({}, cssProperty, "".concat(min).concat(unit));
+  var factor = (max - min) / breakpoints[breakpoints.length - 1];
+  breakpoints.forEach(function (breakpoint) {
+    var value = min + factor * breakpoint;
+    if (transform !== null) {
+      value = transform(value);
+    }
+    output["@media (min-width:".concat(breakpoint, "px)")] = _defineProperty({}, cssProperty, "".concat(Math.round(value * 10000) / 10000).concat(unit));
+  });
+  return output;
+}

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

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

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

@@ -0,0 +1,10 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+/**
+ * @internal These variables should not appear in the :root stylesheet when the `defaultMode="dark"`
+ */
+var excludeVariablesFromRoot = function excludeVariablesFromRoot(cssVarPrefix) {
+  return [].concat(_toConsumableArray(_toConsumableArray(Array(24)).map(function (_, index) {
+    return "--".concat(cssVarPrefix ? "".concat(cssVarPrefix, "-") : '', "overlays-").concat(index + 1);
+  })), ["--".concat(cssVarPrefix ? "".concat(cssVarPrefix, "-") : '', "palette-AppBar-darkBg"), "--".concat(cssVarPrefix ? "".concat(cssVarPrefix, "-") : '', "palette-AppBar-darkColor")]);
+};
+export default excludeVariablesFromRoot;

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

@@ -0,0 +1,336 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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';
+var defaultDarkOverlays = _toConsumableArray(Array(25)).map(function (_, index) {
+  if (index === 0) {
+    return undefined;
+  }
+  var overlay = getOverlayAlpha(index);
+  return "linear-gradient(rgba(255 255 255 / ".concat(overlay, "), rgba(255 255 255 / ").concat(overlay, "))");
+});
+function assignNode(obj, keys) {
+  keys.forEach(function (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 (!("".concat(key, "Channel") in obj)) {
+    // custom channel token is not provided, generate one.
+    // if channel token can't be generated, show a warning.
+    obj["".concat(key, "Channel")] = safeColorChannel(toRgb(obj[key]), "MUI: Can't create `palette.".concat(key, "Channel` because `palette.").concat(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.".concat(key, "Channel` as a string (in rgb format, for example \"12 12 12\") or undefined if you want to remove the channel token."));
+  }
+}
+var silent = function silent(fn) {
+  try {
+    return fn();
+  } catch (error) {
+    // ignore error
+  }
+  return undefined;
+};
+export var createGetCssVar = function createGetCssVar() {
+  var cssVarPrefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'mui';
+  return systemCreateGetCssVar(cssVarPrefix);
+};
+export default function extendTheme() {
+  var _colorSchemesInput$li, _colorSchemesInput$da, _colorSchemesInput$li2, _colorSchemesInput$li3, _colorSchemesInput$da2, _colorSchemesInput$da3;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$colorSchemes = options.colorSchemes,
+    colorSchemesInput = _options$colorSchemes === void 0 ? {} : _options$colorSchemes,
+    _options$cssVarPrefix = options.cssVarPrefix,
+    cssVarPrefix = _options$cssVarPrefix === void 0 ? 'mui' : _options$cssVarPrefix,
+    _options$shouldSkipGe = options.shouldSkipGeneratingVar,
+    shouldSkipGeneratingVar = _options$shouldSkipGe === void 0 ? defaultShouldSkipGeneratingVar : _options$shouldSkipGe,
+    input = _objectWithoutProperties(options, ["colorSchemes", "cssVarPrefix", "shouldSkipGeneratingVar"]);
+  var getCssVar = createGetCssVar(cssVarPrefix);
+  var _createThemeWithoutVa = createThemeWithoutVars(_extends({}, input, colorSchemesInput.light && {
+      palette: (_colorSchemesInput$li = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li.palette
+    })),
+    lightPalette = _createThemeWithoutVa.palette,
+    muiTheme = _objectWithoutProperties(_createThemeWithoutVa, ["palette"]);
+  var _createThemeWithoutVa2 = createThemeWithoutVars({
+      palette: _extends({
+        mode: 'dark'
+      }, (_colorSchemesInput$da = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da.palette)
+    }),
+    darkPalette = _createThemeWithoutVa2.palette;
+  var theme = _extends({}, muiTheme, {
+    cssVarPrefix: cssVarPrefix,
+    getCssVar: 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(function (key) {
+    var palette = theme.colorSchemes[key].palette;
+    var setCssVarColor = function setCssVarColor(cssVar) {
+      var tokens = cssVar.split('-');
+      var color = tokens[1];
+      var 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(function () {
+        return lightPalette.getContrastText(palette.error.main);
+      }));
+      setColor(palette.Alert, 'infoFilledColor', silent(function () {
+        return lightPalette.getContrastText(palette.info.main);
+      }));
+      setColor(palette.Alert, 'successFilledColor', silent(function () {
+        return lightPalette.getContrastText(palette.success.main);
+      }));
+      setColor(palette.Alert, 'warningFilledColor', silent(function () {
+        return 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(".concat(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));
+      var snackbarContentBackground = safeEmphasize(palette.background.default, 0.8);
+      setColor(palette.SnackbarContent, 'bg', snackbarContentBackground);
+      setColor(palette.SnackbarContent, 'color', silent(function () {
+        return 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(function () {
+        return darkPalette.getContrastText(palette.error.dark);
+      }));
+      setColor(palette.Alert, 'infoFilledColor', silent(function () {
+        return darkPalette.getContrastText(palette.info.dark);
+      }));
+      setColor(palette.Alert, 'successFilledColor', silent(function () {
+        return darkPalette.getContrastText(palette.success.dark);
+      }));
+      setColor(palette.Alert, 'warningFilledColor', silent(function () {
+        return 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(".concat(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));
+      var _snackbarContentBackground = safeEmphasize(palette.background.default, 0.98);
+      setColor(palette.SnackbarContent, 'bg', _snackbarContentBackground);
+      setColor(palette.SnackbarContent, 'color', silent(function () {
+        return 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(function (color) {
+      var 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');
+          }
+        }
+      }
+    });
+  });
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  theme = args.reduce(function (acc, argument) {
+    return deepmerge(acc, argument);
+  }, theme);
+  var parserConfig = {
+    prefix: cssVarPrefix,
+    shouldSkipGeneratingVar: shouldSkipGeneratingVar
+  };
+  var _prepareCssVars = prepareCssVars(theme, parserConfig),
+    themeVars = _prepareCssVars.vars,
+    generateCssVars = _prepareCssVars.generateCssVars;
+  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;
+}

backend/frontend/node_modules/@mui/material/legacy/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
+var getOverlayAlpha = function getOverlayAlpha(elevation) {
+  var alphaValue;
+  if (elevation < 1) {
+    alphaValue = 5.11916 * Math.pow(elevation, 2);
+  } else {
+    alphaValue = 4.5 * Math.log(elevation + 1) + 2;
+  }
+  return (alphaValue / 100).toFixed(2);
+};
+export default getOverlayAlpha;

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

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

backend/frontend/node_modules/@mui/material/legacy/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';

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

@@ -0,0 +1,4 @@
+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.\nYou have to import it from @mui/styles.\nSee https://mui.com/r/migration-v4/#mui-material-styles for more details." : _formatMuiErrorMessage(14));
+}

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

@@ -0,0 +1,66 @@
+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) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$breakpoints = options.breakpoints,
+    breakpoints = _options$breakpoints === void 0 ? ['sm', 'md', 'lg'] : _options$breakpoints,
+    _options$disableAlign = options.disableAlign,
+    disableAlign = _options$disableAlign === void 0 ? false : _options$disableAlign,
+    _options$factor = options.factor,
+    factor = _options$factor === void 0 ? 2 : _options$factor,
+    _options$variants = options.variants,
+    variants = _options$variants === void 0 ? ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'subtitle1', 'subtitle2', 'body1', 'body2', 'caption', 'button', 'overline'] : _options$variants;
+  var theme = _extends({}, themeInput);
+  theme.typography = _extends({}, theme.typography);
+  var 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).
+  var convert = convertLength(typography.htmlFontSize);
+  var breakpointValues = breakpoints.map(function (x) {
+    return theme.breakpoints.values[x];
+  });
+  variants.forEach(function (variant) {
+    var style = typography[variant];
+    if (!style) {
+      return;
+    }
+    var remFontSize = parseFloat(convert(style.fontSize, 'rem'));
+    if (remFontSize <= 1) {
+      return;
+    }
+    var maxFontSize = remFontSize;
+    var minFontSize = 1 + (maxFontSize - 1) / factor;
+    var lineHeight = style.lineHeight;
+    if (!isUnitless(lineHeight) && !disableAlign) {
+      throw new Error(process.env.NODE_ENV !== "production" ? "MUI: Unsupported non-unitless line height with grid alignment.\nUse unitless line heights instead." : _formatMuiErrorMessage(6));
+    }
+    if (!isUnitless(lineHeight)) {
+      // make it unitless
+      lineHeight = parseFloat(convert(lineHeight, 'rem')) / parseFloat(remFontSize);
+    }
+    var transform = null;
+    if (!disableAlign) {
+      transform = function transform(value) {
+        return alignProperty({
+          size: value,
+          grid: fontGrid({
+            pixels: 4,
+            lineHeight: lineHeight,
+            htmlFontSize: typography.htmlFontSize
+          })
+        });
+      };
+    }
+    typography[variant] = _extends({}, style, responsiveProperty({
+      cssProperty: 'fontSize',
+      min: minFontSize,
+      max: maxFontSize,
+      unit: 'rem',
+      breakpoints: breakpointValues,
+      transform: transform
+    }));
+  });
+  return theme;
+}

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

@@ -0,0 +1,5 @@
+import slotShouldForwardProp from './slotShouldForwardProp';
+var rootShouldForwardProp = function rootShouldForwardProp(prop) {
+  return slotShouldForwardProp(prop) && prop !== 'classes';
+};
+export default rootShouldForwardProp;

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

@@ -0,0 +1,10 @@
+var shadowKeyUmbraOpacity = 0.2;
+var shadowKeyPenumbraOpacity = 0.14;
+var shadowAmbientShadowOpacity = 0.12;
+function createShadow() {
+  return ["".concat(arguments.length <= 0 ? undefined : arguments[0], "px ").concat(arguments.length <= 1 ? undefined : arguments[1], "px ").concat(arguments.length <= 2 ? undefined : arguments[2], "px ").concat(arguments.length <= 3 ? undefined : arguments[3], "px rgba(0,0,0,").concat(shadowKeyUmbraOpacity, ")"), "".concat(arguments.length <= 4 ? undefined : arguments[4], "px ").concat(arguments.length <= 5 ? undefined : arguments[5], "px ").concat(arguments.length <= 6 ? undefined : arguments[6], "px ").concat(arguments.length <= 7 ? undefined : arguments[7], "px rgba(0,0,0,").concat(shadowKeyPenumbraOpacity, ")"), "".concat(arguments.length <= 8 ? undefined : arguments[8], "px ").concat(arguments.length <= 9 ? undefined : arguments[9], "px ").concat(arguments.length <= 10 ? undefined : arguments[10], "px ").concat(arguments.length <= 11 ? undefined : arguments[11], "px rgba(0,0,0,").concat(shadowAmbientShadowOpacity, ")")].join(',');
+}
+
+// Values from https://github.com/material-components/material-components-web/blob/be8747f94574669cb5e7add1a7c54fa41a89cec7/packages/mdc-elevation/_variables.scss
+var 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;

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

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

backend/frontend/node_modules/@mui/material/legacy/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;

backend/frontend/node_modules/@mui/material/legacy/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';
+var styled = createStyled({
+  themeId: THEME_ID,
+  defaultTheme: defaultTheme,
+  rootShouldForwardProp: rootShouldForwardProp
+});
+export default styled;

backend/frontend/node_modules/@mui/material/legacy/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() {
+  var 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;
+}

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

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

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

@@ -0,0 +1,4 @@
+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.\nYou have to import it from @mui/styles.\nSee https://mui.com/r/migration-v4/#mui-material-styles for more details." : _formatMuiErrorMessage(15));
+}

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

@@ -0,0 +1,4 @@
+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.\nYou have to import it from @mui/styles.\nSee https://mui.com/r/migration-v4/#mui-material-styles for more details." : _formatMuiErrorMessage(16));
+}

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

@@ -0,0 +1,13 @@
+// We need to centralize the zIndex definitions as they work
+// like global values in the browser.
+var zIndex = {
+  mobileStepper: 1000,
+  fab: 1050,
+  speedDial: 1050,
+  appBar: 1100,
+  drawer: 1200,
+  modal: 1300,
+  snackbar: 1400,
+  tooltip: 1500
+};
+export default zIndex;