init 3

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;

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

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

node_modules/@mui/material/esm/ListItemIcon/listItemIconClasses.js

@@ -0,0 +1,7 @@
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+export function getListItemIconUtilityClass(slot) {
+  return generateUtilityClass('MuiListItemIcon', slot);
+}
+const listItemIconClasses = generateUtilityClasses('MuiListItemIcon', ['root', 'alignItemsFlexStart']);
+export default listItemIconClasses;

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

@@ -0,0 +1,227 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import composeClasses from '@mui/utils/composeClasses';
+import Typography, { typographyClasses } from "../Typography/index.js";
+import ListContext from "../List/ListContext.js";
+import { styled } from "../zero-styled/index.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import listItemTextClasses, { getListItemTextUtilityClass } from "./listItemTextClasses.js";
+import useSlot from "../utils/useSlot.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    inset,
+    primary,
+    secondary,
+    dense
+  } = ownerState;
+  const slots = {
+    root: ['root', inset && 'inset', dense && 'dense', primary && secondary && 'multiline'],
+    primary: ['primary'],
+    secondary: ['secondary']
+  };
+  return composeClasses(slots, getListItemTextUtilityClass, classes);
+};
+const ListItemTextRoot = styled('div', {
+  name: 'MuiListItemText',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [{
+      [`& .${listItemTextClasses.primary}`]: styles.primary
+    }, {
+      [`& .${listItemTextClasses.secondary}`]: styles.secondary
+    }, styles.root, ownerState.inset && styles.inset, ownerState.primary && ownerState.secondary && styles.multiline, ownerState.dense && styles.dense];
+  }
+})({
+  flex: '1 1 auto',
+  minWidth: 0,
+  marginTop: 4,
+  marginBottom: 4,
+  [`.${typographyClasses.root}:where(& .${listItemTextClasses.primary})`]: {
+    display: 'block'
+  },
+  [`.${typographyClasses.root}:where(& .${listItemTextClasses.secondary})`]: {
+    display: 'block'
+  },
+  variants: [{
+    props: ({
+      ownerState
+    }) => ownerState.primary && ownerState.secondary,
+    style: {
+      marginTop: 6,
+      marginBottom: 6
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.inset,
+    style: {
+      paddingLeft: 56
+    }
+  }]
+});
+const ListItemText = /*#__PURE__*/React.forwardRef(function ListItemText(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: 'MuiListItemText'
+  });
+  const {
+    children,
+    className,
+    disableTypography = false,
+    inset = false,
+    primary: primaryProp,
+    primaryTypographyProps,
+    secondary: secondaryProp,
+    secondaryTypographyProps,
+    slots = {},
+    slotProps = {},
+    ...other
+  } = props;
+  const {
+    dense
+  } = React.useContext(ListContext);
+  let primary = primaryProp != null ? primaryProp : children;
+  let secondary = secondaryProp;
+  const ownerState = {
+    ...props,
+    disableTypography,
+    inset,
+    primary: !!primary,
+    secondary: !!secondary,
+    dense
+  };
+  const classes = useUtilityClasses(ownerState);
+  const externalForwardedProps = {
+    slots,
+    slotProps: {
+      primary: primaryTypographyProps,
+      secondary: secondaryTypographyProps,
+      ...slotProps
+    }
+  };
+  const [RootSlot, rootSlotProps] = useSlot('root', {
+    className: clsx(classes.root, className),
+    elementType: ListItemTextRoot,
+    externalForwardedProps: {
+      ...externalForwardedProps,
+      ...other
+    },
+    ownerState,
+    ref
+  });
+  const [PrimarySlot, primarySlotProps] = useSlot('primary', {
+    className: classes.primary,
+    elementType: Typography,
+    externalForwardedProps,
+    ownerState
+  });
+  const [SecondarySlot, secondarySlotProps] = useSlot('secondary', {
+    className: classes.secondary,
+    elementType: Typography,
+    externalForwardedProps,
+    ownerState
+  });
+  if (primary != null && primary.type !== Typography && !disableTypography) {
+    primary = /*#__PURE__*/_jsx(PrimarySlot, {
+      variant: dense ? 'body2' : 'body1',
+      component: primarySlotProps?.variant ? undefined : 'span',
+      ...primarySlotProps,
+      children: primary
+    });
+  }
+  if (secondary != null && secondary.type !== Typography && !disableTypography) {
+    secondary = /*#__PURE__*/_jsx(SecondarySlot, {
+      variant: "body2",
+      color: "textSecondary",
+      ...secondarySlotProps,
+      children: secondary
+    });
+  }
+  return /*#__PURE__*/_jsxs(RootSlot, {
+    ...rootSlotProps,
+    children: [primary, secondary]
+  });
+});
+process.env.NODE_ENV !== "production" ? ListItemText.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Alias for the `primary` prop.
+   */
+  children: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * 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: PropTypes.bool,
+  /**
+   * If `true`, the children are indented.
+   * This should be used if there is no left avatar or left icon.
+   * @default false
+   */
+  inset: PropTypes.bool,
+  /**
+   * The main content element.
+   */
+  primary: PropTypes.node,
+  /**
+   * 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: PropTypes.object,
+  /**
+   * The secondary content element.
+   */
+  secondary: PropTypes.node,
+  /**
+   * 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: PropTypes.object,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: PropTypes.shape({
+    primary: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    secondary: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: PropTypes.shape({
+    primary: PropTypes.elementType,
+    root: PropTypes.elementType,
+    secondary: 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 ListItemText;

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

@@ -0,0 +1,71 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import exactProp from '@mui/utils/exactProp';
+/**
+ * NoSsr purposely removes components from the subject of Server Side Rendering (SSR).
+ *
+ * This component can be useful in a variety of situations:
+ *
+ * * Escape hatch for broken dependencies not supporting SSR.
+ * * Improve the time-to-first paint on the client by only rendering above the fold.
+ * * Reduce the rendering time on the server.
+ * * Under too heavy server load, you can turn on service degradation.
+ *
+ * Demos:
+ *
+ * - [No SSR](https://mui.com/material-ui/react-no-ssr/)
+ *
+ * API:
+ *
+ * - [NoSsr API](https://mui.com/material-ui/api/no-ssr/)
+ */
+function NoSsr(props) {
+  const {
+    children,
+    defer = false,
+    fallback = null
+  } = props;
+  const [mountedState, setMountedState] = React.useState(false);
+  useEnhancedEffect(() => {
+    if (!defer) {
+      setMountedState(true);
+    }
+  }, [defer]);
+  React.useEffect(() => {
+    if (defer) {
+      setMountedState(true);
+    }
+  }, [defer]);
+
+  // TODO casting won't be needed at one point https://github.com/DefinitelyTyped/DefinitelyTyped/pull/65135
+  return mountedState ? children : fallback;
+}
+process.env.NODE_ENV !== "production" ? NoSsr.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * You can wrap a node.
+   */
+  children: PropTypes.node,
+  /**
+   * If `true`, the component will not only prevent server-side rendering.
+   * It will also defer the rendering of the children into a different screen frame.
+   * @default false
+   */
+  defer: PropTypes.bool,
+  /**
+   * The fallback content to display.
+   * @default null
+   */
+  fallback: PropTypes.node
+} : void 0;
+if (process.env.NODE_ENV !== 'production') {
+  // eslint-disable-next-line
+  NoSsr['propTypes' + ''] = exactProp(NoSsr.propTypes);
+}
+export default NoSsr;

node_modules/@mui/material/esm/NoSsr/NoSsr.types.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export interface NoSsrProps {
+  /**
+   * You can wrap a node.
+   */
+  children?: React.ReactNode;
+  /**
+   * If `true`, the component will not only prevent server-side rendering.
+   * It will also defer the rendering of the children into a different screen frame.
+   * @default false
+   */
+  defer?: boolean;
+  /**
+   * The fallback content to display.
+   * @default null
+   */
+  fallback?: React.ReactNode;
+}

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

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

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

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import { OverridableComponent, OverrideProps } from '@mui/types';
+import { SxProps, Breakpoint } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { ContainerClasses } from "../Container/containerClasses.js";
+export interface PigmentContainerOwnProps {
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<ContainerClasses>;
+  /**
+   * If `true`, the left and right padding is removed.
+   * @default false
+   */
+  disableGutters?: boolean;
+  /**
+   * Set the max-width to match the min-width of the current breakpoint.
+   * This is useful if you'd prefer to design for a fixed set of sizes
+   * instead of trying to accommodate a fully fluid viewport.
+   * It's fluid by default.
+   * @default false
+   */
+  fixed?: boolean;
+  /**
+   * Determine the max-width of the container.
+   * The container width grows with the size of the screen.
+   * Set to `false` to disable `maxWidth`.
+   * @default 'lg'
+   */
+  maxWidth?: Breakpoint | false;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export interface PigmentContainerTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> {
+  props: AdditionalProps & PigmentContainerOwnProps;
+  defaultComponent: RootComponent;
+}
+export type PigmentContainerProps<RootComponent extends React.ElementType = PigmentContainerTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<PigmentContainerTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+/**
+ *
+ * Demos:
+ *
+ * - [Container](https://mui.com/material-ui/react-container/)
+ *
+ * API:
+ *
+ * - [PigmentContainer API](https://mui.com/material-ui/api/pigment-container/)
+ */
+declare const PigmentContainer: OverridableComponent<PigmentContainerTypeMap>;
+export default PigmentContainer;

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

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { OverridableComponent, OverrideProps } from '@mui/types';
+import { SxProps } from '@mui/system';
+import { Breakpoint, Theme } from "../styles/index.js";
+type ResponsiveStyleValue<T> = T | Array<T | null> | { [key in Breakpoint]?: T | null };
+export interface PigmentStackOwnProps {
+  /**
+   * The content of the component.
+   */
+  children?: React.ReactNode;
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'column'
+   */
+  direction?: ResponsiveStyleValue<'row' | 'row-reverse' | 'column' | 'column-reverse'>;
+  /**
+   * Defines the space between immediate children.
+   * @default 0
+   */
+  spacing?: ResponsiveStyleValue<number | string>;
+  /**
+   * Add an element between each child.
+   */
+  divider?: React.ReactNode;
+  /**
+   * The system prop, which allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export interface PigmentStackTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'div'> {
+  props: AdditionalProps & PigmentStackOwnProps;
+  defaultComponent: RootComponent;
+}
+export type PigmentStackProps<RootComponent extends React.ElementType = PigmentStackTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<PigmentStackTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+/**
+ *
+ * Demos:
+ *
+ * - [Stack](https://mui.com/material-ui/react-stack/)
+ *
+ * API:
+ *
+ * - [PigmentStack API](https://mui.com/material-ui/api/pigment-stack/)
+ */
+declare const PigmentStack: OverridableComponent<PigmentStackTypeMap>;
+export default PigmentStack;

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

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

node_modules/@mui/material/esm/Popper/BasePopper.d.ts

@@ -0,0 +1,7 @@
+import { PolymorphicComponent } from "../utils/PolymorphicComponent.js";
+import { PopperTypeMap } from "./BasePopper.types.js";
+/**
+ * @ignore - internal component.
+ */
+declare const Popper: PolymorphicComponent<PopperTypeMap>;
+export default Popper;

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

@@ -0,0 +1 @@
+export {};

node_modules/@mui/material/esm/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/esm/Select/index.js

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

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

@@ -0,0 +1,269 @@
+'use client';
+
+import * as React from 'react';
+import clsx from 'clsx';
+import PropTypes from 'prop-types';
+import composeClasses from '@mui/utils/composeClasses';
+import { unstable_getUnit as getUnit, unstable_toUnitless as toUnitless } from "../styles/index.js";
+import { keyframes, css, styled } from "../zero-styled/index.js";
+import memoTheme from "../utils/memoTheme.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import { getSkeletonUtilityClass } from "./skeletonClasses.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    variant,
+    animation,
+    hasChildren,
+    width,
+    height
+  } = ownerState;
+  const slots = {
+    root: ['root', variant, animation, hasChildren && 'withChildren', hasChildren && !width && 'fitContent', hasChildren && !height && 'heightAuto']
+  };
+  return composeClasses(slots, getSkeletonUtilityClass, classes);
+};
+const pulseKeyframe = keyframes`
+  0% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.4;
+  }
+
+  100% {
+    opacity: 1;
+  }
+`;
+const waveKeyframe = keyframes`
+  0% {
+    transform: translateX(-100%);
+  }
+
+  50% {
+    /* +0.5s of delay between each loop */
+    transform: translateX(100%);
+  }
+
+  100% {
+    transform: translateX(100%);
+  }
+`;
+
+// This implementation is for supporting both Styled-components v4+ and Pigment CSS.
+// A global animation has to be created here for Styled-components v4+ (https://github.com/styled-components/styled-components/blob/main/packages/styled-components/src/utils/errors.md#12).
+// which can be done by checking typeof indeterminate1Keyframe !== 'string' (at runtime, Pigment CSS transform keyframes`` to a string).
+const pulseAnimation = typeof pulseKeyframe !== 'string' ? css`
+        animation: ${pulseKeyframe} 2s ease-in-out 0.5s infinite;
+      ` : null;
+const waveAnimation = typeof waveKeyframe !== 'string' ? css`
+        &::after {
+          animation: ${waveKeyframe} 2s linear 0.5s infinite;
+        }
+      ` : null;
+const SkeletonRoot = styled('span', {
+  name: 'MuiSkeleton',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, styles[ownerState.variant], ownerState.animation !== false && styles[ownerState.animation], ownerState.hasChildren && styles.withChildren, ownerState.hasChildren && !ownerState.width && styles.fitContent, ownerState.hasChildren && !ownerState.height && styles.heightAuto];
+  }
+})(memoTheme(({
+  theme
+}) => {
+  const radiusUnit = getUnit(theme.shape.borderRadius) || 'px';
+  const radiusValue = toUnitless(theme.shape.borderRadius);
+  return {
+    display: 'block',
+    // Create a "on paper" color with sufficient contrast retaining the color
+    backgroundColor: theme.vars ? theme.vars.palette.Skeleton.bg : theme.alpha(theme.palette.text.primary, theme.palette.mode === 'light' ? 0.11 : 0.13),
+    height: '1.2em',
+    variants: [{
+      props: {
+        variant: 'text'
+      },
+      style: {
+        marginTop: 0,
+        marginBottom: 0,
+        height: 'auto',
+        transformOrigin: '0 55%',
+        transform: 'scale(1, 0.60)',
+        borderRadius: `${radiusValue}${radiusUnit}/${Math.round(radiusValue / 0.6 * 10) / 10}${radiusUnit}`,
+        '&:empty:before': {
+          content: '"\\00a0"'
+        }
+      }
+    }, {
+      props: {
+        variant: 'circular'
+      },
+      style: {
+        borderRadius: '50%'
+      }
+    }, {
+      props: {
+        variant: 'rounded'
+      },
+      style: {
+        borderRadius: (theme.vars || theme).shape.borderRadius
+      }
+    }, {
+      props: ({
+        ownerState
+      }) => ownerState.hasChildren,
+      style: {
+        '& > *': {
+          visibility: 'hidden'
+        }
+      }
+    }, {
+      props: ({
+        ownerState
+      }) => ownerState.hasChildren && !ownerState.width,
+      style: {
+        maxWidth: 'fit-content'
+      }
+    }, {
+      props: ({
+        ownerState
+      }) => ownerState.hasChildren && !ownerState.height,
+      style: {
+        height: 'auto'
+      }
+    }, {
+      props: {
+        animation: 'pulse'
+      },
+      style: pulseAnimation || {
+        animation: `${pulseKeyframe} 2s ease-in-out 0.5s infinite`
+      }
+    }, {
+      props: {
+        animation: 'wave'
+      },
+      style: {
+        position: 'relative',
+        overflow: 'hidden',
+        /* Fix bug in Safari https://bugs.webkit.org/show_bug.cgi?id=68196 */
+        WebkitMaskImage: '-webkit-radial-gradient(white, black)',
+        '&::after': {
+          background: `linear-gradient(
+                90deg,
+                transparent,
+                ${(theme.vars || theme).palette.action.hover},
+                transparent
+              )`,
+          content: '""',
+          position: 'absolute',
+          transform: 'translateX(-100%)' /* Avoid flash during server-side hydration */,
+          bottom: 0,
+          left: 0,
+          right: 0,
+          top: 0
+        }
+      }
+    }, {
+      props: {
+        animation: 'wave'
+      },
+      style: waveAnimation || {
+        '&::after': {
+          animation: `${waveKeyframe} 2s linear 0.5s infinite`
+        }
+      }
+    }]
+  };
+}));
+const Skeleton = /*#__PURE__*/React.forwardRef(function Skeleton(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: 'MuiSkeleton'
+  });
+  const {
+    animation = 'pulse',
+    className,
+    component = 'span',
+    height,
+    style,
+    variant = 'text',
+    width,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    animation,
+    component,
+    variant,
+    hasChildren: Boolean(other.children)
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(SkeletonRoot, {
+    as: component,
+    ref: ref,
+    className: clsx(classes.root, className),
+    ownerState: ownerState,
+    ...other,
+    style: {
+      width,
+      height,
+      ...style
+    }
+  });
+});
+process.env.NODE_ENV !== "production" ? Skeleton.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 animation.
+   * If `false` the animation effect is disabled.
+   * @default 'pulse'
+   */
+  animation: PropTypes.oneOf(['pulse', 'wave', false]),
+  /**
+   * Optional children to infer width and height from.
+   */
+  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,
+  /**
+   * Height of the skeleton.
+   * Useful when you don't want to adapt the skeleton to a text element but for instance a card.
+   */
+  height: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  /**
+   * @ignore
+   */
+  style: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * The type of content that will be rendered.
+   * @default 'text'
+   */
+  variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['circular', 'rectangular', 'rounded', 'text']), PropTypes.string]),
+  /**
+   * Width of the skeleton.
+   * Useful when the skeleton is inside an inline element with no width of its own.
+   */
+  width: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+} : void 0;
+export default Skeleton;

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

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

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

@@ -0,0 +1,131 @@
+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 { FabProps } from "../Fab/index.js";
+import { TransitionProps } from "../transitions/index.js";
+import { SpeedDialClasses } from "./speedDialClasses.js";
+import { CreateSlotsAndSlotProps, SlotComponentProps } from "../utils/types.js";
+export type CloseReason = 'toggle' | 'blur' | 'mouseLeave' | 'escapeKeyDown';
+export type OpenReason = 'toggle' | 'focus' | 'mouseEnter';
+export interface SpeedDialSlots {
+  /**
+   * The component that renders the root slot.
+   * @default 'div'
+   */
+  root: React.ElementType;
+  /**
+   * The component that renders the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Zoom
+   */
+  transition: React.ElementType;
+}
+export type SpeedDialSlotsAndSlotProps = CreateSlotsAndSlotProps<SpeedDialSlots, {
+  /**
+   * Props forwarded to the root slot.
+   * By default, the available props are based on div element.
+   */
+  root: SlotComponentProps<'div', React.HTMLAttributes<HTMLDivElement>, SpeedDialOwnerState>;
+  /**
+   * Props forwarded to the transition slot.
+   * By default, the available props are based on the [Zoom](https://mui.com/material-ui/api/zoom/#props) component.
+   */
+  transition: SlotComponentProps<React.ElementType, TransitionProps, SpeedDialOwnerState>;
+}>;
+export interface SpeedDialProps extends Omit<StandardProps<React.HTMLAttributes<HTMLDivElement>, 'children'>, 'slots' | 'slotProps'>, SpeedDialSlotsAndSlotProps {
+  /**
+   * SpeedDialActions to display when the SpeedDial is `open`.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<SpeedDialClasses>;
+  /**
+   * The aria-label of the button element.
+   * Also used to provide the `id` for the `SpeedDial` element and its children.
+   */
+  ariaLabel: string;
+  /**
+   * The direction the actions open relative to the floating action button.
+   * @default 'up'
+   */
+  direction?: 'up' | 'down' | 'left' | 'right';
+  /**
+   * If `true`, the SpeedDial is hidden.
+   * @default false
+   */
+  hidden?: boolean;
+  /**
+   * Props applied to the [`Fab`](https://mui.com/material-ui/api/fab/) element.
+   * @default {}
+   */
+  FabProps?: Partial<FabProps>;
+  /**
+   * The icon to display in the SpeedDial Fab. The `SpeedDialIcon` component
+   * provides a default Icon with animation.
+   */
+  icon?: React.ReactNode;
+  /**
+   * Callback fired when the component requests to be closed.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"toggle"`, `"blur"`, `"mouseLeave"`, `"escapeKeyDown"`.
+   */
+  onClose?: (event: React.SyntheticEvent<{}>, reason: CloseReason) => void;
+  /**
+   * Callback fired when the component requests to be open.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"toggle"`, `"focus"`, `"mouseEnter"`.
+   */
+  onOpen?: (event: React.SyntheticEvent<{}>, reason: OpenReason) => void;
+  /**
+   * If `true`, the component is shown.
+   */
+  open?: boolean;
+  /**
+   * The icon to display in the SpeedDial Fab when the SpeedDial is open.
+   */
+  openIcon?: React.ReactNode;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * 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 Zoom
+   * * @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?: React.JSXElementConstructor<TransitionProps>;
+  /**
+   * 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?: TransitionProps['timeout'];
+  /**
+   * 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. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
+   */
+  TransitionProps?: TransitionProps;
+}
+export interface SpeedDialOwnerState extends SpeedDialProps {}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Speed Dial](https://mui.com/material-ui/react-speed-dial/)
+ *
+ * API:
+ *
+ * - [SpeedDial API](https://mui.com/material-ui/api/speed-dial/)
+ */
+export default function SpeedDial(props: SpeedDialProps): React.JSX.Element;

node_modules/@mui/material/esm/SpeedDial/speedDialClasses.d.ts

@@ -0,0 +1,22 @@
+export interface SpeedDialClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the Fab component. */
+  fab: string;
+  /** Styles applied to the root element if direction="up" */
+  directionUp: string;
+  /** Styles applied to the root element if direction="down" */
+  directionDown: string;
+  /** Styles applied to the root element if direction="left" */
+  directionLeft: string;
+  /** Styles applied to the root element if direction="right" */
+  directionRight: string;
+  /** Styles applied to the actions (`children` wrapper) element. */
+  actions: string;
+  /** Styles applied to the actions (`children` wrapper) element if `open={false}`. */
+  actionsClosed: string;
+}
+export type SpeedDialClassKey = keyof SpeedDialClasses;
+export declare function getSpeedDialUtilityClass(slot: string): string;
+declare const speedDialClasses: SpeedDialClasses;
+export default speedDialClasses;

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

@@ -0,0 +1,117 @@
+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 { FabProps } from "../Fab/index.js";
+import { TooltipProps } from "../Tooltip/index.js";
+import { SpeedDialActionClasses } from "./speedDialActionClasses.js";
+import { CreateSlotsAndSlotProps, SlotProps } from "../utils/types.js";
+export interface SpeedDialActionSlots {
+  /**
+   * The component that renders the fab.
+   * @default Fab
+   */
+  fab?: React.ElementType;
+  /**
+   * The component that renders the tooltip.
+   * @default Tooltip
+   */
+  tooltip?: React.ElementType;
+  /**
+   * The component that renders the static tooltip.
+   * @default 'span'
+   */
+  staticTooltip?: React.ElementType;
+  /**
+   * The component that renders the static tooltip label.
+   * @default 'span'
+   */
+  staticTooltipLabel?: React.ElementType;
+}
+export interface SpeedDialActionFabSlotPropsOverrides {}
+export interface SpeedDialActionTooltipSlotPropsOverrides {}
+export interface SpeedDialActionStaticTooltipSlotPropsOverrides {}
+export interface SpeedDialActionStaticTooltipLabelSlotPropsOverrides {}
+export type SpeedDialActionSlotsAndSlotProps = CreateSlotsAndSlotProps<SpeedDialActionSlots, {
+  /**
+   * Props forwarded to the fab slot.
+   * By default, the available props are based on the [Fab](https://mui.com/material-ui/api/fab/#props) component.
+   */
+  fab: SlotProps<React.ElementType<FabProps>, SpeedDialActionFabSlotPropsOverrides, SpeedDialActionOwnerState>;
+  /**
+   * Props forwarded to the tooltip slot.
+   * By default, the available props are based on the [Tooltip](https://mui.com/material-ui/api/tooltip/#props) component.
+   */
+  tooltip: SlotProps<React.ElementType<TooltipProps>, SpeedDialActionTooltipSlotPropsOverrides, SpeedDialActionOwnerState>;
+  /**
+   * Props forwarded to the static tooltip slot.
+   * By default, the available props are based on a span element.
+   */
+  staticTooltip: SlotProps<'span', SpeedDialActionStaticTooltipSlotPropsOverrides, SpeedDialActionOwnerState>;
+  /**
+   * Props forwarded to the static tooltip label slot.
+   * By default, the available props are based on a span element.
+   */
+  staticTooltipLabel: SlotProps<'span', SpeedDialActionStaticTooltipLabelSlotPropsOverrides, SpeedDialActionOwnerState>;
+}>;
+export interface SpeedDialActionProps extends Omit<StandardProps<Partial<TooltipProps>, 'children'>, 'slotProps' | 'slots'>, SpeedDialActionSlotsAndSlotProps {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<SpeedDialActionClasses>;
+  /**
+   * Props applied to the [`Fab`](https://mui.com/material-ui/api/fab/) component.
+   * @default {}
+   * @deprecated Use `slotProps.fab` 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.
+   */
+  FabProps?: Partial<FabProps>;
+  /**
+   * Adds a transition delay, to allow a series of SpeedDialActions to be animated.
+   * @default 0
+   */
+  delay?: number;
+  /**
+   * The icon to display in the SpeedDial Fab.
+   */
+  icon?: React.ReactNode;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * `classes` prop applied to the [`Tooltip`](https://mui.com/material-ui/api/tooltip/) element.
+   * @deprecated Use `slotProps.tooltip.classes` 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.
+   */
+  TooltipClasses?: TooltipProps['classes'];
+  /**
+   * Placement of the tooltip.
+   * @default 'left'
+   * @deprecated Use `slotProps.tooltip.placement` 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.
+   */
+  tooltipPlacement?: TooltipProps['placement'];
+  /**
+   * Label to display in the tooltip.
+   * @deprecated Use `slotProps.tooltip.title` 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.
+   */
+  tooltipTitle?: React.ReactNode;
+  /**
+   * Make the tooltip always visible when the SpeedDial is open.
+   * @default false
+   * @deprecated Use `slotProps.tooltip.open` 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.
+   */
+  tooltipOpen?: boolean;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Speed Dial](https://mui.com/material-ui/react-speed-dial/)
+ *
+ * API:
+ *
+ * - [SpeedDialAction API](https://mui.com/material-ui/api/speed-dial-action/)
+ * - inherits [Tooltip API](https://mui.com/material-ui/api/tooltip/)
+ */
+export default function SpeedDialAction(props: SpeedDialActionProps): React.JSX.Element;
+export interface SpeedDialActionOwnerState extends Omit<SpeedDialActionProps, 'slots' | 'slotProps'> {}

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

@@ -0,0 +1,61 @@
+'use client';
+
+import PropTypes from 'prop-types';
+import { createStack } from '@mui/system';
+import styled from "../styles/styled.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+const Stack = createStack({
+  createStyledComponent: styled('div', {
+    name: 'MuiStack',
+    slot: 'Root'
+  }),
+  useThemeProps: inProps => useDefaultProps({
+    props: inProps,
+    name: 'MuiStack'
+  })
+});
+process.env.NODE_ENV !== "production" ? Stack.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,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'column'
+   */
+  direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
+  /**
+   * Add an element between each child.
+   */
+  divider: PropTypes.node,
+  /**
+   * Defines the space between immediate children.
+   * @default 0
+   */
+  spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
+  /**
+   * The system prop, which 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]),
+  /**
+   * If `true`, the CSS flexbox `gap` is used instead of applying `margin` to children.
+   *
+   * While CSS `gap` removes the [known limitations](https://mui.com/joy-ui/react-stack/#limitations),
+   * it is not fully supported in some browsers. We recommend checking https://caniuse.com/?search=flex%20gap before using this flag.
+   *
+   * To enable this flag globally, follow the [theme's default props](https://mui.com/material-ui/customization/theme-components/#default-props) configuration.
+   * @default false
+   */
+  useFlexGap: PropTypes.bool
+} : void 0;
+export default Stack;

node_modules/@mui/material/esm/Step/StepContext.js

@@ -0,0 +1,19 @@
+'use client';
+
+import * as React from 'react';
+/**
+ * Provides information about the current step in Stepper.
+ */
+const StepContext = /*#__PURE__*/React.createContext({});
+if (process.env.NODE_ENV !== 'production') {
+  StepContext.displayName = 'StepContext';
+}
+
+/**
+ * Returns the current StepContext or an empty object if no StepContext
+ * has been defined in the component tree.
+ */
+export function useStepContext() {
+  return React.useContext(StepContext);
+}
+export default StepContext;

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

@@ -0,0 +1,76 @@
+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 { CollapseProps } from "../Collapse/index.js";
+import { TransitionProps } from "../transitions/transition.js";
+import { StepContentClasses } from "./stepContentClasses.js";
+import { CreateSlotsAndSlotProps, SlotComponentProps } from "../utils/types.js";
+export interface StepContentSlots {
+  /**
+   * The component that renders the transition slot.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Collapse
+   */
+  transition?: React.JSXElementConstructor<TransitionProps & {
+    children?: React.ReactElement<unknown, any>;
+  }>;
+}
+export type StepContentSlotsAndSlotProps = CreateSlotsAndSlotProps<StepContentSlots, {
+  /**
+   * Props forwarded to the transition slot.
+   * By default, the available props are based on the [Collapse](https://mui.com/material-ui/api/collapse/#props) component
+   */
+  transition: SlotComponentProps<React.ElementType, CollapseProps, StepContentOwnerState>;
+}>;
+export interface StepContentOwnerState extends StepContentProps {}
+export interface StepContentProps extends StandardProps<React.HTMLAttributes<HTMLDivElement>>, StepContentSlotsAndSlotProps {
+  /**
+   * The content of the component.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<StepContentClasses>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * 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?: React.JSXElementConstructor<TransitionProps & {
+    children: React.ReactElement<unknown, any>;
+  }>;
+  /**
+   * 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?: TransitionProps['timeout'] | 'auto';
+  /**
+   * 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?: TransitionProps;
+}
+export type StepContentClasskey = keyof NonNullable<StepContentProps['classes']>;
+
+/**
+ *
+ * Demos:
+ *
+ * - [Stepper](https://mui.com/material-ui/react-stepper/)
+ *
+ * API:
+ *
+ * - [StepContent API](https://mui.com/material-ui/api/step-content/)
+ */
+export default function StepContent(props: StepContentProps): React.JSX.Element;

node_modules/@mui/material/esm/Stepper/stepperClasses.d.ts

@@ -0,0 +1,16 @@
+export interface StepperClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `orientation="horizontal"`. */
+  horizontal: string;
+  /** Styles applied to the root element if `orientation="vertical"`. */
+  vertical: string;
+  /** Styles applied to the root element if `nonLinear={true}`. */
+  nonLinear: string;
+  /** Styles applied to the root element if `alternativeLabel={true}`. */
+  alternativeLabel: string;
+}
+export type StepperClassKey = keyof StepperClasses;
+export declare function getStepperUtilityClass(slot: string): string;
+declare const stepperClasses: StepperClasses;
+export default stepperClasses;

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

@@ -0,0 +1,661 @@
+'use client';
+
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import PropTypes from 'prop-types';
+import elementTypeAcceptingRef from '@mui/utils/elementTypeAcceptingRef';
+import NoSsr from "../NoSsr/index.js";
+import Drawer, { getAnchor, isHorizontal } from "../Drawer/Drawer.js";
+import useForkRef from "../utils/useForkRef.js";
+import ownerDocument from "../utils/ownerDocument.js";
+import ownerWindow from "../utils/ownerWindow.js";
+import useEventCallback from "../utils/useEventCallback.js";
+import useEnhancedEffect from "../utils/useEnhancedEffect.js";
+import { useTheme } from "../zero-styled/index.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import { getTransitionProps } from "../transitions/utils.js";
+import { mergeSlotProps } from "../utils/index.js";
+import useSlot from "../utils/useSlot.js";
+import SwipeArea from "./SwipeArea.js";
+
+// This value is closed to what browsers are using internally to
+// trigger a native scroll.
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const UNCERTAINTY_THRESHOLD = 3; // px
+
+// This is the part of the drawer displayed on touch start.
+const DRAG_STARTED_SIGNAL = 20; // px
+
+// We can only have one instance at the time claiming ownership for handling the swipe.
+// Otherwise, the UX would be confusing.
+// That's why we use a singleton here.
+let claimedSwipeInstance = null;
+
+// Exported for test purposes.
+export function reset() {
+  claimedSwipeInstance = null;
+}
+function calculateCurrentX(anchor, touches, doc) {
+  return anchor === 'right' ? doc.body.offsetWidth - touches[0].pageX : touches[0].pageX;
+}
+function calculateCurrentY(anchor, touches, containerWindow) {
+  return anchor === 'bottom' ? containerWindow.innerHeight - touches[0].clientY : touches[0].clientY;
+}
+function getMaxTranslate(horizontalSwipe, paperInstance) {
+  return horizontalSwipe ? paperInstance.clientWidth : paperInstance.clientHeight;
+}
+function getTranslate(currentTranslate, startLocation, open, maxTranslate) {
+  return Math.min(Math.max(open ? startLocation - currentTranslate : maxTranslate + startLocation - currentTranslate, 0), maxTranslate);
+}
+
+/**
+ * @param {Element | null} element
+ * @param {Element} rootNode
+ */
+function getDomTreeShapes(element, rootNode) {
+  // Adapted from https://github.com/oliviertassinari/react-swipeable-views/blob/7666de1dba253b896911adf2790ce51467670856/packages/react-swipeable-views/src/SwipeableViews.js#L129
+  const domTreeShapes = [];
+  while (element && element !== rootNode.parentElement) {
+    const style = ownerWindow(rootNode).getComputedStyle(element);
+    if (
+    // Ignore the scroll children if the element is absolute positioned.
+    style.getPropertyValue('position') === 'absolute' ||
+    // Ignore the scroll children if the element has an overflowX hidden
+    style.getPropertyValue('overflow-x') === 'hidden') {
+      // noop
+    } else if (element.clientWidth > 0 && element.scrollWidth > element.clientWidth || element.clientHeight > 0 && element.scrollHeight > element.clientHeight) {
+      // Ignore the nodes that have no width.
+      // Keep elements with a scroll
+      domTreeShapes.push(element);
+    }
+    element = element.parentElement;
+  }
+  return domTreeShapes;
+}
+
+/**
+ * @param {object} param0
+ * @param {ReturnType<getDomTreeShapes>} param0.domTreeShapes
+ */
+function computeHasNativeHandler({
+  domTreeShapes,
+  start,
+  current,
+  anchor
+}) {
+  // Adapted from https://github.com/oliviertassinari/react-swipeable-views/blob/7666de1dba253b896911adf2790ce51467670856/packages/react-swipeable-views/src/SwipeableViews.js#L175
+  const axisProperties = {
+    scrollPosition: {
+      x: 'scrollLeft',
+      y: 'scrollTop'
+    },
+    scrollLength: {
+      x: 'scrollWidth',
+      y: 'scrollHeight'
+    },
+    clientLength: {
+      x: 'clientWidth',
+      y: 'clientHeight'
+    }
+  };
+  return domTreeShapes.some(shape => {
+    // Determine if we are going backward or forward.
+    let goingForward = current >= start;
+    if (anchor === 'top' || anchor === 'left') {
+      goingForward = !goingForward;
+    }
+    const axis = anchor === 'left' || anchor === 'right' ? 'x' : 'y';
+    const scrollPosition = Math.round(shape[axisProperties.scrollPosition[axis]]);
+    const areNotAtStart = scrollPosition > 0;
+    const areNotAtEnd = scrollPosition + shape[axisProperties.clientLength[axis]] < shape[axisProperties.scrollLength[axis]];
+    if (goingForward && areNotAtEnd || !goingForward && areNotAtStart) {
+      return true;
+    }
+    return false;
+  });
+}
+const iOS = typeof navigator !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent);
+const SwipeableDrawer = /*#__PURE__*/React.forwardRef(function SwipeableDrawer(inProps, ref) {
+  const props = useDefaultProps({
+    name: 'MuiSwipeableDrawer',
+    props: inProps
+  });
+  const theme = useTheme();
+  const transitionDurationDefault = {
+    enter: theme.transitions.duration.enteringScreen,
+    exit: theme.transitions.duration.leavingScreen
+  };
+  const {
+    anchor = 'left',
+    disableBackdropTransition = false,
+    disableDiscovery = false,
+    disableSwipeToOpen = iOS,
+    hideBackdrop,
+    hysteresis = 0.52,
+    allowSwipeInChildren = false,
+    minFlingVelocity = 450,
+    ModalProps: {
+      BackdropProps,
+      ...ModalPropsProp
+    } = {},
+    onClose,
+    onOpen,
+    open = false,
+    PaperProps = {},
+    SwipeAreaProps,
+    swipeAreaWidth = 20,
+    transitionDuration = transitionDurationDefault,
+    variant = 'temporary',
+    // Mobile first.
+    slots = {},
+    slotProps = {},
+    ...other
+  } = props;
+  const [maybeSwiping, setMaybeSwiping] = React.useState(false);
+  const swipeInstance = React.useRef({
+    isSwiping: null
+  });
+  const swipeAreaRef = React.useRef();
+  const backdropRef = React.useRef();
+  const paperRef = React.useRef();
+  const handleRef = useForkRef(PaperProps.ref, paperRef);
+  const touchDetected = React.useRef(false);
+
+  // Ref for transition duration based on / to match swipe speed
+  const calculatedDurationRef = React.useRef();
+
+  // Use a ref so the open value used is always up to date inside useCallback.
+  useEnhancedEffect(() => {
+    calculatedDurationRef.current = null;
+  }, [open]);
+  const setPosition = React.useCallback((translate, options = {}) => {
+    const {
+      mode = null,
+      changeTransition = true
+    } = options;
+    const anchorRtl = getAnchor(theme, anchor);
+    const rtlTranslateMultiplier = ['right', 'bottom'].includes(anchorRtl) ? 1 : -1;
+    const horizontalSwipe = isHorizontal(anchor);
+    const transform = horizontalSwipe ? `translate(${rtlTranslateMultiplier * translate}px, 0)` : `translate(0, ${rtlTranslateMultiplier * translate}px)`;
+    const drawerStyle = paperRef.current.style;
+    drawerStyle.webkitTransform = transform;
+    drawerStyle.transform = transform;
+    let transition = '';
+    if (mode) {
+      transition = theme.transitions.create('all', getTransitionProps({
+        easing: undefined,
+        style: undefined,
+        timeout: transitionDuration
+      }, {
+        mode
+      }));
+    }
+    if (changeTransition) {
+      drawerStyle.webkitTransition = transition;
+      drawerStyle.transition = transition;
+    }
+    if (!disableBackdropTransition && !hideBackdrop) {
+      const backdropStyle = backdropRef.current.style;
+      backdropStyle.opacity = 1 - translate / getMaxTranslate(horizontalSwipe, paperRef.current);
+      if (changeTransition) {
+        backdropStyle.webkitTransition = transition;
+        backdropStyle.transition = transition;
+      }
+    }
+  }, [anchor, disableBackdropTransition, hideBackdrop, theme, transitionDuration]);
+  const handleBodyTouchEnd = useEventCallback(nativeEvent => {
+    if (!touchDetected.current) {
+      return;
+    }
+    // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- claimedSwipeInstance is a singleton
+    claimedSwipeInstance = null;
+    touchDetected.current = false;
+    ReactDOM.flushSync(() => {
+      setMaybeSwiping(false);
+    });
+
+    // The swipe wasn't started.
+    if (!swipeInstance.current.isSwiping) {
+      swipeInstance.current.isSwiping = null;
+      return;
+    }
+    swipeInstance.current.isSwiping = null;
+    const anchorRtl = getAnchor(theme, anchor);
+    const horizontal = isHorizontal(anchor);
+    let current;
+    if (horizontal) {
+      current = calculateCurrentX(anchorRtl, nativeEvent.changedTouches, ownerDocument(nativeEvent.currentTarget));
+    } else {
+      current = calculateCurrentY(anchorRtl, nativeEvent.changedTouches, ownerWindow(nativeEvent.currentTarget));
+    }
+    const startLocation = horizontal ? swipeInstance.current.startX : swipeInstance.current.startY;
+    const maxTranslate = getMaxTranslate(horizontal, paperRef.current);
+    const currentTranslate = getTranslate(current, startLocation, open, maxTranslate);
+    const translateRatio = currentTranslate / maxTranslate;
+    if (Math.abs(swipeInstance.current.velocity) > minFlingVelocity) {
+      // Calculate transition duration to match swipe speed
+      calculatedDurationRef.current = Math.abs((maxTranslate - currentTranslate) / swipeInstance.current.velocity) * 1000;
+    }
+    if (open) {
+      if (swipeInstance.current.velocity > minFlingVelocity || translateRatio > hysteresis) {
+        onClose();
+      } else {
+        // Reset the position, the swipe was aborted.
+        setPosition(0, {
+          mode: 'exit'
+        });
+      }
+      return;
+    }
+    if (swipeInstance.current.velocity < -minFlingVelocity || 1 - translateRatio > hysteresis) {
+      onOpen();
+    } else {
+      // Reset the position, the swipe was aborted.
+      setPosition(getMaxTranslate(horizontal, paperRef.current), {
+        mode: 'enter'
+      });
+    }
+  });
+  const startMaybeSwiping = (force = false) => {
+    if (!maybeSwiping) {
+      // on Safari Mobile, if you want to be able to have the 'click' event fired on child elements, nothing in the DOM can be changed.
+      // this is because Safari Mobile will not fire any mouse events (still fires touch though) if the DOM changes during mousemove.
+      // so do this change on first touchmove instead of touchstart
+      if (force || !(disableDiscovery && allowSwipeInChildren)) {
+        ReactDOM.flushSync(() => {
+          setMaybeSwiping(true);
+        });
+      }
+      const horizontalSwipe = isHorizontal(anchor);
+      if (!open && paperRef.current) {
+        // The ref may be null when a parent component updates while swiping.
+        setPosition(getMaxTranslate(horizontalSwipe, paperRef.current) + (disableDiscovery ? 15 : -DRAG_STARTED_SIGNAL), {
+          changeTransition: false
+        });
+      }
+      swipeInstance.current.velocity = 0;
+      swipeInstance.current.lastTime = null;
+      swipeInstance.current.lastTranslate = null;
+      swipeInstance.current.paperHit = false;
+      touchDetected.current = true;
+    }
+  };
+  const handleBodyTouchMove = useEventCallback(nativeEvent => {
+    // the ref may be null when a parent component updates while swiping
+    if (!paperRef.current || !touchDetected.current) {
+      return;
+    }
+
+    // We are not supposed to handle this touch move because the swipe was started in a scrollable container in the drawer
+    if (claimedSwipeInstance !== null && claimedSwipeInstance !== swipeInstance.current) {
+      return;
+    }
+    startMaybeSwiping(true);
+    const anchorRtl = getAnchor(theme, anchor);
+    const horizontalSwipe = isHorizontal(anchor);
+    const currentX = calculateCurrentX(anchorRtl, nativeEvent.touches, ownerDocument(nativeEvent.currentTarget));
+    const currentY = calculateCurrentY(anchorRtl, nativeEvent.touches, ownerWindow(nativeEvent.currentTarget));
+    if (open && paperRef.current.contains(nativeEvent.target) && claimedSwipeInstance === null) {
+      const domTreeShapes = getDomTreeShapes(nativeEvent.target, paperRef.current);
+      const hasNativeHandler = computeHasNativeHandler({
+        domTreeShapes,
+        start: horizontalSwipe ? swipeInstance.current.startX : swipeInstance.current.startY,
+        current: horizontalSwipe ? currentX : currentY,
+        anchor
+      });
+      if (hasNativeHandler) {
+        claimedSwipeInstance = true;
+        return;
+      }
+      claimedSwipeInstance = swipeInstance.current;
+    }
+
+    // We don't know yet.
+    if (swipeInstance.current.isSwiping == null) {
+      const dx = Math.abs(currentX - swipeInstance.current.startX);
+      const dy = Math.abs(currentY - swipeInstance.current.startY);
+      const definitelySwiping = horizontalSwipe ? dx > dy && dx > UNCERTAINTY_THRESHOLD : dy > dx && dy > UNCERTAINTY_THRESHOLD;
+      if (definitelySwiping && nativeEvent.cancelable) {
+        nativeEvent.preventDefault();
+      }
+      if (definitelySwiping === true || (horizontalSwipe ? dy > UNCERTAINTY_THRESHOLD : dx > UNCERTAINTY_THRESHOLD)) {
+        swipeInstance.current.isSwiping = definitelySwiping;
+        if (!definitelySwiping) {
+          handleBodyTouchEnd(nativeEvent);
+          return;
+        }
+
+        // Shift the starting point.
+        swipeInstance.current.startX = currentX;
+        swipeInstance.current.startY = currentY;
+
+        // Compensate for the part of the drawer displayed on touch start.
+        if (!disableDiscovery && !open) {
+          if (horizontalSwipe) {
+            swipeInstance.current.startX -= DRAG_STARTED_SIGNAL;
+          } else {
+            swipeInstance.current.startY -= DRAG_STARTED_SIGNAL;
+          }
+        }
+      }
+    }
+    if (!swipeInstance.current.isSwiping) {
+      return;
+    }
+    const maxTranslate = getMaxTranslate(horizontalSwipe, paperRef.current);
+    let startLocation = horizontalSwipe ? swipeInstance.current.startX : swipeInstance.current.startY;
+    if (open && !swipeInstance.current.paperHit) {
+      startLocation = Math.min(startLocation, maxTranslate);
+    }
+    const translate = getTranslate(horizontalSwipe ? currentX : currentY, startLocation, open, maxTranslate);
+    if (open) {
+      if (!swipeInstance.current.paperHit) {
+        const paperHit = horizontalSwipe ? currentX < maxTranslate : currentY < maxTranslate;
+        if (paperHit) {
+          swipeInstance.current.paperHit = true;
+          swipeInstance.current.startX = currentX;
+          swipeInstance.current.startY = currentY;
+        } else {
+          return;
+        }
+      } else if (translate === 0) {
+        swipeInstance.current.startX = currentX;
+        swipeInstance.current.startY = currentY;
+      }
+    }
+    if (swipeInstance.current.lastTranslate === null) {
+      swipeInstance.current.lastTranslate = translate;
+      swipeInstance.current.lastTime = performance.now() + 1;
+    }
+    const velocity = (translate - swipeInstance.current.lastTranslate) / (performance.now() - swipeInstance.current.lastTime) * 1e3;
+
+    // Low Pass filter.
+    swipeInstance.current.velocity = swipeInstance.current.velocity * 0.4 + velocity * 0.6;
+    swipeInstance.current.lastTranslate = translate;
+    swipeInstance.current.lastTime = performance.now();
+
+    // We are swiping, let's prevent the scroll event on iOS.
+    if (nativeEvent.cancelable) {
+      nativeEvent.preventDefault();
+    }
+    setPosition(translate);
+  });
+  const handleBodyTouchStart = useEventCallback(nativeEvent => {
+    // We are not supposed to handle this touch move.
+    // Example of use case: ignore the event if there is a Slider.
+    if (nativeEvent.defaultPrevented) {
+      return;
+    }
+
+    // We can only have one node at the time claiming ownership for handling the swipe.
+    if (nativeEvent.defaultMuiPrevented) {
+      return;
+    }
+
+    // At least one element clogs the drawer interaction zone.
+    if (open && (hideBackdrop || !backdropRef.current.contains(nativeEvent.target)) && !paperRef.current.contains(nativeEvent.target)) {
+      return;
+    }
+    const anchorRtl = getAnchor(theme, anchor);
+    const horizontalSwipe = isHorizontal(anchor);
+    const currentX = calculateCurrentX(anchorRtl, nativeEvent.touches, ownerDocument(nativeEvent.currentTarget));
+    const currentY = calculateCurrentY(anchorRtl, nativeEvent.touches, ownerWindow(nativeEvent.currentTarget));
+    if (!open) {
+      // logic for if swipe should be ignored:
+      // if disableSwipeToOpen
+      // if target != swipeArea, and target is not a child of paper ref
+      // if is a child of paper ref, and `allowSwipeInChildren` does not allow it
+      if (disableSwipeToOpen || !(nativeEvent.target === swipeAreaRef.current || paperRef.current?.contains(nativeEvent.target) && (typeof allowSwipeInChildren === 'function' ? allowSwipeInChildren(nativeEvent, swipeAreaRef.current, paperRef.current) : allowSwipeInChildren))) {
+        return;
+      }
+      if (horizontalSwipe) {
+        if (currentX > swipeAreaWidth) {
+          return;
+        }
+      } else if (currentY > swipeAreaWidth) {
+        return;
+      }
+    }
+    nativeEvent.defaultMuiPrevented = true;
+    claimedSwipeInstance = null;
+    swipeInstance.current.startX = currentX;
+    swipeInstance.current.startY = currentY;
+    startMaybeSwiping();
+  });
+  React.useEffect(() => {
+    if (variant === 'temporary') {
+      const doc = ownerDocument(paperRef.current);
+      doc.addEventListener('touchstart', handleBodyTouchStart);
+      // A blocking listener prevents Firefox's navbar to auto-hide on scroll.
+      // It only needs to prevent scrolling on the drawer's content when open.
+      // When closed, the overlay prevents scrolling.
+      doc.addEventListener('touchmove', handleBodyTouchMove, {
+        passive: !open
+      });
+      doc.addEventListener('touchend', handleBodyTouchEnd);
+      return () => {
+        doc.removeEventListener('touchstart', handleBodyTouchStart);
+        doc.removeEventListener('touchmove', handleBodyTouchMove, {
+          passive: !open
+        });
+        doc.removeEventListener('touchend', handleBodyTouchEnd);
+      };
+    }
+    return undefined;
+  }, [variant, open, handleBodyTouchStart, handleBodyTouchMove, handleBodyTouchEnd]);
+  React.useEffect(() => () => {
+    // We need to release the lock.
+    if (claimedSwipeInstance === swipeInstance.current) {
+      claimedSwipeInstance = null;
+    }
+  }, []);
+  React.useEffect(() => {
+    if (!open) {
+      setMaybeSwiping(false);
+    }
+  }, [open]);
+  const [SwipeAreaSlot, swipeAreaSlotProps] = useSlot('swipeArea', {
+    ref: swipeAreaRef,
+    elementType: SwipeArea,
+    ownerState: props,
+    externalForwardedProps: {
+      slots,
+      slotProps: {
+        swipeArea: SwipeAreaProps,
+        ...slotProps
+      }
+    },
+    additionalProps: {
+      width: swipeAreaWidth,
+      anchor
+    }
+  });
+  return /*#__PURE__*/_jsxs(React.Fragment, {
+    children: [/*#__PURE__*/_jsx(Drawer, {
+      open: variant === 'temporary' && maybeSwiping ? true : open,
+      variant: variant,
+      ModalProps: {
+        BackdropProps: {
+          ...BackdropProps,
+          ref: backdropRef
+        },
+        // Ensures that paperRef.current will be defined inside the touch start event handler
+        // See https://github.com/mui/material-ui/issues/30414 for more information
+        ...(variant === 'temporary' && {
+          keepMounted: true
+        }),
+        ...ModalPropsProp
+      },
+      hideBackdrop: hideBackdrop,
+      anchor: anchor,
+      transitionDuration: calculatedDurationRef.current || transitionDuration,
+      onClose: onClose,
+      ref: ref,
+      slots: slots,
+      slotProps: {
+        ...slotProps,
+        backdrop: mergeSlotProps(slotProps.backdrop ?? BackdropProps, {
+          ref: backdropRef
+        }),
+        paper: mergeSlotProps(slotProps.paper ?? PaperProps, {
+          style: {
+            pointerEvents: variant === 'temporary' && !open && !allowSwipeInChildren ? 'none' : ''
+          },
+          ref: handleRef
+        })
+      },
+      ...other
+    }), !disableSwipeToOpen && variant === 'temporary' && /*#__PURE__*/_jsx(NoSsr, {
+      children: /*#__PURE__*/_jsx(SwipeAreaSlot, {
+        ...swipeAreaSlotProps
+      })
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" ? SwipeableDrawer.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 set to true, the swipe event will open the drawer even if the user begins the swipe on one of the drawer's children.
+   * This can be useful in scenarios where the drawer is partially visible.
+   * You can customize it further with a callback that determines which children the user can drag over to open the drawer
+   * (for example, to ignore other elements that handle touch move events, like sliders).
+   *
+   * @param {TouchEvent} event The 'touchstart' event
+   * @param {HTMLDivElement} swipeArea The swipe area element
+   * @param {HTMLDivElement} paper The drawer's paper element
+   *
+   * @default false
+   */
+  allowSwipeInChildren: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
+  /**
+   * @ignore
+   */
+  anchor: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  /**
+   * Disable the backdrop transition.
+   * This can improve the FPS on low-end devices.
+   * @default false
+   */
+  disableBackdropTransition: PropTypes.bool,
+  /**
+   * If `true`, touching the screen near the edge of the drawer will not slide in the drawer a bit
+   * to promote accidental discovery of the swipe gesture.
+   * @default false
+   */
+  disableDiscovery: PropTypes.bool,
+  /**
+   * If `true`, swipe to open is disabled. This is useful in browsers where swiping triggers
+   * navigation actions. Swipe to open is disabled on iOS browsers by default.
+   * @default typeof navigator !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent)
+   */
+  disableSwipeToOpen: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  hideBackdrop: PropTypes.bool,
+  /**
+   * Affects how far the drawer must be opened/closed to change its state.
+   * Specified as percent (0-1) of the width of the drawer
+   * @default 0.52
+   */
+  hysteresis: PropTypes.number,
+  /**
+   * Defines, from which (average) velocity on, the swipe is
+   * defined as complete although hysteresis isn't reached.
+   * Good threshold is between 250 - 1000 px/s
+   * @default 450
+   */
+  minFlingVelocity: PropTypes.number,
+  /**
+   * @ignore
+   */
+  ModalProps: PropTypes /* @typescript-to-proptypes-ignore */.shape({
+    BackdropProps: PropTypes.shape({
+      component: elementTypeAcceptingRef
+    })
+  }),
+  /**
+   * Callback fired when the component requests to be closed.
+   *
+   * @param {React.SyntheticEvent<{}>} event The event source of the callback.
+   */
+  onClose: PropTypes.func.isRequired,
+  /**
+   * Callback fired when the component requests to be opened.
+   *
+   * @param {React.SyntheticEvent<{}>} event The event source of the callback.
+   */
+  onOpen: PropTypes.func.isRequired,
+  /**
+   * If `true`, the component is shown.
+   * @default false
+   */
+  open: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  PaperProps: PropTypes /* @typescript-to-proptypes-ignore */.shape({
+    component: elementTypeAcceptingRef,
+    style: PropTypes.object
+  }),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: PropTypes.shape({
+    backdrop: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    docked: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    paper: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    swipeArea: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    transition: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: PropTypes.shape({
+    backdrop: PropTypes.elementType,
+    docked: PropTypes.elementType,
+    paper: PropTypes.elementType,
+    root: PropTypes.elementType,
+    swipeArea: PropTypes.elementType,
+    transition: PropTypes.elementType
+  }),
+  /**
+   * The element is used to intercept the touch events on the edge.
+   * @deprecated use the `slotProps.swipeArea` 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.
+   */
+  SwipeAreaProps: PropTypes.object,
+  /**
+   * The width of the left most (or right most) area in `px` that
+   * the drawer can be swiped open from.
+   * @default 20
+   */
+  swipeAreaWidth: PropTypes.number,
+  /**
+   * 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.oneOfType([PropTypes.number, PropTypes.shape({
+    appear: PropTypes.number,
+    enter: PropTypes.number,
+    exit: PropTypes.number
+  })]),
+  /**
+   * @ignore
+   */
+  variant: PropTypes.oneOf(['permanent', 'persistent', 'temporary'])
+} : void 0;
+export default SwipeableDrawer;

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

@@ -0,0 +1,338 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import composeClasses from '@mui/utils/composeClasses';
+import ButtonBase from "../ButtonBase/index.js";
+import capitalize from "../utils/capitalize.js";
+import { styled } from "../zero-styled/index.js";
+import memoTheme from "../utils/memoTheme.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import unsupportedProp from "../utils/unsupportedProp.js";
+import tabClasses, { getTabUtilityClass } from "./tabClasses.js";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    textColor,
+    fullWidth,
+    wrapped,
+    icon,
+    label,
+    selected,
+    disabled
+  } = ownerState;
+  const slots = {
+    root: ['root', icon && label && 'labelIcon', `textColor${capitalize(textColor)}`, fullWidth && 'fullWidth', wrapped && 'wrapped', selected && 'selected', disabled && 'disabled'],
+    icon: ['iconWrapper', 'icon']
+  };
+  return composeClasses(slots, getTabUtilityClass, classes);
+};
+const TabRoot = styled(ButtonBase, {
+  name: 'MuiTab',
+  slot: 'Root',
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, ownerState.label && ownerState.icon && styles.labelIcon, styles[`textColor${capitalize(ownerState.textColor)}`], ownerState.fullWidth && styles.fullWidth, ownerState.wrapped && styles.wrapped, {
+      [`& .${tabClasses.iconWrapper}`]: styles.iconWrapper
+    }, {
+      [`& .${tabClasses.icon}`]: styles.icon
+    }];
+  }
+})(memoTheme(({
+  theme
+}) => ({
+  ...theme.typography.button,
+  maxWidth: 360,
+  minWidth: 90,
+  position: 'relative',
+  minHeight: 48,
+  flexShrink: 0,
+  padding: '12px 16px',
+  overflow: 'hidden',
+  whiteSpace: 'normal',
+  textAlign: 'center',
+  lineHeight: 1.25,
+  variants: [{
+    props: ({
+      ownerState
+    }) => ownerState.label && (ownerState.iconPosition === 'top' || ownerState.iconPosition === 'bottom'),
+    style: {
+      flexDirection: 'column'
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.label && ownerState.iconPosition !== 'top' && ownerState.iconPosition !== 'bottom',
+    style: {
+      flexDirection: 'row'
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.icon && ownerState.label,
+    style: {
+      minHeight: 72,
+      paddingTop: 9,
+      paddingBottom: 9
+    }
+  }, {
+    props: ({
+      ownerState,
+      iconPosition
+    }) => ownerState.icon && ownerState.label && iconPosition === 'top',
+    style: {
+      [`& > .${tabClasses.icon}`]: {
+        marginBottom: 6
+      }
+    }
+  }, {
+    props: ({
+      ownerState,
+      iconPosition
+    }) => ownerState.icon && ownerState.label && iconPosition === 'bottom',
+    style: {
+      [`& > .${tabClasses.icon}`]: {
+        marginTop: 6
+      }
+    }
+  }, {
+    props: ({
+      ownerState,
+      iconPosition
+    }) => ownerState.icon && ownerState.label && iconPosition === 'start',
+    style: {
+      [`& > .${tabClasses.icon}`]: {
+        marginRight: theme.spacing(1)
+      }
+    }
+  }, {
+    props: ({
+      ownerState,
+      iconPosition
+    }) => ownerState.icon && ownerState.label && iconPosition === 'end',
+    style: {
+      [`& > .${tabClasses.icon}`]: {
+        marginLeft: theme.spacing(1)
+      }
+    }
+  }, {
+    props: {
+      textColor: 'inherit'
+    },
+    style: {
+      color: 'inherit',
+      opacity: 0.6,
+      // same opacity as theme.palette.text.secondary
+      [`&.${tabClasses.selected}`]: {
+        opacity: 1
+      },
+      [`&.${tabClasses.disabled}`]: {
+        opacity: (theme.vars || theme).palette.action.disabledOpacity
+      }
+    }
+  }, {
+    props: {
+      textColor: 'primary'
+    },
+    style: {
+      color: (theme.vars || theme).palette.text.secondary,
+      [`&.${tabClasses.selected}`]: {
+        color: (theme.vars || theme).palette.primary.main
+      },
+      [`&.${tabClasses.disabled}`]: {
+        color: (theme.vars || theme).palette.text.disabled
+      }
+    }
+  }, {
+    props: {
+      textColor: 'secondary'
+    },
+    style: {
+      color: (theme.vars || theme).palette.text.secondary,
+      [`&.${tabClasses.selected}`]: {
+        color: (theme.vars || theme).palette.secondary.main
+      },
+      [`&.${tabClasses.disabled}`]: {
+        color: (theme.vars || theme).palette.text.disabled
+      }
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.fullWidth,
+    style: {
+      flexShrink: 1,
+      flexGrow: 1,
+      flexBasis: 0,
+      maxWidth: 'none'
+    }
+  }, {
+    props: ({
+      ownerState
+    }) => ownerState.wrapped,
+    style: {
+      fontSize: theme.typography.pxToRem(12)
+    }
+  }]
+})));
+const Tab = /*#__PURE__*/React.forwardRef(function Tab(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: 'MuiTab'
+  });
+  const {
+    className,
+    disabled = false,
+    disableFocusRipple = false,
+    // eslint-disable-next-line react/prop-types
+    fullWidth,
+    icon: iconProp,
+    iconPosition = 'top',
+    // eslint-disable-next-line react/prop-types
+    indicator,
+    label,
+    onChange,
+    onClick,
+    onFocus,
+    // eslint-disable-next-line react/prop-types
+    selected,
+    // eslint-disable-next-line react/prop-types
+    selectionFollowsFocus,
+    // eslint-disable-next-line react/prop-types
+    textColor = 'inherit',
+    value,
+    wrapped = false,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    disabled,
+    disableFocusRipple,
+    selected,
+    icon: !!iconProp,
+    iconPosition,
+    label: !!label,
+    fullWidth,
+    textColor,
+    wrapped
+  };
+  const classes = useUtilityClasses(ownerState);
+  const icon = iconProp && label && /*#__PURE__*/React.isValidElement(iconProp) ? /*#__PURE__*/React.cloneElement(iconProp, {
+    className: clsx(classes.icon, iconProp.props.className)
+  }) : iconProp;
+  const handleClick = event => {
+    if (!selected && onChange) {
+      onChange(event, value);
+    }
+    if (onClick) {
+      onClick(event);
+    }
+  };
+  const handleFocus = event => {
+    if (selectionFollowsFocus && !selected && onChange) {
+      onChange(event, value);
+    }
+    if (onFocus) {
+      onFocus(event);
+    }
+  };
+  return /*#__PURE__*/_jsxs(TabRoot, {
+    focusRipple: !disableFocusRipple,
+    className: clsx(classes.root, className),
+    ref: ref,
+    role: "tab",
+    "aria-selected": selected,
+    disabled: disabled,
+    onClick: handleClick,
+    onFocus: handleFocus,
+    ownerState: ownerState,
+    tabIndex: selected ? 0 : -1,
+    ...other,
+    children: [iconPosition === 'top' || iconPosition === 'start' ? /*#__PURE__*/_jsxs(React.Fragment, {
+      children: [icon, label]
+    }) : /*#__PURE__*/_jsxs(React.Fragment, {
+      children: [label, icon]
+    }), indicator]
+  });
+});
+process.env.NODE_ENV !== "production" ? Tab.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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * This prop isn't supported.
+   * Use the `component` prop if you need to change the children structure.
+   */
+  children: unsupportedProp,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: PropTypes.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.bool,
+  /**
+   * The icon to display.
+   */
+  icon: PropTypes.oneOfType([PropTypes.element, PropTypes.string]),
+  /**
+   * The position of the icon relative to the label.
+   * @default 'top'
+   */
+  iconPosition: PropTypes.oneOf(['bottom', 'end', 'start', 'top']),
+  /**
+   * The label element.
+   */
+  label: PropTypes.node,
+  /**
+   * @ignore
+   */
+  onChange: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onClick: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onFocus: PropTypes.func,
+  /**
+   * 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]),
+  /**
+   * You can provide your own value. Otherwise, we fallback to the child position index.
+   */
+  value: PropTypes.any,
+  /**
+   * Tab labels appear in a single row.
+   * They can use a second line if needed.
+   * @default false
+   */
+  wrapped: PropTypes.bool
+} : void 0;
+export default Tab;

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

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

node_modules/@mui/material/esm/TableCell/tableCellClasses.d.ts

@@ -0,0 +1,32 @@
+export interface TableCellClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `variant="head"` or `context.table.head`. */
+  head: string;
+  /** Styles applied to the root element if `variant="body"` or `context.table.body`. */
+  body: string;
+  /** Styles applied to the root element if `variant="footer"` or `context.table.footer`. */
+  footer: 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 `padding="checkbox"`. */
+  paddingCheckbox: string;
+  /** Styles applied to the root element if `padding="none"`. */
+  paddingNone: string;
+  /** Styles applied to the root element if `align="left"`. */
+  alignLeft: string;
+  /** Styles applied to the root element if `align="center"`. */
+  alignCenter: string;
+  /** Styles applied to the root element if `align="right"`. */
+  alignRight: string;
+  /** Styles applied to the root element if `align="justify"`. */
+  alignJustify: string;
+  /** Styles applied to the root element if `context.table.stickyHeader={true}`. */
+  stickyHeader: string;
+}
+export type TableCellClassKey = keyof TableCellClasses;
+export declare function getTableCellUtilityClass(slot: string): string;
+declare const tableCellClasses: TableCellClasses;
+export default tableCellClasses;

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

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from "../styles/index.js";
+import { OverridableComponent, OverrideProps } from "../OverridableComponent/index.js";
+import { TableFooterClasses } from "./tableFooterClasses.js";
+export interface TableFooterOwnProps {
+  /**
+   * The content of the component, normally `TableRow`.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<TableFooterClasses>;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}
+export interface TableFooterTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'tfoot'> {
+  props: AdditionalProps & TableFooterOwnProps;
+  defaultComponent: RootComponent;
+}
+/**
+ *
+ * Demos:
+ *
+ * - [Table](https://mui.com/material-ui/react-table/)
+ *
+ * API:
+ *
+ * - [TableFooter API](https://mui.com/material-ui/api/table-footer/)
+ */
+declare const TableFooter: OverridableComponent<TableFooterTypeMap>;
+export type TableFooterProps<RootComponent extends React.ElementType = TableFooterTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<TableFooterTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default TableFooter;

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

@@ -0,0 +1,85 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import composeClasses from '@mui/utils/composeClasses';
+import Tablelvl2Context from "../Table/Tablelvl2Context.js";
+import { styled } from "../zero-styled/index.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import { getTableFooterUtilityClass } from "./tableFooterClasses.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root']
+  };
+  return composeClasses(slots, getTableFooterUtilityClass, classes);
+};
+const TableFooterRoot = styled('tfoot', {
+  name: 'MuiTableFooter',
+  slot: 'Root'
+})({
+  display: 'table-footer-group'
+});
+const tablelvl2 = {
+  variant: 'footer'
+};
+const defaultComponent = 'tfoot';
+const TableFooter = /*#__PURE__*/React.forwardRef(function TableFooter(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: 'MuiTableFooter'
+  });
+  const {
+    className,
+    component = defaultComponent,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    component
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(Tablelvl2Context.Provider, {
+    value: tablelvl2,
+    children: /*#__PURE__*/_jsx(TableFooterRoot, {
+      as: component,
+      className: clsx(classes.root, className),
+      ref: ref,
+      role: component === defaultComponent ? null : 'rowgroup',
+      ownerState: ownerState,
+      ...other
+    })
+  });
+});
+process.env.NODE_ENV !== "production" ? TableFooter.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.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 TableFooter;

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

@@ -0,0 +1,85 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import composeClasses from '@mui/utils/composeClasses';
+import Tablelvl2Context from "../Table/Tablelvl2Context.js";
+import { styled } from "../zero-styled/index.js";
+import { useDefaultProps } from "../DefaultPropsProvider/index.js";
+import { getTableHeadUtilityClass } from "./tableHeadClasses.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root']
+  };
+  return composeClasses(slots, getTableHeadUtilityClass, classes);
+};
+const TableHeadRoot = 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 = useDefaultProps({
+    props: inProps,
+    name: 'MuiTableHead'
+  });
+  const {
+    className,
+    component = defaultComponent,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    component
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(Tablelvl2Context.Provider, {
+    value: tablelvl2,
+    children: /*#__PURE__*/_jsx(TableHeadRoot, {
+      as: component,
+      className: clsx(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.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 TableHead;

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

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

node_modules/@mui/material/esm/TableRow/tableRowClasses.d.ts

@@ -0,0 +1,16 @@
+export interface TableRowClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** State class applied to the root element if `selected={true}`. */
+  selected: string;
+  /** State class applied to the root element if `hover={true}`. */
+  hover: string;
+  /** Styles applied to the root element if table variant="head". */
+  head: string;
+  /** Styles applied to the root element if table variant="footer". */
+  footer: string;
+}
+export type TableRowClassKey = keyof TableRowClasses;
+export declare function getTableRowUtilityClass(slot: string): string;
+declare const tableRowClasses: TableRowClasses;
+export default tableRowClasses;

node_modules/@mui/material/esm/TableSortLabel/tableSortLabelClasses.d.ts

@@ -0,0 +1,24 @@
+export interface TableSortLabelClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `direction="desc"`. */
+  directionDesc: string;
+  /** Styles applied to the root element if `direction="asc"`. */
+  directionAsc: string;
+  /** State class applied to the root element if `active={true}`. */
+  active: string;
+  /** Styles applied to the icon component. */
+  icon: string;
+  /** Styles applied to the icon component if `direction="desc"`.
+   * @deprecated Combine the [.MuiTableSortLabel-icon](/material-ui/api/table-sort-label/#TableSortLabel-css-MuiTableSortLabel-icon) and [.MuiTableSortLabel-directionDesc](/material-ui/api/table-sort-label/#table-sort-label-classes-MuiTableSortLabel-directionDesc) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconDirectionDesc: string;
+  /** Styles applied to the icon component if `direction="asc"`.
+   * @deprecated Combine the [.MuiTableSortLabel-icon](/material-ui/api/table-sort-label/#TableSortLabel-css-MuiTableSortLabel-icon) and [.MuiTableSortLabel-directionAsc](/material-ui/api/table-sort-label/#table-sort-label-classes-MuiTableSortLabel-directionAsc) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  iconDirectionAsc: string;
+}
+export type TableSortLabelClassKey = keyof TableSortLabelClasses;
+export declare function getTableSortLabelUtilityClass(slot: string): string;
+declare const tableSortLabelClasses: TableSortLabelClasses;
+export default tableSortLabelClasses;

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

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

node_modules/@mui/material/esm/TextField/textFieldClasses.d.ts

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

node_modules/@mui/material/esm/ToggleButtonGroup/toggleButtonGroupClasses.d.ts

@@ -0,0 +1,34 @@
+export interface ToggleButtonGroupClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** State class applied to the root element if `selected={true}`. */
+  selected: string;
+  /** Styles applied to the root element if `orientation="horizontal"`. */
+  horizontal: string;
+  /** Styles applied to the root element if `orientation="vertical"`. */
+  vertical: string;
+  /** State class applied to the root element if `disabled={true}`. */
+  disabled: string;
+  /** Styles applied to the children. */
+  grouped: string;
+  /** Styles applied to the children if `orientation="horizontal"`.
+   *  @deprecated Combine the [.MuiToggleButtonGroup-horizontal](/material-ui/api/toggle-button-group/#toggle-button-group-classes-MuiToggleButtonGroup-horizontal) and [.MuiToggleButtonGroup-grouped](/material-ui/api/toggle-button-group/#toggle-button-group-classes-MuiToggleButtonGroup-grouped) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  groupedHorizontal: string;
+  /** Styles applied to the children if `orientation="vertical"`.
+   * @deprecated Combine the [.MuiToggleButtonGroup-vertical](/material-ui/api/toggle-button-group/#toggle-button-group-classes-MuiToggleButtonGroup-vertical) and [.MuiToggleButtonGroup-grouped](/material-ui/api/toggle-button-group/#toggle-button-group-classes-MuiToggleButtonGroup-grouped) classes instead. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  groupedVertical: string;
+  /** Styles applied to the root element if `fullWidth={true}`. */
+  fullWidth: string;
+  /** Styles applied to the first button in the toggle button group. */
+  firstButton: string;
+  /** Styles applied to the last button in the toggle button group. */
+  lastButton: string;
+  /** Styles applied to buttons in the middle of the toggle button group. */
+  middleButton: string;
+}
+export type ToggleButtonGroupClassKey = keyof ToggleButtonGroupClasses;
+export declare function getToggleButtonGroupUtilityClass(slot: string): string;
+declare const toggleButtonGroupClasses: ToggleButtonGroupClasses;
+export default toggleButtonGroupClasses;

node_modules/@mui/material/esm/colors/cyan.js

@@ -0,0 +1,17 @@
+const cyan = {
+  50: '#e0f7fa',
+  100: '#b2ebf2',
+  200: '#80deea',
+  300: '#4dd0e1',
+  400: '#26c6da',
+  500: '#00bcd4',
+  600: '#00acc1',
+  700: '#0097a7',
+  800: '#00838f',
+  900: '#006064',
+  A100: '#84ffff',
+  A200: '#18ffff',
+  A400: '#00e5ff',
+  A700: '#00b8d4'
+};
+export default cyan;

node_modules/@mui/material/esm/colors/deepOrange.js

@@ -0,0 +1,17 @@
+const deepOrange = {
+  50: '#fbe9e7',
+  100: '#ffccbc',
+  200: '#ffab91',
+  300: '#ff8a65',
+  400: '#ff7043',
+  500: '#ff5722',
+  600: '#f4511e',
+  700: '#e64a19',
+  800: '#d84315',
+  900: '#bf360c',
+  A100: '#ff9e80',
+  A200: '#ff6e40',
+  A400: '#ff3d00',
+  A700: '#dd2c00'
+};
+export default deepOrange;

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

@@ -0,0 +1,20 @@
+export { default as amber } from "./amber.js";
+export { default as blue } from "./blue.js";
+export { default as blueGrey } from "./blueGrey.js";
+export { default as brown } from "./brown.js";
+export { default as common } from "./common.js";
+export { default as cyan } from "./cyan.js";
+export { default as deepOrange } from "./deepOrange.js";
+export { default as deepPurple } from "./deepPurple.js";
+export { default as green } from "./green.js";
+export { default as grey } from "./grey.js";
+export { default as indigo } from "./indigo.js";
+export { default as lightBlue } from "./lightBlue.js";
+export { default as lightGreen } from "./lightGreen.js";
+export { default as lime } from "./lime.js";
+export { default as orange } from "./orange.js";
+export { default as pink } from "./pink.js";
+export { default as purple } from "./purple.js";
+export { default as red } from "./red.js";
+export { default as teal } from "./teal.js";
+export { default as yellow } from "./yellow.js";

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

@@ -0,0 +1,2 @@
+export { default } from '@mui/utils/generateUtilityClass';
+export type { GlobalStateSlot } from '@mui/utils/generateUtilityClass';

node_modules/@mui/material/esm/internal/svg-icons/MoreHoriz.js

@@ -0,0 +1,11 @@
+'use client';
+
+import createSvgIcon from "../../utils/createSvgIcon.js";
+
+/**
+ * @ignore - internal component.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export default createSvgIcon(/*#__PURE__*/_jsx("path", {
+  d: "M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"
+}), 'MoreHoriz');

node_modules/@mui/material/esm/internal/svg-icons/StarBorder.js

@@ -0,0 +1,11 @@
+'use client';
+
+import createSvgIcon from "../../utils/createSvgIcon.js";
+
+/**
+ * @ignore - internal component.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export default createSvgIcon(/*#__PURE__*/_jsx("path", {
+  d: "M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"
+}), 'StarBorder');

node_modules/@mui/material/esm/locale/amET.d.ts

@@ -0,0 +1,2 @@
+import type { Localization } from "./utils/LocaleTextApi.js";
+export declare const amET: Localization;

node_modules/@mui/material/esm/locale/arSD.js

@@ -0,0 +1,73 @@
+export const arSD = {
+  components: {
+    MuiBreadcrumbs: {
+      defaultProps: {
+        expandText: 'إظهار المسار'
+      }
+    },
+    MuiTablePagination: {
+      defaultProps: {
+        getItemAriaLabel: type => {
+          if (type === 'first') {
+            return 'انتقل إلى الصفحة الأولى';
+          }
+          if (type === 'last') {
+            return 'انتقل إلى الصفحة الأخيرة';
+          }
+          if (type === 'next') {
+            return 'انتقل إلى الصفحة التالية';
+          }
+          // if (type === 'previous') {
+          return 'انتقل إلى الصفحة السابقة';
+        },
+        labelRowsPerPage: 'عدد الصفوف في الصفحة:',
+        labelDisplayedRows: ({
+          from,
+          to,
+          count
+        }) => `${from}–${to} من ${count !== -1 ? count : ` أكثر من${to}`}`
+      }
+    },
+    MuiRating: {
+      defaultProps: {
+        getLabelText: value => `${value} ${value !== 1 ? 'نجوم' : 'نجمة'}`,
+        emptyLabelText: 'فارغ'
+      }
+    },
+    MuiAutocomplete: {
+      defaultProps: {
+        clearText: 'مسح',
+        closeText: 'إغلاق',
+        loadingText: 'جار التحميل...',
+        noOptionsText: 'لا يوجد خيارات',
+        openText: 'فتح'
+      }
+    },
+    MuiAlert: {
+      defaultProps: {
+        closeText: 'إغلاق'
+      }
+    },
+    MuiPagination: {
+      defaultProps: {
+        'aria-label': 'التنقل عبر الصفحات',
+        getItemAriaLabel: (type, page, selected) => {
+          if (type === 'page') {
+            return `${selected ? '' : 'انتقل إلى '} صفحة ${page}`;
+          }
+          if (type === 'first') {
+            return 'انتقل إلى الصفحة الأولى';
+          }
+          if (type === 'last') {
+            return 'انتقل الي الصفحة الأخيرة';
+          }
+          if (type === 'next') {
+            return 'انتقل إلى الصفحة التالية';
+          }
+          // if (type === 'previous') {
+          return 'انتقل إلى الصفحة السابقة';
+        }
+      }
+    }
+  }
+};

node_modules/@mui/material/esm/locale/beBY.js

@@ -0,0 +1,85 @@
+export const beBY = {
+  components: {
+    MuiBreadcrumbs: {
+      defaultProps: {
+        expandText: 'Паказаць шлях'
+      }
+    },
+    MuiTablePagination: {
+      defaultProps: {
+        getItemAriaLabel: type => {
+          if (type === 'first') {
+            return 'Перайсці на першую старонку';
+          }
+          if (type === 'last') {
+            return 'Перайсці на апошнюю старонку';
+          }
+          if (type === 'next') {
+            return 'Перайсці на наступную старонку';
+          }
+          // if (type === 'previous') {
+          return 'Перайсці на папярэднюю старонку';
+        },
+        labelRowsPerPage: 'Радкоў на старонцы:',
+        labelDisplayedRows: ({
+          from,
+          to,
+          count
+        }) => `${from}–${to} з ${count !== -1 ? count : `больш чым ${to}`}`
+      }
+    },
+    MuiRating: {
+      defaultProps: {
+        getLabelText: value => {
+          let pluralForm = 'Зорак';
+          const lastDigit = value % 10;
+          if (lastDigit > 1 && lastDigit < 5 && (value < 10 || value > 20)) {
+            pluralForm = 'Зоркі';
+          } else if (lastDigit === 1 && value % 100 !== 11) {
+            pluralForm = 'Зорка';
+          }
+          return `${value} ${pluralForm}`;
+        },
+        emptyLabelText: 'Рэйтынг адсутнічае'
+      }
+    },
+    MuiAutocomplete: {
+      defaultProps: {
+        clearText: 'Ачысціць',
+        closeText: 'Закрыць',
+        loadingText: 'Загрузка…',
+        noOptionsText: 'Няма варыянтаў',
+        openText: 'Адкрыць'
+      }
+    },
+    MuiAlert: {
+      defaultProps: {
+        closeText: 'Закрыць'
+      }
+    },
+    MuiPagination: {
+      defaultProps: {
+        'aria-label': 'Навігацыя па старонкам',
+        getItemAriaLabel: (type, page, selected) => {
+          if (type === 'page') {
+            if (selected) {
+              return `${page} старонка`;
+            }
+            return `Перайсці на ${page} старонку`;
+          }
+          if (type === 'first') {
+            return 'Перайсці на першую старонку';
+          }
+          if (type === 'last') {
+            return 'Перайсці на апошнюю старонку';
+          }
+          if (type === 'next') {
+            return 'Перайсці на наступную старонку';
+          }
+          // if (type === 'previous') {
+          return 'Перайсці на папярэднюю старонку';
+        }
+      }
+    }
+  }
+};

node_modules/@mui/material/esm/locale/daDK.js

@@ -0,0 +1,73 @@
+export const daDK = {
+  components: {
+    MuiBreadcrumbs: {
+      defaultProps: {
+        expandText: 'Vis sti'
+      }
+    },
+    MuiTablePagination: {
+      defaultProps: {
+        getItemAriaLabel: type => {
+          if (type === 'first') {
+            return 'Gå til den første side';
+          }
+          if (type === 'last') {
+            return 'Gå til den sidste side';
+          }
+          if (type === 'next') {
+            return 'Gå til den næste side';
+          }
+          // if (type === 'previous') {
+          return 'Gå til den forrige side';
+        },
+        labelRowsPerPage: 'Rækker pr side:',
+        labelDisplayedRows: ({
+          from,
+          to,
+          count
+        }) => `${from}-${to} af ${count !== -1 ? count : `mere end ${to}`}`
+      }
+    },
+    MuiRating: {
+      defaultProps: {
+        getLabelText: value => `${value} Stjern${value !== 1 ? 'er' : ''}`,
+        emptyLabelText: 'Tom'
+      }
+    },
+    MuiAutocomplete: {
+      defaultProps: {
+        clearText: 'Slet',
+        closeText: 'Luk',
+        loadingText: 'Indlæser…',
+        noOptionsText: 'Ingen muligheder',
+        openText: 'Åben'
+      }
+    },
+    MuiAlert: {
+      defaultProps: {
+        closeText: 'Luk'
+      }
+    },
+    MuiPagination: {
+      defaultProps: {
+        'aria-label': 'Sideinddelings navigation',
+        getItemAriaLabel: (type, page, selected) => {
+          if (type === 'page') {
+            return `${selected ? '' : 'Go to '}page ${page}`;
+          }
+          if (type === 'first') {
+            return 'Gå til den første side';
+          }
+          if (type === 'last') {
+            return 'Gå til den sidste side';
+          }
+          if (type === 'next') {
+            return 'Gå til den næste side';
+          }
+          // if (type === 'previous') {
+          return 'Gå til den forrige side';
+        }
+      }
+    }
+  }
+};

node_modules/@mui/material/esm/locale/jaJP.js

@@ -0,0 +1,73 @@
+export const jaJP = {
+  components: {
+    MuiBreadcrumbs: {
+      defaultProps: {
+        expandText: 'すべて表示'
+      }
+    },
+    MuiTablePagination: {
+      defaultProps: {
+        getItemAriaLabel: type => {
+          if (type === 'first') {
+            return '最初のページへ';
+          }
+          if (type === 'last') {
+            return '最後のページへ';
+          }
+          if (type === 'next') {
+            return '次のページへ';
+          }
+          // if (type === 'previous') {
+          return '前のページへ';
+        },
+        labelRowsPerPage: 'ページあたりの行数:',
+        labelDisplayedRows: ({
+          from,
+          to,
+          count
+        }) => `${from}～${to} / ${count !== -1 ? count : `${to}以上`}`
+      }
+    },
+    MuiRating: {
+      defaultProps: {
+        getLabelText: value => `星${value}`,
+        emptyLabelText: '星なし'
+      }
+    },
+    MuiAutocomplete: {
+      defaultProps: {
+        clearText: 'クリア',
+        closeText: '閉じる',
+        loadingText: '読み込み中…',
+        noOptionsText: 'データがありません',
+        openText: '開く'
+      }
+    },
+    MuiAlert: {
+      defaultProps: {
+        closeText: '閉じる'
+      }
+    },
+    MuiPagination: {
+      defaultProps: {
+        'aria-label': 'ページ選択',
+        getItemAriaLabel: (type, page, selected) => {
+          if (type === 'page') {
+            return `ページ${page}${selected ? '' : 'へ'}`;
+          }
+          if (type === 'first') {
+            return '最初のページへ';
+          }
+          if (type === 'last') {
+            return '最後のページへ';
+          }
+          if (type === 'next') {
+            return '次のページへ';
+          }
+          // if (type === 'previous') {
+          return '前のページへ';
+        }
+      }
+    }
+  }
+};

node_modules/@mui/material/esm/locale/kkKZ.d.ts

@@ -0,0 +1,2 @@
+import type { Localization } from "./utils/LocaleTextApi.js";
+export declare const kkKZ: Localization;

node_modules/@mui/material/esm/locale/psAF.d.ts

@@ -0,0 +1,2 @@
+import type { Localization } from "./utils/LocaleTextApi.js";
+export declare const psAF: Localization;

node_modules/@mui/material/esm/locale/tlTL.js

@@ -0,0 +1,74 @@
+// Tagalog-Tagalog
+export const tlTL = {
+  components: {
+    MuiBreadcrumbs: {
+      defaultProps: {
+        expandText: 'Ipakita ang landas'
+      }
+    },
+    MuiTablePagination: {
+      defaultProps: {
+        getItemAriaLabel: type => {
+          if (type === 'first') {
+            return 'Pumunta sa unang pahina';
+          }
+          if (type === 'last') {
+            return 'Pumunta sa huling pahina';
+          }
+          if (type === 'next') {
+            return 'Pumunta sa susunod na pahina';
+          }
+          // if (type === 'previous') {
+          return 'Pumunta sa nakaraang pahina';
+        },
+        labelRowsPerPage: 'Mga hilera bawat pahina:',
+        labelDisplayedRows: ({
+          from,
+          to,
+          count
+        }) => `${from}–${to} ng ${count !== -1 ? count : `higit sa ${to}`}`
+      }
+    },
+    MuiRating: {
+      defaultProps: {
+        getLabelText: value => `${value} Bituin${value !== 1 ? 's' : ''}`,
+        emptyLabelText: 'Walang laman'
+      }
+    },
+    MuiAutocomplete: {
+      defaultProps: {
+        clearText: 'Maaliwalas',
+        closeText: 'Isara',
+        loadingText: 'Naglo-load…',
+        noOptionsText: 'Walang mga pagpipilian',
+        openText: 'Bukas'
+      }
+    },
+    MuiAlert: {
+      defaultProps: {
+        closeText: 'Isara'
+      }
+    },
+    MuiPagination: {
+      defaultProps: {
+        'aria-label': 'Sayfa navigasyonu',
+        getItemAriaLabel: (type, page, selected) => {
+          if (type === 'page') {
+            return `${selected ? '' : 'Pumunta sa'}pahina ${page}`;
+          }
+          if (type === 'first') {
+            return 'Pumunta sa unang pahina';
+          }
+          if (type === 'last') {
+            return 'Pumunta sa huling pahina';
+          }
+          if (type === 'next') {
+            return 'Pumunta sa susunod na pahina';
+          }
+          // if (type === 'previous') {
+          return 'Pumunta sa nakaraang pahina';
+        }
+      }
+    }
+  }
+};

node_modules/@mui/material/esm/styles/ThemeProviderWithVars.d.ts

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

node_modules/@mui/material/esm/styles/components.js

@@ -0,0 +1 @@
+export {};

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

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

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

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

node_modules/@mui/material/esm/styles/overrides.js

@@ -0,0 +1 @@
+export {};

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

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

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

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

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

@@ -0,0 +1 @@
+export { default } from "./useScrollTrigger.js";

node_modules/@mui/material/esm/utils/getScrollbarSize.d.ts

@@ -0,0 +1,2 @@
+import getScrollbarSize from '@mui/utils/getScrollbarSize';
+export default getScrollbarSize;

node_modules/@mui/material/esm/utils/getScrollbarSize.js

@@ -0,0 +1,2 @@
+import getScrollbarSize from '@mui/utils/getScrollbarSize';
+export default getScrollbarSize;

node_modules/@mui/material/esm/utils/shouldSpreadAdditionalProps.js

@@ -0,0 +1,5 @@
+import isHostComponent from '@mui/utils/isHostComponent';
+const shouldSpreadAdditionalProps = Slot => {
+  return !Slot || !isHostComponent(Slot);
+};
+export default shouldSpreadAdditionalProps;