init 3

node_modules/@mui/material/Accordion/accordionClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getAccordionUtilityClass = getAccordionUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getAccordionUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiAccordion', slot);
+}
+const accordionClasses = (0, _generateUtilityClasses.default)('MuiAccordion', ['root', 'heading', 'rounded', 'expanded', 'disabled', 'gutters', 'region']);
+var _default = exports.default = accordionClasses;

node_modules/@mui/material/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,329 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { OverridableStringUnion } from '@mui/types';
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { IconButtonProps } from "../IconButton/index.js";
+import { ChipProps, ChipTypeMap } from "../Chip/index.js";
+import { PaperProps } from "../Paper/index.js";
+import { PopperProps } from "../Popper/index.js";
+import useAutocomplete, { AutocompleteChangeDetails, AutocompleteChangeReason, AutocompleteCloseReason, AutocompleteInputChangeReason, AutocompleteValue, createFilterOptions, UseAutocompleteProps, AutocompleteFreeSoloValueMapping } from "../useAutocomplete/index.js";
+import { AutocompleteClasses } from "./autocompleteClasses.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+export interface AutocompletePaperSlotPropsOverrides {}
+export interface AutocompletePopperSlotPropsOverrides {}
+export { AutocompleteChangeDetails, AutocompleteChangeReason, AutocompleteCloseReason, AutocompleteInputChangeReason, AutocompleteValue, createFilterOptions };
+export type AutocompleteOwnerState<Value, Multiple extends boolean | undefined, DisableClearable extends boolean | undefined, FreeSolo extends boolean | undefined, ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent']> = AutocompleteProps<Value, Multiple, DisableClearable, FreeSolo, ChipComponent> & {
+  disablePortal: boolean;
+  expanded: boolean;
+  focused: boolean;
+  fullWidth: boolean;
+  getOptionLabel: (option: Value | AutocompleteFreeSoloValueMapping<FreeSolo>) => string;
+  hasClearIcon: boolean;
+  hasPopupIcon: boolean;
+  inputFocused: boolean;
+  popupOpen: boolean;
+  size: OverridableStringUnion<'small' | 'medium', AutocompletePropsSizeOverrides>;
+};
+export type AutocompleteRenderGetTagProps = ({
+  index
+}: {
+  index: number;
+}) => {
+  key: number;
+  className: string;
+  disabled: boolean;
+  'data-tag-index': number;
+  tabIndex: -1;
+  onDelete: (event: any) => void;
+};
+export type AutocompleteRenderValueGetItemProps<Multiple extends boolean | undefined> = Multiple extends true ? (args: {
+  index: number;
+}) => {
+  key: number;
+  className: string;
+  disabled: boolean;
+  'data-item-index': number;
+  tabIndex: -1;
+  onDelete: (event: any) => void;
+} : (args?: {
+  index?: number;
+}) => {
+  className: string;
+  disabled: boolean;
+  'data-item-index': number;
+  tabIndex: -1;
+  onDelete: (event: any) => void;
+};
+export type AutocompleteRenderValue<Value, Multiple, FreeSolo> = Multiple extends true ? Array<Value | AutocompleteFreeSoloValueMapping<FreeSolo>> : NonNullable<Value | AutocompleteFreeSoloValueMapping<FreeSolo>>;
+export interface AutocompleteRenderOptionState {
+  inputValue: string;
+  index: number;
+  selected: boolean;
+}
+export interface AutocompleteRenderGroupParams {
+  key: number;
+  group: string;
+  children?: React.ReactNode;
+}
+export interface AutocompleteRenderInputParams {
+  id: string;
+  disabled: boolean;
+  fullWidth: boolean;
+  size: 'small' | undefined;
+  InputLabelProps: ReturnType<ReturnType<typeof useAutocomplete>['getInputLabelProps']>;
+  InputProps: {
+    ref: React.Ref<any>;
+    className: string;
+    startAdornment: React.ReactNode;
+    endAdornment: React.ReactNode;
+    onMouseDown: React.MouseEventHandler;
+  };
+  inputProps: ReturnType<ReturnType<typeof useAutocomplete>['getInputProps']>;
+}
+export interface AutocompletePropsSizeOverrides {}
+export interface AutocompleteSlots {
+  /**
+   * The component used to render the listbox.
+   * @default 'ul'
+   */
+  listbox: React.JSXElementConstructor<React.HTMLAttributes<HTMLElement>>;
+  /**
+   * The component used to render the body of the popup.
+   * @default Paper
+   */
+  paper: React.JSXElementConstructor<PaperProps & AutocompletePaperSlotPropsOverrides>;
+  /**
+   * The component used to position the popup.
+   * @default Popper
+   */
+  popper: React.JSXElementConstructor<PopperProps & AutocompletePopperSlotPropsOverrides>;
+}
+export type AutocompleteSlotsAndSlotProps<Value, Multiple extends boolean | undefined, DisableClearable extends boolean | undefined, FreeSolo extends boolean | undefined, ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent']> = CreateSlotsAndSlotProps<AutocompleteSlots, {
+  chip: SlotProps<React.ElementType<Partial<ChipProps<ChipComponent>>>, {}, AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>>;
+  clearIndicator: SlotProps<React.ElementType<Partial<IconButtonProps>>, {}, AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>>;
+  /**
+   * Props applied to the Listbox element.
+   */
+  listbox: SlotProps<React.ElementType<ReturnType<ReturnType<typeof useAutocomplete>['getListboxProps']> & {
+    sx?: SxProps<Theme>;
+    ref?: React.Ref<Element>;
+  }>, {}, AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>>;
+  paper: SlotProps<React.ElementType<Partial<PaperProps>>, AutocompletePaperSlotPropsOverrides, AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>>;
+  popper: SlotProps<React.ElementType<Partial<PopperProps>>, AutocompletePopperSlotPropsOverrides, AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>>;
+  popupIndicator: SlotProps<React.ElementType<Partial<IconButtonProps>>, {}, AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>>;
+}>;
+export interface AutocompleteProps<Value, Multiple extends boolean | undefined, DisableClearable extends boolean | undefined, FreeSolo extends boolean | undefined, ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent']> extends UseAutocompleteProps<Value, Multiple, DisableClearable, FreeSolo>, StandardProps<React.HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange' | 'children'>, AutocompleteSlotsAndSlotProps<Value, Multiple, DisableClearable, FreeSolo, ChipComponent> {
+  /**
+   * Props applied to the [`Chip`](https://mui.com/material-ui/api/chip/) element.
+   * @deprecated Use `slotProps.chip` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  ChipProps?: ChipProps<ChipComponent>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<AutocompleteClasses>;
+  /**
+   * The icon to display in place of the default clear icon.
+   * @default <ClearIcon fontSize="small" />
+   */
+  clearIcon?: React.ReactNode;
+  /**
+   * Override the default text for the *clear* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Clear'
+   */
+  clearText?: string;
+  /**
+   * Override the default text for the *close popup* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Close'
+   */
+  closeText?: string;
+  /**
+   * The props used for each slot inside.
+   * @deprecated Use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  componentsProps?: {
+    clearIndicator?: Partial<IconButtonProps>;
+    paper?: PaperProps;
+    popper?: Partial<PopperProps>;
+    popupIndicator?: Partial<IconButtonProps>;
+  };
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * If `true`, the `Popper` content will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal?: boolean;
+  /**
+   * Force the visibility display of the popup icon.
+   * @default 'auto'
+   */
+  forcePopupIcon?: true | false | 'auto';
+  /**
+   * If `true`, the input will take up the full width of its container.
+   * @default false
+   */
+  fullWidth?: boolean;
+  /**
+   * The label to display when the tags are truncated (`limitTags`).
+   *
+   * @param {number} more The number of truncated tags.
+   * @returns {ReactNode}
+   * @default (more) => `+${more}`
+   */
+  getLimitTagsText?: (more: number) => React.ReactNode;
+  /**
+   * The component used to render the listbox.
+   * @default 'ul'
+   * @deprecated Use `slotProps.listbox.component` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  ListboxComponent?: React.JSXElementConstructor<React.HTMLAttributes<HTMLElement>>;
+  /**
+   * Props applied to the Listbox element.
+   * @deprecated Use `slotProps.listbox` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  ListboxProps?: ReturnType<ReturnType<typeof useAutocomplete>['getListboxProps']> & {
+    sx?: SxProps<Theme>;
+    ref?: React.Ref<Element>;
+  };
+  /**
+   * If `true`, the component is in a loading state.
+   * This shows the `loadingText` in place of suggestions (only if there are no suggestions to show, for example `options` are empty).
+   * @default false
+   */
+  loading?: boolean;
+  /**
+   * Text to display when in a loading state.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Loading…'
+   */
+  loadingText?: React.ReactNode;
+  /**
+   * The maximum number of tags that will be visible when not focused.
+   * Set `-1` to disable the limit.
+   * @default -1
+   */
+  limitTags?: number;
+  /**
+   * Text to display when there are no options.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'No options'
+   */
+  noOptionsText?: React.ReactNode;
+  onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement> & {
+    defaultMuiPrevented?: boolean;
+  }) => void;
+  /**
+   * Override the default text for the *open popup* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Open'
+   */
+  openText?: string;
+  /**
+   * The component used to render the body of the popup.
+   * @default Paper
+   * @deprecated Use `slots.paper` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  PaperComponent?: React.JSXElementConstructor<React.HTMLAttributes<HTMLElement>>;
+  /**
+   * The component used to position the popup.
+   * @default Popper
+   * @deprecated Use `slots.popper` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  PopperComponent?: React.JSXElementConstructor<PopperProps>;
+  /**
+   * The icon to display in place of the default popup icon.
+   * @default <ArrowDropDownIcon />
+   */
+  popupIcon?: React.ReactNode;
+  /**
+   * If `true`, the component becomes readonly. It is also supported for multiple tags where the tag cannot be deleted.
+   * @default false
+   */
+  readOnly?: boolean;
+  /**
+   * Render the group.
+   *
+   * @param {AutocompleteRenderGroupParams} params The group to render.
+   * @returns {ReactNode}
+   */
+  renderGroup?: (params: AutocompleteRenderGroupParams) => React.ReactNode;
+  /**
+   * Render the input.
+   *
+   * **Note:** The `renderInput` prop must return a `TextField` component or a compatible custom component
+   * that correctly forwards `InputProps.ref` and spreads `inputProps`. This ensures proper integration
+   * with the Autocomplete's internal logic (e.g., focus management and keyboard navigation).
+   *
+   * Avoid using components like `DatePicker` or `Select` directly, as they may not forward the required props,
+   * leading to runtime errors or unexpected behavior.
+   *
+   * @param {object} params
+   * @returns {ReactNode}
+   */
+  renderInput: (params: AutocompleteRenderInputParams) => React.ReactNode;
+  /**
+   * Render the option, use `getOptionLabel` by default.
+   *
+   * @param {object} props The props to apply on the li element.
+   * @param {Value} option The option to render.
+   * @param {object} state The state of each option.
+   * @param {object} ownerState The state of the Autocomplete component.
+   * @returns {ReactNode}
+   */
+  renderOption?: (props: React.HTMLAttributes<HTMLLIElement> & {
+    key: any;
+  }, option: Value, state: AutocompleteRenderOptionState, ownerState: AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>) => React.ReactNode;
+  /**
+   * Render the selected value when doing multiple selections.
+   *
+   * @deprecated Use `renderValue` prop instead
+   *
+   * @param {Value[]} value The `value` provided to the component.
+   * @param {function} getTagProps A tag props getter.
+   * @param {object} ownerState The state of the Autocomplete component.
+   * @returns {ReactNode}
+   */
+  renderTags?: (value: Value[], getTagProps: AutocompleteRenderGetTagProps, ownerState: AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>) => React.ReactNode;
+  /**
+   * Renders the selected value(s) as rich content in the input for both single and multiple selections.
+   *
+   * @param {AutocompleteRenderValue<Value, Multiple, FreeSolo>} value The `value` provided to the component.
+   * @param {function} getItemProps The value item props.
+   * @param {object} ownerState The state of the Autocomplete component.
+   * @returns {ReactNode}
+   */
+  renderValue?: (value: AutocompleteRenderValue<Value, Multiple, FreeSolo>, getItemProps: AutocompleteRenderValueGetItemProps<Multiple>, ownerState: AutocompleteOwnerState<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>) => React.ReactNode;
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size?: OverridableStringUnion<'small' | 'medium', AutocompletePropsSizeOverrides>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Autocomplete](https://mui.com/material-ui/react-autocomplete/)
+ *
+ * API:
+ *
+ * - [Autocomplete API](https://mui.com/material-ui/api/autocomplete/)
+ */
+export default function Autocomplete<Value, Multiple extends boolean | undefined = false, DisableClearable extends boolean | undefined = false, FreeSolo extends boolean | undefined = false, ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent']>(props: AutocompleteProps<Value, Multiple, DisableClearable, FreeSolo, ChipComponent>): React.JSX.Element;

node_modules/@mui/material/Avatar/Avatar.d.ts

@@ -0,0 +1,112 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { OverridableStringUnion } from '@mui/types';
+import { Theme } from "../styles/index.js";
+import { OverridableComponent, OverrideProps } from "../OverridableComponent/index.js";
+import { AvatarClasses } from "./avatarClasses.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+import { SvgIconProps } from "../SvgIcon/index.js";
+export interface AvatarSlots {
+  /**
+   * The component that renders the root slot.
+   * @default 'div'
+   */
+  root: React.ElementType;
+  /**
+   * The component that renders the img slot.
+   * @default 'img'
+   */
+  img: React.ElementType;
+  /**
+   * The component that renders the fallback slot.
+   * @default Person icon
+   */
+  fallback: React.ElementType;
+}
+export interface AvatarPropsVariantOverrides {}
+export interface AvatarRootSlotPropsOverrides {}
+export interface AvatarImgSlotPropsOverrides {}
+export interface AvatarFallbackSlotPropsOverrides {}
+export type AvatarSlotsAndSlotProps = CreateSlotsAndSlotProps<AvatarSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on the div element.
+   */
+  root: SlotProps<'div', AvatarRootSlotPropsOverrides, AvatarOwnProps>;
+  /**
+   * Props forwarded to the img slot.
+   * By default, the available props are based on the img element.
+   */
+  img: SlotProps<'img', AvatarImgSlotPropsOverrides, AvatarOwnProps>;
+  /**
+   * Props forwarded to the fallback slot.
+   * By default, the available props are based on the [SvgIcon](https://mui.com/material-ui/api/svg-icon/#props) component.
+   */
+  fallback: SlotProps<React.ElementType<SvgIconProps>, AvatarFallbackSlotPropsOverrides, AvatarOwnProps>;
+}>;
+export interface AvatarOwnProps {
+  /**
+   * Used in combination with `src` or `srcSet` to
+   * provide an alt attribute for the rendered `img` element.
+   */
+  alt?: string;
+  /**
+   * Used to render icon or text elements inside the Avatar if `src` is not set.
+   * This can be an element, or just a string.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<AvatarClasses>;
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/img#attributes) applied to the `img` element if the component is used to display an image.
+   * It can be used to listen for the loading error event.
+   * @deprecated Use `slotProps.img` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  imgProps?: React.ImgHTMLAttributes<HTMLImageElement> & {
+    sx?: SxProps<Theme>;
+  };
+  /**
+   * The `sizes` attribute for the `img` element.
+   */
+  sizes?: string;
+  /**
+   * The `src` attribute for the `img` element.
+   */
+  src?: string;
+  /**
+   * The `srcSet` attribute for the `img` element.
+   * Use this attribute for responsive image display.
+   */
+  srcSet?: string;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * The shape of the avatar.
+   * @default 'circular'
+   */
+  variant?: OverridableStringUnion<'circular' | 'rounded' | 'square', AvatarPropsVariantOverrides>;
+}
+export interface AvatarTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> {
+  props: AdditionalProps & AvatarOwnProps & AvatarSlotsAndSlotProps;
+  defaultComponent: RootComponent;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Avatar](https://mui.com/material-ui/react-avatar/)
+ *
+ * API:
+ *
+ * - [Avatar API](https://mui.com/material-ui/api/avatar/)
+ */
+declare const Avatar: OverridableComponent<AvatarTypeMap>;
+export type AvatarProps<RootComponent extends React.ElementType = AvatarTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<AvatarTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default Avatar;

node_modules/@mui/material/AvatarGroup/AvatarGroup.js

@@ -0,0 +1,238 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactIs = require("react-is");
+var _clsx = _interopRequireDefault(require("clsx"));
+var _chainPropTypes = _interopRequireDefault(require("@mui/utils/chainPropTypes"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _Avatar = _interopRequireWildcard(require("../Avatar"));
+var _avatarGroupClasses = _interopRequireWildcard(require("./avatarGroupClasses"));
+var _useSlot = _interopRequireDefault(require("../utils/useSlot"));
+var _jsxRuntime = require("react/jsx-runtime");
+const SPACINGS = {
+  small: -16,
+  medium: -8
+};
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root'],
+    avatar: ['avatar']
+  };
+  return (0, _composeClasses.default)(slots, _avatarGroupClasses.getAvatarGroupUtilityClass, classes);
+};
+const AvatarGroupRoot = (0, _zeroStyled.styled)('div', {
+  name: 'MuiAvatarGroup',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    return [{
+      [`& .${_avatarGroupClasses.default.avatar}`]: styles.avatar
+    }, styles.root];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  display: 'flex',
+  flexDirection: 'row-reverse',
+  [`& .${_Avatar.avatarClasses.root}`]: {
+    border: `2px solid ${(theme.vars || theme).palette.background.default}`,
+    boxSizing: 'content-box',
+    marginLeft: 'var(--AvatarGroup-spacing, -8px)',
+    '&:last-child': {
+      marginLeft: 0
+    }
+  }
+})));
+const AvatarGroup = /*#__PURE__*/React.forwardRef(function AvatarGroup(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiAvatarGroup'
+  });
+  const {
+    children: childrenProp,
+    className,
+    component = 'div',
+    componentsProps,
+    max = 5,
+    renderSurplus,
+    slotProps = {},
+    slots = {},
+    spacing = 'medium',
+    total,
+    variant = 'circular',
+    ...other
+  } = props;
+  let clampedMax = max < 2 ? 2 : max;
+  const ownerState = {
+    ...props,
+    max,
+    spacing,
+    component,
+    variant
+  };
+  const classes = useUtilityClasses(ownerState);
+  const children = React.Children.toArray(childrenProp).filter(child => {
+    if (process.env.NODE_ENV !== 'production') {
+      if ((0, _reactIs.isFragment)(child)) {
+        console.error(["MUI: The AvatarGroup component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
+      }
+    }
+    return /*#__PURE__*/React.isValidElement(child);
+  });
+  const totalAvatars = total || children.length;
+  if (totalAvatars === clampedMax) {
+    clampedMax += 1;
+  }
+  clampedMax = Math.min(totalAvatars + 1, clampedMax);
+  const maxAvatars = Math.min(children.length, clampedMax - 1);
+  const extraAvatars = Math.max(totalAvatars - clampedMax, totalAvatars - maxAvatars, 0);
+  const extraAvatarsElement = renderSurplus ? renderSurplus(extraAvatars) : `+${extraAvatars}`;
+  let marginValue;
+  if (ownerState.spacing && SPACINGS[ownerState.spacing] !== undefined) {
+    marginValue = SPACINGS[ownerState.spacing];
+  } else if (ownerState.spacing === 0) {
+    marginValue = 0;
+  } else {
+    marginValue = -ownerState.spacing || SPACINGS.medium;
+  }
+  const externalForwardedProps = {
+    slots,
+    slotProps: {
+      surplus: slotProps.additionalAvatar ?? componentsProps?.additionalAvatar,
+      ...componentsProps,
+      ...slotProps
+    }
+  };
+  const [SurplusSlot, surplusProps] = (0, _useSlot.default)('surplus', {
+    elementType: _Avatar.default,
+    externalForwardedProps,
+    className: classes.avatar,
+    ownerState,
+    additionalProps: {
+      variant
+    }
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(AvatarGroupRoot, {
+    as: component,
+    ownerState: ownerState,
+    className: (0, _clsx.default)(classes.root, className),
+    ref: ref,
+    ...other,
+    style: {
+      '--AvatarGroup-spacing': `${marginValue}px`,
+      // marginValue is always defined
+      ...other.style
+    },
+    children: [extraAvatars ? /*#__PURE__*/(0, _jsxRuntime.jsx)(SurplusSlot, {
+      ...surplusProps,
+      children: extraAvatarsElement
+    }) : null, children.slice(0, maxAvatars).reverse().map(child => {
+      return /*#__PURE__*/React.cloneElement(child, {
+        className: (0, _clsx.default)(child.props.className, classes.avatar),
+        variant: child.props.variant || variant
+      });
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" ? AvatarGroup.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The avatars to stack.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: _propTypes.default.elementType,
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `slotProps` prop.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  componentsProps: _propTypes.default.shape({
+    additionalAvatar: _propTypes.default.object
+  }),
+  /**
+   * Max avatars to show before +x.
+   * @default 5
+   */
+  max: (0, _chainPropTypes.default)(_propTypes.default.number, props => {
+    if (props.max < 2) {
+      return new Error(['MUI: The prop `max` should be equal to 2 or above.', 'A value below is clamped to 2.'].join('\n'));
+    }
+    return null;
+  }),
+  /**
+   * custom renderer of extraAvatars
+   * @param {number} surplus number of extra avatars
+   * @returns {React.ReactNode} custom element to display
+   */
+  renderSurplus: _propTypes.default.func,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: _propTypes.default.shape({
+    additionalAvatar: _propTypes.default.object,
+    surplus: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: _propTypes.default.shape({
+    surplus: _propTypes.default.elementType
+  }),
+  /**
+   * Spacing between avatars.
+   * @default 'medium'
+   */
+  spacing: _propTypes.default.oneOfType([_propTypes.default.oneOf(['medium', 'small']), _propTypes.default.number]),
+  /**
+   * @ignore
+   */
+  style: _propTypes.default.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * The total number of avatars. Used for calculating the number of extra avatars.
+   * @default children.length
+   */
+  total: _propTypes.default.number,
+  /**
+   * The variant to use.
+   * @default 'circular'
+   */
+  variant: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['circular', 'rounded', 'square']), _propTypes.default.string])
+} : void 0;
+var _default = exports.default = AvatarGroup;

node_modules/@mui/material/AvatarGroup/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  avatarGroupClasses: true
+};
+Object.defineProperty(exports, "avatarGroupClasses", {
+  enumerable: true,
+  get: function () {
+    return _avatarGroupClasses.default;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _AvatarGroup.default;
+  }
+});
+var _AvatarGroup = _interopRequireDefault(require("./AvatarGroup"));
+var _avatarGroupClasses = _interopRequireWildcard(require("./avatarGroupClasses"));
+Object.keys(_avatarGroupClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _avatarGroupClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _avatarGroupClasses[key];
+    }
+  });
+});

node_modules/@mui/material/Badge/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Badge.js";
+export * from "./Badge.js";
+export { default as badgeClasses } from "./badgeClasses.js";
+export * from "./badgeClasses.js";

node_modules/@mui/material/Badge/useBadge.d.ts

@@ -0,0 +1,3 @@
+import { UseBadgeParameters, UseBadgeReturnValue } from "./useBadge.types.js";
+declare function useBadge(parameters: UseBadgeParameters): UseBadgeReturnValue;
+export default useBadge;

node_modules/@mui/material/BottomNavigationAction/bottomNavigationActionClasses.d.ts

@@ -0,0 +1,14 @@
+export interface BottomNavigationActionClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** State class applied to the root element if selected. */
+  selected: string;
+  /** State class applied to the root element if `showLabel={false}` and not selected. */
+  iconOnly: string;
+  /** Styles applied to the label's span element. */
+  label: string;
+}
+export type BottomNavigationActionClassKey = keyof BottomNavigationActionClasses;
+export declare function getBottomNavigationActionUtilityClass(slot: string): string;
+declare const bottomNavigationActionClasses: BottomNavigationActionClasses;
+export default bottomNavigationActionClasses;

node_modules/@mui/material/Box/Box.d.ts

@@ -0,0 +1,20 @@
+import { BoxTypeMap } from '@mui/system';
+import { OverridableComponent } from '@mui/types';
+import { OverrideProps } from "../OverridableComponent/index.js";
+import { Theme as MaterialTheme } from "../styles/index.js";
+
+/**
+ *
+ * Demos:
+ *
+ * - [Box](https://mui.com/material-ui/react-box/)
+ *
+ * API:
+ *
+ * - [Box API](https://mui.com/material-ui/api/box/)
+ */
+declare const Box: OverridableComponent<BoxTypeMap<{}, 'div', MaterialTheme>>;
+export type BoxProps<RootComponent extends React.ElementType = BoxTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<BoxTypeMap<AdditionalProps, RootComponent, MaterialTheme>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default Box;

node_modules/@mui/material/Breadcrumbs/BreadcrumbCollapsed.js

@@ -0,0 +1,97 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _colorManipulator = require("@mui/system/colorManipulator");
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _MoreHoriz = _interopRequireDefault(require("../internal/svg-icons/MoreHoriz"));
+var _ButtonBase = _interopRequireDefault(require("../ButtonBase"));
+var _jsxRuntime = require("react/jsx-runtime");
+const BreadcrumbCollapsedButton = (0, _zeroStyled.styled)(_ButtonBase.default, {
+  name: 'MuiBreadcrumbCollapsed'
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  display: 'flex',
+  marginLeft: `calc(${theme.spacing(1)} * 0.5)`,
+  marginRight: `calc(${theme.spacing(1)} * 0.5)`,
+  ...(theme.palette.mode === 'light' ? {
+    backgroundColor: theme.palette.grey[100],
+    color: theme.palette.grey[700]
+  } : {
+    backgroundColor: theme.palette.grey[700],
+    color: theme.palette.grey[100]
+  }),
+  borderRadius: 2,
+  '&:hover, &:focus': {
+    ...(theme.palette.mode === 'light' ? {
+      backgroundColor: theme.palette.grey[200]
+    } : {
+      backgroundColor: theme.palette.grey[600]
+    })
+  },
+  '&:active': {
+    boxShadow: theme.shadows[0],
+    ...(theme.palette.mode === 'light' ? {
+      backgroundColor: (0, _colorManipulator.emphasize)(theme.palette.grey[200], 0.12)
+    } : {
+      backgroundColor: (0, _colorManipulator.emphasize)(theme.palette.grey[600], 0.12)
+    })
+  }
+})));
+const BreadcrumbCollapsedIcon = (0, _zeroStyled.styled)(_MoreHoriz.default)({
+  width: 24,
+  height: 16
+});
+
+/**
+ * @ignore - internal component.
+ */
+function BreadcrumbCollapsed(props) {
+  const {
+    slots = {},
+    slotProps = {},
+    ...otherProps
+  } = props;
+  const ownerState = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("li", {
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(BreadcrumbCollapsedButton, {
+      focusRipple: true,
+      ...otherProps,
+      ownerState: ownerState,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(BreadcrumbCollapsedIcon, {
+        as: slots.CollapsedIcon,
+        ownerState: ownerState,
+        ...slotProps.collapsedIcon
+      })
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? BreadcrumbCollapsed.propTypes = {
+  /**
+   * The props used for the CollapsedIcon slot.
+   * @default {}
+   */
+  slotProps: _propTypes.default.shape({
+    collapsedIcon: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
+  }),
+  /**
+   * The components used for each slot inside the BreadcumbCollapsed.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: _propTypes.default.shape({
+    CollapsedIcon: _propTypes.default.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.object
+} : void 0;
+var _default = exports.default = BreadcrumbCollapsed;

node_modules/@mui/material/Button/Button.js

@@ -0,0 +1,692 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _resolveProps = _interopRequireDefault(require("@mui/utils/resolveProps"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _utils = require("../utils");
+var _rootShouldForwardProp = _interopRequireDefault(require("../styles/rootShouldForwardProp"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _ButtonBase = _interopRequireDefault(require("../ButtonBase"));
+var _CircularProgress = _interopRequireDefault(require("../CircularProgress"));
+var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
+var _createSimplePaletteValueFilter = _interopRequireDefault(require("../utils/createSimplePaletteValueFilter"));
+var _buttonClasses = _interopRequireWildcard(require("./buttonClasses"));
+var _ButtonGroupContext = _interopRequireDefault(require("../ButtonGroup/ButtonGroupContext"));
+var _ButtonGroupButtonContext = _interopRequireDefault(require("../ButtonGroup/ButtonGroupButtonContext"));
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    color,
+    disableElevation,
+    fullWidth,
+    size,
+    variant,
+    loading,
+    loadingPosition,
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root', loading && 'loading', variant, `${variant}${(0, _capitalize.default)(color)}`, `size${(0, _capitalize.default)(size)}`, `${variant}Size${(0, _capitalize.default)(size)}`, `color${(0, _capitalize.default)(color)}`, disableElevation && 'disableElevation', fullWidth && 'fullWidth', loading && `loadingPosition${(0, _capitalize.default)(loadingPosition)}`],
+    startIcon: ['icon', 'startIcon', `iconSize${(0, _capitalize.default)(size)}`],
+    endIcon: ['icon', 'endIcon', `iconSize${(0, _capitalize.default)(size)}`],
+    loadingIndicator: ['loadingIndicator'],
+    loadingWrapper: ['loadingWrapper']
+  };
+  const composedClasses = (0, _composeClasses.default)(slots, _buttonClasses.getButtonUtilityClass, classes);
+  return {
+    ...classes,
+    // forward the focused, disabled, etc. classes to the ButtonBase
+    ...composedClasses
+  };
+};
+const commonIconStyles = [{
+  props: {
+    size: 'small'
+  },
+  style: {
+    '& > *:nth-of-type(1)': {
+      fontSize: 18
+    }
+  }
+}, {
+  props: {
+    size: 'medium'
+  },
+  style: {
+    '& > *:nth-of-type(1)': {
+      fontSize: 20
+    }
+  }
+}, {
+  props: {
+    size: 'large'
+  },
+  style: {
+    '& > *:nth-of-type(1)': {
+      fontSize: 22
+    }
+  }
+}];
+const ButtonRoot = (0, _zeroStyled.styled)(_ButtonBase.default, {
+  shouldForwardProp: prop => (0, _rootShouldForwardProp.default)(prop) || prop === 'classes',
+  name: 'MuiButton',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, styles[ownerState.variant], styles[`${ownerState.variant}${(0, _capitalize.default)(ownerState.color)}`], styles[`size${(0, _capitalize.default)(ownerState.size)}`], styles[`${ownerState.variant}Size${(0, _capitalize.default)(ownerState.size)}`], ownerState.color === 'inherit' && styles.colorInherit, ownerState.disableElevation && styles.disableElevation, ownerState.fullWidth && styles.fullWidth, ownerState.loading && styles.loading];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => {
+  const inheritContainedBackgroundColor = theme.palette.mode === 'light' ? theme.palette.grey[300] : theme.palette.grey[800];
+  const inheritContainedHoverBackgroundColor = theme.palette.mode === 'light' ? theme.palette.grey.A100 : theme.palette.grey[700];
+  return {
+    ...theme.typography.button,
+    minWidth: 64,
+    padding: '6px 16px',
+    border: 0,
+    borderRadius: (theme.vars || theme).shape.borderRadius,
+    transition: theme.transitions.create(['background-color', 'box-shadow', 'border-color', 'color'], {
+      duration: theme.transitions.duration.short
+    }),
+    '&:hover': {
+      textDecoration: 'none'
+    },
+    [`&.${_buttonClasses.default.disabled}`]: {
+      color: (theme.vars || theme).palette.action.disabled
+    },
+    variants: [{
+      props: {
+        variant: 'contained'
+      },
+      style: {
+        color: `var(--variant-containedColor)`,
+        backgroundColor: `var(--variant-containedBg)`,
+        boxShadow: (theme.vars || theme).shadows[2],
+        '&:hover': {
+          boxShadow: (theme.vars || theme).shadows[4],
+          // Reset on touch devices, it doesn't add specificity
+          '@media (hover: none)': {
+            boxShadow: (theme.vars || theme).shadows[2]
+          }
+        },
+        '&:active': {
+          boxShadow: (theme.vars || theme).shadows[8]
+        },
+        [`&.${_buttonClasses.default.focusVisible}`]: {
+          boxShadow: (theme.vars || theme).shadows[6]
+        },
+        [`&.${_buttonClasses.default.disabled}`]: {
+          color: (theme.vars || theme).palette.action.disabled,
+          boxShadow: (theme.vars || theme).shadows[0],
+          backgroundColor: (theme.vars || theme).palette.action.disabledBackground
+        }
+      }
+    }, {
+      props: {
+        variant: 'outlined'
+      },
+      style: {
+        padding: '5px 15px',
+        border: '1px solid currentColor',
+        borderColor: `var(--variant-outlinedBorder, currentColor)`,
+        backgroundColor: `var(--variant-outlinedBg)`,
+        color: `var(--variant-outlinedColor)`,
+        [`&.${_buttonClasses.default.disabled}`]: {
+          border: `1px solid ${(theme.vars || theme).palette.action.disabledBackground}`
+        }
+      }
+    }, {
+      props: {
+        variant: 'text'
+      },
+      style: {
+        padding: '6px 8px',
+        color: `var(--variant-textColor)`,
+        backgroundColor: `var(--variant-textBg)`
+      }
+    }, ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)()).map(([color]) => ({
+      props: {
+        color
+      },
+      style: {
+        '--variant-textColor': (theme.vars || theme).palette[color].main,
+        '--variant-outlinedColor': (theme.vars || theme).palette[color].main,
+        '--variant-outlinedBorder': theme.alpha((theme.vars || theme).palette[color].main, 0.5),
+        '--variant-containedColor': (theme.vars || theme).palette[color].contrastText,
+        '--variant-containedBg': (theme.vars || theme).palette[color].main,
+        '@media (hover: hover)': {
+          '&:hover': {
+            '--variant-containedBg': (theme.vars || theme).palette[color].dark,
+            '--variant-textBg': theme.alpha((theme.vars || theme).palette[color].main, (theme.vars || theme).palette.action.hoverOpacity),
+            '--variant-outlinedBorder': (theme.vars || theme).palette[color].main,
+            '--variant-outlinedBg': theme.alpha((theme.vars || theme).palette[color].main, (theme.vars || theme).palette.action.hoverOpacity)
+          }
+        }
+      }
+    })), {
+      props: {
+        color: 'inherit'
+      },
+      style: {
+        color: 'inherit',
+        borderColor: 'currentColor',
+        '--variant-containedBg': theme.vars ? theme.vars.palette.Button.inheritContainedBg : inheritContainedBackgroundColor,
+        '@media (hover: hover)': {
+          '&:hover': {
+            '--variant-containedBg': theme.vars ? theme.vars.palette.Button.inheritContainedHoverBg : inheritContainedHoverBackgroundColor,
+            '--variant-textBg': theme.alpha((theme.vars || theme).palette.text.primary, (theme.vars || theme).palette.action.hoverOpacity),
+            '--variant-outlinedBg': theme.alpha((theme.vars || theme).palette.text.primary, (theme.vars || theme).palette.action.hoverOpacity)
+          }
+        }
+      }
+    }, {
+      props: {
+        size: 'small',
+        variant: 'text'
+      },
+      style: {
+        padding: '4px 5px',
+        fontSize: theme.typography.pxToRem(13)
+      }
+    }, {
+      props: {
+        size: 'large',
+        variant: 'text'
+      },
+      style: {
+        padding: '8px 11px',
+        fontSize: theme.typography.pxToRem(15)
+      }
+    }, {
+      props: {
+        size: 'small',
+        variant: 'outlined'
+      },
+      style: {
+        padding: '3px 9px',
+        fontSize: theme.typography.pxToRem(13)
+      }
+    }, {
+      props: {
+        size: 'large',
+        variant: 'outlined'
+      },
+      style: {
+        padding: '7px 21px',
+        fontSize: theme.typography.pxToRem(15)
+      }
+    }, {
+      props: {
+        size: 'small',
+        variant: 'contained'
+      },
+      style: {
+        padding: '4px 10px',
+        fontSize: theme.typography.pxToRem(13)
+      }
+    }, {
+      props: {
+        size: 'large',
+        variant: 'contained'
+      },
+      style: {
+        padding: '8px 22px',
+        fontSize: theme.typography.pxToRem(15)
+      }
+    }, {
+      props: {
+        disableElevation: true
+      },
+      style: {
+        boxShadow: 'none',
+        '&:hover': {
+          boxShadow: 'none'
+        },
+        [`&.${_buttonClasses.default.focusVisible}`]: {
+          boxShadow: 'none'
+        },
+        '&:active': {
+          boxShadow: 'none'
+        },
+        [`&.${_buttonClasses.default.disabled}`]: {
+          boxShadow: 'none'
+        }
+      }
+    }, {
+      props: {
+        fullWidth: true
+      },
+      style: {
+        width: '100%'
+      }
+    }, {
+      props: {
+        loadingPosition: 'center'
+      },
+      style: {
+        transition: theme.transitions.create(['background-color', 'box-shadow', 'border-color'], {
+          duration: theme.transitions.duration.short
+        }),
+        [`&.${_buttonClasses.default.loading}`]: {
+          color: 'transparent'
+        }
+      }
+    }]
+  };
+}));
+const ButtonStartIcon = (0, _zeroStyled.styled)('span', {
+  name: 'MuiButton',
+  slot: 'StartIcon',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.startIcon, ownerState.loading && styles.startIconLoadingStart, styles[`iconSize${(0, _capitalize.default)(ownerState.size)}`]];
+  }
+})(({
+  theme
+}) => ({
+  display: 'inherit',
+  marginRight: 8,
+  marginLeft: -4,
+  variants: [{
+    props: {
+      size: 'small'
+    },
+    style: {
+      marginLeft: -2
+    }
+  }, {
+    props: {
+      loadingPosition: 'start',
+      loading: true
+    },
+    style: {
+      transition: theme.transitions.create(['opacity'], {
+        duration: theme.transitions.duration.short
+      }),
+      opacity: 0
+    }
+  }, {
+    props: {
+      loadingPosition: 'start',
+      loading: true,
+      fullWidth: true
+    },
+    style: {
+      marginRight: -8
+    }
+  }, ...commonIconStyles]
+}));
+const ButtonEndIcon = (0, _zeroStyled.styled)('span', {
+  name: 'MuiButton',
+  slot: 'EndIcon',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.endIcon, ownerState.loading && styles.endIconLoadingEnd, styles[`iconSize${(0, _capitalize.default)(ownerState.size)}`]];
+  }
+})(({
+  theme
+}) => ({
+  display: 'inherit',
+  marginRight: -4,
+  marginLeft: 8,
+  variants: [{
+    props: {
+      size: 'small'
+    },
+    style: {
+      marginRight: -2
+    }
+  }, {
+    props: {
+      loadingPosition: 'end',
+      loading: true
+    },
+    style: {
+      transition: theme.transitions.create(['opacity'], {
+        duration: theme.transitions.duration.short
+      }),
+      opacity: 0
+    }
+  }, {
+    props: {
+      loadingPosition: 'end',
+      loading: true,
+      fullWidth: true
+    },
+    style: {
+      marginLeft: -8
+    }
+  }, ...commonIconStyles]
+}));
+const ButtonLoadingIndicator = (0, _zeroStyled.styled)('span', {
+  name: 'MuiButton',
+  slot: 'LoadingIndicator'
+})(({
+  theme
+}) => ({
+  display: 'none',
+  position: 'absolute',
+  visibility: 'visible',
+  variants: [{
+    props: {
+      loading: true
+    },
+    style: {
+      display: 'flex'
+    }
+  }, {
+    props: {
+      loadingPosition: 'start'
+    },
+    style: {
+      left: 14
+    }
+  }, {
+    props: {
+      loadingPosition: 'start',
+      size: 'small'
+    },
+    style: {
+      left: 10
+    }
+  }, {
+    props: {
+      variant: 'text',
+      loadingPosition: 'start'
+    },
+    style: {
+      left: 6
+    }
+  }, {
+    props: {
+      loadingPosition: 'center'
+    },
+    style: {
+      left: '50%',
+      transform: 'translate(-50%)',
+      color: (theme.vars || theme).palette.action.disabled
+    }
+  }, {
+    props: {
+      loadingPosition: 'end'
+    },
+    style: {
+      right: 14
+    }
+  }, {
+    props: {
+      loadingPosition: 'end',
+      size: 'small'
+    },
+    style: {
+      right: 10
+    }
+  }, {
+    props: {
+      variant: 'text',
+      loadingPosition: 'end'
+    },
+    style: {
+      right: 6
+    }
+  }, {
+    props: {
+      loadingPosition: 'start',
+      fullWidth: true
+    },
+    style: {
+      position: 'relative',
+      left: -10
+    }
+  }, {
+    props: {
+      loadingPosition: 'end',
+      fullWidth: true
+    },
+    style: {
+      position: 'relative',
+      right: -10
+    }
+  }]
+}));
+const ButtonLoadingIconPlaceholder = (0, _zeroStyled.styled)('span', {
+  name: 'MuiButton',
+  slot: 'LoadingIconPlaceholder'
+})({
+  display: 'inline-block',
+  width: '1em',
+  height: '1em'
+});
+const Button = /*#__PURE__*/React.forwardRef(function Button(inProps, ref) {
+  // props priority: `inProps` > `contextProps` > `themeDefaultProps`
+  const contextProps = React.useContext(_ButtonGroupContext.default);
+  const buttonGroupButtonContextPositionClassName = React.useContext(_ButtonGroupButtonContext.default);
+  const resolvedProps = (0, _resolveProps.default)(contextProps, inProps);
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: resolvedProps,
+    name: 'MuiButton'
+  });
+  const {
+    children,
+    color = 'primary',
+    component = 'button',
+    className,
+    disabled = false,
+    disableElevation = false,
+    disableFocusRipple = false,
+    endIcon: endIconProp,
+    focusVisibleClassName,
+    fullWidth = false,
+    id: idProp,
+    loading = null,
+    loadingIndicator: loadingIndicatorProp,
+    loadingPosition = 'center',
+    size = 'medium',
+    startIcon: startIconProp,
+    type,
+    variant = 'text',
+    ...other
+  } = props;
+  const loadingId = (0, _utils.unstable_useId)(idProp);
+  const loadingIndicator = loadingIndicatorProp ?? /*#__PURE__*/(0, _jsxRuntime.jsx)(_CircularProgress.default, {
+    "aria-labelledby": loadingId,
+    color: "inherit",
+    size: 16
+  });
+  const ownerState = {
+    ...props,
+    color,
+    component,
+    disabled,
+    disableElevation,
+    disableFocusRipple,
+    fullWidth,
+    loading,
+    loadingIndicator,
+    loadingPosition,
+    size,
+    type,
+    variant
+  };
+  const classes = useUtilityClasses(ownerState);
+  const startIcon = (startIconProp || loading && loadingPosition === 'start') && /*#__PURE__*/(0, _jsxRuntime.jsx)(ButtonStartIcon, {
+    className: classes.startIcon,
+    ownerState: ownerState,
+    children: startIconProp || /*#__PURE__*/(0, _jsxRuntime.jsx)(ButtonLoadingIconPlaceholder, {
+      className: classes.loadingIconPlaceholder,
+      ownerState: ownerState
+    })
+  });
+  const endIcon = (endIconProp || loading && loadingPosition === 'end') && /*#__PURE__*/(0, _jsxRuntime.jsx)(ButtonEndIcon, {
+    className: classes.endIcon,
+    ownerState: ownerState,
+    children: endIconProp || /*#__PURE__*/(0, _jsxRuntime.jsx)(ButtonLoadingIconPlaceholder, {
+      className: classes.loadingIconPlaceholder,
+      ownerState: ownerState
+    })
+  });
+  const positionClassName = buttonGroupButtonContextPositionClassName || '';
+  const loader = typeof loading === 'boolean' ?
+  /*#__PURE__*/
+  // use plain HTML span to minimize the runtime overhead
+  (0, _jsxRuntime.jsx)("span", {
+    className: classes.loadingWrapper,
+    style: {
+      display: 'contents'
+    },
+    children: loading && /*#__PURE__*/(0, _jsxRuntime.jsx)(ButtonLoadingIndicator, {
+      className: classes.loadingIndicator,
+      ownerState: ownerState,
+      children: loadingIndicator
+    })
+  }) : null;
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(ButtonRoot, {
+    ownerState: ownerState,
+    className: (0, _clsx.default)(contextProps.className, classes.root, className, positionClassName),
+    component: component,
+    disabled: disabled || loading,
+    focusRipple: !disableFocusRipple,
+    focusVisibleClassName: (0, _clsx.default)(classes.focusVisible, focusVisibleClassName),
+    ref: ref,
+    type: type,
+    id: loading ? loadingId : idProp,
+    ...other,
+    classes: classes,
+    children: [startIcon, loadingPosition !== 'end' && loader, children, loadingPosition === 'end' && loader, endIcon]
+  });
+});
+process.env.NODE_ENV !== "production" ? Button.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.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.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['inherit', 'primary', 'secondary', 'success', 'error', 'info', 'warning']), _propTypes.default.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: _propTypes.default.elementType,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: _propTypes.default.bool,
+  /**
+   * If `true`, no elevation is used.
+   * @default false
+   */
+  disableElevation: _propTypes.default.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: _propTypes.default.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: _propTypes.default.bool,
+  /**
+   * Element placed after the children.
+   */
+  endIcon: _propTypes.default.node,
+  /**
+   * @ignore
+   */
+  focusVisibleClassName: _propTypes.default.string,
+  /**
+   * If `true`, the button will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: _propTypes.default.bool,
+  /**
+   * The URL to link to when the button is clicked.
+   * If defined, an `a` element will be used as the root node.
+   */
+  href: _propTypes.default.string,
+  /**
+   * @ignore
+   */
+  id: _propTypes.default.string,
+  /**
+   * If `true`, the loading indicator is visible and the button is disabled.
+   * If `true | false`, the loading wrapper is always rendered before the children to prevent [Google Translation Crash](https://github.com/mui/material-ui/issues/27853).
+   * @default null
+   */
+  loading: _propTypes.default.bool,
+  /**
+   * Element placed before the children if the button is in loading state.
+   * The node should contain an element with `role="progressbar"` with an accessible name.
+   * By default, it renders a `CircularProgress` that is labeled by the button itself.
+   * @default <CircularProgress color="inherit" size={16} />
+   */
+  loadingIndicator: _propTypes.default.node,
+  /**
+   * The loading indicator can be positioned on the start, end, or the center of the button.
+   * @default 'center'
+   */
+  loadingPosition: _propTypes.default.oneOf(['center', 'end', 'start']),
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense button styling.
+   * @default 'medium'
+   */
+  size: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['small', 'medium', 'large']), _propTypes.default.string]),
+  /**
+   * Element placed before the children.
+   */
+  startIcon: _propTypes.default.node,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * @ignore
+   */
+  type: _propTypes.default.oneOfType([_propTypes.default.oneOf(['button', 'reset', 'submit']), _propTypes.default.string]),
+  /**
+   * The variant to use.
+   * @default 'text'
+   */
+  variant: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['contained', 'outlined', 'text']), _propTypes.default.string])
+} : void 0;
+var _default = exports.default = Button;

node_modules/@mui/material/Button/buttonClasses.d.ts

@@ -0,0 +1,194 @@
+export interface ButtonClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `variant="text"`. */
+  text: string;
+  /** Styles applied to the root element if `variant="text"` and `color="inherit"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorInherit](/material-ui/api/button/#button-classes-MuiButton-colorInherit) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textInherit: string;
+  /** Styles applied to the root element if `variant="text"` and `color="primary"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorPrimary](/material-ui/api/button/#button-classes-MuiButton-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textPrimary: string;
+  /** Styles applied to the root element if `variant="text"` and `color="secondary"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorSecondary](/material-ui/api/button/#button-classes-MuiButton-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textSecondary: string;
+  /** Styles applied to the root element if `variant="text"` and `color="success"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorSuccess](/material-ui/api/button/#button-classes-MuiButton-colorSuccess) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textSuccess: string;
+  /** Styles applied to the root element if `variant="text"` and `color="error"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorError](/material-ui/api/button/#button-classes-MuiButton-colorError) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textError: string;
+  /** Styles applied to the root element if `variant="text"` and `color="info"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorInfo](/material-ui/api/button/#button-classes-MuiButton-colorInfo) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textInfo: string;
+  /** Styles applied to the root element if `variant="text"` and `color="warning"`.
+   * @deprecated Combine the [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) and [.MuiButton-colorWarning](/material-ui/api/button/#button-classes-MuiButton-colorWarning) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textWarning: string;
+  /** Styles applied to the root element if `variant="outlined"`. */
+  outlined: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="inherit"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorInherit](/material-ui/api/button/#button-classes-MuiButton-colorInherit) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedInherit: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="primary"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorPrimary](/material-ui/api/button/#button-classes-MuiButton-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedPrimary: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="secondary"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorSecondary](/material-ui/api/button/#button-classes-MuiButton-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedSecondary: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="success"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorSuccess](/material-ui/api/button/#button-classes-MuiButton-colorSuccess) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedSuccess: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="error"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorError](/material-ui/api/button/#button-classes-MuiButton-colorError) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedError: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="info"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorInfo](/material-ui/api/button/#button-classes-MuiButton-colorInfo) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedInfo: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="warning"`.
+   * @deprecated Combine the [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) and [.MuiButton-colorWarning](/material-ui/api/button/#button-classes-MuiButton-colorWarning) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedWarning: string;
+  /** Styles applied to the root element if `variant="contained"`. */
+  contained: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="inherit"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorInherit](/material-ui/api/button/#button-classes-MuiButton-colorInherit) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedInherit: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="primary"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorPrimary](/material-ui/api/button/#button-classes-MuiButton-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedPrimary: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="secondary"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorSecondary](/material-ui/api/button/#button-classes-MuiButton-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedSecondary: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="success"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorSuccess](/material-ui/api/button/#button-classes-MuiButton-colorSuccess) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedSuccess: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="info"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorInfo](/material-ui/api/button/#button-classes-MuiButton-colorInfo) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedInfo: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="error"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorError](/material-ui/api/button/#button-classes-MuiButton-colorError) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedError: string;
+  /** Styles applied to the root element if `variant="contained"` and `color="warning"`.
+   * @deprecated Combine the [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) and [.MuiButton-colorWarning](/material-ui/api/button/#button-classes-MuiButton-colorWarning) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedWarning: string;
+  /** Styles applied to the root element if `disableElevation={true}`. */
+  disableElevation: string;
+  /** State class applied to the ButtonBase root element if the button is keyboard focused. */
+  focusVisible: string;
+  /** State class applied to the root element if `disabled={true}`. */
+  disabled: string;
+  /** Styles applied to the root element if `color="inherit"`. */
+  colorInherit: string;
+  /** Styles applied to the root element if `size="small"` and `variant="text"`.
+   * @deprecated Combine the [.MuiButton-sizeSmall](/material-ui/api/button/#button-classes-MuiButton-sizeSmall) and [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textSizeSmall: string;
+  /** Styles applied to the root element if `size="medium"` and `variant="text"`.
+   * @deprecated Combine the [.MuiButton-sizeMedium](/material-ui/api/button/#button-classes-MuiButton-sizeMedium) and [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textSizeMedium: string;
+  /** Styles applied to the root element if `size="large"` and `variant="text"`.
+   * @deprecated Combine the [.MuiButton-sizeLarge](/material-ui/api/button/#button-classes-MuiButton-sizeLarge) and [.MuiButton-text](/material-ui/api/button/#button-classes-MuiButton-text) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  textSizeLarge: string;
+  /** Styles applied to the root element if `size="small"` and `variant="outlined"`.
+   * @deprecated Combine the [.MuiButton-sizeSmall](/material-ui/api/button/#button-classes-MuiButton-sizeSmall) and [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedSizeSmall: string;
+  /** Styles applied to the root element if `size="medium"` and `variant="outlined"`.
+   * @deprecated Combine the [.MuiButton-sizeMedium](/material-ui/api/button/#button-classes-MuiButton-sizeMedium) and [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedSizeMedium: string;
+  /** Styles applied to the root element if `size="large"` and `variant="outlined"`.
+   * @deprecated Combine the [.MuiButton-sizeLarge](/material-ui/api/button/#button-classes-MuiButton-sizeLarge) and [.MuiButton-outlined](/material-ui/api/button/#button-classes-MuiButton-outlined) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedSizeLarge: string;
+  /** Styles applied to the root element if `size="small"` and `variant="contained"`.
+   * @deprecated Combine the [.MuiButton-sizeSmall](/material-ui/api/button/#button-classes-MuiButton-sizeSmall) and [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedSizeSmall: string;
+  /** Styles applied to the root element if `size="medium"` and `variant="contained"`.
+   * @deprecated Combine the [.MuiButton-sizeMedium](/material-ui/api/button/#button-classes-MuiButton-sizeMedium) and [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedSizeMedium: string;
+  /** Styles applied to the root element if `size="large"` and `variant="contained"`.
+   * @deprecated Combine the [.MuiButton-sizeLarge](/material-ui/api/button/#button-classes-MuiButton-sizeLarge) and [.MuiButton-contained](/material-ui/api/button/#button-classes-MuiButton-contained) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  containedSizeLarge: string;
+  /** Styles applied to the root element if `size="small"`. */
+  sizeSmall: string;
+  /** Styles applied to the root element if `size="medium"`. */
+  sizeMedium: string;
+  /** Styles applied to the root element if `size="large"`. */
+  sizeLarge: string;
+  /** Styles applied to the root element if `fullWidth={true}`. */
+  fullWidth: string;
+  /** Styles applied to the icon element if supplied */
+  icon: string;
+  /** Styles applied to the startIcon element if supplied. */
+  startIcon: string;
+  /** Styles applied to the endIcon element if supplied. */
+  endIcon: string;
+  /** Styles applied to the icon element if supplied and `size="small"`.
+   * @deprecated Combine the [.MuiButton-icon](/material-ui/api/button/#button-classes-MuiButton-icon) and [.MuiButtonSizeSmall](/material-ui/api/button/#button-classes-MuiButton-sizeSmall) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconSizeSmall: string;
+  /** Styles applied to the icon element if supplied and `size="medium"`.
+   * @deprecated Combine the [.MuiButton-icon](/material-ui/api/button/#button-classes-MuiButton-icon) and [.MuiButtonSizeMedium](/material-ui/api/button/#button-classes-MuiButton-sizeMedium) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconSizeMedium: string;
+  /** Styles applied to the icon element if supplied and `size="large"`.
+   * @deprecated Combine the [.MuiButton-icon](/material-ui/api/button/#button-classes-MuiButton-icon) and [.MuiButtonSizeLarge](/material-ui/api/button/#button-classes-MuiButton-sizeLarge) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconSizeLarge: string;
+  /** Styles applied to the root element if `color="primary"`. */
+  colorPrimary: string;
+  /** Styles applied to the root element if `color="secondary"`. */
+  colorSecondary: string;
+  /** Styles applied to the root element if `color="success"`. */
+  colorSuccess: string;
+  /** Styles applied to the root element if `color="error"`. */
+  colorError: string;
+  /** Styles applied to the root element if `color="info"`. */
+  colorInfo: string;
+  /** Styles applied to the root element if `color="warning"`. */
+  colorWarning: string;
+  /** Styles applied to the root element if `loading={true}`. */
+  loading: string;
+  /** Styles applied to the loadingWrapper element. */
+  loadingWrapper: string;
+  /** Styles applied to the loadingIconPlaceholder element. */
+  loadingIconPlaceholder: string;
+  /** Styles applied to the loadingIndicator element. */
+  loadingIndicator: string;
+  /** Styles applied to the root element if `loadingPosition="center"`. */
+  loadingPositionCenter: string;
+  /** Styles applied to the root element if `loadingPosition="start"`. */
+  loadingPositionStart: string;
+  /** Styles applied to the root element if `loadingPosition="end"`. */
+  loadingPositionEnd: string;
+}
+export type ButtonClassKey = keyof ButtonClasses;
+export declare function getButtonUtilityClass(slot: string): string;
+declare const buttonClasses: ButtonClasses;
+export default buttonClasses;

node_modules/@mui/material/ButtonGroup/ButtonGroupButtonContext.js

@@ -0,0 +1,17 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+/**
+ * @ignore - internal component.
+ */
+const ButtonGroupButtonContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== 'production') {
+  ButtonGroupButtonContext.displayName = 'ButtonGroupButtonContext';
+}
+var _default = exports.default = ButtonGroupButtonContext;

node_modules/@mui/material/ButtonGroup/index.d.ts

@@ -0,0 +1,6 @@
+export { default } from "./ButtonGroup.js";
+export * from "./ButtonGroup.js";
+export { default as buttonGroupClasses } from "./buttonGroupClasses.js";
+export * from "./buttonGroupClasses.js";
+export { default as ButtonGroupContext } from "./ButtonGroupContext.js";
+export { default as ButtonGroupButtonContext } from "./ButtonGroupButtonContext.js";

node_modules/@mui/material/Card/Card.js

@@ -0,0 +1,90 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _chainPropTypes = _interopRequireDefault(require("@mui/utils/chainPropTypes"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _zeroStyled = require("../zero-styled");
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _Paper = _interopRequireDefault(require("../Paper"));
+var _cardClasses = require("./cardClasses");
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root']
+  };
+  return (0, _composeClasses.default)(slots, _cardClasses.getCardUtilityClass, classes);
+};
+const CardRoot = (0, _zeroStyled.styled)(_Paper.default, {
+  name: 'MuiCard',
+  slot: 'Root'
+})({
+  overflow: 'hidden'
+});
+const Card = /*#__PURE__*/React.forwardRef(function Card(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiCard'
+  });
+  const {
+    className,
+    raised = false,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    raised
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(CardRoot, {
+    className: (0, _clsx.default)(classes.root, className),
+    elevation: raised ? 8 : undefined,
+    ref: ref,
+    ownerState: ownerState,
+    ...other
+  });
+});
+process.env.NODE_ENV !== "production" ? Card.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * If `true`, the card will use raised styling.
+   * @default false
+   */
+  raised: (0, _chainPropTypes.default)(_propTypes.default.bool, props => {
+    if (props.raised && props.variant === 'outlined') {
+      return new Error('MUI: Combining `raised={true}` with `variant="outlined"` has no effect.');
+    }
+    return null;
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object])
+} : void 0;
+var _default = exports.default = Card;

node_modules/@mui/material/CardActionArea/CardActionArea.d.ts

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { SlotProps, CreateSlotsAndSlotProps } from "../utils/types.js";
+import { Theme } from "../styles/index.js";
+import { ButtonBaseProps, ButtonBaseTypeMap, ExtendButtonBase, ExtendButtonBaseTypeMap } from "../ButtonBase/index.js";
+import { OverrideProps } from "../OverridableComponent/index.js";
+import { CardActionAreaClasses } from "./cardActionAreaClasses.js";
+export interface CardActionAreaSlots {
+  /**
+   * The component that renders the root.
+   * @default ButtonBase
+   */
+  root: React.ElementType;
+  /**
+   * The component that renders the focusHighlight.
+   * @default span
+   */
+  focusHighlight: React.ElementType;
+}
+export type CardActionAreaSlotsAndSlotProps = CreateSlotsAndSlotProps<CardActionAreaSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on the span element.
+   */
+  root: SlotProps<React.ElementType<ButtonBaseProps>, {}, CardActionAreaOwnerState>;
+  /**
+   * Props forwarded to the focusHighlight slot.
+   * By default, the available props are based on the span element.
+   */
+  focusHighlight: SlotProps<'span', {}, CardActionAreaOwnerState>;
+}>;
+export interface CardActionAreaOwnerState extends Omit<CardActionAreaProps, 'slots' | 'slotProps'> {}
+export interface CardActionAreaOwnProps {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<CardActionAreaClasses>;
+  focusVisibleClassName?: string;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export type CardActionAreaTypeMap<AdditionalProps, RootComponent extends React.ElementType> = ExtendButtonBaseTypeMap<{
+  props: AdditionalProps & CardActionAreaOwnProps & CardActionAreaSlotsAndSlotProps;
+  defaultComponent: RootComponent;
+}>;
+
+/**
+ *
+ * Demos:
+ *
+ * - [Card](https://mui.com/material-ui/react-card/)
+ *
+ * API:
+ *
+ * - [CardActionArea API](https://mui.com/material-ui/api/card-action-area/)
+ * - inherits [ButtonBase API](https://mui.com/material-ui/api/button-base/)
+ */
+declare const CardActionArea: ExtendButtonBase<CardActionAreaTypeMap<{}, ButtonBaseTypeMap['defaultComponent']>>;
+export type CardActionAreaProps<RootComponent extends React.ElementType = ButtonBaseTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<CardActionAreaTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default CardActionArea;

node_modules/@mui/material/CardActions/cardActionsClasses.d.ts

@@ -0,0 +1,10 @@
+export interface CardActionsClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element unless `disableSpacing={true}`. */
+  spacing: string;
+}
+export type CardActionsClassKey = keyof CardActionsClasses;
+export declare function getCardActionsUtilityClass(slot: string): string;
+declare const cardActionsClasses: CardActionsClasses;
+export default cardActionsClasses;

node_modules/@mui/material/CardContent/cardContentClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getCardContentUtilityClass = getCardContentUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getCardContentUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiCardContent', slot);
+}
+const cardContentClasses = (0, _generateUtilityClasses.default)('MuiCardContent', ['root']);
+var _default = exports.default = cardContentClasses;

node_modules/@mui/material/CardMedia/cardMediaClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getCardMediaUtilityClass = getCardMediaUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getCardMediaUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiCardMedia', slot);
+}
+const cardMediaClasses = (0, _generateUtilityClasses.default)('MuiCardMedia', ['root', 'media', 'img']);
+var _default = exports.default = cardMediaClasses;

node_modules/@mui/material/Checkbox/Checkbox.js

@@ -0,0 +1,286 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _SwitchBase = _interopRequireDefault(require("../internal/SwitchBase"));
+var _CheckBoxOutlineBlank = _interopRequireDefault(require("../internal/svg-icons/CheckBoxOutlineBlank"));
+var _CheckBox = _interopRequireDefault(require("../internal/svg-icons/CheckBox"));
+var _IndeterminateCheckBox = _interopRequireDefault(require("../internal/svg-icons/IndeterminateCheckBox"));
+var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
+var _rootShouldForwardProp = _interopRequireDefault(require("../styles/rootShouldForwardProp"));
+var _checkboxClasses = _interopRequireWildcard(require("./checkboxClasses"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _createSimplePaletteValueFilter = _interopRequireDefault(require("../utils/createSimplePaletteValueFilter"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _utils = require("../utils");
+var _useSlot = _interopRequireDefault(require("../utils/useSlot"));
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    indeterminate,
+    color,
+    size
+  } = ownerState;
+  const slots = {
+    root: ['root', indeterminate && 'indeterminate', `color${(0, _capitalize.default)(color)}`, `size${(0, _capitalize.default)(size)}`]
+  };
+  const composedClasses = (0, _composeClasses.default)(slots, _checkboxClasses.getCheckboxUtilityClass, classes);
+  return {
+    ...classes,
+    // forward the disabled and checked classes to the SwitchBase
+    ...composedClasses
+  };
+};
+const CheckboxRoot = (0, _zeroStyled.styled)(_SwitchBase.default, {
+  shouldForwardProp: prop => (0, _rootShouldForwardProp.default)(prop) || prop === 'classes',
+  name: 'MuiCheckbox',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, ownerState.indeterminate && styles.indeterminate, styles[`size${(0, _capitalize.default)(ownerState.size)}`], ownerState.color !== 'default' && styles[`color${(0, _capitalize.default)(ownerState.color)}`]];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  color: (theme.vars || theme).palette.text.secondary,
+  variants: [{
+    props: {
+      color: 'default',
+      disableRipple: false
+    },
+    style: {
+      '&:hover': {
+        backgroundColor: theme.alpha((theme.vars || theme).palette.action.active, (theme.vars || theme).palette.action.hoverOpacity)
+      }
+    }
+  }, ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)()).map(([color]) => ({
+    props: {
+      color,
+      disableRipple: false
+    },
+    style: {
+      '&:hover': {
+        backgroundColor: theme.alpha((theme.vars || theme).palette[color].main, (theme.vars || theme).palette.action.hoverOpacity)
+      }
+    }
+  })), ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)()).map(([color]) => ({
+    props: {
+      color
+    },
+    style: {
+      [`&.${_checkboxClasses.default.checked}, &.${_checkboxClasses.default.indeterminate}`]: {
+        color: (theme.vars || theme).palette[color].main
+      },
+      [`&.${_checkboxClasses.default.disabled}`]: {
+        color: (theme.vars || theme).palette.action.disabled
+      }
+    }
+  })), {
+    // Should be last to override other colors
+    props: {
+      disableRipple: false
+    },
+    style: {
+      // Reset on touch devices, it doesn't add specificity
+      '&:hover': {
+        '@media (hover: none)': {
+          backgroundColor: 'transparent'
+        }
+      }
+    }
+  }]
+})));
+const defaultCheckedIcon = /*#__PURE__*/(0, _jsxRuntime.jsx)(_CheckBox.default, {});
+const defaultIcon = /*#__PURE__*/(0, _jsxRuntime.jsx)(_CheckBoxOutlineBlank.default, {});
+const defaultIndeterminateIcon = /*#__PURE__*/(0, _jsxRuntime.jsx)(_IndeterminateCheckBox.default, {});
+const Checkbox = /*#__PURE__*/React.forwardRef(function Checkbox(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiCheckbox'
+  });
+  const {
+    checkedIcon = defaultCheckedIcon,
+    color = 'primary',
+    icon: iconProp = defaultIcon,
+    indeterminate = false,
+    indeterminateIcon: indeterminateIconProp = defaultIndeterminateIcon,
+    inputProps,
+    size = 'medium',
+    disableRipple = false,
+    className,
+    slots = {},
+    slotProps = {},
+    ...other
+  } = props;
+  const icon = indeterminate ? indeterminateIconProp : iconProp;
+  const indeterminateIcon = indeterminate ? indeterminateIconProp : checkedIcon;
+  const ownerState = {
+    ...props,
+    disableRipple,
+    color,
+    indeterminate,
+    size
+  };
+  const classes = useUtilityClasses(ownerState);
+  const externalInputProps = slotProps.input ?? inputProps;
+  const [RootSlot, rootSlotProps] = (0, _useSlot.default)('root', {
+    ref,
+    elementType: CheckboxRoot,
+    className: (0, _clsx.default)(classes.root, className),
+    shouldForwardComponentProp: true,
+    externalForwardedProps: {
+      slots,
+      slotProps,
+      ...other
+    },
+    ownerState,
+    additionalProps: {
+      type: 'checkbox',
+      icon: /*#__PURE__*/React.cloneElement(icon, {
+        fontSize: icon.props.fontSize ?? size
+      }),
+      checkedIcon: /*#__PURE__*/React.cloneElement(indeterminateIcon, {
+        fontSize: indeterminateIcon.props.fontSize ?? size
+      }),
+      disableRipple,
+      slots,
+      slotProps: {
+        input: (0, _utils.mergeSlotProps)(typeof externalInputProps === 'function' ? externalInputProps(ownerState) : externalInputProps, {
+          'data-indeterminate': indeterminate
+        })
+      }
+    }
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(RootSlot, {
+    ...rootSlotProps,
+    classes: classes
+  });
+});
+process.env.NODE_ENV !== "production" ? Checkbox.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.default.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <CheckBoxIcon />
+   */
+  checkedIcon: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.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.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), _propTypes.default.string]),
+  /**
+   * The default checked state. Use when the component is not controlled.
+   */
+  defaultChecked: _propTypes.default.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: _propTypes.default.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: _propTypes.default.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <CheckBoxOutlineBlankIcon />
+   */
+  icon: _propTypes.default.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: _propTypes.default.string,
+  /**
+   * If `true`, the component appears indeterminate.
+   * This does not set the native input element to indeterminate due
+   * to inconsistent behavior across browsers.
+   * However, we set a `data-indeterminate` attribute on the `input`.
+   * @default false
+   */
+  indeterminate: _propTypes.default.bool,
+  /**
+   * The icon to display when the component is indeterminate.
+   * @default <IndeterminateCheckBoxIcon />
+   */
+  indeterminateIcon: _propTypes.default.node,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#attributes) applied to the `input` element.
+   * @deprecated Use `slotProps.input` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  inputProps: _propTypes.default.object,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: _propTypes.default.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: _propTypes.default.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense checkbox styling.
+   * @default 'medium'
+   */
+  size: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['medium', 'small']), _propTypes.default.string]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: _propTypes.default.shape({
+    input: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
+    root: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: _propTypes.default.shape({
+    input: _propTypes.default.elementType,
+    root: _propTypes.default.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   * The browser uses "on" as the default value.
+   */
+  value: _propTypes.default.any
+} : void 0;
+var _default = exports.default = Checkbox;

node_modules/@mui/material/Checkbox/checkboxClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getCheckboxUtilityClass = getCheckboxUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getCheckboxUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiCheckbox', slot);
+}
+const checkboxClasses = (0, _generateUtilityClasses.default)('MuiCheckbox', ['root', 'checked', 'disabled', 'indeterminate', 'colorPrimary', 'colorSecondary', 'sizeSmall', 'sizeMedium']);
+var _default = exports.default = checkboxClasses;

node_modules/@mui/material/Checkbox/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Checkbox.js";
+export * from "./Checkbox.js";
+export { default as checkboxClasses } from "./checkboxClasses.js";
+export * from "./checkboxClasses.js";

node_modules/@mui/material/Chip/Chip.js

@@ -0,0 +1,634 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _Cancel = _interopRequireDefault(require("../internal/svg-icons/Cancel"));
+var _useForkRef = _interopRequireDefault(require("../utils/useForkRef"));
+var _unsupportedProp = _interopRequireDefault(require("../utils/unsupportedProp"));
+var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
+var _ButtonBase = _interopRequireDefault(require("../ButtonBase"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _createSimplePaletteValueFilter = _interopRequireDefault(require("../utils/createSimplePaletteValueFilter"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _chipClasses = _interopRequireWildcard(require("./chipClasses"));
+var _useSlot = _interopRequireDefault(require("../utils/useSlot"));
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    disabled,
+    size,
+    color,
+    iconColor,
+    onDelete,
+    clickable,
+    variant
+  } = ownerState;
+  const slots = {
+    root: ['root', variant, disabled && 'disabled', `size${(0, _capitalize.default)(size)}`, `color${(0, _capitalize.default)(color)}`, clickable && 'clickable', clickable && `clickableColor${(0, _capitalize.default)(color)}`, onDelete && 'deletable', onDelete && `deletableColor${(0, _capitalize.default)(color)}`, `${variant}${(0, _capitalize.default)(color)}`],
+    label: ['label', `label${(0, _capitalize.default)(size)}`],
+    avatar: ['avatar', `avatar${(0, _capitalize.default)(size)}`, `avatarColor${(0, _capitalize.default)(color)}`],
+    icon: ['icon', `icon${(0, _capitalize.default)(size)}`, `iconColor${(0, _capitalize.default)(iconColor)}`],
+    deleteIcon: ['deleteIcon', `deleteIcon${(0, _capitalize.default)(size)}`, `deleteIconColor${(0, _capitalize.default)(color)}`, `deleteIcon${(0, _capitalize.default)(variant)}Color${(0, _capitalize.default)(color)}`]
+  };
+  return (0, _composeClasses.default)(slots, _chipClasses.getChipUtilityClass, classes);
+};
+const ChipRoot = (0, _zeroStyled.styled)('div', {
+  name: 'MuiChip',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    const {
+      color,
+      iconColor,
+      clickable,
+      onDelete,
+      size,
+      variant
+    } = ownerState;
+    return [{
+      [`& .${_chipClasses.default.avatar}`]: styles.avatar
+    }, {
+      [`& .${_chipClasses.default.avatar}`]: styles[`avatar${(0, _capitalize.default)(size)}`]
+    }, {
+      [`& .${_chipClasses.default.avatar}`]: styles[`avatarColor${(0, _capitalize.default)(color)}`]
+    }, {
+      [`& .${_chipClasses.default.icon}`]: styles.icon
+    }, {
+      [`& .${_chipClasses.default.icon}`]: styles[`icon${(0, _capitalize.default)(size)}`]
+    }, {
+      [`& .${_chipClasses.default.icon}`]: styles[`iconColor${(0, _capitalize.default)(iconColor)}`]
+    }, {
+      [`& .${_chipClasses.default.deleteIcon}`]: styles.deleteIcon
+    }, {
+      [`& .${_chipClasses.default.deleteIcon}`]: styles[`deleteIcon${(0, _capitalize.default)(size)}`]
+    }, {
+      [`& .${_chipClasses.default.deleteIcon}`]: styles[`deleteIconColor${(0, _capitalize.default)(color)}`]
+    }, {
+      [`& .${_chipClasses.default.deleteIcon}`]: styles[`deleteIcon${(0, _capitalize.default)(variant)}Color${(0, _capitalize.default)(color)}`]
+    }, styles.root, styles[`size${(0, _capitalize.default)(size)}`], styles[`color${(0, _capitalize.default)(color)}`], clickable && styles.clickable, clickable && color !== 'default' && styles[`clickableColor${(0, _capitalize.default)(color)})`], onDelete && styles.deletable, onDelete && color !== 'default' && styles[`deletableColor${(0, _capitalize.default)(color)}`], styles[variant], styles[`${variant}${(0, _capitalize.default)(color)}`]];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => {
+  const textColor = theme.palette.mode === 'light' ? theme.palette.grey[700] : theme.palette.grey[300];
+  return {
+    maxWidth: '100%',
+    fontFamily: theme.typography.fontFamily,
+    fontSize: theme.typography.pxToRem(13),
+    display: 'inline-flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    height: 32,
+    lineHeight: 1.5,
+    color: (theme.vars || theme).palette.text.primary,
+    backgroundColor: (theme.vars || theme).palette.action.selected,
+    borderRadius: 32 / 2,
+    whiteSpace: 'nowrap',
+    transition: theme.transitions.create(['background-color', 'box-shadow']),
+    // reset cursor explicitly in case ButtonBase is used
+    cursor: 'unset',
+    // We disable the focus ring for mouse, touch and keyboard users.
+    outline: 0,
+    textDecoration: 'none',
+    border: 0,
+    // Remove `button` border
+    padding: 0,
+    // Remove `button` padding
+    verticalAlign: 'middle',
+    boxSizing: 'border-box',
+    [`&.${_chipClasses.default.disabled}`]: {
+      opacity: (theme.vars || theme).palette.action.disabledOpacity,
+      pointerEvents: 'none'
+    },
+    [`& .${_chipClasses.default.avatar}`]: {
+      marginLeft: 5,
+      marginRight: -6,
+      width: 24,
+      height: 24,
+      color: theme.vars ? theme.vars.palette.Chip.defaultAvatarColor : textColor,
+      fontSize: theme.typography.pxToRem(12)
+    },
+    [`& .${_chipClasses.default.avatarColorPrimary}`]: {
+      color: (theme.vars || theme).palette.primary.contrastText,
+      backgroundColor: (theme.vars || theme).palette.primary.dark
+    },
+    [`& .${_chipClasses.default.avatarColorSecondary}`]: {
+      color: (theme.vars || theme).palette.secondary.contrastText,
+      backgroundColor: (theme.vars || theme).palette.secondary.dark
+    },
+    [`& .${_chipClasses.default.avatarSmall}`]: {
+      marginLeft: 4,
+      marginRight: -4,
+      width: 18,
+      height: 18,
+      fontSize: theme.typography.pxToRem(10)
+    },
+    [`& .${_chipClasses.default.icon}`]: {
+      marginLeft: 5,
+      marginRight: -6
+    },
+    [`& .${_chipClasses.default.deleteIcon}`]: {
+      WebkitTapHighlightColor: 'transparent',
+      color: theme.alpha((theme.vars || theme).palette.text.primary, 0.26),
+      fontSize: 22,
+      cursor: 'pointer',
+      margin: '0 5px 0 -6px',
+      '&:hover': {
+        color: theme.alpha((theme.vars || theme).palette.text.primary, 0.4)
+      }
+    },
+    variants: [{
+      props: {
+        size: 'small'
+      },
+      style: {
+        height: 24,
+        [`& .${_chipClasses.default.icon}`]: {
+          fontSize: 18,
+          marginLeft: 4,
+          marginRight: -4
+        },
+        [`& .${_chipClasses.default.deleteIcon}`]: {
+          fontSize: 16,
+          marginRight: 4,
+          marginLeft: -4
+        }
+      }
+    }, ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)(['contrastText'])).map(([color]) => {
+      return {
+        props: {
+          color
+        },
+        style: {
+          backgroundColor: (theme.vars || theme).palette[color].main,
+          color: (theme.vars || theme).palette[color].contrastText,
+          [`& .${_chipClasses.default.deleteIcon}`]: {
+            color: theme.alpha((theme.vars || theme).palette[color].contrastText, 0.7),
+            '&:hover, &:active': {
+              color: (theme.vars || theme).palette[color].contrastText
+            }
+          }
+        }
+      };
+    }), {
+      props: props => props.iconColor === props.color,
+      style: {
+        [`& .${_chipClasses.default.icon}`]: {
+          color: theme.vars ? theme.vars.palette.Chip.defaultIconColor : textColor
+        }
+      }
+    }, {
+      props: props => props.iconColor === props.color && props.color !== 'default',
+      style: {
+        [`& .${_chipClasses.default.icon}`]: {
+          color: 'inherit'
+        }
+      }
+    }, {
+      props: {
+        onDelete: true
+      },
+      style: {
+        [`&.${_chipClasses.default.focusVisible}`]: {
+          backgroundColor: theme.alpha((theme.vars || theme).palette.action.selected, `${(theme.vars || theme).palette.action.selectedOpacity} + ${(theme.vars || theme).palette.action.focusOpacity}`)
+        }
+      }
+    }, ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)(['dark'])).map(([color]) => {
+      return {
+        props: {
+          color,
+          onDelete: true
+        },
+        style: {
+          [`&.${_chipClasses.default.focusVisible}`]: {
+            background: (theme.vars || theme).palette[color].dark
+          }
+        }
+      };
+    }), {
+      props: {
+        clickable: true
+      },
+      style: {
+        userSelect: 'none',
+        WebkitTapHighlightColor: 'transparent',
+        cursor: 'pointer',
+        '&:hover': {
+          backgroundColor: theme.alpha((theme.vars || theme).palette.action.selected, `${(theme.vars || theme).palette.action.selectedOpacity} + ${(theme.vars || theme).palette.action.hoverOpacity}`)
+        },
+        [`&.${_chipClasses.default.focusVisible}`]: {
+          backgroundColor: theme.alpha((theme.vars || theme).palette.action.selected, `${(theme.vars || theme).palette.action.selectedOpacity} + ${(theme.vars || theme).palette.action.focusOpacity}`)
+        },
+        '&:active': {
+          boxShadow: (theme.vars || theme).shadows[1]
+        }
+      }
+    }, ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)(['dark'])).map(([color]) => ({
+      props: {
+        color,
+        clickable: true
+      },
+      style: {
+        [`&:hover, &.${_chipClasses.default.focusVisible}`]: {
+          backgroundColor: (theme.vars || theme).palette[color].dark
+        }
+      }
+    })), {
+      props: {
+        variant: 'outlined'
+      },
+      style: {
+        backgroundColor: 'transparent',
+        border: theme.vars ? `1px solid ${theme.vars.palette.Chip.defaultBorder}` : `1px solid ${theme.palette.mode === 'light' ? theme.palette.grey[400] : theme.palette.grey[700]}`,
+        [`&.${_chipClasses.default.clickable}:hover`]: {
+          backgroundColor: (theme.vars || theme).palette.action.hover
+        },
+        [`&.${_chipClasses.default.focusVisible}`]: {
+          backgroundColor: (theme.vars || theme).palette.action.focus
+        },
+        [`& .${_chipClasses.default.avatar}`]: {
+          marginLeft: 4
+        },
+        [`& .${_chipClasses.default.avatarSmall}`]: {
+          marginLeft: 2
+        },
+        [`& .${_chipClasses.default.icon}`]: {
+          marginLeft: 4
+        },
+        [`& .${_chipClasses.default.iconSmall}`]: {
+          marginLeft: 2
+        },
+        [`& .${_chipClasses.default.deleteIcon}`]: {
+          marginRight: 5
+        },
+        [`& .${_chipClasses.default.deleteIconSmall}`]: {
+          marginRight: 3
+        }
+      }
+    }, ...Object.entries(theme.palette).filter((0, _createSimplePaletteValueFilter.default)()) // no need to check for mainChannel as it's calculated from main
+    .map(([color]) => ({
+      props: {
+        variant: 'outlined',
+        color
+      },
+      style: {
+        color: (theme.vars || theme).palette[color].main,
+        border: `1px solid ${theme.alpha((theme.vars || theme).palette[color].main, 0.7)}`,
+        [`&.${_chipClasses.default.clickable}:hover`]: {
+          backgroundColor: theme.alpha((theme.vars || theme).palette[color].main, (theme.vars || theme).palette.action.hoverOpacity)
+        },
+        [`&.${_chipClasses.default.focusVisible}`]: {
+          backgroundColor: theme.alpha((theme.vars || theme).palette[color].main, (theme.vars || theme).palette.action.focusOpacity)
+        },
+        [`& .${_chipClasses.default.deleteIcon}`]: {
+          color: theme.alpha((theme.vars || theme).palette[color].main, 0.7),
+          '&:hover, &:active': {
+            color: (theme.vars || theme).palette[color].main
+          }
+        }
+      }
+    }))]
+  };
+}));
+const ChipLabel = (0, _zeroStyled.styled)('span', {
+  name: 'MuiChip',
+  slot: 'Label',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    const {
+      size
+    } = ownerState;
+    return [styles.label, styles[`label${(0, _capitalize.default)(size)}`]];
+  }
+})({
+  overflow: 'hidden',
+  textOverflow: 'ellipsis',
+  paddingLeft: 12,
+  paddingRight: 12,
+  whiteSpace: 'nowrap',
+  variants: [{
+    props: {
+      variant: 'outlined'
+    },
+    style: {
+      paddingLeft: 11,
+      paddingRight: 11
+    }
+  }, {
+    props: {
+      size: 'small'
+    },
+    style: {
+      paddingLeft: 8,
+      paddingRight: 8
+    }
+  }, {
+    props: {
+      size: 'small',
+      variant: 'outlined'
+    },
+    style: {
+      paddingLeft: 7,
+      paddingRight: 7
+    }
+  }]
+});
+function isDeleteKeyboardEvent(keyboardEvent) {
+  return keyboardEvent.key === 'Backspace' || keyboardEvent.key === 'Delete';
+}
+
+/**
+ * Chips represent complex entities in small blocks, such as a contact.
+ */
+const Chip = /*#__PURE__*/React.forwardRef(function Chip(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiChip'
+  });
+  const {
+    avatar: avatarProp,
+    className,
+    clickable: clickableProp,
+    color = 'default',
+    component: ComponentProp,
+    deleteIcon: deleteIconProp,
+    disabled = false,
+    icon: iconProp,
+    label,
+    onClick,
+    onDelete,
+    onKeyDown,
+    onKeyUp,
+    size = 'medium',
+    variant = 'filled',
+    tabIndex,
+    skipFocusWhenDisabled = false,
+    // TODO v6: Rename to `focusableWhenDisabled`.
+    slots = {},
+    slotProps = {},
+    ...other
+  } = props;
+  const chipRef = React.useRef(null);
+  const handleRef = (0, _useForkRef.default)(chipRef, ref);
+  const handleDeleteIconClick = event => {
+    // Stop the event from bubbling up to the `Chip`
+    event.stopPropagation();
+    if (onDelete) {
+      onDelete(event);
+    }
+  };
+  const handleKeyDown = event => {
+    // Ignore events from children of `Chip`.
+    if (event.currentTarget === event.target && isDeleteKeyboardEvent(event)) {
+      // Will be handled in keyUp, otherwise some browsers
+      // might init navigation
+      event.preventDefault();
+    }
+    if (onKeyDown) {
+      onKeyDown(event);
+    }
+  };
+  const handleKeyUp = event => {
+    // Ignore events from children of `Chip`.
+    if (event.currentTarget === event.target) {
+      if (onDelete && isDeleteKeyboardEvent(event)) {
+        onDelete(event);
+      }
+    }
+    if (onKeyUp) {
+      onKeyUp(event);
+    }
+  };
+  const clickable = clickableProp !== false && onClick ? true : clickableProp;
+  const component = clickable || onDelete ? _ButtonBase.default : ComponentProp || 'div';
+  const ownerState = {
+    ...props,
+    component,
+    disabled,
+    size,
+    color,
+    iconColor: /*#__PURE__*/React.isValidElement(iconProp) ? iconProp.props.color || color : color,
+    onDelete: !!onDelete,
+    clickable,
+    variant
+  };
+  const classes = useUtilityClasses(ownerState);
+  const moreProps = component === _ButtonBase.default ? {
+    component: ComponentProp || 'div',
+    focusVisibleClassName: classes.focusVisible,
+    ...(onDelete && {
+      disableRipple: true
+    })
+  } : {};
+  let deleteIcon = null;
+  if (onDelete) {
+    deleteIcon = deleteIconProp && /*#__PURE__*/React.isValidElement(deleteIconProp) ? (/*#__PURE__*/React.cloneElement(deleteIconProp, {
+      className: (0, _clsx.default)(deleteIconProp.props.className, classes.deleteIcon),
+      onClick: handleDeleteIconClick
+    })) : /*#__PURE__*/(0, _jsxRuntime.jsx)(_Cancel.default, {
+      className: classes.deleteIcon,
+      onClick: handleDeleteIconClick
+    });
+  }
+  let avatar = null;
+  if (avatarProp && /*#__PURE__*/React.isValidElement(avatarProp)) {
+    avatar = /*#__PURE__*/React.cloneElement(avatarProp, {
+      className: (0, _clsx.default)(classes.avatar, avatarProp.props.className)
+    });
+  }
+  let icon = null;
+  if (iconProp && /*#__PURE__*/React.isValidElement(iconProp)) {
+    icon = /*#__PURE__*/React.cloneElement(iconProp, {
+      className: (0, _clsx.default)(classes.icon, iconProp.props.className)
+    });
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    if (avatar && icon) {
+      console.error('MUI: The Chip component can not handle the avatar ' + 'and the icon prop at the same time. Pick one.');
+    }
+  }
+  const externalForwardedProps = {
+    slots,
+    slotProps
+  };
+  const [RootSlot, rootProps] = (0, _useSlot.default)('root', {
+    elementType: ChipRoot,
+    externalForwardedProps: {
+      ...externalForwardedProps,
+      ...other
+    },
+    ownerState,
+    // The `component` prop is preserved because `Chip` relies on it for internal logic. If `shouldForwardComponentProp` were `false`, `useSlot` would remove the `component` prop, potentially breaking the component's behavior.
+    shouldForwardComponentProp: true,
+    ref: handleRef,
+    className: (0, _clsx.default)(classes.root, className),
+    additionalProps: {
+      disabled: clickable && disabled ? true : undefined,
+      tabIndex: skipFocusWhenDisabled && disabled ? -1 : tabIndex,
+      ...moreProps
+    },
+    getSlotProps: handlers => ({
+      ...handlers,
+      onClick: event => {
+        handlers.onClick?.(event);
+        onClick?.(event);
+      },
+      onKeyDown: event => {
+        handlers.onKeyDown?.(event);
+        handleKeyDown(event);
+      },
+      onKeyUp: event => {
+        handlers.onKeyUp?.(event);
+        handleKeyUp(event);
+      }
+    })
+  });
+  const [LabelSlot, labelProps] = (0, _useSlot.default)('label', {
+    elementType: ChipLabel,
+    externalForwardedProps,
+    ownerState,
+    className: classes.label
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(RootSlot, {
+    as: component,
+    ...rootProps,
+    children: [avatar || icon, /*#__PURE__*/(0, _jsxRuntime.jsx)(LabelSlot, {
+      ...labelProps,
+      children: label
+    }), deleteIcon]
+  });
+});
+process.env.NODE_ENV !== "production" ? Chip.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The Avatar element to display.
+   */
+  avatar: _propTypes.default.element,
+  /**
+   * This prop isn't supported.
+   * Use the `component` prop if you need to change the children structure.
+   */
+  children: _unsupportedProp.default,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * If `true`, the chip will appear clickable, and will raise when pressed,
+   * even if the onClick prop is not defined.
+   * If `false`, the chip will not appear clickable, even if onClick prop is defined.
+   * This can be used, for example,
+   * along with the component prop to indicate an anchor Chip is clickable.
+   * Note: this controls the UI and does not affect the onClick event.
+   */
+  clickable: _propTypes.default.bool,
+  /**
+   * 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 'default'
+   */
+  color: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), _propTypes.default.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: _propTypes.default.elementType,
+  /**
+   * Override the default delete icon element. Shown only if `onDelete` is set.
+   */
+  deleteIcon: _propTypes.default.element,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: _propTypes.default.bool,
+  /**
+   * Icon element.
+   */
+  icon: _propTypes.default.element,
+  /**
+   * The content of the component.
+   */
+  label: _propTypes.default.node,
+  /**
+   * @ignore
+   */
+  onClick: _propTypes.default.func,
+  /**
+   * Callback fired when the delete icon is clicked.
+   * If set, the delete icon will be shown.
+   */
+  onDelete: _propTypes.default.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: _propTypes.default.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: _propTypes.default.func,
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['medium', 'small']), _propTypes.default.string]),
+  /**
+   * If `true`, allows the disabled chip to escape focus.
+   * If `false`, allows the disabled chip to receive focus.
+   * @default false
+   */
+  skipFocusWhenDisabled: _propTypes.default.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: _propTypes.default.shape({
+    label: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
+    root: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: _propTypes.default.shape({
+    label: _propTypes.default.elementType,
+    root: _propTypes.default.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * @ignore
+   */
+  tabIndex: _propTypes.default.number,
+  /**
+   * The variant to use.
+   * @default 'filled'
+   */
+  variant: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['filled', 'outlined']), _propTypes.default.string])
+} : void 0;
+var _default = exports.default = Chip;

node_modules/@mui/material/Chip/chipClasses.d.ts

@@ -0,0 +1,150 @@
+export interface ChipClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `size="small"`. */
+  sizeSmall: string;
+  /** Styles applied to the root element if `size="medium"`. */
+  sizeMedium: string;
+  /** Styles applied to the root element if `color="default"`. */
+  colorDefault: string;
+  /** Styles applied to the root element if `color="error"`. */
+  colorError: string;
+  /** Styles applied to the root element if `color="info"`. */
+  colorInfo: string;
+  /** Styles applied to the root element if `color="primary"`. */
+  colorPrimary: string;
+  /** Styles applied to the root element if `color="secondary"`. */
+  colorSecondary: string;
+  /** Styles applied to the root element if `color="success"`. */
+  colorSuccess: string;
+  /** Styles applied to the root element if `color="warning"`. */
+  colorWarning: string;
+  /** State class applied to the root element if `disabled={true}`. */
+  disabled: string;
+  /** Styles applied to the root element if `onClick` is defined or `clickable={true}`. */
+  clickable: string;
+  /** Styles applied to the root element if `onClick` and `color="primary"` is defined or `clickable={true}`.
+   * @deprecated Combine the [.MuiChip-clickable](/material-ui/api/chip/#chip-classes-MuiChip-clickable) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  clickableColorPrimary: string;
+  /** Styles applied to the root element if `onClick` and `color="secondary"` is defined or `clickable={true}`.
+   * @deprecated Combine the [.MuiChip-clickable](/material-ui/api/chip/#chip-classes-MuiChip-clickable) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  clickableColorSecondary: string;
+  /** Styles applied to the root element if `onDelete` is defined. */
+  deletable: string;
+  /** Styles applied to the root element if `onDelete` and `color="primary"` is defined.
+   * @deprecated Combine the [.MuiChip-deletable](/material-ui/api/chip/#chip-classes-MuiChip-deletable) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deletableColorPrimary: string;
+  /** Styles applied to the root element if `onDelete` and `color="secondary"` is defined.
+   * @deprecated Combine the [.MuiChip-deletable](/material-ui/api/chip/#chip-classes-MuiChip-deletable) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deletableColorSecondary: string;
+  /** Styles applied to the root element if `variant="outlined"`. */
+  outlined: string;
+  /** Styles applied to the root element if `variant="filled"`. */
+  filled: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="primary"`.
+   * @deprecated Combine the [.MuiChip-outlined](/material-ui/api/chip/#chip-classes-MuiChip-outlined) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedPrimary: string;
+  /** Styles applied to the root element if `variant="outlined"` and `color="secondary"`.
+   * @deprecated Combine the [.MuiChip-outlined](/material-ui/api/chip/#chip-classes-MuiChip-outlined) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  outlinedSecondary: string;
+  /** Styles applied to the root element if `variant="filled"` and `color="primary"`.
+   * @deprecated Combine the [.MuiChip-filled](/material-ui/api/chip/#chip-classes-MuiChip-filled) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  filledPrimary: string;
+  /** Styles applied to the root element if `variant="filled"` and `color="secondary"`.
+   * @deprecated Combine the [.MuiChip-filled](/material-ui/api/chip/#chip-classes-MuiChip-filled) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  filledSecondary: string;
+  /** Styles applied to the avatar element. */
+  avatar: string;
+  /** Styles applied to the avatar element if `size="small"`.
+   * @deprecated Combine the [.MuiChip-avatar](/material-ui/api/chip/#chip-classes-MuiChip-avatar) and [.MuiChip-sizeSmall](/material-ui/api/chip/#chip-classes-MuiChip-sizeSmall) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  avatarSmall: string;
+  /** Styles applied to the avatar element if `size="medium"`.
+   * @deprecated Combine the [.MuiChip-avatar](/material-ui/api/chip/#chip-classes-MuiChip-avatar) and [.MuiChip-sizeMedium](/material-ui/api/chip/#chip-classes-MuiChip-sizeMedium) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  avatarMedium: string;
+  /** Styles applied to the avatar element if `color="primary"`.
+   * @deprecated Combine the [.MuiChip-avatar](/material-ui/api/chip/#chip-classes-MuiChip-avatar) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  avatarColorPrimary: string;
+  /** Styles applied to the avatar element if `color="secondary"`.
+   * @deprecated Combine the [.MuiChip-avatar](/material-ui/api/chip/#chip-classes-MuiChip-avatar) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  avatarColorSecondary: string;
+  /** Styles applied to the icon element. */
+  icon: string;
+  /** Styles applied to the icon element if `size="small"`.
+   * @deprecated Combine the [.MuiChip-icon](/material-ui/api/chip/#chip-classes-MuiChip-icon) and [.MuiChip-sizeSmall](/material-ui/api/chip/#chip-classes-MuiChip-sizeSmall) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconSmall: string;
+  /** Styles applied to the icon element if `size="medium"`.
+   * @deprecated Combine the [.MuiChip-icon](/material-ui/api/chip/#chip-classes-MuiChip-icon) and [.MuiChip-sizeMedium](/material-ui/api/chip/#chip-classes-MuiChip-sizeMedium) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconMedium: string;
+  /** Styles applied to the icon element if `color="primary"`.
+   * @deprecated Combine the [.MuiChip-icon](/material-ui/api/chip/#chip-classes-MuiChip-icon) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconColorPrimary: string;
+  /** Styles applied to the icon element if `color="secondary"`.
+   * @deprecated Combine the [.MuiChip-icon](/material-ui/api/chip/#chip-classes-MuiChip-icon) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconColorSecondary: string;
+  /** Styles applied to the label `span` element. */
+  label: string;
+  /** Styles applied to the label `span` element if `size="small"`.
+   * @deprecated Combine the [.MuiChip-label](/material-ui/api/chip/#Chip-css-MuiChip-label) and [.MuiChip-sizeSmall](/material-ui/api/chip/#chip-classes-MuiChip-sizeSmall) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  labelSmall: string;
+  /** Styles applied to the label `span` element if `size="medium"`.
+   * @deprecated Combine the [.MuiChip-label](/material-ui/api/chip/#Chip-css-MuiChip-label) and [.MuiChip-sizeMedium](/material-ui/api/chip/#chip-classes-MuiChip-sizeMedium) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  labelMedium: string;
+  /** Styles applied to the deleteIcon element. */
+  deleteIcon: string;
+  /** Styles applied to the deleteIcon element if `size="small"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) and [.MuiChip-sizeSmall](/material-ui/api/chip/#chip-classes-MuiChip-sizeSmall) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconSmall: string;
+  /** Styles applied to the deleteIcon element if `size="medium"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) and [.MuiChip-sizeMedium](/material-ui/api/chip/#chip-classes-MuiChip-sizeMedium) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconMedium: string;
+  /** Styles applied to the deleteIcon element if `color="primary"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconColorPrimary: string;
+  /** Styles applied to the deleteIcon element if `color="secondary"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconColorSecondary: string;
+  /** Styles applied to the deleteIcon element if `color="primary"` and `variant="outlined"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) , [.MuiChip-outlined](/material-ui/api/chip/#chip-classes-MuiChip-outlined) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconOutlinedColorPrimary: string;
+  /** Styles applied to the deleteIcon element if `color="secondary"` and `variant="outlined"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) , [.MuiChip-outlined](/material-ui/api/chip/#chip-classes-MuiChip-outlined) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconOutlinedColorSecondary: string;
+  /** Styles applied to the deleteIcon element if `color="primary"` and `variant="filled"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) , [.MuiChip-filled](/material-ui/api/chip/#chip-classes-MuiChip-filled) and [.MuiChip-colorPrimary](/material-ui/api/chip/#chip-classes-MuiChip-colorPrimary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconFilledColorPrimary: string;
+  /** Styles applied to the deleteIcon element if `color="secondary"` and `variant="filled"`.
+   * @deprecated Combine the [.MuiChip-deleteIcon](/material-ui/api/chip/#chip-classes-MuiChip-deleteIcon) , [.MuiChip-filled](/material-ui/api/chip/#chip-classes-MuiChip-filled) and [.MuiChip-colorSecondary](/material-ui/api/chip/#chip-classes-MuiChip-colorSecondary) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  deleteIconFilledColorSecondary: string;
+  /** State class applied to the root element if keyboard focused. */
+  focusVisible: string;
+}
+export type ChipClassKey = keyof ChipClasses;
+export declare function getChipUtilityClass(slot: string): string;
+declare const chipClasses: ChipClasses;
+export default chipClasses;

node_modules/@mui/material/ClickAwayListener/ClickAwayListener.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+type ClickAwayMouseEventHandler = 'onClick' | 'onMouseDown' | 'onMouseUp' | 'onPointerDown' | 'onPointerUp';
+type ClickAwayTouchEventHandler = 'onTouchStart' | 'onTouchEnd';
+export interface ClickAwayListenerProps {
+  /**
+   * The wrapped element.
+   */
+  children: React.ReactElement<any>;
+  /**
+   * If `true`, the React tree is ignored and only the DOM tree is considered.
+   * This prop changes how portaled elements are handled.
+   * @default false
+   */
+  disableReactTree?: boolean;
+  /**
+   * The mouse event to listen to. You can disable the listener by providing `false`.
+   * @default 'onClick'
+   */
+  mouseEvent?: ClickAwayMouseEventHandler | false;
+  /**
+   * Callback fired when a "click away" event is detected.
+   */
+  onClickAway: (event: MouseEvent | TouchEvent) => void;
+  /**
+   * The touch event to listen to. You can disable the listener by providing `false`.
+   * @default 'onTouchEnd'
+   */
+  touchEvent?: ClickAwayTouchEventHandler | false;
+}
+/**
+ * Listen for click events that occur somewhere in the document, outside of the element itself.
+ * For instance, if you need to hide a menu when people click anywhere else on your page.
+ *
+ * Demos:
+ *
+ * - [Click-Away Listener](https://mui.com/material-ui/react-click-away-listener/)
+ * - [Menu](https://mui.com/material-ui/react-menu/)
+ *
+ * API:
+ *
+ * - [ClickAwayListener API](https://mui.com/material-ui/api/click-away-listener/)
+ */
+declare function ClickAwayListener(props: ClickAwayListenerProps): React.JSX.Element;
+declare namespace ClickAwayListener {
+  var propTypes: any;
+}
+export { ClickAwayListener };

node_modules/@mui/material/Container/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Container.js";
+export * from "./Container.js";
+export { default as containerClasses } from "./containerClasses.js";
+export * from "./containerClasses.js";

node_modules/@mui/material/DefaultPropsProvider/DefaultPropsProvider.js

@@ -0,0 +1,37 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.useDefaultProps = useDefaultProps;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DefaultPropsProvider = _interopRequireWildcard(require("@mui/system/DefaultPropsProvider"));
+var _jsxRuntime = require("react/jsx-runtime");
+function DefaultPropsProvider(props) {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_DefaultPropsProvider.default, {
+    ...props
+  });
+}
+process.env.NODE_ENV !== "production" ? DefaultPropsProvider.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: _propTypes.default.node,
+  /**
+   * @ignore
+   */
+  value: _propTypes.default.object.isRequired
+} : void 0;
+var _default = exports.default = DefaultPropsProvider;
+function useDefaultProps(params) {
+  return (0, _DefaultPropsProvider.useDefaultProps)(params);
+}

node_modules/@mui/material/DialogTitle/DialogTitle.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { OverridableComponent, OverrideProps } from "../OverridableComponent/index.js";
+import { Theme } from "../styles/index.js";
+import { TypographyTypeMap } from "../Typography/index.js";
+import { DialogTitleClasses } from "./dialogTitleClasses.js";
+export interface DialogTitleOwnProps extends Omit<TypographyTypeMap['props'], 'classes'> {
+  /**
+   * The content of the component.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<DialogTitleClasses>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export interface DialogTitleTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = TypographyTypeMap['defaultComponent']> {
+  props: AdditionalProps & DialogTitleOwnProps;
+  defaultComponent: RootComponent;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Dialog](https://mui.com/material-ui/react-dialog/)
+ *
+ * API:
+ *
+ * - [DialogTitle API](https://mui.com/material-ui/api/dialog-title/)
+ * - inherits [Typography API](https://mui.com/material-ui/api/typography/)
+ */
+declare const DialogTitle: OverridableComponent<DialogTitleTypeMap>;
+export type DialogTitleProps<RootComponent extends React.ElementType = DialogTitleTypeMap['defaultComponent'], AdditionalProps = {
+  component?: React.ElementType;
+}> = OverrideProps<DialogTitleTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default DialogTitle;

node_modules/@mui/material/DialogTitle/dialogTitleClasses.d.ts

@@ -0,0 +1,8 @@
+export interface DialogTitleClasses {
+  /** Styles applied to the root element. */
+  root: string;
+}
+export type DialogTitleClassKey = keyof DialogTitleClasses;
+export declare function getDialogTitleUtilityClass(slot: string): string;
+declare const dialogTitleClasses: DialogTitleClasses;
+export default dialogTitleClasses;

node_modules/@mui/material/Drawer/Drawer.js

@@ -0,0 +1,447 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getAnchor = getAnchor;
+exports.isHorizontal = isHorizontal;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _integerPropType = _interopRequireDefault(require("@mui/utils/integerPropType"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _RtlProvider = require("@mui/system/RtlProvider");
+var _Modal = _interopRequireDefault(require("../Modal"));
+var _Slide = _interopRequireDefault(require("../Slide"));
+var _Paper = _interopRequireDefault(require("../Paper"));
+var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
+var _rootShouldForwardProp = _interopRequireDefault(require("../styles/rootShouldForwardProp"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _drawerClasses = require("./drawerClasses");
+var _useSlot = _interopRequireDefault(require("../utils/useSlot"));
+var _utils = require("../utils");
+var _jsxRuntime = require("react/jsx-runtime");
+const overridesResolver = (props, styles) => {
+  const {
+    ownerState
+  } = props;
+  return [styles.root, (ownerState.variant === 'permanent' || ownerState.variant === 'persistent') && styles.docked, styles.modal];
+};
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    anchor,
+    variant
+  } = ownerState;
+  const slots = {
+    root: ['root', `anchor${(0, _capitalize.default)(anchor)}`],
+    docked: [(variant === 'permanent' || variant === 'persistent') && 'docked'],
+    modal: ['modal'],
+    paper: ['paper', `paperAnchor${(0, _capitalize.default)(anchor)}`, variant !== 'temporary' && `paperAnchorDocked${(0, _capitalize.default)(anchor)}`]
+  };
+  return (0, _composeClasses.default)(slots, _drawerClasses.getDrawerUtilityClass, classes);
+};
+const DrawerRoot = (0, _zeroStyled.styled)(_Modal.default, {
+  name: 'MuiDrawer',
+  slot: 'Root',
+  overridesResolver
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  zIndex: (theme.vars || theme).zIndex.drawer
+})));
+const DrawerDockedRoot = (0, _zeroStyled.styled)('div', {
+  shouldForwardProp: _rootShouldForwardProp.default,
+  name: 'MuiDrawer',
+  slot: 'Docked',
+  skipVariantsResolver: false,
+  overridesResolver
+})({
+  flex: '0 0 auto'
+});
+const DrawerPaper = (0, _zeroStyled.styled)(_Paper.default, {
+  name: 'MuiDrawer',
+  slot: 'Paper',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.paper, styles[`paperAnchor${(0, _capitalize.default)(ownerState.anchor)}`], ownerState.variant !== 'temporary' && styles[`paperAnchorDocked${(0, _capitalize.default)(ownerState.anchor)}`]];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  overflowY: 'auto',
+  display: 'flex',
+  flexDirection: 'column',
+  height: '100%',
+  flex: '1 0 auto',
+  zIndex: (theme.vars || theme).zIndex.drawer,
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: 'touch',
+  // temporary style
+  position: 'fixed',
+  top: 0,
+  // We disable the focus ring for mouse, touch and keyboard users.
+  // At some point, it would be better to keep it for keyboard users.
+  // :focus-ring CSS pseudo-class will help.
+  outline: 0,
+  variants: [{
+    props: {
+      anchor: 'left'
+    },
+    style: {
+      left: 0
+    }
+  }, {
+    props: {
+      anchor: 'top'
+    },
+    style: {
+      top: 0,
+      left: 0,
+      right: 0,
+      height: 'auto',
+      maxHeight: '100%'
+    }
+  }, {
+    props: {
+      anchor: 'right'
+    },
+    style: {
+      right: 0
+    }
+  }, {
+    props: {
+      anchor: 'bottom'
+    },
+    style: {
+      top: 'auto',
+      left: 0,
+      bottom: 0,
+      right: 0,
+      height: 'auto',
+      maxHeight: '100%'
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.anchor === 'left' && ownerState.variant !== 'temporary',
+    style: {
+      borderRight: `1px solid ${(theme.vars || theme).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.anchor === 'top' && ownerState.variant !== 'temporary',
+    style: {
+      borderBottom: `1px solid ${(theme.vars || theme).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.anchor === 'right' && ownerState.variant !== 'temporary',
+    style: {
+      borderLeft: `1px solid ${(theme.vars || theme).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.anchor === 'bottom' && ownerState.variant !== 'temporary',
+    style: {
+      borderTop: `1px solid ${(theme.vars || theme).palette.divider}`
+    }
+  }]
+})));
+const oppositeDirection = {
+  left: 'right',
+  right: 'left',
+  top: 'down',
+  bottom: 'up'
+};
+function isHorizontal(anchor) {
+  return ['left', 'right'].includes(anchor);
+}
+function getAnchor({
+  direction
+}, anchor) {
+  return direction === 'rtl' && isHorizontal(anchor) ? oppositeDirection[anchor] : anchor;
+}
+
+/**
+ * The props of the [Modal](/material-ui/api/modal/) component are available
+ * when `variant="temporary"` is set.
+ */
+const Drawer = /*#__PURE__*/React.forwardRef(function Drawer(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiDrawer'
+  });
+  const theme = (0, _zeroStyled.useTheme)();
+  const isRtl = (0, _RtlProvider.useRtl)();
+  const defaultTransitionDuration = {
+    enter: theme.transitions.duration.enteringScreen,
+    exit: theme.transitions.duration.leavingScreen
+  };
+  const {
+    anchor: anchorProp = 'left',
+    BackdropProps,
+    children,
+    className,
+    elevation = 16,
+    hideBackdrop = false,
+    ModalProps: {
+      BackdropProps: BackdropPropsProp,
+      ...ModalProps
+    } = {},
+    onClose,
+    open = false,
+    PaperProps = {},
+    SlideProps,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent,
+    transitionDuration = defaultTransitionDuration,
+    variant = 'temporary',
+    slots = {},
+    slotProps = {},
+    ...other
+  } = props;
+
+  // Let's assume that the Drawer will always be rendered on user space.
+  // We use this state is order to skip the appear transition during the
+  // initial mount of the component.
+  const mounted = React.useRef(false);
+  React.useEffect(() => {
+    mounted.current = true;
+  }, []);
+  const anchorInvariant = getAnchor({
+    direction: isRtl ? 'rtl' : 'ltr'
+  }, anchorProp);
+  const anchor = anchorProp;
+  const ownerState = {
+    ...props,
+    anchor,
+    elevation,
+    open,
+    variant,
+    ...other
+  };
+  const classes = useUtilityClasses(ownerState);
+  const externalForwardedProps = {
+    slots: {
+      transition: TransitionComponent,
+      ...slots
+    },
+    slotProps: {
+      paper: PaperProps,
+      transition: SlideProps,
+      ...slotProps,
+      backdrop: (0, _utils.mergeSlotProps)(slotProps.backdrop || {
+        ...BackdropProps,
+        ...BackdropPropsProp
+      }, {
+        transitionDuration
+      })
+    }
+  };
+  const [RootSlot, rootSlotProps] = (0, _useSlot.default)('root', {
+    ref,
+    elementType: DrawerRoot,
+    className: (0, _clsx.default)(classes.root, classes.modal, className),
+    shouldForwardComponentProp: true,
+    ownerState,
+    externalForwardedProps: {
+      ...externalForwardedProps,
+      ...other,
+      ...ModalProps
+    },
+    additionalProps: {
+      open,
+      onClose,
+      hideBackdrop,
+      slots: {
+        backdrop: externalForwardedProps.slots.backdrop
+      },
+      slotProps: {
+        backdrop: externalForwardedProps.slotProps.backdrop
+      }
+    }
+  });
+  const [PaperSlot, paperSlotProps] = (0, _useSlot.default)('paper', {
+    elementType: DrawerPaper,
+    shouldForwardComponentProp: true,
+    className: (0, _clsx.default)(classes.paper, PaperProps.className),
+    ownerState,
+    externalForwardedProps,
+    additionalProps: {
+      elevation: variant === 'temporary' ? elevation : 0,
+      square: true,
+      ...(variant === 'temporary' && {
+        role: 'dialog',
+        'aria-modal': 'true'
+      })
+    }
+  });
+  const [DockedSlot, dockedSlotProps] = (0, _useSlot.default)('docked', {
+    elementType: DrawerDockedRoot,
+    ref,
+    className: (0, _clsx.default)(classes.root, classes.docked, className),
+    ownerState,
+    externalForwardedProps,
+    additionalProps: other // pass `other` here because `DockedSlot` is also a root slot for some variants
+  });
+  const [TransitionSlot, transitionSlotProps] = (0, _useSlot.default)('transition', {
+    elementType: _Slide.default,
+    ownerState,
+    externalForwardedProps,
+    additionalProps: {
+      in: open,
+      direction: oppositeDirection[anchorInvariant],
+      timeout: transitionDuration,
+      appear: mounted.current
+    }
+  });
+  const drawer = /*#__PURE__*/(0, _jsxRuntime.jsx)(PaperSlot, {
+    ...paperSlotProps,
+    children: children
+  });
+  if (variant === 'permanent') {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(DockedSlot, {
+      ...dockedSlotProps,
+      children: drawer
+    });
+  }
+  const slidingDrawer = /*#__PURE__*/(0, _jsxRuntime.jsx)(TransitionSlot, {
+    ...transitionSlotProps,
+    children: drawer
+  });
+  if (variant === 'persistent') {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(DockedSlot, {
+      ...dockedSlotProps,
+      children: slidingDrawer
+    });
+  }
+
+  // variant === temporary
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(RootSlot, {
+    ...rootSlotProps,
+    children: slidingDrawer
+  });
+});
+process.env.NODE_ENV !== "production" ? Drawer.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Side from which the drawer will appear.
+   * @default 'left'
+   */
+  anchor: _propTypes.default.oneOf(['bottom', 'left', 'right', 'top']),
+  /**
+   * @ignore
+   */
+  BackdropProps: _propTypes.default.object,
+  /**
+   * The content of the component.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * The elevation of the drawer.
+   * @default 16
+   */
+  elevation: _integerPropType.default,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: _propTypes.default.bool,
+  /**
+   * Props applied to the [`Modal`](https://mui.com/material-ui/api/modal/) element.
+   * @default {}
+   */
+  ModalProps: _propTypes.default.object,
+  /**
+   * Callback fired when the component requests to be closed.
+   * The `reason` parameter can optionally be used to control the response to `onClose`.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
+   */
+  onClose: _propTypes.default.func,
+  /**
+   * If `true`, the component is shown.
+   * @default false
+   */
+  open: _propTypes.default.bool,
+  /**
+   * Props applied to the [`Paper`](https://mui.com/material-ui/api/paper/) element.
+   * @deprecated use the `slotProps.paper` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   * @default {}
+   */
+  PaperProps: _propTypes.default.object,
+  /**
+   * Props applied to the [`Slide`](https://mui.com/material-ui/api/slide/) element.
+   * @deprecated use the `slotProps.transition` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  SlideProps: _propTypes.default.object,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: _propTypes.default.shape({
+    backdrop: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
+    docked: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
+    paper: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
+    root: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
+    transition: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: _propTypes.default.shape({
+    backdrop: _propTypes.default.elementType,
+    docked: _propTypes.default.elementType,
+    paper: _propTypes.default.elementType,
+    root: _propTypes.default.elementType,
+    transition: _propTypes.default.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  transitionDuration: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({
+    appear: _propTypes.default.number,
+    enter: _propTypes.default.number,
+    exit: _propTypes.default.number
+  })]),
+  /**
+   * The variant to use.
+   * @default 'temporary'
+   */
+  variant: _propTypes.default.oneOf(['permanent', 'persistent', 'temporary'])
+} : void 0;
+var _default = exports.default = Drawer;

node_modules/@mui/material/FormHelperText/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./FormHelperText.js";
+export * from "./FormHelperText.js";
+export { default as formHelperTextClasses } from "./formHelperTextClasses.js";
+export * from "./formHelperTextClasses.js";

node_modules/@mui/material/FormHelperText/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  formHelperTextClasses: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _FormHelperText.default;
+  }
+});
+Object.defineProperty(exports, "formHelperTextClasses", {
+  enumerable: true,
+  get: function () {
+    return _formHelperTextClasses.default;
+  }
+});
+var _FormHelperText = _interopRequireDefault(require("./FormHelperText"));
+var _formHelperTextClasses = _interopRequireWildcard(require("./formHelperTextClasses"));
+Object.keys(_formHelperTextClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _formHelperTextClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _formHelperTextClasses[key];
+    }
+  });
+});

node_modules/@mui/material/GridLegacy/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./GridLegacy.js";
+export * from "./GridLegacy.js";
+export { default as gridLegacyClasses } from "./gridLegacyClasses.js";
+export * from "./gridLegacyClasses.js";

node_modules/@mui/material/Input/Input.d.ts

@@ -0,0 +1,36 @@
+import { SxProps } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { InputBaseProps } from "../InputBase/index.js";
+import { InputClasses } from "./inputClasses.js";
+export interface InputProps extends StandardProps<InputBaseProps> {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<InputClasses>;
+  /**
+   * If `true`, the `input` will not have an underline.
+   * @default false
+   */
+  disableUnderline?: boolean;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Text Field](https://mui.com/material-ui/react-text-field/)
+ *
+ * API:
+ *
+ * - [Input API](https://mui.com/material-ui/api/input/)
+ * - inherits [InputBase API](https://mui.com/material-ui/api/input-base/)
+ */
+declare const Input: ((props: InputProps) => React.JSX.Element) & {
+  muiName: string;
+};
+export default Input;

node_modules/@mui/material/InputBase/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./InputBase.js";
+export * from "./InputBase.js";
+export { default as inputBaseClasses } from "./inputBaseClasses.js";
+export * from "./inputBaseClasses.js";

node_modules/@mui/material/ListItem/listItemClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getListItemUtilityClass = getListItemUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getListItemUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiListItem', slot);
+}
+const listItemClasses = (0, _generateUtilityClasses.default)('MuiListItem', ['root', 'container', 'dense', 'alignItemsFlexStart', 'divider', 'gutters', 'padding', 'secondaryAction']);
+var _default = exports.default = listItemClasses;

node_modules/@mui/material/ListItemText/ListItemText.d.ts

@@ -0,0 +1,106 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { TypographyProps } from "../Typography/index.js";
+import { ListItemTextClasses } from "./listItemTextClasses.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+export interface ListItemTextSlots {
+  /**
+   * The component that renders the root slot.
+   * @default 'div'
+   */
+  root?: React.ElementType;
+  /**
+   * The component that renders the primary slot.
+   * @default Typography
+   */
+  primary?: React.ElementType;
+  /**
+   * The component that renders the secondary slot.
+   * @default Typography
+   */
+  secondary?: React.ElementType;
+}
+export type ListItemTextSlotsAndSlotProps = CreateSlotsAndSlotProps<ListItemTextSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on `div` element.
+   */
+  root: SlotProps<'div', {}, ListItemTextOwnerState>;
+  /**
+   * Props forwarded to the primary slot (as long as disableTypography is not `true`)
+   * By default, the available props are based on the [Typography](https://mui.com/material-ui/api/typography/#props) component
+   */
+  primary: SlotProps<React.ElementType<TypographyProps>, {}, ListItemTextOwnerState>;
+  /**
+   * Props forwarded to the secondary slot (as long as disableTypography is not `true`)
+   * By default, the available props are based on the [Typography](https://mui.com/material-ui/api/typography/#props) component
+   */
+  secondary: SlotProps<React.ElementType<TypographyProps>, {}, ListItemTextOwnerState>;
+}>;
+export interface ListItemTextOwnerState extends ListItemTextProps {}
+export interface ListItemTextProps<PrimaryTypographyComponent extends React.ElementType = 'span', SecondaryTypographyComponent extends React.ElementType = 'p'> extends StandardProps<React.HTMLAttributes<HTMLDivElement>>, ListItemTextSlotsAndSlotProps {
+  /**
+   * Alias for the `primary` prop.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<ListItemTextClasses>;
+  /**
+   * If `true`, the children won't be wrapped by a Typography component.
+   * This can be useful to render an alternative Typography variant by wrapping
+   * the `children` (or `primary`) text, and optional `secondary` text
+   * with the Typography component.
+   * @default false
+   */
+  disableTypography?: boolean;
+  /**
+   * If `true`, the children are indented.
+   * This should be used if there is no left avatar or left icon.
+   * @default false
+   */
+  inset?: boolean;
+  /**
+   * The main content element.
+   */
+  primary?: React.ReactNode;
+  /**
+   * These props will be forwarded to the primary typography component
+   * (as long as disableTypography is not `true`).
+   * @deprecated Use `slotProps.primary` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  primaryTypographyProps?: TypographyProps<PrimaryTypographyComponent, {
+    component?: PrimaryTypographyComponent;
+  }>;
+  /**
+   * The secondary content element.
+   */
+  secondary?: React.ReactNode;
+  /**
+   * These props will be forwarded to the secondary typography component
+   * (as long as disableTypography is not `true`).
+   * @deprecated Use `slotProps.secondary` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  secondaryTypographyProps?: TypographyProps<SecondaryTypographyComponent, {
+    component?: SecondaryTypographyComponent;
+  }>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Lists](https://mui.com/material-ui/react-list/)
+ *
+ * API:
+ *
+ * - [ListItemText API](https://mui.com/material-ui/api/list-item-text/)
+ */
+export default function ListItemText<PrimaryTypographyComponent extends React.ElementType = 'span', SecondaryTypographyComponent extends React.ElementType = 'p'>(props: ListItemTextProps<PrimaryTypographyComponent, SecondaryTypographyComponent>): React.JSX.Element;

node_modules/@mui/material/Menu/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Menu.js";
+export * from "./Menu.js";
+export { default as menuClasses } from "./menuClasses.js";
+export * from "./menuClasses.js";

node_modules/@mui/material/MobileStepper/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./MobileStepper.js";
+export * from "./MobileStepper.js";
+export { default as mobileStepperClasses } from "./mobileStepperClasses.js";
+export * from "./mobileStepperClasses.js";

node_modules/@mui/material/Modal/ModalManager.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModalManager = void 0;
+exports.ariaHidden = ariaHidden;
+var _ownerWindow = _interopRequireDefault(require("@mui/utils/ownerWindow"));
+var _ownerDocument = _interopRequireDefault(require("@mui/utils/ownerDocument"));
+var _getScrollbarSize = _interopRequireDefault(require("@mui/utils/getScrollbarSize"));
+// Is a vertical scrollbar displayed?
+function isOverflowing(container) {
+  const doc = (0, _ownerDocument.default)(container);
+  if (doc.body === container) {
+    return (0, _ownerWindow.default)(container).innerWidth > doc.documentElement.clientWidth;
+  }
+  return container.scrollHeight > container.clientHeight;
+}
+function ariaHidden(element, hide) {
+  if (hide) {
+    element.setAttribute('aria-hidden', 'true');
+  } else {
+    element.removeAttribute('aria-hidden');
+  }
+}
+function getPaddingRight(element) {
+  return parseInt((0, _ownerWindow.default)(element).getComputedStyle(element).paddingRight, 10) || 0;
+}
+function isAriaHiddenForbiddenOnElement(element) {
+  // The forbidden HTML tags are the ones from ARIA specification that
+  // can be children of body and can't have aria-hidden attribute.
+  // cf. https://www.w3.org/TR/html-aria/#docconformance
+  const forbiddenTagNames = ['TEMPLATE', 'SCRIPT', 'STYLE', 'LINK', 'MAP', 'META', 'NOSCRIPT', 'PICTURE', 'COL', 'COLGROUP', 'PARAM', 'SLOT', 'SOURCE', 'TRACK'];
+  const isForbiddenTagName = forbiddenTagNames.includes(element.tagName);
+  const isInputHidden = element.tagName === 'INPUT' && element.getAttribute('type') === 'hidden';
+  return isForbiddenTagName || isInputHidden;
+}
+function ariaHiddenSiblings(container, mountElement, currentElement, elementsToExclude, hide) {
+  const blacklist = [mountElement, currentElement, ...elementsToExclude];
+  [].forEach.call(container.children, element => {
+    const isNotExcludedElement = !blacklist.includes(element);
+    const isNotForbiddenElement = !isAriaHiddenForbiddenOnElement(element);
+    if (isNotExcludedElement && isNotForbiddenElement) {
+      ariaHidden(element, hide);
+    }
+  });
+}
+function findIndexOf(items, callback) {
+  let idx = -1;
+  items.some((item, index) => {
+    if (callback(item)) {
+      idx = index;
+      return true;
+    }
+    return false;
+  });
+  return idx;
+}
+function handleContainer(containerInfo, props) {
+  const restoreStyle = [];
+  const container = containerInfo.container;
+  if (!props.disableScrollLock) {
+    if (isOverflowing(container)) {
+      // Compute the size before applying overflow hidden to avoid any scroll jumps.
+      const scrollbarSize = (0, _getScrollbarSize.default)((0, _ownerWindow.default)(container));
+      restoreStyle.push({
+        value: container.style.paddingRight,
+        property: 'padding-right',
+        el: container
+      });
+      // Use computed style, here to get the real padding to add our scrollbar width.
+      container.style.paddingRight = `${getPaddingRight(container) + scrollbarSize}px`;
+
+      // .mui-fixed is a global helper.
+      const fixedElements = (0, _ownerDocument.default)(container).querySelectorAll('.mui-fixed');
+      [].forEach.call(fixedElements, element => {
+        restoreStyle.push({
+          value: element.style.paddingRight,
+          property: 'padding-right',
+          el: element
+        });
+        element.style.paddingRight = `${getPaddingRight(element) + scrollbarSize}px`;
+      });
+    }
+    let scrollContainer;
+    if (container.parentNode instanceof DocumentFragment) {
+      scrollContainer = (0, _ownerDocument.default)(container).body;
+    } else {
+      // Support html overflow-y: auto for scroll stability between pages
+      // https://css-tricks.com/snippets/css/force-vertical-scrollbar/
+      const parent = container.parentElement;
+      const containerWindow = (0, _ownerWindow.default)(container);
+      scrollContainer = parent?.nodeName === 'HTML' && containerWindow.getComputedStyle(parent).overflowY === 'scroll' ? parent : container;
+    }
+
+    // Block the scroll even if no scrollbar is visible to account for mobile keyboard
+    // screensize shrink.
+    restoreStyle.push({
+      value: scrollContainer.style.overflow,
+      property: 'overflow',
+      el: scrollContainer
+    }, {
+      value: scrollContainer.style.overflowX,
+      property: 'overflow-x',
+      el: scrollContainer
+    }, {
+      value: scrollContainer.style.overflowY,
+      property: 'overflow-y',
+      el: scrollContainer
+    });
+    scrollContainer.style.overflow = 'hidden';
+  }
+  const restore = () => {
+    restoreStyle.forEach(({
+      value,
+      el,
+      property
+    }) => {
+      if (value) {
+        el.style.setProperty(property, value);
+      } else {
+        el.style.removeProperty(property);
+      }
+    });
+  };
+  return restore;
+}
+function getHiddenSiblings(container) {
+  const hiddenSiblings = [];
+  [].forEach.call(container.children, element => {
+    if (element.getAttribute('aria-hidden') === 'true') {
+      hiddenSiblings.push(element);
+    }
+  });
+  return hiddenSiblings;
+}
+/**
+ * @ignore - do not document.
+ *
+ * Proper state management for containers and the modals in those containers.
+ * Simplified, but inspired by react-overlay's ModalManager class.
+ * Used by the Modal to ensure proper styling of containers.
+ */
+class ModalManager {
+  constructor() {
+    this.modals = [];
+    this.containers = [];
+  }
+  add(modal, container) {
+    let modalIndex = this.modals.indexOf(modal);
+    if (modalIndex !== -1) {
+      return modalIndex;
+    }
+    modalIndex = this.modals.length;
+    this.modals.push(modal);
+
+    // If the modal we are adding is already in the DOM.
+    if (modal.modalRef) {
+      ariaHidden(modal.modalRef, false);
+    }
+    const hiddenSiblings = getHiddenSiblings(container);
+    ariaHiddenSiblings(container, modal.mount, modal.modalRef, hiddenSiblings, true);
+    const containerIndex = findIndexOf(this.containers, item => item.container === container);
+    if (containerIndex !== -1) {
+      this.containers[containerIndex].modals.push(modal);
+      return modalIndex;
+    }
+    this.containers.push({
+      modals: [modal],
+      container,
+      restore: null,
+      hiddenSiblings
+    });
+    return modalIndex;
+  }
+  mount(modal, props) {
+    const containerIndex = findIndexOf(this.containers, item => item.modals.includes(modal));
+    const containerInfo = this.containers[containerIndex];
+    if (!containerInfo.restore) {
+      containerInfo.restore = handleContainer(containerInfo, props);
+    }
+  }
+  remove(modal, ariaHiddenState = true) {
+    const modalIndex = this.modals.indexOf(modal);
+    if (modalIndex === -1) {
+      return modalIndex;
+    }
+    const containerIndex = findIndexOf(this.containers, item => item.modals.includes(modal));
+    const containerInfo = this.containers[containerIndex];
+    containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);
+    this.modals.splice(modalIndex, 1);
+
+    // If that was the last modal in a container, clean up the container.
+    if (containerInfo.modals.length === 0) {
+      // The modal might be closed before it had the chance to be mounted in the DOM.
+      if (containerInfo.restore) {
+        containerInfo.restore();
+      }
+      if (modal.modalRef) {
+        // In case the modal wasn't in the DOM yet.
+        ariaHidden(modal.modalRef, ariaHiddenState);
+      }
+      ariaHiddenSiblings(containerInfo.container, modal.mount, modal.modalRef, containerInfo.hiddenSiblings, false);
+      this.containers.splice(containerIndex, 1);
+    } else {
+      // Otherwise make sure the next top modal is visible to a screen reader.
+      const nextTop = containerInfo.modals[containerInfo.modals.length - 1];
+      // as soon as a modal is adding its modalRef is undefined. it can't set
+      // aria-hidden because the dom element doesn't exist either
+      // when modal was unmounted before modalRef gets null
+      if (nextTop.modalRef) {
+        ariaHidden(nextTop.modalRef, false);
+      }
+    }
+    return modalIndex;
+  }
+  isTopModal(modal) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;
+  }
+}
+exports.ModalManager = ModalManager;

node_modules/@mui/material/Popper/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Popper.js";
+export * from "./Popper.js";
+export * from "./popperClasses.js";
+export { PopperPlacementType } from "./BasePopper.types.js";

node_modules/@mui/material/Popper/popperClasses.d.ts

@@ -0,0 +1,8 @@
+export interface PopperClasses {
+  /** Class name applied to the root element. */
+  root: string;
+}
+export type PopperClassKey = keyof PopperClasses;
+export declare function getPopperUtilityClass(slot: string): string;
+declare const popperClasses: PopperClasses;
+export default popperClasses;

node_modules/@mui/material/Portal/Portal.types.js

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

node_modules/@mui/material/Portal/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./Portal.js";
+export * from "./Portal.js";
+export * from "./Portal.types.js";

node_modules/@mui/material/Radio/radioClasses.d.ts

@@ -0,0 +1,18 @@
+export interface RadioClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** State class applied to the root element if `checked={true}`. */
+  checked: string;
+  /** State class applied to the root element if `disabled={true}`. */
+  disabled: string;
+  /** Styles applied to the root element if `color="primary"`. */
+  colorPrimary: string;
+  /** Styles applied to the root element if `color="secondary"`. */
+  colorSecondary: string;
+  /** Styles applied to the root element if `size="small"`. */
+  sizeSmall: string;
+}
+export type RadioClassKey = keyof RadioClasses;
+export declare function getRadioUtilityClass(slot: string): string;
+declare const radioClasses: RadioClasses;
+export default radioClasses;

node_modules/@mui/material/RadioGroup/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useRadioGroup: true,
+  radioGroupClasses: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _RadioGroup.default;
+  }
+});
+Object.defineProperty(exports, "radioGroupClasses", {
+  enumerable: true,
+  get: function () {
+    return _radioGroupClasses.default;
+  }
+});
+Object.defineProperty(exports, "useRadioGroup", {
+  enumerable: true,
+  get: function () {
+    return _useRadioGroup.default;
+  }
+});
+var _RadioGroup = _interopRequireDefault(require("./RadioGroup"));
+var _useRadioGroup = _interopRequireDefault(require("./useRadioGroup"));
+var _radioGroupClasses = _interopRequireWildcard(require("./radioGroupClasses"));
+Object.keys(_radioGroupClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _radioGroupClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _radioGroupClasses[key];
+    }
+  });
+});

node_modules/@mui/material/RadioGroup/useRadioGroup.js

@@ -0,0 +1,14 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRadioGroup;
+var React = _interopRequireWildcard(require("react"));
+var _RadioGroupContext = _interopRequireDefault(require("./RadioGroupContext"));
+function useRadioGroup() {
+  return React.useContext(_RadioGroupContext.default);
+}

node_modules/@mui/material/Skeleton/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  skeletonClasses: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _Skeleton.default;
+  }
+});
+Object.defineProperty(exports, "skeletonClasses", {
+  enumerable: true,
+  get: function () {
+    return _skeletonClasses.default;
+  }
+});
+var _Skeleton = _interopRequireDefault(require("./Skeleton"));
+var _skeletonClasses = _interopRequireWildcard(require("./skeletonClasses"));
+Object.keys(_skeletonClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _skeletonClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _skeletonClasses[key];
+    }
+  });
+});

node_modules/@mui/material/Slider/SliderValueLabel.js

@@ -0,0 +1,60 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = SliderValueLabel;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _sliderClasses = _interopRequireDefault(require("./sliderClasses"));
+var _jsxRuntime = require("react/jsx-runtime");
+const useValueLabelClasses = props => {
+  const {
+    open
+  } = props;
+  const utilityClasses = {
+    offset: (0, _clsx.default)(open && _sliderClasses.default.valueLabelOpen),
+    circle: _sliderClasses.default.valueLabelCircle,
+    label: _sliderClasses.default.valueLabelLabel
+  };
+  return utilityClasses;
+};
+
+/**
+ * @ignore - internal component.
+ */
+function SliderValueLabel(props) {
+  const {
+    children,
+    className,
+    value
+  } = props;
+  const classes = useValueLabelClasses(props);
+  if (!children) {
+    return null;
+  }
+  return /*#__PURE__*/React.cloneElement(children, {
+    className: children.props.className
+  }, /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
+    children: [children.props.children, /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      className: (0, _clsx.default)(classes.offset, className),
+      "aria-hidden": true,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+        className: classes.circle,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+          className: classes.label,
+          children: value
+        })
+      })
+    })]
+  }));
+}
+process.env.NODE_ENV !== "production" ? SliderValueLabel.propTypes = {
+  children: _propTypes.default.element.isRequired,
+  className: _propTypes.default.string,
+  value: _propTypes.default.node
+} : void 0;

node_modules/@mui/material/Slider/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Slider.js";
+export * from "./Slider.js";
+export { default as sliderClasses } from "./sliderClasses.js";
+export * from "./sliderClasses.js";

node_modules/@mui/material/SpeedDialAction/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  speedDialActionClasses: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _SpeedDialAction.default;
+  }
+});
+Object.defineProperty(exports, "speedDialActionClasses", {
+  enumerable: true,
+  get: function () {
+    return _speedDialActionClasses.default;
+  }
+});
+var _SpeedDialAction = _interopRequireDefault(require("./SpeedDialAction"));
+var _speedDialActionClasses = _interopRequireWildcard(require("./speedDialActionClasses"));
+Object.keys(_speedDialActionClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _speedDialActionClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _speedDialActionClasses[key];
+    }
+  });
+});

node_modules/@mui/material/Stack/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Stack.js";
+export * from "./Stack.js";
+export { default as stackClasses } from "./stackClasses.js";
+export * from "./stackClasses.js";

node_modules/@mui/material/StepButton/StepButton.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { ButtonBaseTypeMap, ExtendButtonBase, ExtendButtonBaseTypeMap } from "../ButtonBase/index.js";
+import { OverrideProps } from "../OverridableComponent/index.js";
+import { Theme } from "../styles/index.js";
+import { StepButtonClasses } from "./stepButtonClasses.js";
+export interface StepButtonOwnProps {
+  /**
+   * Can be a `StepLabel` or a node to place inside `StepLabel` as children.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<StepButtonClasses>;
+  /**
+   * The icon displayed by the step label.
+   */
+  icon?: React.ReactNode;
+  /**
+   * The optional node to display.
+   */
+  optional?: React.ReactNode;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export type StepButtonTypeMap<AdditionalProps, RootComponent extends React.ElementType> = ExtendButtonBaseTypeMap<{
+  props: AdditionalProps & StepButtonOwnProps;
+  defaultComponent: RootComponent;
+  ignoredProps: 'disabled';
+}>;
+
+/**
+ *
+ * Demos:
+ *
+ * - [Stepper](https://mui.com/material-ui/react-stepper/)
+ *
+ * API:
+ *
+ * - [StepButton API](https://mui.com/material-ui/api/step-button/)
+ * - inherits [ButtonBase API](https://mui.com/material-ui/api/button-base/)
+ */
+declare const StepButton: ExtendButtonBase<StepButtonTypeMap<{}, ButtonBaseTypeMap['defaultComponent']>>;
+export type StepButtonClasskey = keyof NonNullable<StepButtonProps['classes']>;
+export type StepButtonProps<RootComponent extends React.ElementType = ButtonBaseTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<StepButtonTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default StepButton;

node_modules/@mui/material/StepContent/StepContent.js

@@ -0,0 +1,193 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _Collapse = _interopRequireDefault(require("../Collapse"));
+var _StepperContext = _interopRequireDefault(require("../Stepper/StepperContext"));
+var _StepContext = _interopRequireDefault(require("../Step/StepContext"));
+var _stepContentClasses = require("./stepContentClasses");
+var _useSlot = _interopRequireDefault(require("../utils/useSlot"));
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    last
+  } = ownerState;
+  const slots = {
+    root: ['root', last && 'last'],
+    transition: ['transition']
+  };
+  return (0, _composeClasses.default)(slots, _stepContentClasses.getStepContentUtilityClass, classes);
+};
+const StepContentRoot = (0, _zeroStyled.styled)('div', {
+  name: 'MuiStepContent',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, ownerState.last && styles.last];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  marginLeft: 12,
+  // half icon
+  paddingLeft: 8 + 12,
+  // margin + half icon
+  paddingRight: 8,
+  borderLeft: theme.vars ? `1px solid ${theme.vars.palette.StepContent.border}` : `1px solid ${theme.palette.mode === 'light' ? theme.palette.grey[400] : theme.palette.grey[600]}`,
+  variants: [{
+    props: {
+      last: true
+    },
+    style: {
+      borderLeft: 'none'
+    }
+  }]
+})));
+const StepContentTransition = (0, _zeroStyled.styled)(_Collapse.default, {
+  name: 'MuiStepContent',
+  slot: 'Transition'
+})({});
+const StepContent = /*#__PURE__*/React.forwardRef(function StepContent(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiStepContent'
+  });
+  const {
+    children,
+    className,
+    TransitionComponent = _Collapse.default,
+    transitionDuration: transitionDurationProp = 'auto',
+    TransitionProps,
+    slots = {},
+    slotProps = {},
+    ...other
+  } = props;
+  const {
+    orientation
+  } = React.useContext(_StepperContext.default);
+  const {
+    active,
+    last,
+    expanded
+  } = React.useContext(_StepContext.default);
+  const ownerState = {
+    ...props,
+    last
+  };
+  const classes = useUtilityClasses(ownerState);
+  if (process.env.NODE_ENV !== 'production') {
+    if (orientation !== 'vertical') {
+      console.error('MUI: <StepContent /> is only designed for use with the vertical stepper.');
+    }
+  }
+  let transitionDuration = transitionDurationProp;
+  if (transitionDurationProp === 'auto' && !TransitionComponent.muiSupportAuto) {
+    transitionDuration = undefined;
+  }
+  const externalForwardedProps = {
+    slots,
+    slotProps: {
+      transition: TransitionProps,
+      ...slotProps
+    }
+  };
+  const [TransitionSlot, transitionProps] = (0, _useSlot.default)('transition', {
+    elementType: StepContentTransition,
+    externalForwardedProps,
+    ownerState,
+    className: classes.transition,
+    additionalProps: {
+      in: active || expanded,
+      timeout: transitionDuration,
+      unmountOnExit: true
+    }
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(StepContentRoot, {
+    className: (0, _clsx.default)(classes.root, className),
+    ref: ref,
+    ownerState: ownerState,
+    ...other,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(TransitionSlot, {
+      as: TransitionComponent,
+      ...transitionProps,
+      children: children
+    })
+  });
+});
+process.env.NODE_ENV !== "production" ? StepContent.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: _propTypes.default.shape({
+    transition: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: _propTypes.default.shape({
+    transition: _propTypes.default.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Collapse
+   * @deprecated Use `slots.transition` instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   */
+  TransitionComponent: _propTypes.default.elementType,
+  /**
+   * Adjust the duration of the content expand transition.
+   * Passed as a prop to the transition component.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default 'auto'
+   */
+  transitionDuration: _propTypes.default.oneOfType([_propTypes.default.oneOf(['auto']), _propTypes.default.number, _propTypes.default.shape({
+    appear: _propTypes.default.number,
+    enter: _propTypes.default.number,
+    exit: _propTypes.default.number
+  })]),
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   * @deprecated Use `slotProps.transition` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  TransitionProps: _propTypes.default.object
+} : void 0;
+var _default = exports.default = StepContent;

node_modules/@mui/material/StepIcon/StepIcon.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { SvgIconOwnProps } from "../SvgIcon/index.js";
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { StepIconClasses } from "./stepIconClasses.js";
+export interface StepIconProps
+// TODO v7: extend React.HTMLAttributes<SVGSVGElement> as svg is root component of StepIcon not div
+extends StandardProps<React.HTMLAttributes<HTMLDivElement>, 'color' | 'children'>, Omit<SvgIconOwnProps, 'children'> {
+  /**
+   * Whether this step is active.
+   * @default false
+   */
+  active?: boolean;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<StepIconClasses>;
+  /**
+   * Mark the step as completed. Is passed to child components.
+   * @default false
+   */
+  completed?: boolean;
+  /**
+   * If `true`, the step is marked as failed.
+   * @default false
+   */
+  error?: boolean;
+  /**
+   * The label displayed in the step icon.
+   */
+  icon: React.ReactNode;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export type StepIconClasskey = keyof NonNullable<StepIconProps['classes']>;
+
+/**
+ *
+ * Demos:
+ *
+ * - [Stepper](https://mui.com/material-ui/react-stepper/)
+ *
+ * API:
+ *
+ * - [StepIcon API](https://mui.com/material-ui/api/step-icon/)
+ * - inherits [SvgIcon API](https://mui.com/material-ui/api/svg-icon/)
+ */
+export default function StepIcon(props: StepIconProps): React.JSX.Element;

node_modules/@mui/material/StepLabel/StepLabel.d.ts

@@ -0,0 +1,106 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { StepIconProps } from "../StepIcon/index.js";
+import { StepLabelClasses } from "./stepLabelClasses.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+export interface StepLabelSlots {
+  /**
+   * The component that renders the root.
+   * @default span
+   */
+  root: React.ElementType;
+  /**
+   * The component that renders the label.
+   * @default span
+   */
+  label: React.ElementType;
+  /**
+   * The component to render in place of the [`StepIcon`](https://mui.com/material-ui/api/step-icon/).
+   */
+  stepIcon: React.ElementType;
+}
+export type StepLabelSlotsAndSlotProps = CreateSlotsAndSlotProps<StepLabelSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on the span element.
+   */
+  root: SlotProps<'span', {}, StepLabelOwnerState>;
+  /**
+   * Props forwarded to the label slot.
+   * By default, the available props are based on the span element.
+   */
+  label: SlotProps<'span', {}, StepLabelOwnerState>;
+  /**
+   * Props forwarded to the stepIcon slot.
+   * By default, the available props are based on the div element.
+   */
+  stepIcon: SlotProps<React.ElementType<StepIconProps>, {}, StepLabelOwnerState>;
+}>;
+export interface StepLabelOwnerState extends StepLabelProps {}
+export interface StepLabelProps extends StandardProps<React.HTMLAttributes<HTMLDivElement>>, StepLabelSlotsAndSlotProps {
+  /**
+   * In most cases will simply be a string containing a title for the label.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<StepLabelClasses>;
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  componentsProps?: {
+    /**
+     * Props applied to the label element.
+     * @default {}
+     */
+    label?: React.HTMLProps<HTMLSpanElement>;
+  };
+  /**
+   * If `true`, the step is marked as failed.
+   * @default false
+   */
+  error?: boolean;
+  /**
+   * Override the default label of the step icon.
+   */
+  icon?: React.ReactNode;
+  /**
+   * The optional node to display.
+   */
+  optional?: React.ReactNode;
+  /**
+   * The component to render in place of the [`StepIcon`](https://mui.com/material-ui/api/step-icon/).
+   * @deprecated Use `slots.stepIcon` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  StepIconComponent?: React.ElementType<StepIconProps>;
+  /**
+   * Props applied to the [`StepIcon`](https://mui.com/material-ui/api/step-icon/) element.
+   * @deprecated Use `slotProps.stepIcon` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  StepIconProps?: Partial<StepIconProps>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export type StepLabelClasskey = keyof NonNullable<StepLabelProps['classes']>;
+
+/**
+ *
+ * Demos:
+ *
+ * - [Stepper](https://mui.com/material-ui/react-stepper/)
+ *
+ * API:
+ *
+ * - [StepLabel API](https://mui.com/material-ui/api/step-label/)
+ */
+declare const StepLabel: ((props: StepLabelProps) => React.JSX.Element) & {
+  muiName: string;
+};
+export default StepLabel;

node_modules/@mui/material/Tab/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  tabClasses: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _Tab.default;
+  }
+});
+Object.defineProperty(exports, "tabClasses", {
+  enumerable: true,
+  get: function () {
+    return _tabClasses.default;
+  }
+});
+var _Tab = _interopRequireDefault(require("./Tab"));
+var _tabClasses = _interopRequireWildcard(require("./tabClasses"));
+Object.keys(_tabClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _tabClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _tabClasses[key];
+    }
+  });
+});

node_modules/@mui/material/TableHead/TableHead.js

@@ -0,0 +1,92 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _Tablelvl2Context = _interopRequireDefault(require("../Table/Tablelvl2Context"));
+var _zeroStyled = require("../zero-styled");
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _tableHeadClasses = require("./tableHeadClasses");
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root']
+  };
+  return (0, _composeClasses.default)(slots, _tableHeadClasses.getTableHeadUtilityClass, classes);
+};
+const TableHeadRoot = (0, _zeroStyled.styled)('thead', {
+  name: 'MuiTableHead',
+  slot: 'Root'
+})({
+  display: 'table-header-group'
+});
+const tablelvl2 = {
+  variant: 'head'
+};
+const defaultComponent = 'thead';
+const TableHead = /*#__PURE__*/React.forwardRef(function TableHead(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiTableHead'
+  });
+  const {
+    className,
+    component = defaultComponent,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    component
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Tablelvl2Context.default.Provider, {
+    value: tablelvl2,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(TableHeadRoot, {
+      as: component,
+      className: (0, _clsx.default)(classes.root, className),
+      ref: ref,
+      role: component === defaultComponent ? null : 'rowgroup',
+      ownerState: ownerState,
+      ...other
+    })
+  });
+});
+process.env.NODE_ENV !== "production" ? TableHead.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component, normally `TableRow`.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: _propTypes.default.elementType,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object])
+} : void 0;
+var _default = exports.default = TableHead;

node_modules/@mui/material/TableHead/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  tableHeadClasses: true
+};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _TableHead.default;
+  }
+});
+Object.defineProperty(exports, "tableHeadClasses", {
+  enumerable: true,
+  get: function () {
+    return _tableHeadClasses.default;
+  }
+});
+var _TableHead = _interopRequireDefault(require("./TableHead"));
+var _tableHeadClasses = _interopRequireWildcard(require("./tableHeadClasses"));
+Object.keys(_tableHeadClasses).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _tableHeadClasses[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _tableHeadClasses[key];
+    }
+  });
+});

node_modules/@mui/material/TableHead/tableHeadClasses.d.ts

@@ -0,0 +1,8 @@
+export interface TableHeadClasses {
+  /** Styles applied to the root element. */
+  root: string;
+}
+export type TableHeadClassKey = keyof TableHeadClasses;
+export declare function getTableHeadUtilityClass(slot: string): string;
+declare const tableHeadClasses: TableHeadClasses;
+export default tableHeadClasses;

node_modules/@mui/material/TablePaginationActions/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./TablePaginationActions.js";
+export * from "./TablePaginationActions.js";
+export { default as tablePaginationActionsClasses } from "./tablePaginationActionsClasses.js";
+export * from "./tablePaginationActionsClasses.js";

node_modules/@mui/material/TableSortLabel/tableSortLabelClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getTableSortLabelUtilityClass = getTableSortLabelUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getTableSortLabelUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiTableSortLabel', slot);
+}
+const tableSortLabelClasses = (0, _generateUtilityClasses.default)('MuiTableSortLabel', ['root', 'active', 'icon', 'iconDirectionDesc', 'iconDirectionAsc', 'directionDesc', 'directionAsc']);
+var _default = exports.default = tableSortLabelClasses;

node_modules/@mui/material/ToggleButton/toggleButtonClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getToggleButtonUtilityClass = getToggleButtonUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getToggleButtonUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiToggleButton', slot);
+}
+const toggleButtonClasses = (0, _generateUtilityClasses.default)('MuiToggleButton', ['root', 'disabled', 'selected', 'standard', 'primary', 'secondary', 'sizeSmall', 'sizeMedium', 'sizeLarge', 'fullWidth']);
+var _default = exports.default = toggleButtonClasses;

node_modules/@mui/material/ToggleButtonGroup/ToggleButtonGroup.js

@@ -0,0 +1,288 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _reactIs = require("react-is");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _getValidReactChildren = _interopRequireDefault(require("@mui/utils/getValidReactChildren"));
+var _zeroStyled = require("../zero-styled");
+var _memoTheme = _interopRequireDefault(require("../utils/memoTheme"));
+var _DefaultPropsProvider = require("../DefaultPropsProvider");
+var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
+var _toggleButtonGroupClasses = _interopRequireWildcard(require("./toggleButtonGroupClasses"));
+var _ToggleButtonGroupContext = _interopRequireDefault(require("./ToggleButtonGroupContext"));
+var _ToggleButtonGroupButtonContext = _interopRequireDefault(require("./ToggleButtonGroupButtonContext"));
+var _toggleButtonClasses = _interopRequireDefault(require("../ToggleButton/toggleButtonClasses"));
+var _jsxRuntime = require("react/jsx-runtime");
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    orientation,
+    fullWidth,
+    disabled
+  } = ownerState;
+  const slots = {
+    root: ['root', orientation, fullWidth && 'fullWidth'],
+    grouped: ['grouped', `grouped${(0, _capitalize.default)(orientation)}`, disabled && 'disabled'],
+    firstButton: ['firstButton'],
+    lastButton: ['lastButton'],
+    middleButton: ['middleButton']
+  };
+  return (0, _composeClasses.default)(slots, _toggleButtonGroupClasses.getToggleButtonGroupUtilityClass, classes);
+};
+const ToggleButtonGroupRoot = (0, _zeroStyled.styled)('div', {
+  name: 'MuiToggleButtonGroup',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [{
+      [`& .${_toggleButtonGroupClasses.default.grouped}`]: styles.grouped
+    }, {
+      [`& .${_toggleButtonGroupClasses.default.grouped}`]: styles[`grouped${(0, _capitalize.default)(ownerState.orientation)}`]
+    }, {
+      [`& .${_toggleButtonGroupClasses.default.firstButton}`]: styles.firstButton
+    }, {
+      [`& .${_toggleButtonGroupClasses.default.lastButton}`]: styles.lastButton
+    }, {
+      [`& .${_toggleButtonGroupClasses.default.middleButton}`]: styles.middleButton
+    }, styles.root, ownerState.orientation === 'vertical' && styles.vertical, ownerState.fullWidth && styles.fullWidth];
+  }
+})((0, _memoTheme.default)(({
+  theme
+}) => ({
+  display: 'inline-flex',
+  borderRadius: (theme.vars || theme).shape.borderRadius,
+  variants: [{
+    props: {
+      orientation: 'vertical'
+    },
+    style: {
+      flexDirection: 'column',
+      [`& .${_toggleButtonGroupClasses.default.grouped}`]: {
+        [`&.${_toggleButtonGroupClasses.default.selected} + .${_toggleButtonGroupClasses.default.grouped}.${_toggleButtonGroupClasses.default.selected}`]: {
+          borderTop: 0,
+          marginTop: 0
+        }
+      },
+      [`& .${_toggleButtonGroupClasses.default.firstButton},& .${_toggleButtonGroupClasses.default.middleButton}`]: {
+        borderBottomLeftRadius: 0,
+        borderBottomRightRadius: 0
+      },
+      [`& .${_toggleButtonGroupClasses.default.lastButton},& .${_toggleButtonGroupClasses.default.middleButton}`]: {
+        marginTop: -1,
+        borderTop: '1px solid transparent',
+        borderTopLeftRadius: 0,
+        borderTopRightRadius: 0
+      },
+      [`& .${_toggleButtonGroupClasses.default.lastButton}.${_toggleButtonClasses.default.disabled},& .${_toggleButtonGroupClasses.default.middleButton}.${_toggleButtonClasses.default.disabled}`]: {
+        borderTop: '1px solid transparent'
+      }
+    }
+  }, {
+    props: {
+      fullWidth: true
+    },
+    style: {
+      width: '100%'
+    }
+  }, {
+    props: {
+      orientation: 'horizontal'
+    },
+    style: {
+      [`& .${_toggleButtonGroupClasses.default.grouped}`]: {
+        [`&.${_toggleButtonGroupClasses.default.selected} + .${_toggleButtonGroupClasses.default.grouped}.${_toggleButtonGroupClasses.default.selected}`]: {
+          borderLeft: 0,
+          marginLeft: 0
+        }
+      },
+      [`& .${_toggleButtonGroupClasses.default.firstButton},& .${_toggleButtonGroupClasses.default.middleButton}`]: {
+        borderTopRightRadius: 0,
+        borderBottomRightRadius: 0
+      },
+      [`& .${_toggleButtonGroupClasses.default.lastButton},& .${_toggleButtonGroupClasses.default.middleButton}`]: {
+        marginLeft: -1,
+        borderLeft: '1px solid transparent',
+        borderTopLeftRadius: 0,
+        borderBottomLeftRadius: 0
+      },
+      [`& .${_toggleButtonGroupClasses.default.lastButton}.${_toggleButtonClasses.default.disabled},& .${_toggleButtonGroupClasses.default.middleButton}.${_toggleButtonClasses.default.disabled}`]: {
+        borderLeft: '1px solid transparent'
+      }
+    }
+  }]
+})));
+const ToggleButtonGroup = /*#__PURE__*/React.forwardRef(function ToggleButtonGroup(inProps, ref) {
+  const props = (0, _DefaultPropsProvider.useDefaultProps)({
+    props: inProps,
+    name: 'MuiToggleButtonGroup'
+  });
+  const {
+    children,
+    className,
+    color = 'standard',
+    disabled = false,
+    exclusive = false,
+    fullWidth = false,
+    onChange,
+    orientation = 'horizontal',
+    size = 'medium',
+    value,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    disabled,
+    fullWidth,
+    orientation,
+    size
+  };
+  const classes = useUtilityClasses(ownerState);
+  const handleChange = React.useCallback((event, buttonValue) => {
+    if (!onChange) {
+      return;
+    }
+    const index = value && value.indexOf(buttonValue);
+    let newValue;
+    if (value && index >= 0) {
+      newValue = value.slice();
+      newValue.splice(index, 1);
+    } else {
+      newValue = value ? value.concat(buttonValue) : [buttonValue];
+    }
+    onChange(event, newValue);
+  }, [onChange, value]);
+  const handleExclusiveChange = React.useCallback((event, buttonValue) => {
+    if (!onChange) {
+      return;
+    }
+    onChange(event, value === buttonValue ? null : buttonValue);
+  }, [onChange, value]);
+  const context = React.useMemo(() => ({
+    className: classes.grouped,
+    onChange: exclusive ? handleExclusiveChange : handleChange,
+    value,
+    size,
+    fullWidth,
+    color,
+    disabled
+  }), [classes.grouped, exclusive, handleExclusiveChange, handleChange, value, size, fullWidth, color, disabled]);
+  const validChildren = (0, _getValidReactChildren.default)(children);
+  const childrenCount = validChildren.length;
+  const getButtonPositionClassName = index => {
+    const isFirstButton = index === 0;
+    const isLastButton = index === childrenCount - 1;
+    if (isFirstButton && isLastButton) {
+      return '';
+    }
+    if (isFirstButton) {
+      return classes.firstButton;
+    }
+    if (isLastButton) {
+      return classes.lastButton;
+    }
+    return classes.middleButton;
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(ToggleButtonGroupRoot, {
+    role: "group",
+    className: (0, _clsx.default)(classes.root, className),
+    ref: ref,
+    ownerState: ownerState,
+    ...other,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_ToggleButtonGroupContext.default.Provider, {
+      value: context,
+      children: validChildren.map((child, index) => {
+        if (process.env.NODE_ENV !== 'production') {
+          if ((0, _reactIs.isFragment)(child)) {
+            console.error(["MUI: The ToggleButtonGroup component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
+          }
+        }
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ToggleButtonGroupButtonContext.default.Provider, {
+          value: getButtonPositionClassName(index),
+          children: child
+        }, index);
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" ? ToggleButtonGroup.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: _propTypes.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: _propTypes.default.object,
+  /**
+   * @ignore
+   */
+  className: _propTypes.default.string,
+  /**
+   * The color of the button when it is selected.
+   * 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 'standard'
+   */
+  color: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['standard', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), _propTypes.default.string]),
+  /**
+   * If `true`, the component is disabled. This implies that all ToggleButton children will be disabled.
+   * @default false
+   */
+  disabled: _propTypes.default.bool,
+  /**
+   * If `true`, only allow one of the child ToggleButton values to be selected.
+   * @default false
+   */
+  exclusive: _propTypes.default.bool,
+  /**
+   * If `true`, the button group will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: _propTypes.default.bool,
+  /**
+   * Callback fired when the value changes.
+   *
+   * @param {React.MouseEvent<HTMLElement>} event The event source of the callback.
+   * @param {any} value of the selected buttons. When `exclusive` is true
+   * this is a single value; when false an array of selected values. If no value
+   * is selected and `exclusive` is true the value is null; when false an empty array.
+   */
+  onChange: _propTypes.default.func,
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation: _propTypes.default.oneOf(['horizontal', 'vertical']),
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_propTypes.default.oneOf(['small', 'medium', 'large']), _propTypes.default.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
+  /**
+   * The currently selected value within the group or an array of selected
+   * values when `exclusive` is false.
+   *
+   * The value must have reference equality with the option in order to be selected.
+   */
+  value: _propTypes.default.any
+} : void 0;
+var _default = exports.default = ToggleButtonGroup;

node_modules/@mui/material/Toolbar/toolbarClasses.d.ts

@@ -0,0 +1,14 @@
+export interface ToolbarClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element unless `disableGutters={true}`. */
+  gutters: string;
+  /** Styles applied to the root element if `variant="regular"`. */
+  regular: string;
+  /** Styles applied to the root element if `variant="dense"`. */
+  dense: string;
+}
+export type ToolbarClassKey = keyof ToolbarClasses;
+export declare function getToolbarUtilityClass(slot: string): string;
+declare const toolbarClasses: ToolbarClasses;
+export default toolbarClasses;

node_modules/@mui/material/Tooltip/Tooltip.d.ts

@@ -0,0 +1,230 @@
+import * as React from 'react';
+import { MUIStyledCommonProps, SxProps } from '@mui/system';
+import { PopperProps } from "../Popper/index.js";
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+import { TransitionProps } from "../transitions/transition.js";
+import { TooltipClasses } from "./tooltipClasses.js";
+export interface TooltipComponentsPropsOverrides {}
+export interface TooltipPopperSlotPropsOverrides {}
+export interface TooltipTransitionSlotPropsOverrides {}
+export interface TooltipTooltipSlotPropsOverrides {}
+export interface TooltipArrowSlotPropsOverrides {}
+export interface TooltipSlots {
+  /**
+   * The component used for the popper.
+   * @default Popper
+   */
+  popper: React.ElementType;
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Grow
+   */
+  transition: React.ElementType;
+  /**
+   * The component used for the tooltip.
+   */
+  tooltip: React.ElementType;
+  /**
+   * The component used for the arrow.
+   */
+  arrow: React.ElementType;
+}
+export type TooltipSlotsAndSlotProps = CreateSlotsAndSlotProps<TooltipSlots, {
+  /**
+   * Props forwarded to the popper slot.
+   * By default, the available props are based on the [Popper](https://mui.com/material-ui/api/popper/#props) component.
+   */
+  popper: SlotProps<React.ElementType<PopperProps>, TooltipPopperSlotPropsOverrides, TooltipOwnerState>;
+  /**
+   * Props forwarded to the transition slot.
+   * By default, the available props are based on the [Grow](https://mui.com/material-ui/api/grow/#props) component.
+   */
+  transition: SlotProps<React.ElementType, TransitionProps & TooltipTransitionSlotPropsOverrides, TooltipOwnerState>;
+  /**
+   * Props forwarded to the tooltip slot.
+   * By default, the available props are based on the div element.
+   */
+  tooltip: SlotProps<'div', TooltipTooltipSlotPropsOverrides, TooltipOwnerState>;
+  /**
+   * Props forwarded to the tooltip slot.
+   * By default, the available props are based on the span element.
+   */
+  arrow: SlotProps<'span', TooltipArrowSlotPropsOverrides, TooltipOwnerState>;
+}>;
+export interface TooltipProps extends StandardProps<React.HTMLAttributes<HTMLDivElement>, 'title'>, TooltipSlotsAndSlotProps {
+  /**
+   * If `true`, adds an arrow to the tooltip.
+   * @default false
+   */
+  arrow?: boolean;
+  /**
+   * Tooltip reference element.
+   */
+  children: React.ReactElement<unknown, any>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<TooltipClasses>;
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components?: {
+    Popper?: React.ElementType<PopperProps>;
+    Transition?: React.ElementType;
+    Tooltip?: React.ElementType;
+    Arrow?: React.ElementType;
+  };
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps?: {
+    popper?: Partial<PopperProps> & TooltipComponentsPropsOverrides;
+    transition?: TransitionProps & TooltipComponentsPropsOverrides;
+    tooltip?: React.HTMLProps<HTMLDivElement> & MUIStyledCommonProps & TooltipComponentsPropsOverrides;
+    arrow?: React.HTMLProps<HTMLSpanElement> & MUIStyledCommonProps & TooltipComponentsPropsOverrides;
+  };
+  /**
+   * Set to `true` if the `title` acts as an accessible description.
+   * By default the `title` acts as an accessible label for the child.
+   * @default false
+   */
+  describeChild?: boolean;
+  /**
+   * Do not respond to focus-visible events.
+   * @default false
+   */
+  disableFocusListener?: boolean;
+  /**
+   * Do not respond to hover events.
+   * @default false
+   */
+  disableHoverListener?: boolean;
+  /**
+   * Makes a tooltip not interactive, i.e. it will close when the user
+   * hovers over the tooltip before the `leaveDelay` is expired.
+   * @default false
+   */
+  disableInteractive?: boolean;
+  /**
+   * Do not respond to long press touch events.
+   * @default false
+   */
+  disableTouchListener?: boolean;
+  /**
+   * The number of milliseconds to wait before showing the tooltip.
+   * This prop won't impact the enter touch delay (`enterTouchDelay`).
+   * @default 100
+   */
+  enterDelay?: number;
+  /**
+   * The number of milliseconds to wait before showing the tooltip when one was already recently opened.
+   * @default 0
+   */
+  enterNextDelay?: number;
+  /**
+   * The number of milliseconds a user must touch the element before showing the tooltip.
+   * @default 700
+   */
+  enterTouchDelay?: number;
+  /**
+   * If `true`, the tooltip follow the cursor over the wrapped element.
+   * @default false
+   */
+  followCursor?: boolean;
+  /**
+   * This prop is used to help implement the accessibility logic.
+   * If you don't provide this prop. It falls back to a randomly generated id.
+   */
+  id?: string;
+  /**
+   * The number of milliseconds to wait before hiding the tooltip.
+   * This prop won't impact the leave touch delay (`leaveTouchDelay`).
+   * @default 0
+   */
+  leaveDelay?: number;
+  /**
+   * The number of milliseconds after the user stops touching an element before hiding the tooltip.
+   * @default 1500
+   */
+  leaveTouchDelay?: number;
+  /**
+   * Callback fired when the component requests to be closed.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   */
+  onClose?: (event: React.SyntheticEvent | Event) => void;
+  /**
+   * Callback fired when the component requests to be open.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   */
+  onOpen?: (event: React.SyntheticEvent) => void;
+  /**
+   * If `true`, the component is shown.
+   */
+  open?: boolean;
+  /**
+   * Tooltip placement.
+   * @default 'bottom'
+   */
+  placement?: PopperProps['placement'];
+  /**
+   * The component used for the popper.
+   * @deprecated use the `slots.popper` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  PopperComponent?: React.JSXElementConstructor<PopperProps>;
+  /**
+   * Props applied to the [`Popper`](https://mui.com/material-ui/api/popper/) element.
+   * @deprecated use the `slotProps.popper` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   * @default {}
+   */
+  PopperProps?: Partial<PopperProps>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * Tooltip title. Zero-length titles string, undefined, null and false are never displayed.
+   */
+  title: React.ReactNode;
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @deprecated use the `slots.transition` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  TransitionComponent?: React.JSXElementConstructor<TransitionProps & {
+    children: React.ReactElement<unknown, any>;
+  }>;
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   * @deprecated use the `slotProps.transition` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   * @default {}
+   */
+  TransitionProps?: TransitionProps;
+}
+export interface TooltipOwnerState extends TooltipProps {}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Tooltip](https://mui.com/material-ui/react-tooltip/)
+ *
+ * API:
+ *
+ * - [Tooltip API](https://mui.com/material-ui/api/tooltip/)
+ */
+export default function Tooltip(props: TooltipProps): React.JSX.Element;

node_modules/@mui/material/Typography/typographyClasses.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getTypographyUtilityClass = getTypographyUtilityClass;
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+function getTypographyUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiTypography', slot);
+}
+const typographyClasses = (0, _generateUtilityClasses.default)('MuiTypography', ['root', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'subtitle1', 'subtitle2', 'body1', 'body2', 'inherit', 'button', 'caption', 'overline', 'alignLeft', 'alignRight', 'alignCenter', 'alignJustify', 'noWrap', 'gutterBottom', 'paragraph']);
+var _default = exports.default = typographyClasses;

node_modules/@mui/material/Unstable_TrapFocus/FocusTrap.types.js

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

node_modules/@mui/material/Unstable_TrapFocus/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./FocusTrap.js";
+export { FocusTrapProps as TrapFocusProps } from "./FocusTrap.types.js";

node_modules/@mui/material/colors/deepPurple.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const deepPurple = {
+  50: '#ede7f6',
+  100: '#d1c4e9',
+  200: '#b39ddb',
+  300: '#9575cd',
+  400: '#7e57c2',
+  500: '#673ab7',
+  600: '#5e35b1',
+  700: '#512da8',
+  800: '#4527a0',
+  900: '#311b92',
+  A100: '#b388ff',
+  A200: '#7c4dff',
+  A400: '#651fff',
+  A700: '#6200ea'
+};
+var _default = exports.default = deepPurple;

node_modules/@mui/material/colors/indigo.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ![indigo 50](https://mui.com/static/colors-preview/indigo-50-24x24.png) ![indigo 100](https://mui.com/static/colors-preview/indigo-100-24x24.png) ![indigo 200](https://mui.com/static/colors-preview/indigo-200-24x24.png) ![indigo 300](https://mui.com/static/colors-preview/indigo-300-24x24.png) ![indigo 400](https://mui.com/static/colors-preview/indigo-400-24x24.png) ![indigo 500](https://mui.com/static/colors-preview/indigo-500-24x24.png) ![indigo 600](https://mui.com/static/colors-preview/indigo-600-24x24.png) ![indigo 700](https://mui.com/static/colors-preview/indigo-700-24x24.png) ![indigo 800](https://mui.com/static/colors-preview/indigo-800-24x24.png) ![indigo 900](https://mui.com/static/colors-preview/indigo-900-24x24.png) ![indigo A100](https://mui.com/static/colors-preview/indigo-A100-24x24.png) ![indigo A200](https://mui.com/static/colors-preview/indigo-A200-24x24.png) ![indigo A400](https://mui.com/static/colors-preview/indigo-A400-24x24.png) ![indigo A700](https://mui.com/static/colors-preview/indigo-A700-24x24.png)
+ */
+declare const indigo: {
+  /**
+   * Preview: ![indigo 50](https://mui.com/static/colors-preview/indigo-50-24x24.png)
+   */
+  50: '#e8eaf6';
+  /**
+   * Preview: ![indigo 100](https://mui.com/static/colors-preview/indigo-100-24x24.png)
+   */
+  100: '#c5cae9';
+  /**
+   * Preview: ![indigo 200](https://mui.com/static/colors-preview/indigo-200-24x24.png)
+   */
+  200: '#9fa8da';
+  /**
+   * Preview: ![indigo 300](https://mui.com/static/colors-preview/indigo-300-24x24.png)
+   */
+  300: '#7986cb';
+  /**
+   * Preview: ![indigo 400](https://mui.com/static/colors-preview/indigo-400-24x24.png)
+   */
+  400: '#5c6bc0';
+  /**
+   * Preview: ![indigo 500](https://mui.com/static/colors-preview/indigo-500-24x24.png)
+   */
+  500: '#3f51b5';
+  /**
+   * Preview: ![indigo 600](https://mui.com/static/colors-preview/indigo-600-24x24.png)
+   */
+  600: '#3949ab';
+  /**
+   * Preview: ![indigo 700](https://mui.com/static/colors-preview/indigo-700-24x24.png)
+   */
+  700: '#303f9f';
+  /**
+   * Preview: ![indigo 800](https://mui.com/static/colors-preview/indigo-800-24x24.png)
+   */
+  800: '#283593';
+  /**
+   * Preview: ![indigo 900](https://mui.com/static/colors-preview/indigo-900-24x24.png)
+   */
+  900: '#1a237e';
+  /**
+   * Preview: ![indigo A100](https://mui.com/static/colors-preview/indigo-A100-24x24.png)
+   */
+  A100: '#8c9eff';
+  /**
+   * Preview: ![indigo A200](https://mui.com/static/colors-preview/indigo-A200-24x24.png)
+   */
+  A200: '#536dfe';
+  /**
+   * Preview: ![indigo A400](https://mui.com/static/colors-preview/indigo-A400-24x24.png)
+   */
+  A400: '#3d5afe';
+  /**
+   * Preview: ![indigo A700](https://mui.com/static/colors-preview/indigo-A700-24x24.png)
+   */
+  A700: '#304ffe';
+};
+export default indigo;

node_modules/@mui/material/colors/pink.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const pink = {
+  50: '#fce4ec',
+  100: '#f8bbd0',
+  200: '#f48fb1',
+  300: '#f06292',
+  400: '#ec407a',
+  500: '#e91e63',
+  600: '#d81b60',
+  700: '#c2185b',
+  800: '#ad1457',
+  900: '#880e4f',
+  A100: '#ff80ab',
+  A200: '#ff4081',
+  A400: '#f50057',
+  A700: '#c51162'
+};
+var _default = exports.default = pink;

node_modules/@mui/material/darkScrollbar/index.d.ts

@@ -0,0 +1,28 @@
+export default function darkScrollbar(options?: {
+  track: string;
+  thumb: string;
+  active: string;
+}): {
+  scrollbarColor: string;
+  '&::-webkit-scrollbar, & *::-webkit-scrollbar': {
+    backgroundColor: string;
+  };
+  '&::-webkit-scrollbar-thumb, & *::-webkit-scrollbar-thumb': {
+    borderRadius: number;
+    backgroundColor: string;
+    minHeight: number;
+    border: string;
+  };
+  '&::-webkit-scrollbar-thumb:focus, & *::-webkit-scrollbar-thumb:focus': {
+    backgroundColor: string;
+  };
+  '&::-webkit-scrollbar-thumb:active, & *::-webkit-scrollbar-thumb:active': {
+    backgroundColor: string;
+  };
+  '&::-webkit-scrollbar-thumb:hover, & *::-webkit-scrollbar-thumb:hover': {
+    backgroundColor: string;
+  };
+  '&::-webkit-scrollbar-corner, & *::-webkit-scrollbar-corner': {
+    backgroundColor: string;
+  };
+};

node_modules/@mui/material/esm/AccordionActions/accordionActionsClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getAccordionActionsUtilityClass(slot) {
+  return generateUtilityClass('MuiAccordionActions', slot);
+}
+const accordionActionsClasses = generateUtilityClasses('MuiAccordionActions', ['root', 'spacing']);
+export default accordionActionsClasses;

node_modules/@mui/material/esm/AccordionDetails/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./AccordionDetails.js";
+export * from "./AccordionDetails.js";
+export { default as accordionDetailsClasses } from "./accordionDetailsClasses.js";
+export * from "./accordionDetailsClasses.js";

node_modules/@mui/material/esm/AppBar/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./AppBar.js";
+export * from "./AppBar.js";
+export { default as appBarClasses } from "./appBarClasses.js";
+export * from "./appBarClasses.js";

node_modules/@mui/material/esm/Autocomplete/autocompleteClasses.d.ts

@@ -0,0 +1,58 @@
+export interface AutocompleteClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `fullWidth={true}`. */
+  fullWidth: string;
+  /** State class applied to the root element if the listbox is displayed. */
+  expanded: string;
+  /** State class applied to the root element if focused. */
+  focused: string;
+  /** Styles applied to the option elements if they are keyboard focused. */
+  focusVisible: string;
+  /** Styles applied to the tag elements, for example the chips. */
+  tag: string;
+  /** Styles applied to the tag elements, for example the chips if `size="small"`. */
+  tagSizeSmall: string;
+  /** Styles applied to the tag elements, for example the chips if `size="medium"`. */
+  tagSizeMedium: string;
+  /** Styles applied when the popup icon is rendered. */
+  hasPopupIcon: string;
+  /** Styles applied when the clear icon is rendered. */
+  hasClearIcon: string;
+  /** Styles applied to the Input element. */
+  inputRoot: string;
+  /** Styles applied to the input element. */
+  input: string;
+  /** Styles applied to the input element if the input is focused. */
+  inputFocused: string;
+  /** Styles applied to the endAdornment element. */
+  endAdornment: string;
+  /** Styles applied to the clear indicator. */
+  clearIndicator: string;
+  /** Styles applied to the popup indicator. */
+  popupIndicator: string;
+  /** Styles applied to the popup indicator if the popup is open. */
+  popupIndicatorOpen: string;
+  /** Styles applied to the popper element. */
+  popper: string;
+  /** Styles applied to the popper element if `disablePortal={true}`. */
+  popperDisablePortal: string;
+  /** Styles applied to the Paper component. */
+  paper: string;
+  /** Styles applied to the listbox component. */
+  listbox: string;
+  /** Styles applied to the loading wrapper. */
+  loading: string;
+  /** Styles applied to the no option wrapper. */
+  noOptions: string;
+  /** Styles applied to the option elements. */
+  option: string;
+  /** Styles applied to the group's label elements. */
+  groupLabel: string;
+  /** Styles applied to the group's ul elements. */
+  groupUl: string;
+}
+export type AutocompleteClassKey = keyof AutocompleteClasses;
+export declare function getAutocompleteUtilityClass(slot: string): string;
+declare const autocompleteClasses: AutocompleteClasses;
+export default autocompleteClasses;

node_modules/@mui/material/esm/Avatar/Avatar.d.ts

@@ -0,0 +1,112 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { OverridableStringUnion } from '@mui/types';
+import { Theme } from "../styles/index.js";
+import { OverridableComponent, OverrideProps } from "../OverridableComponent/index.js";
+import { AvatarClasses } from "./avatarClasses.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+import { SvgIconProps } from "../SvgIcon/index.js";
+export interface AvatarSlots {
+  /**
+   * The component that renders the root slot.
+   * @default 'div'
+   */
+  root: React.ElementType;
+  /**
+   * The component that renders the img slot.
+   * @default 'img'
+   */
+  img: React.ElementType;
+  /**
+   * The component that renders the fallback slot.
+   * @default Person icon
+   */
+  fallback: React.ElementType;
+}
+export interface AvatarPropsVariantOverrides {}
+export interface AvatarRootSlotPropsOverrides {}
+export interface AvatarImgSlotPropsOverrides {}
+export interface AvatarFallbackSlotPropsOverrides {}
+export type AvatarSlotsAndSlotProps = CreateSlotsAndSlotProps<AvatarSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on the div element.
+   */
+  root: SlotProps<'div', AvatarRootSlotPropsOverrides, AvatarOwnProps>;
+  /**
+   * Props forwarded to the img slot.
+   * By default, the available props are based on the img element.
+   */
+  img: SlotProps<'img', AvatarImgSlotPropsOverrides, AvatarOwnProps>;
+  /**
+   * Props forwarded to the fallback slot.
+   * By default, the available props are based on the [SvgIcon](https://mui.com/material-ui/api/svg-icon/#props) component.
+   */
+  fallback: SlotProps<React.ElementType<SvgIconProps>, AvatarFallbackSlotPropsOverrides, AvatarOwnProps>;
+}>;
+export interface AvatarOwnProps {
+  /**
+   * Used in combination with `src` or `srcSet` to
+   * provide an alt attribute for the rendered `img` element.
+   */
+  alt?: string;
+  /**
+   * Used to render icon or text elements inside the Avatar if `src` is not set.
+   * This can be an element, or just a string.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<AvatarClasses>;
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/img#attributes) applied to the `img` element if the component is used to display an image.
+   * It can be used to listen for the loading error event.
+   * @deprecated Use `slotProps.img` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  imgProps?: React.ImgHTMLAttributes<HTMLImageElement> & {
+    sx?: SxProps<Theme>;
+  };
+  /**
+   * The `sizes` attribute for the `img` element.
+   */
+  sizes?: string;
+  /**
+   * The `src` attribute for the `img` element.
+   */
+  src?: string;
+  /**
+   * The `srcSet` attribute for the `img` element.
+   * Use this attribute for responsive image display.
+   */
+  srcSet?: string;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * The shape of the avatar.
+   * @default 'circular'
+   */
+  variant?: OverridableStringUnion<'circular' | 'rounded' | 'square', AvatarPropsVariantOverrides>;
+}
+export interface AvatarTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> {
+  props: AdditionalProps & AvatarOwnProps & AvatarSlotsAndSlotProps;
+  defaultComponent: RootComponent;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Avatar](https://mui.com/material-ui/react-avatar/)
+ *
+ * API:
+ *
+ * - [Avatar API](https://mui.com/material-ui/api/avatar/)
+ */
+declare const Avatar: OverridableComponent<AvatarTypeMap>;
+export type AvatarProps<RootComponent extends React.ElementType = AvatarTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<AvatarTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default Avatar;

node_modules/@mui/material/esm/Badge/badgeClasses.js

@@ -0,0 +1,9 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getBadgeUtilityClass(slot) {
+  return generateUtilityClass('MuiBadge', slot);
+}
+const badgeClasses = generateUtilityClasses('MuiBadge', ['root', 'badge', 'dot', 'standard', 'anchorOriginTopRight', 'anchorOriginBottomRight', 'anchorOriginTopLeft', 'anchorOriginBottomLeft', 'invisible', 'colorError', 'colorInfo', 'colorPrimary', 'colorSecondary', 'colorSuccess', 'colorWarning', 'overlapRectangular', 'overlapCircular',
+// TODO: v6 remove the overlap value from these class keys
+'anchorOriginTopLeftCircular', 'anchorOriginTopLeftRectangular', 'anchorOriginTopRightCircular', 'anchorOriginTopRightRectangular', 'anchorOriginBottomLeftCircular', 'anchorOriginBottomLeftRectangular', 'anchorOriginBottomRightCircular', 'anchorOriginBottomRightRectangular']);
+export default badgeClasses;

node_modules/@mui/material/esm/BottomNavigationAction/index.js

@@ -0,0 +1,3 @@
+export { default } from "./BottomNavigationAction.js";
+export { default as bottomNavigationActionClasses } from "./bottomNavigationActionClasses.js";
+export * from "./bottomNavigationActionClasses.js";

node_modules/@mui/material/esm/Box/index.js

@@ -0,0 +1,3 @@
+export { default } from "./Box.js";
+export { default as boxClasses } from "./boxClasses.js";
+export * from "./boxClasses.js";

node_modules/@mui/material/esm/Breadcrumbs/breadcrumbsClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getBreadcrumbsUtilityClass(slot) {
+  return generateUtilityClass('MuiBreadcrumbs', slot);
+}
+const breadcrumbsClasses = generateUtilityClasses('MuiBreadcrumbs', ['root', 'ol', 'li', 'separator']);
+export default breadcrumbsClasses;

node_modules/@mui/material/esm/Card/index.js

@@ -0,0 +1,3 @@
+export { default } from "./Card.js";
+export { default as cardClasses } from "./cardClasses.js";
+export * from "./cardClasses.js";

node_modules/@mui/material/esm/CardContent/CardContent.d.ts

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { OverridableComponent, OverrideProps } from "../OverridableComponent/index.js";
+import { Theme } from "../styles/index.js";
+import { CardContentClasses } from "./cardContentClasses.js";
+export interface CardContentOwnProps {
+  /**
+   * The content of the component.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<CardContentClasses>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export interface CardContentTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> {
+  props: AdditionalProps & CardContentOwnProps;
+  defaultComponent: RootComponent;
+}
+/**
+ *
+ * Demos:
+ *
+ * - [Card](https://mui.com/material-ui/react-card/)
+ *
+ * API:
+ *
+ * - [CardContent API](https://mui.com/material-ui/api/card-content/)
+ */
+declare const CardContent: OverridableComponent<CardContentTypeMap>;
+export type CardContentProps<RootComponent extends React.ElementType = CardContentTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<CardContentTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default CardContent;

node_modules/@mui/material/esm/CardContent/CardContent.js

@@ -0,0 +1,79 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import composeClasses from '@mui/utils/composeClasses';
+import { styled } from "../zero-styled/index.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import { getCardContentUtilityClass } from "./cardContentClasses.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root']
+  };
+  return composeClasses(slots, getCardContentUtilityClass, classes);
+};
+const CardContentRoot = styled('div', {
+  name: 'MuiCardContent',
+  slot: 'Root'
+})({
+  padding: 16,
+  '&:last-child': {
+    paddingBottom: 24
+  }
+});
+const CardContent = /*#__PURE__*/React.forwardRef(function CardContent(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: 'MuiCardContent'
+  });
+  const {
+    className,
+    component = 'div',
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    component
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(CardContentRoot, {
+    as: component,
+    className: clsx(classes.root, className),
+    ownerState: ownerState,
+    ref: ref,
+    ...other
+  });
+});
+process.env.NODE_ENV !== "production" ? CardContent.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * 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])
+} : void 0;
+export default CardContent;

node_modules/@mui/material/esm/CardContent/cardContentClasses.d.ts

@@ -0,0 +1,8 @@
+export interface CardContentClasses {
+  /** Styles applied to the root element. */
+  root: string;
+}
+export type CardContentClassKey = keyof CardContentClasses;
+export declare function getCardContentUtilityClass(slot: string): string;
+declare const cardContentClasses: CardContentClasses;
+export default cardContentClasses;

node_modules/@mui/material/esm/Chip/Chip.d.ts

@@ -0,0 +1,133 @@
+import * as React from 'react';
+import { OverridableStringUnion } from '@mui/types';
+import { SxProps } from '@mui/system';
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+import { Theme } from "../styles/index.js";
+import { OverridableComponent, OverrideProps } from "../OverridableComponent/index.js";
+import { ChipClasses } from "./chipClasses.js";
+export interface ChipSlots {
+  /**
+   * The component that renders the root.
+   * @default div
+   */
+  root: React.ElementType;
+  /**
+   * The component that renders the label.
+   * @default span
+   */
+  label: React.ElementType;
+}
+export type ChipSlotsAndSlotProps = CreateSlotsAndSlotProps<ChipSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on the div element.
+   */
+  root: SlotProps<'div', {}, ChipOwnerState>;
+  /**
+   * Props forwarded to the label slot.
+   * By default, the available props are based on the span element.
+   */
+  label: SlotProps<'span', {}, ChipOwnerState>;
+}>;
+export interface ChipOwnerState extends Omit<ChipProps, 'slots' | 'slotProps'> {}
+export interface ChipPropsVariantOverrides {}
+export interface ChipPropsSizeOverrides {}
+export interface ChipPropsColorOverrides {}
+export interface ChipOwnProps {
+  /**
+   * The Avatar element to display.
+   */
+  avatar?: React.ReactElement<unknown>;
+  /**
+   * This prop isn't supported.
+   * Use the `component` prop if you need to change the children structure.
+   */
+  children?: null;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<ChipClasses>;
+  /**
+   * If `true`, the chip will appear clickable, and will raise when pressed,
+   * even if the onClick prop is not defined.
+   * If `false`, the chip will not appear clickable, even if onClick prop is defined.
+   * This can be used, for example,
+   * along with the component prop to indicate an anchor Chip is clickable.
+   * Note: this controls the UI and does not affect the onClick event.
+   */
+  clickable?: boolean;
+  /**
+   * 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 'default'
+   */
+  color?: OverridableStringUnion<'default' | 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning', ChipPropsColorOverrides>;
+  /**
+   * Override the default delete icon element. Shown only if `onDelete` is set.
+   */
+  deleteIcon?: React.ReactElement<unknown>;
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * Icon element.
+   */
+  icon?: React.ReactElement<unknown>;
+  /**
+   * The content of the component.
+   */
+  label?: React.ReactNode;
+  /**
+   * Callback fired when the delete icon is clicked.
+   * If set, the delete icon will be shown.
+   */
+  onDelete?: React.EventHandler<any>;
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size?: OverridableStringUnion<'small' | 'medium', ChipPropsSizeOverrides>;
+  /**
+   * If `true`, allows the disabled chip to escape focus.
+   * If `false`, allows the disabled chip to receive focus.
+   * @default false
+   */
+  skipFocusWhenDisabled?: boolean;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   *  @ignore
+   */
+  tabIndex?: number;
+  /**
+   * The variant to use.
+   * @default 'filled'
+   */
+  variant?: OverridableStringUnion<'filled' | 'outlined', ChipPropsVariantOverrides>;
+}
+export interface ChipTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> {
+  props: AdditionalProps & ChipOwnProps & ChipSlotsAndSlotProps;
+  defaultComponent: RootComponent;
+}
+
+/**
+ * Chips represent complex entities in small blocks, such as a contact.
+ *
+ * Demos:
+ *
+ * - [Chip](https://mui.com/material-ui/react-chip/)
+ *
+ * API:
+ *
+ * - [Chip API](https://mui.com/material-ui/api/chip/)
+ */
+declare const Chip: OverridableComponent<ChipTypeMap>;
+export type ChipProps<RootComponent extends React.ElementType = ChipTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<ChipTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default Chip;

node_modules/@mui/material/esm/Chip/chipClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getChipUtilityClass(slot) {
+  return generateUtilityClass('MuiChip', slot);
+}
+const chipClasses = generateUtilityClasses('MuiChip', ['root', 'sizeSmall', 'sizeMedium', 'colorDefault', 'colorError', 'colorInfo', 'colorPrimary', 'colorSecondary', 'colorSuccess', 'colorWarning', 'disabled', 'clickable', 'clickableColorPrimary', 'clickableColorSecondary', 'deletable', 'deletableColorPrimary', 'deletableColorSecondary', 'outlined', 'filled', 'outlinedPrimary', 'outlinedSecondary', 'filledPrimary', 'filledSecondary', 'avatar', 'avatarSmall', 'avatarMedium', 'avatarColorPrimary', 'avatarColorSecondary', 'icon', 'iconSmall', 'iconMedium', 'iconColorPrimary', 'iconColorSecondary', 'label', 'labelSmall', 'labelMedium', 'deleteIcon', 'deleteIconSmall', 'deleteIconMedium', 'deleteIconColorPrimary', 'deleteIconColorSecondary', 'deleteIconOutlinedColorPrimary', 'deleteIconOutlinedColorSecondary', 'deleteIconFilledColorPrimary', 'deleteIconFilledColorSecondary', 'focusVisible']);
+export default chipClasses;

node_modules/@mui/material/esm/Collapse/collapseClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getCollapseUtilityClass(slot) {
+  return generateUtilityClass('MuiCollapse', slot);
+}
+const collapseClasses = generateUtilityClasses('MuiCollapse', ['root', 'horizontal', 'vertical', 'entered', 'hidden', 'wrapper', 'wrapperInner']);
+export default collapseClasses;

node_modules/@mui/material/esm/Dialog/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Dialog.js";
+export * from "./Dialog.js";
+export { default as dialogClasses } from "./dialogClasses.js";
+export * from "./dialogClasses.js";

node_modules/@mui/material/esm/DialogContentText/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./DialogContentText.js";
+export * from "./DialogContentText.js";
+export { default as dialogContentTextClasses } from "./dialogContentTextClasses.js";
+export * from "./dialogContentTextClasses.js";

node_modules/@mui/material/esm/Drawer/drawerClasses.d.ts

@@ -0,0 +1,54 @@
+export interface DrawerClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `variant="permanent or persistent"`. */
+  docked: string;
+  /** Styles applied to the Paper component. */
+  paper: string;
+  /** Styles applied to the root element if `anchor="left"`. */
+  anchorLeft: string;
+  /** Styles applied to the root element if `anchor="right"`. */
+  anchorRight: string;
+  /** Styles applied to the root element if `anchor="top"`. */
+  anchorTop: string;
+  /** Styles applied to the root element if `anchor="bottom"`. */
+  anchorBottom: string;
+  /** Styles applied to the Paper component if `anchor="left"`.
+   *  @deprecated Combine the [.MuiDrawer-anchorLeft](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorLeft) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorLeft: string;
+  /** Styles applied to the Paper component if `anchor="right"`.
+   *  @deprecated Combine the [.MuiDrawer-anchorRight](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorRight) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorRight: string;
+  /** Styles applied to the Paper component if `anchor="top"`.
+   *  @deprecated Combine the [.MuiDrawer-anchorTop](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorTop) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorTop: string;
+  /** Styles applied to the Paper component if `anchor="bottom"`.
+   *  @deprecated Combine the [.MuiDrawer-anchorBottom](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorBottom) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorBottom: string;
+  /** Styles applied to the Paper component if `anchor="left"` and `variant` is not "temporary".
+   * @deprecated Combine the [.MuiDrawer-anchorLeft](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorLeft), [.MuiDrawer-docked](/material-ui/api/drawer/#Drawer-css-MuiDrawer-docked) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorDockedLeft: string;
+  /** Styles applied to the Paper component if `anchor="top"` and `variant` is not "temporary".
+   * @deprecated Combine the [.MuiDrawer-anchorTop](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorTop), [.MuiDrawer-docked](/material-ui/api/drawer/#Drawer-css-MuiDrawer-docked) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorDockedTop: string;
+  /** Styles applied to the Paper component if `anchor="right"` and `variant` is not "temporary".
+   * @deprecated Combine the [.MuiDrawer-anchorRight](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorRight), [.MuiDrawer-docked](/material-ui/api/drawer/#Drawer-css-MuiDrawer-docked) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorDockedRight: string;
+  /** Styles applied to the Paper component if `anchor="bottom"` and `variant` is not "temporary".
+   * @deprecated Combine the [.MuiDrawer-anchorBottom](/material-ui/api/drawer/#drawer-classes-MuiDrawer-anchorBottom), [.MuiDrawer-docked](/material-ui/api/drawer/#Drawer-css-MuiDrawer-docked) and [.MuiDrawer-paper](/material-ui/api/drawer/#Drawer-css-MuiDrawer-paper) classes instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  paperAnchorDockedBottom: string;
+  /** Styles applied to the Modal component. */
+  modal: string;
+}
+export type DrawerClassKey = keyof DrawerClasses;
+export declare function getDrawerUtilityClass(slot: string): string;
+declare const drawerClasses: DrawerClasses;
+export default drawerClasses;

node_modules/@mui/material/esm/FormGroup/FormGroup.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { InternalStandardProps as StandardProps } from "../internal/index.js";
+import { FormGroupClasses } from "./formGroupClasses.js";
+export interface FormGroupProps extends StandardProps<React.HTMLAttributes<HTMLDivElement>> {
+  /**
+   * The content of the component.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<FormGroupClasses>;
+  /**
+   * Display group of elements in a compact row.
+   * @default false
+   */
+  row?: boolean;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+
+/**
+ * `FormGroup` wraps controls such as `Checkbox` and `Switch`.
+ * It provides compact row layout.
+ * For the `Radio`, you should be using the `RadioGroup` component instead of this one.
+ *
+ * Demos:
+ *
+ * - [Checkbox](https://mui.com/material-ui/react-checkbox/)
+ * - [Switch](https://mui.com/material-ui/react-switch/)
+ *
+ * API:
+ *
+ * - [FormGroup API](https://mui.com/material-ui/api/form-group/)
+ */
+export default function FormGroup(props: FormGroupProps): React.JSX.Element;

node_modules/@mui/material/esm/GridLegacy/GridLegacy.js

@@ -0,0 +1,588 @@
+'use client';
+
+// A grid component using the following libs as inspiration.
+//
+// For the implementation:
+// - https://getbootstrap.com/docs/4.3/layout/grid/
+// - https://github.com/kristoferjoseph/flexboxgrid/blob/master/src/css/flexboxgrid.css
+// - https://github.com/roylee0704/react-flexbox-grid
+// - https://material.angularjs.org/latest/layout/introduction
+//
+// Follow this flexbox Guide to better understand the underlying model:
+// - https://css-tricks.com/snippets/css/a-guide-to-flexbox/
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import { handleBreakpoints, unstable_resolveBreakpointValues as resolveBreakpointValues } from '@mui/system';
+import { extendSxProp } from '@mui/system/styleFunctionSx';
+import composeClasses from '@mui/utils/composeClasses';
+import requirePropFactory from "../utils/requirePropFactory.js";
+import styled from "../styles/styled.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import useTheme from "../styles/useTheme.js";
+import GridLegacyContext from "./GridLegacyContext.js";
+import gridLegacyClasses, { getGridLegacyUtilityClass } from "./gridLegacyClasses.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+let warnedOnce = false;
+function warnAboutDeprecatedGridLegacy() {
+  if (!warnedOnce && process.env.NODE_ENV === 'development') {
+    warnedOnce = true;
+    console.warn('MUI: The GridLegacy component is deprecated. See https://mui.com/material-ui/migration/upgrade-to-grid-v2/ for migration instructions.\n');
+  }
+}
+export function generateGridLegacy({
+  theme,
+  ownerState
+}) {
+  let size;
+  return theme.breakpoints.keys.reduce((globalStyles, breakpoint) => {
+    // Use side effect over immutability for better performance.
+    let styles = {};
+    if (ownerState[breakpoint]) {
+      size = ownerState[breakpoint];
+    }
+    if (!size) {
+      return globalStyles;
+    }
+    if (size === true) {
+      // For the auto layouting
+      styles = {
+        flexBasis: 0,
+        flexGrow: 1,
+        maxWidth: '100%'
+      };
+    } else if (size === 'auto') {
+      styles = {
+        flexBasis: 'auto',
+        flexGrow: 0,
+        flexShrink: 0,
+        maxWidth: 'none',
+        width: 'auto'
+      };
+    } else {
+      const columnsBreakpointValues = resolveBreakpointValues({
+        values: ownerState.columns,
+        breakpoints: theme.breakpoints.values
+      });
+      const columnValue = typeof columnsBreakpointValues === 'object' ? columnsBreakpointValues[breakpoint] : columnsBreakpointValues;
+      if (columnValue === undefined || columnValue === null) {
+        return globalStyles;
+      }
+      // Keep 7 significant numbers.
+      const width = `${Math.round(size / columnValue * 10e7) / 10e5}%`;
+      let more = {};
+      if (ownerState.container && ownerState.item && ownerState.columnSpacing !== 0) {
+        const themeSpacing = theme.spacing(ownerState.columnSpacing);
+        if (themeSpacing !== '0px') {
+          const fullWidth = `calc(${width} + ${themeSpacing})`;
+          more = {
+            flexBasis: fullWidth,
+            maxWidth: fullWidth
+          };
+        }
+      }
+
+      // Close to the bootstrap implementation:
+      // https://github.com/twbs/bootstrap/blob/8fccaa2439e97ec72a4b7dc42ccc1f649790adb0/scss/mixins/_grid.scss#L41
+      styles = {
+        flexBasis: width,
+        flexGrow: 0,
+        maxWidth: width,
+        ...more
+      };
+    }
+
+    // No need for a media query for the first size.
+    if (theme.breakpoints.values[breakpoint] === 0) {
+      Object.assign(globalStyles, styles);
+    } else {
+      globalStyles[theme.breakpoints.up(breakpoint)] = styles;
+    }
+    return globalStyles;
+  }, {});
+}
+export function generateDirection({
+  theme,
+  ownerState
+}) {
+  const directionValues = resolveBreakpointValues({
+    values: ownerState.direction,
+    breakpoints: theme.breakpoints.values
+  });
+  return handleBreakpoints({
+    theme
+  }, directionValues, propValue => {
+    const output = {
+      flexDirection: propValue
+    };
+    if (propValue.startsWith('column')) {
+      output[`& > .${gridLegacyClasses.item}`] = {
+        maxWidth: 'none'
+      };
+    }
+    return output;
+  });
+}
+
+/**
+ * Extracts zero value breakpoint keys before a non-zero value breakpoint key.
+ * @example { xs: 0, sm: 0, md: 2, lg: 0, xl: 0 } or [0, 0, 2, 0, 0]
+ * @returns [xs, sm]
+ */
+function extractZeroValueBreakpointKeys({
+  breakpoints,
+  values
+}) {
+  let nonZeroKey = '';
+  Object.keys(values).forEach(key => {
+    if (nonZeroKey !== '') {
+      return;
+    }
+    if (values[key] !== 0) {
+      nonZeroKey = key;
+    }
+  });
+  const sortedBreakpointKeysByValue = Object.keys(breakpoints).sort((a, b) => {
+    return breakpoints[a] - breakpoints[b];
+  });
+  return sortedBreakpointKeysByValue.slice(0, sortedBreakpointKeysByValue.indexOf(nonZeroKey));
+}
+export function generateRowGap({
+  theme,
+  ownerState
+}) {
+  const {
+    container,
+    rowSpacing
+  } = ownerState;
+  let styles = {};
+  if (container && rowSpacing !== 0) {
+    const rowSpacingValues = resolveBreakpointValues({
+      values: rowSpacing,
+      breakpoints: theme.breakpoints.values
+    });
+    let zeroValueBreakpointKeys;
+    if (typeof rowSpacingValues === 'object') {
+      zeroValueBreakpointKeys = extractZeroValueBreakpointKeys({
+        breakpoints: theme.breakpoints.values,
+        values: rowSpacingValues
+      });
+    }
+    styles = handleBreakpoints({
+      theme
+    }, rowSpacingValues, (propValue, breakpoint) => {
+      const themeSpacing = theme.spacing(propValue);
+      if (themeSpacing !== '0px') {
+        return {
+          marginTop: `calc(-1 * ${themeSpacing})`,
+          [`& > .${gridLegacyClasses.item}`]: {
+            paddingTop: themeSpacing
+          }
+        };
+      }
+      if (zeroValueBreakpointKeys?.includes(breakpoint)) {
+        return {};
+      }
+      return {
+        marginTop: 0,
+        [`& > .${gridLegacyClasses.item}`]: {
+          paddingTop: 0
+        }
+      };
+    });
+  }
+  return styles;
+}
+export function generateColumnGap({
+  theme,
+  ownerState
+}) {
+  const {
+    container,
+    columnSpacing
+  } = ownerState;
+  let styles = {};
+  if (container && columnSpacing !== 0) {
+    const columnSpacingValues = resolveBreakpointValues({
+      values: columnSpacing,
+      breakpoints: theme.breakpoints.values
+    });
+    let zeroValueBreakpointKeys;
+    if (typeof columnSpacingValues === 'object') {
+      zeroValueBreakpointKeys = extractZeroValueBreakpointKeys({
+        breakpoints: theme.breakpoints.values,
+        values: columnSpacingValues
+      });
+    }
+    styles = handleBreakpoints({
+      theme
+    }, columnSpacingValues, (propValue, breakpoint) => {
+      const themeSpacing = theme.spacing(propValue);
+      if (themeSpacing !== '0px') {
+        const negativeValue = `calc(-1 * ${themeSpacing})`;
+        return {
+          width: `calc(100% + ${themeSpacing})`,
+          marginLeft: negativeValue,
+          [`& > .${gridLegacyClasses.item}`]: {
+            paddingLeft: themeSpacing
+          }
+        };
+      }
+      if (zeroValueBreakpointKeys?.includes(breakpoint)) {
+        return {};
+      }
+      return {
+        width: '100%',
+        marginLeft: 0,
+        [`& > .${gridLegacyClasses.item}`]: {
+          paddingLeft: 0
+        }
+      };
+    });
+  }
+  return styles;
+}
+export function resolveSpacingStyles(spacing, breakpoints, styles = {}) {
+  // undefined/null or `spacing` <= 0
+  if (!spacing || spacing <= 0) {
+    return [];
+  }
+  // in case of string/number `spacing`
+  if (typeof spacing === 'string' && !Number.isNaN(Number(spacing)) || typeof spacing === 'number') {
+    return [styles[`spacing-xs-${String(spacing)}`]];
+  }
+  // in case of object `spacing`
+  const spacingStyles = [];
+  breakpoints.forEach(breakpoint => {
+    const value = spacing[breakpoint];
+    if (Number(value) > 0) {
+      spacingStyles.push(styles[`spacing-${breakpoint}-${String(value)}`]);
+    }
+  });
+  return spacingStyles;
+}
+
+// Default CSS values
+// flex: '0 1 auto',
+// flexDirection: 'row',
+// alignItems: 'flex-start',
+// flexWrap: 'nowrap',
+// justifyContent: 'flex-start',
+const GridLegacyRoot = styled('div', {
+  name: 'MuiGridLegacy',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    const {
+      container,
+      direction,
+      item,
+      spacing,
+      wrap,
+      zeroMinWidth,
+      breakpoints
+    } = ownerState;
+    let spacingStyles = [];
+
+    // in case of grid item
+    if (container) {
+      spacingStyles = resolveSpacingStyles(spacing, breakpoints, styles);
+    }
+    const breakpointsStyles = [];
+    breakpoints.forEach(breakpoint => {
+      const value = ownerState[breakpoint];
+      if (value) {
+        breakpointsStyles.push(styles[`grid-${breakpoint}-${String(value)}`]);
+      }
+    });
+    return [styles.root, container && styles.container, item && styles.item, zeroMinWidth && styles.zeroMinWidth, ...spacingStyles, direction !== 'row' && styles[`direction-xs-${String(direction)}`], wrap !== 'wrap' && styles[`wrap-xs-${String(wrap)}`], ...breakpointsStyles];
+  }
+})(
+// FIXME(romgrk): Can't use memoTheme here
+({
+  ownerState
+}) => ({
+  boxSizing: 'border-box',
+  ...(ownerState.container && {
+    display: 'flex',
+    flexWrap: 'wrap',
+    width: '100%'
+  }),
+  ...(ownerState.item && {
+    margin: 0 // For instance, it's useful when used with a `figure` element.
+  }),
+  ...(ownerState.zeroMinWidth && {
+    minWidth: 0
+  }),
+  ...(ownerState.wrap !== 'wrap' && {
+    flexWrap: ownerState.wrap
+  })
+}), generateDirection, generateRowGap, generateColumnGap, generateGridLegacy);
+export function resolveSpacingClasses(spacing, breakpoints) {
+  // undefined/null or `spacing` <= 0
+  if (!spacing || spacing <= 0) {
+    return [];
+  }
+  // in case of string/number `spacing`
+  if (typeof spacing === 'string' && !Number.isNaN(Number(spacing)) || typeof spacing === 'number') {
+    return [`spacing-xs-${String(spacing)}`];
+  }
+  // in case of object `spacing`
+  const classes = [];
+  breakpoints.forEach(breakpoint => {
+    const value = spacing[breakpoint];
+    if (Number(value) > 0) {
+      const className = `spacing-${breakpoint}-${String(value)}`;
+      classes.push(className);
+    }
+  });
+  return classes;
+}
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    container,
+    direction,
+    item,
+    spacing,
+    wrap,
+    zeroMinWidth,
+    breakpoints
+  } = ownerState;
+  let spacingClasses = [];
+
+  // in case of grid item
+  if (container) {
+    spacingClasses = resolveSpacingClasses(spacing, breakpoints);
+  }
+  const breakpointsClasses = [];
+  breakpoints.forEach(breakpoint => {
+    const value = ownerState[breakpoint];
+    if (value) {
+      breakpointsClasses.push(`grid-${breakpoint}-${String(value)}`);
+    }
+  });
+  const slots = {
+    root: ['root', container && 'container', item && 'item', zeroMinWidth && 'zeroMinWidth', ...spacingClasses, direction !== 'row' && `direction-xs-${String(direction)}`, wrap !== 'wrap' && `wrap-xs-${String(wrap)}`, ...breakpointsClasses]
+  };
+  return composeClasses(slots, getGridLegacyUtilityClass, classes);
+};
+
+/**
+ * @deprecated Use the [`Grid`](https://mui.com/material-ui/react-grid/) component instead.
+ */
+const GridLegacy = /*#__PURE__*/React.forwardRef(function GridLegacy(inProps, ref) {
+  const themeProps = useDefaultProps({
+    props: inProps,
+    name: 'MuiGridLegacy'
+  });
+  const {
+    breakpoints
+  } = useTheme();
+  const props = extendSxProp(themeProps);
+  const {
+    className,
+    columns: columnsProp,
+    columnSpacing: columnSpacingProp,
+    component = 'div',
+    container = false,
+    direction = 'row',
+    item = false,
+    rowSpacing: rowSpacingProp,
+    spacing = 0,
+    wrap = 'wrap',
+    zeroMinWidth = false,
+    ...other
+  } = props;
+  React.useEffect(() => {
+    warnAboutDeprecatedGridLegacy();
+  }, []);
+  const rowSpacing = rowSpacingProp || spacing;
+  const columnSpacing = columnSpacingProp || spacing;
+  const columnsContext = React.useContext(GridLegacyContext);
+
+  // columns set with default breakpoint unit of 12
+  const columns = container ? columnsProp || 12 : columnsContext;
+  const breakpointsValues = {};
+  const otherFiltered = {
+    ...other
+  };
+  breakpoints.keys.forEach(breakpoint => {
+    if (other[breakpoint] != null) {
+      breakpointsValues[breakpoint] = other[breakpoint];
+      delete otherFiltered[breakpoint];
+    }
+  });
+  const ownerState = {
+    ...props,
+    columns,
+    container,
+    direction,
+    item,
+    rowSpacing,
+    columnSpacing,
+    wrap,
+    zeroMinWidth,
+    spacing,
+    ...breakpointsValues,
+    breakpoints: breakpoints.keys
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(GridLegacyContext.Provider, {
+    value: columns,
+    children: /*#__PURE__*/_jsx(GridLegacyRoot, {
+      ownerState: ownerState,
+      className: clsx(classes.root, className),
+      as: component,
+      ref: ref,
+      ...otherFiltered
+    })
+  });
+});
+process.env.NODE_ENV !== "production" ? GridLegacy.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * The number of columns.
+   * @default 12
+   */
+  columns: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number, PropTypes.object]),
+  /**
+   * Defines the horizontal space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  columnSpacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * If `true`, the component will have the flex *container* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  container: PropTypes.bool,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'row'
+   */
+  direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
+  /**
+   * If `true`, the component will have the flex *item* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  item: PropTypes.bool,
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `lg` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  lg: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `md` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  md: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
+  /**
+   * Defines the vertical space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  rowSpacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `sm` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  sm: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
+  /**
+   * Defines the space between the type `item` components.
+   * It can only be used on a type `container` component.
+   * @default 0
+   */
+  spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, 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]),
+  /**
+   * Defines the `flex-wrap` style property.
+   * It's applied for all screen sizes.
+   * @default 'wrap'
+   */
+  wrap: PropTypes.oneOf(['nowrap', 'wrap-reverse', 'wrap']),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `xl` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  xl: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for all the screen sizes with the lowest priority.
+   * @default false
+   */
+  xs: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
+  /**
+   * If `true`, it sets `min-width: 0` on the item.
+   * Refer to the limitations section of the documentation to better understand the use case.
+   * @default false
+   */
+  zeroMinWidth: PropTypes.bool
+} : void 0;
+if (process.env.NODE_ENV !== 'production') {
+  const requireProp = requirePropFactory('GridLegacy', GridLegacy);
+  // eslint-disable-next-line no-useless-concat
+  GridLegacy['propTypes' + ''] = {
+    // eslint-disable-next-line react/forbid-foreign-prop-types
+    ...GridLegacy.propTypes,
+    direction: requireProp('container'),
+    lg: requireProp('item'),
+    md: requireProp('item'),
+    sm: requireProp('item'),
+    spacing: requireProp('container'),
+    wrap: requireProp('container'),
+    xs: requireProp('item'),
+    zeroMinWidth: requireProp('item')
+  };
+}
+export default GridLegacy;

node_modules/@mui/material/esm/ImageList/imageListClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getImageListUtilityClass(slot) {
+  return generateUtilityClass('MuiImageList', slot);
+}
+const imageListClasses = generateUtilityClasses('MuiImageList', ['root', 'masonry', 'quilted', 'standard', 'woven']);
+export default imageListClasses;

node_modules/@mui/material/esm/ImageListItem/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ImageListItem.js";
+export { default } from "./ImageListItem.js";
+export * from "./imageListItemClasses.js";
+export { default as imageListItemClasses } from "./imageListItemClasses.js";

node_modules/@mui/material/esm/LinearProgress/linearProgressClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getLinearProgressUtilityClass(slot) {
+  return generateUtilityClass('MuiLinearProgress', slot);
+}
+const linearProgressClasses = generateUtilityClasses('MuiLinearProgress', ['root', 'colorPrimary', 'colorSecondary', 'determinate', 'indeterminate', 'buffer', 'query', 'dashed', 'dashedColorPrimary', 'dashedColorSecondary', 'bar', 'bar1', 'bar2', 'barColorPrimary', 'barColorSecondary', 'bar1Indeterminate', 'bar1Determinate', 'bar1Buffer', 'bar2Indeterminate', 'bar2Buffer']);
+export default linearProgressClasses;

node_modules/@mui/material/esm/List/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./List.js";
+export * from "./List.js";
+export { default as listClasses } from "./listClasses.js";
+export * from "./listClasses.js";

node_modules/@mui/material/esm/ListItemButton/ListItemButton.d.ts

@@ -0,0 +1,85 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { ExtendButtonBase, ExtendButtonBaseTypeMap } from "../ButtonBase/index.js";
+import { OverrideProps } from "../OverridableComponent/index.js";
+import { ListItemButtonClasses } from "./listItemButtonClasses.js";
+
+/**
+ * This interface is kept for backward compatibility. To extend `LitItemButton`
+ * props through module augmentation, use `ListItemButtonOwnProps`.
+ */
+export interface ListItemButtonBaseProps {
+  /**
+   * Defines the `align-items` style property.
+   * @default 'center'
+   */
+  alignItems?: 'flex-start' | 'center';
+  /**
+   * If `true`, the list item is focused during the first mount.
+   * Focus will also be triggered if the value changes from false to true.
+   * @default false
+   */
+  autoFocus?: boolean;
+  /**
+   * The content of the component if a `ListItemSecondaryAction` is used it must
+   * be the last child.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<ListItemButtonClasses>;
+  /**
+   * If `true`, compact vertical padding designed for keyboard and mouse input is used.
+   * The prop defaults to the value inherited from the parent List component.
+   * @default false
+   */
+  dense?: boolean;
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * If `true`, the left and right padding is removed.
+   * @default false
+   */
+  disableGutters?: boolean;
+  /**
+   * If `true`, a 1px light border is added to the bottom of the list item.
+   * @default false
+   */
+  divider?: boolean;
+  /**
+   * Use to apply selected styling.
+   * @default false
+   */
+  selected?: boolean;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export interface ListItemButtonOwnProps extends ListItemButtonBaseProps {}
+export type ListItemButtonTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> = ExtendButtonBaseTypeMap<{
+  props: AdditionalProps & ListItemButtonOwnProps;
+  defaultComponent: RootComponent;
+}>;
+
+/**
+ *
+ * Demos:
+ *
+ * - [Lists](https://mui.com/material-ui/react-list/)
+ *
+ * API:
+ *
+ * - [ListItemButton API](https://mui.com/material-ui/api/list-item-button/)
+ * - inherits [ButtonBase API](https://mui.com/material-ui/api/button-base/)
+ */
+declare const ListItemButton: ExtendButtonBase<ListItemButtonTypeMap>;
+export type ListItemButtonProps<RootComponent extends React.ElementType = ListItemButtonTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<ListItemButtonTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default ListItemButton;