iobroker.vis-2
Version:
Next generation graphical user interface for ioBroker.
11,519 lines • 359 kB
JavaScript
import { C as defaultTheme, T as THEME_ID, y as createTypography, a as createTheme, u as useDefaultProps, s as styled, m as memoTheme, r as rootShouldForwardProp, v as getOverlayAlpha, j as slotShouldForwardProp, c as createSvgIcon, __tla as __tla_0 } from "./createSvgIcon-BEOyHFEj.js";
import { a as useEnhancedEffect, c as useThemeProps$1, e as extendSxProp$1, b as useId, i as isMuiElement, u as useRtl, d as unstable_createUseMediaQuery, __tla as __tla_1 } from "./useMediaQuery-DfRjuqob.js";
import { e as __mf_31, _ as __mf_32, i as __mf_20, c as __mf_29, h as __mf_24, k as __mf_35, g as __mf_14, a as React, p as __mf_15, n as __mf_9, u as __mf_0, l as __mf_26, d as __mf_10, b as __mf_21, f as __mf_2$1, __tla as __tla_2 } from "./iobroker_vis__loadShare__react__loadShare__.js-QKtVi7r1.js";
import { e as __mf_52, x as __mf_7, y as __mf_39, z as __mf_2, h as __mf_27, g as __mf_17, __tla as __tla_3 } from "./iobroker_vis__loadShare___mf_0_mui_mf_1_system__loadShare__.js-Zvkdie3d.js";
import { j as jsxRuntimeExports, __tla as __tla_4 } from "./jsx-runtime-DXKJPqi2.js";
import { s as styleFunctionSx, g as generateUtilityClass, a as generateUtilityClasses, c as composeClasses, b as alpha, r as resolveProps, __tla as __tla_5 } from "./createStyled-CtLRJdF1.js";
import { __tla as __tla_6 } from "./iobroker_vis__loadShare__prop_mf_2_types__loadShare__.js-OoAqYupB.js";
import { c as clsx, a as capitalize, f as formatMuiErrorMessage, d as deepmerge, __tla as __tla_7 } from "./clsx-DKpeWZFz.js";
import { b as _inheritsLoose, _ as _objectWithoutPropertiesLoose, a as _extends, c as _assertThisInitialized } from "./assertThisInitialized-DtkDSj7h.js";
import { R as ReactDOM, a as __mf_1, __tla as __tla_8 } from "./iobroker_vis__loadShare__react_mf_2_dom__loadShare__.js-D8CM_cOC.js";
let ArrowDropDownIcon, DialogContent, ButtonBase, Chip, DialogActions, ThemeProvider, FormHelperText, Grow, getDividerUtilityClass, IconButton, ListContext, getListItemIconUtilityClass, List, MenuItem, useSlot, getListItemTextUtilityClass, Paper, listItemTextClasses, typographyClasses, getListItemButtonUtilityClass, Transition, listItemButtonClasses, debounce$1, ownerWindow, useTimeout, getTransitionProps, createSimplePaletteValueFilter, setRef, useSlotProps, getFormHelperTextUtilityClasses, filledInputClasses, inputBaseClasses, outlinedInputClasses, inputClasses, ButtonGroupContext, ButtonGroupButtonContext, mergeSlotProps, getReactElementRef, globalCss, DialogContext, Popover, PopoverPaper, PopoverRoot, Portal, TextareaAutosize, backdropClasses, buttonBaseClasses, buttonClasses, chipClasses, circularProgressClasses, dialogActionsClasses, dialogContentClasses, dialogTitleClasses, dividerClasses, formControlClasses, formHelperTextClasses, formLabelClasses, getBackdropUtilityClass, getButtonBaseUtilityClass, getButtonUtilityClass, getChipUtilityClass, getCircularProgressUtilityClass, getDialogActionsUtilityClass, getDialogContentUtilityClass, getDialogUtilityClass, getFilledInputUtilityClass, getFormControlUtilityClasses, getDialogTitleUtilityClass, reflow, Modal, formControlState, isFocusVisible, NativeSelectInput, Input, getNativeSelectUtilityClasses, createChainedFunction, extractEventHandlers, isHostComponent, Timeout, InputBase, Select, Backdrop, CircularProgress, CssVarsProvider, Experimental_CssVarsProvider, FilledInput, FormLabel, FormLabelRoot, GlobalStyles, ListItemSecondaryAction, Menu, ModalManager, OutlinedInput, Typography, getFormLabelUtilityClasses, getIconButtonUtilityClass, getInitColorSchemeScript, getInputAdornmentUtilityClass, getInputBaseUtilityClass, getInputLabelUtilityClasses, getInputUtilityClass, getListItemSecondaryActionClassesUtilityClass, getListItemUtilityClass, getListUtilityClass, selectClasses, textFieldClasses, touchRippleClasses, useColorScheme, getMenuItemUtilityClass, getMenuUtilityClass, getModalUtilityClass, getOffsetLeft, getOffsetTop, getOutlinedInputUtilityClass, getPaperUtilityClass, getPopoverUtilityClass, getPopperUtilityClass, getSelectUtilityClasses, getTextFieldUtilityClass, getTouchRippleUtilityClass, getTypographyUtilityClass, iconButtonClasses, inputAdornmentClasses, inputLabelClasses, listClasses, listItemClasses, listItemIconClasses, listItemSecondaryActionClasses, menuClasses, menuItemClasses, modalClasses, nativeSelectClasses, paperClasses, popoverClasses, useControlled, useEventCallback, useForkRef, forceReflow, MenuList, InputAdornment, useFormControl, InputLabel, FormControl, TextField, useTheme, Fade, TransitionGroup, useMediaQuery, FocusTrap, ownerDocument, Popper, Button, useThemeProps, visuallyHidden, ListItem, resolveComponentProps, Dialog, dialogClasses;
let __tla = Promise.all([
(() => {
try {
return __tla_0;
} catch {
}
})(),
(() => {
try {
return __tla_1;
} catch {
}
})(),
(() => {
try {
return __tla_2;
} catch {
}
})(),
(() => {
try {
return __tla_3;
} catch {
}
})(),
(() => {
try {
return __tla_4;
} catch {
}
})(),
(() => {
try {
return __tla_5;
} catch {
}
})(),
(() => {
try {
return __tla_6;
} catch {
}
})(),
(() => {
try {
return __tla_7;
} catch {
}
})(),
(() => {
try {
return __tla_8;
} catch {
}
})()
]).then(async () => {
createChainedFunction = function(...funcs) {
return funcs.reduce((acc, func) => {
if (func == null) {
return acc;
}
return function chainedFunction(...args) {
acc.apply(this, args);
func.apply(this, args);
};
}, () => {
});
};
debounce$1 = function(func, wait = 166) {
let timeout;
function debounced(...args) {
const later = () => {
func.apply(this, args);
};
clearTimeout(timeout);
timeout = setTimeout(later, wait);
}
debounced.clear = () => {
clearTimeout(timeout);
};
return debounced;
};
ownerDocument = function(node) {
return node && node.ownerDocument || document;
};
ownerWindow = function(node) {
const doc = ownerDocument(node);
return doc.defaultView || window;
};
setRef = function(ref, value) {
if (typeof ref === "function") {
ref(value);
} else if (ref) {
ref.current = value;
}
};
useControlled = function({ controlled, default: defaultProp, name, state = "value" }) {
const { current: isControlled } = __mf_31(controlled !== void 0);
const [valueState, setValue] = __mf_32(defaultProp);
const value = isControlled ? controlled : valueState;
const setValueIfUncontrolled = __mf_20((newValue) => {
if (!isControlled) {
setValue(newValue);
}
}, []);
return [
value,
setValueIfUncontrolled
];
};
useEventCallback = function(fn) {
const ref = __mf_31(fn);
useEnhancedEffect(() => {
ref.current = fn;
});
return __mf_31((...args) => (0, ref.current)(...args)).current;
};
useForkRef = function(...refs) {
const cleanupRef = __mf_31(void 0);
const refEffect = __mf_20((instance) => {
const cleanups = refs.map((ref) => {
if (ref == null) {
return null;
}
if (typeof ref === "function") {
const refCallback = ref;
const refCleanup = refCallback(instance);
return typeof refCleanup === "function" ? refCleanup : () => {
refCallback(null);
};
}
ref.current = instance;
return () => {
ref.current = null;
};
});
return () => {
cleanups.forEach((refCleanup) => refCleanup == null ? void 0 : refCleanup());
};
}, refs);
return __mf_29(() => {
if (refs.every((ref) => ref == null)) {
return null;
}
return (value) => {
if (cleanupRef.current) {
cleanupRef.current();
cleanupRef.current = void 0;
}
if (value != null) {
cleanupRef.current = refEffect(value);
}
};
}, refs);
};
const UNINITIALIZED = {};
function useLazyRef(init, initArg) {
const ref = __mf_31(UNINITIALIZED);
if (ref.current === UNINITIALIZED) {
ref.current = init(initArg);
}
return ref;
}
const EMPTY = [];
function useOnMount(fn) {
__mf_24(fn, EMPTY);
}
Timeout = class {
static create() {
return new Timeout();
}
currentId = null;
start(delay, fn) {
this.clear();
this.currentId = setTimeout(() => {
this.currentId = null;
fn();
}, delay);
}
clear = () => {
if (this.currentId !== null) {
clearTimeout(this.currentId);
this.currentId = null;
}
};
disposeEffect = () => {
return this.clear;
};
};
useTimeout = function() {
const timeout = useLazyRef(Timeout.create).current;
useOnMount(timeout.disposeEffect);
return timeout;
};
isFocusVisible = function(element) {
try {
return element.matches(":focus-visible");
} catch (error) {
}
return false;
};
function getScrollbarSize(win = window) {
const documentWidth = win.document.documentElement.clientWidth;
return win.innerWidth - documentWidth;
}
visuallyHidden = {
border: 0,
clip: "rect(0 0 0 0)",
height: "1px",
margin: "-1px",
overflow: "hidden",
padding: 0,
position: "absolute",
whiteSpace: "nowrap",
width: "1px"
};
function isHostComponent$1(element) {
return typeof element === "string";
}
function appendOwnerState(elementType, otherProps, ownerState) {
if (elementType === void 0 || isHostComponent$1(elementType)) {
return otherProps;
}
return {
...otherProps,
ownerState: {
...otherProps.ownerState,
...ownerState
}
};
}
extractEventHandlers = function(object, excludeKeys = []) {
if (object === void 0) {
return {};
}
const result = {};
Object.keys(object).filter((prop) => prop.match(/^on[A-Z]/) && typeof object[prop] === "function" && !excludeKeys.includes(prop)).forEach((prop) => {
result[prop] = object[prop];
});
return result;
};
function omitEventHandlers(object) {
if (object === void 0) {
return {};
}
const result = {};
Object.keys(object).filter((prop) => !(prop.match(/^on[A-Z]/) && typeof object[prop] === "function")).forEach((prop) => {
result[prop] = object[prop];
});
return result;
}
function mergeSlotProps$1(parameters) {
const { getSlotProps, additionalProps, externalSlotProps, externalForwardedProps, className } = parameters;
if (!getSlotProps) {
const joinedClasses2 = clsx(additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);
const mergedStyle2 = {
...additionalProps == null ? void 0 : additionalProps.style,
...externalForwardedProps == null ? void 0 : externalForwardedProps.style,
...externalSlotProps == null ? void 0 : externalSlotProps.style
};
const props2 = {
...additionalProps,
...externalForwardedProps,
...externalSlotProps
};
if (joinedClasses2.length > 0) {
props2.className = joinedClasses2;
}
if (Object.keys(mergedStyle2).length > 0) {
props2.style = mergedStyle2;
}
return {
props: props2,
internalRef: void 0
};
}
const eventHandlers = extractEventHandlers({
...externalForwardedProps,
...externalSlotProps
});
const componentsPropsWithoutEventHandlers = omitEventHandlers(externalSlotProps);
const otherPropsWithoutEventHandlers = omitEventHandlers(externalForwardedProps);
const internalSlotProps = getSlotProps(eventHandlers);
const joinedClasses = clsx(internalSlotProps == null ? void 0 : internalSlotProps.className, additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);
const mergedStyle = {
...internalSlotProps == null ? void 0 : internalSlotProps.style,
...additionalProps == null ? void 0 : additionalProps.style,
...externalForwardedProps == null ? void 0 : externalForwardedProps.style,
...externalSlotProps == null ? void 0 : externalSlotProps.style
};
const props = {
...internalSlotProps,
...additionalProps,
...otherPropsWithoutEventHandlers,
...componentsPropsWithoutEventHandlers
};
if (joinedClasses.length > 0) {
props.className = joinedClasses;
}
if (Object.keys(mergedStyle).length > 0) {
props.style = mergedStyle;
}
return {
props,
internalRef: internalSlotProps.ref
};
}
resolveComponentProps = function(componentProps, ownerState, slotState) {
if (typeof componentProps === "function") {
return componentProps(ownerState, slotState);
}
return componentProps;
};
useSlotProps = function(parameters) {
var _a;
const { elementType, externalSlotProps, ownerState, skipResolvingSlotProps = false, ...other } = parameters;
const resolvedComponentsProps = skipResolvingSlotProps ? {} : resolveComponentProps(externalSlotProps, ownerState);
const { props: mergedProps, internalRef } = mergeSlotProps$1({
...other,
externalSlotProps: resolvedComponentsProps
});
const ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, (_a = parameters.additionalProps) == null ? void 0 : _a.ref);
const props = appendOwnerState(elementType, {
...mergedProps,
ref
}, ownerState);
return props;
};
getReactElementRef = function(element) {
var _a;
if (parseInt(__mf_35, 10) >= 19) {
return ((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.ref) || null;
}
return (element == null ? void 0 : element.ref) || null;
};
useTheme = function() {
const theme = __mf_52(defaultTheme);
return theme[THEME_ID] || theme;
};
useThemeProps = function({ props, name }) {
return useThemeProps$1({
props,
name,
defaultTheme,
themeId: THEME_ID
});
};
function ThemeProviderNoVars({ theme: themeInput, ...props }) {
const scopedTheme = THEME_ID in themeInput ? themeInput[THEME_ID] : void 0;
return jsxRuntimeExports.jsx(__mf_7, {
...props,
themeId: scopedTheme ? THEME_ID : void 0,
theme: scopedTheme || themeInput
});
}
const defaultConfig = {
colorSchemeStorageKey: "mui-color-scheme",
defaultLightColorScheme: "light",
defaultDarkColorScheme: "dark",
modeStorageKey: "mui-mode"
};
let InternalCssVarsProvider, deprecatedGetInitColorSchemeScript;
({ CssVarsProvider: InternalCssVarsProvider, useColorScheme, getInitColorSchemeScript: deprecatedGetInitColorSchemeScript } = __mf_39({
themeId: THEME_ID,
theme: () => createTheme({
cssVariables: true
}),
colorSchemeStorageKey: defaultConfig.colorSchemeStorageKey,
modeStorageKey: defaultConfig.modeStorageKey,
defaultColorScheme: {
light: defaultConfig.defaultLightColorScheme,
dark: defaultConfig.defaultDarkColorScheme
},
resolveTheme: (theme) => {
const newTheme = {
...theme,
typography: createTypography(theme.palette, theme.typography)
};
newTheme.unstable_sx = function sx(props) {
return styleFunctionSx({
sx: props,
theme: this
});
};
return newTheme;
}
}));
Experimental_CssVarsProvider = function(props) {
return jsxRuntimeExports.jsx(InternalCssVarsProvider, {
...props
});
};
let warnedInitScriptOnce = false;
getInitColorSchemeScript = (params) => {
if (!warnedInitScriptOnce) {
console.warn([
"MUI: The getInitColorSchemeScript function has been deprecated.",
"",
"You should use `import InitColorSchemeScript from '@mui/material/InitColorSchemeScript'`",
"and replace the function call with `<InitColorSchemeScript />` instead."
].join("\n"));
warnedInitScriptOnce = true;
}
return deprecatedGetInitColorSchemeScript(params);
};
CssVarsProvider = InternalCssVarsProvider;
ThemeProvider = function({ theme, ...props }) {
const noVarsTheme = __mf_29(() => {
if (typeof theme === "function") {
return theme;
}
const muiTheme = THEME_ID in theme ? theme[THEME_ID] : theme;
if (!("colorSchemes" in muiTheme)) {
if (!("vars" in muiTheme)) {
return {
...theme,
vars: null
};
}
return theme;
}
return null;
}, [
theme
]);
if (noVarsTheme) {
return jsxRuntimeExports.jsx(ThemeProviderNoVars, {
theme: noVarsTheme,
...props
});
}
return jsxRuntimeExports.jsx(CssVarsProvider, {
theme,
...props
});
};
GlobalStyles = function(props) {
return jsxRuntimeExports.jsx(__mf_2, {
...props,
defaultTheme,
themeId: THEME_ID
});
};
globalCss = function(styles2) {
return function GlobalStylesWrapper(props) {
return jsxRuntimeExports.jsx(GlobalStyles, {
styles: typeof styles2 === "function" ? (theme) => styles2({
theme,
...props
}) : styles2
});
};
};
function internal_createExtendSxProp() {
return extendSxProp$1;
}
mergeSlotProps = function(externalSlotProps, defaultSlotProps) {
if (!externalSlotProps) {
return defaultSlotProps;
}
if (typeof externalSlotProps === "function" || typeof defaultSlotProps === "function") {
return (ownerState) => {
const defaultSlotPropsValue = typeof defaultSlotProps === "function" ? defaultSlotProps(ownerState) : defaultSlotProps;
const externalSlotPropsValue = typeof externalSlotProps === "function" ? externalSlotProps({
...ownerState,
...defaultSlotPropsValue
}) : externalSlotProps;
const className2 = clsx(ownerState == null ? void 0 : ownerState.className, defaultSlotPropsValue == null ? void 0 : defaultSlotPropsValue.className, externalSlotPropsValue == null ? void 0 : externalSlotPropsValue.className);
return {
...defaultSlotPropsValue,
...externalSlotPropsValue,
...!!className2 && {
className: className2
},
...(defaultSlotPropsValue == null ? void 0 : defaultSlotPropsValue.style) && (externalSlotPropsValue == null ? void 0 : externalSlotPropsValue.style) && {
style: {
...defaultSlotPropsValue.style,
...externalSlotPropsValue.style
}
},
...(defaultSlotPropsValue == null ? void 0 : defaultSlotPropsValue.sx) && (externalSlotPropsValue == null ? void 0 : externalSlotPropsValue.sx) && {
sx: [
...Array.isArray(defaultSlotPropsValue.sx) ? defaultSlotPropsValue.sx : [
defaultSlotPropsValue.sx
],
...Array.isArray(externalSlotPropsValue.sx) ? externalSlotPropsValue.sx : [
externalSlotPropsValue.sx
]
]
}
};
};
}
const typedDefaultSlotProps = defaultSlotProps;
const className = clsx(typedDefaultSlotProps == null ? void 0 : typedDefaultSlotProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);
return {
...defaultSlotProps,
...externalSlotProps,
...!!className && {
className
},
...(typedDefaultSlotProps == null ? void 0 : typedDefaultSlotProps.style) && (externalSlotProps == null ? void 0 : externalSlotProps.style) && {
style: {
...typedDefaultSlotProps.style,
...externalSlotProps.style
}
},
...(typedDefaultSlotProps == null ? void 0 : typedDefaultSlotProps.sx) && (externalSlotProps == null ? void 0 : externalSlotProps.sx) && {
sx: [
...Array.isArray(typedDefaultSlotProps.sx) ? typedDefaultSlotProps.sx : [
typedDefaultSlotProps.sx
],
...Array.isArray(externalSlotProps.sx) ? externalSlotProps.sx : [
externalSlotProps.sx
]
]
}
};
};
function hasCorrectMainProperty(obj) {
return typeof obj.main === "string";
}
function checkSimplePaletteColorValues(obj, additionalPropertiesToCheck = []) {
if (!hasCorrectMainProperty(obj)) {
return false;
}
for (const value of additionalPropertiesToCheck) {
if (!obj.hasOwnProperty(value) || typeof obj[value] !== "string") {
return false;
}
}
return true;
}
createSimplePaletteValueFilter = function(additionalPropertiesToCheck = []) {
return ([, value]) => value && checkSimplePaletteColorValues(value, additionalPropertiesToCheck);
};
getTypographyUtilityClass = function(slot) {
return generateUtilityClass("MuiTypography", slot);
};
typographyClasses = generateUtilityClasses("MuiTypography", [
"root",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"subtitle1",
"subtitle2",
"body1",
"body2",
"inherit",
"button",
"caption",
"overline",
"alignLeft",
"alignRight",
"alignCenter",
"alignJustify",
"noWrap",
"gutterBottom",
"paragraph"
]);
const v6Colors = {
primary: true,
secondary: true,
error: true,
info: true,
success: true,
warning: true,
textPrimary: true,
textSecondary: true,
textDisabled: true
};
const extendSxProp = internal_createExtendSxProp();
const useUtilityClasses$v = (ownerState) => {
const { align, gutterBottom, noWrap, paragraph, variant, classes } = ownerState;
const slots = {
root: [
"root",
variant,
ownerState.align !== "inherit" && `align${capitalize(align)}`,
gutterBottom && "gutterBottom",
noWrap && "noWrap",
paragraph && "paragraph"
]
};
return composeClasses(slots, getTypographyUtilityClass, classes);
};
const TypographyRoot = styled("span", {
name: "MuiTypography",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.variant && styles2[ownerState.variant],
ownerState.align !== "inherit" && styles2[`align${capitalize(ownerState.align)}`],
ownerState.noWrap && styles2.noWrap,
ownerState.gutterBottom && styles2.gutterBottom,
ownerState.paragraph && styles2.paragraph
];
}
})(memoTheme(({ theme }) => {
var _a;
return {
margin: 0,
variants: [
{
props: {
variant: "inherit"
},
style: {
font: "inherit",
lineHeight: "inherit",
letterSpacing: "inherit"
}
},
...Object.entries(theme.typography).filter(([variant, value]) => variant !== "inherit" && value && typeof value === "object").map(([variant, value]) => ({
props: {
variant
},
style: value
})),
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
color: (theme.vars || theme).palette[color].main
}
})),
...Object.entries(((_a = theme.palette) == null ? void 0 : _a.text) || {}).filter(([, value]) => typeof value === "string").map(([color]) => ({
props: {
color: `text${capitalize(color)}`
},
style: {
color: (theme.vars || theme).palette.text[color]
}
})),
{
props: ({ ownerState }) => ownerState.align !== "inherit",
style: {
textAlign: "var(--Typography-textAlign)"
}
},
{
props: ({ ownerState }) => ownerState.noWrap,
style: {
overflow: "hidden",
textOverflow: "ellipsis",
whiteSpace: "nowrap"
}
},
{
props: ({ ownerState }) => ownerState.gutterBottom,
style: {
marginBottom: "0.35em"
}
},
{
props: ({ ownerState }) => ownerState.paragraph,
style: {
marginBottom: 16
}
}
]
};
}));
const defaultVariantMapping = {
h1: "h1",
h2: "h2",
h3: "h3",
h4: "h4",
h5: "h5",
h6: "h6",
subtitle1: "h6",
subtitle2: "h6",
body1: "p",
body2: "p",
inherit: "p"
};
Typography = __mf_14(function Typography2(inProps, ref) {
const { color, ...themeProps } = useDefaultProps({
props: inProps,
name: "MuiTypography"
});
const isSxColor = !v6Colors[color];
const props = extendSxProp({
...themeProps,
...isSxColor && {
color
}
});
const { align = "inherit", className, component, gutterBottom = false, noWrap = false, paragraph = false, variant = "body1", variantMapping = defaultVariantMapping, ...other } = props;
const ownerState = {
...props,
align,
color,
className,
component,
gutterBottom,
noWrap,
paragraph,
variant,
variantMapping
};
const Component = component || (paragraph ? "p" : variantMapping[variant] || defaultVariantMapping[variant]) || "span";
const classes = useUtilityClasses$v(ownerState);
return jsxRuntimeExports.jsx(TypographyRoot, {
as: Component,
ref,
className: clsx(classes.root, className),
...other,
ownerState,
style: {
...align !== "inherit" && {
"--Typography-textAlign": align
},
...other.style
}
});
});
class LazyRipple {
static create() {
return new LazyRipple();
}
static use() {
const ripple = useLazyRef(LazyRipple.create).current;
const [shouldMount, setShouldMount] = __mf_32(false);
ripple.shouldMount = shouldMount;
ripple.setShouldMount = setShouldMount;
__mf_24(ripple.mountEffect, [
shouldMount
]);
return ripple;
}
constructor() {
this.ref = {
current: null
};
this.mounted = null;
this.didMount = false;
this.shouldMount = false;
this.setShouldMount = null;
}
mount() {
if (!this.mounted) {
this.mounted = createControlledPromise();
this.shouldMount = true;
this.setShouldMount(this.shouldMount);
}
return this.mounted;
}
mountEffect = () => {
if (this.shouldMount && !this.didMount) {
if (this.ref.current !== null) {
this.didMount = true;
this.mounted.resolve();
}
}
};
start(...args) {
this.mount().then(() => {
var _a;
return (_a = this.ref.current) == null ? void 0 : _a.start(...args);
});
}
stop(...args) {
this.mount().then(() => {
var _a;
return (_a = this.ref.current) == null ? void 0 : _a.stop(...args);
});
}
pulsate(...args) {
this.mount().then(() => {
var _a;
return (_a = this.ref.current) == null ? void 0 : _a.pulsate(...args);
});
}
}
function useLazyRipple() {
return LazyRipple.use();
}
function createControlledPromise() {
let resolve;
let reject;
const p = new Promise((resolveFn, rejectFn) => {
resolve = resolveFn;
reject = rejectFn;
});
p.resolve = resolve;
p.reject = reject;
return p;
}
const config = {
disabled: false
};
const TransitionGroupContext = React.createContext(null);
forceReflow = function forceReflow2(node) {
return node.scrollTop;
};
var UNMOUNTED = "unmounted";
var EXITED = "exited";
var ENTERING = "entering";
var ENTERED = "entered";
var EXITING = "exiting";
Transition = (function(_React$Component) {
_inheritsLoose(Transition2, _React$Component);
function Transition2(props, context) {
var _this;
_this = _React$Component.call(this, props, context) || this;
var parentGroup = context;
var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
var initialStatus;
_this.appearStatus = null;
if (props.in) {
if (appear) {
initialStatus = EXITED;
_this.appearStatus = ENTERING;
} else {
initialStatus = ENTERED;
}
} else {
if (props.unmountOnExit || props.mountOnEnter) {
initialStatus = UNMOUNTED;
} else {
initialStatus = EXITED;
}
}
_this.state = {
status: initialStatus
};
_this.nextCallback = null;
return _this;
}
Transition2.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
var nextIn = _ref.in;
if (nextIn && prevState.status === UNMOUNTED) {
return {
status: EXITED
};
}
return null;
};
var _proto = Transition2.prototype;
_proto.componentDidMount = function componentDidMount() {
this.updateStatus(true, this.appearStatus);
};
_proto.componentDidUpdate = function componentDidUpdate(prevProps) {
var nextStatus = null;
if (prevProps !== this.props) {
var status = this.state.status;
if (this.props.in) {
if (status !== ENTERING && status !== ENTERED) {
nextStatus = ENTERING;
}
} else {
if (status === ENTERING || status === ENTERED) {
nextStatus = EXITING;
}
}
}
this.updateStatus(false, nextStatus);
};
_proto.componentWillUnmount = function componentWillUnmount() {
this.cancelNextCallback();
};
_proto.getTimeouts = function getTimeouts() {
var timeout2 = this.props.timeout;
var exit, enter, appear;
exit = enter = appear = timeout2;
if (timeout2 != null && typeof timeout2 !== "number") {
exit = timeout2.exit;
enter = timeout2.enter;
appear = timeout2.appear !== void 0 ? timeout2.appear : enter;
}
return {
exit,
enter,
appear
};
};
_proto.updateStatus = function updateStatus(mounting, nextStatus) {
if (mounting === void 0) {
mounting = false;
}
if (nextStatus !== null) {
this.cancelNextCallback();
if (nextStatus === ENTERING) {
if (this.props.unmountOnExit || this.props.mountOnEnter) {
var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);
if (node) forceReflow(node);
}
this.performEnter(mounting);
} else {
this.performExit();
}
} else if (this.props.unmountOnExit && this.state.status === EXITED) {
this.setState({
status: UNMOUNTED
});
}
};
_proto.performEnter = function performEnter(mounting) {
var _this2 = this;
var enter = this.props.enter;
var appearing = this.context ? this.context.isMounting : mounting;
var _ref2 = this.props.nodeRef ? [
appearing
] : [
ReactDOM.findDOMNode(this),
appearing
], maybeNode = _ref2[0], maybeAppearing = _ref2[1];
var timeouts = this.getTimeouts();
var enterTimeout = appearing ? timeouts.appear : timeouts.enter;
if (!mounting && !enter || config.disabled) {
this.safeSetState({
status: ENTERED
}, function() {
_this2.props.onEntered(maybeNode);
});
return;
}
this.props.onEnter(maybeNode, maybeAppearing);
this.safeSetState({
status: ENTERING
}, function() {
_this2.props.onEntering(maybeNode, maybeAppearing);
_this2.onTransitionEnd(enterTimeout, function() {
_this2.safeSetState({
status: ENTERED
}, function() {
_this2.props.onEntered(maybeNode, maybeAppearing);
});
});
});
};
_proto.performExit = function performExit() {
var _this3 = this;
var exit = this.props.exit;
var timeouts = this.getTimeouts();
var maybeNode = this.props.nodeRef ? void 0 : ReactDOM.findDOMNode(this);
if (!exit || config.disabled) {
this.safeSetState({
status: EXITED
}, function() {
_this3.props.onExited(maybeNode);
});
return;
}
this.props.onExit(maybeNode);
this.safeSetState({
status: EXITING
}, function() {
_this3.props.onExiting(maybeNode);
_this3.onTransitionEnd(timeouts.exit, function() {
_this3.safeSetState({
status: EXITED
}, function() {
_this3.props.onExited(maybeNode);
});
});
});
};
_proto.cancelNextCallback = function cancelNextCallback() {
if (this.nextCallback !== null) {
this.nextCallback.cancel();
this.nextCallback = null;
}
};
_proto.safeSetState = function safeSetState(nextState, callback) {
callback = this.setNextCallback(callback);
this.setState(nextState, callback);
};
_proto.setNextCallback = function setNextCallback(callback) {
var _this4 = this;
var active = true;
this.nextCallback = function(event) {
if (active) {
active = false;
_this4.nextCallback = null;
callback(event);
}
};
this.nextCallback.cancel = function() {
active = false;
};
return this.nextCallback;
};
_proto.onTransitionEnd = function onTransitionEnd(timeout2, handler) {
this.setNextCallback(handler);
var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);
var doesNotHaveTimeoutOrListener = timeout2 == null && !this.props.addEndListener;
if (!node || doesNotHaveTimeoutOrListener) {
setTimeout(this.nextCallback, 0);
return;
}
if (this.props.addEndListener) {
var _ref3 = this.props.nodeRef ? [
this.nextCallback
] : [
node,
this.nextCallback
], maybeNode = _ref3[0], maybeNextCallback = _ref3[1];
this.props.addEndListener(maybeNode, maybeNextCallback);
}
if (timeout2 != null) {
setTimeout(this.nextCallback, timeout2);
}
};
_proto.render = function render() {
var status = this.state.status;
if (status === UNMOUNTED) {
return null;
}
var _this$props = this.props, children = _this$props.children;
_this$props.in;
_this$props.mountOnEnter;
_this$props.unmountOnExit;
_this$props.appear;
_this$props.enter;
_this$props.exit;
_this$props.timeout;
_this$props.addEndListener;
_this$props.onEnter;
_this$props.onEntering;
_this$props.onEntered;
_this$props.onExit;
_this$props.onExiting;
_this$props.onExited;
_this$props.nodeRef;
var childProps = _objectWithoutPropertiesLoose(_this$props, [
"children",
"in",
"mountOnEnter",
"unmountOnExit",
"appear",
"enter",
"exit",
"timeout",
"addEndListener",
"onEnter",
"onEntering",
"onEntered",
"onExit",
"onExiting",
"onExited",
"nodeRef"
]);
return React.createElement(TransitionGroupContext.Provider, {
value: null
}, typeof children === "function" ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps));
};
return Transition2;
})(React.Component);
Transition.contextType = TransitionGroupContext;
Transition.propTypes = {};
function noop$1() {
}
Transition.defaultProps = {
in: false,
mountOnEnter: false,
unmountOnExit: false,
appear: false,
enter: true,
exit: true,
onEnter: noop$1,
onEntering: noop$1,
onEntered: noop$1,
onExit: noop$1,
onExiting: noop$1,
onExited: noop$1
};
Transition.UNMOUNTED = UNMOUNTED;
Transition.EXITED = EXITED;
Transition.ENTERING = ENTERING;
Transition.ENTERED = ENTERED;
Transition.EXITING = EXITING;
function getChildMapping(children, mapFn) {
var mapper = function mapper2(child) {
return mapFn && __mf_15(child) ? mapFn(child) : child;
};
var result = /* @__PURE__ */ Object.create(null);
if (children) __mf_0.map(children, function(c) {
return c;
}).forEach(function(child) {
result[child.key] = mapper(child);
});
return result;
}
function mergeChildMappings(prev, next) {
prev = prev || {};
next = next || {};
function getValueForKey(key) {
return key in next ? next[key] : prev[key];
}
var nextKeysPending = /* @__PURE__ */ Object.create(null);
var pendingKeys = [];
for (var prevKey in prev) {
if (prevKey in next) {
if (pendingKeys.length) {
nextKeysPending[prevKey] = pendingKeys;
pendingKeys = [];
}
} else {
pendingKeys.push(prevKey);
}
}
var i;
var childMapping = {};
for (var nextKey in next) {
if (nextKeysPending[nextKey]) {
for (i = 0; i < nextKeysPending[nextKey].length; i++) {
var pendingNextKey = nextKeysPending[nextKey][i];
childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
}
}
childMapping[nextKey] = getValueForKey(nextKey);
}
for (i = 0; i < pendingKeys.length; i++) {
childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
}
return childMapping;
}
function getProp(child, prop, props) {
return props[prop] != null ? props[prop] : child.props[prop];
}
function getInitialChildMapping(props, onExited) {
return getChildMapping(props.children, function(child) {
return __mf_9(child, {
onExited: onExited.bind(null, child),
in: true,
appear: getProp(child, "appear", props),
enter: getProp(child, "enter", props),
exit: getProp(child, "exit", props)
});
});
}
function getNextChildMapping(nextProps, prevChildMapping, onExited) {
var nextChildMapping = getChildMapping(nextProps.children);
var children = mergeChildMappings(prevChildMapping, nextChildMapping);
Object.keys(children).forEach(function(key) {
var child = children[key];
if (!__mf_15(child)) return;
var hasPrev = key in prevChildMapping;
var hasNext = key in nextChildMapping;
var prevChild = prevChildMapping[key];
var isLeaving = __mf_15(prevChild) && !prevChild.props.in;
if (hasNext && (!hasPrev || isLeaving)) {
children[key] = __mf_9(child, {
onExited: onExited.bind(null, child),
in: true,
exit: getProp(child, "exit", nextProps),
enter: getProp(child, "enter", nextProps)
});
} else if (!hasNext && hasPrev && !isLeaving) {
children[key] = __mf_9(child, {
in: false
});
} else if (hasNext && hasPrev && __mf_15(prevChild)) {
children[key] = __mf_9(child, {
onExited: onExited.bind(null, child),
in: prevChild.props.in,
exit: getProp(child, "exit", nextProps),
enter: getProp(child, "enter", nextProps)
});
}
});
return children;
}
var values = Object.values || function(obj) {
return Object.keys(obj).map(function(k) {
return obj[k];
});
};
var defaultProps = {
component: "div",
childFactory: function childFactory(child) {
return child;
}
};
TransitionGroup = (function(_React$Component) {
_inheritsLoose(TransitionGroup2, _React$Component);
function TransitionGroup2(props, context) {
var _this;
_this = _React$Component.call(this, props, context) || this;
var handleExited = _this.handleExited.bind(_assertThisInitialized(_this));
_this.state = {
contextValue: {
isMounting: true
},
handleExited,
firstRender: true
};
return _this;
}
var _proto = TransitionGroup2.prototype;
_proto.componentDidMount = function componentDidMount() {
this.mounted = true;
this.setState({
contextValue: {
isMounting: false
}
});
};
_proto.componentWillUnmount = function componentWillUnmount() {
this.mounted = false;
};
TransitionGroup2.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {
var prevChildMapping = _ref.children, handleExited = _ref.handleExited, firstRender = _ref.firstRender;
return {
children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),
firstRender: false
};
};
_proto.handleExited = function handleExited(child, node) {
var currentChildMapping = getChildMapping(this.props.children);
if (child.key in currentChildMapping) return;
if (child.props.onExited) {
child.props.onExited(node);
}
if (this.mounted) {
this.setState(function(state) {
var children = _extends({}, state.children);
delete children[child.key];
return {
children
};
});
}
};
_proto.render = function render() {
var _this$props = this.props, Component = _this$props.component, childFactory2 = _this$props.childFactory, props = _objectWithoutPropertiesLoose(_this$props, [
"component",
"childFactory"
]);
var contextValue = this.state.contextValue;
var children = values(this.state.children).map(childFactory2);
delete props.appear;
delete props.enter;
delete props.exit;
if (Component === null) {
return React.createElement(TransitionGroupContext.Provider, {
value: contextValue
}, children);
}
return React.createElement(TransitionGroupContext.Provider, {
value: contextValue
}, React.createElement(Component, props, children));
};
return TransitionGroup2;
})(React.Component);
TransitionGroup.propTypes = {};
TransitionGroup.defaultProps = defaultProps;
function Ripple(props) {
const { className, classes, pulsate = false, rippleX, rippleY, rippleSize, in: inProp, onExited, timeout } = props;
const [leaving, setLeaving] = __mf_32(false);
const rippleClassName = clsx(className, classes.ripple, classes.rippleVisible, pulsate && classes.ripplePulsate);
const rippleStyles = {
width: rippleSize,
height: rippleSize,
top: -(rippleSize / 2) + rippleY,
left: -(rippleSize / 2) + rippleX
};
const childClassName = clsx(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate);
if (!inProp && !leaving) {
setLeaving(true);
}
__mf_24(() => {
if (!inProp && onExited != null) {
const timeoutId = setTimeout(onExited, timeout);
return () => {
clearTimeout(timeoutId);
};
}
return void 0;
}, [
onExited,
inProp,
timeout
]);
return jsxRuntimeExports.jsx("span", {
className: rippleClassName,
style: rippleStyles,
children: jsxRuntimeExports.jsx("span", {
className: childClassName
})
});
}
getTouchRippleUtilityClass = function(slot) {
return generateUtilityClass("MuiTouchRipple", slot);
};
touchRippleClasses = generateUtilityClasses("MuiTouchRipple", [
"root",
"ripple",
"rippleVisible",
"ripplePulsate",
"child",
"childLeaving",
"childPulsate"
]);
const DURATION = 550;
const DELAY_RIPPLE = 80;
const enterKeyframe = __mf_27`
0% {
transform: scale(0);
opacity: 0.1;
}
100% {
transform: scale(1);
opacity: 0.3;
}
`;
const exitKeyframe = __mf_27`
0% {
opacity: 1;
}
100% {
opacity: 0;
}
`;
const pulsateKeyframe = __mf_27`
0% {
transform: scale(1);
}
50% {
transform: scale(0.92);
}
100% {
transform: scale(1);
}
`;
const TouchRippleRoot = styled("span", {
name: "MuiTouchRipple",
slot: "Root"
})({
overflow: "hidden",
pointerEvents: "none",
position: "absolute",
zIndex: 0,
top: 0,
right: 0,
bottom: 0,
left: 0,
borderRadius: "inherit"
});
const TouchRippleRipple = styled(Ripple, {
name: "MuiTouchRipple",
slot: "Ripple"
})`
opacity: 0;
position: absolute;
&.${touchRippleClasses.rippleVisible} {
opacity: 0.3;
transform: scale(1);
animation-name: ${enterKeyframe};
animation-duration: ${DURATION}ms;
animation-timing-function: ${({ theme }) => theme.transitions.easing.easeInOut};
}
&.${touchRippleClasses.ripplePulsate} {
animation-duration: ${({ theme }) => theme.transitions.duration.shorter}ms;
}
& .${touchRippleClasses.child} {
opacity: 1;
display: block;
width: 100%;
height: 100%;
border-radius: 50%;
background-color: currentColor;
}
& .${touchRippleClasses.childLeaving} {
opacity: 0;
animation-name: ${exitKeyframe};
animation-duration: ${DURATION}ms;
animation-timing-function: ${({ theme }) => theme.transitions.easing.easeInOut};
}
& .${touchRippleClasses.childPulsate} {
position: absolute;
/* @noflip */
left: 0px;
top: 0;
animation-name: ${pulsateKeyframe};
animation-duration: 2500ms;
animation-timing-function: ${({ theme }) => theme.transitions.easing.easeInOut};
animation-iteration-count: infinite;
animation-delay: 200ms;
}
`;
const TouchRipple = __mf_14(function TouchRipple2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiTouchRipple"
});
const { center: centerProp = false, classes = {}, className, ...other } = props;
const [ripples, setRipples] = __mf_32([]);
const nextKey = __mf_31(0);
const rippleCallback = __mf_31(null);
__mf_24(() => {
if (rippleCallback.current) {
rippleCallback.current();
rippleCallback.current = null;
}
}, [
ripples
]);
const ignoringMouseDown = __mf_31(false);
const startTimer = useTimeout();
const startTimerCommit = __mf_31(null);
const container = __mf_31(null);
const startCommit = __mf_20((params) => {
const { pulsate: pulsate2, rippleX, rippleY, rippleSize, cb } = params;
setRipples((oldRipples) => [
...oldRipples,
jsxRuntimeExports.jsx(TouchRippleRipple, {
classes: {
ripple: clsx(classes.ripple, touchRippleClasses.ripple),
rippleVisible: clsx(classes.rippleVisible, touchRippleClasses.rippleVisible),
ripplePulsate: clsx(classes.ripplePulsate, touchRippleClasses.ripplePulsate),
child: clsx(classes.child, touchRippleClasses.child),
childLeaving: clsx(classes.childLeaving, touchRippleClasses.childLeaving),
childPulsate: clsx(classes.childPulsate, touchRippleClasses.childPulsate)
},
timeout: DURATION,
pulsate: pulsate2,
rippleX,
rippleY,
rippleSize
}, nextKey.current)
]);
nextKey.current += 1;
rippleCallback.current = cb;
}, [
classes
]);
const start2 = __mf_20((event = {}, options = {}, cb = () => {
}) => {
const { pulsate: pulsate2 = false, center = centerProp || options.pulsate, fakeElement = false } = options;
if ((event == null ? void 0 : event.type) === "mousedown" && ignoringMouseDown.current) {
ignoringMouseDown.current = false;
return;
}
if ((event == null ? void 0 : event.type) === "touchstart") {
ignoringMouseDown.current = true;
}
const element = fakeElement ? null : container.current;
const rect = element ? element.getBoundingClientRect() : {
width: 0,
height: 0,
left: 0,
top: 0
};
let rippleX;
let rippleY;
let rippleSize;
if (center || event === void 0 || event.clientX === 0 && event.clientY === 0 || !event.clientX && !event.touches) {
rippleX = Math.round(rect.width / 2);
rippleY = Math.round(rect.height / 2);
} else {
const { clientX, clientY } = event.touches && event.touches.length > 0 ? event.touches[0] : event;
rippleX = Math.round(clientX - rect.left);
rippleY = Math.round(clientY - rect.top);
}
if (center) {
rippleSize = Math.sqrt((2 * rect.width ** 2 + rect.height ** 2) / 3);
if (rippleSize % 2 === 0) {
rippleSize += 1;
}
} else {
const sizeX = Math.max(Math.abs((element ? element.clientWidth : 0) - rippleX), rippleX) * 2 + 2;
const sizeY = Math.max(Math.abs((element ? element.clientHeight : 0) - rippleY), rippleY) * 2 + 2;
rippleSize = Math.sqrt(sizeX ** 2 + sizeY ** 2);
}
if (event == null ? void 0 : event.touches) {
if (startTimerCommit.current === null) {
startTimerCommit.current = () => {
startCommit({
pulsate: pulsate2,
rippleX,
rippleY,
rippleSize,
cb
});
};
startTimer.start(DELAY_RIPPLE, () => {
if (startTimerCommit.current) {
startTimerCommit.current();
startTimerCommit.current = null;
}
});
}
} else {
startCommit({
pulsate: pulsate2,
rippleX,
rippleY,
rippleSize,
cb
});
}
}, [
centerProp,
startCommit,
startTimer
]);
const pulsate = __mf_20(() => {
start2({}, {
pulsate: true
});
}, [
start2
]);
const stop = __mf_20((event, cb) => {
startTimer.clear();
if ((event == null ? void 0 : event.type) === "touchend" && startTimerCommit.current) {
startTimerCommit.current();
startTimerCommit.current = null;
startTimer.start(0, () => {
stop(event, cb);
});
return;
}
startTimerCommit.current = null;
setRipples((oldRipples) => {
if (oldRipples.length > 0) {
return oldRipples.slice(1);
}
return oldRipples;
});
rippleCallback.current = cb;
}, [
startTimer
]);
__mf_26(ref, () => ({
pulsate,
start: start2,
stop
}), [
pulsate,
start2,
stop
]);
return jsxRuntimeExports.jsx(TouchRippleRoot, {
className: clsx(touchRippleClasses.root, classes.root, className),
ref: container,
...other,
children: jsxRuntimeExports.jsx(TransitionGroup, {
component: null,
exit: true,
children: ripples
})
});
});
getButtonBaseUtilityClass = function(slot) {
return generateUtilityClass("MuiButtonBase", slot);
};
buttonBaseClasses = generateUtilityClasses("MuiButtonBase", [
"root",
"disabled",
"focusVisible"
]);
const useUtilityClasses$u = (ownerState) => {
const { disabled, focusVisible, focusVisibleClassName, classes } = ownerState;
const slots = {
root: [
"root",
disabled && "disabled",
focusVisible && "focusVisible"
]
};
const composedClasses = composeClasses(slots, getButtonBaseUtilityClass, classes);
if (focusVisible && focusVisibleClassName) {
composedClasses.root += ` ${focusVisibleClassName}`;
}
return composedClasses;
};
const ButtonBaseRoot = styled("button", {
name: "MuiButtonBase",
slot: "Root",
overridesResolver: (props, styles2) => styles2.root
})({
display: "inline-flex",
alignItems: "center",
justifyContent: "center",
position: "relative",
boxSizing: "border-box",
WebkitTapHighlightColor: "transparent",
backgroundColor: "transparent",
outline: 0,
border: 0,
margin: 0,
borderRadius: 0,
padding: 0,
cursor: "pointer",
userSelect: "none",
verticalAlign: "middle",
MozAppearance: "none",
WebkitAppearance: "none",
textDecoration: "none",
color: "inherit",
"&::-moz-focus-inner": {
borderStyle: "none"
},
[`&.${buttonBaseClasses.disabled}`]: {
pointerEvents: "none",
cursor: "default"
},
"@media print": {
colorAdjust: "exact"
}
});
ButtonBase = __mf_14(function ButtonBase2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiButtonBase"
});
const { action, centerRipple = false, children, className, component = "button", disabled = false, disableRipple = false, disableTouchRipple = false, focusRipple = false, focusVisibleClassName, LinkComponent = "a", onBlur, onClick, onContextMenu, onDragLeave, onFocus, onFocusVisible, onKeyDown, onKeyUp, onMouseDown, onMouseLeave, onMouseUp, onTouchEnd, onTouchMove, onTouchStart, tabIndex = 0, TouchRippleProps, touchRippleRef, type, ...other } = props;
const buttonRef = __mf_31(null);
const ripple = useLazyRipple();
const handleRippleRef = useForkRef(ripple.ref, touchRippleRef);
const [focusVisible, setFocusVisible] = __mf_32(false);
if (disabled && focusVisible) {
setFocusVisible(false);
}
__mf_26(action, () => ({
focusVisible: () => {
setFocusVisible(true);
buttonRef.current.focus();
}
}), []);
const enableTouchRipple = ripple.shouldMount && !disableRipple && !disabled;
__mf_24(() => {
if (focusVisible && focusRipple && !disableRipple) {
ripple.pulsate();
}
}, [
disableRipple,
focusRipple,
focusVisible,
ripple
]);
const handleMouseDown = useRippleHandler(ripple, "start", onMouseDown, disableTouchRipple);
const handleContextMenu = useRippleHandler(ripple, "stop", onContextMenu, disableTouchRipple);
const handleDragLeave = useRippleHandler(ripple, "stop", onDragLeave, disableTouchRipple);
const handleMouseUp = useRippleHandler(ripple, "stop", onMouseUp, disableTouchRipple);
const handleMouseLeave = useRippleHandler(ripple, "stop", (event) => {
if (focusVisible) {
event.preventDefault();
}
if (onMouseLeave) {
onMouseLeave(event);
}
}, disableTouchRipple);
const handleTouchStart = useRippleHandler(ripple, "start", onTouchStart, disableTouchRipple);
const handleTouchEnd = useRippleHandler(ripple, "stop", onTouchEnd, disableTouchRipple);
const handleTouchMove = useRippleHandler(ripple, "stop", onTouchMove, disableTouchRipple);
const handleBlur = useRippleHandler(ripple, "stop", (event) => {
if (!isFocusVisible(event.target)) {
setFocusVisible(false);
}
if (onBlur) {
onBlur(event);
}
}, false);
const handleFocus = useEventCallback((event) => {
if (!buttonRef.current) {
buttonRef.current = event.currentTarget;
}
if (isFocusVisible(event.target)) {
setFocusVisible(true);
if (onFocusVisible) {
onFocusVisible(event);
}
}
if (onFocus) {
onFocus(event);
}
});
const isNonNativeButton = () => {
const button = buttonRef.current;
return component && component !== "button" && !(button.tagName === "A" && button.href);
};
const handleKeyDown = useEventCallback((event) => {
if (focusRipple && !event.repeat && focusVisible && event.key === " ") {
ripple.stop(event, () => {
ripple.start(event);
});
}
if (event.target === event.currentTarget && isNonNativeButton() && event.key === " ") {
event.preventDefault();
}
if (onKeyDown) {
onKeyDown(event);
}
if (event.target === event.currentTarget && isNonNativeButton() && event.key === "Enter" && !disabled) {
event.preventDefault();
if (onClick) {
onClick(event);
}
}
});
const handleKeyUp = useEventCallback((event) => {
if (focusRipple && event.key === " " && focusVisible && !event.defaultPrevented) {
ripple.stop(event, () => {
ripple.pulsate(event);
});
}
if (onKeyUp) {
onKeyUp(event);
}
if (onClick && event.target === event.currentTarget && isNonNativeButton() && event.key === " " && !event.defaultPrevented) {
onClick(event);
}
});
let ComponentProp = component;
if (ComponentProp === "button" && (other.href || other.to)) {
ComponentProp = LinkComponent;
}
const buttonProps = {};
if (ComponentProp === "button") {
buttonProps.type = type === void 0 ? "button" : type;
buttonProps.disabled = disabled;
} else {
if (!other.href && !other.to) {
buttonProps.role = "button";
}
if (disabled) {
buttonProps["aria-disabled"] = disabled;
}
}
const handleRef = useForkRef(ref, buttonRef);
const ownerState = {
...props,
centerRipple,
component,
disabled,
disableRipple,
disableTouchRipple,
focusRipple,
tabIndex,
focusVisible
};
const classes = useUtilityClasses$u(ownerState);
return jsxRuntimeExports.jsxs(ButtonBaseRoot, {
as: ComponentProp,
className: clsx(classes.root, className),
ownerState,
onBlur: handleBlur,
onClick,
onContextMenu: handleContextMenu,
onFocus: handleFocus,
onKeyDown: handleKeyDown,
onKeyUp: handleKeyUp,
onMouseDown: handleMouseDown,
onMouseLeave: handleMouseLeave,
onMouseUp: handleMouseUp,
onDragLeave: handleDragLeave,
onTouchEnd: handleTouchEnd,
onTouchMove: handleTouchMove,
onTouchStart: handleTouchStart,
ref: handleRef,
tabIndex: disabled ? -1 : tabIndex,
type,
...buttonProps,
...other,
children: [
children,
enableTouchRipple ? jsxRuntimeExports.jsx(TouchRipple, {
ref: handleRippleRef,
center: centerRipple,
...TouchRippleProps
}) : null
]
});
});
function useRippleHandler(ripple, rippleAction, eventCallback, skipRippleAction = false) {
return useEventCallback((event) => {
if (eventCallback) {
eventCallback(event);
}
if (!skipRippleAction) {
ripple[rippleAction](event);
}
return true;
});
}
getCircularProgressUtilityClass = function(slot) {
return generateUtilityClass("MuiCircularProgress", slot);
};
circularProgressClasses = generateUtilityClasses("MuiCircularProgress", [
"root",
"determinate",
"indeterminate",
"colorPrimary",
"colorSecondary",
"svg",
"circle",
"circleDeterminate",
"circleIndeterminate",
"circleDisableShrink"
]);
const SIZE = 44;
const circularRotateKeyframe = __mf_27`
0% {
transform: rotate(0deg);
}
100% {
transform: rotate(360deg);
}
`;
const circularDashKeyframe = __mf_27`
0% {
stroke-dasharray: 1px, 200px;
stroke-dashoffset: 0;
}
50% {
stroke-dasharray: 100px, 200px;
stroke-dashoffset: -15px;
}
100% {
stroke-dasharray: 1px, 200px;
stroke-dashoffset: -126px;
}
`;
const rotateAnimation = typeof circularRotateKeyframe !== "string" ? __mf_17`
animation: ${circularRotateKeyframe} 1.4s linear infinite;
` : null;
const dashAnimation = typeof circularDashKeyframe !== "string" ? __mf_17`
animation: ${circularDashKeyframe} 1.4s ease-in-out infinite;
` : null;
const useUtilityClasses$t = (ownerState) => {
const { classes, variant, color, disableShrink } = ownerState;
const slots = {
root: [
"root",
variant,
`color${capitalize(color)}`
],
svg: [
"svg"
],
circle: [
"circle",
`circle${capitalize(variant)}`,
disableShrink && "circleDisableShrink"
]
};
return composeClasses(slots, getCircularProgressUtilityClass, classes);
};
const CircularProgressRoot = styled("span", {
name: "MuiCircularProgress",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
styles2[ownerState.variant],
styles2[`color${capitalize(ownerState.color)}`]
];
}
})(memoTheme(({ theme }) => ({
display: "inline-block",
variants: [
{
props: {
variant: "determinate"
},
style: {
transition: theme.transitions.create("transform")
}
},
{
props: {
variant: "indeterminate"
},
style: rotateAnimation || {
animation: `${circularRotateKeyframe} 1.4s linear infinite`
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
color: (theme.vars || theme).palette[color].main
}
}))
]
})));
const CircularProgressSVG = styled("svg", {
name: "MuiCircularProgress",
slot: "Svg",
overridesResolver: (props, styles2) => styles2.svg
})({
display: "block"
});
const CircularProgressCircle = styled("circle", {
name: "MuiCircularProgress",
slot: "Circle",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.circle,
styles2[`circle${capitalize(ownerState.variant)}`],
ownerState.disableShrink && styles2.circleDisableShrink
];
}
})(memoTheme(({ theme }) => ({
stroke: "currentColor",
variants: [
{
props: {
variant: "determinate"
},
style: {
transition: theme.transitions.create("stroke-dashoffset")
}
},
{
props: {
variant: "indeterminate"
},
style: {
strokeDasharray: "80px, 200px",
strokeDashoffset: 0
}
},
{
props: ({ ownerState }) => ownerState.variant === "indeterminate" && !ownerState.disableShrink,
style: dashAnimation || {
animation: `${circularDashKeyframe} 1.4s ease-in-out infinite`
}
}
]
})));
CircularProgress = __mf_14(function CircularProgress2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiCircularProgress"
});
const { className, color = "primary", disableShrink = false, size = 40, style, thickness = 3.6, value = 0, variant = "indeterminate", ...other } = props;
const ownerState = {
...props,
color,
disableShrink,
size,
thickness,
value,
variant
};
const classes = useUtilityClasses$t(ownerState);
const circleStyle = {};
const rootStyle = {};
const rootProps = {};
if (variant === "determinate") {
const circumference = 2 * Math.PI * ((SIZE - thickness) / 2);
circleStyle.strokeDasharray = circumference.toFixed(3);
rootProps["aria-valuenow"] = Math.round(value);
circleStyle.strokeDashoffset = `${((100 - value) / 100 * circumference).toFixed(3)}px`;
rootStyle.transform = "rotate(-90deg)";
}
return jsxRuntimeExports.jsx(CircularProgressRoot, {
className: clsx(classes.root, className),
style: {
width: size,
height: size,
...rootStyle,
...style
},
ownerState,
ref,
role: "progressbar",
...rootProps,
...other,
children: jsxRuntimeExports.jsx(CircularProgressSVG, {
className: classes.svg,
ownerState,
viewBox: `${SIZE / 2} ${SIZE / 2} ${SIZE} ${SIZE}`,
children: jsxRuntimeExports.jsx(CircularProgressCircle, {
className: classes.circle,
style: circleStyle,
ownerState,
cx: SIZE,
cy: SIZE,
r: (SIZE - thickness) / 2,
fill: "none",
strokeWidth: thickness
})
})
});
});
getIconButtonUtilityClass = function(slot) {
return generateUtilityClass("MuiIconButton", slot);
};
iconButtonClasses = generateUtilityClasses("MuiIconButton", [
"root",
"disabled",
"colorInherit",
"colorPrimary",
"colorSecondary",
"colorError",
"colorInfo",
"colorSuccess",
"colorWarning",
"edgeStart",
"edgeEnd",
"sizeSmall",
"sizeMedium",
"sizeLarge",
"loading",
"loadingIndicator",
"loadingWrapper"
]);
const useUtilityClasses$s = (ownerState) => {
const { classes, disabled, color, edge, size, loading } = ownerState;
const slots = {
root: [
"root",
loading && "loading",
disabled && "disabled",
color !== "default" && `color${capitalize(color)}`,
edge && `edge${capitalize(edge)}`,
`size${capitalize(size)}`
],
loadingIndicator: [
"loadingIndicator"
],
loadingWrapper: [
"loadingWrapper"
]
};
return composeClasses(slots, getIconButtonUtilityClass, classes);
};
const IconButtonRoot = styled(ButtonBase, {
name: "MuiIconButton",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.loading && styles2.loading,
ownerState.color !== "default" && styles2[`color${capitalize(ownerState.color)}`],
ownerState.edge && styles2[`edge${capitalize(ownerState.edge)}`],
styles2[`size${capitalize(ownerState.size)}`]
];
}
})(memoTheme(({ theme }) => ({
textAlign: "center",
flex: "0 0 auto",
fontSize: theme.typography.pxToRem(24),
padding: 8,
borderRadius: "50%",
color: (theme.vars || theme).palette.action.active,
transition: theme.transitions.create("background-color", {
duration: theme.transitions.duration.shortest
}),
variants: [
{
props: (props) => !props.disableRipple,
style: {
"--IconButton-hoverBg": theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),
"&:hover": {
backgroundColor: "var(--IconButton-hoverBg)",
"@media (hover: none)": {
backgroundColor: "transparent"
}
}
}
},
{
props: {
edge: "start"
},
style: {
marginLeft: -12
}
},
{
props: {
edge: "start",
size: "small"
},
style: {
marginLeft: -3
}
},
{
props: {
edge: "end"
},
style: {
marginRight: -12
}
},
{
props: {
edge: "end",
size: "small"
},
style: {
marginRight: -3
}
}
]
})), memoTheme(({ theme }) => ({
variants: [
{
props: {
color: "inherit"
},
style: {
color: "inherit"
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
color: (theme.vars || theme).palette[color].main
}
})),
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
"--IconButton-hoverBg": theme.vars ? `rgba(${(theme.vars || theme).palette[color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha((theme.vars || theme).palette[color].main, theme.palette.action.hoverOpacity)
}
})),
{
props: {
size: "small"
},
style: {
padding: 5,
fontSize: theme.typography.pxToRem(18)
}
},
{
props: {
size: "large"
},
style: {
padding: 12,
fontSize: theme.typography.pxToRem(28)
}
}
],
[`&.${iconButtonClasses.disabled}`]: {
backgroundColor: "transparent",
color: (theme.vars || theme).palette.action.disabled
},
[`&.${iconButtonClasses.loading}`]: {
color: "transparent"
}
})));
const IconButtonLoadingIndicator = styled("span", {
name: "MuiIconButton",
slot: "LoadingIndicator",
overridesResolver: (props, styles2) => styles2.loadingIndicator
})(({ theme }) => ({
display: "none",
position: "absolute",
visibility: "visible",
top: "50%",
left: "50%",
transform: "translate(-50%, -50%)",
color: (theme.vars || theme).palette.action.disabled,
variants: [
{
props: {
loading: true
},
style: {
display: "flex"
}
}
]
}));
IconButton = __mf_14(function IconButton2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiIconButton"
});
const { edge = false, children, className, color = "default", disabled = false, disableFocusRipple = false, size = "medium", id: idProp, loading = null, loadingIndicator: loadingIndicatorProp, ...other } = props;
const loadingId = useId(idProp);
const loadingIndicator = loadingIndicatorProp ?? jsxRuntimeExports.jsx(CircularProgress, {
"aria-labelledby": loadingId,
color: "inherit",
size: 16
});
const ownerState = {
...props,
edge,
color,
disabled,
disableFocusRipple,
loading,
loadingIndicator,
size
};
const classes = useUtilityClasses$s(ownerState);
return jsxRuntimeExports.jsxs(IconButtonRoot, {
id: loading ? loadingId : idProp,
className: clsx(classes.root, className),
centerRipple: true,
focusRipple: !disableFocusRipple,
disabled: disabled || loading,
ref,
...other,
ownerState,
children: [
typeof loading === "boolean" && jsxRuntimeExports.jsx("span", {
className: classes.loadingWrapper,
style: {
display: "contents"
},
children: jsxRuntimeExports.jsx(IconButtonLoadingIndicator, {
className: classes.loadingIndicator,
ownerState,
children: loading && loadingIndicator
})
}),
children
]
});
});
ListContext = __mf_10({});
getDividerUtilityClass = function(slot) {
return generateUtilityClass("MuiDivider", slot);
};
dividerClasses = generateUtilityClasses("MuiDivider", [
"root",
"absolute",
"fullWidth",
"inset",
"middle",
"flexItem",
"light",
"vertical",
"withChildren",
"withChildrenVertical",
"textAlignRight",
"textAlignLeft",
"wrapper",
"wrapperVertical"
]);
getListItemIconUtilityClass = function(slot) {
return generateUtilityClass("MuiListItemIcon", slot);
};
listItemIconClasses = generateUtilityClasses("MuiListItemIcon", [
"root",
"alignItemsFlexStart"
]);
getListItemTextUtilityClass = function(slot) {
return generateUtilityClass("MuiListItemText", slot);
};
listItemTextClasses = generateUtilityClasses("MuiListItemText", [
"root",
"multiline",
"dense",
"inset",
"primary",
"secondary"
]);
useSlot = function(name, parameters) {
const { className, elementType: initialElementType, ownerState, externalForwardedProps, internalForwardedProps, shouldForwardComponentProp = false, ...useSlotPropsParams } = parameters;
const { component: rootComponent, slots = {
[name]: void 0
}, slotProps = {
[name]: void 0
}, ...other } = externalForwardedProps;
const elementType = slots[name] || initialElementType;
const resolvedComponentsProps = resolveComponentProps(slotProps[name], ownerState);
const { props: { component: slotComponent, ...mergedProps }, internalRef } = mergeSlotProps$1({
className,
...useSlotPropsParams,
externalForwardedProps: name === "root" ? other : void 0,
externalSlotProps: resolvedComponentsProps
});
const ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, parameters.ref);
const LeafComponent = name === "root" ? slotComponent || rootComponent : slotComponent;
const props = appendOwnerState(elementType, {
...name === "root" && !rootComponent && !slots[name] && internalForwardedProps,
...name !== "root" && !slots[name] && internalForwardedProps,
...mergedProps,
...LeafComponent && !shouldForwardComponentProp && {
as: LeafComponent
},
...LeafComponent && shouldForwardComponentProp && {
component: LeafComponent
},
ref
}, ownerState);
return [
elementType,
props
];
};
getMenuItemUtilityClass = function(slot) {
return generateUtilityClass("MuiMenuItem", slot);
};
menuItemClasses = generateUtilityClasses("MuiMenuItem", [
"root",
"focusVisible",
"dense",
"disabled",
"divider",
"gutters",
"selected"
]);
const overridesResolver$2 = (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.dense && styles2.dense,
ownerState.divider && styles2.divider,
!ownerState.disableGutters && styles2.gutters
];
};
const useUtilityClasses$r = (ownerState) => {
const { disabled, dense, divider, disableGutters, selected, classes } = ownerState;
const slots = {
root: [
"root",
dense && "dense",
disabled && "disabled",
!disableGutters && "gutters",
divider && "divider",
selected && "selected"
]
};
const composedClasses = composeClasses(slots, getMenuItemUtilityClass, classes);
return {
...classes,
...composedClasses
};
};
const MenuItemRoot = styled(ButtonBase, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiMenuItem",
slot: "Root",
overridesResolver: overridesResolver$2
})(memoTheme(({ theme }) => ({
...theme.typography.body1,
display: "flex",
justifyContent: "flex-start",
alignItems: "center",
position: "relative",
textDecoration: "none",
minHeight: 48,
paddingTop: 6,
paddingBottom: 6,
boxSizing: "border-box",
whiteSpace: "nowrap",
"&:hover": {
textDecoration: "none",
backgroundColor: (theme.vars || theme).palette.action.hover,
"@media (hover: none)": {
backgroundColor: "transparent"
}
},
[`&.${menuItemClasses.selected}`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity),
[`&.${menuItemClasses.focusVisible}`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.focusOpacity}))` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
}
},
[`&.${menuItemClasses.selected}:hover`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.hoverOpacity}))` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
"@media (hover: none)": {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
}
},
[`&.${menuItemClasses.focusVisible}`]: {
backgroundColor: (theme.vars || theme).palette.action.focus
},
[`&.${menuItemClasses.disabled}`]: {
opacity: (theme.vars || theme).palette.action.disabledOpacity
},
[`& + .${dividerClasses.root}`]: {
marginTop: theme.spacing(1),
marginBottom: theme.spacing(1)
},
[`& + .${dividerClasses.inset}`]: {
marginLeft: 52
},
[`& .${listItemTextClasses.root}`]: {
marginTop: 0,
marginBottom: 0
},
[`& .${listItemTextClasses.inset}`]: {
paddingLeft: 36
},
[`& .${listItemIconClasses.root}`]: {
minWidth: 36
},
variants: [
{
props: ({ ownerState }) => !ownerState.disableGutters,
style: {
paddingLeft: 16,
paddingRight: 16
}
},
{
props: ({ ownerState }) => ownerState.divider,
style: {
borderBottom: `1px solid ${(theme.vars || theme).palette.divider}`,
backgroundClip: "padding-box"
}
},
{
props: ({ ownerState }) => !ownerState.dense,
style: {
[theme.breakpoints.up("sm")]: {
minHeight: "auto"
}
}
},
{
props: ({ ownerState }) => ownerState.dense,
style: {
minHeight: 32,
paddingTop: 4,
paddingBottom: 4,
...theme.typography.body2,
[`& .${listItemIconClasses.root} svg`]: {
fontSize: "1.25rem"
}
}
}
]
})));
MenuItem = __mf_14(function MenuItem2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiMenuItem"
});
const { autoFocus = false, component = "li", dense = false, divider = false, disableGutters = false, focusVisibleClassName, role = "menuitem", tabIndex: tabIndexProp, className, ...other } = props;
const context = __mf_21(ListContext);
const childContext = __mf_29(() => ({
dense: dense || context.dense || false,
disableGutters
}), [
context.dense,
dense,
disableGutters
]);
const menuItemRef = __mf_31(null);
useEnhancedEffect(() => {
if (autoFocus) {
if (menuItemRef.current) {
menuItemRef.current.focus();
}
}
}, [
autoFocus
]);
const ownerState = {
...props,
dense: childContext.dense,
divider,
disableGutters
};
const classes = useUtilityClasses$r(props);
const handleRef = useForkRef(menuItemRef, ref);
let tabIndex;
if (!props.disabled) {
tabIndex = tabIndexProp !== void 0 ? tabIndexProp : -1;
}
return jsxRuntimeExports.jsx(ListContext.Provider, {
value: childContext,
children: jsxRuntimeExports.jsx(MenuItemRoot, {
ref: handleRef,
role,
tabIndex,
component,
focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
className: clsx(classes.root, className),
...other,
ownerState,
classes
})
});
});
getListUtilityClass = function(slot) {
return generateUtilityClass("MuiList", slot);
};
listClasses = generateUtilityClasses("MuiList", [
"root",
"padding",
"dense",
"subheader"
]);
const useUtilityClasses$q = (ownerState) => {
const { classes, disablePadding, dense, subheader } = ownerState;
const slots = {
root: [
"root",
!disablePadding && "padding",
dense && "dense",
subheader && "subheader"
]
};
return composeClasses(slots, getListUtilityClass, classes);
};
const ListRoot = styled("ul", {
name: "MuiList",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
!ownerState.disablePadding && styles2.padding,
ownerState.dense && styles2.dense,
ownerState.subheader && styles2.subheader
];
}
})({
listStyle: "none",
margin: 0,
padding: 0,
position: "relative",
variants: [
{
props: ({ ownerState }) => !ownerState.disablePadding,
style: {
paddingTop: 8,
paddingBottom: 8
}
},
{
props: ({ ownerState }) => ownerState.subheader,
style: {
paddingTop: 0
}
}
]
});
List = __mf_14(function List2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiList"
});
const { children, className, component = "ul", dense = false, disablePadding = false, subheader, ...other } = props;
const context = __mf_29(() => ({
dense
}), [
dense
]);
const ownerState = {
...props,
component,
dense,
disablePadding
};
const classes = useUtilityClasses$q(ownerState);
return jsxRuntimeExports.jsx(ListContext.Provider, {
value: context,
children: jsxRuntimeExports.jsxs(ListRoot, {
as: component,
className: clsx(classes.root, className),
ref,
ownerState,
...other,
children: [
subheader,
children
]
})
});
});
function nextItem(list, item, disableListWrap) {
if (list === item) {
return list.firstChild;
}
if (item && item.nextElementSibling) {
return item.nextElementSibling;
}
return disableListWrap ? null : list.firstChild;
}
function previousItem(list, item, disableListWrap) {
if (list === item) {
return disableListWrap ? list.firstChild : list.lastChild;
}
if (item && item.previousElementSibling) {
return item.previousElementSibling;
}
return disableListWrap ? null : list.lastChild;
}
function textCriteriaMatches(nextFocus, textCriteria) {
if (textCriteria === void 0) {
return true;
}
let text = nextFocus.innerText;
if (text === void 0) {
text = nextFocus.textContent;
}
text = text.trim().toLowerCase();
if (text.length === 0) {
return false;
}
if (textCriteria.repeating) {
return text[0] === textCriteria.keys[0];
}
return text.startsWith(textCriteria.keys.join(""));
}
function moveFocus(list, currentFocus, disableListWrap, disabledItemsFocusable, traversalFunction, textCriteria) {
let wrappedOnce = false;
let nextFocus = traversalFunction(list, currentFocus, currentFocus ? disableListWrap : false);
while (nextFocus) {
if (nextFocus === list.firstChild) {
if (wrappedOnce) {
return false;
}
wrappedOnce = true;
}
const nextFocusDisabled = disabledItemsFocusable ? false : nextFocus.disabled || nextFocus.getAttribute("aria-disabled") === "true";
if (!nextFocus.hasAttribute("tabindex") || !textCriteriaMatches(nextFocus, textCriteria) || nextFocusDisabled) {
nextFocus = traversalFunction(list, nextFocus, disableListWrap);
} else {
nextFocus.focus();
return true;
}
}
return false;
}
MenuList = __mf_14(function MenuList2(props, ref) {
const { actions, autoFocus = false, autoFocusItem = false, children, className, disabledItemsFocusable = false, disableListWrap = false, onKeyDown, variant = "selectedMenu", ...other } = props;
const listRef = __mf_31(null);
const textCriteriaRef = __mf_31({
keys: [],
repeating: true,
previousKeyMatched: true,
lastTime: null
});
useEnhancedEffect(() => {
if (autoFocus) {
listRef.current.focus();
}
}, [
autoFocus
]);
__mf_26(actions, () => ({
adjustStyleForScrollbar: (containerElement, { direction }) => {
const noExplicitWidth = !listRef.current.style.width;
if (containerElement.clientHeight < listRef.current.clientHeight && noExplicitWidth) {
const scrollbarSize = `${getScrollbarSize(ownerWindow(containerElement))}px`;
listRef.current.style[direction === "rtl" ? "paddingLeft" : "paddingRight"] = scrollbarSize;
listRef.current.style.width = `calc(100% + ${scrollbarSize})`;
}
return listRef.current;
}
}), []);
const handleKeyDown = (event) => {
const list = listRef.current;
const key = event.key;
const isModifierKeyPressed = event.ctrlKey || event.metaKey || event.altKey;
if (isModifierKeyPressed) {
if (onKeyDown) {
onKeyDown(event);
}
return;
}
const currentFocus = ownerDocument(list).activeElement;
if (key === "ArrowDown") {
event.preventDefault();
moveFocus(list, currentFocus, disableListWrap, disabledItemsFocusable, nextItem);
} else if (key === "ArrowUp") {
event.preventDefault();
moveFocus(list, currentFocus, disableListWrap, disabledItemsFocusable, previousItem);
} else if (key === "Home") {
event.preventDefault();
moveFocus(list, null, disableListWrap, disabledItemsFocusable, nextItem);
} else if (key === "End") {
event.preventDefault();
moveFocus(list, null, disableListWrap, disabledItemsFocusable, previousItem);
} else if (key.length === 1) {
const criteria = textCriteriaRef.current;
const lowerKey = key.toLowerCase();
const currTime = performance.now();
if (criteria.keys.length > 0) {
if (currTime - criteria.lastTime > 500) {
criteria.keys = [];
criteria.repeating = true;
criteria.previousKeyMatched = true;
} else if (criteria.repeating && lowerKey !== criteria.keys[0]) {
criteria.repeating = false;
}
}
criteria.lastTime = currTime;
criteria.keys.push(lowerKey);
const keepFocusOnCurrent = currentFocus && !criteria.repeating && textCriteriaMatches(currentFocus, criteria);
if (criteria.previousKeyMatched && (keepFocusOnCurrent || moveFocus(list, currentFocus, false, disabledItemsFocusable, nextItem, criteria))) {
event.preventDefault();
} else {
criteria.previousKeyMatched = false;
}
}
if (onKeyDown) {
onKeyDown(event);
}
};
const handleRef = useForkRef(listRef, ref);
let activeItemIndex = -1;
__mf_0.forEach(children, (child, index) => {
if (!__mf_15(child)) {
if (activeItemIndex === index) {
activeItemIndex += 1;
if (activeItemIndex >= children.length) {
activeItemIndex = -1;
}
}
return;
}
if (!child.props.disabled) {
if (variant === "selectedMenu" && child.props.selected) {
activeItemIndex = index;
} else if (activeItemIndex === -1) {
activeItemIndex = index;
}
}
if (activeItemIndex === index && (child.props.disabled || child.props.muiSkipListHighlight || child.type.muiSkipListHighlight)) {
activeItemIndex += 1;
if (activeItemIndex >= children.length) {
activeItemIndex = -1;
}
}
});
const items = __mf_0.map(children, (child, index) => {
if (index === activeItemIndex) {
const newChildProps = {};
if (autoFocusItem) {
newChildProps.autoFocus = true;
}
if (child.props.tabIndex === void 0 && variant === "selectedMenu") {
newChildProps.tabIndex = 0;
}
return __mf_9(child, newChildProps);
}
return child;
});
return jsxRuntimeExports.jsx(List, {
role: "menu",
ref: handleRef,
className,
onKeyDown: handleKeyDown,
tabIndex: autoFocus ? 0 : -1,
...other,
children: items
});
});
function getStyleValue(value) {
return parseInt(value, 10) || 0;
}
const styles$2 = {
shadow: {
visibility: "hidden",
position: "absolute",
overflow: "hidden",
height: 0,
top: 0,
left: 0,
transform: "translateZ(0)"
}
};
function isObjectEmpty(object) {
for (const _ in object) {
return false;
}
return true;
}
function isEmpty$1(obj) {
return isObjectEmpty(obj) || obj.outerHeightStyle === 0 && !obj.overflowing;
}
TextareaAutosize = __mf_14(function TextareaAutosize2(props, forwardedRef) {
const { onChange, maxRows, minRows = 1, style, value, ...other } = props;
const { current: isControlled } = __mf_31(value != null);
const textareaRef = __mf_31(null);
const handleRef = useForkRef(forwardedRef, textareaRef);
const heightRef = __mf_31(null);
const hiddenTextareaRef = __mf_31(null);
const calculateTextareaStyles = __mf_20(() => {
const textarea = textareaRef.current;
const hiddenTextarea = hiddenTextareaRef.current;
if (!textarea || !hiddenTextarea) {
return void 0;
}
const containerWindow = ownerWindow(textarea);
const computedStyle = containerWindow.getComputedStyle(textarea);
if (computedStyle.width === "0px") {
return {
outerHeightStyle: 0,
overflowing: false
};
}
hiddenTextarea.style.width = computedStyle.width;
hiddenTextarea.value = textarea.value || props.placeholder || "x";
if (hiddenTextarea.value.slice(-1) === "\n") {
hiddenTextarea.value += " ";
}
const boxSizing = computedStyle.boxSizing;
const padding = getStyleValue(computedStyle.paddingBottom) + getStyleValue(computedStyle.paddingTop);
const border = getStyleValue(computedStyle.borderBottomWidth) + getStyleValue(computedStyle.borderTopWidth);
const innerHeight = hiddenTextarea.scrollHeight;
hiddenTextarea.value = "x";
const singleRowHeight = hiddenTextarea.scrollHeight;
let outerHeight = innerHeight;
if (minRows) {
outerHeight = Math.max(Number(minRows) * singleRowHeight, outerHeight);
}
if (maxRows) {
outerHeight = Math.min(Number(maxRows) * singleRowHeight, outerHeight);
}
outerHeight = Math.max(outerHeight, singleRowHeight);
const outerHeightStyle = outerHeight + (boxSizing === "border-box" ? padding + border : 0);
const overflowing = Math.abs(outerHeight - innerHeight) <= 1;
return {
outerHeightStyle,
overflowing
};
}, [
maxRows,
minRows,
props.placeholder
]);
const didHeightChange = useEventCallback(() => {
const textarea = textareaRef.current;
const textareaStyles = calculateTextareaStyles();
if (!textarea || !textareaStyles || isEmpty$1(textareaStyles)) {
return false;
}
const outerHeightStyle = textareaStyles.outerHeightStyle;
return heightRef.current != null && heightRef.current !== outerHeightStyle;
});
const syncHeight = __mf_20(() => {
const textarea = textareaRef.current;
const textareaStyles = calculateTextareaStyles();
if (!textarea || !textareaStyles || isEmpty$1(textareaStyles)) {
return;
}
const outerHeightStyle = textareaStyles.outerHeightStyle;
if (heightRef.current !== outerHeightStyle) {
heightRef.current = outerHeightStyle;
textarea.style.height = `${outerHeightStyle}px`;
}
textarea.style.overflow = textareaStyles.overflowing ? "hidden" : "";
}, [
calculateTextareaStyles
]);
const frameRef = __mf_31(-1);
useEnhancedEffect(() => {
const debouncedHandleResize = debounce$1(syncHeight);
const textarea = textareaRef == null ? void 0 : textareaRef.current;
if (!textarea) {
return void 0;
}
const containerWindow = ownerWindow(textarea);
containerWindow.addEventListener("resize", debouncedHandleResize);
let resizeObserver;
if (typeof ResizeObserver !== "undefined") {
resizeObserver = new ResizeObserver(() => {
if (didHeightChange()) {
resizeObserver.unobserve(textarea);
cancelAnimationFrame(frameRef.current);
syncHeight();
frameRef.current = requestAnimationFrame(() => {
resizeObserver.observe(textarea);
});
}
});
resizeObserver.observe(textarea);
}
return () => {
debouncedHandleResize.clear();
cancelAnimationFrame(frameRef.current);
containerWindow.removeEventListener("resize", debouncedHandleResize);
if (resizeObserver) {
resizeObserver.disconnect();
}
};
}, [
calculateTextareaStyles,
syncHeight,
didHeightChange
]);
useEnhancedEffect(() => {
syncHeight();
});
const handleChange = (event) => {
if (!isControlled) {
syncHeight();
}
if (onChange) {
onChange(event);
}
};
return jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
jsxRuntimeExports.jsx("textarea", {
value,
onChange: handleChange,
ref: handleRef,
rows: minRows,
style,
...other
}),
jsxRuntimeExports.jsx("textarea", {
"aria-hidden": true,
className: props.className,
readOnly: true,
ref: hiddenTextareaRef,
tabIndex: -1,
style: {
...styles$2.shadow,
...style,
paddingTop: 0,
paddingBottom: 0
}
})
]
});
});
isHostComponent = function(element) {
return typeof element === "string";
};
formControlState = function({ props, states, muiFormControl }) {
return states.reduce((acc, state) => {
acc[state] = props[state];
if (muiFormControl) {
if (typeof props[state] === "undefined") {
acc[state] = muiFormControl[state];
}
}
return acc;
}, {});
};
const FormControlContext = __mf_10(void 0);
useFormControl = function() {
return __mf_21(FormControlContext);
};
function hasValue(value) {
return value != null && !(Array.isArray(value) && value.length === 0);
}
function isFilled(obj, SSR = false) {
return obj && (hasValue(obj.value) && obj.value !== "" || SSR && hasValue(obj.defaultValue) && obj.defaultValue !== "");
}
function isAdornedStart(obj) {
return obj.startAdornment;
}
getInputBaseUtilityClass = function(slot) {
return generateUtilityClass("MuiInputBase", slot);
};
inputBaseClasses = generateUtilityClasses("MuiInputBase", [
"root",
"formControl",
"focused",
"disabled",
"adornedStart",
"adornedEnd",
"error",
"sizeSmall",
"multiline",
"colorSecondary",
"fullWidth",
"hiddenLabel",
"readOnly",
"input",
"inputSizeSmall",
"inputMultiline",
"inputTypeSearch",
"inputAdornedStart",
"inputAdornedEnd",
"inputHiddenLabel"
]);
var _InputGlobalStyles;
const rootOverridesResolver = (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.formControl && styles2.formControl,
ownerState.startAdornment && styles2.adornedStart,
ownerState.endAdornment && styles2.adornedEnd,
ownerState.error && styles2.error,
ownerState.size === "small" && styles2.sizeSmall,
ownerState.multiline && styles2.multiline,
ownerState.color && styles2[`color${capitalize(ownerState.color)}`],
ownerState.fullWidth && styles2.fullWidth,
ownerState.hiddenLabel && styles2.hiddenLabel
];
};
const inputOverridesResolver = (props, styles2) => {
const { ownerState } = props;
return [
styles2.input,
ownerState.size === "small" && styles2.inputSizeSmall,
ownerState.multiline && styles2.inputMultiline,
ownerState.type === "search" && styles2.inputTypeSearch,
ownerState.startAdornment && styles2.inputAdornedStart,
ownerState.endAdornment && styles2.inputAdornedEnd,
ownerState.hiddenLabel && styles2.inputHiddenLabel
];
};
const useUtilityClasses$p = (ownerState) => {
const { classes, color, disabled, error, endAdornment, focused, formControl, fullWidth, hiddenLabel, multiline, readOnly, size, startAdornment, type } = ownerState;
const slots = {
root: [
"root",
`color${capitalize(color)}`,
disabled && "disabled",
error && "error",
fullWidth && "fullWidth",
focused && "focused",
formControl && "formControl",
size && size !== "medium" && `size${capitalize(size)}`,
multiline && "multiline",
startAdornment && "adornedStart",
endAdornment && "adornedEnd",
hiddenLabel && "hiddenLabel",
readOnly && "readOnly"
],
input: [
"input",
disabled && "disabled",
type === "search" && "inputTypeSearch",
multiline && "inputMultiline",
size === "small" && "inputSizeSmall",
hiddenLabel && "inputHiddenLabel",
startAdornment && "inputAdornedStart",
endAdornment && "inputAdornedEnd",
readOnly && "readOnly"
]
};
return composeClasses(slots, getInputBaseUtilityClass, classes);
};
const InputBaseRoot = styled("div", {
name: "MuiInputBase",
slot: "Root",
overridesResolver: rootOverridesResolver
})(memoTheme(({ theme }) => ({
...theme.typography.body1,
color: (theme.vars || theme).palette.text.primary,
lineHeight: "1.4375em",
boxSizing: "border-box",
position: "relative",
cursor: "text",
display: "inline-flex",
alignItems: "center",
[`&.${inputBaseClasses.disabled}`]: {
color: (theme.vars || theme).palette.text.disabled,
cursor: "default"
},
variants: [
{
props: ({ ownerState }) => ownerState.multiline,
style: {
padding: "4px 0 5px"
}
},
{
props: ({ ownerState, size }) => ownerState.multiline && size === "small",
style: {
paddingTop: 1
}
},
{
props: ({ ownerState }) => ownerState.fullWidth,
style: {
width: "100%"
}
}
]
})));
const InputBaseInput = styled("input", {
name: "MuiInputBase",
slot: "Input",
overridesResolver: inputOverridesResolver
})(memoTheme(({ theme }) => {
const light = theme.palette.mode === "light";
const placeholder = {
color: "currentColor",
...theme.vars ? {
opacity: theme.vars.opacity.inputPlaceholder
} : {
opacity: light ? 0.42 : 0.5
},
transition: theme.transitions.create("opacity", {
duration: theme.transitions.duration.shorter
})
};
const placeholderHidden = {
opacity: "0 !important"
};
const placeholderVisible = theme.vars ? {
opacity: theme.vars.opacity.inputPlaceholder
} : {
opacity: light ? 0.42 : 0.5
};
return {
font: "inherit",
letterSpacing: "inherit",
color: "currentColor",
padding: "4px 0 5px",
border: 0,
boxSizing: "content-box",
background: "none",
height: "1.4375em",
margin: 0,
WebkitTapHighlightColor: "transparent",
display: "block",
minWidth: 0,
width: "100%",
"&::-webkit-input-placeholder": placeholder,
"&::-moz-placeholder": placeholder,
"&::-ms-input-placeholder": placeholder,
"&:focus": {
outline: 0
},
"&:invalid": {
boxShadow: "none"
},
"&::-webkit-search-decoration": {
WebkitAppearance: "none"
},
[`label[data-shrink=false] + .${inputBaseClasses.formControl} &`]: {
"&::-webkit-input-placeholder": placeholderHidden,
"&::-moz-placeholder": placeholderHidden,
"&::-ms-input-placeholder": placeholderHidden,
"&:focus::-webkit-input-placeholder": placeholderVisible,
"&:focus::-moz-placeholder": placeholderVisible,
"&:focus::-ms-input-placeholder": placeholderVisible
},
[`&.${inputBaseClasses.disabled}`]: {
opacity: 1,
WebkitTextFillColor: (theme.vars || theme).palette.text.disabled
},
variants: [
{
props: ({ ownerState }) => !ownerState.disableInjectingGlobalStyles,
style: {
animationName: "mui-auto-fill-cancel",
animationDuration: "10ms",
"&:-webkit-autofill": {
animationDuration: "5000s",
animationName: "mui-auto-fill"
}
}
},
{
props: {
size: "small"
},
style: {
paddingTop: 1
}
},
{
props: ({ ownerState }) => ownerState.multiline,
style: {
height: "auto",
resize: "none",
padding: 0,
paddingTop: 0
}
},
{
props: {
type: "search"
},
style: {
MozAppearance: "textfield"
}
}
]
};
}));
const InputGlobalStyles = globalCss({
"@keyframes mui-auto-fill": {
from: {
display: "block"
}
},
"@keyframes mui-auto-fill-cancel": {
from: {
display: "block"
}
}
});
InputBase = __mf_14(function InputBase2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiInputBase"
});
const { "aria-describedby": ariaDescribedby, autoComplete, autoFocus, className, color, components = {}, componentsProps = {}, defaultValue, disabled, disableInjectingGlobalStyles, endAdornment, error, fullWidth = false, id, inputComponent = "input", inputProps: inputPropsProp = {}, inputRef: inputRefProp, margin, maxRows, minRows, multiline = false, name, onBlur, onChange, onClick, onFocus, onKeyDown, onKeyUp, placeholder, readOnly, renderSuffix, rows, size, slotProps = {}, slots = {}, startAdornment, type = "text", value: valueProp, ...other } = props;
const value = inputPropsProp.value != null ? inputPropsProp.value : valueProp;
const { current: isControlled } = __mf_31(value != null);
const inputRef = __mf_31();
const handleInputRefWarning = __mf_20((instance) => {
}, []);
const handleInputRef = useForkRef(inputRef, inputRefProp, inputPropsProp.ref, handleInputRefWarning);
const [focused, setFocused] = __mf_32(false);
const muiFormControl = useFormControl();
const fcs = formControlState({
props,
muiFormControl,
states: [
"color",
"disabled",
"error",
"hiddenLabel",
"size",
"required",
"filled"
]
});
fcs.focused = muiFormControl ? muiFormControl.focused : focused;
__mf_24(() => {
if (!muiFormControl && disabled && focused) {
setFocused(false);
if (onBlur) {
onBlur();
}
}
}, [
muiFormControl,
disabled,
focused,
onBlur
]);
const onFilled = muiFormControl && muiFormControl.onFilled;
const onEmpty = muiFormControl && muiFormControl.onEmpty;
const checkDirty = __mf_20((obj) => {
if (isFilled(obj)) {
if (onFilled) {
onFilled();
}
} else if (onEmpty) {
onEmpty();
}
}, [
onFilled,
onEmpty
]);
useEnhancedEffect(() => {
if (isControlled) {
checkDirty({
value
});
}
}, [
value,
checkDirty,
isControlled
]);
const handleFocus = (event) => {
if (onFocus) {
onFocus(event);
}
if (inputPropsProp.onFocus) {
inputPropsProp.onFocus(event);
}
if (muiFormControl && muiFormControl.onFocus) {
muiFormControl.onFocus(event);
} else {
setFocused(true);
}
};
const handleBlur = (event) => {
if (onBlur) {
onBlur(event);
}
if (inputPropsProp.onBlur) {
inputPropsProp.onBlur(event);
}
if (muiFormControl && muiFormControl.onBlur) {
muiFormControl.onBlur(event);
} else {
setFocused(false);
}
};
const handleChange = (event, ...args) => {
if (!isControlled) {
const element = event.target || inputRef.current;
if (element == null) {
throw new Error(formatMuiErrorMessage(1));
}
checkDirty({
value: element.value
});
}
if (inputPropsProp.onChange) {
inputPropsProp.onChange(event, ...args);
}
if (onChange) {
onChange(event, ...args);
}
};
__mf_24(() => {
checkDirty(inputRef.current);
}, []);
const handleClick = (event) => {
if (inputRef.current && event.currentTarget === event.target) {
inputRef.current.focus();
}
if (onClick) {
onClick(event);
}
};
let InputComponent = inputComponent;
let inputProps = inputPropsProp;
if (multiline && InputComponent === "input") {
if (rows) {
inputProps = {
type: void 0,
minRows: rows,
maxRows: rows,
...inputProps
};
} else {
inputProps = {
type: void 0,
maxRows,
minRows,
...inputProps
};
}
InputComponent = TextareaAutosize;
}
const handleAutoFill = (event) => {
checkDirty(event.animationName === "mui-auto-fill-cancel" ? inputRef.current : {
value: "x"
});
};
__mf_24(() => {
if (muiFormControl) {
muiFormControl.setAdornedStart(Boolean(startAdornment));
}
}, [
muiFormControl,
startAdornment
]);
const ownerState = {
...props,
color: fcs.color || "primary",
disabled: fcs.disabled,
endAdornment,
error: fcs.error,
focused: fcs.focused,
formControl: muiFormControl,
fullWidth,
hiddenLabel: fcs.hiddenLabel,
multiline,
size: fcs.size,
startAdornment,
type
};
const classes = useUtilityClasses$p(ownerState);
const Root = slots.root || components.Root || InputBaseRoot;
const rootProps = slotProps.root || componentsProps.root || {};
const Input2 = slots.input || components.Input || InputBaseInput;
inputProps = {
...inputProps,
...slotProps.input ?? componentsProps.input
};
return jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
!disableInjectingGlobalStyles && typeof InputGlobalStyles === "function" && (_InputGlobalStyles || (_InputGlobalStyles = jsxRuntimeExports.jsx(InputGlobalStyles, {}))),
jsxRuntimeExports.jsxs(Root, {
...rootProps,
ref,
onClick: handleClick,
...other,
...!isHostComponent(Root) && {
ownerState: {
...ownerState,
...rootProps.ownerState
}
},
className: clsx(classes.root, rootProps.className, className, readOnly && "MuiInputBase-readOnly"),
children: [
startAdornment,
jsxRuntimeExports.jsx(FormControlContext.Provider, {
value: null,
children: jsxRuntimeExports.jsx(Input2, {
"aria-invalid": fcs.error,
"aria-describedby": ariaDescribedby,
autoComplete,
autoFocus,
defaultValue,
disabled: fcs.disabled,
id,
onAnimationStart: handleAutoFill,
name,
placeholder,
readOnly,
required: fcs.required,
rows,
value,
onKeyDown,
onKeyUp,
type,
...inputProps,
...!isHostComponent(Input2) && {
as: InputComponent,
ownerState: {
...ownerState,
...inputProps.ownerState
}
},
ref: handleInputRef,
className: clsx(classes.input, inputProps.className, readOnly && "MuiInputBase-readOnly"),
onBlur: handleBlur,
onChange: handleChange,
onFocus: handleFocus
})
}),
endAdornment,
renderSuffix ? renderSuffix({
...fcs,
startAdornment
}) : null
]
})
]
});
});
getInputUtilityClass = function(slot) {
return generateUtilityClass("MuiInput", slot);
};
inputClasses = {
...inputBaseClasses,
...generateUtilityClasses("MuiInput", [
"root",
"underline",
"input"
])
};
const useUtilityClasses$o = (ownerState) => {
const { classes, disableUnderline } = ownerState;
const slots = {
root: [
"root",
!disableUnderline && "underline"
],
input: [
"input"
]
};
const composedClasses = composeClasses(slots, getInputUtilityClass, classes);
return {
...classes,
...composedClasses
};
};
const InputRoot = styled(InputBaseRoot, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiInput",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
...rootOverridesResolver(props, styles2),
!ownerState.disableUnderline && styles2.underline
];
}
})(memoTheme(({ theme }) => {
const light = theme.palette.mode === "light";
let bottomLineColor = light ? "rgba(0, 0, 0, 0.42)" : "rgba(255, 255, 255, 0.7)";
if (theme.vars) {
bottomLineColor = `rgba(${theme.vars.palette.common.onBackgroundChannel} / ${theme.vars.opacity.inputUnderline})`;
}
return {
position: "relative",
variants: [
{
props: ({ ownerState }) => ownerState.formControl,
style: {
"label + &": {
marginTop: 16
}
}
},
{
props: ({ ownerState }) => !ownerState.disableUnderline,
style: {
"&::after": {
left: 0,
bottom: 0,
content: '""',
position: "absolute",
right: 0,
transform: "scaleX(0)",
transition: theme.transitions.create("transform", {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
}),
pointerEvents: "none"
},
[`&.${inputClasses.focused}:after`]: {
transform: "scaleX(1) translateX(0)"
},
[`&.${inputClasses.error}`]: {
"&::before, &::after": {
borderBottomColor: (theme.vars || theme).palette.error.main
}
},
"&::before": {
borderBottom: `1px solid ${bottomLineColor}`,
left: 0,
bottom: 0,
content: '"\\00a0"',
position: "absolute",
right: 0,
transition: theme.transitions.create("border-bottom-color", {
duration: theme.transitions.duration.shorter
}),
pointerEvents: "none"
},
[`&:hover:not(.${inputClasses.disabled}, .${inputClasses.error}):before`]: {
borderBottom: `2px solid ${(theme.vars || theme).palette.text.primary}`,
"@media (hover: none)": {
borderBottom: `1px solid ${bottomLineColor}`
}
},
[`&.${inputClasses.disabled}:before`]: {
borderBottomStyle: "dotted"
}
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color,
disableUnderline: false
},
style: {
"&::after": {
borderBottom: `2px solid ${(theme.vars || theme).palette[color].main}`
}
}
}))
]
};
}));
const InputInput = styled(InputBaseInput, {
name: "MuiInput",
slot: "Input",
overridesResolver: inputOverridesResolver
})({});
Input = __mf_14(function Input2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiInput"
});
const { disableUnderline = false, components = {}, componentsProps: componentsPropsProp, fullWidth = false, inputComponent = "input", multiline = false, slotProps, slots = {}, type = "text", ...other } = props;
const classes = useUtilityClasses$o(props);
const ownerState = {
disableUnderline
};
const inputComponentsProps = {
root: {
ownerState
}
};
const componentsProps = slotProps ?? componentsPropsProp ? deepmerge(slotProps ?? componentsPropsProp, inputComponentsProps) : inputComponentsProps;
const RootSlot = slots.root ?? components.Root ?? InputRoot;
const InputSlot = slots.input ?? components.Input ?? InputInput;
return jsxRuntimeExports.jsx(InputBase, {
slots: {
root: RootSlot,
input: InputSlot
},
slotProps: componentsProps,
fullWidth,
inputComponent,
multiline,
ref,
type,
...other,
classes
});
});
Input.muiName = "Input";
getFilledInputUtilityClass = function(slot) {
return generateUtilityClass("MuiFilledInput", slot);
};
filledInputClasses = {
...inputBaseClasses,
...generateUtilityClasses("MuiFilledInput", [
"root",
"underline",
"input",
"adornedStart",
"adornedEnd",
"sizeSmall",
"multiline",
"hiddenLabel"
])
};
const useUtilityClasses$n = (ownerState) => {
const { classes, disableUnderline, startAdornment, endAdornment, size, hiddenLabel, multiline } = ownerState;
const slots = {
root: [
"root",
!disableUnderline && "underline",
startAdornment && "adornedStart",
endAdornment && "adornedEnd",
size === "small" && `size${capitalize(size)}`,
hiddenLabel && "hiddenLabel",
multiline && "multiline"
],
input: [
"input"
]
};
const composedClasses = composeClasses(slots, getFilledInputUtilityClass, classes);
return {
...classes,
...composedClasses
};
};
const FilledInputRoot = styled(InputBaseRoot, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiFilledInput",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
...rootOverridesResolver(props, styles2),
!ownerState.disableUnderline && styles2.underline
];
}
})(memoTheme(({ theme }) => {
const light = theme.palette.mode === "light";
const bottomLineColor = light ? "rgba(0, 0, 0, 0.42)" : "rgba(255, 255, 255, 0.7)";
const backgroundColor = light ? "rgba(0, 0, 0, 0.06)" : "rgba(255, 255, 255, 0.09)";
const hoverBackground = light ? "rgba(0, 0, 0, 0.09)" : "rgba(255, 255, 255, 0.13)";
const disabledBackground = light ? "rgba(0, 0, 0, 0.12)" : "rgba(255, 255, 255, 0.12)";
return {
position: "relative",
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor,
borderTopLeftRadius: (theme.vars || theme).shape.borderRadius,
borderTopRightRadius: (theme.vars || theme).shape.borderRadius,
transition: theme.transitions.create("background-color", {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
}),
"&:hover": {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.hoverBg : hoverBackground,
"@media (hover: none)": {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor
}
},
[`&.${filledInputClasses.focused}`]: {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor
},
[`&.${filledInputClasses.disabled}`]: {
backgroundColor: theme.vars ? theme.vars.palette.FilledInput.disabledBg : disabledBackground
},
variants: [
{
props: ({ ownerState }) => !ownerState.disableUnderline,
style: {
"&::after": {
left: 0,
bottom: 0,
content: '""',
position: "absolute",
right: 0,
transform: "scaleX(0)",
transition: theme.transitions.create("transform", {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
}),
pointerEvents: "none"
},
[`&.${filledInputClasses.focused}:after`]: {
transform: "scaleX(1) translateX(0)"
},
[`&.${filledInputClasses.error}`]: {
"&::before, &::after": {
borderBottomColor: (theme.vars || theme).palette.error.main
}
},
"&::before": {
borderBottom: `1px solid ${theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / ${theme.vars.opacity.inputUnderline})` : bottomLineColor}`,
left: 0,
bottom: 0,
content: '"\\00a0"',
position: "absolute",
right: 0,
transition: theme.transitions.create("border-bottom-color", {
duration: theme.transitions.duration.shorter
}),
pointerEvents: "none"
},
[`&:hover:not(.${filledInputClasses.disabled}, .${filledInputClasses.error}):before`]: {
borderBottom: `1px solid ${(theme.vars || theme).palette.text.primary}`
},
[`&.${filledInputClasses.disabled}:before`]: {
borderBottomStyle: "dotted"
}
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => {
var _a;
return {
props: {
disableUnderline: false,
color
},
style: {
"&::after": {
borderBottom: `2px solid ${(_a = (theme.vars || theme).palette[color]) == null ? void 0 : _a.main}`
}
}
};
}),
{
props: ({ ownerState }) => ownerState.startAdornment,
style: {
paddingLeft: 12
}
},
{
props: ({ ownerState }) => ownerState.endAdornment,
style: {
paddingRight: 12
}
},
{
props: ({ ownerState }) => ownerState.multiline,
style: {
padding: "25px 12px 8px"
}
},
{
props: ({ ownerState, size }) => ownerState.multiline && size === "small",
style: {
paddingTop: 21,
paddingBottom: 4
}
},
{
props: ({ ownerState }) => ownerState.multiline && ownerState.hiddenLabel,
style: {
paddingTop: 16,
paddingBottom: 17
}
},
{
props: ({ ownerState }) => ownerState.multiline && ownerState.hiddenLabel && ownerState.size === "small",
style: {
paddingTop: 8,
paddingBottom: 9
}
}
]
};
}));
const FilledInputInput = styled(InputBaseInput, {
name: "MuiFilledInput",
slot: "Input",
overridesResolver: inputOverridesResolver
})(memoTheme(({ theme }) => ({
paddingTop: 25,
paddingRight: 12,
paddingBottom: 8,
paddingLeft: 12,
...!theme.vars && {
"&:-webkit-autofill": {
WebkitBoxShadow: theme.palette.mode === "light" ? null : "0 0 0 100px #266798 inset",
WebkitTextFillColor: theme.palette.mode === "light" ? null : "#fff",
caretColor: theme.palette.mode === "light" ? null : "#fff",
borderTopLeftRadius: "inherit",
borderTopRightRadius: "inherit"
}
},
...theme.vars && {
"&:-webkit-autofill": {
borderTopLeftRadius: "inherit",
borderTopRightRadius: "inherit"
},
[theme.getColorSchemeSelector("dark")]: {
"&:-webkit-autofill": {
WebkitBoxShadow: "0 0 0 100px #266798 inset",
WebkitTextFillColor: "#fff",
caretColor: "#fff"
}
}
},
variants: [
{
props: {
size: "small"
},
style: {
paddingTop: 21,
paddingBottom: 4
}
},
{
props: ({ ownerState }) => ownerState.hiddenLabel,
style: {
paddingTop: 16,
paddingBottom: 17
}
},
{
props: ({ ownerState }) => ownerState.startAdornment,
style: {
paddingLeft: 0
}
},
{
props: ({ ownerState }) => ownerState.endAdornment,
style: {
paddingRight: 0
}
},
{
props: ({ ownerState }) => ownerState.hiddenLabel && ownerState.size === "small",
style: {
paddingTop: 8,
paddingBottom: 9
}
},
{
props: ({ ownerState }) => ownerState.multiline,
style: {
paddingTop: 0,
paddingBottom: 0,
paddingLeft: 0,
paddingRight: 0
}
}
]
})));
FilledInput = __mf_14(function FilledInput2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiFilledInput"
});
const { disableUnderline = false, components = {}, componentsProps: componentsPropsProp, fullWidth = false, hiddenLabel, inputComponent = "input", multiline = false, slotProps, slots = {}, type = "text", ...other } = props;
const ownerState = {
...props,
disableUnderline,
fullWidth,
inputComponent,
multiline,
type
};
const classes = useUtilityClasses$n(props);
const filledInputComponentsProps = {
root: {
ownerState
},
input: {
ownerState
}
};
const componentsProps = slotProps ?? componentsPropsProp ? deepmerge(filledInputComponentsProps, slotProps ?? componentsPropsProp) : filledInputComponentsProps;
const RootSlot = slots.root ?? components.Root ?? FilledInputRoot;
const InputSlot = slots.input ?? components.Input ?? FilledInputInput;
return jsxRuntimeExports.jsx(InputBase, {
slots: {
root: RootSlot,
input: InputSlot
},
slotProps: componentsProps,
fullWidth,
inputComponent,
multiline,
ref,
type,
...other,
classes
});
});
FilledInput.muiName = "Input";
var _span$3;
const NotchedOutlineRoot$1 = styled("fieldset", {
name: "MuiNotchedOutlined",
shouldForwardProp: rootShouldForwardProp
})({
textAlign: "left",
position: "absolute",
bottom: 0,
right: 0,
top: -5,
left: 0,
margin: 0,
padding: "0 8px",
pointerEvents: "none",
borderRadius: "inherit",
borderStyle: "solid",
borderWidth: 1,
overflow: "hidden",
minWidth: "0%"
});
const NotchedOutlineLegend = styled("legend", {
name: "MuiNotchedOutlined",
shouldForwardProp: rootShouldForwardProp
})(memoTheme(({ theme }) => ({
float: "unset",
width: "auto",
overflow: "hidden",
variants: [
{
props: ({ ownerState }) => !ownerState.withLabel,
style: {
padding: 0,
lineHeight: "11px",
transition: theme.transitions.create("width", {
duration: 150,
easing: theme.transitions.easing.easeOut
})
}
},
{
props: ({ ownerState }) => ownerState.withLabel,
style: {
display: "block",
padding: 0,
height: 11,
fontSize: "0.75em",
visibility: "hidden",
maxWidth: 0.01,
transition: theme.transitions.create("max-width", {
duration: 50,
easing: theme.transitions.easing.easeOut
}),
whiteSpace: "nowrap",
"& > span": {
paddingLeft: 5,
paddingRight: 5,
display: "inline-block",
opacity: 0,
visibility: "visible"
}
}
},
{
props: ({ ownerState }) => ownerState.withLabel && ownerState.notched,
style: {
maxWidth: "100%",
transition: theme.transitions.create("max-width", {
duration: 100,
easing: theme.transitions.easing.easeOut,
delay: 50
})
}
}
]
})));
function NotchedOutline(props) {
const { children, classes, className, label, notched, ...other } = props;
const withLabel = label != null && label !== "";
const ownerState = {
...props,
notched,
withLabel
};
return jsxRuntimeExports.jsx(NotchedOutlineRoot$1, {
"aria-hidden": true,
className,
ownerState,
...other,
children: jsxRuntimeExports.jsx(NotchedOutlineLegend, {
ownerState,
children: withLabel ? jsxRuntimeExports.jsx("span", {
children: label
}) : _span$3 || (_span$3 = jsxRuntimeExports.jsx("span", {
className: "notranslate",
"aria-hidden": true,
children: "\u200B"
}))
})
});
}
getOutlinedInputUtilityClass = function(slot) {
return generateUtilityClass("MuiOutlinedInput", slot);
};
outlinedInputClasses = {
...inputBaseClasses,
...generateUtilityClasses("MuiOutlinedInput", [
"root",
"notchedOutline",
"input"
])
};
const useUtilityClasses$m = (ownerState) => {
const { classes } = ownerState;
const slots = {
root: [
"root"
],
notchedOutline: [
"notchedOutline"
],
input: [
"input"
]
};
const composedClasses = composeClasses(slots, getOutlinedInputUtilityClass, classes);
return {
...classes,
...composedClasses
};
};
const OutlinedInputRoot = styled(InputBaseRoot, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiOutlinedInput",
slot: "Root",
overridesResolver: rootOverridesResolver
})(memoTheme(({ theme }) => {
const borderColor = theme.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)";
return {
position: "relative",
borderRadius: (theme.vars || theme).shape.borderRadius,
[`&:hover .${outlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette.text.primary
},
"@media (hover: none)": {
[`&:hover .${outlinedInputClasses.notchedOutline}`]: {
borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
}
},
[`&.${outlinedInputClasses.focused} .${outlinedInputClasses.notchedOutline}`]: {
borderWidth: 2
},
variants: [
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
[`&.${outlinedInputClasses.focused} .${outlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette[color].main
}
}
})),
{
props: {},
style: {
[`&.${outlinedInputClasses.error} .${outlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette.error.main
},
[`&.${outlinedInputClasses.disabled} .${outlinedInputClasses.notchedOutline}`]: {
borderColor: (theme.vars || theme).palette.action.disabled
}
}
},
{
props: ({ ownerState }) => ownerState.startAdornment,
style: {
paddingLeft: 14
}
},
{
props: ({ ownerState }) => ownerState.endAdornment,
style: {
paddingRight: 14
}
},
{
props: ({ ownerState }) => ownerState.multiline,
style: {
padding: "16.5px 14px"
}
},
{
props: ({ ownerState, size }) => ownerState.multiline && size === "small",
style: {
padding: "8.5px 14px"
}
}
]
};
}));
const NotchedOutlineRoot = styled(NotchedOutline, {
name: "MuiOutlinedInput",
slot: "NotchedOutline",
overridesResolver: (props, styles2) => styles2.notchedOutline
})(memoTheme(({ theme }) => {
const borderColor = theme.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)";
return {
borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
};
}));
const OutlinedInputInput = styled(InputBaseInput, {
name: "MuiOutlinedInput",
slot: "Input",
overridesResolver: inputOverridesResolver
})(memoTheme(({ theme }) => ({
padding: "16.5px 14px",
...!theme.vars && {
"&:-webkit-autofill": {
WebkitBoxShadow: theme.palette.mode === "light" ? null : "0 0 0 100px #266798 inset",
WebkitTextFillColor: theme.palette.mode === "light" ? null : "#fff",
caretColor: theme.palette.mode === "light" ? null : "#fff",
borderRadius: "inherit"
}
},
...theme.vars && {
"&:-webkit-autofill": {
borderRadius: "inherit"
},
[theme.getColorSchemeSelector("dark")]: {
"&:-webkit-autofill": {
WebkitBoxShadow: "0 0 0 100px #266798 inset",
WebkitTextFillColor: "#fff",
caretColor: "#fff"
}
}
},
variants: [
{
props: {
size: "small"
},
style: {
padding: "8.5px 14px"
}
},
{
props: ({ ownerState }) => ownerState.multiline,
style: {
padding: 0
}
},
{
props: ({ ownerState }) => ownerState.startAdornment,
style: {
paddingLeft: 0
}
},
{
props: ({ ownerState }) => ownerState.endAdornment,
style: {
paddingRight: 0
}
}
]
})));
OutlinedInput = __mf_14(function OutlinedInput2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiOutlinedInput"
});
const { components = {}, fullWidth = false, inputComponent = "input", label, multiline = false, notched, slots = {}, slotProps = {}, type = "text", ...other } = props;
const classes = useUtilityClasses$m(props);
const muiFormControl = useFormControl();
const fcs = formControlState({
props,
muiFormControl,
states: [
"color",
"disabled",
"error",
"focused",
"hiddenLabel",
"size",
"required"
]
});
const ownerState = {
...props,
color: fcs.color || "primary",
disabled: fcs.disabled,
error: fcs.error,
focused: fcs.focused,
formControl: muiFormControl,
fullWidth,
hiddenLabel: fcs.hiddenLabel,
multiline,
size: fcs.size,
type
};
const RootSlot = slots.root ?? components.Root ?? OutlinedInputRoot;
const InputSlot = slots.input ?? components.Input ?? OutlinedInputInput;
const [NotchedSlot, notchedProps] = useSlot("notchedOutline", {
elementType: NotchedOutlineRoot,
className: classes.notchedOutline,
shouldForwardComponentProp: true,
ownerState,
externalForwardedProps: {
slots,
slotProps
},
additionalProps: {
label: label != null && label !== "" && fcs.required ? jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
label,
"\u2009",
"*"
]
}) : label
}
});
return jsxRuntimeExports.jsx(InputBase, {
slots: {
root: RootSlot,
input: InputSlot
},
slotProps,
renderSuffix: (state) => jsxRuntimeExports.jsx(NotchedSlot, {
...notchedProps,
notched: typeof notched !== "undefined" ? notched : Boolean(state.startAdornment || state.filled || state.focused)
}),
fullWidth,
inputComponent,
multiline,
ref,
type,
...other,
classes: {
...classes,
notchedOutline: null
}
});
});
OutlinedInput.muiName = "Input";
getFormLabelUtilityClasses = function(slot) {
return generateUtilityClass("MuiFormLabel", slot);
};
formLabelClasses = generateUtilityClasses("MuiFormLabel", [
"root",
"colorSecondary",
"focused",
"disabled",
"error",
"filled",
"required",
"asterisk"
]);
const useUtilityClasses$l = (ownerState) => {
const { classes, color, focused, disabled, error, filled, required } = ownerState;
const slots = {
root: [
"root",
`color${capitalize(color)}`,
disabled && "disabled",
error && "error",
filled && "filled",
focused && "focused",
required && "required"
],
asterisk: [
"asterisk",
error && "error"
]
};
return composeClasses(slots, getFormLabelUtilityClasses, classes);
};
FormLabelRoot = styled("label", {
name: "MuiFormLabel",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.color === "secondary" && styles2.colorSecondary,
ownerState.filled && styles2.filled
];
}
})(memoTheme(({ theme }) => ({
color: (theme.vars || theme).palette.text.secondary,
...theme.typography.body1,
lineHeight: "1.4375em",
padding: 0,
position: "relative",
variants: [
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
[`&.${formLabelClasses.focused}`]: {
color: (theme.vars || theme).palette[color].main
}
}
})),
{
props: {},
style: {
[`&.${formLabelClasses.disabled}`]: {
color: (theme.vars || theme).palette.text.disabled
},
[`&.${formLabelClasses.error}`]: {
color: (theme.vars || theme).palette.error.main
}
}
}
]
})));
const AsteriskComponent = styled("span", {
name: "MuiFormLabel",
slot: "Asterisk",
overridesResolver: (props, styles2) => styles2.asterisk
})(memoTheme(({ theme }) => ({
[`&.${formLabelClasses.error}`]: {
color: (theme.vars || theme).palette.error.main
}
})));
FormLabel = __mf_14(function FormLabel2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiFormLabel"
});
const { children, className, color, component = "label", disabled, error, filled, focused, required, ...other } = props;
const muiFormControl = useFormControl();
const fcs = formControlState({
props,
muiFormControl,
states: [
"color",
"required",
"focused",
"disabled",
"error",
"filled"
]
});
const ownerState = {
...props,
color: fcs.color || "primary",
component,
disabled: fcs.disabled,
error: fcs.error,
filled: fcs.filled,
focused: fcs.focused,
required: fcs.required
};
const classes = useUtilityClasses$l(ownerState);
return jsxRuntimeExports.jsxs(FormLabelRoot, {
as: component,
ownerState,
className: clsx(classes.root, className),
ref,
...other,
children: [
children,
fcs.required && jsxRuntimeExports.jsxs(AsteriskComponent, {
ownerState,
"aria-hidden": true,
className: classes.asterisk,
children: [
"\u2009",
"*"
]
})
]
});
});
getInputLabelUtilityClasses = function(slot) {
return generateUtilityClass("MuiInputLabel", slot);
};
inputLabelClasses = generateUtilityClasses("MuiInputLabel", [
"root",
"focused",
"disabled",
"error",
"required",
"asterisk",
"formControl",
"sizeSmall",
"shrink",
"animated",
"standard",
"filled",
"outlined"
]);
const useUtilityClasses$k = (ownerState) => {
const { classes, formControl, size, shrink, disableAnimation, variant, required } = ownerState;
const slots = {
root: [
"root",
formControl && "formControl",
!disableAnimation && "animated",
shrink && "shrink",
size && size !== "normal" && `size${capitalize(size)}`,
variant
],
asterisk: [
required && "asterisk"
]
};
const composedClasses = composeClasses(slots, getInputLabelUtilityClasses, classes);
return {
...classes,
...composedClasses
};
};
const InputLabelRoot = styled(FormLabel, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiInputLabel",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
{
[`& .${formLabelClasses.asterisk}`]: styles2.asterisk
},
styles2.root,
ownerState.formControl && styles2.formControl,
ownerState.size === "small" && styles2.sizeSmall,
ownerState.shrink && styles2.shrink,
!ownerState.disableAnimation && styles2.animated,
ownerState.focused && styles2.focused,
styles2[ownerState.variant]
];
}
})(memoTheme(({ theme }) => ({
display: "block",
transformOrigin: "top left",
whiteSpace: "nowrap",
overflow: "hidden",
textOverflow: "ellipsis",
maxWidth: "100%",
variants: [
{
props: ({ ownerState }) => ownerState.formControl,
style: {
position: "absolute",
left: 0,
top: 0,
transform: "translate(0, 20px) scale(1)"
}
},
{
props: {
size: "small"
},
style: {
transform: "translate(0, 17px) scale(1)"
}
},
{
props: ({ ownerState }) => ownerState.shrink,
style: {
transform: "translate(0, -1.5px) scale(0.75)",
transformOrigin: "top left",
maxWidth: "133%"
}
},
{
props: ({ ownerState }) => !ownerState.disableAnimation,
style: {
transition: theme.transitions.create([
"color",
"transform",
"max-width"
], {
duration: theme.transitions.duration.shorter,
easing: theme.transitions.easing.easeOut
})
}
},
{
props: {
variant: "filled"
},
style: {
zIndex: 1,
pointerEvents: "none",
transform: "translate(12px, 16px) scale(1)",
maxWidth: "calc(100% - 24px)"
}
},
{
props: {
variant: "filled",
size: "small"
},
style: {
transform: "translate(12px, 13px) scale(1)"
}
},
{
props: ({ variant, ownerState }) => variant === "filled" && ownerState.shrink,
style: {
userSelect: "none",
pointerEvents: "auto",
transform: "translate(12px, 7px) scale(0.75)",
maxWidth: "calc(133% - 24px)"
}
},
{
props: ({ variant, ownerState, size }) => variant === "filled" && ownerState.shrink && size === "small",
style: {
transform: "translate(12px, 4px) scale(0.75)"
}
},
{
props: {
variant: "outlined"
},
style: {
zIndex: 1,
pointerEvents: "none",
transform: "translate(14px, 16px) scale(1)",
maxWidth: "calc(100% - 24px)"
}
},
{
props: {
variant: "outlined",
size: "small"
},
style: {
transform: "translate(14px, 9px) scale(1)"
}
},
{
props: ({ variant, ownerState }) => variant === "outlined" && ownerState.shrink,
style: {
userSelect: "none",
pointerEvents: "auto",
maxWidth: "calc(133% - 32px)",
transform: "translate(14px, -9px) scale(0.75)"
}
}
]
})));
InputLabel = __mf_14(function InputLabel2(inProps, ref) {
const props = useDefaultProps({
name: "MuiInputLabel",
props: inProps
});
const { disableAnimation = false, margin, shrink: shrinkProp, variant, className, ...other } = props;
const muiFormControl = useFormControl();
let shrink = shrinkProp;
if (typeof shrink === "undefined" && muiFormControl) {
shrink = muiFormControl.filled || muiFormControl.focused || muiFormControl.adornedStart;
}
const fcs = formControlState({
props,
muiFormControl,
states: [
"size",
"variant",
"required",
"focused"
]
});
const ownerState = {
...props,
disableAnimation,
formControl: muiFormControl,
shrink,
size: fcs.size,
variant: fcs.variant,
required: fcs.required,
focused: fcs.focused
};
const classes = useUtilityClasses$k(ownerState);
return jsxRuntimeExports.jsx(InputLabelRoot, {
"data-shrink": shrink,
ref,
className: clsx(classes.root, className),
...other,
ownerState,
classes
});
});
getFormControlUtilityClasses = function(slot) {
return generateUtilityClass("MuiFormControl", slot);
};
formControlClasses = generateUtilityClasses("MuiFormControl", [
"root",
"marginNone",
"marginNormal",
"marginDense",
"fullWidth",
"disabled"
]);
const useUtilityClasses$j = (ownerState) => {
const { classes, margin, fullWidth } = ownerState;
const slots = {
root: [
"root",
margin !== "none" && `margin${capitalize(margin)}`,
fullWidth && "fullWidth"
]
};
return composeClasses(slots, getFormControlUtilityClasses, classes);
};
const FormControlRoot = styled("div", {
name: "MuiFormControl",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
styles2[`margin${capitalize(ownerState.margin)}`],
ownerState.fullWidth && styles2.fullWidth
];
}
})({
display: "inline-flex",
flexDirection: "column",
position: "relative",
minWidth: 0,
padding: 0,
margin: 0,
border: 0,
verticalAlign: "top",
variants: [
{
props: {
margin: "normal"
},
style: {
marginTop: 16,
marginBottom: 8
}
},
{
props: {
margin: "dense"
},
style: {
marginTop: 8,
marginBottom: 4
}
},
{
props: {
fullWidth: true
},
style: {
width: "100%"
}
}
]
});
FormControl = __mf_14(function FormControl2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiFormControl"
});
const { children, className, color = "primary", component = "div", disabled = false, error = false, focused: visuallyFocused, fullWidth = false, hiddenLabel = false, margin = "none", required = false, size = "medium", variant = "outlined", ...other } = props;
const ownerState = {
...props,
color,
component,
disabled,
error,
fullWidth,
hiddenLabel,
margin,
required,
size,
variant
};
const classes = useUtilityClasses$j(ownerState);
const [adornedStart, setAdornedStart] = __mf_32(() => {
let initialAdornedStart = false;
if (children) {
__mf_0.forEach(children, (child) => {
if (!isMuiElement(child, [
"Input",
"Select"
])) {
return;
}
const input = isMuiElement(child, [
"Select"
]) ? child.props.input : child;
if (input && isAdornedStart(input.props)) {
initialAdornedStart = true;
}
});
}
return initialAdornedStart;
});
const [filled, setFilled] = __mf_32(() => {
let initialFilled = false;
if (children) {
__mf_0.forEach(children, (child) => {
if (!isMuiElement(child, [
"Input",
"Select"
])) {
return;
}
if (isFilled(child.props, true) || isFilled(child.props.inputProps, true)) {
initialFilled = true;
}
});
}
return initialFilled;
});
const [focusedState, setFocused] = __mf_32(false);
if (disabled && focusedState) {
setFocused(false);
}
const focused = visuallyFocused !== void 0 && !disabled ? visuallyFocused : focusedState;
let registerEffect;
__mf_31(false);
const onFilled = __mf_20(() => {
setFilled(true);
}, []);
const onEmpty = __mf_20(() => {
setFilled(false);
}, []);
const childContext = __mf_29(() => {
return {
adornedStart,
setAdornedStart,
color,
disabled,
error,
filled,
focused,
fullWidth,
hiddenLabel,
size,
onBlur: () => {
setFocused(false);
},
onFocus: () => {
setFocused(true);
},
onEmpty,
onFilled,
registerEffect,
required,
variant
};
}, [
adornedStart,
color,
disabled,
error,
filled,
focused,
fullWidth,
hiddenLabel,
registerEffect,
onEmpty,
onFilled,
required,
size,
variant
]);
return jsxRuntimeExports.jsx(FormControlContext.Provider, {
value: childContext,
children: jsxRuntimeExports.jsx(FormControlRoot, {
as: component,
ownerState,
className: clsx(classes.root, className),
ref,
...other,
children
})
});
});
getFormHelperTextUtilityClasses = function(slot) {
return generateUtilityClass("MuiFormHelperText", slot);
};
formHelperTextClasses = generateUtilityClasses("MuiFormHelperText", [
"root",
"error",
"disabled",
"sizeSmall",
"sizeMedium",
"contained",
"focused",
"filled",
"required"
]);
var _span$2;
const useUtilityClasses$i = (ownerState) => {
const { classes, contained, size, disabled, error, filled, focused, required } = ownerState;
const slots = {
root: [
"root",
disabled && "disabled",
error && "error",
size && `size${capitalize(size)}`,
contained && "contained",
focused && "focused",
filled && "filled",
required && "required"
]
};
return composeClasses(slots, getFormHelperTextUtilityClasses, classes);
};
const FormHelperTextRoot = styled("p", {
name: "MuiFormHelperText",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.size && styles2[`size${capitalize(ownerState.size)}`],
ownerState.contained && styles2.contained,
ownerState.filled && styles2.filled
];
}
})(memoTheme(({ theme }) => ({
color: (theme.vars || theme).palette.text.secondary,
...theme.typography.caption,
textAlign: "left",
marginTop: 3,
marginRight: 0,
marginBottom: 0,
marginLeft: 0,
[`&.${formHelperTextClasses.disabled}`]: {
color: (theme.vars || theme).palette.text.disabled
},
[`&.${formHelperTextClasses.error}`]: {
color: (theme.vars || theme).palette.error.main
},
variants: [
{
props: {
size: "small"
},
style: {
marginTop: 4
}
},
{
props: ({ ownerState }) => ownerState.contained,
style: {
marginLeft: 14,
marginRight: 14
}
}
]
})));
FormHelperText = __mf_14(function FormHelperText2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiFormHelperText"
});
const { children, className, component = "p", disabled, error, filled, focused, margin, required, variant, ...other } = props;
const muiFormControl = useFormControl();
const fcs = formControlState({
props,
muiFormControl,
states: [
"variant",
"size",
"disabled",
"error",
"filled",
"focused",
"required"
]
});
const ownerState = {
...props,
component,
contained: fcs.variant === "filled" || fcs.variant === "outlined",
variant: fcs.variant,
size: fcs.size,
disabled: fcs.disabled,
error: fcs.error,
filled: fcs.filled,
focused: fcs.focused,
required: fcs.required
};
delete ownerState.ownerState;
const classes = useUtilityClasses$i(ownerState);
return jsxRuntimeExports.jsx(FormHelperTextRoot, {
as: component,
className: clsx(classes.root, className),
ref,
...other,
ownerState,
children: children === " " ? _span$2 || (_span$2 = jsxRuntimeExports.jsx("span", {
className: "notranslate",
"aria-hidden": true,
children: "\u200B"
})) : children
});
});
reflow = (node) => node.scrollTop;
getTransitionProps = function(props, options) {
const { timeout, easing, style = {} } = props;
return {
duration: style.transitionDuration ?? (typeof timeout === "number" ? timeout : timeout[options.mode] || 0),
easing: style.transitionTimingFunction ?? (typeof easing === "object" ? easing[options.mode] : easing),
delay: style.transitionDelay
};
};
function getScale(value) {
return `scale(${value}, ${value ** 2})`;
}
const styles$1 = {
entering: {
opacity: 1,
transform: getScale(1)
},
entered: {
opacity: 1,
transform: "none"
}
};
const isWebKit154 = typeof navigator !== "undefined" && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\/)15(.|_)4/i.test(navigator.userAgent);
Grow = __mf_14(function Grow2(props, ref) {
const { addEndListener, appear = true, children, easing, in: inProp, onEnter, onEntered, onEntering, onExit, onExited, onExiting, style, timeout = "auto", TransitionComponent = Transition, ...other } = props;
const timer = useTimeout();
const autoTimeout = __mf_31();
const theme = useTheme();
const nodeRef = __mf_31(null);
const handleRef = useForkRef(nodeRef, getReactElementRef(children), ref);
const normalizedTransitionCallback = (callback) => (maybeIsAppearing) => {
if (callback) {
const node = nodeRef.current;
if (maybeIsAppearing === void 0) {
callback(node);
} else {
callback(node, maybeIsAppearing);
}
}
};
const handleEntering = normalizedTransitionCallback(onEntering);
const handleEnter = normalizedTransitionCallback((node, isAppearing) => {
reflow(node);
const { duration: transitionDuration, delay, easing: transitionTimingFunction } = getTransitionProps({
style,
timeout,
easing
}, {
mode: "enter"
});
let duration;
if (timeout === "auto") {
duration = theme.transitions.getAutoHeightDuration(node.clientHeight);
autoTimeout.current = duration;
} else {
duration = transitionDuration;
}
node.style.transition = [
theme.transitions.create("opacity", {
duration,
delay
}),
theme.transitions.create("transform", {
duration: isWebKit154 ? duration : duration * 0.666,
delay,
easing: transitionTimingFunction
})
].join(",");
if (onEnter) {
onEnter(node, isAppearing);
}
});
const handleEntered = normalizedTransitionCallback(onEntered);
const handleExiting = normalizedTransitionCallback(onExiting);
const handleExit = normalizedTransitionCallback((node) => {
const { duration: transitionDuration, delay, easing: transitionTimingFunction } = getTransitionProps({
style,
timeout,
easing
}, {
mode: "exit"
});
let duration;
if (timeout === "auto") {
duration = theme.transitions.getAutoHeightDuration(node.clientHeight);
autoTimeout.current = duration;
} else {
duration = transitionDuration;
}
node.style.transition = [
theme.transitions.create("opacity", {
duration,
delay
}),
theme.transitions.create("transform", {
duration: isWebKit154 ? duration : duration * 0.666,
delay: isWebKit154 ? delay : delay || duration * 0.333,
easing: transitionTimingFunction
})
].join(",");
node.style.opacity = 0;
node.style.transform = getScale(0.75);
if (onExit) {
onExit(node);
}
});
const handleExited = normalizedTransitionCallback(onExited);
const handleAddEndListener = (next) => {
if (timeout === "auto") {
timer.start(autoTimeout.current || 0, next);
}
if (addEndListener) {
addEndListener(nodeRef.current, next);
}
};
return jsxRuntimeExports.jsx(TransitionComponent, {
appear,
in: inProp,
nodeRef,
onEnter: handleEnter,
onEntered: handleEntered,
onEntering: handleEntering,
onExit: handleExit,
onExited: handleExited,
onExiting: handleExiting,
addEndListener: handleAddEndListener,
timeout: timeout === "auto" ? null : timeout,
...other,
children: (state, { ownerState, ...restChildProps }) => {
return __mf_9(children, {
style: {
opacity: 0,
transform: getScale(0.75),
visibility: state === "exited" && !inProp ? "hidden" : void 0,
...styles$1[state],
...style,
...children.props.style
},
ref: handleRef,
...restChildProps
});
}
});
});
if (Grow) {
Grow.muiSupportAuto = true;
}
function isOverflowing(container) {
const doc = ownerDocument(container);
if (doc.body === container) {
return ownerWindow(container).innerWidth > doc.documentElement.clientWidth;
}
return container.scrollHeight > container.clientHeight;
}
function ariaHidden(element, hide2) {
if (hide2) {
element.setAttribute("aria-hidden", "true");
} else {
element.removeAttribute("aria-hidden");
}
}
function getPaddingRight(element) {
return parseInt(ownerWindow(element).getComputedStyle(element).paddingRight, 10) || 0;
}
function isAriaHiddenForbiddenOnElement(element) {
const forbiddenTagNames = [
"TEMPLATE",
"SCRIPT",
"STYLE",
"LINK",
"MAP",
"META",
"NOSCRIPT",
"PICTURE",
"COL",
"COLGROUP",
"PARAM",
"SLOT",
"SOURCE",
"TRACK"
];
const isForbiddenTagName = forbiddenTagNames.includes(element.tagName);
const isInputHidden = element.tagName === "INPUT" && element.getAttribute("type") === "hidden";
return isForbiddenTagName || isInputHidden;
}
function ariaHiddenSiblings(container, mountElement, currentElement, elementsToExclude, hide2) {
const blacklist = [
mountElement,
currentElement,
...elementsToExclude
];
[].forEach.call(container.children, (element) => {
const isNotExcludedElement = !blacklist.includes(element);
const isNotForbiddenElement = !isAriaHiddenForbiddenOnElement(element);
if (isNotExcludedElement && isNotForbiddenElement) {
ariaHidden(element, hide2);
}
});
}
function findIndexOf(items, callback) {
let idx = -1;
items.some((item, index) => {
if (callback(item)) {
idx = index;
return true;
}
return false;
});
return idx;
}
function handleContainer(containerInfo, props) {
const restoreStyle = [];
const container = containerInfo.container;
if (!props.disableScrollLock) {
if (isOverflowing(container)) {
const scrollbarSize = getScrollbarSize(ownerWindow(container));
restoreStyle.push({
value: container.style.paddingRight,
property: "padding-right",
el: container
});
container.style.paddingRight = `${getPaddingRight(container) + scrollbarSize}px`;
const fixedElements = ownerDocument(container).querySelectorAll(".mui-fixed");
[].forEach.call(fixedElements, (element) => {
restoreStyle.push({
value: element.style.paddingRight,
property: "padding-right",
el: element
});
element.style.paddingRight = `${getPaddingRight(element) + scrollbarSize}px`;
});
}
let scrollContainer;
if (container.parentNode instanceof DocumentFragment) {
scrollContainer = ownerDocument(container).body;
} else {
const parent = container.parentElement;
const containerWindow = ownerWindow(container);
scrollContainer = (parent == null ? void 0 : parent.nodeName) === "HTML" && containerWindow.getComputedStyle(parent).overflowY === "scroll" ? parent : container;
}
restoreStyle.push({
value: scrollContainer.style.overflow,
property: "overflow",
el: scrollContainer
}, {
value: scrollContainer.style.overflowX,
property: "overflow-x",
el: scrollContainer
}, {
value: scrollContainer.style.overflowY,
property: "overflow-y",
el: scrollContainer
});
scrollContainer.style.overflow = "hidden";
}
const restore = () => {
restoreStyle.forEach(({ value, el, property }) => {
if (value) {
el.style.setProperty(property, value);
} else {
el.style.removeProperty(property);
}
});
};
return restore;
}
function getHiddenSiblings(container) {
const hiddenSiblings = [];
[].forEach.call(container.children, (element) => {
if (element.getAttribute("aria-hidden") === "true") {
hiddenSiblings.push(element);
}
});
return hiddenSiblings;
}
ModalManager = class {
constructor() {
this.modals = [];
this.containers = [];
}
add(modal, container) {
let modalIndex = this.modals.indexOf(modal);
if (modalIndex !== -1) {
return modalIndex;
}
modalIndex = this.modals.length;
this.modals.push(modal);
if (modal.modalRef) {
ariaHidden(modal.modalRef, false);
}
const hiddenSiblings = getHiddenSiblings(container);
ariaHiddenSiblings(container, modal.mount, modal.modalRef, hiddenSiblings, true);
const containerIndex = findIndexOf(this.containers, (item) => item.container === container);
if (containerIndex !== -1) {
this.containers[containerIndex].modals.push(modal);
return modalIndex;
}
this.containers.push({
modals: [
modal
],
container,
restore: null,
hiddenSiblings
});
return modalIndex;
}
mount(modal, props) {
const containerIndex = findIndexOf(this.containers, (item) => item.modals.includes(modal));
const containerInfo = this.containers[containerIndex];
if (!containerInfo.restore) {
containerInfo.restore = handleContainer(containerInfo, props);
}
}
remove(modal, ariaHiddenState = true) {
const modalIndex = this.modals.indexOf(modal);
if (modalIndex === -1) {
return modalIndex;
}
const containerIndex = findIndexOf(this.containers, (item) => item.modals.includes(modal));
const containerInfo = this.containers[containerIndex];
containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);
this.modals.splice(modalIndex, 1);
if (containerInfo.modals.length === 0) {
if (containerInfo.restore) {
containerInfo.restore();
}
if (modal.modalRef) {
ariaHidden(modal.modalRef, ariaHiddenState);
}
ariaHiddenSiblings(containerInfo.container, modal.mount, modal.modalRef, containerInfo.hiddenSiblings, false);
this.containers.splice(containerIndex, 1);
} else {
const nextTop = containerInfo.modals[containerInfo.modals.length - 1];
if (nextTop.modalRef) {
ariaHidden(nextTop.modalRef, false);
}
}
return modalIndex;
}
isTopModal(modal) {
return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;
}
};
const candidatesSelector = [
"input",
"select",
"textarea",
"a[href]",
"button",
"[tabindex]",
"audio[controls]",
"video[controls]",
'[contenteditable]:not([contenteditable="false"])'
].join(",");
function getTabIndex(node) {
const tabindexAttr = parseInt(node.getAttribute("tabindex") || "", 10);
if (!Number.isNaN(tabindexAttr)) {
return tabindexAttr;
}
if (node.contentEditable === "true" || (node.nodeName === "AUDIO" || node.nodeName === "VIDEO" || node.nodeName === "DETAILS") && node.getAttribute("tabindex") === null) {
return 0;
}
return node.tabIndex;
}
function isNonTabbableRadio(node) {
if (node.tagName !== "INPUT" || node.type !== "radio") {
return false;
}
if (!node.name) {
return false;
}
const getRadio = (selector) => node.ownerDocument.querySelector(`input[type="radio"]${selector}`);
let roving = getRadio(`[name="${node.name}"]:checked`);
if (!roving) {
roving = getRadio(`[name="${node.name}"]`);
}
return roving !== node;
}
function isNodeMatchingSelectorFocusable(node) {
if (node.disabled || node.tagName === "INPUT" && node.type === "hidden" || isNonTabbableRadio(node)) {
return false;
}
return true;
}
function defaultGetTabbable(root) {
const regularTabNodes = [];
const orderedTabNodes = [];
Array.from(root.querySelectorAll(candidatesSelector)).forEach((node, i) => {
const nodeTabIndex = getTabIndex(node);
if (nodeTabIndex === -1 || !isNodeMatchingSelectorFocusable(node)) {
return;
}
if (nodeTabIndex === 0) {
regularTabNodes.push(node);
} else {
orderedTabNodes.push({
documentOrder: i,
tabIndex: nodeTabIndex,
node
});
}
});
return orderedTabNodes.sort((a, b) => a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex).map((a) => a.node).concat(regularTabNodes);
}
function defaultIsEnabled() {
return true;
}
FocusTrap = function(props) {
const { children, disableAutoFocus = false, disableEnforceFocus = false, disableRestoreFocus = false, getTabbable = defaultGetTabbable, isEnabled = defaultIsEnabled, open } = props;
const ignoreNextEnforceFocus = __mf_31(false);
const sentinelStart = __mf_31(null);
const sentinelEnd = __mf_31(null);
const nodeToRestore = __mf_31(null);
const reactFocusEventTarget = __mf_31(null);
const activated = __mf_31(false);
const rootRef = __mf_31(null);
const handleRef = useForkRef(getReactElementRef(children), rootRef);
const lastKeydown = __mf_31(null);
__mf_24(() => {
if (!open || !rootRef.current) {
return;
}
activated.current = !disableAutoFocus;
}, [
disableAutoFocus,
open
]);
__mf_24(() => {
if (!open || !rootRef.current) {
return;
}
const doc = ownerDocument(rootRef.current);
if (!rootRef.current.contains(doc.activeElement)) {
if (!rootRef.current.hasAttribute("tabIndex")) {
rootRef.current.setAttribute("tabIndex", "-1");
}
if (activated.current) {
rootRef.current.focus();
}
}
return () => {
if (!disableRestoreFocus) {
if (nodeToRestore.current && nodeToRestore.current.focus) {
ignoreNextEnforceFocus.current = true;
nodeToRestore.current.focus();
}
nodeToRestore.current = null;
}
};
}, [
open
]);
__mf_24(() => {
if (!open || !rootRef.current) {
return;
}
const doc = ownerDocument(rootRef.current);
const loopFocus = (nativeEvent) => {
lastKeydown.current = nativeEvent;
if (disableEnforceFocus || !isEnabled() || nativeEvent.key !== "Tab") {
return;
}
if (doc.activeElement === rootRef.current && nativeEvent.shiftKey) {
ignoreNextEnforceFocus.current = true;
if (sentinelEnd.current) {
sentinelEnd.current.focus();
}
}
};
const contain = () => {
var _a, _b;
const rootElement = rootRef.current;
if (rootElement === null) {
return;
}
if (!doc.hasFocus() || !isEnabled() || ignoreNextEnforceFocus.current) {
ignoreNextEnforceFocus.current = false;
return;
}
if (rootElement.contains(doc.activeElement)) {
return;
}
if (disableEnforceFocus && doc.activeElement !== sentinelStart.current && doc.activeElement !== sentinelEnd.current) {
return;
}
if (doc.activeElement !== reactFocusEventTarget.current) {
reactFocusEventTarget.current = null;
} else if (reactFocusEventTarget.current !== null) {
return;
}
if (!activated.current) {
return;
}
let tabbable = [];
if (doc.activeElement === sentinelStart.current || doc.activeElement === sentinelEnd.current) {
tabbable = getTabbable(rootRef.current);
}
if (tabbable.length > 0) {
const isShiftTab = Boolean(((_a = lastKeydown.current) == null ? void 0 : _a.shiftKey) && ((_b = lastKeydown.current) == null ? void 0 : _b.key) === "Tab");
const focusNext = tabbable[0];
const focusPrevious = tabbable[tabbable.length - 1];
if (typeof focusNext !== "string" && typeof focusPrevious !== "string") {
if (isShiftTab) {
focusPrevious.focus();
} else {
focusNext.focus();
}
}
} else {
rootElement.focus();
}
};
doc.addEventListener("focusin", contain);
doc.addEventListener("keydown", loopFocus, true);
const interval = setInterval(() => {
if (doc.activeElement && doc.activeElement.tagName === "BODY") {
contain();
}
}, 50);
return () => {
clearInterval(interval);
doc.removeEventListener("focusin", contain);
doc.removeEventListener("keydown", loopFocus, true);
};
}, [
disableAutoFocus,
disableEnforceFocus,
disableRestoreFocus,
isEnabled,
open,
getTabbable
]);
const onFocus = (event) => {
if (nodeToRestore.current === null) {
nodeToRestore.current = event.relatedTarget;
}
activated.current = true;
reactFocusEventTarget.current = event.target;
const childrenPropsHandler = children.props.onFocus;
if (childrenPropsHandler) {
childrenPropsHandler(event);
}
};
const handleFocusSentinel = (event) => {
if (nodeToRestore.current === null) {
nodeToRestore.current = event.relatedTarget;
}
activated.current = true;
};
return jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
jsxRuntimeExports.jsx("div", {
tabIndex: open ? 0 : -1,
onFocus: handleFocusSentinel,
ref: sentinelStart,
"data-testid": "sentinelStart"
}),
__mf_9(children, {
ref: handleRef,
onFocus
}),
jsxRuntimeExports.jsx("div", {
tabIndex: open ? 0 : -1,
onFocus: handleFocusSentinel,
ref: sentinelEnd,
"data-testid": "sentinelEnd"
})
]
});
};
function getContainer$1(container) {
return typeof container === "function" ? container() : container;
}
Portal = __mf_14(function Portal2(props, forwardedRef) {
const { children, container, disablePortal = false } = props;
const [mountNode, setMountNode] = __mf_32(null);
const handleRef = useForkRef(__mf_15(children) ? getReactElementRef(children) : null, forwardedRef);
useEnhancedEffect(() => {
if (!disablePortal) {
setMountNode(getContainer$1(container) || document.body);
}
}, [
container,
disablePortal
]);
useEnhancedEffect(() => {
if (mountNode && !disablePortal) {
setRef(forwardedRef, mountNode);
return () => {
setRef(forwardedRef, null);
};
}
return void 0;
}, [
forwardedRef,
mountNode,
disablePortal
]);
if (disablePortal) {
if (__mf_15(children)) {
const newProps = {
ref: handleRef
};
return __mf_9(children, newProps);
}
return children;
}
return mountNode ? __mf_1(children, mountNode) : mountNode;
});
const styles = {
entering: {
opacity: 1
},
entered: {
opacity: 1
}
};
Fade = __mf_14(function Fade2(props, ref) {
const theme = useTheme();
const defaultTimeout = {
enter: theme.transitions.duration.enteringScreen,
exit: theme.transitions.duration.leavingScreen
};
const { addEndListener, appear = true, children, easing, in: inProp, onEnter, onEntered, onEntering, onExit, onExited, onExiting, style, timeout = defaultTimeout, TransitionComponent = Transition, ...other } = props;
const nodeRef = __mf_31(null);
const handleRef = useForkRef(nodeRef, getReactElementRef(children), ref);
const normalizedTransitionCallback = (callback) => (maybeIsAppearing) => {
if (callback) {
const node = nodeRef.current;
if (maybeIsAppearing === void 0) {
callback(node);
} else {
callback(node, maybeIsAppearing);
}
}
};
const handleEntering = normalizedTransitionCallback(onEntering);
const handleEnter = normalizedTransitionCallback((node, isAppearing) => {
reflow(node);
const transitionProps = getTransitionProps({
style,
timeout,
easing
}, {
mode: "enter"
});
node.style.webkitTransition = theme.transitions.create("opacity", transitionProps);
node.style.transition = theme.transitions.create("opacity", transitionProps);
if (onEnter) {
onEnter(node, isAppearing);
}
});
const handleEntered = normalizedTransitionCallback(onEntered);
const handleExiting = normalizedTransitionCallback(onExiting);
const handleExit = normalizedTransitionCallback((node) => {
const transitionProps = getTransitionProps({
style,
timeout,
easing
}, {
mode: "exit"
});
node.style.webkitTransition = theme.transitions.create("opacity", transitionProps);
node.style.transition = theme.transitions.create("opacity", transitionProps);
if (onExit) {
onExit(node);
}
});
const handleExited = normalizedTransitionCallback(onExited);
const handleAddEndListener = (next) => {
if (addEndListener) {
addEndListener(nodeRef.current, next);
}
};
return jsxRuntimeExports.jsx(TransitionComponent, {
appear,
in: inProp,
nodeRef,
onEnter: handleEnter,
onEntered: handleEntered,
onEntering: handleEntering,
onExit: handleExit,
onExited: handleExited,
onExiting: handleExiting,
addEndListener: handleAddEndListener,
timeout,
...other,
children: (state, { ownerState, ...restChildProps }) => {
return __mf_9(children, {
style: {
opacity: 0,
visibility: state === "exited" && !inProp ? "hidden" : void 0,
...styles[state],
...style,
...children.props.style
},
ref: handleRef,
...restChildProps
});
}
});
});
getBackdropUtilityClass = function(slot) {
return generateUtilityClass("MuiBackdrop", slot);
};
backdropClasses = generateUtilityClasses("MuiBackdrop", [
"root",
"invisible"
]);
const useUtilityClasses$h = (ownerState) => {
const { classes, invisible } = ownerState;
const slots = {
root: [
"root",
invisible && "invisible"
]
};
return composeClasses(slots, getBackdropUtilityClass, classes);
};
const BackdropRoot = styled("div", {
name: "MuiBackdrop",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.invisible && styles2.invisible
];
}
})({
position: "fixed",
display: "flex",
alignItems: "center",
justifyContent: "center",
right: 0,
bottom: 0,
top: 0,
left: 0,
backgroundColor: "rgba(0, 0, 0, 0.5)",
WebkitTapHighlightColor: "transparent",
variants: [
{
props: {
invisible: true
},
style: {
backgroundColor: "transparent"
}
}
]
});
Backdrop = __mf_14(function Backdrop2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiBackdrop"
});
const { children, className, component = "div", invisible = false, open, components = {}, componentsProps = {}, slotProps = {}, slots = {}, TransitionComponent: TransitionComponentProp, transitionDuration, ...other } = props;
const ownerState = {
...props,
component,
invisible
};
const classes = useUtilityClasses$h(ownerState);
const backwardCompatibleSlots = {
transition: TransitionComponentProp,
root: components.Root,
...slots
};
const backwardCompatibleSlotProps = {
...componentsProps,
...slotProps
};
const externalForwardedProps = {
slots: backwardCompatibleSlots,
slotProps: backwardCompatibleSlotProps
};
const [RootSlot, rootProps] = useSlot("root", {
elementType: BackdropRoot,
externalForwardedProps,
className: clsx(classes.root, className),
ownerState
});
const [TransitionSlot, transitionProps] = useSlot("transition", {
elementType: Fade,
externalForwardedProps,
ownerState
});
return jsxRuntimeExports.jsx(TransitionSlot, {
in: open,
timeout: transitionDuration,
...other,
...transitionProps,
children: jsxRuntimeExports.jsx(RootSlot, {
"aria-hidden": true,
...rootProps,
classes,
ref,
children
})
});
});
function getContainer(container) {
return typeof container === "function" ? container() : container;
}
function getHasTransition(children) {
return children ? children.props.hasOwnProperty("in") : false;
}
const noop = () => {
};
const manager = new ModalManager();
function useModal(parameters) {
const { container, disableEscapeKeyDown = false, disableScrollLock = false, closeAfterTransition = false, onTransitionEnter, onTransitionExited, children, onClose, open, rootRef } = parameters;
const modal = __mf_31({});
const mountNodeRef = __mf_31(null);
const modalRef = __mf_31(null);
const handleRef = useForkRef(modalRef, rootRef);
const [exited, setExited] = __mf_32(!open);
const hasTransition = getHasTransition(children);
let ariaHiddenProp = true;
if (parameters["aria-hidden"] === "false" || parameters["aria-hidden"] === false) {
ariaHiddenProp = false;
}
const getDoc = () => ownerDocument(mountNodeRef.current);
const getModal = () => {
modal.current.modalRef = modalRef.current;
modal.current.mount = mountNodeRef.current;
return modal.current;
};
const handleMounted = () => {
manager.mount(getModal(), {
disableScrollLock
});
if (modalRef.current) {
modalRef.current.scrollTop = 0;
}
};
const handleOpen = useEventCallback(() => {
const resolvedContainer = getContainer(container) || getDoc().body;
manager.add(getModal(), resolvedContainer);
if (modalRef.current) {
handleMounted();
}
});
const isTopModal = () => manager.isTopModal(getModal());
const handlePortalRef = useEventCallback((node) => {
mountNodeRef.current = node;
if (!node) {
return;
}
if (open && isTopModal()) {
handleMounted();
} else if (modalRef.current) {
ariaHidden(modalRef.current, ariaHiddenProp);
}
});
const handleClose = __mf_20(() => {
manager.remove(getModal(), ariaHiddenProp);
}, [
ariaHiddenProp
]);
__mf_24(() => {
return () => {
handleClose();
};
}, [
handleClose
]);
__mf_24(() => {
if (open) {
handleOpen();
} else if (!hasTransition || !closeAfterTransition) {
handleClose();
}
}, [
open,
handleClose,
hasTransition,
closeAfterTransition,
handleOpen
]);
const createHandleKeyDown = (otherHandlers) => (event) => {
var _a;
(_a = otherHandlers.onKeyDown) == null ? void 0 : _a.call(otherHandlers, event);
if (event.key !== "Escape" || event.which === 229 || !isTopModal()) {
return;
}
if (!disableEscapeKeyDown) {
event.stopPropagation();
if (onClose) {
onClose(event, "escapeKeyDown");
}
}
};
const createHandleBackdropClick = (otherHandlers) => (event) => {
var _a;
(_a = otherHandlers.onClick) == null ? void 0 : _a.call(otherHandlers, event);
if (event.target !== event.currentTarget) {
return;
}
if (onClose) {
onClose(event, "backdropClick");
}
};
const getRootProps = (otherHandlers = {}) => {
const propsEventHandlers = extractEventHandlers(parameters);
delete propsEventHandlers.onTransitionEnter;
delete propsEventHandlers.onTransitionExited;
const externalEventHandlers = {
...propsEventHandlers,
...otherHandlers
};
return {
role: "presentation",
...externalEventHandlers,
onKeyDown: createHandleKeyDown(externalEventHandlers),
ref: handleRef
};
};
const getBackdropProps = (otherHandlers = {}) => {
const externalEventHandlers = otherHandlers;
return {
"aria-hidden": true,
...externalEventHandlers,
onClick: createHandleBackdropClick(externalEventHandlers),
open
};
};
const getTransitionProps2 = () => {
const handleEnter = () => {
setExited(false);
if (onTransitionEnter) {
onTransitionEnter();
}
};
const handleExited = () => {
setExited(true);
if (onTransitionExited) {
onTransitionExited();
}
if (closeAfterTransition) {
handleClose();
}
};
return {
onEnter: createChainedFunction(handleEnter, (children == null ? void 0 : children.props.onEnter) ?? noop),
onExited: createChainedFunction(handleExited, (children == null ? void 0 : children.props.onExited) ?? noop)
};
};
return {
getRootProps,
getBackdropProps,
getTransitionProps: getTransitionProps2,
rootRef: handleRef,
portalRef: handlePortalRef,
isTopModal,
exited,
hasTransition
};
}
getModalUtilityClass = function(slot) {
return generateUtilityClass("MuiModal", slot);
};
modalClasses = generateUtilityClasses("MuiModal", [
"root",
"hidden",
"backdrop"
]);
const useUtilityClasses$g = (ownerState) => {
const { open, exited, classes } = ownerState;
const slots = {
root: [
"root",
!open && exited && "hidden"
],
backdrop: [
"backdrop"
]
};
return composeClasses(slots, getModalUtilityClass, classes);
};
const ModalRoot = styled("div", {
name: "MuiModal",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
!ownerState.open && ownerState.exited && styles2.hidden
];
}
})(memoTheme(({ theme }) => ({
position: "fixed",
zIndex: (theme.vars || theme).zIndex.modal,
right: 0,
bottom: 0,
top: 0,
left: 0,
variants: [
{
props: ({ ownerState }) => !ownerState.open && ownerState.exited,
style: {
visibility: "hidden"
}
}
]
})));
const ModalBackdrop = styled(Backdrop, {
name: "MuiModal",
slot: "Backdrop",
overridesResolver: (props, styles2) => {
return styles2.backdrop;
}
})({
zIndex: -1
});
Modal = __mf_14(function Modal2(inProps, ref) {
const props = useDefaultProps({
name: "MuiModal",
props: inProps
});
const { BackdropComponent = ModalBackdrop, BackdropProps, classes: classesProp, className, closeAfterTransition = false, children, container, component, components = {}, componentsProps = {}, disableAutoFocus = false, disableEnforceFocus = false, disableEscapeKeyDown = false, disablePortal = false, disableRestoreFocus = false, disableScrollLock = false, hideBackdrop = false, keepMounted = false, onBackdropClick, onClose, onTransitionEnter, onTransitionExited, open, slotProps = {}, slots = {}, theme, ...other } = props;
const propsWithDefaults = {
...props,
closeAfterTransition,
disableAutoFocus,
disableEnforceFocus,
disableEscapeKeyDown,
disablePortal,
disableRestoreFocus,
disableScrollLock,
hideBackdrop,
keepMounted
};
const { getRootProps, getBackdropProps, getTransitionProps: getTransitionProps2, portalRef, isTopModal, exited, hasTransition } = useModal({
...propsWithDefaults,
rootRef: ref
});
const ownerState = {
...propsWithDefaults,
exited
};
const classes = useUtilityClasses$g(ownerState);
const childProps = {};
if (children.props.tabIndex === void 0) {
childProps.tabIndex = "-1";
}
if (hasTransition) {
const { onEnter, onExited } = getTransitionProps2();
childProps.onEnter = onEnter;
childProps.onExited = onExited;
}
const externalForwardedProps = {
slots: {
root: components.Root,
backdrop: components.Backdrop,
...slots
},
slotProps: {
...componentsProps,
...slotProps
}
};
const [RootSlot, rootProps] = useSlot("root", {
ref,
elementType: ModalRoot,
externalForwardedProps: {
...externalForwardedProps,
...other,
component
},
getSlotProps: getRootProps,
ownerState,
className: clsx(className, classes == null ? void 0 : classes.root, !ownerState.open && ownerState.exited && (classes == null ? void 0 : classes.hidden))
});
const [BackdropSlot, backdropProps] = useSlot("backdrop", {
ref: BackdropProps == null ? void 0 : BackdropProps.ref,
elementType: BackdropComponent,
externalForwardedProps,
shouldForwardComponentProp: true,
additionalProps: BackdropProps,
getSlotProps: (otherHandlers) => {
return getBackdropProps({
...otherHandlers,
onClick: (event) => {
if (onBackdropClick) {
onBackdropClick(event);
}
if (otherHandlers == null ? void 0 : otherHandlers.onClick) {
otherHandlers.onClick(event);
}
}
});
},
className: clsx(BackdropProps == null ? void 0 : BackdropProps.className, classes == null ? void 0 : classes.backdrop),
ownerState
});
if (!keepMounted && !open && (!hasTransition || exited)) {
return null;
}
return jsxRuntimeExports.jsx(Portal, {
ref: portalRef,
container,
disablePortal,
children: jsxRuntimeExports.jsxs(RootSlot, {
...rootProps,
children: [
!hideBackdrop && BackdropComponent ? jsxRuntimeExports.jsx(BackdropSlot, {
...backdropProps
}) : null,
jsxRuntimeExports.jsx(FocusTrap, {
disableEnforceFocus,
disableAutoFocus,
disableRestoreFocus,
isEnabled: isTopModal,
open,
children: __mf_9(children, childProps)
})
]
})
});
});
getPaperUtilityClass = function(slot) {
return generateUtilityClass("MuiPaper", slot);
};
paperClasses = generateUtilityClasses("MuiPaper", [
"root",
"rounded",
"outlined",
"elevation",
"elevation0",
"elevation1",
"elevation2",
"elevation3",
"elevation4",
"elevation5",
"elevation6",
"elevation7",
"elevation8",
"elevation9",
"elevation10",
"elevation11",
"elevation12",
"elevation13",
"elevation14",
"elevation15",
"elevation16",
"elevation17",
"elevation18",
"elevation19",
"elevation20",
"elevation21",
"elevation22",
"elevation23",
"elevation24"
]);
const useUtilityClasses$f = (ownerState) => {
const { square, elevation, variant, classes } = ownerState;
const slots = {
root: [
"root",
variant,
!square && "rounded",
variant === "elevation" && `elevation${elevation}`
]
};
return composeClasses(slots, getPaperUtilityClass, classes);
};
const PaperRoot = styled("div", {
name: "MuiPaper",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
styles2[ownerState.variant],
!ownerState.square && styles2.rounded,
ownerState.variant === "elevation" && styles2[`elevation${ownerState.elevation}`]
];
}
})(memoTheme(({ theme }) => ({
backgroundColor: (theme.vars || theme).palette.background.paper,
color: (theme.vars || theme).palette.text.primary,
transition: theme.transitions.create("box-shadow"),
variants: [
{
props: ({ ownerState }) => !ownerState.square,
style: {
borderRadius: theme.shape.borderRadius
}
},
{
props: {
variant: "outlined"
},
style: {
border: `1px solid ${(theme.vars || theme).palette.divider}`
}
},
{
props: {
variant: "elevation"
},
style: {
boxShadow: "var(--Paper-shadow)",
backgroundImage: "var(--Paper-overlay)"
}
}
]
})));
Paper = __mf_14(function Paper2(inProps, ref) {
var _a;
const props = useDefaultProps({
props: inProps,
name: "MuiPaper"
});
const theme = useTheme();
const { className, component = "div", elevation = 1, square = false, variant = "elevation", ...other } = props;
const ownerState = {
...props,
component,
elevation,
square,
variant
};
const classes = useUtilityClasses$f(ownerState);
return jsxRuntimeExports.jsx(PaperRoot, {
as: component,
ownerState,
className: clsx(classes.root, className),
ref,
...other,
style: {
...variant === "elevation" && {
"--Paper-shadow": (theme.vars || theme).shadows[elevation],
...theme.vars && {
"--Paper-overlay": (_a = theme.vars.overlays) == null ? void 0 : _a[elevation]
},
...!theme.vars && theme.palette.mode === "dark" && {
"--Paper-overlay": `linear-gradient(${alpha("#fff", getOverlayAlpha(elevation))}, ${alpha("#fff", getOverlayAlpha(elevation))})`
}
},
...other.style
}
});
});
getPopoverUtilityClass = function(slot) {
return generateUtilityClass("MuiPopover", slot);
};
popoverClasses = generateUtilityClasses("MuiPopover", [
"root",
"paper"
]);
getOffsetTop = function(rect, vertical) {
let offset2 = 0;
if (typeof vertical === "number") {
offset2 = vertical;
} else if (vertical === "center") {
offset2 = rect.height / 2;
} else if (vertical === "bottom") {
offset2 = rect.height;
}
return offset2;
};
getOffsetLeft = function(rect, horizontal) {
let offset2 = 0;
if (typeof horizontal === "number") {
offset2 = horizontal;
} else if (horizontal === "center") {
offset2 = rect.width / 2;
} else if (horizontal === "right") {
offset2 = rect.width;
}
return offset2;
};
function getTransformOriginValue(transformOrigin) {
return [
transformOrigin.horizontal,
transformOrigin.vertical
].map((n) => typeof n === "number" ? `${n}px` : n).join(" ");
}
function resolveAnchorEl$1(anchorEl) {
return typeof anchorEl === "function" ? anchorEl() : anchorEl;
}
const useUtilityClasses$e = (ownerState) => {
const { classes } = ownerState;
const slots = {
root: [
"root"
],
paper: [
"paper"
]
};
return composeClasses(slots, getPopoverUtilityClass, classes);
};
PopoverRoot = styled(Modal, {
name: "MuiPopover",
slot: "Root",
overridesResolver: (props, styles2) => styles2.root
})({});
PopoverPaper = styled(Paper, {
name: "MuiPopover",
slot: "Paper",
overridesResolver: (props, styles2) => styles2.paper
})({
position: "absolute",
overflowY: "auto",
overflowX: "hidden",
minWidth: 16,
minHeight: 16,
maxWidth: "calc(100% - 32px)",
maxHeight: "calc(100% - 32px)",
outline: 0
});
Popover = __mf_14(function Popover2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiPopover"
});
const { action, anchorEl, anchorOrigin = {
vertical: "top",
horizontal: "left"
}, anchorPosition, anchorReference = "anchorEl", children, className, container: containerProp, elevation = 8, marginThreshold = 16, open, PaperProps: PaperPropsProp = {}, slots = {}, slotProps = {}, transformOrigin = {
vertical: "top",
horizontal: "left"
}, TransitionComponent, transitionDuration: transitionDurationProp = "auto", TransitionProps = {}, disableScrollLock = false, ...other } = props;
const paperRef = __mf_31();
const ownerState = {
...props,
anchorOrigin,
anchorReference,
elevation,
marginThreshold,
transformOrigin,
TransitionComponent,
transitionDuration: transitionDurationProp,
TransitionProps
};
const classes = useUtilityClasses$e(ownerState);
const getAnchorOffset = __mf_20(() => {
if (anchorReference === "anchorPosition") {
return anchorPosition;
}
const resolvedAnchorEl = resolveAnchorEl$1(anchorEl);
const anchorElement = resolvedAnchorEl && resolvedAnchorEl.nodeType === 1 ? resolvedAnchorEl : ownerDocument(paperRef.current).body;
const anchorRect = anchorElement.getBoundingClientRect();
return {
top: anchorRect.top + getOffsetTop(anchorRect, anchorOrigin.vertical),
left: anchorRect.left + getOffsetLeft(anchorRect, anchorOrigin.horizontal)
};
}, [
anchorEl,
anchorOrigin.horizontal,
anchorOrigin.vertical,
anchorPosition,
anchorReference
]);
const getTransformOrigin = __mf_20((elemRect) => {
return {
vertical: getOffsetTop(elemRect, transformOrigin.vertical),
horizontal: getOffsetLeft(elemRect, transformOrigin.horizontal)
};
}, [
transformOrigin.horizontal,
transformOrigin.vertical
]);
const getPositioningStyle = __mf_20((element) => {
const elemRect = {
width: element.offsetWidth,
height: element.offsetHeight
};
const elemTransformOrigin = getTransformOrigin(elemRect);
if (anchorReference === "none") {
return {
top: null,
left: null,
transformOrigin: getTransformOriginValue(elemTransformOrigin)
};
}
const anchorOffset = getAnchorOffset();
let top2 = anchorOffset.top - elemTransformOrigin.vertical;
let left2 = anchorOffset.left - elemTransformOrigin.horizontal;
const bottom2 = top2 + elemRect.height;
const right2 = left2 + elemRect.width;
const containerWindow = ownerWindow(resolveAnchorEl$1(anchorEl));
const heightThreshold = containerWindow.innerHeight - marginThreshold;
const widthThreshold = containerWindow.innerWidth - marginThreshold;
if (marginThreshold !== null && top2 < marginThreshold) {
const diff = top2 - marginThreshold;
top2 -= diff;
elemTransformOrigin.vertical += diff;
} else if (marginThreshold !== null && bottom2 > heightThreshold) {
const diff = bottom2 - heightThreshold;
top2 -= diff;
elemTransformOrigin.vertical += diff;
}
if (marginThreshold !== null && left2 < marginThreshold) {
const diff = left2 - marginThreshold;
left2 -= diff;
elemTransformOrigin.horizontal += diff;
} else if (right2 > widthThreshold) {
const diff = right2 - widthThreshold;
left2 -= diff;
elemTransformOrigin.horizontal += diff;
}
return {
top: `${Math.round(top2)}px`,
left: `${Math.round(left2)}px`,
transformOrigin: getTransformOriginValue(elemTransformOrigin)
};
}, [
anchorEl,
anchorReference,
getAnchorOffset,
getTransformOrigin,
marginThreshold
]);
const [isPositioned, setIsPositioned] = __mf_32(open);
const setPositioningStyles = __mf_20(() => {
const element = paperRef.current;
if (!element) {
return;
}
const positioning = getPositioningStyle(element);
if (positioning.top !== null) {
element.style.setProperty("top", positioning.top);
}
if (positioning.left !== null) {
element.style.left = positioning.left;
}
element.style.transformOrigin = positioning.transformOrigin;
setIsPositioned(true);
}, [
getPositioningStyle
]);
__mf_24(() => {
if (disableScrollLock) {
window.addEventListener("scroll", setPositioningStyles);
}
return () => window.removeEventListener("scroll", setPositioningStyles);
}, [
anchorEl,
disableScrollLock,
setPositioningStyles
]);
const handleEntering = () => {
setPositioningStyles();
};
const handleExited = () => {
setIsPositioned(false);
};
__mf_24(() => {
if (open) {
setPositioningStyles();
}
});
__mf_26(action, () => open ? {
updatePosition: () => {
setPositioningStyles();
}
} : null, [
open,
setPositioningStyles
]);
__mf_24(() => {
if (!open) {
return void 0;
}
const handleResize = debounce$1(() => {
setPositioningStyles();
});
const containerWindow = ownerWindow(resolveAnchorEl$1(anchorEl));
containerWindow.addEventListener("resize", handleResize);
return () => {
handleResize.clear();
containerWindow.removeEventListener("resize", handleResize);
};
}, [
anchorEl,
open,
setPositioningStyles
]);
let transitionDuration = transitionDurationProp;
const externalForwardedProps = {
slots: {
transition: TransitionComponent,
...slots
},
slotProps: {
transition: TransitionProps,
paper: PaperPropsProp,
...slotProps
}
};
const [TransitionSlot, transitionSlotProps] = useSlot("transition", {
elementType: Grow,
externalForwardedProps,
ownerState,
getSlotProps: (handlers) => ({
...handlers,
onEntering: (element, isAppearing) => {
var _a;
(_a = handlers.onEntering) == null ? void 0 : _a.call(handlers, element, isAppearing);
handleEntering();
},
onExited: (element) => {
var _a;
(_a = handlers.onExited) == null ? void 0 : _a.call(handlers, element);
handleExited();
}
}),
additionalProps: {
appear: true,
in: open
}
});
if (transitionDurationProp === "auto" && !TransitionSlot.muiSupportAuto) {
transitionDuration = void 0;
}
const container = containerProp || (anchorEl ? ownerDocument(resolveAnchorEl$1(anchorEl)).body : void 0);
const [RootSlot, { slots: rootSlotsProp, slotProps: rootSlotPropsProp, ...rootProps }] = useSlot("root", {
ref,
elementType: PopoverRoot,
externalForwardedProps: {
...externalForwardedProps,
...other
},
shouldForwardComponentProp: true,
additionalProps: {
slots: {
backdrop: slots.backdrop
},
slotProps: {
backdrop: mergeSlotProps(typeof slotProps.backdrop === "function" ? slotProps.backdrop(ownerState) : slotProps.backdrop, {
invisible: true
})
},
container,
open
},
ownerState,
className: clsx(classes.root, className)
});
const [PaperSlot, paperProps] = useSlot("paper", {
ref: paperRef,
className: classes.paper,
elementType: PopoverPaper,
externalForwardedProps,
shouldForwardComponentProp: true,
additionalProps: {
elevation,
style: isPositioned ? void 0 : {
opacity: 0
}
},
ownerState
});
return jsxRuntimeExports.jsx(RootSlot, {
...rootProps,
...!isHostComponent(RootSlot) && {
slots: rootSlotsProp,
slotProps: rootSlotPropsProp,
disableScrollLock
},
children: jsxRuntimeExports.jsx(TransitionSlot, {
...transitionSlotProps,
timeout: transitionDuration,
children: jsxRuntimeExports.jsx(PaperSlot, {
...paperProps,
children
})
})
});
});
getMenuUtilityClass = function(slot) {
return generateUtilityClass("MuiMenu", slot);
};
menuClasses = generateUtilityClasses("MuiMenu", [
"root",
"paper",
"list"
]);
const RTL_ORIGIN = {
vertical: "top",
horizontal: "right"
};
const LTR_ORIGIN = {
vertical: "top",
horizontal: "left"
};
const useUtilityClasses$d = (ownerState) => {
const { classes } = ownerState;
const slots = {
root: [
"root"
],
paper: [
"paper"
],
list: [
"list"
]
};
return composeClasses(slots, getMenuUtilityClass, classes);
};
const MenuRoot = styled(Popover, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiMenu",
slot: "Root",
overridesResolver: (props, styles2) => styles2.root
})({});
const MenuPaper = styled(PopoverPaper, {
name: "MuiMenu",
slot: "Paper",
overridesResolver: (props, styles2) => styles2.paper
})({
maxHeight: "calc(100% - 96px)",
WebkitOverflowScrolling: "touch"
});
const MenuMenuList = styled(MenuList, {
name: "MuiMenu",
slot: "List",
overridesResolver: (props, styles2) => styles2.list
})({
outline: 0
});
Menu = __mf_14(function Menu2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiMenu"
});
const { autoFocus = true, children, className, disableAutoFocusItem = false, MenuListProps = {}, onClose, open, PaperProps = {}, PopoverClasses, transitionDuration = "auto", TransitionProps: { onEntering, ...TransitionProps } = {}, variant = "selectedMenu", slots = {}, slotProps = {}, ...other } = props;
const isRtl = useRtl();
const ownerState = {
...props,
autoFocus,
disableAutoFocusItem,
MenuListProps,
onEntering,
PaperProps,
transitionDuration,
TransitionProps,
variant
};
const classes = useUtilityClasses$d(ownerState);
const autoFocusItem = autoFocus && !disableAutoFocusItem && open;
const menuListActionsRef = __mf_31(null);
const handleEntering = (element, isAppearing) => {
if (menuListActionsRef.current) {
menuListActionsRef.current.adjustStyleForScrollbar(element, {
direction: isRtl ? "rtl" : "ltr"
});
}
if (onEntering) {
onEntering(element, isAppearing);
}
};
const handleListKeyDown = (event) => {
if (event.key === "Tab") {
event.preventDefault();
if (onClose) {
onClose(event, "tabKeyDown");
}
}
};
let activeItemIndex = -1;
__mf_0.map(children, (child, index) => {
if (!__mf_15(child)) {
return;
}
if (!child.props.disabled) {
if (variant === "selectedMenu" && child.props.selected) {
activeItemIndex = index;
} else if (activeItemIndex === -1) {
activeItemIndex = index;
}
}
});
const externalForwardedProps = {
slots,
slotProps: {
list: MenuListProps,
transition: TransitionProps,
paper: PaperProps,
...slotProps
}
};
const rootSlotProps = useSlotProps({
elementType: slots.root,
externalSlotProps: slotProps.root,
ownerState,
className: [
classes.root,
className
]
});
const [PaperSlot, paperSlotProps] = useSlot("paper", {
className: classes.paper,
elementType: MenuPaper,
externalForwardedProps,
shouldForwardComponentProp: true,
ownerState
});
const [ListSlot, listSlotProps] = useSlot("list", {
className: clsx(classes.list, MenuListProps.className),
elementType: MenuMenuList,
shouldForwardComponentProp: true,
externalForwardedProps,
getSlotProps: (handlers) => ({
...handlers,
onKeyDown: (event) => {
var _a;
handleListKeyDown(event);
(_a = handlers.onKeyDown) == null ? void 0 : _a.call(handlers, event);
}
}),
ownerState
});
const resolvedTransitionProps = typeof externalForwardedProps.slotProps.transition === "function" ? externalForwardedProps.slotProps.transition(ownerState) : externalForwardedProps.slotProps.transition;
return jsxRuntimeExports.jsx(MenuRoot, {
onClose,
anchorOrigin: {
vertical: "bottom",
horizontal: isRtl ? "right" : "left"
},
transformOrigin: isRtl ? RTL_ORIGIN : LTR_ORIGIN,
slots: {
root: slots.root,
paper: PaperSlot,
backdrop: slots.backdrop,
...slots.transition && {
transition: slots.transition
}
},
slotProps: {
root: rootSlotProps,
paper: paperSlotProps,
backdrop: typeof slotProps.backdrop === "function" ? slotProps.backdrop(ownerState) : slotProps.backdrop,
transition: {
...resolvedTransitionProps,
onEntering: (...args) => {
var _a;
handleEntering(...args);
(_a = resolvedTransitionProps == null ? void 0 : resolvedTransitionProps.onEntering) == null ? void 0 : _a.call(resolvedTransitionProps, ...args);
}
}
},
open,
ref,
transitionDuration,
ownerState,
...other,
classes: PopoverClasses,
children: jsxRuntimeExports.jsx(ListSlot, {
actions: menuListActionsRef,
autoFocus: autoFocus && (activeItemIndex === -1 || disableAutoFocusItem),
autoFocusItem,
variant,
...listSlotProps,
children
})
});
});
getNativeSelectUtilityClasses = function(slot) {
return generateUtilityClass("MuiNativeSelect", slot);
};
nativeSelectClasses = generateUtilityClasses("MuiNativeSelect", [
"root",
"select",
"multiple",
"filled",
"outlined",
"standard",
"disabled",
"icon",
"iconOpen",
"iconFilled",
"iconOutlined",
"iconStandard",
"nativeInput",
"error"
]);
const useUtilityClasses$c = (ownerState) => {
const { classes, variant, disabled, multiple, open, error } = ownerState;
const slots = {
select: [
"select",
variant,
disabled && "disabled",
multiple && "multiple",
error && "error"
],
icon: [
"icon",
`icon${capitalize(variant)}`,
open && "iconOpen",
disabled && "disabled"
]
};
return composeClasses(slots, getNativeSelectUtilityClasses, classes);
};
const StyledSelectSelect = styled("select", {
name: "MuiNativeSelect"
})(({ theme }) => ({
MozAppearance: "none",
WebkitAppearance: "none",
userSelect: "none",
borderRadius: 0,
cursor: "pointer",
"&:focus": {
borderRadius: 0
},
[`&.${nativeSelectClasses.disabled}`]: {
cursor: "default"
},
"&[multiple]": {
height: "auto"
},
"&:not([multiple]) option, &:not([multiple]) optgroup": {
backgroundColor: (theme.vars || theme).palette.background.paper
},
variants: [
{
props: ({ ownerState }) => ownerState.variant !== "filled" && ownerState.variant !== "outlined",
style: {
"&&&": {
paddingRight: 24,
minWidth: 16
}
}
},
{
props: {
variant: "filled"
},
style: {
"&&&": {
paddingRight: 32
}
}
},
{
props: {
variant: "outlined"
},
style: {
borderRadius: (theme.vars || theme).shape.borderRadius,
"&:focus": {
borderRadius: (theme.vars || theme).shape.borderRadius
},
"&&&": {
paddingRight: 32
}
}
}
]
}));
const NativeSelectSelect = styled(StyledSelectSelect, {
name: "MuiNativeSelect",
slot: "Select",
shouldForwardProp: rootShouldForwardProp,
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.select,
styles2[ownerState.variant],
ownerState.error && styles2.error,
{
[`&.${nativeSelectClasses.multiple}`]: styles2.multiple
}
];
}
})({});
const StyledSelectIcon = styled("svg", {
name: "MuiNativeSelect"
})(({ theme }) => ({
position: "absolute",
right: 0,
top: "calc(50% - .5em)",
pointerEvents: "none",
color: (theme.vars || theme).palette.action.active,
[`&.${nativeSelectClasses.disabled}`]: {
color: (theme.vars || theme).palette.action.disabled
},
variants: [
{
props: ({ ownerState }) => ownerState.open,
style: {
transform: "rotate(180deg)"
}
},
{
props: {
variant: "filled"
},
style: {
right: 7
}
},
{
props: {
variant: "outlined"
},
style: {
right: 7
}
}
]
}));
const NativeSelectIcon = styled(StyledSelectIcon, {
name: "MuiNativeSelect",
slot: "Icon",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.icon,
ownerState.variant && styles2[`icon${capitalize(ownerState.variant)}`],
ownerState.open && styles2.iconOpen
];
}
})({});
NativeSelectInput = __mf_14(function NativeSelectInput2(props, ref) {
const { className, disabled, error, IconComponent, inputRef, variant = "standard", ...other } = props;
const ownerState = {
...props,
disabled,
variant,
error
};
const classes = useUtilityClasses$c(ownerState);
return jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
jsxRuntimeExports.jsx(NativeSelectSelect, {
ownerState,
className: clsx(classes.select, className),
disabled,
ref: inputRef || ref,
...other
}),
props.multiple ? null : jsxRuntimeExports.jsx(NativeSelectIcon, {
as: IconComponent,
ownerState,
className: classes.icon
})
]
});
});
getSelectUtilityClasses = function(slot) {
return generateUtilityClass("MuiSelect", slot);
};
selectClasses = generateUtilityClasses("MuiSelect", [
"root",
"select",
"multiple",
"filled",
"outlined",
"standard",
"disabled",
"focused",
"icon",
"iconOpen",
"iconFilled",
"iconOutlined",
"iconStandard",
"nativeInput",
"error"
]);
var _span$1;
const SelectSelect = styled(StyledSelectSelect, {
name: "MuiSelect",
slot: "Select",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
{
[`&.${selectClasses.select}`]: styles2.select
},
{
[`&.${selectClasses.select}`]: styles2[ownerState.variant]
},
{
[`&.${selectClasses.error}`]: styles2.error
},
{
[`&.${selectClasses.multiple}`]: styles2.multiple
}
];
}
})({
[`&.${selectClasses.select}`]: {
height: "auto",
minHeight: "1.4375em",
textOverflow: "ellipsis",
whiteSpace: "nowrap",
overflow: "hidden"
}
});
const SelectIcon = styled(StyledSelectIcon, {
name: "MuiSelect",
slot: "Icon",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.icon,
ownerState.variant && styles2[`icon${capitalize(ownerState.variant)}`],
ownerState.open && styles2.iconOpen
];
}
})({});
const SelectNativeInput = styled("input", {
shouldForwardProp: (prop) => slotShouldForwardProp(prop) && prop !== "classes",
name: "MuiSelect",
slot: "NativeInput",
overridesResolver: (props, styles2) => styles2.nativeInput
})({
bottom: 0,
left: 0,
position: "absolute",
opacity: 0,
pointerEvents: "none",
width: "100%",
boxSizing: "border-box"
});
function areEqualValues(a, b) {
if (typeof b === "object" && b !== null) {
return a === b;
}
return String(a) === String(b);
}
function isEmpty(display) {
return display == null || typeof display === "string" && !display.trim();
}
const useUtilityClasses$b = (ownerState) => {
const { classes, variant, disabled, multiple, open, error } = ownerState;
const slots = {
select: [
"select",
variant,
disabled && "disabled",
multiple && "multiple",
error && "error"
],
icon: [
"icon",
`icon${capitalize(variant)}`,
open && "iconOpen",
disabled && "disabled"
],
nativeInput: [
"nativeInput"
]
};
return composeClasses(slots, getSelectUtilityClasses, classes);
};
const SelectInput = __mf_14(function SelectInput2(props, ref) {
var _a;
const { "aria-describedby": ariaDescribedby, "aria-label": ariaLabel, autoFocus, autoWidth, children, className, defaultOpen, defaultValue, disabled, displayEmpty, error = false, IconComponent, inputRef: inputRefProp, labelId, MenuProps = {}, multiple, name, onBlur, onChange, onClose, onFocus, onOpen, open: openProp, readOnly, renderValue, required, SelectDisplayProps = {}, tabIndex: tabIndexProp, type, value: valueProp, variant = "standard", ...other } = props;
const [value, setValueState] = useControlled({
controlled: valueProp,
default: defaultValue,
name: "Select"
});
const [openState, setOpenState] = useControlled({
controlled: openProp,
default: defaultOpen,
name: "Select"
});
const inputRef = __mf_31(null);
const displayRef = __mf_31(null);
const [displayNode, setDisplayNode] = __mf_32(null);
const { current: isOpenControlled } = __mf_31(openProp != null);
const [menuMinWidthState, setMenuMinWidthState] = __mf_32();
const handleRef = useForkRef(ref, inputRefProp);
const handleDisplayRef = __mf_20((node) => {
displayRef.current = node;
if (node) {
setDisplayNode(node);
}
}, []);
const anchorElement = displayNode == null ? void 0 : displayNode.parentNode;
__mf_26(handleRef, () => ({
focus: () => {
displayRef.current.focus();
},
node: inputRef.current,
value
}), [
value
]);
__mf_24(() => {
if (defaultOpen && openState && displayNode && !isOpenControlled) {
setMenuMinWidthState(autoWidth ? null : anchorElement.clientWidth);
displayRef.current.focus();
}
}, [
displayNode,
autoWidth
]);
__mf_24(() => {
if (autoFocus) {
displayRef.current.focus();
}
}, [
autoFocus
]);
__mf_24(() => {
if (!labelId) {
return void 0;
}
const label = ownerDocument(displayRef.current).getElementById(labelId);
if (label) {
const handler = () => {
if (getSelection().isCollapsed) {
displayRef.current.focus();
}
};
label.addEventListener("click", handler);
return () => {
label.removeEventListener("click", handler);
};
}
return void 0;
}, [
labelId
]);
const update = (open2, event) => {
if (open2) {
if (onOpen) {
onOpen(event);
}
} else if (onClose) {
onClose(event);
}
if (!isOpenControlled) {
setMenuMinWidthState(autoWidth ? null : anchorElement.clientWidth);
setOpenState(open2);
}
};
const handleMouseDown = (event) => {
if (event.button !== 0) {
return;
}
event.preventDefault();
displayRef.current.focus();
update(true, event);
};
const handleClose = (event) => {
update(false, event);
};
const childrenArray = __mf_0.toArray(children);
const handleChange = (event) => {
const child = childrenArray.find((childItem) => childItem.props.value === event.target.value);
if (child === void 0) {
return;
}
setValueState(child.props.value);
if (onChange) {
onChange(event, child);
}
};
const handleItemClick = (child) => (event) => {
let newValue;
if (!event.currentTarget.hasAttribute("tabindex")) {
return;
}
if (multiple) {
newValue = Array.isArray(value) ? value.slice() : [];
const itemIndex = value.indexOf(child.props.value);
if (itemIndex === -1) {
newValue.push(child.props.value);
} else {
newValue.splice(itemIndex, 1);
}
} else {
newValue = child.props.value;
}
if (child.props.onClick) {
child.props.onClick(event);
}
if (value !== newValue) {
setValueState(newValue);
if (onChange) {
const nativeEvent = event.nativeEvent || event;
const clonedEvent = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
Object.defineProperty(clonedEvent, "target", {
writable: true,
value: {
value: newValue,
name
}
});
onChange(clonedEvent, child);
}
}
if (!multiple) {
update(false, event);
}
};
const handleKeyDown = (event) => {
if (!readOnly) {
const validKeys = [
" ",
"ArrowUp",
"ArrowDown",
"Enter"
];
if (validKeys.includes(event.key)) {
event.preventDefault();
update(true, event);
}
}
};
const open = displayNode !== null && openState;
const handleBlur = (event) => {
if (!open && onBlur) {
Object.defineProperty(event, "target", {
writable: true,
value: {
value,
name
}
});
onBlur(event);
}
};
delete other["aria-invalid"];
let display;
let displaySingle;
const displayMultiple = [];
let computeDisplay = false;
if (isFilled({
value
}) || displayEmpty) {
if (renderValue) {
display = renderValue(value);
} else {
computeDisplay = true;
}
}
const items = childrenArray.map((child) => {
if (!__mf_15(child)) {
return null;
}
let selected;
if (multiple) {
if (!Array.isArray(value)) {
throw new Error(formatMuiErrorMessage(2));
}
selected = value.some((v) => areEqualValues(v, child.props.value));
if (selected && computeDisplay) {
displayMultiple.push(child.props.children);
}
} else {
selected = areEqualValues(value, child.props.value);
if (selected && computeDisplay) {
displaySingle = child.props.children;
}
}
return __mf_9(child, {
"aria-selected": selected ? "true" : "false",
onClick: handleItemClick(child),
onKeyUp: (event) => {
if (event.key === " ") {
event.preventDefault();
}
if (child.props.onKeyUp) {
child.props.onKeyUp(event);
}
},
role: "option",
selected,
value: void 0,
"data-value": child.props.value
});
});
if (computeDisplay) {
if (multiple) {
if (displayMultiple.length === 0) {
display = null;
} else {
display = displayMultiple.reduce((output, child, index) => {
output.push(child);
if (index < displayMultiple.length - 1) {
output.push(", ");
}
return output;
}, []);
}
} else {
display = displaySingle;
}
}
let menuMinWidth = menuMinWidthState;
if (!autoWidth && isOpenControlled && displayNode) {
menuMinWidth = anchorElement.clientWidth;
}
let tabIndex;
if (typeof tabIndexProp !== "undefined") {
tabIndex = tabIndexProp;
} else {
tabIndex = disabled ? null : 0;
}
const buttonId = SelectDisplayProps.id || (name ? `mui-component-select-${name}` : void 0);
const ownerState = {
...props,
variant,
value,
open,
error
};
const classes = useUtilityClasses$b(ownerState);
const paperProps = {
...MenuProps.PaperProps,
...(_a = MenuProps.slotProps) == null ? void 0 : _a.paper
};
const listboxId = useId();
return jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
jsxRuntimeExports.jsx(SelectSelect, {
as: "div",
ref: handleDisplayRef,
tabIndex,
role: "combobox",
"aria-controls": open ? listboxId : void 0,
"aria-disabled": disabled ? "true" : void 0,
"aria-expanded": open ? "true" : "false",
"aria-haspopup": "listbox",
"aria-label": ariaLabel,
"aria-labelledby": [
labelId,
buttonId
].filter(Boolean).join(" ") || void 0,
"aria-describedby": ariaDescribedby,
"aria-required": required ? "true" : void 0,
"aria-invalid": error ? "true" : void 0,
onKeyDown: handleKeyDown,
onMouseDown: disabled || readOnly ? null : handleMouseDown,
onBlur: handleBlur,
onFocus,
...SelectDisplayProps,
ownerState,
className: clsx(SelectDisplayProps.className, classes.select, className),
id: buttonId,
children: isEmpty(display) ? _span$1 || (_span$1 = jsxRuntimeExports.jsx("span", {
className: "notranslate",
"aria-hidden": true,
children: "\u200B"
})) : display
}),
jsxRuntimeExports.jsx(SelectNativeInput, {
"aria-invalid": error,
value: Array.isArray(value) ? value.join(",") : value,
name,
ref: inputRef,
"aria-hidden": true,
onChange: handleChange,
tabIndex: -1,
disabled,
className: classes.nativeInput,
autoFocus,
required,
...other,
ownerState
}),
jsxRuntimeExports.jsx(SelectIcon, {
as: IconComponent,
className: classes.icon,
ownerState
}),
jsxRuntimeExports.jsx(Menu, {
id: `menu-${name || ""}`,
anchorEl: anchorElement,
open,
onClose: handleClose,
anchorOrigin: {
vertical: "bottom",
horizontal: "center"
},
transformOrigin: {
vertical: "top",
horizontal: "center"
},
...MenuProps,
slotProps: {
...MenuProps.slotProps,
list: {
"aria-labelledby": labelId,
role: "listbox",
"aria-multiselectable": multiple ? "true" : void 0,
disableListWrap: true,
id: listboxId,
...MenuProps.MenuListProps
},
paper: {
...paperProps,
style: {
minWidth: menuMinWidth,
...paperProps != null ? paperProps.style : null
}
}
},
children: items
})
]
});
});
ArrowDropDownIcon = createSvgIcon(jsxRuntimeExports.jsx("path", {
d: "M7 10l5 5 5-5z"
}), "ArrowDropDown");
const useUtilityClasses$a = (ownerState) => {
const { classes } = ownerState;
const slots = {
root: [
"root"
]
};
const composedClasses = composeClasses(slots, getSelectUtilityClasses, classes);
return {
...classes,
...composedClasses
};
};
const styledRootConfig = {
name: "MuiSelect",
overridesResolver: (props, styles2) => styles2.root,
shouldForwardProp: (prop) => rootShouldForwardProp(prop) && prop !== "variant",
slot: "Root"
};
const StyledInput = styled(Input, styledRootConfig)("");
const StyledOutlinedInput = styled(OutlinedInput, styledRootConfig)("");
const StyledFilledInput = styled(FilledInput, styledRootConfig)("");
Select = __mf_14(function Select2(inProps, ref) {
const props = useDefaultProps({
name: "MuiSelect",
props: inProps
});
const { autoWidth = false, children, classes: classesProp = {}, className, defaultOpen = false, displayEmpty = false, IconComponent = ArrowDropDownIcon, id, input, inputProps, label, labelId, MenuProps, multiple = false, native = false, onClose, onOpen, open, renderValue, SelectDisplayProps, variant: variantProp = "outlined", ...other } = props;
const inputComponent = native ? NativeSelectInput : SelectInput;
const muiFormControl = useFormControl();
const fcs = formControlState({
props,
muiFormControl,
states: [
"variant",
"error"
]
});
const variant = fcs.variant || variantProp;
const ownerState = {
...props,
variant,
classes: classesProp
};
const classes = useUtilityClasses$a(ownerState);
const { root, ...restOfClasses } = classes;
const InputComponent = input || {
standard: jsxRuntimeExports.jsx(StyledInput, {
ownerState
}),
outlined: jsxRuntimeExports.jsx(StyledOutlinedInput, {
label,
ownerState
}),
filled: jsxRuntimeExports.jsx(StyledFilledInput, {
ownerState
})
}[variant];
const inputComponentRef = useForkRef(ref, getReactElementRef(InputComponent));
return jsxRuntimeExports.jsx(__mf_2$1, {
children: __mf_9(InputComponent, {
inputComponent,
inputProps: {
children,
error: fcs.error,
IconComponent,
variant,
type: void 0,
multiple,
...native ? {
id
} : {
autoWidth,
defaultOpen,
displayEmpty,
labelId,
MenuProps,
onClose,
onOpen,
open,
renderValue,
SelectDisplayProps: {
id,
...SelectDisplayProps
}
},
...inputProps,
classes: inputProps ? deepmerge(restOfClasses, inputProps.classes) : restOfClasses,
...input ? input.props.inputProps : {}
},
...(multiple && native || displayEmpty) && variant === "outlined" ? {
notched: true
} : {},
ref: inputComponentRef,
className: clsx(InputComponent.props.className, className, classes.root),
...!input && {
variant
},
...other
})
});
});
Select.muiName = "Select";
getTextFieldUtilityClass = function(slot) {
return generateUtilityClass("MuiTextField", slot);
};
textFieldClasses = generateUtilityClasses("MuiTextField", [
"root"
]);
const variantComponent = {
standard: Input,
filled: FilledInput,
outlined: OutlinedInput
};
const useUtilityClasses$9 = (ownerState) => {
const { classes } = ownerState;
const slots = {
root: [
"root"
]
};
return composeClasses(slots, getTextFieldUtilityClass, classes);
};
const TextFieldRoot = styled(FormControl, {
name: "MuiTextField",
slot: "Root",
overridesResolver: (props, styles2) => styles2.root
})({});
TextField = __mf_14(function TextField2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiTextField"
});
const { autoComplete, autoFocus = false, children, className, color = "primary", defaultValue, disabled = false, error = false, FormHelperTextProps: FormHelperTextPropsProp, fullWidth = false, helperText, id: idOverride, InputLabelProps: InputLabelPropsProp, inputProps: inputPropsProp, InputProps: InputPropsProp, inputRef, label, maxRows, minRows, multiline = false, name, onBlur, onChange, onFocus, placeholder, required = false, rows, select = false, SelectProps: SelectPropsProp, slots = {}, slotProps = {}, type, value, variant = "outlined", ...other } = props;
const ownerState = {
...props,
autoFocus,
color,
disabled,
error,
fullWidth,
multiline,
required,
select,
variant
};
const classes = useUtilityClasses$9(ownerState);
const id = useId(idOverride);
const helperTextId = helperText && id ? `${id}-helper-text` : void 0;
const inputLabelId = label && id ? `${id}-label` : void 0;
const InputComponent = variantComponent[variant];
const externalForwardedProps = {
slots,
slotProps: {
input: InputPropsProp,
inputLabel: InputLabelPropsProp,
htmlInput: inputPropsProp,
formHelperText: FormHelperTextPropsProp,
select: SelectPropsProp,
...slotProps
}
};
const inputAdditionalProps = {};
const inputLabelSlotProps = externalForwardedProps.slotProps.inputLabel;
if (variant === "outlined") {
if (inputLabelSlotProps && typeof inputLabelSlotProps.shrink !== "undefined") {
inputAdditionalProps.notched = inputLabelSlotProps.shrink;
}
inputAdditionalProps.label = label;
}
if (select) {
if (!SelectPropsProp || !SelectPropsProp.native) {
inputAdditionalProps.id = void 0;
}
inputAdditionalProps["aria-describedby"] = void 0;
}
const [RootSlot, rootProps] = useSlot("root", {
elementType: TextFieldRoot,
shouldForwardComponentProp: true,
externalForwardedProps: {
...externalForwardedProps,
...other
},
ownerState,
className: clsx(classes.root, className),
ref,
additionalProps: {
disabled,
error,
fullWidth,
required,
color,
variant
}
});
const [InputSlot, inputProps] = useSlot("input", {
elementType: InputComponent,
externalForwardedProps,
additionalProps: inputAdditionalProps,
ownerState
});
const [InputLabelSlot, inputLabelProps] = useSlot("inputLabel", {
elementType: InputLabel,
externalForwardedProps,
ownerState
});
const [HtmlInputSlot, htmlInputProps] = useSlot("htmlInput", {
elementType: "input",
externalForwardedProps,
ownerState
});
const [FormHelperTextSlot, formHelperTextProps] = useSlot("formHelperText", {
elementType: FormHelperText,
externalForwardedProps,
ownerState
});
const [SelectSlot, selectProps] = useSlot("select", {
elementType: Select,
externalForwardedProps,
ownerState
});
const InputElement = jsxRuntimeExports.jsx(InputSlot, {
"aria-describedby": helperTextId,
autoComplete,
autoFocus,
defaultValue,
fullWidth,
multiline,
name,
rows,
maxRows,
minRows,
type,
value,
id,
inputRef,
onBlur,
onChange,
onFocus,
placeholder,
inputProps: htmlInputProps,
slots: {
input: slots.htmlInput ? HtmlInputSlot : void 0
},
...inputProps
});
return jsxRuntimeExports.jsxs(RootSlot, {
...rootProps,
children: [
label != null && label !== "" && jsxRuntimeExports.jsx(InputLabelSlot, {
htmlFor: id,
id: inputLabelId,
...inputLabelProps,
children: label
}),
select ? jsxRuntimeExports.jsx(SelectSlot, {
"aria-describedby": helperTextId,
id,
labelId: inputLabelId,
value,
input: InputElement,
...selectProps,
children
}) : InputElement,
helperText && jsxRuntimeExports.jsx(FormHelperTextSlot, {
id: helperTextId,
...formHelperTextProps,
children: helperText
})
]
});
});
getInputAdornmentUtilityClass = function(slot) {
return generateUtilityClass("MuiInputAdornment", slot);
};
inputAdornmentClasses = generateUtilityClasses("MuiInputAdornment", [
"root",
"filled",
"standard",
"outlined",
"positionStart",
"positionEnd",
"disablePointerEvents",
"hiddenLabel",
"sizeSmall"
]);
var _span;
const overridesResolver$1 = (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
styles2[`position${capitalize(ownerState.position)}`],
ownerState.disablePointerEvents === true && styles2.disablePointerEvents,
styles2[ownerState.variant]
];
};
const useUtilityClasses$8 = (ownerState) => {
const { classes, disablePointerEvents, hiddenLabel, position, size, variant } = ownerState;
const slots = {
root: [
"root",
disablePointerEvents && "disablePointerEvents",
position && `position${capitalize(position)}`,
variant,
hiddenLabel && "hiddenLabel",
size && `size${capitalize(size)}`
]
};
return composeClasses(slots, getInputAdornmentUtilityClass, classes);
};
const InputAdornmentRoot = styled("div", {
name: "MuiInputAdornment",
slot: "Root",
overridesResolver: overridesResolver$1
})(memoTheme(({ theme }) => ({
display: "flex",
maxHeight: "2em",
alignItems: "center",
whiteSpace: "nowrap",
color: (theme.vars || theme).palette.action.active,
variants: [
{
props: {
variant: "filled"
},
style: {
[`&.${inputAdornmentClasses.positionStart}&:not(.${inputAdornmentClasses.hiddenLabel})`]: {
marginTop: 16
}
}
},
{
props: {
position: "start"
},
style: {
marginRight: 8
}
},
{
props: {
position: "end"
},
style: {
marginLeft: 8
}
},
{
props: {
disablePointerEvents: true
},
style: {
pointerEvents: "none"
}
}
]
})));
InputAdornment = __mf_14(function InputAdornment2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiInputAdornment"
});
const { children, className, component = "div", disablePointerEvents = false, disableTypography = false, position, variant: variantProp, ...other } = props;
const muiFormControl = useFormControl() || {};
let variant = variantProp;
if (variantProp && muiFormControl.variant) ;
if (muiFormControl && !variant) {
variant = muiFormControl.variant;
}
const ownerState = {
...props,
hiddenLabel: muiFormControl.hiddenLabel,
size: muiFormControl.size,
disablePointerEvents,
position,
variant
};
const classes = useUtilityClasses$8(ownerState);
return jsxRuntimeExports.jsx(FormControlContext.Provider, {
value: null,
children: jsxRuntimeExports.jsx(InputAdornmentRoot, {
as: component,
ownerState,
className: clsx(classes.root, className),
ref,
...other,
children: typeof children === "string" && !disableTypography ? jsxRuntimeExports.jsx(Typography, {
color: "textSecondary",
children
}) : jsxRuntimeExports.jsxs(__mf_2$1, {
children: [
position === "start" ? _span || (_span = jsxRuntimeExports.jsx("span", {
className: "notranslate",
"aria-hidden": true,
children: "\u200B"
})) : null,
children
]
})
})
});
});
useMediaQuery = unstable_createUseMediaQuery({
themeId: THEME_ID
});
var top = "top";
var bottom = "bottom";
var right = "right";
var left = "left";
var auto = "auto";
var basePlacements = [
top,
bottom,
right,
left
];
var start = "start";
var end = "end";
var clippingParents = "clippingParents";
var viewport = "viewport";
var popper = "popper";
var reference = "reference";
var variationPlacements = basePlacements.reduce(function(acc, placement) {
return acc.concat([
placement + "-" + start,
placement + "-" + end
]);
}, []);
var placements = [].concat(basePlacements, [
auto
]).reduce(function(acc, placement) {
return acc.concat([
placement,
placement + "-" + start,
placement + "-" + end
]);
}, []);
var beforeRead = "beforeRead";
var read = "read";
var afterRead = "afterRead";
var beforeMain = "beforeMain";
var main = "main";
var afterMain = "afterMain";
var beforeWrite = "beforeWrite";
var write = "write";
var afterWrite = "afterWrite";
var modifierPhases = [
beforeRead,
read,
afterRead,
beforeMain,
main,
afterMain,
beforeWrite,
write,
afterWrite
];
function getNodeName(element) {
return element ? (element.nodeName || "").toLowerCase() : null;
}
function getWindow(node) {
if (node == null) {
return window;
}
if (node.toString() !== "[object Window]") {
var ownerDocument2 = node.ownerDocument;
return ownerDocument2 ? ownerDocument2.defaultView || window : window;
}
return node;
}
function isElement(node) {
var OwnElement = getWindow(node).Element;
return node instanceof OwnElement || node instanceof Element;
}
function isHTMLElement$1(node) {
var OwnElement = getWindow(node).HTMLElement;
return node instanceof OwnElement || node instanceof HTMLElement;
}
function isShadowRoot(node) {
if (typeof ShadowRoot === "undefined") {
return false;
}
var OwnElement = getWindow(node).ShadowRoot;
return node instanceof OwnElement || node instanceof ShadowRoot;
}
function applyStyles(_ref) {
var state = _ref.state;
Object.keys(state.elements).forEach(function(name) {
var style = state.styles[name] || {};
var attributes = state.attributes[name] || {};
var element = state.elements[name];
if (!isHTMLElement$1(element) || !getNodeName(element)) {
return;
}
Object.assign(element.style, style);
Object.keys(attributes).forEach(function(name2) {
var value = attributes[name2];
if (value === false) {
element.removeAttribute(name2);
} else {
element.setAttribute(name2, value === true ? "" : value);
}
});
});
}
function effect$2(_ref2) {
var state = _ref2.state;
var initialStyles = {
popper: {
position: state.options.strategy,
left: "0",
top: "0",
margin: "0"
},
arrow: {
position: "absolute"
},
reference: {}
};
Object.assign(state.elements.popper.style, initialStyles.popper);
state.styles = initialStyles;
if (state.elements.arrow) {
Object.assign(state.elements.arrow.style, initialStyles.arrow);
}
return function() {
Object.keys(state.elements).forEach(function(name) {
var element = state.elements[name];
var attributes = state.attributes[name] || {};
var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
var style = styleProperties.reduce(function(style2, property) {
style2[property] = "";
return style2;
}, {});
if (!isHTMLElement$1(element) || !getNodeName(element)) {
return;
}
Object.assign(element.style, style);
Object.keys(attributes).forEach(function(attribute) {
element.removeAttribute(attribute);
});
});
};
}
const applyStyles$1 = {
name: "applyStyles",
enabled: true,
phase: "write",
fn: applyStyles,
effect: effect$2,
requires: [
"computeStyles"
]
};
function getBasePlacement(placement) {
return placement.split("-")[0];
}
var max = Math.max;
var min = Math.min;
var round = Math.round;
function getUAString() {
var uaData = navigator.userAgentData;
if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
return uaData.brands.map(function(item) {
return item.brand + "/" + item.version;
}).join(" ");
}
return navigator.userAgent;
}
function isLayoutViewport() {
return !/^((?!chrome|android).)*safari/i.test(getUAString());
}
function getBoundingClientRect(element, includeScale, isFixedStrategy) {
if (includeScale === void 0) {
includeScale = false;
}
if (isFixedStrategy === void 0) {
isFixedStrategy = false;
}
var clientRect = element.getBoundingClientRect();
var scaleX = 1;
var scaleY = 1;
if (includeScale && isHTMLElement$1(element)) {
scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
}
var _ref = isElement(element) ? getWindow(element) : window, visualViewport = _ref.visualViewport;
var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
var width = clientRect.width / scaleX;
var height = clientRect.height / scaleY;
return {
width,
height,
top: y,
right: x + width,
bottom: y + height,
left: x,
x,
y
};
}
function getLayoutRect(element) {
var clientRect = getBoundingClientRect(element);
var width = element.offsetWidth;
var height = element.offsetHeight;
if (Math.abs(clientRect.width - width) <= 1) {
width = clientRect.width;
}
if (Math.abs(clientRect.height - height) <= 1) {
height = clientRect.height;
}
return {
x: element.offsetLeft,
y: element.offsetTop,
width,
height
};
}
function contains(parent, child) {
var rootNode = child.getRootNode && child.getRootNode();
if (parent.contains(child)) {
return true;
} else if (rootNode && isShadowRoot(rootNode)) {
var next = child;
do {
if (next && parent.isSameNode(next)) {
return true;
}
next = next.parentNode || next.host;
} while (next);
}
return false;
}
function getComputedStyle(element) {
return getWindow(element).getComputedStyle(element);
}
function isTableElement(element) {
return [
"table",
"td",
"th"
].indexOf(getNodeName(element)) >= 0;
}
function getDocumentElement(element) {
return ((isElement(element) ? element.ownerDocument : element.document) || window.document).documentElement;
}
function getParentNode(element) {
if (getNodeName(element) === "html") {
return element;
}
return element.assignedSlot || element.parentNode || (isShadowRoot(element) ? element.host : null) || getDocumentElement(element);
}
function getTrueOffsetParent(element) {
if (!isHTMLElement$1(element) || getComputedStyle(element).position === "fixed") {
return null;
}
return element.offsetParent;
}
function getContainingBlock(element) {
var isFirefox = /firefox/i.test(getUAString());
var isIE = /Trident/i.test(getUAString());
if (isIE && isHTMLElement$1(element)) {
var elementCss = getComputedStyle(element);
if (elementCss.position === "fixed") {
return null;
}
}
var currentNode = getParentNode(element);
if (isShadowRoot(currentNode)) {
currentNode = currentNode.host;
}
while (isHTMLElement$1(currentNode) && [
"html",
"body"
].indexOf(getNodeName(currentNode)) < 0) {
var css = getComputedStyle(currentNode);
if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || [
"transform",
"perspective"
].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
return currentNode;
} else {
currentNode = currentNode.parentNode;
}
}
return null;
}
function getOffsetParent(element) {
var window2 = getWindow(element);
var offsetParent = getTrueOffsetParent(element);
while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
offsetParent = getTrueOffsetParent(offsetParent);
}
if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static")) {
return window2;
}
return offsetParent || getContainingBlock(element) || window2;
}
function getMainAxisFromPlacement(placement) {
return [
"top",
"bottom"
].indexOf(placement) >= 0 ? "x" : "y";
}
function within(min$1, value, max$1) {
return max(min$1, min(value, max$1));
}
function withinMaxClamp(min2, value, max2) {
var v = within(min2, value, max2);
return v > max2 ? max2 : v;
}
function getFreshSideObject() {
return {
top: 0,
right: 0,
bottom: 0,
left: 0
};
}
function mergePaddingObject(paddingObject) {
return Object.assign({}, getFreshSideObject(), paddingObject);
}
function expandToHashMap(value, keys) {
return keys.reduce(function(hashMap, key) {
hashMap[key] = value;
return hashMap;
}, {});
}
var toPaddingObject = function toPaddingObject2(padding, state) {
padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
placement: state.placement
})) : padding;
return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
};
function arrow(_ref) {
var _state$modifiersData$;
var state = _ref.state, name = _ref.name, options = _ref.options;
var arrowElement = state.elements.arrow;
var popperOffsets2 = state.modifiersData.popperOffsets;
var basePlacement = getBasePlacement(state.placement);
var axis = getMainAxisFromPlacement(basePlacement);
var isVertical = [
left,
right
].indexOf(basePlacement) >= 0;
var len = isVertical ? "height" : "width";
if (!arrowElement || !popperOffsets2) {
return;
}
var paddingObject = toPaddingObject(options.padding, state);
var arrowRect = getLayoutRect(arrowElement);
var minProp = axis === "y" ? top : left;
var maxProp = axis === "y" ? bottom : right;
var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len];
var startDiff = popperOffsets2[axis] - state.rects.reference[axis];
var arrowOffsetParent = getOffsetParent(arrowElement);
var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
var centerToReference = endDiff / 2 - startDiff / 2;
var min2 = paddingObject[minProp];
var max2 = clientSize - arrowRect[len] - paddingObject[maxProp];
var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
var offset2 = within(min2, center, max2);
var axisProp = axis;
state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$);
}
function effect$1(_ref2) {
var state = _ref2.state, options = _ref2.options;
var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
if (arrowElement == null) {
return;
}
if (typeof arrowElement === "string") {
arrowElement = state.elements.popper.querySelector(arrowElement);
if (!arrowElement) {
return;
}
}
if (!contains(state.elements.popper, arrowElement)) {
return;
}
state.elements.arrow = arrowElement;
}
const arrow$1 = {
name: "arrow",
enabled: true,
phase: "main",
fn: arrow,
effect: effect$1,
requires: [
"popperOffsets"
],
requiresIfExists: [
"preventOverflow"
]
};
function getVariation(placement) {
return placement.split("-")[1];
}
var unsetSides = {
top: "auto",
right: "auto",
bottom: "auto",
left: "auto"
};
function roundOffsetsByDPR(_ref, win) {
var x = _ref.x, y = _ref.y;
var dpr = win.devicePixelRatio || 1;
return {
x: round(x * dpr) / dpr || 0,
y: round(y * dpr) / dpr || 0
};
}
function mapToStyles(_ref2) {
var _Object$assign2;
var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
x,
y
}) : {
x,
y
};
x = _ref3.x;
y = _ref3.y;
var hasX = offsets.hasOwnProperty("x");
var hasY = offsets.hasOwnProperty("y");
var sideX = left;
var sideY = top;
var win = window;
if (adaptive) {
var offsetParent = getOffsetParent(popper2);
var heightProp = "clientHeight";
var widthProp = "clientWidth";
if (offsetParent === getWindow(popper2)) {
offsetParent = getDocumentElement(popper2);
if (getComputedStyle(offsetParent).position !== "static" && position === "absolute") {
heightProp = "scrollHeight";
widthProp = "scrollWidth";
}
}
offsetParent = offsetParent;
if (placement === top || (placement === left || placement === right) && variation === end) {
sideY = bottom;
var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp];
y -= offsetY - popperRect.height;
y *= gpuAcceleration ? 1 : -1;
}
if (placement === left || (placement === top || placement === bottom) && variation === end) {
sideX = right;
var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp];
x -= offsetX - popperRect.width;
x *= gpuAcceleration ? 1 : -1;
}
}
var commonStyles = Object.assign({
position
}, adaptive && unsetSides);
var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
x,
y
}, getWindow(popper2)) : {
x,
y
};
x = _ref4.x;
y = _ref4.y;
if (gpuAcceleration) {
var _Object$assign;
return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
}
return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
}
function computeStyles(_ref5) {
var state = _ref5.state, options = _ref5.options;
var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
var commonStyles = {
placement: getBasePlacement(state.placement),
variation: getVariation(state.placement),
popper: state.elements.popper,
popperRect: state.rects.popper,
gpuAcceleration,
isFixed: state.options.strategy === "fixed"
};
if (state.modifiersData.popperOffsets != null) {
state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
offsets: state.modifiersData.popperOffsets,
position: state.options.strategy,
adaptive,
roundOffsets
})));
}
if (state.modifiersData.arrow != null) {
state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
offsets: state.modifiersData.arrow,
position: "absolute",
adaptive: false,
roundOffsets
})));
}
state.attributes.popper = Object.assign({}, state.attributes.popper, {
"data-popper-placement": state.placement
});
}
const computeStyles$1 = {
name: "computeStyles",
enabled: true,
phase: "beforeWrite",
fn: computeStyles,
data: {}
};
var passive = {
passive: true
};
function effect(_ref) {
var state = _ref.state, instance = _ref.instance, options = _ref.options;
var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
var window2 = getWindow(state.elements.popper);
var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
if (scroll) {
scrollParents.forEach(function(scrollParent) {
scrollParent.addEventListener("scroll", instance.update, passive);
});
}
if (resize) {
window2.addEventListener("resize", instance.update, passive);
}
return function() {
if (scroll) {
scrollParents.forEach(function(scrollParent) {
scrollParent.removeEventListener("scroll", instance.update, passive);
});
}
if (resize) {
window2.removeEventListener("resize", instance.update, passive);
}
};
}
const eventListeners = {
name: "eventListeners",
enabled: true,
phase: "write",
fn: function fn() {
},
effect,
data: {}
};
var hash$1 = {
left: "right",
right: "left",
bottom: "top",
top: "bottom"
};
function getOppositePlacement(placement) {
return placement.replace(/left|right|bottom|top/g, function(matched) {
return hash$1[matched];
});
}
var hash = {
start: "end",
end: "start"
};
function getOppositeVariationPlacement(placement) {
return placement.replace(/start|end/g, function(matched) {
return hash[matched];
});
}
function getWindowScroll(node) {
var win = getWindow(node);
var scrollLeft = win.pageXOffset;
var scrollTop = win.pageYOffset;
return {
scrollLeft,
scrollTop
};
}
function getWindowScrollBarX(element) {
return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
}
function getViewportRect(element, strategy) {
var win = getWindow(element);
var html = getDocumentElement(element);
var visualViewport = win.visualViewport;
var width = html.clientWidth;
var height = html.clientHeight;
var x = 0;
var y = 0;
if (visualViewport) {
width = visualViewport.width;
height = visualViewport.height;
var layoutViewport = isLayoutViewport();
if (layoutViewport || !layoutViewport && strategy === "fixed") {
x = visualViewport.offsetLeft;
y = visualViewport.offsetTop;
}
}
return {
width,
height,
x: x + getWindowScrollBarX(element),
y
};
}
function getDocumentRect(element) {
var _element$ownerDocumen;
var html = getDocumentElement(element);
var winScroll = getWindowScroll(element);
var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
var y = -winScroll.scrollTop;
if (getComputedStyle(body || html).direction === "rtl") {
x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
}
return {
width,
height,
x,
y
};
}
function isScrollParent(element) {
var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
}
function getScrollParent(node) {
if ([
"html",
"body",
"#document"
].indexOf(getNodeName(node)) >= 0) {
return node.ownerDocument.body;
}
if (isHTMLElement$1(node) && isScrollParent(node)) {
return node;
}
return getScrollParent(getParentNode(node));
}
function listScrollParents(element, list) {
var _element$ownerDocumen;
if (list === void 0) {
list = [];
}
var scrollParent = getScrollParent(element);
var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
var win = getWindow(scrollParent);
var target = isBody ? [
win
].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
var updatedList = list.concat(target);
return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode(target)));
}
function rectToClientRect(rect) {
return Object.assign({}, rect, {
left: rect.x,
top: rect.y,
right: rect.x + rect.width,
bottom: rect.y + rect.height
});
}
function getInnerBoundingClientRect(element, strategy) {
var rect = getBoundingClientRect(element, false, strategy === "fixed");
rect.top = rect.top + element.clientTop;
rect.left = rect.left + element.clientLeft;
rect.bottom = rect.top + element.clientHeight;
rect.right = rect.left + element.clientWidth;
rect.width = element.clientWidth;
rect.height = element.clientHeight;
rect.x = rect.left;
rect.y = rect.top;
return rect;
}
function getClientRectFromMixedType(element, clippingParent, strategy) {
return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
}
function getClippingParents(element) {
var clippingParents2 = listScrollParents(getParentNode(element));
var canEscapeClipping = [
"absolute",
"fixed"
].indexOf(getComputedStyle(element).position) >= 0;
var clipperElement = canEscapeClipping && isHTMLElement$1(element) ? getOffsetParent(element) : element;
if (!isElement(clipperElement)) {
return [];
}
return clippingParents2.filter(function(clippingParent) {
return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
});
}
function getClippingRect(element, boundary, rootBoundary, strategy) {
var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
var clippingParents2 = [].concat(mainClippingParents, [
rootBoundary
]);
var firstClippingParent = clippingParents2[0];
var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
var rect = getClientRectFromMixedType(element, clippingParent, strategy);
accRect.top = max(rect.top, accRect.top);
accRect.right = min(rect.right, accRect.right);
accRect.bottom = min(rect.bottom, accRect.bottom);
accRect.left = max(rect.left, accRect.left);
return accRect;
}, getClientRectFromMixedType(element, firstClippingParent, strategy));
clippingRect.width = clippingRect.right - clippingRect.left;
clippingRect.height = clippingRect.bottom - clippingRect.top;
clippingRect.x = clippingRect.left;
clippingRect.y = clippingRect.top;
return clippingRect;
}
function computeOffsets(_ref) {
var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
var basePlacement = placement ? getBasePlacement(placement) : null;
var variation = placement ? getVariation(placement) : null;
var commonX = reference2.x + reference2.width / 2 - element.width / 2;
var commonY = reference2.y + reference2.height / 2 - element.height / 2;
var offsets;
switch (basePlacement) {
case top:
offsets = {
x: commonX,
y: reference2.y - element.height
};
break;
case bottom:
offsets = {
x: commonX,
y: reference2.y + reference2.height
};
break;
case right:
offsets = {
x: reference2.x + reference2.width,
y: commonY
};
break;
case left:
offsets = {
x: reference2.x - element.width,
y: commonY
};
break;
default:
offsets = {
x: reference2.x,
y: reference2.y
};
}
var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
if (mainAxis != null) {
var len = mainAxis === "y" ? "height" : "width";
switch (variation) {
case start:
offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2);
break;
case end:
offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
break;
}
}
return offsets;
}
function detectOverflow(state, options) {
if (options === void 0) {
options = {};
}
var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
var altContext = elementContext === popper ? reference : popper;
var popperRect = state.rects.popper;
var element = state.elements[altBoundary ? altContext : elementContext];
var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
var referenceClientRect = getBoundingClientRect(state.elements.reference);
var popperOffsets2 = computeOffsets({
reference: referenceClientRect,
element: popperRect,
placement
});
var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
var overflowOffsets = {
top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
right: elementClientRect.right - clippingClientRect.right + paddingObject.right
};
var offsetData = state.modifiersData.offset;
if (elementContext === popper && offsetData) {
var offset2 = offsetData[placement];
Object.keys(overflowOffsets).forEach(function(key) {
var multiply = [
right,
bottom
].indexOf(key) >= 0 ? 1 : -1;
var axis = [
top,
bottom
].indexOf(key) >= 0 ? "y" : "x";
overflowOffsets[key] += offset2[axis] * multiply;
});
}
return overflowOffsets;
}
function computeAutoPlacement(state, options) {
if (options === void 0) {
options = {};
}
var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
var variation = getVariation(placement);
var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
return getVariation(placement2) === variation;
}) : basePlacements;
var allowedPlacements = placements$1.filter(function(placement2) {
return allowedAutoPlacements.indexOf(placement2) >= 0;
});
if (allowedPlacements.length === 0) {
allowedPlacements = placements$1;
}
var overflows = allowedPlacements.reduce(function(acc, placement2) {
acc[placement2] = detectOverflow(state, {
placement: placement2,
boundary,
rootBoundary,
padding
})[getBasePlacement(placement2)];
return acc;
}, {});
return Object.keys(overflows).sort(function(a, b) {
return overflows[a] - overflows[b];
});
}
function getExpandedFallbackPlacements(placement) {
if (getBasePlacement(placement) === auto) {
return [];
}
var oppositePlacement = getOppositePlacement(placement);
return [
getOppositeVariationPlacement(placement),
oppositePlacement,
getOppositeVariationPlacement(oppositePlacement)
];
}
function flip(_ref) {
var state = _ref.state, options = _ref.options, name = _ref.name;
if (state.modifiersData[name]._skip) {
return;
}
var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
var preferredPlacement = state.options.placement;
var basePlacement = getBasePlacement(preferredPlacement);
var isBasePlacement = basePlacement === preferredPlacement;
var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [
getOppositePlacement(preferredPlacement)
] : getExpandedFallbackPlacements(preferredPlacement));
var placements2 = [
preferredPlacement
].concat(fallbackPlacements).reduce(function(acc, placement2) {
return acc.concat(getBasePlacement(placement2) === auto ? computeAutoPlacement(state, {
placement: placement2,
boundary,
rootBoundary,
padding,
flipVariations,
allowedAutoPlacements
}) : placement2);
}, []);
var referenceRect = state.rects.reference;
var popperRect = state.rects.popper;
var checksMap = /* @__PURE__ */ new Map();
var makeFallbackChecks = true;
var firstFittingPlacement = placements2[0];
for (var i = 0; i < placements2.length; i++) {
var placement = placements2[i];
var _basePlacement = getBasePlacement(placement);
var isStartVariation = getVariation(placement) === start;
var isVertical = [
top,
bottom
].indexOf(_basePlacement) >= 0;
var len = isVertical ? "width" : "height";
var overflow = detectOverflow(state, {
placement,
boundary,
rootBoundary,
altBoundary,
padding
});
var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
if (referenceRect[len] > popperRect[len]) {
mainVariationSide = getOppositePlacement(mainVariationSide);
}
var altVariationSide = getOppositePlacement(mainVariationSide);
var checks = [];
if (checkMainAxis) {
checks.push(overflow[_basePlacement] <= 0);
}
if (checkAltAxis) {
checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
}
if (checks.every(function(check) {
return check;
})) {
firstFittingPlacement = placement;
makeFallbackChecks = false;
break;
}
checksMap.set(placement, checks);
}
if (makeFallbackChecks) {
var numberOfChecks = flipVariations ? 3 : 1;
var _loop = function _loop2(_i2) {
var fittingPlacement = placements2.find(function(placement2) {
var checks2 = checksMap.get(placement2);
if (checks2) {
return checks2.slice(0, _i2).every(function(check) {
return check;
});
}
});
if (fittingPlacement) {
firstFittingPlacement = fittingPlacement;
return "break";
}
};
for (var _i = numberOfChecks; _i > 0; _i--) {
var _ret = _loop(_i);
if (_ret === "break") break;
}
}
if (state.placement !== firstFittingPlacement) {
state.modifiersData[name]._skip = true;
state.placement = firstFittingPlacement;
state.reset = true;
}
}
const flip$1 = {
name: "flip",
enabled: true,
phase: "main",
fn: flip,
requiresIfExists: [
"offset"
],
data: {
_skip: false
}
};
function getSideOffsets(overflow, rect, preventedOffsets) {
if (preventedOffsets === void 0) {
preventedOffsets = {
x: 0,
y: 0
};
}
return {
top: overflow.top - rect.height - preventedOffsets.y,
right: overflow.right - rect.width + preventedOffsets.x,
bottom: overflow.bottom - rect.height + preventedOffsets.y,
left: overflow.left - rect.width - preventedOffsets.x
};
}
function isAnySideFullyClipped(overflow) {
return [
top,
right,
bottom,
left
].some(function(side) {
return overflow[side] >= 0;
});
}
function hide(_ref) {
var state = _ref.state, name = _ref.name;
var referenceRect = state.rects.reference;
var popperRect = state.rects.popper;
var preventedOffsets = state.modifiersData.preventOverflow;
var referenceOverflow = detectOverflow(state, {
elementContext: "reference"
});
var popperAltOverflow = detectOverflow(state, {
altBoundary: true
});
var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
state.modifiersData[name] = {
referenceClippingOffsets,
popperEscapeOffsets,
isReferenceHidden,
hasPopperEscaped
};
state.attributes.popper = Object.assign({}, state.attributes.popper, {
"data-popper-reference-hidden": isReferenceHidden,
"data-popper-escaped": hasPopperEscaped
});
}
const hide$1 = {
name: "hide",
enabled: true,
phase: "main",
requiresIfExists: [
"preventOverflow"
],
fn: hide
};
function distanceAndSkiddingToXY(placement, rects, offset2) {
var basePlacement = getBasePlacement(placement);
var invertDistance = [
left,
top
].indexOf(basePlacement) >= 0 ? -1 : 1;
var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
placement
})) : offset2, skidding = _ref[0], distance = _ref[1];
skidding = skidding || 0;
distance = (distance || 0) * invertDistance;
return [
left,
right
].indexOf(basePlacement) >= 0 ? {
x: distance,
y: skidding
} : {
x: skidding,
y: distance
};
}
function offset(_ref2) {
var state = _ref2.state, options = _ref2.options, name = _ref2.name;
var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [
0,
0
] : _options$offset;
var data = placements.reduce(function(acc, placement) {
acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
return acc;
}, {});
var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
if (state.modifiersData.popperOffsets != null) {
state.modifiersData.popperOffsets.x += x;
state.modifiersData.popperOffsets.y += y;
}
state.modifiersData[name] = data;
}
const offset$1 = {
name: "offset",
enabled: true,
phase: "main",
requires: [
"popperOffsets"
],
fn: offset
};
function popperOffsets(_ref) {
var state = _ref.state, name = _ref.name;
state.modifiersData[name] = computeOffsets({
reference: state.rects.reference,
element: state.rects.popper,
placement: state.placement
});
}
const popperOffsets$1 = {
name: "popperOffsets",
enabled: true,
phase: "read",
fn: popperOffsets,
data: {}
};
function getAltAxis(axis) {
return axis === "x" ? "y" : "x";
}
function preventOverflow(_ref) {
var state = _ref.state, options = _ref.options, name = _ref.name;
var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
var overflow = detectOverflow(state, {
boundary,
rootBoundary,
padding,
altBoundary
});
var basePlacement = getBasePlacement(state.placement);
var variation = getVariation(state.placement);
var isBasePlacement = !variation;
var mainAxis = getMainAxisFromPlacement(basePlacement);
var altAxis = getAltAxis(mainAxis);
var popperOffsets2 = state.modifiersData.popperOffsets;
var referenceRect = state.rects.reference;
var popperRect = state.rects.popper;
var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
placement: state.placement
})) : tetherOffset;
var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
mainAxis: tetherOffsetValue,
altAxis: tetherOffsetValue
} : Object.assign({
mainAxis: 0,
altAxis: 0
}, tetherOffsetValue);
var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
var data = {
x: 0,
y: 0
};
if (!popperOffsets2) {
return;
}
if (checkMainAxis) {
var _offsetModifierState$;
var mainSide = mainAxis === "y" ? top : left;
var altSide = mainAxis === "y" ? bottom : right;
var len = mainAxis === "y" ? "height" : "width";
var offset2 = popperOffsets2[mainAxis];
var min$1 = offset2 + overflow[mainSide];
var max$1 = offset2 - overflow[altSide];
var additive = tether ? -popperRect[len] / 2 : 0;
var minLen = variation === start ? referenceRect[len] : popperRect[len];
var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
var arrowElement = state.elements.arrow;
var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
width: 0,
height: 0
};
var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
var arrowPaddingMin = arrowPaddingObject[mainSide];
var arrowPaddingMax = arrowPaddingObject[altSide];
var arrowLen = within(0, referenceRect[len], arrowRect[len]);
var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
var tetherMax = offset2 + maxOffset - offsetModifierValue;
var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
popperOffsets2[mainAxis] = preventedOffset;
data[mainAxis] = preventedOffset - offset2;
}
if (checkAltAxis) {
var _offsetModifierState$2;
var _mainSide = mainAxis === "x" ? top : left;
var _altSide = mainAxis === "x" ? bottom : right;
var _offset = popperOffsets2[altAxis];
var _len = altAxis === "y" ? "height" : "width";
var _min = _offset + overflow[_mainSide];
var _max = _offset - overflow[_altSide];
var isOriginSide = [
top,
left
].indexOf(basePlacement) !== -1;
var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
popperOffsets2[altAxis] = _preventedOffset;
data[altAxis] = _preventedOffset - _offset;
}
state.modifiersData[name] = data;
}
const preventOverflow$1 = {
name: "preventOverflow",
enabled: true,
phase: "main",
fn: preventOverflow,
requiresIfExists: [
"offset"
]
};
function getHTMLElementScroll(element) {
return {
scrollLeft: element.scrollLeft,
scrollTop: element.scrollTop
};
}
function getNodeScroll(node) {
if (node === getWindow(node) || !isHTMLElement$1(node)) {
return getWindowScroll(node);
} else {
return getHTMLElementScroll(node);
}
}
function isElementScaled(element) {
var rect = element.getBoundingClientRect();
var scaleX = round(rect.width) / element.offsetWidth || 1;
var scaleY = round(rect.height) / element.offsetHeight || 1;
return scaleX !== 1 || scaleY !== 1;
}
function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
if (isFixed === void 0) {
isFixed = false;
}
var isOffsetParentAnElement = isHTMLElement$1(offsetParent);
var offsetParentIsScaled = isHTMLElement$1(offsetParent) && isElementScaled(offsetParent);
var documentElement = getDocumentElement(offsetParent);
var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
var scroll = {
scrollLeft: 0,
scrollTop: 0
};
var offsets = {
x: 0,
y: 0
};
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) {
scroll = getNodeScroll(offsetParent);
}
if (isHTMLElement$1(offsetParent)) {
offsets = getBoundingClientRect(offsetParent, true);
offsets.x += offsetParent.clientLeft;
offsets.y += offsetParent.clientTop;
} else if (documentElement) {
offsets.x = getWindowScrollBarX(documentElement);
}
}
return {
x: rect.left + scroll.scrollLeft - offsets.x,
y: rect.top + scroll.scrollTop - offsets.y,
width: rect.width,
height: rect.height
};
}
function order(modifiers) {
var map = /* @__PURE__ */ new Map();
var visited = /* @__PURE__ */ new Set();
var result = [];
modifiers.forEach(function(modifier) {
map.set(modifier.name, modifier);
});
function sort(modifier) {
visited.add(modifier.name);
var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
requires.forEach(function(dep) {
if (!visited.has(dep)) {
var depModifier = map.get(dep);
if (depModifier) {
sort(depModifier);
}
}
});
result.push(modifier);
}
modifiers.forEach(function(modifier) {
if (!visited.has(modifier.name)) {
sort(modifier);
}
});
return result;
}
function orderModifiers(modifiers) {
var orderedModifiers = order(modifiers);
return modifierPhases.reduce(function(acc, phase) {
return acc.concat(orderedModifiers.filter(function(modifier) {
return modifier.phase === phase;
}));
}, []);
}
function debounce(fn) {
var pending;
return function() {
if (!pending) {
pending = new Promise(function(resolve) {
Promise.resolve().then(function() {
pending = void 0;
resolve(fn());
});
});
}
return pending;
};
}
function mergeByName(modifiers) {
var merged = modifiers.reduce(function(merged2, current) {
var existing = merged2[current.name];
merged2[current.name] = existing ? Object.assign({}, existing, current, {
options: Object.assign({}, existing.options, current.options),
data: Object.assign({}, existing.data, current.data)
}) : current;
return merged2;
}, {});
return Object.keys(merged).map(function(key) {
return merged[key];
});
}
var DEFAULT_OPTIONS = {
placement: "bottom",
modifiers: [],
strategy: "absolute"
};
function areValidElements() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return !args.some(function(element) {
return !(element && typeof element.getBoundingClientRect === "function");
});
}
function popperGenerator(generatorOptions) {
if (generatorOptions === void 0) {
generatorOptions = {};
}
var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
return function createPopper2(reference2, popper2, options) {
if (options === void 0) {
options = defaultOptions;
}
var state = {
placement: "bottom",
orderedModifiers: [],
options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
modifiersData: {},
elements: {
reference: reference2,
popper: popper2
},
attributes: {},
styles: {}
};
var effectCleanupFns = [];
var isDestroyed = false;
var instance = {
state,
setOptions: function setOptions(setOptionsAction) {
var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
cleanupModifierEffects();
state.options = Object.assign({}, defaultOptions, state.options, options2);
state.scrollParents = {
reference: isElement(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
popper: listScrollParents(popper2)
};
var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
state.orderedModifiers = orderedModifiers.filter(function(m) {
return m.enabled;
});
runModifierEffects();
return instance.update();
},
forceUpdate: function forceUpdate() {
if (isDestroyed) {
return;
}
var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
if (!areValidElements(reference3, popper3)) {
return;
}
state.rects = {
reference: getCompositeRect(reference3, getOffsetParent(popper3), state.options.strategy === "fixed"),
popper: getLayoutRect(popper3)
};
state.reset = false;
state.placement = state.options.placement;
state.orderedModifiers.forEach(function(modifier) {
return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
});
for (var index = 0; index < state.orderedModifiers.length; index++) {
if (state.reset === true) {
state.reset = false;
index = -1;
continue;
}
var _state$orderedModifie = state.orderedModifiers[index], fn = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
if (typeof fn === "function") {
state = fn({
state,
options: _options,
name,
instance
}) || state;
}
}
},
update: debounce(function() {
return new Promise(function(resolve) {
instance.forceUpdate();
resolve(state);
});
}),
destroy: function destroy() {
cleanupModifierEffects();
isDestroyed = true;
}
};
if (!areValidElements(reference2, popper2)) {
return instance;
}
instance.setOptions(options).then(function(state2) {
if (!isDestroyed && options.onFirstUpdate) {
options.onFirstUpdate(state2);
}
});
function runModifierEffects() {
state.orderedModifiers.forEach(function(_ref) {
var name = _ref.name, _ref$options = _ref.options, options2 = _ref$options === void 0 ? {} : _ref$options, effect2 = _ref.effect;
if (typeof effect2 === "function") {
var cleanupFn = effect2({
state,
name,
instance,
options: options2
});
var noopFn = function noopFn2() {
};
effectCleanupFns.push(cleanupFn || noopFn);
}
});
}
function cleanupModifierEffects() {
effectCleanupFns.forEach(function(fn) {
return fn();
});
effectCleanupFns = [];
}
return instance;
};
}
var defaultModifiers = [
eventListeners,
popperOffsets$1,
computeStyles$1,
applyStyles$1,
offset$1,
flip$1,
preventOverflow$1,
arrow$1,
hide$1
];
var createPopper = popperGenerator({
defaultModifiers
});
getPopperUtilityClass = function(slot) {
return generateUtilityClass("MuiPopper", slot);
};
generateUtilityClasses("MuiPopper", [
"root"
]);
function flipPlacement(placement, direction) {
if (direction === "ltr") {
return placement;
}
switch (placement) {
case "bottom-end":
return "bottom-start";
case "bottom-start":
return "bottom-end";
case "top-end":
return "top-start";
case "top-start":
return "top-end";
default:
return placement;
}
}
function resolveAnchorEl(anchorEl) {
return typeof anchorEl === "function" ? anchorEl() : anchorEl;
}
function isHTMLElement(element) {
return element.nodeType !== void 0;
}
const useUtilityClasses$7 = (ownerState) => {
const { classes } = ownerState;
const slots = {
root: [
"root"
]
};
return composeClasses(slots, getPopperUtilityClass, classes);
};
const defaultPopperOptions = {};
const PopperTooltip = __mf_14(function PopperTooltip2(props, forwardedRef) {
const { anchorEl, children, direction, disablePortal, modifiers, open, placement: initialPlacement, popperOptions, popperRef: popperRefProp, slotProps = {}, slots = {}, TransitionProps, ownerState: ownerStateProp, ...other } = props;
const tooltipRef = __mf_31(null);
const ownRef = useForkRef(tooltipRef, forwardedRef);
const popperRef = __mf_31(null);
const handlePopperRef = useForkRef(popperRef, popperRefProp);
const handlePopperRefRef = __mf_31(handlePopperRef);
useEnhancedEffect(() => {
handlePopperRefRef.current = handlePopperRef;
}, [
handlePopperRef
]);
__mf_26(popperRefProp, () => popperRef.current, []);
const rtlPlacement = flipPlacement(initialPlacement, direction);
const [placement, setPlacement] = __mf_32(rtlPlacement);
const [resolvedAnchorElement, setResolvedAnchorElement] = __mf_32(resolveAnchorEl(anchorEl));
__mf_24(() => {
if (popperRef.current) {
popperRef.current.forceUpdate();
}
});
__mf_24(() => {
if (anchorEl) {
setResolvedAnchorElement(resolveAnchorEl(anchorEl));
}
}, [
anchorEl
]);
useEnhancedEffect(() => {
if (!resolvedAnchorElement || !open) {
return void 0;
}
const handlePopperUpdate = (data) => {
setPlacement(data.placement);
};
let popperModifiers = [
{
name: "preventOverflow",
options: {
altBoundary: disablePortal
}
},
{
name: "flip",
options: {
altBoundary: disablePortal
}
},
{
name: "onUpdate",
enabled: true,
phase: "afterWrite",
fn: ({ state }) => {
handlePopperUpdate(state);
}
}
];
if (modifiers != null) {
popperModifiers = popperModifiers.concat(modifiers);
}
if (popperOptions && popperOptions.modifiers != null) {
popperModifiers = popperModifiers.concat(popperOptions.modifiers);
}
const popper2 = createPopper(resolvedAnchorElement, tooltipRef.current, {
placement: rtlPlacement,
...popperOptions,
modifiers: popperModifiers
});
handlePopperRefRef.current(popper2);
return () => {
popper2.destroy();
handlePopperRefRef.current(null);
};
}, [
resolvedAnchorElement,
disablePortal,
modifiers,
open,
popperOptions,
rtlPlacement
]);
const childProps = {
placement
};
if (TransitionProps !== null) {
childProps.TransitionProps = TransitionProps;
}
const classes = useUtilityClasses$7(props);
const Root = slots.root ?? "div";
const rootProps = useSlotProps({
elementType: Root,
externalSlotProps: slotProps.root,
externalForwardedProps: other,
additionalProps: {
role: "tooltip",
ref: ownRef
},
ownerState: props,
className: classes.root
});
return jsxRuntimeExports.jsx(Root, {
...rootProps,
children: typeof children === "function" ? children(childProps) : children
});
});
const Popper$1 = __mf_14(function Popper2(props, forwardedRef) {
const { anchorEl, children, container: containerProp, direction = "ltr", disablePortal = false, keepMounted = false, modifiers, open, placement = "bottom", popperOptions = defaultPopperOptions, popperRef, style, transition = false, slotProps = {}, slots = {}, ...other } = props;
const [exited, setExited] = __mf_32(true);
const handleEnter = () => {
setExited(false);
};
const handleExited = () => {
setExited(true);
};
if (!keepMounted && !open && (!transition || exited)) {
return null;
}
let container;
if (containerProp) {
container = containerProp;
} else if (anchorEl) {
const resolvedAnchorEl = resolveAnchorEl(anchorEl);
container = resolvedAnchorEl && isHTMLElement(resolvedAnchorEl) ? ownerDocument(resolvedAnchorEl).body : ownerDocument(null).body;
}
const display = !open && keepMounted && (!transition || exited) ? "none" : void 0;
const transitionProps = transition ? {
in: open,
onEnter: handleEnter,
onExited: handleExited
} : void 0;
return jsxRuntimeExports.jsx(Portal, {
disablePortal,
container,
children: jsxRuntimeExports.jsx(PopperTooltip, {
anchorEl,
direction,
disablePortal,
modifiers,
ref: forwardedRef,
open: transition ? !exited : open,
placement,
popperOptions,
popperRef,
slotProps,
slots,
...other,
style: {
position: "fixed",
top: 0,
left: 0,
display,
...style
},
TransitionProps: transitionProps,
children
})
});
});
const PopperRoot = styled(Popper$1, {
name: "MuiPopper",
slot: "Root",
overridesResolver: (props, styles2) => styles2.root
})({});
Popper = __mf_14(function Popper2(inProps, ref) {
const isRtl = useRtl();
const props = useDefaultProps({
props: inProps,
name: "MuiPopper"
});
const { anchorEl, component, components, componentsProps, container, disablePortal, keepMounted, modifiers, open, placement, popperOptions, popperRef, transition, slots, slotProps, ...other } = props;
const RootComponent = (slots == null ? void 0 : slots.root) ?? (components == null ? void 0 : components.Root);
const otherProps = {
anchorEl,
container,
disablePortal,
keepMounted,
modifiers,
open,
placement,
popperOptions,
popperRef,
transition,
...other
};
return jsxRuntimeExports.jsx(PopperRoot, {
as: component,
direction: isRtl ? "rtl" : "ltr",
slots: {
root: RootComponent
},
slotProps: slotProps ?? componentsProps,
...otherProps,
ref
});
});
getButtonUtilityClass = function(slot) {
return generateUtilityClass("MuiButton", slot);
};
buttonClasses = generateUtilityClasses("MuiButton", [
"root",
"text",
"textInherit",
"textPrimary",
"textSecondary",
"textSuccess",
"textError",
"textInfo",
"textWarning",
"outlined",
"outlinedInherit",
"outlinedPrimary",
"outlinedSecondary",
"outlinedSuccess",
"outlinedError",
"outlinedInfo",
"outlinedWarning",
"contained",
"containedInherit",
"containedPrimary",
"containedSecondary",
"containedSuccess",
"containedError",
"containedInfo",
"containedWarning",
"disableElevation",
"focusVisible",
"disabled",
"colorInherit",
"colorPrimary",
"colorSecondary",
"colorSuccess",
"colorError",
"colorInfo",
"colorWarning",
"textSizeSmall",
"textSizeMedium",
"textSizeLarge",
"outlinedSizeSmall",
"outlinedSizeMedium",
"outlinedSizeLarge",
"containedSizeSmall",
"containedSizeMedium",
"containedSizeLarge",
"sizeMedium",
"sizeSmall",
"sizeLarge",
"fullWidth",
"startIcon",
"endIcon",
"icon",
"iconSizeSmall",
"iconSizeMedium",
"iconSizeLarge",
"loading",
"loadingWrapper",
"loadingIconPlaceholder",
"loadingIndicator",
"loadingPositionCenter",
"loadingPositionStart",
"loadingPositionEnd"
]);
ButtonGroupContext = __mf_10({});
ButtonGroupButtonContext = __mf_10(void 0);
const useUtilityClasses$6 = (ownerState) => {
const { color, disableElevation, fullWidth, size, variant, loading, loadingPosition, classes } = ownerState;
const slots = {
root: [
"root",
loading && "loading",
variant,
`${variant}${capitalize(color)}`,
`size${capitalize(size)}`,
`${variant}Size${capitalize(size)}`,
`color${capitalize(color)}`,
disableElevation && "disableElevation",
fullWidth && "fullWidth",
loading && `loadingPosition${capitalize(loadingPosition)}`
],
startIcon: [
"icon",
"startIcon",
`iconSize${capitalize(size)}`
],
endIcon: [
"icon",
"endIcon",
`iconSize${capitalize(size)}`
],
loadingIndicator: [
"loadingIndicator"
],
loadingWrapper: [
"loadingWrapper"
]
};
const composedClasses = composeClasses(slots, getButtonUtilityClass, classes);
return {
...classes,
...composedClasses
};
};
const commonIconStyles = [
{
props: {
size: "small"
},
style: {
"& > *:nth-of-type(1)": {
fontSize: 18
}
}
},
{
props: {
size: "medium"
},
style: {
"& > *:nth-of-type(1)": {
fontSize: 20
}
}
},
{
props: {
size: "large"
},
style: {
"& > *:nth-of-type(1)": {
fontSize: 22
}
}
}
];
const ButtonRoot = styled(ButtonBase, {
shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
name: "MuiButton",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
styles2[ownerState.variant],
styles2[`${ownerState.variant}${capitalize(ownerState.color)}`],
styles2[`size${capitalize(ownerState.size)}`],
styles2[`${ownerState.variant}Size${capitalize(ownerState.size)}`],
ownerState.color === "inherit" && styles2.colorInherit,
ownerState.disableElevation && styles2.disableElevation,
ownerState.fullWidth && styles2.fullWidth,
ownerState.loading && styles2.loading
];
}
})(memoTheme(({ theme }) => {
const inheritContainedBackgroundColor = theme.palette.mode === "light" ? theme.palette.grey[300] : theme.palette.grey[800];
const inheritContainedHoverBackgroundColor = theme.palette.mode === "light" ? theme.palette.grey.A100 : theme.palette.grey[700];
return {
...theme.typography.button,
minWidth: 64,
padding: "6px 16px",
border: 0,
borderRadius: (theme.vars || theme).shape.borderRadius,
transition: theme.transitions.create([
"background-color",
"box-shadow",
"border-color",
"color"
], {
duration: theme.transitions.duration.short
}),
"&:hover": {
textDecoration: "none"
},
[`&.${buttonClasses.disabled}`]: {
color: (theme.vars || theme).palette.action.disabled
},
variants: [
{
props: {
variant: "contained"
},
style: {
color: `var(--variant-containedColor)`,
backgroundColor: `var(--variant-containedBg)`,
boxShadow: (theme.vars || theme).shadows[2],
"&:hover": {
boxShadow: (theme.vars || theme).shadows[4],
"@media (hover: none)": {
boxShadow: (theme.vars || theme).shadows[2]
}
},
"&:active": {
boxShadow: (theme.vars || theme).shadows[8]
},
[`&.${buttonClasses.focusVisible}`]: {
boxShadow: (theme.vars || theme).shadows[6]
},
[`&.${buttonClasses.disabled}`]: {
color: (theme.vars || theme).palette.action.disabled,
boxShadow: (theme.vars || theme).shadows[0],
backgroundColor: (theme.vars || theme).palette.action.disabledBackground
}
}
},
{
props: {
variant: "outlined"
},
style: {
padding: "5px 15px",
border: "1px solid currentColor",
borderColor: `var(--variant-outlinedBorder, currentColor)`,
backgroundColor: `var(--variant-outlinedBg)`,
color: `var(--variant-outlinedColor)`,
[`&.${buttonClasses.disabled}`]: {
border: `1px solid ${(theme.vars || theme).palette.action.disabledBackground}`
}
}
},
{
props: {
variant: "text"
},
style: {
padding: "6px 8px",
color: `var(--variant-textColor)`,
backgroundColor: `var(--variant-textBg)`
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
color
},
style: {
"--variant-textColor": (theme.vars || theme).palette[color].main,
"--variant-outlinedColor": (theme.vars || theme).palette[color].main,
"--variant-outlinedBorder": theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / 0.5)` : alpha(theme.palette[color].main, 0.5),
"--variant-containedColor": (theme.vars || theme).palette[color].contrastText,
"--variant-containedBg": (theme.vars || theme).palette[color].main,
"@media (hover: hover)": {
"&:hover": {
"--variant-containedBg": (theme.vars || theme).palette[color].dark,
"--variant-textBg": theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette[color].main, theme.palette.action.hoverOpacity),
"--variant-outlinedBorder": (theme.vars || theme).palette[color].main,
"--variant-outlinedBg": theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette[color].main, theme.palette.action.hoverOpacity)
}
}
}
})),
{
props: {
color: "inherit"
},
style: {
color: "inherit",
borderColor: "currentColor",
"--variant-containedBg": theme.vars ? theme.vars.palette.Button.inheritContainedBg : inheritContainedBackgroundColor,
"@media (hover: hover)": {
"&:hover": {
"--variant-containedBg": theme.vars ? theme.vars.palette.Button.inheritContainedHoverBg : inheritContainedHoverBackgroundColor,
"--variant-textBg": theme.vars ? `rgba(${theme.vars.palette.text.primaryChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.text.primary, theme.palette.action.hoverOpacity),
"--variant-outlinedBg": theme.vars ? `rgba(${theme.vars.palette.text.primaryChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.text.primary, theme.palette.action.hoverOpacity)
}
}
}
},
{
props: {
size: "small",
variant: "text"
},
style: {
padding: "4px 5px",
fontSize: theme.typography.pxToRem(13)
}
},
{
props: {
size: "large",
variant: "text"
},
style: {
padding: "8px 11px",
fontSize: theme.typography.pxToRem(15)
}
},
{
props: {
size: "small",
variant: "outlined"
},
style: {
padding: "3px 9px",
fontSize: theme.typography.pxToRem(13)
}
},
{
props: {
size: "large",
variant: "outlined"
},
style: {
padding: "7px 21px",
fontSize: theme.typography.pxToRem(15)
}
},
{
props: {
size: "small",
variant: "contained"
},
style: {
padding: "4px 10px",
fontSize: theme.typography.pxToRem(13)
}
},
{
props: {
size: "large",
variant: "contained"
},
style: {
padding: "8px 22px",
fontSize: theme.typography.pxToRem(15)
}
},
{
props: {
disableElevation: true
},
style: {
boxShadow: "none",
"&:hover": {
boxShadow: "none"
},
[`&.${buttonClasses.focusVisible}`]: {
boxShadow: "none"
},
"&:active": {
boxShadow: "none"
},
[`&.${buttonClasses.disabled}`]: {
boxShadow: "none"
}
}
},
{
props: {
fullWidth: true
},
style: {
width: "100%"
}
},
{
props: {
loadingPosition: "center"
},
style: {
transition: theme.transitions.create([
"background-color",
"box-shadow",
"border-color"
], {
duration: theme.transitions.duration.short
}),
[`&.${buttonClasses.loading}`]: {
color: "transparent"
}
}
}
]
};
}));
const ButtonStartIcon = styled("span", {
name: "MuiButton",
slot: "StartIcon",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.startIcon,
ownerState.loading && styles2.startIconLoadingStart,
styles2[`iconSize${capitalize(ownerState.size)}`]
];
}
})(({ theme }) => ({
display: "inherit",
marginRight: 8,
marginLeft: -4,
variants: [
{
props: {
size: "small"
},
style: {
marginLeft: -2
}
},
{
props: {
loadingPosition: "start",
loading: true
},
style: {
transition: theme.transitions.create([
"opacity"
], {
duration: theme.transitions.duration.short
}),
opacity: 0
}
},
{
props: {
loadingPosition: "start",
loading: true,
fullWidth: true
},
style: {
marginRight: -8
}
},
...commonIconStyles
]
}));
const ButtonEndIcon = styled("span", {
name: "MuiButton",
slot: "EndIcon",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.endIcon,
ownerState.loading && styles2.endIconLoadingEnd,
styles2[`iconSize${capitalize(ownerState.size)}`]
];
}
})(({ theme }) => ({
display: "inherit",
marginRight: -4,
marginLeft: 8,
variants: [
{
props: {
size: "small"
},
style: {
marginRight: -2
}
},
{
props: {
loadingPosition: "end",
loading: true
},
style: {
transition: theme.transitions.create([
"opacity"
], {
duration: theme.transitions.duration.short
}),
opacity: 0
}
},
{
props: {
loadingPosition: "end",
loading: true,
fullWidth: true
},
style: {
marginLeft: -8
}
},
...commonIconStyles
]
}));
const ButtonLoadingIndicator = styled("span", {
name: "MuiButton",
slot: "LoadingIndicator",
overridesResolver: (props, styles2) => styles2.loadingIndicator
})(({ theme }) => ({
display: "none",
position: "absolute",
visibility: "visible",
variants: [
{
props: {
loading: true
},
style: {
display: "flex"
}
},
{
props: {
loadingPosition: "start"
},
style: {
left: 14
}
},
{
props: {
loadingPosition: "start",
size: "small"
},
style: {
left: 10
}
},
{
props: {
variant: "text",
loadingPosition: "start"
},
style: {
left: 6
}
},
{
props: {
loadingPosition: "center"
},
style: {
left: "50%",
transform: "translate(-50%)",
color: (theme.vars || theme).palette.action.disabled
}
},
{
props: {
loadingPosition: "end"
},
style: {
right: 14
}
},
{
props: {
loadingPosition: "end",
size: "small"
},
style: {
right: 10
}
},
{
props: {
variant: "text",
loadingPosition: "end"
},
style: {
right: 6
}
},
{
props: {
loadingPosition: "start",
fullWidth: true
},
style: {
position: "relative",
left: -10
}
},
{
props: {
loadingPosition: "end",
fullWidth: true
},
style: {
position: "relative",
right: -10
}
}
]
}));
const ButtonLoadingIconPlaceholder = styled("span", {
name: "MuiButton",
slot: "LoadingIconPlaceholder",
overridesResolver: (props, styles2) => styles2.loadingIconPlaceholder
})({
display: "inline-block",
width: "1em",
height: "1em"
});
Button = __mf_14(function Button2(inProps, ref) {
const contextProps = __mf_21(ButtonGroupContext);
const buttonGroupButtonContextPositionClassName = __mf_21(ButtonGroupButtonContext);
const resolvedProps = resolveProps(contextProps, inProps);
const props = useDefaultProps({
props: resolvedProps,
name: "MuiButton"
});
const { children, color = "primary", component = "button", className, disabled = false, disableElevation = false, disableFocusRipple = false, endIcon: endIconProp, focusVisibleClassName, fullWidth = false, id: idProp, loading = null, loadingIndicator: loadingIndicatorProp, loadingPosition = "center", size = "medium", startIcon: startIconProp, type, variant = "text", ...other } = props;
const loadingId = useId(idProp);
const loadingIndicator = loadingIndicatorProp ?? jsxRuntimeExports.jsx(CircularProgress, {
"aria-labelledby": loadingId,
color: "inherit",
size: 16
});
const ownerState = {
...props,
color,
component,
disabled,
disableElevation,
disableFocusRipple,
fullWidth,
loading,
loadingIndicator,
loadingPosition,
size,
type,
variant
};
const classes = useUtilityClasses$6(ownerState);
const startIcon = (startIconProp || loading && loadingPosition === "start") && jsxRuntimeExports.jsx(ButtonStartIcon, {
className: classes.startIcon,
ownerState,
children: startIconProp || jsxRuntimeExports.jsx(ButtonLoadingIconPlaceholder, {
className: classes.loadingIconPlaceholder,
ownerState
})
});
const endIcon = (endIconProp || loading && loadingPosition === "end") && jsxRuntimeExports.jsx(ButtonEndIcon, {
className: classes.endIcon,
ownerState,
children: endIconProp || jsxRuntimeExports.jsx(ButtonLoadingIconPlaceholder, {
className: classes.loadingIconPlaceholder,
ownerState
})
});
const positionClassName = buttonGroupButtonContextPositionClassName || "";
const loader = typeof loading === "boolean" ? jsxRuntimeExports.jsx("span", {
className: classes.loadingWrapper,
style: {
display: "contents"
},
children: loading && jsxRuntimeExports.jsx(ButtonLoadingIndicator, {
className: classes.loadingIndicator,
ownerState,
children: loadingIndicator
})
}) : null;
return jsxRuntimeExports.jsxs(ButtonRoot, {
ownerState,
className: clsx(contextProps.className, classes.root, className, positionClassName),
component,
disabled: disabled || loading,
focusRipple: !disableFocusRipple,
focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
ref,
type,
id: loading ? loadingId : idProp,
...other,
classes,
children: [
startIcon,
loadingPosition !== "end" && loader,
children,
loadingPosition === "end" && loader,
endIcon
]
});
});
getDialogActionsUtilityClass = function(slot) {
return generateUtilityClass("MuiDialogActions", slot);
};
dialogActionsClasses = generateUtilityClasses("MuiDialogActions", [
"root",
"spacing"
]);
const useUtilityClasses$5 = (ownerState) => {
const { classes, disableSpacing } = ownerState;
const slots = {
root: [
"root",
!disableSpacing && "spacing"
]
};
return composeClasses(slots, getDialogActionsUtilityClass, classes);
};
const DialogActionsRoot = styled("div", {
name: "MuiDialogActions",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
!ownerState.disableSpacing && styles2.spacing
];
}
})({
display: "flex",
alignItems: "center",
padding: 8,
justifyContent: "flex-end",
flex: "0 0 auto",
variants: [
{
props: ({ ownerState }) => !ownerState.disableSpacing,
style: {
"& > :not(style) ~ :not(style)": {
marginLeft: 8
}
}
}
]
});
DialogActions = __mf_14(function DialogActions2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiDialogActions"
});
const { className, disableSpacing = false, ...other } = props;
const ownerState = {
...props,
disableSpacing
};
const classes = useUtilityClasses$5(ownerState);
return jsxRuntimeExports.jsx(DialogActionsRoot, {
className: clsx(classes.root, className),
ownerState,
ref,
...other
});
});
getListItemUtilityClass = function(slot) {
return generateUtilityClass("MuiListItem", slot);
};
listItemClasses = generateUtilityClasses("MuiListItem", [
"root",
"container",
"dense",
"alignItemsFlexStart",
"divider",
"gutters",
"padding",
"secondaryAction"
]);
getListItemButtonUtilityClass = function(slot) {
return generateUtilityClass("MuiListItemButton", slot);
};
listItemButtonClasses = generateUtilityClasses("MuiListItemButton", [
"root",
"focusVisible",
"dense",
"alignItemsFlexStart",
"disabled",
"divider",
"gutters",
"selected"
]);
getListItemSecondaryActionClassesUtilityClass = function(slot) {
return generateUtilityClass("MuiListItemSecondaryAction", slot);
};
listItemSecondaryActionClasses = generateUtilityClasses("MuiListItemSecondaryAction", [
"root",
"disableGutters"
]);
const useUtilityClasses$4 = (ownerState) => {
const { disableGutters, classes } = ownerState;
const slots = {
root: [
"root",
disableGutters && "disableGutters"
]
};
return composeClasses(slots, getListItemSecondaryActionClassesUtilityClass, classes);
};
const ListItemSecondaryActionRoot = styled("div", {
name: "MuiListItemSecondaryAction",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.disableGutters && styles2.disableGutters
];
}
})({
position: "absolute",
right: 16,
top: "50%",
transform: "translateY(-50%)",
variants: [
{
props: ({ ownerState }) => ownerState.disableGutters,
style: {
right: 0
}
}
]
});
ListItemSecondaryAction = __mf_14(function ListItemSecondaryAction2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiListItemSecondaryAction"
});
const { className, ...other } = props;
const context = __mf_21(ListContext);
const ownerState = {
...props,
disableGutters: context.disableGutters
};
const classes = useUtilityClasses$4(ownerState);
return jsxRuntimeExports.jsx(ListItemSecondaryActionRoot, {
className: clsx(classes.root, className),
ownerState,
ref,
...other
});
});
ListItemSecondaryAction.muiName = "ListItemSecondaryAction";
const overridesResolver = (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.dense && styles2.dense,
ownerState.alignItems === "flex-start" && styles2.alignItemsFlexStart,
ownerState.divider && styles2.divider,
!ownerState.disableGutters && styles2.gutters,
!ownerState.disablePadding && styles2.padding,
ownerState.hasSecondaryAction && styles2.secondaryAction
];
};
const useUtilityClasses$3 = (ownerState) => {
const { alignItems, classes, dense, disableGutters, disablePadding, divider, hasSecondaryAction } = ownerState;
const slots = {
root: [
"root",
dense && "dense",
!disableGutters && "gutters",
!disablePadding && "padding",
divider && "divider",
alignItems === "flex-start" && "alignItemsFlexStart",
hasSecondaryAction && "secondaryAction"
],
container: [
"container"
]
};
return composeClasses(slots, getListItemUtilityClass, classes);
};
const ListItemRoot = styled("div", {
name: "MuiListItem",
slot: "Root",
overridesResolver
})(memoTheme(({ theme }) => ({
display: "flex",
justifyContent: "flex-start",
alignItems: "center",
position: "relative",
textDecoration: "none",
width: "100%",
boxSizing: "border-box",
textAlign: "left",
variants: [
{
props: ({ ownerState }) => !ownerState.disablePadding,
style: {
paddingTop: 8,
paddingBottom: 8
}
},
{
props: ({ ownerState }) => !ownerState.disablePadding && ownerState.dense,
style: {
paddingTop: 4,
paddingBottom: 4
}
},
{
props: ({ ownerState }) => !ownerState.disablePadding && !ownerState.disableGutters,
style: {
paddingLeft: 16,
paddingRight: 16
}
},
{
props: ({ ownerState }) => !ownerState.disablePadding && !!ownerState.secondaryAction,
style: {
paddingRight: 48
}
},
{
props: ({ ownerState }) => !!ownerState.secondaryAction,
style: {
[`& > .${listItemButtonClasses.root}`]: {
paddingRight: 48
}
}
},
{
props: {
alignItems: "flex-start"
},
style: {
alignItems: "flex-start"
}
},
{
props: ({ ownerState }) => ownerState.divider,
style: {
borderBottom: `1px solid ${(theme.vars || theme).palette.divider}`,
backgroundClip: "padding-box"
}
},
{
props: ({ ownerState }) => ownerState.button,
style: {
transition: theme.transitions.create("background-color", {
duration: theme.transitions.duration.shortest
}),
"&:hover": {
textDecoration: "none",
backgroundColor: (theme.vars || theme).palette.action.hover,
"@media (hover: none)": {
backgroundColor: "transparent"
}
}
}
},
{
props: ({ ownerState }) => ownerState.hasSecondaryAction,
style: {
paddingRight: 48
}
}
]
})));
const ListItemContainer = styled("li", {
name: "MuiListItem",
slot: "Container",
overridesResolver: (props, styles2) => styles2.container
})({
position: "relative"
});
ListItem = __mf_14(function ListItem2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiListItem"
});
const { alignItems = "center", children: childrenProp, className, component: componentProp, components = {}, componentsProps = {}, ContainerComponent = "li", ContainerProps: { className: ContainerClassName, ...ContainerProps } = {}, dense = false, disableGutters = false, disablePadding = false, divider = false, secondaryAction, slotProps = {}, slots = {}, ...other } = props;
const context = __mf_21(ListContext);
const childContext = __mf_29(() => ({
dense: dense || context.dense || false,
alignItems,
disableGutters
}), [
alignItems,
context.dense,
dense,
disableGutters
]);
const listItemRef = __mf_31(null);
const children = __mf_0.toArray(childrenProp);
const hasSecondaryAction = children.length && isMuiElement(children[children.length - 1], [
"ListItemSecondaryAction"
]);
const ownerState = {
...props,
alignItems,
dense: childContext.dense,
disableGutters,
disablePadding,
divider,
hasSecondaryAction
};
const classes = useUtilityClasses$3(ownerState);
const handleRef = useForkRef(listItemRef, ref);
const Root = slots.root || components.Root || ListItemRoot;
const rootProps = slotProps.root || componentsProps.root || {};
const componentProps = {
className: clsx(classes.root, rootProps.className, className),
...other
};
let Component = componentProp || "li";
if (hasSecondaryAction) {
Component = !componentProps.component && !componentProp ? "div" : Component;
if (ContainerComponent === "li") {
if (Component === "li") {
Component = "div";
} else if (componentProps.component === "li") {
componentProps.component = "div";
}
}
return jsxRuntimeExports.jsx(ListContext.Provider, {
value: childContext,
children: jsxRuntimeExports.jsxs(ListItemContainer, {
as: ContainerComponent,
className: clsx(classes.container, ContainerClassName),
ref: handleRef,
ownerState,
...ContainerProps,
children: [
jsxRuntimeExports.jsx(Root, {
...rootProps,
...!isHostComponent(Root) && {
as: Component,
ownerState: {
...ownerState,
...rootProps.ownerState
}
},
...componentProps,
children
}),
children.pop()
]
})
});
}
return jsxRuntimeExports.jsx(ListContext.Provider, {
value: childContext,
children: jsxRuntimeExports.jsxs(Root, {
...rootProps,
as: Component,
ref: handleRef,
...!isHostComponent(Root) && {
ownerState: {
...ownerState,
...rootProps.ownerState
}
},
...componentProps,
children: [
children,
secondaryAction && jsxRuntimeExports.jsx(ListItemSecondaryAction, {
children: secondaryAction
})
]
})
});
});
const CancelIcon = createSvgIcon(jsxRuntimeExports.jsx("path", {
d: "M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"
}), "Cancel");
getChipUtilityClass = function(slot) {
return generateUtilityClass("MuiChip", slot);
};
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"
]);
const useUtilityClasses$2 = (ownerState) => {
const { classes, disabled, size, color, iconColor, onDelete, clickable, variant } = ownerState;
const slots = {
root: [
"root",
variant,
disabled && "disabled",
`size${capitalize(size)}`,
`color${capitalize(color)}`,
clickable && "clickable",
clickable && `clickableColor${capitalize(color)}`,
onDelete && "deletable",
onDelete && `deletableColor${capitalize(color)}`,
`${variant}${capitalize(color)}`
],
label: [
"label",
`label${capitalize(size)}`
],
avatar: [
"avatar",
`avatar${capitalize(size)}`,
`avatarColor${capitalize(color)}`
],
icon: [
"icon",
`icon${capitalize(size)}`,
`iconColor${capitalize(iconColor)}`
],
deleteIcon: [
"deleteIcon",
`deleteIcon${capitalize(size)}`,
`deleteIconColor${capitalize(color)}`,
`deleteIcon${capitalize(variant)}Color${capitalize(color)}`
]
};
return composeClasses(slots, getChipUtilityClass, classes);
};
const ChipRoot = styled("div", {
name: "MuiChip",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
const { color, iconColor, clickable, onDelete, size, variant } = ownerState;
return [
{
[`& .${chipClasses.avatar}`]: styles2.avatar
},
{
[`& .${chipClasses.avatar}`]: styles2[`avatar${capitalize(size)}`]
},
{
[`& .${chipClasses.avatar}`]: styles2[`avatarColor${capitalize(color)}`]
},
{
[`& .${chipClasses.icon}`]: styles2.icon
},
{
[`& .${chipClasses.icon}`]: styles2[`icon${capitalize(size)}`]
},
{
[`& .${chipClasses.icon}`]: styles2[`iconColor${capitalize(iconColor)}`]
},
{
[`& .${chipClasses.deleteIcon}`]: styles2.deleteIcon
},
{
[`& .${chipClasses.deleteIcon}`]: styles2[`deleteIcon${capitalize(size)}`]
},
{
[`& .${chipClasses.deleteIcon}`]: styles2[`deleteIconColor${capitalize(color)}`]
},
{
[`& .${chipClasses.deleteIcon}`]: styles2[`deleteIcon${capitalize(variant)}Color${capitalize(color)}`]
},
styles2.root,
styles2[`size${capitalize(size)}`],
styles2[`color${capitalize(color)}`],
clickable && styles2.clickable,
clickable && color !== "default" && styles2[`clickableColor${capitalize(color)})`],
onDelete && styles2.deletable,
onDelete && color !== "default" && styles2[`deletableColor${capitalize(color)}`],
styles2[variant],
styles2[`${variant}${capitalize(color)}`]
];
}
})(memoTheme(({ theme }) => {
const textColor = theme.palette.mode === "light" ? theme.palette.grey[700] : theme.palette.grey[300];
return {
maxWidth: "100%",
fontFamily: theme.typography.fontFamily,
fontSize: theme.typography.pxToRem(13),
display: "inline-flex",
alignItems: "center",
justifyContent: "center",
height: 32,
color: (theme.vars || theme).palette.text.primary,
backgroundColor: (theme.vars || theme).palette.action.selected,
borderRadius: 32 / 2,
whiteSpace: "nowrap",
transition: theme.transitions.create([
"background-color",
"box-shadow"
]),
cursor: "unset",
outline: 0,
textDecoration: "none",
border: 0,
padding: 0,
verticalAlign: "middle",
boxSizing: "border-box",
[`&.${chipClasses.disabled}`]: {
opacity: (theme.vars || theme).palette.action.disabledOpacity,
pointerEvents: "none"
},
[`& .${chipClasses.avatar}`]: {
marginLeft: 5,
marginRight: -6,
width: 24,
height: 24,
color: theme.vars ? theme.vars.palette.Chip.defaultAvatarColor : textColor,
fontSize: theme.typography.pxToRem(12)
},
[`& .${chipClasses.avatarColorPrimary}`]: {
color: (theme.vars || theme).palette.primary.contrastText,
backgroundColor: (theme.vars || theme).palette.primary.dark
},
[`& .${chipClasses.avatarColorSecondary}`]: {
color: (theme.vars || theme).palette.secondary.contrastText,
backgroundColor: (theme.vars || theme).palette.secondary.dark
},
[`& .${chipClasses.avatarSmall}`]: {
marginLeft: 4,
marginRight: -4,
width: 18,
height: 18,
fontSize: theme.typography.pxToRem(10)
},
[`& .${chipClasses.icon}`]: {
marginLeft: 5,
marginRight: -6
},
[`& .${chipClasses.deleteIcon}`]: {
WebkitTapHighlightColor: "transparent",
color: theme.vars ? `rgba(${theme.vars.palette.text.primaryChannel} / 0.26)` : alpha(theme.palette.text.primary, 0.26),
fontSize: 22,
cursor: "pointer",
margin: "0 5px 0 -6px",
"&:hover": {
color: theme.vars ? `rgba(${theme.vars.palette.text.primaryChannel} / 0.4)` : alpha(theme.palette.text.primary, 0.4)
}
},
variants: [
{
props: {
size: "small"
},
style: {
height: 24,
[`& .${chipClasses.icon}`]: {
fontSize: 18,
marginLeft: 4,
marginRight: -4
},
[`& .${chipClasses.deleteIcon}`]: {
fontSize: 16,
marginRight: 4,
marginLeft: -4
}
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter([
"contrastText"
])).map(([color]) => {
return {
props: {
color
},
style: {
backgroundColor: (theme.vars || theme).palette[color].main,
color: (theme.vars || theme).palette[color].contrastText,
[`& .${chipClasses.deleteIcon}`]: {
color: theme.vars ? `rgba(${theme.vars.palette[color].contrastTextChannel} / 0.7)` : alpha(theme.palette[color].contrastText, 0.7),
"&:hover, &:active": {
color: (theme.vars || theme).palette[color].contrastText
}
}
}
};
}),
{
props: (props) => props.iconColor === props.color,
style: {
[`& .${chipClasses.icon}`]: {
color: theme.vars ? theme.vars.palette.Chip.defaultIconColor : textColor
}
}
},
{
props: (props) => props.iconColor === props.color && props.color !== "default",
style: {
[`& .${chipClasses.icon}`]: {
color: "inherit"
}
}
},
{
props: {
onDelete: true
},
style: {
[`&.${chipClasses.focusVisible}`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.selectedChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.focusOpacity}))` : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
}
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter([
"dark"
])).map(([color]) => {
return {
props: {
color,
onDelete: true
},
style: {
[`&.${chipClasses.focusVisible}`]: {
background: (theme.vars || theme).palette[color].dark
}
}
};
}),
{
props: {
clickable: true
},
style: {
userSelect: "none",
WebkitTapHighlightColor: "transparent",
cursor: "pointer",
"&:hover": {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.selectedChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.hoverOpacity}))` : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity)
},
[`&.${chipClasses.focusVisible}`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.selectedChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.focusOpacity}))` : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
},
"&:active": {
boxShadow: (theme.vars || theme).shadows[1]
}
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter([
"dark"
])).map(([color]) => ({
props: {
color,
clickable: true
},
style: {
[`&:hover, &.${chipClasses.focusVisible}`]: {
backgroundColor: (theme.vars || theme).palette[color].dark
}
}
})),
{
props: {
variant: "outlined"
},
style: {
backgroundColor: "transparent",
border: theme.vars ? `1px solid ${theme.vars.palette.Chip.defaultBorder}` : `1px solid ${theme.palette.mode === "light" ? theme.palette.grey[400] : theme.palette.grey[700]}`,
[`&.${chipClasses.clickable}:hover`]: {
backgroundColor: (theme.vars || theme).palette.action.hover
},
[`&.${chipClasses.focusVisible}`]: {
backgroundColor: (theme.vars || theme).palette.action.focus
},
[`& .${chipClasses.avatar}`]: {
marginLeft: 4
},
[`& .${chipClasses.avatarSmall}`]: {
marginLeft: 2
},
[`& .${chipClasses.icon}`]: {
marginLeft: 4
},
[`& .${chipClasses.iconSmall}`]: {
marginLeft: 2
},
[`& .${chipClasses.deleteIcon}`]: {
marginRight: 5
},
[`& .${chipClasses.deleteIconSmall}`]: {
marginRight: 3
}
}
},
...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color]) => ({
props: {
variant: "outlined",
color
},
style: {
color: (theme.vars || theme).palette[color].main,
border: `1px solid ${theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / 0.7)` : alpha(theme.palette[color].main, 0.7)}`,
[`&.${chipClasses.clickable}:hover`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette[color].main, theme.palette.action.hoverOpacity)
},
[`&.${chipClasses.focusVisible}`]: {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / ${theme.vars.palette.action.focusOpacity})` : alpha(theme.palette[color].main, theme.palette.action.focusOpacity)
},
[`& .${chipClasses.deleteIcon}`]: {
color: theme.vars ? `rgba(${theme.vars.palette[color].mainChannel} / 0.7)` : alpha(theme.palette[color].main, 0.7),
"&:hover, &:active": {
color: (theme.vars || theme).palette[color].main
}
}
}
}))
]
};
}));
const ChipLabel = styled("span", {
name: "MuiChip",
slot: "Label",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
const { size } = ownerState;
return [
styles2.label,
styles2[`label${capitalize(size)}`]
];
}
})({
overflow: "hidden",
textOverflow: "ellipsis",
paddingLeft: 12,
paddingRight: 12,
whiteSpace: "nowrap",
variants: [
{
props: {
variant: "outlined"
},
style: {
paddingLeft: 11,
paddingRight: 11
}
},
{
props: {
size: "small"
},
style: {
paddingLeft: 8,
paddingRight: 8
}
},
{
props: {
size: "small",
variant: "outlined"
},
style: {
paddingLeft: 7,
paddingRight: 7
}
}
]
});
function isDeleteKeyboardEvent(keyboardEvent) {
return keyboardEvent.key === "Backspace" || keyboardEvent.key === "Delete";
}
Chip = __mf_14(function Chip2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiChip"
});
const { avatar: avatarProp, className, clickable: clickableProp, color = "default", component: ComponentProp, deleteIcon: deleteIconProp, disabled = false, icon: iconProp, label, onClick, onDelete, onKeyDown, onKeyUp, size = "medium", variant = "filled", tabIndex, skipFocusWhenDisabled = false, ...other } = props;
const chipRef = __mf_31(null);
const handleRef = useForkRef(chipRef, ref);
const handleDeleteIconClick = (event) => {
event.stopPropagation();
if (onDelete) {
onDelete(event);
}
};
const handleKeyDown = (event) => {
if (event.currentTarget === event.target && isDeleteKeyboardEvent(event)) {
event.preventDefault();
}
if (onKeyDown) {
onKeyDown(event);
}
};
const handleKeyUp = (event) => {
if (event.currentTarget === event.target) {
if (onDelete && isDeleteKeyboardEvent(event)) {
onDelete(event);
}
}
if (onKeyUp) {
onKeyUp(event);
}
};
const clickable = clickableProp !== false && onClick ? true : clickableProp;
const component = clickable || onDelete ? ButtonBase : ComponentProp || "div";
const ownerState = {
...props,
component,
disabled,
size,
color,
iconColor: __mf_15(iconProp) ? iconProp.props.color || color : color,
onDelete: !!onDelete,
clickable,
variant
};
const classes = useUtilityClasses$2(ownerState);
const moreProps = component === ButtonBase ? {
component: ComponentProp || "div",
focusVisibleClassName: classes.focusVisible,
...onDelete && {
disableRipple: true
}
} : {};
let deleteIcon = null;
if (onDelete) {
deleteIcon = deleteIconProp && __mf_15(deleteIconProp) ? __mf_9(deleteIconProp, {
className: clsx(deleteIconProp.props.className, classes.deleteIcon),
onClick: handleDeleteIconClick
}) : jsxRuntimeExports.jsx(CancelIcon, {
className: clsx(classes.deleteIcon),
onClick: handleDeleteIconClick
});
}
let avatar = null;
if (avatarProp && __mf_15(avatarProp)) {
avatar = __mf_9(avatarProp, {
className: clsx(classes.avatar, avatarProp.props.className)
});
}
let icon = null;
if (iconProp && __mf_15(iconProp)) {
icon = __mf_9(iconProp, {
className: clsx(classes.icon, iconProp.props.className)
});
}
return jsxRuntimeExports.jsxs(ChipRoot, {
as: component,
className: clsx(classes.root, className),
disabled: clickable && disabled ? true : void 0,
onClick,
onKeyDown: handleKeyDown,
onKeyUp: handleKeyUp,
ref: handleRef,
tabIndex: skipFocusWhenDisabled && disabled ? -1 : tabIndex,
ownerState,
...moreProps,
...other,
children: [
avatar || icon,
jsxRuntimeExports.jsx(ChipLabel, {
className: clsx(classes.label),
ownerState,
children: label
}),
deleteIcon
]
});
});
getDialogContentUtilityClass = function(slot) {
return generateUtilityClass("MuiDialogContent", slot);
};
dialogContentClasses = generateUtilityClasses("MuiDialogContent", [
"root",
"dividers"
]);
getDialogTitleUtilityClass = function(slot) {
return generateUtilityClass("MuiDialogTitle", slot);
};
dialogTitleClasses = generateUtilityClasses("MuiDialogTitle", [
"root"
]);
const useUtilityClasses$1 = (ownerState) => {
const { classes, dividers } = ownerState;
const slots = {
root: [
"root",
dividers && "dividers"
]
};
return composeClasses(slots, getDialogContentUtilityClass, classes);
};
const DialogContentRoot = styled("div", {
name: "MuiDialogContent",
slot: "Root",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.root,
ownerState.dividers && styles2.dividers
];
}
})(memoTheme(({ theme }) => ({
flex: "1 1 auto",
WebkitOverflowScrolling: "touch",
overflowY: "auto",
padding: "20px 24px",
variants: [
{
props: ({ ownerState }) => ownerState.dividers,
style: {
padding: "16px 24px",
borderTop: `1px solid ${(theme.vars || theme).palette.divider}`,
borderBottom: `1px solid ${(theme.vars || theme).palette.divider}`
}
},
{
props: ({ ownerState }) => !ownerState.dividers,
style: {
[`.${dialogTitleClasses.root} + &`]: {
paddingTop: 0
}
}
}
]
})));
DialogContent = __mf_14(function DialogContent2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiDialogContent"
});
const { className, dividers = false, ...other } = props;
const ownerState = {
...props,
dividers
};
const classes = useUtilityClasses$1(ownerState);
return jsxRuntimeExports.jsx(DialogContentRoot, {
className: clsx(classes.root, className),
ownerState,
ref,
...other
});
});
getDialogUtilityClass = function(slot) {
return generateUtilityClass("MuiDialog", slot);
};
dialogClasses = generateUtilityClasses("MuiDialog", [
"root",
"scrollPaper",
"scrollBody",
"container",
"paper",
"paperScrollPaper",
"paperScrollBody",
"paperWidthFalse",
"paperWidthXs",
"paperWidthSm",
"paperWidthMd",
"paperWidthLg",
"paperWidthXl",
"paperFullWidth",
"paperFullScreen"
]);
DialogContext = __mf_10({});
const DialogBackdrop = styled(Backdrop, {
name: "MuiDialog",
slot: "Backdrop",
overrides: (props, styles2) => styles2.backdrop
})({
zIndex: -1
});
const useUtilityClasses = (ownerState) => {
const { classes, scroll, maxWidth, fullWidth, fullScreen } = ownerState;
const slots = {
root: [
"root"
],
container: [
"container",
`scroll${capitalize(scroll)}`
],
paper: [
"paper",
`paperScroll${capitalize(scroll)}`,
`paperWidth${capitalize(String(maxWidth))}`,
fullWidth && "paperFullWidth",
fullScreen && "paperFullScreen"
]
};
return composeClasses(slots, getDialogUtilityClass, classes);
};
const DialogRoot = styled(Modal, {
name: "MuiDialog",
slot: "Root",
overridesResolver: (props, styles2) => styles2.root
})({
"@media print": {
position: "absolute !important"
}
});
const DialogContainer = styled("div", {
name: "MuiDialog",
slot: "Container",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.container,
styles2[`scroll${capitalize(ownerState.scroll)}`]
];
}
})({
height: "100%",
"@media print": {
height: "auto"
},
outline: 0,
variants: [
{
props: {
scroll: "paper"
},
style: {
display: "flex",
justifyContent: "center",
alignItems: "center"
}
},
{
props: {
scroll: "body"
},
style: {
overflowY: "auto",
overflowX: "hidden",
textAlign: "center",
"&::after": {
content: '""',
display: "inline-block",
verticalAlign: "middle",
height: "100%",
width: "0"
}
}
}
]
});
const DialogPaper = styled(Paper, {
name: "MuiDialog",
slot: "Paper",
overridesResolver: (props, styles2) => {
const { ownerState } = props;
return [
styles2.paper,
styles2[`scrollPaper${capitalize(ownerState.scroll)}`],
styles2[`paperWidth${capitalize(String(ownerState.maxWidth))}`],
ownerState.fullWidth && styles2.paperFullWidth,
ownerState.fullScreen && styles2.paperFullScreen
];
}
})(memoTheme(({ theme }) => ({
margin: 32,
position: "relative",
overflowY: "auto",
"@media print": {
overflowY: "visible",
boxShadow: "none"
},
variants: [
{
props: {
scroll: "paper"
},
style: {
display: "flex",
flexDirection: "column",
maxHeight: "calc(100% - 64px)"
}
},
{
props: {
scroll: "body"
},
style: {
display: "inline-block",
verticalAlign: "middle",
textAlign: "initial"
}
},
{
props: ({ ownerState }) => !ownerState.maxWidth,
style: {
maxWidth: "calc(100% - 64px)"
}
},
{
props: {
maxWidth: "xs"
},
style: {
maxWidth: theme.breakpoints.unit === "px" ? Math.max(theme.breakpoints.values.xs, 444) : `max(${theme.breakpoints.values.xs}${theme.breakpoints.unit}, 444px)`,
[`&.${dialogClasses.paperScrollBody}`]: {
[theme.breakpoints.down(Math.max(theme.breakpoints.values.xs, 444) + 32 * 2)]: {
maxWidth: "calc(100% - 64px)"
}
}
}
},
...Object.keys(theme.breakpoints.values).filter((maxWidth) => maxWidth !== "xs").map((maxWidth) => ({
props: {
maxWidth
},
style: {
maxWidth: `${theme.breakpoints.values[maxWidth]}${theme.breakpoints.unit}`,
[`&.${dialogClasses.paperScrollBody}`]: {
[theme.breakpoints.down(theme.breakpoints.values[maxWidth] + 32 * 2)]: {
maxWidth: "calc(100% - 64px)"
}
}
}
})),
{
props: ({ ownerState }) => ownerState.fullWidth,
style: {
width: "calc(100% - 64px)"
}
},
{
props: ({ ownerState }) => ownerState.fullScreen,
style: {
margin: 0,
width: "100%",
maxWidth: "100%",
height: "100%",
maxHeight: "none",
borderRadius: 0,
[`&.${dialogClasses.paperScrollBody}`]: {
margin: 0,
maxWidth: "100%"
}
}
}
]
})));
Dialog = __mf_14(function Dialog2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiDialog"
});
const theme = useTheme();
const defaultTransitionDuration = {
enter: theme.transitions.duration.enteringScreen,
exit: theme.transitions.duration.leavingScreen
};
const { "aria-describedby": ariaDescribedby, "aria-labelledby": ariaLabelledbyProp, "aria-modal": ariaModal = true, BackdropComponent, BackdropProps, children, className, disableEscapeKeyDown = false, fullScreen = false, fullWidth = false, maxWidth = "sm", onBackdropClick, onClick, onClose, open, PaperComponent = Paper, PaperProps = {}, scroll = "paper", slots = {}, slotProps = {}, TransitionComponent = Fade, transitionDuration = defaultTransitionDuration, TransitionProps, ...other } = props;
const ownerState = {
...props,
disableEscapeKeyDown,
fullScreen,
fullWidth,
maxWidth,
scroll
};
const classes = useUtilityClasses(ownerState);
const backdropClick = __mf_31();
const handleMouseDown = (event) => {
backdropClick.current = event.target === event.currentTarget;
};
const handleBackdropClick = (event) => {
if (onClick) {
onClick(event);
}
if (!backdropClick.current) {
return;
}
backdropClick.current = null;
if (onBackdropClick) {
onBackdropClick(event);
}
if (onClose) {
onClose(event, "backdropClick");
}
};
const ariaLabelledby = useId(ariaLabelledbyProp);
const dialogContextValue = __mf_29(() => {
return {
titleId: ariaLabelledby
};
}, [
ariaLabelledby
]);
const backwardCompatibleSlots = {
transition: TransitionComponent,
...slots
};
const backwardCompatibleSlotProps = {
transition: TransitionProps,
paper: PaperProps,
backdrop: BackdropProps,
...slotProps
};
const externalForwardedProps = {
slots: backwardCompatibleSlots,
slotProps: backwardCompatibleSlotProps
};
const [RootSlot, rootSlotProps] = useSlot("root", {
elementType: DialogRoot,
shouldForwardComponentProp: true,
externalForwardedProps,
ownerState,
className: clsx(classes.root, className),
ref
});
const [BackdropSlot, backdropSlotProps] = useSlot("backdrop", {
elementType: DialogBackdrop,
shouldForwardComponentProp: true,
externalForwardedProps,
ownerState
});
const [PaperSlot, paperSlotProps] = useSlot("paper", {
elementType: DialogPaper,
shouldForwardComponentProp: true,
externalForwardedProps,
ownerState,
className: clsx(classes.paper, PaperProps.className)
});
const [ContainerSlot, containerSlotProps] = useSlot("container", {
elementType: DialogContainer,
externalForwardedProps,
ownerState,
className: clsx(classes.container)
});
const [TransitionSlot, transitionSlotProps] = useSlot("transition", {
elementType: Fade,
externalForwardedProps,
ownerState,
additionalProps: {
appear: true,
in: open,
timeout: transitionDuration,
role: "presentation"
}
});
return jsxRuntimeExports.jsx(RootSlot, {
closeAfterTransition: true,
slots: {
backdrop: BackdropSlot
},
slotProps: {
backdrop: {
transitionDuration,
as: BackdropComponent,
...backdropSlotProps
}
},
disableEscapeKeyDown,
onClose,
open,
onClick: handleBackdropClick,
...rootSlotProps,
...other,
children: jsxRuntimeExports.jsx(TransitionSlot, {
...transitionSlotProps,
children: jsxRuntimeExports.jsx(ContainerSlot, {
onMouseDown: handleMouseDown,
...containerSlotProps,
children: jsxRuntimeExports.jsx(PaperSlot, {
as: PaperComponent,
elevation: 24,
role: "dialog",
"aria-describedby": ariaDescribedby,
"aria-labelledby": ariaLabelledby,
"aria-modal": ariaModal,
...paperSlotProps,
children: jsxRuntimeExports.jsx(DialogContext.Provider, {
value: dialogContextValue,
children
})
})
})
})
});
});
});
export {
ArrowDropDownIcon as $,
DialogContent as A,
ButtonBase as B,
Chip as C,
DialogActions as D,
ThemeProvider as E,
FormHelperText as F,
Grow as G,
getDividerUtilityClass as H,
IconButton as I,
ListContext as J,
getListItemIconUtilityClass as K,
List as L,
MenuItem as M,
useSlot as N,
getListItemTextUtilityClass as O,
Paper as P,
listItemTextClasses as Q,
typographyClasses as R,
getListItemButtonUtilityClass as S,
Transition as T,
listItemButtonClasses as U,
debounce$1 as V,
ownerWindow as W,
useTimeout as X,
getTransitionProps as Y,
createSimplePaletteValueFilter as Z,
setRef as _,
__tla,
useSlotProps as a,
getFormHelperTextUtilityClasses as a$,
filledInputClasses as a0,
inputBaseClasses as a1,
outlinedInputClasses as a2,
inputClasses as a3,
ButtonGroupContext as a4,
ButtonGroupButtonContext as a5,
mergeSlotProps as a6,
getReactElementRef as a7,
globalCss as a8,
DialogContext as a9,
Popover as aA,
PopoverPaper as aB,
PopoverRoot as aC,
Portal as aD,
TextareaAutosize as aE,
backdropClasses as aF,
buttonBaseClasses as aG,
buttonClasses as aH,
chipClasses as aI,
circularProgressClasses as aJ,
dialogActionsClasses as aK,
dialogContentClasses as aL,
dialogTitleClasses as aM,
dividerClasses as aN,
formControlClasses as aO,
formHelperTextClasses as aP,
formLabelClasses as aQ,
getBackdropUtilityClass as aR,
getButtonBaseUtilityClass as aS,
getButtonUtilityClass as aT,
getChipUtilityClass as aU,
getCircularProgressUtilityClass as aV,
getDialogActionsUtilityClass as aW,
getDialogContentUtilityClass as aX,
getDialogUtilityClass as aY,
getFilledInputUtilityClass as aZ,
getFormControlUtilityClasses as a_,
getDialogTitleUtilityClass as aa,
reflow as ab,
Modal as ac,
formControlState as ad,
isFocusVisible as ae,
NativeSelectInput as af,
Input as ag,
getNativeSelectUtilityClasses as ah,
createChainedFunction as ai,
extractEventHandlers as aj,
isHostComponent as ak,
Timeout as al,
InputBase as am,
Select as an,
Backdrop as ao,
CircularProgress as ap,
CssVarsProvider as aq,
Experimental_CssVarsProvider as ar,
FilledInput as as,
FormLabel as at,
FormLabelRoot as au,
GlobalStyles as av,
ListItemSecondaryAction as aw,
Menu as ax,
ModalManager as ay,
OutlinedInput as az,
Typography as b,
getFormLabelUtilityClasses as b0,
getIconButtonUtilityClass as b1,
getInitColorSchemeScript as b2,
getInputAdornmentUtilityClass as b3,
getInputBaseUtilityClass as b4,
getInputLabelUtilityClasses as b5,
getInputUtilityClass as b6,
getListItemSecondaryActionClassesUtilityClass as b7,
getListItemUtilityClass as b8,
getListUtilityClass as b9,
selectClasses as bA,
textFieldClasses as bB,
touchRippleClasses as bC,
useColorScheme as bD,
getMenuItemUtilityClass as ba,
getMenuUtilityClass as bb,
getModalUtilityClass as bc,
getOffsetLeft as bd,
getOffsetTop as be,
getOutlinedInputUtilityClass as bf,
getPaperUtilityClass as bg,
getPopoverUtilityClass as bh,
getPopperUtilityClass as bi,
getSelectUtilityClasses as bj,
getTextFieldUtilityClass as bk,
getTouchRippleUtilityClass as bl,
getTypographyUtilityClass as bm,
iconButtonClasses as bn,
inputAdornmentClasses as bo,
inputLabelClasses as bp,
listClasses as bq,
listItemClasses as br,
listItemIconClasses as bs,
listItemSecondaryActionClasses as bt,
menuClasses as bu,
menuItemClasses as bv,
modalClasses as bw,
nativeSelectClasses as bx,
paperClasses as by,
popoverClasses as bz,
useControlled as c,
useEventCallback as d,
useForkRef as e,
forceReflow as f,
MenuList as g,
InputAdornment as h,
useFormControl as i,
InputLabel as j,
FormControl as k,
TextField as l,
useTheme as m,
Fade as n,
TransitionGroup as o,
useMediaQuery as p,
FocusTrap as q,
ownerDocument as r,
Popper as s,
Button as t,
useThemeProps as u,
visuallyHidden as v,
ListItem as w,
resolveComponentProps as x,
Dialog as y,
dialogClasses as z
};