` by default. You can change this
* behavior by providing a `component` prop.
* If you use React v16+ and would like to avoid a wrapping `
` element
* you can pass in `component={null}`. This is useful if the wrapping div
* borks your css styles.
*/
component: import_prop_types5.default.any,
/**
* A set of `
` components, that are toggled `in` and out as they
* leave. the `` will inject specific transition props, so
* remember to spread them through if you are wrapping the `` as
* with our `` example.
*
* While this component is meant for multiple `Transition` or `CSSTransition`
* children, sometimes you may want to have a single transition child with
* content that you want to be transitioned out and in when you change it
* (e.g. routes, images etc.) In that case you can change the `key` prop of
* the transition child as you change its content, this will cause
* `TransitionGroup` to transition the child out and back in.
*/
children: import_prop_types5.default.node,
/**
* A convenience prop that enables or disables appear animations
* for all children. Note that specifying this will override any defaults set
* on individual children Transitions.
*/
appear: import_prop_types5.default.bool,
/**
* A convenience prop that enables or disables enter animations
* for all children. Note that specifying this will override any defaults set
* on individual children Transitions.
*/
enter: import_prop_types5.default.bool,
/**
* A convenience prop that enables or disables exit animations
* for all children. Note that specifying this will override any defaults set
* on individual children Transitions.
*/
exit: import_prop_types5.default.bool,
/**
* You may need to apply reactive updates to a child as it is exiting.
* This is generally done by using `cloneElement` however in the case of an exiting
* child the element has already been removed and not accessible to the consumer.
*
* If you do need to update a child as it leaves you can provide a `childFactory`
* to wrap every child, even the ones that are leaving.
*
* @type Function(child: ReactElement) -> ReactElement
*/
childFactory: import_prop_types5.default.func
} : {};
TransitionGroup.defaultProps = defaultProps;
var TransitionGroup_default = TransitionGroup;
// node_modules/react-transition-group/esm/ReplaceTransition.js
var ReplaceTransition = function(_React$Component) {
_inheritsLoose(ReplaceTransition2, _React$Component);
function ReplaceTransition2() {
var _this;
for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
_args[_key] = arguments[_key];
}
_this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
_this.handleEnter = function() {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return _this.handleLifecycle("onEnter", 0, args);
};
_this.handleEntering = function() {
for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
args[_key3] = arguments[_key3];
}
return _this.handleLifecycle("onEntering", 0, args);
};
_this.handleEntered = function() {
for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
args[_key4] = arguments[_key4];
}
return _this.handleLifecycle("onEntered", 0, args);
};
_this.handleExit = function() {
for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
args[_key5] = arguments[_key5];
}
return _this.handleLifecycle("onExit", 1, args);
};
_this.handleExiting = function() {
for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
args[_key6] = arguments[_key6];
}
return _this.handleLifecycle("onExiting", 1, args);
};
_this.handleExited = function() {
for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
args[_key7] = arguments[_key7];
}
return _this.handleLifecycle("onExited", 1, args);
};
return _this;
}
var _proto = ReplaceTransition2.prototype;
_proto.handleLifecycle = function handleLifecycle(handler, idx, originalArgs) {
var _child$props;
var children2 = this.props.children;
var child = import_react6.default.Children.toArray(children2)[idx];
if (child.props[handler]) (_child$props = child.props)[handler].apply(_child$props, originalArgs);
if (this.props[handler]) {
var maybeNode = child.props.nodeRef ? void 0 : import_react_dom2.default.findDOMNode(this);
this.props[handler](maybeNode);
}
};
_proto.render = function render() {
var _this$props = this.props, children2 = _this$props.children, inProp = _this$props.in, props = _objectWithoutPropertiesLoose(_this$props, ["children", "in"]);
var _React$Children$toArr = import_react6.default.Children.toArray(children2), first = _React$Children$toArr[0], second = _React$Children$toArr[1];
delete props.onEnter;
delete props.onEntering;
delete props.onEntered;
delete props.onExit;
delete props.onExiting;
delete props.onExited;
return import_react6.default.createElement(TransitionGroup_default, props, inProp ? import_react6.default.cloneElement(first, {
key: "first",
onEnter: this.handleEnter,
onEntering: this.handleEntering,
onEntered: this.handleEntered
}) : import_react6.default.cloneElement(second, {
key: "second",
onEnter: this.handleExit,
onEntering: this.handleExiting,
onEntered: this.handleExited
}));
};
return ReplaceTransition2;
}(import_react6.default.Component);
ReplaceTransition.propTypes = true ? {
in: import_prop_types6.default.bool.isRequired,
children: function children(props, propName) {
if (import_react6.default.Children.count(props[propName]) !== 2) return new Error('"' + propName + '" must be exactly two transition components.');
return null;
}
} : {};
// node_modules/react-transition-group/esm/SwitchTransition.js
var import_react7 = __toESM(require_react());
var import_prop_types7 = __toESM(require_prop_types());
var _leaveRenders;
var _enterRenders;
function areChildrenDifferent(oldChildren, newChildren) {
if (oldChildren === newChildren) return false;
if (import_react7.default.isValidElement(oldChildren) && import_react7.default.isValidElement(newChildren) && oldChildren.key != null && oldChildren.key === newChildren.key) {
return false;
}
return true;
}
var modes = {
out: "out-in",
in: "in-out"
};
var callHook = function callHook2(element, name, cb) {
return function() {
var _element$props;
element.props[name] && (_element$props = element.props)[name].apply(_element$props, arguments);
cb();
};
};
var leaveRenders = (_leaveRenders = {}, _leaveRenders[modes.out] = function(_ref) {
var current = _ref.current, changeState = _ref.changeState;
return import_react7.default.cloneElement(current, {
in: false,
onExited: callHook(current, "onExited", function() {
changeState(ENTERING, null);
})
});
}, _leaveRenders[modes.in] = function(_ref2) {
var current = _ref2.current, changeState = _ref2.changeState, children2 = _ref2.children;
return [current, import_react7.default.cloneElement(children2, {
in: true,
onEntered: callHook(children2, "onEntered", function() {
changeState(ENTERING);
})
})];
}, _leaveRenders);
var enterRenders = (_enterRenders = {}, _enterRenders[modes.out] = function(_ref3) {
var children2 = _ref3.children, changeState = _ref3.changeState;
return import_react7.default.cloneElement(children2, {
in: true,
onEntered: callHook(children2, "onEntered", function() {
changeState(ENTERED, import_react7.default.cloneElement(children2, {
in: true
}));
})
});
}, _enterRenders[modes.in] = function(_ref4) {
var current = _ref4.current, children2 = _ref4.children, changeState = _ref4.changeState;
return [import_react7.default.cloneElement(current, {
in: false,
onExited: callHook(current, "onExited", function() {
changeState(ENTERED, import_react7.default.cloneElement(children2, {
in: true
}));
})
}), import_react7.default.cloneElement(children2, {
in: true
})];
}, _enterRenders);
var SwitchTransition = function(_React$Component) {
_inheritsLoose(SwitchTransition2, _React$Component);
function SwitchTransition2() {
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
_this.state = {
status: ENTERED,
current: null
};
_this.appeared = false;
_this.changeState = function(status, current) {
if (current === void 0) {
current = _this.state.current;
}
_this.setState({
status,
current
});
};
return _this;
}
var _proto = SwitchTransition2.prototype;
_proto.componentDidMount = function componentDidMount() {
this.appeared = true;
};
SwitchTransition2.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {
if (props.children == null) {
return {
current: null
};
}
if (state.status === ENTERING && props.mode === modes.in) {
return {
status: ENTERING
};
}
if (state.current && areChildrenDifferent(state.current, props.children)) {
return {
status: EXITING
};
}
return {
current: import_react7.default.cloneElement(props.children, {
in: true
})
};
};
_proto.render = function render() {
var _this$props = this.props, children2 = _this$props.children, mode = _this$props.mode, _this$state = this.state, status = _this$state.status, current = _this$state.current;
var data = {
children: children2,
current,
changeState: this.changeState,
status
};
var component;
switch (status) {
case ENTERING:
component = enterRenders[mode](data);
break;
case EXITING:
component = leaveRenders[mode](data);
break;
case ENTERED:
component = current;
}
return import_react7.default.createElement(TransitionGroupContext_default.Provider, {
value: {
isMounting: !this.appeared
}
}, component);
};
return SwitchTransition2;
}(import_react7.default.Component);
SwitchTransition.propTypes = true ? {
/**
* Transition modes.
* `out-in`: Current element transitions out first, then when complete, the new element transitions in.
* `in-out`: New element transitions in first, then when complete, the current element transitions out.
*
* @type {'out-in'|'in-out'}
*/
mode: import_prop_types7.default.oneOf([modes.in, modes.out]),
/**
* Any `Transition` or `CSSTransition` component.
*/
children: import_prop_types7.default.oneOfType([import_prop_types7.default.element.isRequired])
} : {};
SwitchTransition.defaultProps = {
mode: modes.out
};
// node_modules/@mui/material/transitions/utils.js
var reflow = (node) => node.scrollTop;
function getTransitionProps(props, options) {
const {
timeout: timeout2,
easing: easing2,
style = {}
} = props;
return {
duration: style.transitionDuration ?? (typeof timeout2 === "number" ? timeout2 : timeout2[options.mode] || 0),
easing: style.transitionTimingFunction ?? (typeof easing2 === "object" ? easing2[options.mode] : easing2),
delay: style.transitionDelay
};
}
// node_modules/@mui/material/Collapse/collapseClasses.js
function getCollapseUtilityClass(slot) {
return generateUtilityClass("MuiCollapse", slot);
}
var collapseClasses = generateUtilityClasses("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
var collapseClasses_default = collapseClasses;
// node_modules/@mui/material/Collapse/Collapse.js
var import_jsx_runtime7 = __toESM(require_jsx_runtime());
var useUtilityClasses2 = (ownerState) => {
const {
orientation,
classes
} = ownerState;
const slots = {
root: ["root", `${orientation}`],
entered: ["entered"],
hidden: ["hidden"],
wrapper: ["wrapper", `${orientation}`],
wrapperInner: ["wrapperInner", `${orientation}`]
};
return composeClasses(slots, getCollapseUtilityClass, classes);
};
var CollapseRoot = styled_default("div", {
name: "MuiCollapse",
slot: "Root",
overridesResolver: (props, styles6) => {
const {
ownerState
} = props;
return [styles6.root, styles6[ownerState.orientation], ownerState.state === "entered" && styles6.entered, ownerState.state === "exited" && !ownerState.in && ownerState.collapsedSize === "0px" && styles6.hidden];
}
})(memoTheme(({
theme
}) => ({
height: 0,
overflow: "hidden",
transition: theme.transitions.create("height"),
variants: [{
props: {
orientation: "horizontal"
},
style: {
height: "auto",
width: 0,
transition: theme.transitions.create("width")
}
}, {
props: {
state: "entered"
},
style: {
height: "auto",
overflow: "visible"
}
}, {
props: {
state: "entered",
orientation: "horizontal"
},
style: {
width: "auto"
}
}, {
props: ({
ownerState
}) => ownerState.state === "exited" && !ownerState.in && ownerState.collapsedSize === "0px",
style: {
visibility: "hidden"
}
}]
})));
var CollapseWrapper = styled_default("div", {
name: "MuiCollapse",
slot: "Wrapper",
overridesResolver: (props, styles6) => styles6.wrapper
})({
// Hack to get children with a negative margin to not falsify the height computation.
display: "flex",
width: "100%",
variants: [{
props: {
orientation: "horizontal"
},
style: {
width: "auto",
height: "100%"
}
}]
});
var CollapseWrapperInner = styled_default("div", {
name: "MuiCollapse",
slot: "WrapperInner",
overridesResolver: (props, styles6) => styles6.wrapperInner
})({
width: "100%",
variants: [{
props: {
orientation: "horizontal"
},
style: {
width: "auto",
height: "100%"
}
}]
});
var Collapse = React13.forwardRef(function Collapse2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiCollapse"
});
const {
addEndListener,
children: children2,
className,
collapsedSize: collapsedSizeProp = "0px",
component,
easing: easing2,
in: inProp,
onEnter,
onEntered,
onEntering,
onExit,
onExited,
onExiting,
orientation = "vertical",
style,
timeout: timeout2 = duration.standard,
// eslint-disable-next-line react/prop-types
TransitionComponent = Transition_default,
...other
} = props;
const ownerState = {
...props,
orientation,
collapsedSize: collapsedSizeProp
};
const classes = useUtilityClasses2(ownerState);
const theme = useTheme();
const timer = useTimeout();
const wrapperRef = React13.useRef(null);
const autoTransitionDuration = React13.useRef();
const collapsedSize = typeof collapsedSizeProp === "number" ? `${collapsedSizeProp}px` : collapsedSizeProp;
const isHorizontal2 = orientation === "horizontal";
const size = isHorizontal2 ? "width" : "height";
const nodeRef = React13.useRef(null);
const handleRef = useForkRef_default(ref, nodeRef);
const normalizedTransitionCallback = (callback) => (maybeIsAppearing) => {
if (callback) {
const node = nodeRef.current;
if (maybeIsAppearing === void 0) {
callback(node);
} else {
callback(node, maybeIsAppearing);
}
}
};
const getWrapperSize = () => wrapperRef.current ? wrapperRef.current[isHorizontal2 ? "clientWidth" : "clientHeight"] : 0;
const handleEnter = normalizedTransitionCallback((node, isAppearing) => {
if (wrapperRef.current && isHorizontal2) {
wrapperRef.current.style.position = "absolute";
}
node.style[size] = collapsedSize;
if (onEnter) {
onEnter(node, isAppearing);
}
});
const handleEntering = normalizedTransitionCallback((node, isAppearing) => {
const wrapperSize = getWrapperSize();
if (wrapperRef.current && isHorizontal2) {
wrapperRef.current.style.position = "";
}
const {
duration: transitionDuration,
easing: transitionTimingFunction
} = getTransitionProps({
style,
timeout: timeout2,
easing: easing2
}, {
mode: "enter"
});
if (timeout2 === "auto") {
const duration2 = theme.transitions.getAutoHeightDuration(wrapperSize);
node.style.transitionDuration = `${duration2}ms`;
autoTransitionDuration.current = duration2;
} else {
node.style.transitionDuration = typeof transitionDuration === "string" ? transitionDuration : `${transitionDuration}ms`;
}
node.style[size] = `${wrapperSize}px`;
node.style.transitionTimingFunction = transitionTimingFunction;
if (onEntering) {
onEntering(node, isAppearing);
}
});
const handleEntered = normalizedTransitionCallback((node, isAppearing) => {
node.style[size] = "auto";
if (onEntered) {
onEntered(node, isAppearing);
}
});
const handleExit = normalizedTransitionCallback((node) => {
node.style[size] = `${getWrapperSize()}px`;
if (onExit) {
onExit(node);
}
});
const handleExited = normalizedTransitionCallback(onExited);
const handleExiting = normalizedTransitionCallback((node) => {
const wrapperSize = getWrapperSize();
const {
duration: transitionDuration,
easing: transitionTimingFunction
} = getTransitionProps({
style,
timeout: timeout2,
easing: easing2
}, {
mode: "exit"
});
if (timeout2 === "auto") {
const duration2 = theme.transitions.getAutoHeightDuration(wrapperSize);
node.style.transitionDuration = `${duration2}ms`;
autoTransitionDuration.current = duration2;
} else {
node.style.transitionDuration = typeof transitionDuration === "string" ? transitionDuration : `${transitionDuration}ms`;
}
node.style[size] = collapsedSize;
node.style.transitionTimingFunction = transitionTimingFunction;
if (onExiting) {
onExiting(node);
}
});
const handleAddEndListener = (next) => {
if (timeout2 === "auto") {
timer.start(autoTransitionDuration.current || 0, next);
}
if (addEndListener) {
addEndListener(nodeRef.current, next);
}
};
return (0, import_jsx_runtime7.jsx)(TransitionComponent, {
in: inProp,
onEnter: handleEnter,
onEntered: handleEntered,
onEntering: handleEntering,
onExit: handleExit,
onExited: handleExited,
onExiting: handleExiting,
addEndListener: handleAddEndListener,
nodeRef,
timeout: timeout2 === "auto" ? null : timeout2,
...other,
children: (state, childProps) => (0, import_jsx_runtime7.jsx)(CollapseRoot, {
as: component,
className: clsx_default(classes.root, className, {
"entered": classes.entered,
"exited": !inProp && collapsedSize === "0px" && classes.hidden
}[state]),
style: {
[isHorizontal2 ? "minWidth" : "minHeight"]: collapsedSize,
...style
},
ref: handleRef,
...childProps,
// `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
// that might have been forwarded from the Transition component.
ownerState: {
...ownerState,
state
},
children: (0, import_jsx_runtime7.jsx)(CollapseWrapper, {
ownerState: {
...ownerState,
state
},
className: classes.wrapper,
ref: wrapperRef,
children: (0, import_jsx_runtime7.jsx)(CollapseWrapperInner, {
ownerState: {
...ownerState,
state
},
className: classes.wrapperInner,
children: children2
})
})
})
});
});
true ? Collapse.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* Add a custom transition end trigger. Called with the transitioning DOM
* node and a done callback. Allows for more fine grained transition end
* logic. Note: Timeouts are still used as a fallback if provided.
*/
addEndListener: import_prop_types8.default.func,
/**
* The content node to be collapsed.
*/
children: import_prop_types8.default.node,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types8.default.object,
/**
* @ignore
*/
className: import_prop_types8.default.string,
/**
* The width (horizontal) or height (vertical) of the container when collapsed.
* @default '0px'
*/
collapsedSize: import_prop_types8.default.oneOfType([import_prop_types8.default.number, import_prop_types8.default.string]),
/**
* The component used for the root node.
* Either a string to use a HTML element or a component.
*/
component: elementTypeAcceptingRef_default,
/**
* The transition timing function.
* You may specify a single easing or a object containing enter and exit values.
*/
easing: import_prop_types8.default.oneOfType([import_prop_types8.default.shape({
enter: import_prop_types8.default.string,
exit: import_prop_types8.default.string
}), import_prop_types8.default.string]),
/**
* If `true`, the component will transition in.
*/
in: import_prop_types8.default.bool,
/**
* @ignore
*/
onEnter: import_prop_types8.default.func,
/**
* @ignore
*/
onEntered: import_prop_types8.default.func,
/**
* @ignore
*/
onEntering: import_prop_types8.default.func,
/**
* @ignore
*/
onExit: import_prop_types8.default.func,
/**
* @ignore
*/
onExited: import_prop_types8.default.func,
/**
* @ignore
*/
onExiting: import_prop_types8.default.func,
/**
* The transition orientation.
* @default 'vertical'
*/
orientation: import_prop_types8.default.oneOf(["horizontal", "vertical"]),
/**
* @ignore
*/
style: import_prop_types8.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types8.default.oneOfType([import_prop_types8.default.arrayOf(import_prop_types8.default.oneOfType([import_prop_types8.default.func, import_prop_types8.default.object, import_prop_types8.default.bool])), import_prop_types8.default.func, import_prop_types8.default.object]),
/**
* The duration for the transition, in milliseconds.
* You may specify a single timeout for all transitions, or individually with an object.
*
* Set to 'auto' to automatically calculate transition time based on height.
* @default duration.standard
*/
timeout: import_prop_types8.default.oneOfType([import_prop_types8.default.oneOf(["auto"]), import_prop_types8.default.number, import_prop_types8.default.shape({
appear: import_prop_types8.default.number,
enter: import_prop_types8.default.number,
exit: import_prop_types8.default.number
})])
} : void 0;
if (Collapse) {
Collapse.muiSupportAuto = true;
}
var Collapse_default = Collapse;
// node_modules/@mui/material/Paper/Paper.js
var React14 = __toESM(require_react());
var import_prop_types9 = __toESM(require_prop_types());
// node_modules/@mui/material/Paper/paperClasses.js
function getPaperUtilityClass(slot) {
return generateUtilityClass("MuiPaper", slot);
}
var 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"]);
var paperClasses_default = paperClasses;
// node_modules/@mui/material/Paper/Paper.js
var import_jsx_runtime8 = __toESM(require_jsx_runtime());
var useUtilityClasses3 = (ownerState) => {
const {
square,
elevation,
variant,
classes
} = ownerState;
const slots = {
root: ["root", variant, !square && "rounded", variant === "elevation" && `elevation${elevation}`]
};
return composeClasses(slots, getPaperUtilityClass, classes);
};
var PaperRoot = styled_default("div", {
name: "MuiPaper",
slot: "Root",
overridesResolver: (props, styles6) => {
const {
ownerState
} = props;
return [styles6.root, styles6[ownerState.variant], !ownerState.square && styles6.rounded, ownerState.variant === "elevation" && styles6[`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)"
}
}]
})));
var Paper = React14.forwardRef(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 = useUtilityClasses3(ownerState);
if (true) {
if (theme.shadows[elevation] === void 0) {
console.error([`MUI: The elevation provided is not available in the theme.`, `Please make sure that \`theme.shadows[${elevation}]\` is defined.`].join("\n"));
}
}
return (0, import_jsx_runtime8.jsx)(PaperRoot, {
as: component,
ownerState,
className: clsx_default(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
}
});
});
true ? Paper.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* The content of the component.
*/
children: import_prop_types9.default.node,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types9.default.object,
/**
* @ignore
*/
className: import_prop_types9.default.string,
/**
* The component used for the root node.
* Either a string to use a HTML element or a component.
*/
component: import_prop_types9.default.elementType,
/**
* Shadow depth, corresponds to `dp` in the spec.
* It accepts values between 0 and 24 inclusive.
* @default 1
*/
elevation: chainPropTypes(integerPropType_default, (props) => {
const {
elevation,
variant
} = props;
if (elevation > 0 && variant === "outlined") {
return new Error(`MUI: Combining \`elevation={${elevation}}\` with \`variant="${variant}"\` has no effect. Either use \`elevation={0}\` or use a different \`variant\`.`);
}
return null;
}),
/**
* If `true`, rounded corners are disabled.
* @default false
*/
square: import_prop_types9.default.bool,
/**
* @ignore
*/
style: import_prop_types9.default.object,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types9.default.oneOfType([import_prop_types9.default.arrayOf(import_prop_types9.default.oneOfType([import_prop_types9.default.func, import_prop_types9.default.object, import_prop_types9.default.bool])), import_prop_types9.default.func, import_prop_types9.default.object]),
/**
* The variant to use.
* @default 'elevation'
*/
variant: import_prop_types9.default.oneOfType([import_prop_types9.default.oneOf(["elevation", "outlined"]), import_prop_types9.default.string])
} : void 0;
var Paper_default = Paper;
// node_modules/@mui/material/Accordion/AccordionContext.js
var React15 = __toESM(require_react());
var AccordionContext = React15.createContext({});
if (true) {
AccordionContext.displayName = "AccordionContext";
}
var AccordionContext_default = AccordionContext;
// node_modules/@mui/material/utils/useSlot.js
function useSlot(name, parameters) {
const {
className,
elementType: initialElementType,
ownerState,
externalForwardedProps,
getSlotOwnerState,
internalForwardedProps,
...useSlotPropsParams
} = parameters;
const {
component: rootComponent,
slots = {
[name]: void 0
},
slotProps = {
[name]: void 0
},
...other
} = externalForwardedProps;
const elementType = slots[name] || initialElementType;
const resolvedComponentsProps = resolveComponentProps_default(slotProps[name], ownerState);
const {
props: {
component: slotComponent,
...mergedProps
},
internalRef
} = mergeSlotProps_default({
className,
...useSlotPropsParams,
externalForwardedProps: name === "root" ? other : void 0,
externalSlotProps: resolvedComponentsProps
});
const ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, parameters.ref);
const slotOwnerState = getSlotOwnerState ? getSlotOwnerState(mergedProps) : {};
const finalOwnerState = {
...ownerState,
...slotOwnerState
};
const LeafComponent = name === "root" ? slotComponent || rootComponent : slotComponent;
const props = appendOwnerState_default(elementType, {
...name === "root" && !rootComponent && !slots[name] && internalForwardedProps,
...name !== "root" && !slots[name] && internalForwardedProps,
...mergedProps,
...LeafComponent && {
as: LeafComponent
},
ref
}, finalOwnerState);
Object.keys(slotOwnerState).forEach((propName) => {
delete props[propName];
});
return [elementType, props];
}
// node_modules/@mui/material/Accordion/accordionClasses.js
function getAccordionUtilityClass(slot) {
return generateUtilityClass("MuiAccordion", slot);
}
var accordionClasses = generateUtilityClasses("MuiAccordion", ["root", "heading", "rounded", "expanded", "disabled", "gutters", "region"]);
var accordionClasses_default = accordionClasses;
// node_modules/@mui/material/Accordion/Accordion.js
var import_jsx_runtime9 = __toESM(require_jsx_runtime());
var useUtilityClasses4 = (ownerState) => {
const {
classes,
square,
expanded,
disabled,
disableGutters
} = ownerState;
const slots = {
root: ["root", !square && "rounded", expanded && "expanded", disabled && "disabled", !disableGutters && "gutters"],
heading: ["heading"],
region: ["region"]
};
return composeClasses(slots, getAccordionUtilityClass, classes);
};
var AccordionRoot = styled_default(Paper_default, {
name: "MuiAccordion",
slot: "Root",
overridesResolver: (props, styles6) => {
const {
ownerState
} = props;
return [{
[`& .${accordionClasses_default.region}`]: styles6.region
}, styles6.root, !ownerState.square && styles6.rounded, !ownerState.disableGutters && styles6.gutters];
}
})(memoTheme(({
theme
}) => {
const transition = {
duration: theme.transitions.duration.shortest
};
return {
position: "relative",
transition: theme.transitions.create(["margin"], transition),
overflowAnchor: "none",
// Keep the same scrolling position
"&::before": {
position: "absolute",
left: 0,
top: -1,
right: 0,
height: 1,
content: '""',
opacity: 1,
backgroundColor: (theme.vars || theme).palette.divider,
transition: theme.transitions.create(["opacity", "background-color"], transition)
},
"&:first-of-type": {
"&::before": {
display: "none"
}
},
[`&.${accordionClasses_default.expanded}`]: {
"&::before": {
opacity: 0
},
"&:first-of-type": {
marginTop: 0
},
"&:last-of-type": {
marginBottom: 0
},
"& + &": {
"&::before": {
display: "none"
}
}
},
[`&.${accordionClasses_default.disabled}`]: {
backgroundColor: (theme.vars || theme).palette.action.disabledBackground
}
};
}), memoTheme(({
theme
}) => ({
variants: [{
props: (props) => !props.square,
style: {
borderRadius: 0,
"&:first-of-type": {
borderTopLeftRadius: (theme.vars || theme).shape.borderRadius,
borderTopRightRadius: (theme.vars || theme).shape.borderRadius
},
"&:last-of-type": {
borderBottomLeftRadius: (theme.vars || theme).shape.borderRadius,
borderBottomRightRadius: (theme.vars || theme).shape.borderRadius,
// Fix a rendering issue on Edge
"@supports (-ms-ime-align: auto)": {
borderBottomLeftRadius: 0,
borderBottomRightRadius: 0
}
}
}
}, {
props: (props) => !props.disableGutters,
style: {
[`&.${accordionClasses_default.expanded}`]: {
margin: "16px 0"
}
}
}]
})));
var AccordionHeading = styled_default("h3", {
name: "MuiAccordion",
slot: "Heading",
overridesResolver: (props, styles6) => styles6.heading
})({
all: "unset"
});
var Accordion = React16.forwardRef(function Accordion2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiAccordion"
});
const {
children: childrenProp,
className,
defaultExpanded = false,
disabled = false,
disableGutters = false,
expanded: expandedProp,
onChange,
square = false,
slots = {},
slotProps = {},
TransitionComponent: TransitionComponentProp,
TransitionProps: TransitionPropsProp,
...other
} = props;
const [expanded, setExpandedState] = useControlled_default({
controlled: expandedProp,
default: defaultExpanded,
name: "Accordion",
state: "expanded"
});
const handleChange = React16.useCallback((event) => {
setExpandedState(!expanded);
if (onChange) {
onChange(event, !expanded);
}
}, [expanded, onChange, setExpandedState]);
const [summary, ...children2] = React16.Children.toArray(childrenProp);
const contextValue = React16.useMemo(() => ({
expanded,
disabled,
disableGutters,
toggle: handleChange
}), [expanded, disabled, disableGutters, handleChange]);
const ownerState = {
...props,
square,
disabled,
disableGutters,
expanded
};
const classes = useUtilityClasses4(ownerState);
const backwardCompatibleSlots = {
transition: TransitionComponentProp,
...slots
};
const backwardCompatibleSlotProps = {
transition: TransitionPropsProp,
...slotProps
};
const externalForwardedProps = {
slots: backwardCompatibleSlots,
slotProps: backwardCompatibleSlotProps
};
const [AccordionHeadingSlot, accordionProps] = useSlot("heading", {
elementType: AccordionHeading,
externalForwardedProps,
className: classes.heading,
ownerState
});
const [TransitionSlot, transitionProps] = useSlot("transition", {
elementType: Collapse_default,
externalForwardedProps,
ownerState
});
return (0, import_jsx_runtime9.jsxs)(AccordionRoot, {
className: clsx_default(classes.root, className),
ref,
ownerState,
square,
...other,
children: [(0, import_jsx_runtime9.jsx)(AccordionHeadingSlot, {
...accordionProps,
children: (0, import_jsx_runtime9.jsx)(AccordionContext_default.Provider, {
value: contextValue,
children: summary
})
}), (0, import_jsx_runtime9.jsx)(TransitionSlot, {
in: expanded,
timeout: "auto",
...transitionProps,
children: (0, import_jsx_runtime9.jsx)("div", {
"aria-labelledby": summary.props.id,
id: summary.props["aria-controls"],
role: "region",
className: classes.region,
children: children2
})
})]
});
});
true ? Accordion.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* The content of the component.
*/
children: chainPropTypes(import_prop_types10.default.node.isRequired, (props) => {
const summary = React16.Children.toArray(props.children)[0];
if ((0, import_react_is.isFragment)(summary)) {
return new Error("MUI: The Accordion doesn't accept a Fragment as a child. Consider providing an array instead.");
}
if (!React16.isValidElement(summary)) {
return new Error("MUI: Expected the first child of Accordion to be a valid element.");
}
return null;
}),
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types10.default.object,
/**
* @ignore
*/
className: import_prop_types10.default.string,
/**
* If `true`, expands the accordion by default.
* @default false
*/
defaultExpanded: import_prop_types10.default.bool,
/**
* If `true`, the component is disabled.
* @default false
*/
disabled: import_prop_types10.default.bool,
/**
* If `true`, it removes the margin between two expanded accordion items and the increase of height.
* @default false
*/
disableGutters: import_prop_types10.default.bool,
/**
* If `true`, expands the accordion, otherwise collapse it.
* Setting this prop enables control over the accordion.
*/
expanded: import_prop_types10.default.bool,
/**
* Callback fired when the expand/collapse state is changed.
*
* @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
* @param {boolean} expanded The `expanded` state of the accordion.
*/
onChange: import_prop_types10.default.func,
/**
* The props used for each slot inside.
* @default {}
*/
slotProps: import_prop_types10.default.shape({
heading: import_prop_types10.default.oneOfType([import_prop_types10.default.func, import_prop_types10.default.object]),
transition: import_prop_types10.default.oneOfType([import_prop_types10.default.func, import_prop_types10.default.object])
}),
/**
* The components used for each slot inside.
* @default {}
*/
slots: import_prop_types10.default.shape({
heading: import_prop_types10.default.elementType,
transition: import_prop_types10.default.elementType
}),
/**
* If `true`, rounded corners are disabled.
* @default false
*/
square: import_prop_types10.default.bool,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types10.default.oneOfType([import_prop_types10.default.arrayOf(import_prop_types10.default.oneOfType([import_prop_types10.default.func, import_prop_types10.default.object, import_prop_types10.default.bool])), import_prop_types10.default.func, import_prop_types10.default.object]),
/**
* The component used for the transition.
* [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
*/
TransitionComponent: import_prop_types10.default.elementType,
/**
* Props applied to the transition element.
* By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
*/
TransitionProps: import_prop_types10.default.object
} : void 0;
var Accordion_default = Accordion;
// node_modules/@mui/material/AccordionActions/AccordionActions.js
var React17 = __toESM(require_react());
var import_prop_types11 = __toESM(require_prop_types());
// node_modules/@mui/material/AccordionActions/accordionActionsClasses.js
function getAccordionActionsUtilityClass(slot) {
return generateUtilityClass("MuiAccordionActions", slot);
}
var accordionActionsClasses = generateUtilityClasses("MuiAccordionActions", ["root", "spacing"]);
var accordionActionsClasses_default = accordionActionsClasses;
// node_modules/@mui/material/AccordionActions/AccordionActions.js
var import_jsx_runtime10 = __toESM(require_jsx_runtime());
var useUtilityClasses5 = (ownerState) => {
const {
classes,
disableSpacing
} = ownerState;
const slots = {
root: ["root", !disableSpacing && "spacing"]
};
return composeClasses(slots, getAccordionActionsUtilityClass, classes);
};
var AccordionActionsRoot = styled_default("div", {
name: "MuiAccordionActions",
slot: "Root",
overridesResolver: (props, styles6) => {
const {
ownerState
} = props;
return [styles6.root, !ownerState.disableSpacing && styles6.spacing];
}
})({
display: "flex",
alignItems: "center",
padding: 8,
justifyContent: "flex-end",
variants: [{
props: (props) => !props.disableSpacing,
style: {
"& > :not(style) ~ :not(style)": {
marginLeft: 8
}
}
}]
});
var AccordionActions = React17.forwardRef(function AccordionActions2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiAccordionActions"
});
const {
className,
disableSpacing = false,
...other
} = props;
const ownerState = {
...props,
disableSpacing
};
const classes = useUtilityClasses5(ownerState);
return (0, import_jsx_runtime10.jsx)(AccordionActionsRoot, {
className: clsx_default(classes.root, className),
ref,
ownerState,
...other
});
});
true ? AccordionActions.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* The content of the component.
*/
children: import_prop_types11.default.node,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types11.default.object,
/**
* @ignore
*/
className: import_prop_types11.default.string,
/**
* If `true`, the actions do not have additional margin.
* @default false
*/
disableSpacing: import_prop_types11.default.bool,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types11.default.oneOfType([import_prop_types11.default.arrayOf(import_prop_types11.default.oneOfType([import_prop_types11.default.func, import_prop_types11.default.object, import_prop_types11.default.bool])), import_prop_types11.default.func, import_prop_types11.default.object])
} : void 0;
var AccordionActions_default = AccordionActions;
// node_modules/@mui/material/AccordionDetails/AccordionDetails.js
var React18 = __toESM(require_react());
var import_prop_types12 = __toESM(require_prop_types());
// node_modules/@mui/material/AccordionDetails/accordionDetailsClasses.js
function getAccordionDetailsUtilityClass(slot) {
return generateUtilityClass("MuiAccordionDetails", slot);
}
var accordionDetailsClasses = generateUtilityClasses("MuiAccordionDetails", ["root"]);
var accordionDetailsClasses_default = accordionDetailsClasses;
// node_modules/@mui/material/AccordionDetails/AccordionDetails.js
var import_jsx_runtime11 = __toESM(require_jsx_runtime());
var useUtilityClasses6 = (ownerState) => {
const {
classes
} = ownerState;
const slots = {
root: ["root"]
};
return composeClasses(slots, getAccordionDetailsUtilityClass, classes);
};
var AccordionDetailsRoot = styled_default("div", {
name: "MuiAccordionDetails",
slot: "Root",
overridesResolver: (props, styles6) => styles6.root
})(memoTheme(({
theme
}) => ({
padding: theme.spacing(1, 2, 2)
})));
var AccordionDetails = React18.forwardRef(function AccordionDetails2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiAccordionDetails"
});
const {
className,
...other
} = props;
const ownerState = props;
const classes = useUtilityClasses6(ownerState);
return (0, import_jsx_runtime11.jsx)(AccordionDetailsRoot, {
className: clsx_default(classes.root, className),
ref,
ownerState,
...other
});
});
true ? AccordionDetails.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* The content of the component.
*/
children: import_prop_types12.default.node,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types12.default.object,
/**
* @ignore
*/
className: import_prop_types12.default.string,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types12.default.oneOfType([import_prop_types12.default.arrayOf(import_prop_types12.default.oneOfType([import_prop_types12.default.func, import_prop_types12.default.object, import_prop_types12.default.bool])), import_prop_types12.default.func, import_prop_types12.default.object])
} : void 0;
var AccordionDetails_default = AccordionDetails;
// node_modules/@mui/material/AccordionSummary/AccordionSummary.js
var React23 = __toESM(require_react());
var import_prop_types16 = __toESM(require_prop_types());
// node_modules/@mui/material/ButtonBase/ButtonBase.js
var React22 = __toESM(require_react());
var import_prop_types15 = __toESM(require_prop_types());
// node_modules/@mui/material/useLazyRipple/useLazyRipple.js
var React19 = __toESM(require_react());
var LazyRipple = class _LazyRipple {
constructor() {
__publicField(this, "mountEffect", () => {
if (this.shouldMount && !this.didMount) {
if (this.ref.current !== null) {
this.didMount = true;
this.mounted.resolve();
}
}
});
this.ref = {
current: null
};
this.mounted = null;
this.didMount = false;
this.shouldMount = false;
this.setShouldMount = null;
}
/** React ref to the ripple instance */
/** If the ripple component should be mounted */
/** Promise that resolves when the ripple component is mounted */
/** If the ripple component has been mounted */
/** React state hook setter */
static create() {
return new _LazyRipple();
}
static use() {
const ripple = useLazyRef(_LazyRipple.create).current;
const [shouldMount, setShouldMount] = React19.useState(false);
ripple.shouldMount = shouldMount;
ripple.setShouldMount = setShouldMount;
React19.useEffect(ripple.mountEffect, [shouldMount]);
return ripple;
}
mount() {
if (!this.mounted) {
this.mounted = createControlledPromise();
this.shouldMount = true;
this.setShouldMount(this.shouldMount);
}
return this.mounted;
}
/* Ripple API */
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;
}
// node_modules/@mui/material/ButtonBase/TouchRipple.js
var React21 = __toESM(require_react());
var import_prop_types14 = __toESM(require_prop_types());
// node_modules/@mui/material/ButtonBase/Ripple.js
var React20 = __toESM(require_react());
var import_prop_types13 = __toESM(require_prop_types());
var import_jsx_runtime12 = __toESM(require_jsx_runtime());
function Ripple(props) {
const {
className,
classes,
pulsate = false,
rippleX,
rippleY,
rippleSize,
in: inProp,
onExited,
timeout: timeout2
} = props;
const [leaving, setLeaving] = React20.useState(false);
const rippleClassName = clsx_default(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_default(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate);
if (!inProp && !leaving) {
setLeaving(true);
}
React20.useEffect(() => {
if (!inProp && onExited != null) {
const timeoutId = setTimeout(onExited, timeout2);
return () => {
clearTimeout(timeoutId);
};
}
return void 0;
}, [onExited, inProp, timeout2]);
return (0, import_jsx_runtime12.jsx)("span", {
className: rippleClassName,
style: rippleStyles,
children: (0, import_jsx_runtime12.jsx)("span", {
className: childClassName
})
});
}
true ? Ripple.propTypes = {
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types13.default.object.isRequired,
className: import_prop_types13.default.string,
/**
* @ignore - injected from TransitionGroup
*/
in: import_prop_types13.default.bool,
/**
* @ignore - injected from TransitionGroup
*/
onExited: import_prop_types13.default.func,
/**
* If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
*/
pulsate: import_prop_types13.default.bool,
/**
* Diameter of the ripple.
*/
rippleSize: import_prop_types13.default.number,
/**
* Horizontal position of the ripple center.
*/
rippleX: import_prop_types13.default.number,
/**
* Vertical position of the ripple center.
*/
rippleY: import_prop_types13.default.number,
/**
* exit delay
*/
timeout: import_prop_types13.default.number.isRequired
} : void 0;
var Ripple_default = Ripple;
// node_modules/@mui/material/ButtonBase/touchRippleClasses.js
function getTouchRippleUtilityClass(slot) {
return generateUtilityClass("MuiTouchRipple", slot);
}
var touchRippleClasses = generateUtilityClasses("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]);
var touchRippleClasses_default = touchRippleClasses;
// node_modules/@mui/material/ButtonBase/TouchRipple.js
var import_jsx_runtime13 = __toESM(require_jsx_runtime());
var DURATION = 550;
var DELAY_RIPPLE = 80;
var enterKeyframe = keyframes`
0% {
transform: scale(0);
opacity: 0.1;
}
100% {
transform: scale(1);
opacity: 0.3;
}
`;
var exitKeyframe = keyframes`
0% {
opacity: 1;
}
100% {
opacity: 0;
}
`;
var pulsateKeyframe = keyframes`
0% {
transform: scale(1);
}
50% {
transform: scale(0.92);
}
100% {
transform: scale(1);
}
`;
var TouchRippleRoot = styled_default("span", {
name: "MuiTouchRipple",
slot: "Root"
})({
overflow: "hidden",
pointerEvents: "none",
position: "absolute",
zIndex: 0,
top: 0,
right: 0,
bottom: 0,
left: 0,
borderRadius: "inherit"
});
var TouchRippleRipple = styled_default(Ripple_default, {
name: "MuiTouchRipple",
slot: "Ripple"
})`
opacity: 0;
position: absolute;
&.${touchRippleClasses_default.rippleVisible} {
opacity: 0.3;
transform: scale(1);
animation-name: ${enterKeyframe};
animation-duration: ${DURATION}ms;
animation-timing-function: ${({
theme
}) => theme.transitions.easing.easeInOut};
}
&.${touchRippleClasses_default.ripplePulsate} {
animation-duration: ${({
theme
}) => theme.transitions.duration.shorter}ms;
}
& .${touchRippleClasses_default.child} {
opacity: 1;
display: block;
width: 100%;
height: 100%;
border-radius: 50%;
background-color: currentColor;
}
& .${touchRippleClasses_default.childLeaving} {
opacity: 0;
animation-name: ${exitKeyframe};
animation-duration: ${DURATION}ms;
animation-timing-function: ${({
theme
}) => theme.transitions.easing.easeInOut};
}
& .${touchRippleClasses_default.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;
}
`;
var TouchRipple = React21.forwardRef(function TouchRipple2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiTouchRipple"
});
const {
center: centerProp = false,
classes = {},
className,
...other
} = props;
const [ripples, setRipples] = React21.useState([]);
const nextKey = React21.useRef(0);
const rippleCallback = React21.useRef(null);
React21.useEffect(() => {
if (rippleCallback.current) {
rippleCallback.current();
rippleCallback.current = null;
}
}, [ripples]);
const ignoringMouseDown = React21.useRef(false);
const startTimer = useTimeout();
const startTimerCommit = React21.useRef(null);
const container = React21.useRef(null);
const startCommit = React21.useCallback((params) => {
const {
pulsate: pulsate2,
rippleX,
rippleY,
rippleSize,
cb
} = params;
setRipples((oldRipples) => [...oldRipples, (0, import_jsx_runtime13.jsx)(TouchRippleRipple, {
classes: {
ripple: clsx_default(classes.ripple, touchRippleClasses_default.ripple),
rippleVisible: clsx_default(classes.rippleVisible, touchRippleClasses_default.rippleVisible),
ripplePulsate: clsx_default(classes.ripplePulsate, touchRippleClasses_default.ripplePulsate),
child: clsx_default(classes.child, touchRippleClasses_default.child),
childLeaving: clsx_default(classes.childLeaving, touchRippleClasses_default.childLeaving),
childPulsate: clsx_default(classes.childPulsate, touchRippleClasses_default.childPulsate)
},
timeout: DURATION,
pulsate: pulsate2,
rippleX,
rippleY,
rippleSize
}, nextKey.current)]);
nextKey.current += 1;
rippleCallback.current = cb;
}, [classes]);
const start2 = React21.useCallback((event = {}, options = {}, cb = () => {
}) => {
const {
pulsate: pulsate2 = false,
center = centerProp || options.pulsate,
fakeElement = false
// For test purposes
} = 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 = React21.useCallback(() => {
start2({}, {
pulsate: true
});
}, [start2]);
const stop = React21.useCallback((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]);
React21.useImperativeHandle(ref, () => ({
pulsate,
start: start2,
stop
}), [pulsate, start2, stop]);
return (0, import_jsx_runtime13.jsx)(TouchRippleRoot, {
className: clsx_default(touchRippleClasses_default.root, classes.root, className),
ref: container,
...other,
children: (0, import_jsx_runtime13.jsx)(TransitionGroup_default, {
component: null,
exit: true,
children: ripples
})
});
});
true ? TouchRipple.propTypes = {
/**
* If `true`, the ripple starts at the center of the component
* rather than at the point of interaction.
*/
center: import_prop_types14.default.bool,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types14.default.object,
/**
* @ignore
*/
className: import_prop_types14.default.string
} : void 0;
var TouchRipple_default = TouchRipple;
// node_modules/@mui/material/ButtonBase/buttonBaseClasses.js
function getButtonBaseUtilityClass(slot) {
return generateUtilityClass("MuiButtonBase", slot);
}
var buttonBaseClasses = generateUtilityClasses("MuiButtonBase", ["root", "disabled", "focusVisible"]);
var buttonBaseClasses_default = buttonBaseClasses;
// node_modules/@mui/material/ButtonBase/ButtonBase.js
var import_jsx_runtime14 = __toESM(require_jsx_runtime());
var useUtilityClasses7 = (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;
};
var ButtonBaseRoot = styled_default("button", {
name: "MuiButtonBase",
slot: "Root",
overridesResolver: (props, styles6) => styles6.root
})({
display: "inline-flex",
alignItems: "center",
justifyContent: "center",
position: "relative",
boxSizing: "border-box",
WebkitTapHighlightColor: "transparent",
backgroundColor: "transparent",
// Reset default value
// We disable the focus ring for mouse, touch and keyboard users.
outline: 0,
border: 0,
margin: 0,
// Remove the margin in Safari
borderRadius: 0,
padding: 0,
// Remove the padding in Firefox
cursor: "pointer",
userSelect: "none",
verticalAlign: "middle",
MozAppearance: "none",
// Reset
WebkitAppearance: "none",
// Reset
textDecoration: "none",
// So we take precedent over the style of a native element.
color: "inherit",
"&::-moz-focus-inner": {
borderStyle: "none"
// Remove Firefox dotted outline.
},
[`&.${buttonBaseClasses_default.disabled}`]: {
pointerEvents: "none",
// Disable link interactions
cursor: "default"
},
"@media print": {
colorAdjust: "exact"
}
});
var ButtonBase = React22.forwardRef(function ButtonBase2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiButtonBase"
});
const {
action,
centerRipple = false,
children: children2,
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 = React22.useRef(null);
const ripple = useLazyRipple();
const handleRippleRef = useForkRef_default(ripple.ref, touchRippleRef);
const [focusVisible, setFocusVisible] = React22.useState(false);
if (disabled && focusVisible) {
setFocusVisible(false);
}
React22.useImperativeHandle(action, () => ({
focusVisible: () => {
setFocusVisible(true);
buttonRef.current.focus();
}
}), []);
const enableTouchRipple = ripple.shouldMount && !disableRipple && !disabled;
React22.useEffect(() => {
if (focusVisible && focusRipple && !disableRipple) {
ripple.pulsate();
}
}, [disableRipple, focusRipple, focusVisible, ripple]);
function useRippleHandler(rippleAction, eventCallback, skipRippleAction = disableTouchRipple) {
return useEventCallback_default2((event) => {
if (eventCallback) {
eventCallback(event);
}
const ignore = skipRippleAction;
if (!ignore) {
ripple[rippleAction](event);
}
return true;
});
}
const handleMouseDown = useRippleHandler("start", onMouseDown);
const handleContextMenu = useRippleHandler("stop", onContextMenu);
const handleDragLeave = useRippleHandler("stop", onDragLeave);
const handleMouseUp = useRippleHandler("stop", onMouseUp);
const handleMouseLeave = useRippleHandler("stop", (event) => {
if (focusVisible) {
event.preventDefault();
}
if (onMouseLeave) {
onMouseLeave(event);
}
});
const handleTouchStart = useRippleHandler("start", onTouchStart);
const handleTouchEnd = useRippleHandler("stop", onTouchEnd);
const handleTouchMove = useRippleHandler("stop", onTouchMove);
const handleBlur = useRippleHandler("stop", (event) => {
if (!isFocusVisible(event.target)) {
setFocusVisible(false);
}
if (onBlur) {
onBlur(event);
}
}, false);
const handleFocus = useEventCallback_default2((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_default2((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_default2((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_default(ref, buttonRef);
const ownerState = {
...props,
centerRipple,
component,
disabled,
disableRipple,
disableTouchRipple,
focusRipple,
tabIndex,
focusVisible
};
const classes = useUtilityClasses7(ownerState);
return (0, import_jsx_runtime14.jsxs)(ButtonBaseRoot, {
as: ComponentProp,
className: clsx_default(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: [children2, enableTouchRipple ? (0, import_jsx_runtime14.jsx)(TouchRipple_default, {
ref: handleRippleRef,
center: centerRipple,
...TouchRippleProps
}) : null]
});
});
true ? ButtonBase.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* A ref for imperative actions.
* It currently only supports `focusVisible()` action.
*/
action: refType_default,
/**
* If `true`, the ripples are centered.
* They won't start at the cursor interaction position.
* @default false
*/
centerRipple: import_prop_types15.default.bool,
/**
* The content of the component.
*/
children: import_prop_types15.default.node,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types15.default.object,
/**
* @ignore
*/
className: import_prop_types15.default.string,
/**
* The component used for the root node.
* Either a string to use a HTML element or a component.
*/
component: elementTypeAcceptingRef_default,
/**
* If `true`, the component is disabled.
* @default false
*/
disabled: import_prop_types15.default.bool,
/**
* If `true`, the ripple effect is disabled.
*
* ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
* to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
* @default false
*/
disableRipple: import_prop_types15.default.bool,
/**
* If `true`, the touch ripple effect is disabled.
* @default false
*/
disableTouchRipple: import_prop_types15.default.bool,
/**
* If `true`, the base button will have a keyboard focus ripple.
* @default false
*/
focusRipple: import_prop_types15.default.bool,
/**
* This prop can help identify which element has keyboard focus.
* The class name will be applied when the element gains the focus through keyboard interaction.
* It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
* The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
* A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
* if needed.
*/
focusVisibleClassName: import_prop_types15.default.string,
/**
* @ignore
*/
href: import_prop_types15.default.any,
/**
* The component used to render a link when the `href` prop is provided.
* @default 'a'
*/
LinkComponent: import_prop_types15.default.elementType,
/**
* @ignore
*/
onBlur: import_prop_types15.default.func,
/**
* @ignore
*/
onClick: import_prop_types15.default.func,
/**
* @ignore
*/
onContextMenu: import_prop_types15.default.func,
/**
* @ignore
*/
onDragLeave: import_prop_types15.default.func,
/**
* @ignore
*/
onFocus: import_prop_types15.default.func,
/**
* Callback fired when the component is focused with a keyboard.
* We trigger a `onFocus` callback too.
*/
onFocusVisible: import_prop_types15.default.func,
/**
* @ignore
*/
onKeyDown: import_prop_types15.default.func,
/**
* @ignore
*/
onKeyUp: import_prop_types15.default.func,
/**
* @ignore
*/
onMouseDown: import_prop_types15.default.func,
/**
* @ignore
*/
onMouseLeave: import_prop_types15.default.func,
/**
* @ignore
*/
onMouseUp: import_prop_types15.default.func,
/**
* @ignore
*/
onTouchEnd: import_prop_types15.default.func,
/**
* @ignore
*/
onTouchMove: import_prop_types15.default.func,
/**
* @ignore
*/
onTouchStart: import_prop_types15.default.func,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types15.default.oneOfType([import_prop_types15.default.arrayOf(import_prop_types15.default.oneOfType([import_prop_types15.default.func, import_prop_types15.default.object, import_prop_types15.default.bool])), import_prop_types15.default.func, import_prop_types15.default.object]),
/**
* @default 0
*/
tabIndex: import_prop_types15.default.number,
/**
* Props applied to the `TouchRipple` element.
*/
TouchRippleProps: import_prop_types15.default.object,
/**
* A ref that points to the `TouchRipple` element.
*/
touchRippleRef: import_prop_types15.default.oneOfType([import_prop_types15.default.func, import_prop_types15.default.shape({
current: import_prop_types15.default.shape({
pulsate: import_prop_types15.default.func.isRequired,
start: import_prop_types15.default.func.isRequired,
stop: import_prop_types15.default.func.isRequired
})
})]),
/**
* @ignore
*/
type: import_prop_types15.default.oneOfType([import_prop_types15.default.oneOf(["button", "reset", "submit"]), import_prop_types15.default.string])
} : void 0;
var ButtonBase_default = ButtonBase;
// node_modules/@mui/material/AccordionSummary/accordionSummaryClasses.js
function getAccordionSummaryUtilityClass(slot) {
return generateUtilityClass("MuiAccordionSummary", slot);
}
var accordionSummaryClasses = generateUtilityClasses("MuiAccordionSummary", ["root", "expanded", "focusVisible", "disabled", "gutters", "contentGutters", "content", "expandIconWrapper"]);
var accordionSummaryClasses_default = accordionSummaryClasses;
// node_modules/@mui/material/AccordionSummary/AccordionSummary.js
var import_jsx_runtime15 = __toESM(require_jsx_runtime());
var useUtilityClasses8 = (ownerState) => {
const {
classes,
expanded,
disabled,
disableGutters
} = ownerState;
const slots = {
root: ["root", expanded && "expanded", disabled && "disabled", !disableGutters && "gutters"],
focusVisible: ["focusVisible"],
content: ["content", expanded && "expanded", !disableGutters && "contentGutters"],
expandIconWrapper: ["expandIconWrapper", expanded && "expanded"]
};
return composeClasses(slots, getAccordionSummaryUtilityClass, classes);
};
var AccordionSummaryRoot = styled_default(ButtonBase_default, {
name: "MuiAccordionSummary",
slot: "Root",
overridesResolver: (props, styles6) => styles6.root
})(memoTheme(({
theme
}) => {
const transition = {
duration: theme.transitions.duration.shortest
};
return {
display: "flex",
minHeight: 48,
padding: theme.spacing(0, 2),
transition: theme.transitions.create(["min-height", "background-color"], transition),
[`&.${accordionSummaryClasses_default.focusVisible}`]: {
backgroundColor: (theme.vars || theme).palette.action.focus
},
[`&.${accordionSummaryClasses_default.disabled}`]: {
opacity: (theme.vars || theme).palette.action.disabledOpacity
},
[`&:hover:not(.${accordionSummaryClasses_default.disabled})`]: {
cursor: "pointer"
},
variants: [{
props: (props) => !props.disableGutters,
style: {
[`&.${accordionSummaryClasses_default.expanded}`]: {
minHeight: 64
}
}
}]
};
}));
var AccordionSummaryContent = styled_default("div", {
name: "MuiAccordionSummary",
slot: "Content",
overridesResolver: (props, styles6) => styles6.content
})(memoTheme(({
theme
}) => ({
display: "flex",
flexGrow: 1,
margin: "12px 0",
variants: [{
props: (props) => !props.disableGutters,
style: {
transition: theme.transitions.create(["margin"], {
duration: theme.transitions.duration.shortest
}),
[`&.${accordionSummaryClasses_default.expanded}`]: {
margin: "20px 0"
}
}
}]
})));
var AccordionSummaryExpandIconWrapper = styled_default("div", {
name: "MuiAccordionSummary",
slot: "ExpandIconWrapper",
overridesResolver: (props, styles6) => styles6.expandIconWrapper
})(memoTheme(({
theme
}) => ({
display: "flex",
color: (theme.vars || theme).palette.action.active,
transform: "rotate(0deg)",
transition: theme.transitions.create("transform", {
duration: theme.transitions.duration.shortest
}),
[`&.${accordionSummaryClasses_default.expanded}`]: {
transform: "rotate(180deg)"
}
})));
var AccordionSummary = React23.forwardRef(function AccordionSummary2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiAccordionSummary"
});
const {
children: children2,
className,
expandIcon,
focusVisibleClassName,
onClick,
...other
} = props;
const {
disabled = false,
disableGutters,
expanded,
toggle
} = React23.useContext(AccordionContext_default);
const handleChange = (event) => {
if (toggle) {
toggle(event);
}
if (onClick) {
onClick(event);
}
};
const ownerState = {
...props,
expanded,
disabled,
disableGutters
};
const classes = useUtilityClasses8(ownerState);
return (0, import_jsx_runtime15.jsxs)(AccordionSummaryRoot, {
focusRipple: false,
disableRipple: true,
disabled,
component: "div",
"aria-expanded": expanded,
className: clsx_default(classes.root, className),
focusVisibleClassName: clsx_default(classes.focusVisible, focusVisibleClassName),
onClick: handleChange,
ref,
ownerState,
...other,
children: [(0, import_jsx_runtime15.jsx)(AccordionSummaryContent, {
className: classes.content,
ownerState,
children: children2
}), expandIcon && (0, import_jsx_runtime15.jsx)(AccordionSummaryExpandIconWrapper, {
className: classes.expandIconWrapper,
ownerState,
children: expandIcon
})]
});
});
true ? AccordionSummary.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* The content of the component.
*/
children: import_prop_types16.default.node,
/**
* Override or extend the styles applied to the component.
*/
classes: import_prop_types16.default.object,
/**
* @ignore
*/
className: import_prop_types16.default.string,
/**
* The icon to display as the expand indicator.
*/
expandIcon: import_prop_types16.default.node,
/**
* This prop can help identify which element has keyboard focus.
* The class name will be applied when the element gains the focus through keyboard interaction.
* It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
* The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
* A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
* if needed.
*/
focusVisibleClassName: import_prop_types16.default.string,
/**
* @ignore
*/
onClick: import_prop_types16.default.func,
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: import_prop_types16.default.oneOfType([import_prop_types16.default.arrayOf(import_prop_types16.default.oneOfType([import_prop_types16.default.func, import_prop_types16.default.object, import_prop_types16.default.bool])), import_prop_types16.default.func, import_prop_types16.default.object])
} : void 0;
var AccordionSummary_default = AccordionSummary;
// node_modules/@mui/material/Alert/Alert.js
var React30 = __toESM(require_react());
var import_prop_types18 = __toESM(require_prop_types());
// node_modules/@mui/material/utils/createSimplePaletteValueFilter.js
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;
}
function createSimplePaletteValueFilter(additionalPropertiesToCheck = []) {
return ([, value]) => value && checkSimplePaletteColorValues(value, additionalPropertiesToCheck);
}
// node_modules/@mui/material/Alert/alertClasses.js
function getAlertUtilityClass(slot) {
return generateUtilityClass("MuiAlert", slot);
}
var alertClasses = generateUtilityClasses("MuiAlert", ["root", "action", "icon", "message", "filled", "colorSuccess", "colorInfo", "colorWarning", "colorError", "filledSuccess", "filledInfo", "filledWarning", "filledError", "outlined", "outlinedSuccess", "outlinedInfo", "outlinedWarning", "outlinedError", "standard", "standardSuccess", "standardInfo", "standardWarning", "standardError"]);
var alertClasses_default = alertClasses;
// node_modules/@mui/material/IconButton/IconButton.js
var React24 = __toESM(require_react());
var import_prop_types17 = __toESM(require_prop_types());
// node_modules/@mui/material/IconButton/iconButtonClasses.js
function getIconButtonUtilityClass(slot) {
return generateUtilityClass("MuiIconButton", slot);
}
var iconButtonClasses = generateUtilityClasses("MuiIconButton", ["root", "disabled", "colorInherit", "colorPrimary", "colorSecondary", "colorError", "colorInfo", "colorSuccess", "colorWarning", "edgeStart", "edgeEnd", "sizeSmall", "sizeMedium", "sizeLarge"]);
var iconButtonClasses_default = iconButtonClasses;
// node_modules/@mui/material/IconButton/IconButton.js
var import_jsx_runtime16 = __toESM(require_jsx_runtime());
var useUtilityClasses9 = (ownerState) => {
const {
classes,
disabled,
color,
edge,
size
} = ownerState;
const slots = {
root: ["root", disabled && "disabled", color !== "default" && `color${capitalize_default(color)}`, edge && `edge${capitalize_default(edge)}`, `size${capitalize_default(size)}`]
};
return composeClasses(slots, getIconButtonUtilityClass, classes);
};
var IconButtonRoot = styled_default(ButtonBase_default, {
name: "MuiIconButton",
slot: "Root",
overridesResolver: (props, styles6) => {
const {
ownerState
} = props;
return [styles6.root, ownerState.color !== "default" && styles6[`color${capitalize_default(ownerState.color)}`], ownerState.edge && styles6[`edge${capitalize_default(ownerState.edge)}`], styles6[`size${capitalize_default(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: {
disableRipple: false
},
style: {
"&:hover": {
backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),
// Reset on touch devices, it doesn't add specificity
"@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,
disableRipple: false
},
style: {
"&:hover": {
backgroundColor: 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),
// Reset on touch devices, it doesn't add specificity
"@media (hover: none)": {
backgroundColor: "transparent"
}
}
}
})), {
props: {
size: "small"
},
style: {
padding: 5,
fontSize: theme.typography.pxToRem(18)
}
}, {
props: {
size: "large"
},
style: {
padding: 12,
fontSize: theme.typography.pxToRem(28)
}
}],
[`&.${iconButtonClasses_default.disabled}`]: {
backgroundColor: "transparent",
color: (theme.vars || theme).palette.action.disabled
}
})));
var IconButton = React24.forwardRef(function IconButton2(inProps, ref) {
const props = useDefaultProps({
props: inProps,
name: "MuiIconButton"
});
const {
edge = false,
children: children2,
className,
color = "default",
disabled = false,
disableFocusRipple = false,
disableRipple = false,
size = "medium",
...other
} = props;
const ownerState = {
...props,
edge,
color,
disabled,
disableFocusRipple,
disableRipple,
size
};
const classes = useUtilityClasses9(ownerState);
return (0, import_jsx_runtime16.jsx)(IconButtonRoot, {
className: clsx_default(classes.root, className),
centerRipple: true,
focusRipple: !disableFocusRipple,
disabled,
disableRipple,
ref,
...other,
ownerState,
children: children2
});
});
true ? IconButton.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the d.ts file and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* The icon to display.
*/
children: chainPropTypes(import_prop_types17.default.node, (props) => {
const found = React24.Children.toArray(props.children).some((child) => React24.isValidElement(child) && child.props.onClick);
if (found) {
return new Error(["MUI: You are providing an onClick event listener to a child of a button element.", "Prefer applying it to the IconButton directly.", "This guarantees that the whole