Jesus sucks

backend/frontend/node_modules/@mui/material/legacy/Radio/Radio.js

@@ -0,0 +1,212 @@
+'use client';
+
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import refType from '@mui/utils/refType';
+import composeClasses from '@mui/utils/composeClasses';
+import { alpha } from '@mui/system/colorManipulator';
+import SwitchBase from '../internal/SwitchBase';
+import { useDefaultProps } from '../DefaultPropsProvider';
+import RadioButtonIcon from './RadioButtonIcon';
+import capitalize from '../utils/capitalize';
+import createChainedFunction from '../utils/createChainedFunction';
+import useRadioGroup from '../RadioGroup/useRadioGroup';
+import radioClasses, { getRadioUtilityClass } from './radioClasses';
+import styled, { rootShouldForwardProp } from '../styles/styled';
+import { jsx as _jsx } from "react/jsx-runtime";
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes,
+    color = ownerState.color,
+    size = ownerState.size;
+  var slots = {
+    root: ['root', "color".concat(capitalize(color)), size !== 'medium' && "size".concat(capitalize(size))]
+  };
+  return _extends({}, classes, composeClasses(slots, getRadioUtilityClass, classes));
+};
+var RadioRoot = styled(SwitchBase, {
+  shouldForwardProp: function shouldForwardProp(prop) {
+    return rootShouldForwardProp(prop) || prop === 'classes';
+  },
+  name: 'MuiRadio',
+  slot: 'Root',
+  overridesResolver: function overridesResolver(props, styles) {
+    var ownerState = props.ownerState;
+    return [styles.root, ownerState.size !== 'medium' && styles["size".concat(capitalize(ownerState.size))], styles["color".concat(capitalize(ownerState.color))]];
+  }
+})(function (_ref) {
+  var theme = _ref.theme,
+    ownerState = _ref.ownerState;
+  return _extends({
+    color: (theme.vars || theme).palette.text.secondary
+  }, !ownerState.disableRipple && {
+    '&:hover': {
+      backgroundColor: theme.vars ? "rgba(".concat(ownerState.color === 'default' ? theme.vars.palette.action.activeChannel : theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(ownerState.color === 'default' ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      '@media (hover: none)': {
+        backgroundColor: 'transparent'
+      }
+    }
+  }, ownerState.color !== 'default' && _defineProperty({}, "&.".concat(radioClasses.checked), {
+    color: (theme.vars || theme).palette[ownerState.color].main
+  }), _defineProperty({}, "&.".concat(radioClasses.disabled), {
+    color: (theme.vars || theme).palette.action.disabled
+  }));
+});
+function areEqualValues(a, b) {
+  if (_typeof(b) === 'object' && b !== null) {
+    return a === b;
+  }
+
+  // The value could be a number, the DOM will stringify it anyway.
+  return String(a) === String(b);
+}
+var defaultCheckedIcon = /*#__PURE__*/_jsx(RadioButtonIcon, {
+  checked: true
+});
+var defaultIcon = /*#__PURE__*/_jsx(RadioButtonIcon, {});
+var Radio = /*#__PURE__*/React.forwardRef(function Radio(inProps, ref) {
+  var _defaultIcon$props$fo, _defaultCheckedIcon$p;
+  var props = useDefaultProps({
+    props: inProps,
+    name: 'MuiRadio'
+  });
+  var checkedProp = props.checked,
+    _props$checkedIcon = props.checkedIcon,
+    checkedIcon = _props$checkedIcon === void 0 ? defaultCheckedIcon : _props$checkedIcon,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'primary' : _props$color,
+    _props$icon = props.icon,
+    icon = _props$icon === void 0 ? defaultIcon : _props$icon,
+    nameProp = props.name,
+    onChangeProp = props.onChange,
+    _props$size = props.size,
+    size = _props$size === void 0 ? 'medium' : _props$size,
+    className = props.className,
+    other = _objectWithoutProperties(props, ["checked", "checkedIcon", "color", "icon", "name", "onChange", "size", "className"]);
+  var ownerState = _extends({}, props, {
+    color: color,
+    size: size
+  });
+  var classes = useUtilityClasses(ownerState);
+  var radioGroup = useRadioGroup();
+  var checked = checkedProp;
+  var onChange = createChainedFunction(onChangeProp, radioGroup && radioGroup.onChange);
+  var name = nameProp;
+  if (radioGroup) {
+    if (typeof checked === 'undefined') {
+      checked = areEqualValues(radioGroup.value, props.value);
+    }
+    if (typeof name === 'undefined') {
+      name = radioGroup.name;
+    }
+  }
+  return /*#__PURE__*/_jsx(RadioRoot, _extends({
+    type: "radio",
+    icon: /*#__PURE__*/React.cloneElement(icon, {
+      fontSize: (_defaultIcon$props$fo = defaultIcon.props.fontSize) != null ? _defaultIcon$props$fo : size
+    }),
+    checkedIcon: /*#__PURE__*/React.cloneElement(checkedIcon, {
+      fontSize: (_defaultCheckedIcon$p = defaultCheckedIcon.props.fontSize) != null ? _defaultCheckedIcon$p : size
+    }),
+    ownerState: ownerState,
+    classes: classes,
+    name: name,
+    checked: checked,
+    onChange: onChange,
+    ref: ref,
+    className: clsx(classes.root, className)
+  }, other));
+});
+process.env.NODE_ENV !== "production" ? Radio.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: PropTypes.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <RadioButtonIcon checked />
+   */
+  checkedIcon: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: PropTypes.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <RadioButtonIcon />
+   */
+  icon: PropTypes.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: PropTypes.string,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: PropTypes.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: refType,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: PropTypes.string,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: PropTypes.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: PropTypes.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense radio styling.
+   * @default 'medium'
+   */
+  size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   */
+  value: PropTypes.any
+} : void 0;
+export default Radio;

backend/frontend/node_modules/@mui/material/legacy/Radio/RadioButtonIcon.js

@@ -0,0 +1,82 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import RadioButtonUncheckedIcon from '../internal/svg-icons/RadioButtonUnchecked';
+import RadioButtonCheckedIcon from '../internal/svg-icons/RadioButtonChecked';
+import styled, { rootShouldForwardProp } from '../styles/styled';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var RadioButtonIconRoot = styled('span', {
+  shouldForwardProp: rootShouldForwardProp
+})({
+  position: 'relative',
+  display: 'flex'
+});
+var RadioButtonIconBackground = styled(RadioButtonUncheckedIcon)({
+  // Scale applied to prevent dot misalignment in Safari
+  transform: 'scale(1)'
+});
+var RadioButtonIconDot = styled(RadioButtonCheckedIcon)(function (_ref) {
+  var theme = _ref.theme,
+    ownerState = _ref.ownerState;
+  return _extends({
+    left: 0,
+    position: 'absolute',
+    transform: 'scale(0)',
+    transition: theme.transitions.create('transform', {
+      easing: theme.transitions.easing.easeIn,
+      duration: theme.transitions.duration.shortest
+    })
+  }, ownerState.checked && {
+    transform: 'scale(1)',
+    transition: theme.transitions.create('transform', {
+      easing: theme.transitions.easing.easeOut,
+      duration: theme.transitions.duration.shortest
+    })
+  });
+});
+
+/**
+ * @ignore - internal component.
+ */
+function RadioButtonIcon(props) {
+  var _props$checked = props.checked,
+    checked = _props$checked === void 0 ? false : _props$checked,
+    _props$classes = props.classes,
+    classes = _props$classes === void 0 ? {} : _props$classes,
+    fontSize = props.fontSize;
+  var ownerState = _extends({}, props, {
+    checked: checked
+  });
+  return /*#__PURE__*/_jsxs(RadioButtonIconRoot, {
+    className: classes.root,
+    ownerState: ownerState,
+    children: [/*#__PURE__*/_jsx(RadioButtonIconBackground, {
+      fontSize: fontSize,
+      className: classes.background,
+      ownerState: ownerState
+    }), /*#__PURE__*/_jsx(RadioButtonIconDot, {
+      fontSize: fontSize,
+      className: classes.dot,
+      ownerState: ownerState
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" ? RadioButtonIcon.propTypes = {
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: PropTypes.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense radio styling.
+   */
+  fontSize: PropTypes.oneOf(['small', 'medium'])
+} : void 0;
+export default RadioButtonIcon;

backend/frontend/node_modules/@mui/material/legacy/Radio/index.js

@@ -0,0 +1,5 @@
+'use client';
+
+export { default } from './Radio';
+export { default as radioClasses } from './radioClasses';
+export * from './radioClasses';

backend/frontend/node_modules/@mui/material/legacy/Radio/radioClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getRadioUtilityClass(slot) {
+  return generateUtilityClass('MuiRadio', slot);
+}
+var radioClasses = generateUtilityClasses('MuiRadio', ['root', 'checked', 'disabled', 'colorPrimary', 'colorSecondary', 'sizeSmall']);
+export default radioClasses;