@mui/material 5.10.2 → 5.10.3

package/Toolbar/toolbarClasses.js

@@ -1,6 +1,17 @@
-import { generateUtilityClass, generateUtilityClasses } from '@mui/base';
-export function getToolbarUtilityClass(slot) {
-  return generateUtilityClass('MuiToolbar', slot);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getToolbarUtilityClass = getToolbarUtilityClass;
+
+var _base = require("@mui/base");
+
+function getToolbarUtilityClass(slot) {
+  return (0, _base.generateUtilityClass)('MuiToolbar', slot);
 }
-const toolbarClasses = generateUtilityClasses('MuiToolbar', ['root', 'gutters', 'regular', 'dense']);
-export default toolbarClasses;
+
+const toolbarClasses = (0, _base.generateUtilityClasses)('MuiToolbar', ['root', 'gutters', 'regular', 'dense']);
+var _default = toolbarClasses;
+exports.default = _default;

package/Tooltip/Tooltip.js

@@ -1,26 +1,60 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _extends from "@babel/runtime/helpers/esm/extends";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.testReset = testReset;
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _clsx = _interopRequireDefault(require("clsx"));
+
+var _utils = require("@mui/utils");
+
+var _base = require("@mui/base");
+
+var _system = require("@mui/system");
+
+var _styled = _interopRequireDefault(require("../styles/styled"));
+
+var _useTheme = _interopRequireDefault(require("../styles/useTheme"));
+
+var _useThemeProps = _interopRequireDefault(require("../styles/useThemeProps"));
+
+var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
+
+var _Grow = _interopRequireDefault(require("../Grow"));
+
+var _Popper = _interopRequireDefault(require("../Popper"));
+
+var _useEventCallback = _interopRequireDefault(require("../utils/useEventCallback"));
+
+var _useForkRef = _interopRequireDefault(require("../utils/useForkRef"));
+
+var _useId = _interopRequireDefault(require("../utils/useId"));
+
+var _useIsFocusVisible = _interopRequireDefault(require("../utils/useIsFocusVisible"));
+
+var _useControlled = _interopRequireDefault(require("../utils/useControlled"));
+
+var _tooltipClasses = _interopRequireWildcard(require("./tooltipClasses"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
 const _excluded = ["arrow", "children", "classes", "components", "componentsProps", "describeChild", "disableFocusListener", "disableHoverListener", "disableInteractive", "disableTouchListener", "enterDelay", "enterNextDelay", "enterTouchDelay", "followCursor", "id", "leaveDelay", "leaveTouchDelay", "onClose", "onOpen", "open", "placement", "PopperComponent", "PopperProps", "title", "TransitionComponent", "TransitionProps"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import clsx from 'clsx';
-import { elementAcceptingRef } from '@mui/utils';
-import { unstable_composeClasses as composeClasses, appendOwnerState } from '@mui/base';
-import { alpha } from '@mui/system';
-import styled from '../styles/styled';
-import useTheme from '../styles/useTheme';
-import useThemeProps from '../styles/useThemeProps';
-import capitalize from '../utils/capitalize';
-import Grow from '../Grow';
-import Popper from '../Popper';
-import useEventCallback from '../utils/useEventCallback';
-import useForkRef from '../utils/useForkRef';
-import useId from '../utils/useId';
-import useIsFocusVisible from '../utils/useIsFocusVisible';
-import useControlled from '../utils/useControlled';
-import tooltipClasses, { getTooltipUtilityClass } from './tooltipClasses';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function round(value) {
   return Math.round(value * 1e5) / 1e5;
@@ -36,13 +70,13 @@ const useUtilityClasses = ownerState => {
   } = ownerState;
   const slots = {
     popper: ['popper', !disableInteractive && 'popperInteractive', arrow && 'popperArrow'],
-    tooltip: ['tooltip', arrow && 'tooltipArrow', touch && 'touch', `tooltipPlacement${capitalize(placement.split('-')[0])}`],
+    tooltip: ['tooltip', arrow && 'tooltipArrow', touch && 'touch', `tooltipPlacement${(0, _capitalize.default)(placement.split('-')[0])}`],
     arrow: ['arrow']
   };
-  return composeClasses(slots, getTooltipUtilityClass, classes);
+  return (0, _base.unstable_composeClasses)(slots, _tooltipClasses.getTooltipUtilityClass, classes);
 };
 
-const TooltipPopper = styled(Popper, {
+const TooltipPopper = (0, _styled.default)(_Popper.default, {
   name: 'MuiTooltip',
   slot: 'Popper',
   overridesResolver: (props, styles) => {
@@ -55,7 +89,7 @@ const TooltipPopper = styled(Popper, {
   theme,
   ownerState,
   open
-}) => _extends({
+}) => (0, _extends2.default)({
   zIndex: (theme.vars || theme).zIndex.tooltip,
   pointerEvents: 'none'
 }, !ownerState.disableInteractive && {
@@ -63,21 +97,21 @@ const TooltipPopper = styled(Popper, {
 }, !open && {
   pointerEvents: 'none'
 }, ownerState.arrow && {
-  [`&[data-popper-placement*="bottom"] .${tooltipClasses.arrow}`]: {
+  [`&[data-popper-placement*="bottom"] .${_tooltipClasses.default.arrow}`]: {
     top: 0,
     marginTop: '-0.71em',
     '&::before': {
       transformOrigin: '0 100%'
     }
   },
-  [`&[data-popper-placement*="top"] .${tooltipClasses.arrow}`]: {
+  [`&[data-popper-placement*="top"] .${_tooltipClasses.default.arrow}`]: {
     bottom: 0,
     marginBottom: '-0.71em',
     '&::before': {
       transformOrigin: '100% 0'
     }
   },
-  [`&[data-popper-placement*="right"] .${tooltipClasses.arrow}`]: _extends({}, !ownerState.isRtl ? {
+  [`&[data-popper-placement*="right"] .${_tooltipClasses.default.arrow}`]: (0, _extends2.default)({}, !ownerState.isRtl ? {
     left: 0,
     marginLeft: '-0.71em'
   } : {
@@ -90,7 +124,7 @@ const TooltipPopper = styled(Popper, {
       transformOrigin: '100% 100%'
     }
   }),
-  [`&[data-popper-placement*="left"] .${tooltipClasses.arrow}`]: _extends({}, !ownerState.isRtl ? {
+  [`&[data-popper-placement*="left"] .${_tooltipClasses.default.arrow}`]: (0, _extends2.default)({}, !ownerState.isRtl ? {
     right: 0,
     marginRight: '-0.71em'
   } : {
@@ -104,20 +138,20 @@ const TooltipPopper = styled(Popper, {
     }
   })
 }));
-const TooltipTooltip = styled('div', {
+const TooltipTooltip = (0, _styled.default)('div', {
   name: 'MuiTooltip',
   slot: 'Tooltip',
   overridesResolver: (props, styles) => {
     const {
       ownerState
     } = props;
-    return [styles.tooltip, ownerState.touch && styles.touch, ownerState.arrow && styles.tooltipArrow, styles[`tooltipPlacement${capitalize(ownerState.placement.split('-')[0])}`]];
+    return [styles.tooltip, ownerState.touch && styles.touch, ownerState.arrow && styles.tooltipArrow, styles[`tooltipPlacement${(0, _capitalize.default)(ownerState.placement.split('-')[0])}`]];
   }
 })(({
   theme,
   ownerState
-}) => _extends({
-  backgroundColor: theme.vars ? theme.vars.palette.Tooltip.bg : alpha(theme.palette.grey[700], 0.92),
+}) => (0, _extends2.default)({
+  backgroundColor: theme.vars ? theme.vars.palette.Tooltip.bg : (0, _system.alpha)(theme.palette.grey[700], 0.92),
   borderRadius: (theme.vars || theme).shape.borderRadius,
   color: (theme.vars || theme).palette.common.white,
   fontFamily: theme.typography.fontFamily,
@@ -136,42 +170,42 @@ const TooltipTooltip = styled('div', {
   lineHeight: `${round(16 / 14)}em`,
   fontWeight: theme.typography.fontWeightRegular
 }, {
-  [`.${tooltipClasses.popper}[data-popper-placement*="left"] &`]: _extends({
+  [`.${_tooltipClasses.default.popper}[data-popper-placement*="left"] &`]: (0, _extends2.default)({
     transformOrigin: 'right center'
-  }, !ownerState.isRtl ? _extends({
+  }, !ownerState.isRtl ? (0, _extends2.default)({
     marginRight: '14px'
   }, ownerState.touch && {
     marginRight: '24px'
-  }) : _extends({
+  }) : (0, _extends2.default)({
     marginLeft: '14px'
   }, ownerState.touch && {
     marginLeft: '24px'
   })),
-  [`.${tooltipClasses.popper}[data-popper-placement*="right"] &`]: _extends({
+  [`.${_tooltipClasses.default.popper}[data-popper-placement*="right"] &`]: (0, _extends2.default)({
     transformOrigin: 'left center'
-  }, !ownerState.isRtl ? _extends({
+  }, !ownerState.isRtl ? (0, _extends2.default)({
     marginLeft: '14px'
   }, ownerState.touch && {
     marginLeft: '24px'
-  }) : _extends({
+  }) : (0, _extends2.default)({
     marginRight: '14px'
   }, ownerState.touch && {
     marginRight: '24px'
   })),
-  [`.${tooltipClasses.popper}[data-popper-placement*="top"] &`]: _extends({
+  [`.${_tooltipClasses.default.popper}[data-popper-placement*="top"] &`]: (0, _extends2.default)({
     transformOrigin: 'center bottom',
     marginBottom: '14px'
   }, ownerState.touch && {
     marginBottom: '24px'
   }),
-  [`.${tooltipClasses.popper}[data-popper-placement*="bottom"] &`]: _extends({
+  [`.${_tooltipClasses.default.popper}[data-popper-placement*="bottom"] &`]: (0, _extends2.default)({
     transformOrigin: 'center top',
     marginTop: '14px'
   }, ownerState.touch && {
     marginTop: '24px'
   })
 }));
-const TooltipArrow = styled('span', {
+const TooltipArrow = (0, _styled.default)('span', {
   name: 'MuiTooltip',
   slot: 'Arrow',
   overridesResolver: (props, styles) => styles.arrow
@@ -185,7 +219,7 @@ const TooltipArrow = styled('span', {
   /* = width / sqrt(2) = (length of the hypotenuse) */
   ,
   boxSizing: 'border-box',
-  color: theme.vars ? theme.vars.palette.Tooltip.bg : alpha(theme.palette.grey[700], 0.9),
+  color: theme.vars ? theme.vars.palette.Tooltip.bg : (0, _system.alpha)(theme.palette.grey[700], 0.9),
   '&::before': {
     content: '""',
     margin: 'auto',
@@ -198,7 +232,8 @@ const TooltipArrow = styled('span', {
 }));
 let hystersisOpen = false;
 let hystersisTimer = null;
-export function testReset() {
+
+function testReset() {
   hystersisOpen = false;
   clearTimeout(hystersisTimer);
 }
@@ -217,11 +252,10 @@ function composeEventHandler(handler, eventHandler) {
 const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
   var _components$Popper, _ref, _components$Transitio, _components$Tooltip, _components$Arrow, _componentsProps$popp;
 
-  const props = useThemeProps({
+  const props = (0, _useThemeProps.default)({
     props: inProps,
     name: 'MuiTooltip'
   });
-
   const {
     arrow = false,
     children,
@@ -246,12 +280,11 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     PopperComponent: PopperComponentProp,
     PopperProps = {},
     title,
-    TransitionComponent: TransitionComponentProp = Grow,
+    TransitionComponent: TransitionComponentProp = _Grow.default,
     TransitionProps
   } = props,
-        other = _objectWithoutPropertiesLoose(props, _excluded);
-
-  const theme = useTheme();
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const theme = (0, _useTheme.default)();
   const isRtl = theme.direction === 'rtl';
   const [childNode, setChildNode] = React.useState();
   const [arrowRef, setArrowRef] = React.useState(null);
@@ -261,7 +294,7 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
   const enterTimer = React.useRef();
   const leaveTimer = React.useRef();
   const touchTimer = React.useRef();
-  const [openState, setOpenState] = useControlled({
+  const [openState, setOpenState] = (0, _useControlled.default)({
     controlled: openProp,
     default: false,
     name: 'Tooltip',
@@ -282,7 +315,7 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     }, [title, childNode, isControlled]);
   }
 
-  const id = useId(idProp);
+  const id = (0, _useId.default)(idProp);
   const prevUserSelect = React.useRef();
   const stopTouchInteraction = React.useCallback(() => {
     if (prevUserSelect.current !== undefined) {
@@ -314,7 +347,7 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     }
   };
 
-  const handleClose = useEventCallback(
+  const handleClose = (0, _useEventCallback.default)(
   /**
    * @param {React.SyntheticEvent | Event} event
    */
@@ -372,7 +405,7 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     onBlur: handleBlurVisible,
     onFocus: handleFocusVisible,
     ref: focusVisibleRef
-  } = useIsFocusVisible(); // We don't necessarily care about the focusVisible state (which is safe to access via ref anyway).
+  } = (0, _useIsFocusVisible.default)(); // We don't necessarily care about the focusVisible state (which is safe to access via ref anyway).
   // We just need to re-render the Tooltip if the focus-visible state changes.
 
   const [, setChildIsFocusVisible] = React.useState(false);
@@ -461,9 +494,9 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
       document.removeEventListener('keydown', handleKeyDown);
     };
   }, [handleClose, open]);
-  const handleUseRef = useForkRef(setChildNode, ref);
-  const handleFocusRef = useForkRef(focusVisibleRef, handleUseRef);
-  const handleRef = useForkRef(children.ref, handleFocusRef); // There is no point in displaying an empty tooltip.
+  const handleUseRef = (0, _useForkRef.default)(setChildNode, ref);
+  const handleFocusRef = (0, _useForkRef.default)(focusVisibleRef, handleUseRef);
+  const handleRef = (0, _useForkRef.default)(children.ref, handleFocusRef); // There is no point in displaying an empty tooltip.
 
   if (title === '') {
     open = false;
@@ -503,8 +536,8 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     nameOrDescProps['aria-labelledby'] = open && !titleIsString ? id : null;
   }
 
-  const childrenProps = _extends({}, nameOrDescProps, other, children.props, {
-    className: clsx(other.className, children.props.className),
+  const childrenProps = (0, _extends2.default)({}, nameOrDescProps, other, children.props, {
+    className: (0, _clsx.default)(other.className, children.props.className),
     onTouchStart: detectTouchStart,
     ref: handleRef
   }, followCursor ? {
@@ -570,12 +603,11 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
       tooltipModifiers = tooltipModifiers.concat(PopperProps.popperOptions.modifiers);
     }
 
-    return _extends({}, PopperProps.popperOptions, {
+    return (0, _extends2.default)({}, PopperProps.popperOptions, {
       modifiers: tooltipModifiers
     });
   }, [arrowRef, PopperProps]);
-
-  const ownerState = _extends({}, props, {
+  const ownerState = (0, _extends2.default)({}, props, {
     isRtl,
     arrow,
     disableInteractive,
@@ -583,19 +615,18 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
     PopperComponentProp,
     touch: ignoreNonTouchEvents.current
   });
-
   const classes = useUtilityClasses(ownerState);
   const PopperComponent = (_components$Popper = components.Popper) != null ? _components$Popper : TooltipPopper;
-  const TransitionComponent = (_ref = (_components$Transitio = components.Transition) != null ? _components$Transitio : TransitionComponentProp) != null ? _ref : Grow;
+  const TransitionComponent = (_ref = (_components$Transitio = components.Transition) != null ? _components$Transitio : TransitionComponentProp) != null ? _ref : _Grow.default;
   const TooltipComponent = (_components$Tooltip = components.Tooltip) != null ? _components$Tooltip : TooltipTooltip;
   const ArrowComponent = (_components$Arrow = components.Arrow) != null ? _components$Arrow : TooltipArrow;
-  const popperProps = appendOwnerState(PopperComponent, _extends({}, PopperProps, componentsProps.popper), ownerState);
-  const transitionProps = appendOwnerState(TransitionComponent, _extends({}, TransitionProps, componentsProps.transition), ownerState);
-  const tooltipProps = appendOwnerState(TooltipComponent, _extends({}, componentsProps.tooltip), ownerState);
-  const tooltipArrowProps = appendOwnerState(ArrowComponent, _extends({}, componentsProps.arrow), ownerState);
-  return /*#__PURE__*/_jsxs(React.Fragment, {
-    children: [/*#__PURE__*/React.cloneElement(children, childrenProps), /*#__PURE__*/_jsx(PopperComponent, _extends({
-      as: PopperComponentProp != null ? PopperComponentProp : Popper,
+  const popperProps = (0, _base.appendOwnerState)(PopperComponent, (0, _extends2.default)({}, PopperProps, componentsProps.popper), ownerState);
+  const transitionProps = (0, _base.appendOwnerState)(TransitionComponent, (0, _extends2.default)({}, TransitionProps, componentsProps.transition), ownerState);
+  const tooltipProps = (0, _base.appendOwnerState)(TooltipComponent, (0, _extends2.default)({}, componentsProps.tooltip), ownerState);
+  const tooltipArrowProps = (0, _base.appendOwnerState)(ArrowComponent, (0, _extends2.default)({}, componentsProps.arrow), ownerState);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
+    children: [/*#__PURE__*/React.cloneElement(children, childrenProps), /*#__PURE__*/(0, _jsxRuntime.jsx)(PopperComponent, (0, _extends2.default)({
+      as: PopperComponentProp != null ? PopperComponentProp : _Popper.default,
       placement: placement,
       anchorEl: followCursor ? {
         getBoundingClientRect: () => ({
@@ -612,20 +643,20 @@ const Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(inProps, ref) {
       id: id,
       transition: true
     }, interactiveWrapperListeners, popperProps, {
-      className: clsx(classes.popper, PopperProps == null ? void 0 : PopperProps.className, (_componentsProps$popp = componentsProps.popper) == null ? void 0 : _componentsProps$popp.className),
+      className: (0, _clsx.default)(classes.popper, PopperProps == null ? void 0 : PopperProps.className, (_componentsProps$popp = componentsProps.popper) == null ? void 0 : _componentsProps$popp.className),
       popperOptions: popperOptions,
       children: ({
         TransitionProps: TransitionPropsInner
       }) => {
         var _componentsProps$tool, _componentsProps$arro;
 
-        return /*#__PURE__*/_jsx(TransitionComponent, _extends({
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(TransitionComponent, (0, _extends2.default)({
           timeout: theme.transitions.duration.shorter
         }, TransitionPropsInner, transitionProps, {
-          children: /*#__PURE__*/_jsxs(TooltipComponent, _extends({}, tooltipProps, {
-            className: clsx(classes.tooltip, (_componentsProps$tool = componentsProps.tooltip) == null ? void 0 : _componentsProps$tool.className),
-            children: [title, arrow ? /*#__PURE__*/_jsx(ArrowComponent, _extends({}, tooltipArrowProps, {
-              className: clsx(classes.arrow, (_componentsProps$arro = componentsProps.arrow) == null ? void 0 : _componentsProps$arro.className),
+          children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(TooltipComponent, (0, _extends2.default)({}, tooltipProps, {
+            className: (0, _clsx.default)(classes.tooltip, (_componentsProps$tool = componentsProps.tooltip) == null ? void 0 : _componentsProps$tool.className),
+            children: [title, arrow ? /*#__PURE__*/(0, _jsxRuntime.jsx)(ArrowComponent, (0, _extends2.default)({}, tooltipArrowProps, {
+              className: (0, _clsx.default)(classes.arrow, (_componentsProps$arro = componentsProps.arrow) == null ? void 0 : _componentsProps$arro.className),
               ref: setArrowRef
             })) : null]
           }))
@@ -646,33 +677,33 @@ process.env.NODE_ENV !== "production" ? Tooltip.propTypes
    * If `true`, adds an arrow to the tooltip.
    * @default false
    */
-  arrow: PropTypes.bool,
+  arrow: _propTypes.default.bool,
 
   /**
    * Tooltip reference element.
    */
-  children: elementAcceptingRef.isRequired,
+  children: _utils.elementAcceptingRef.isRequired,
 
   /**
    * Override or extend the styles applied to the component.
    */
-  classes: PropTypes.object,
+  classes: _propTypes.default.object,
 
   /**
    * @ignore
    */
-  className: PropTypes.string,
+  className: _propTypes.default.string,
 
   /**
    * The components used for each slot inside the Tooltip.
    * Either a string to use a HTML element or a component.
    * @default {}
    */
-  components: PropTypes.shape({
-    Arrow: PropTypes.elementType,
-    Popper: PropTypes.elementType,
-    Tooltip: PropTypes.elementType,
-    Transition: PropTypes.elementType
+  components: _propTypes.default.shape({
+    Arrow: _propTypes.default.elementType,
+    Popper: _propTypes.default.elementType,
+    Tooltip: _propTypes.default.elementType,
+    Transition: _propTypes.default.elementType
   }),
 
   /**
@@ -681,11 +712,11 @@ process.env.NODE_ENV !== "production" ? Tooltip.propTypes
    * and `componentsProps.transition` prop values win over `TransitionProps` if both are applied.
    * @default {}
    */
-  componentsProps: PropTypes.shape({
-    arrow: PropTypes.object,
-    popper: PropTypes.object,
-    tooltip: PropTypes.object,
-    transition: PropTypes.object
+  componentsProps: _propTypes.default.shape({
+    arrow: _propTypes.default.object,
+    popper: _propTypes.default.object,
+    tooltip: _propTypes.default.object,
+    transition: _propTypes.default.object
   }),
 
   /**
@@ -693,123 +724,123 @@ process.env.NODE_ENV !== "production" ? Tooltip.propTypes
    * By default the `title` acts as an accessible label for the child.
    * @default false
    */
-  describeChild: PropTypes.bool,
+  describeChild: _propTypes.default.bool,
 
   /**
    * Do not respond to focus-visible events.
    * @default false
    */
-  disableFocusListener: PropTypes.bool,
+  disableFocusListener: _propTypes.default.bool,
 
   /**
    * Do not respond to hover events.
    * @default false
    */
-  disableHoverListener: PropTypes.bool,
+  disableHoverListener: _propTypes.default.bool,
 
   /**
    * Makes a tooltip not interactive, i.e. it will close when the user
    * hovers over the tooltip before the `leaveDelay` is expired.
    * @default false
    */
-  disableInteractive: PropTypes.bool,
+  disableInteractive: _propTypes.default.bool,
 
   /**
    * Do not respond to long press touch events.
    * @default false
    */
-  disableTouchListener: PropTypes.bool,
+  disableTouchListener: _propTypes.default.bool,
 
   /**
    * The number of milliseconds to wait before showing the tooltip.
    * This prop won't impact the enter touch delay (`enterTouchDelay`).
    * @default 100
    */
-  enterDelay: PropTypes.number,
+  enterDelay: _propTypes.default.number,
 
   /**
    * The number of milliseconds to wait before showing the tooltip when one was already recently opened.
    * @default 0
    */
-  enterNextDelay: PropTypes.number,
+  enterNextDelay: _propTypes.default.number,
 
   /**
    * The number of milliseconds a user must touch the element before showing the tooltip.
    * @default 700
    */
-  enterTouchDelay: PropTypes.number,
+  enterTouchDelay: _propTypes.default.number,
 
   /**
    * If `true`, the tooltip follow the cursor over the wrapped element.
    * @default false
    */
-  followCursor: PropTypes.bool,
+  followCursor: _propTypes.default.bool,
 
   /**
    * This prop is used to help implement the accessibility logic.
    * If you don't provide this prop. It falls back to a randomly generated id.
    */
-  id: PropTypes.string,
+  id: _propTypes.default.string,
 
   /**
    * The number of milliseconds to wait before hiding the tooltip.
    * This prop won't impact the leave touch delay (`leaveTouchDelay`).
    * @default 0
    */
-  leaveDelay: PropTypes.number,
+  leaveDelay: _propTypes.default.number,
 
   /**
    * The number of milliseconds after the user stops touching an element before hiding the tooltip.
    * @default 1500
    */
-  leaveTouchDelay: PropTypes.number,
+  leaveTouchDelay: _propTypes.default.number,
 
   /**
    * Callback fired when the component requests to be closed.
    *
    * @param {React.SyntheticEvent} event The event source of the callback.
    */
-  onClose: PropTypes.func,
+  onClose: _propTypes.default.func,
 
   /**
    * Callback fired when the component requests to be open.
    *
    * @param {React.SyntheticEvent} event The event source of the callback.
    */
-  onOpen: PropTypes.func,
+  onOpen: _propTypes.default.func,
 
   /**
    * If `true`, the component is shown.
    */
-  open: PropTypes.bool,
+  open: _propTypes.default.bool,
 
   /**
    * Tooltip placement.
    * @default 'bottom'
    */
-  placement: PropTypes.oneOf(['bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+  placement: _propTypes.default.oneOf(['bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
 
   /**
    * The component used for the popper.
    * @default Popper
    */
-  PopperComponent: PropTypes.elementType,
+  PopperComponent: _propTypes.default.elementType,
 
   /**
    * Props applied to the [`Popper`](/material-ui/api/popper/) element.
    * @default {}
    */
-  PopperProps: PropTypes.object,
+  PopperProps: _propTypes.default.object,
 
   /**
    * The system prop that allows defining system overrides as well as additional CSS styles.
    */
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
 
   /**
    * Tooltip title. Zero-length titles string are never displayed.
    */
-  title: PropTypes
+  title: _propTypes.default
   /* @typescript-to-proptypes-ignore */
   .node.isRequired,
 
@@ -818,12 +849,13 @@ process.env.NODE_ENV !== "production" ? Tooltip.propTypes
    * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
    * @default Grow
    */
-  TransitionComponent: PropTypes.elementType,
+  TransitionComponent: _propTypes.default.elementType,
 
   /**
    * Props applied to the transition element.
    * By default, the element is based on this [`Transition`](http://reactcommunity.org/react-transition-group/transition/) component.
    */
-  TransitionProps: PropTypes.object
+  TransitionProps: _propTypes.default.object
 } : void 0;
-export default Tooltip;
+var _default = Tooltip;
+exports.default = _default;