@tenancy.nz/datepicker 1.3.4

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickerPopper/PickerPopper.js

@@ -0,0 +1,344 @@
+import _extends from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import * as React from 'react';
+import Grow from '@mui/material/Grow';
+import Fade from '@mui/material/Fade';
+import MuiPaper from '@mui/material/Paper';
+import MuiPopper from '@mui/material/Popper';
+import BaseFocusTrap from '@mui/material/Unstable_TrapFocus';
+import { useThemeProps, styled } from '@mui/material/styles';
+import { getPickerPopperUtilityClass } from './pickerPopperClasses.js';
+import { getActiveElement, executeInTheNextEventLoopTick } from '../../utils/utils.js';
+import { usePickerPrivateContext } from '../../hooks/usePickerPrivateContext.js';
+import { jsx } from 'react/jsx-runtime';
+import { usePickerContext } from '../../../hooks/usePickerContext.js';
+import useEventCallback from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js';
+import useForkRef from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useForkRef/useForkRef.js';
+import useSlotProps from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js';
+import composeClasses from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.js';
+import ownerDocument from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js';
+
+const _excluded = ["PaperComponent", "ownerState", "children", "paperSlotProps", "paperClasses", "onPaperClick", "onPaperTouchStart"];
+const useUtilityClasses = classes => {
+  const slots = {
+    root: ['root'],
+    paper: ['paper']
+  };
+  return composeClasses(slots, getPickerPopperUtilityClass, classes);
+};
+const PickerPopperRoot = styled(MuiPopper, {
+  name: 'MuiPickerPopper',
+  slot: 'Root'
+})(({
+  theme
+}) => ({
+  zIndex: theme.zIndex.modal
+}));
+const PickerPopperPaper = styled(MuiPaper, {
+  name: 'MuiPickerPopper',
+  slot: 'Paper'
+})({
+  outline: 0,
+  transformOrigin: 'top center',
+  variants: [{
+    props: ({
+      popperPlacement
+    }) => new Set(['top', 'top-start', 'top-end']).has(popperPlacement),
+    style: {
+      transformOrigin: 'bottom center'
+    }
+  }]
+});
+function clickedRootScrollbar(event, doc) {
+  return doc.documentElement.clientWidth < event.clientX || doc.documentElement.clientHeight < event.clientY;
+}
+/**
+ * Based on @mui/material/ClickAwayListener without the customization.
+ * We can probably strip away even more since children won't be portaled.
+ * @param {boolean} active Only listen to clicks when the popper is opened.
+ * @param {(event: MouseEvent | TouchEvent) => void} onClickAway The callback to call when clicking outside the popper.
+ * @returns {Array} The ref and event handler to listen to the outside clicks.
+ */
+function useClickAwayListener(active, onClickAway) {
+  const movedRef = React.useRef(false);
+  const syntheticEventRef = React.useRef(false);
+  const nodeRef = React.useRef(null);
+  const activatedRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!active) {
+      return undefined;
+    }
+
+    // Ensure that this hook is not "activated" synchronously.
+    // https://github.com/facebook/react/issues/20074
+    function armClickAwayListener() {
+      activatedRef.current = true;
+    }
+    document.addEventListener('mousedown', armClickAwayListener, true);
+    document.addEventListener('touchstart', armClickAwayListener, true);
+    return () => {
+      document.removeEventListener('mousedown', armClickAwayListener, true);
+      document.removeEventListener('touchstart', armClickAwayListener, true);
+      activatedRef.current = false;
+    };
+  }, [active]);
+
+  // The handler doesn't take event.defaultPrevented into account:
+  //
+  // event.preventDefault() is meant to stop default behaviors like
+  // clicking a checkbox to check it, hitting a button to submit a form,
+  // and hitting left arrow to move the cursor in a text input etc.
+  // Only special HTML elements have these default behaviors.
+  const handleClickAway = useEventCallback(event => {
+    if (!activatedRef.current) {
+      return;
+    }
+
+    // Given developers can stop the propagation of the synthetic event,
+    // we can only be confident with a positive value.
+    const insideReactTree = syntheticEventRef.current;
+    syntheticEventRef.current = false;
+    const doc = ownerDocument(nodeRef.current);
+
+    // 1. IE11 support, which trigger the handleClickAway even after the unbind
+    // 2. The child might render null.
+    // 3. Behave like a blur listener.
+    if (!nodeRef.current ||
+    // is a TouchEvent?
+    'clientX' in event && clickedRootScrollbar(event, doc)) {
+      return;
+    }
+
+    // Do not act if user performed touchmove
+    if (movedRef.current) {
+      movedRef.current = false;
+      return;
+    }
+    let insideDOM;
+
+    // If not enough, can use https://github.com/DieterHolvoet/event-propagation-path/blob/master/propagationPath.js
+    if (event.composedPath) {
+      insideDOM = event.composedPath().indexOf(nodeRef.current) > -1;
+    } else {
+      insideDOM = !doc.documentElement.contains(event.target) || nodeRef.current.contains(event.target);
+    }
+    if (!insideDOM && !insideReactTree) {
+      onClickAway(event);
+    }
+  });
+
+  // Keep track of mouse/touch events that bubbled up through the portal.
+  const handleSynthetic = event => {
+    // Ignore events handled by our internal components
+    if (!event.defaultMuiPrevented) {
+      syntheticEventRef.current = true;
+    }
+  };
+  React.useEffect(() => {
+    if (active) {
+      const doc = ownerDocument(nodeRef.current);
+      const handleTouchMove = () => {
+        movedRef.current = true;
+      };
+      doc.addEventListener('touchstart', handleClickAway);
+      doc.addEventListener('touchmove', handleTouchMove);
+      return () => {
+        doc.removeEventListener('touchstart', handleClickAway);
+        doc.removeEventListener('touchmove', handleTouchMove);
+      };
+    }
+    return undefined;
+  }, [active, handleClickAway]);
+  React.useEffect(() => {
+    // TODO This behavior is not tested automatically
+    // It's unclear whether this is due to different update semantics in test (batched in act() vs discrete on click).
+    // Or if this is a timing related issues due to different Transition components
+    // Once we get rid of all the manual scheduling (for example setTimeout(update, 0)) we can revisit this code+test.
+    if (active) {
+      const doc = ownerDocument(nodeRef.current);
+      doc.addEventListener('click', handleClickAway);
+      return () => {
+        doc.removeEventListener('click', handleClickAway);
+        // cleanup `handleClickAway`
+        syntheticEventRef.current = false;
+      };
+    }
+    return undefined;
+  }, [active, handleClickAway]);
+  return [nodeRef, handleSynthetic, handleSynthetic];
+}
+const PickerPopperPaperWrapper = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+      PaperComponent,
+      ownerState,
+      children,
+      paperSlotProps,
+      paperClasses,
+      onPaperClick,
+      onPaperTouchStart
+      // picks up the style props provided by `Transition`
+      // https://mui.com/material-ui/transitions/#child-requirement
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const paperProps = useSlotProps({
+    elementType: PaperComponent,
+    externalSlotProps: paperSlotProps,
+    additionalProps: {
+      tabIndex: -1,
+      elevation: 8,
+      ref
+    },
+    className: paperClasses,
+    ownerState
+  });
+  return /*#__PURE__*/jsx(PaperComponent, _extends({}, other, paperProps, {
+    onClick: event => {
+      onPaperClick(event);
+      paperProps.onClick?.(event);
+    },
+    onTouchStart: event => {
+      onPaperTouchStart(event);
+      paperProps.onTouchStart?.(event);
+    },
+    ownerState: ownerState,
+    children: children
+  }));
+});
+if (process.env.NODE_ENV !== "production") PickerPopperPaperWrapper.displayName = "PickerPopperPaperWrapper";
+function PickerPopper(inProps) {
+  const props = useThemeProps({
+    props: inProps,
+    name: 'MuiPickerPopper'
+  });
+  const {
+    children,
+    placement = 'bottom-start',
+    slots,
+    slotProps,
+    classes: classesProp
+  } = props;
+  const {
+    open,
+    popupRef,
+    reduceAnimations
+  } = usePickerContext();
+  const {
+    ownerState: pickerOwnerState,
+    rootRefObject
+  } = usePickerPrivateContext();
+  const {
+    dismissViews,
+    getCurrentViewMode,
+    onPopperExited,
+    triggerElement,
+    viewContainerRole
+  } = usePickerPrivateContext();
+  React.useEffect(() => {
+    function handleKeyDown(nativeEvent) {
+      if (open && nativeEvent.key === 'Escape') {
+        dismissViews();
+      }
+    }
+    document.addEventListener('keydown', handleKeyDown);
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [dismissViews, open]);
+  const lastFocusedElementRef = React.useRef(null);
+  React.useEffect(() => {
+    if (viewContainerRole === 'tooltip' || getCurrentViewMode() === 'field') {
+      return;
+    }
+    if (open) {
+      lastFocusedElementRef.current = getActiveElement(rootRefObject.current);
+    } else if (lastFocusedElementRef.current && lastFocusedElementRef.current instanceof HTMLElement) {
+      // make sure the button is flushed with updated label, before returning focus to it
+      // avoids issue, where screen reader could fail to announce selected date after selection
+      setTimeout(() => {
+        if (lastFocusedElementRef.current instanceof HTMLElement) {
+          lastFocusedElementRef.current.focus();
+        }
+      });
+    }
+  }, [open, viewContainerRole, getCurrentViewMode, rootRefObject]);
+  const classes = useUtilityClasses(classesProp);
+  const handleClickAway = useEventCallback(() => {
+    if (viewContainerRole === 'tooltip') {
+      executeInTheNextEventLoopTick(() => {
+        if (rootRefObject.current?.contains(getActiveElement(rootRefObject.current)) || popupRef.current?.contains(getActiveElement(popupRef.current))) {
+          return;
+        }
+        dismissViews();
+      });
+    } else {
+      dismissViews();
+    }
+  });
+  const [clickAwayRef, onPaperClick, onPaperTouchStart] = useClickAwayListener(open, handleClickAway);
+  const paperRef = React.useRef(null);
+  const handleRef = useForkRef(paperRef, popupRef);
+  const handlePaperRef = useForkRef(handleRef, clickAwayRef);
+  const handleKeyDown = event => {
+    if (event.key === 'Escape') {
+      // stop the propagation to avoid closing parent modal
+      event.stopPropagation();
+      dismissViews();
+    }
+  };
+  const Transition = slots?.desktopTransition ?? reduceAnimations ? Fade : Grow;
+  const FocusTrap = slots?.desktopTrapFocus ?? BaseFocusTrap;
+  const Paper = slots?.desktopPaper ?? PickerPopperPaper;
+  const Popper = slots?.popper ?? PickerPopperRoot;
+  const popperProps = useSlotProps({
+    elementType: Popper,
+    externalSlotProps: slotProps?.popper,
+    additionalProps: {
+      transition: true,
+      role: viewContainerRole == null ? undefined : viewContainerRole,
+      open,
+      placement,
+      anchorEl: triggerElement,
+      onKeyDown: handleKeyDown
+    },
+    className: classes.root,
+    ownerState: pickerOwnerState
+  });
+  const ownerState = React.useMemo(() => _extends({}, pickerOwnerState, {
+    popperPlacement: popperProps.placement
+  }), [pickerOwnerState, popperProps.placement]);
+  return /*#__PURE__*/jsx(Popper, _extends({}, popperProps, {
+    children: ({
+      TransitionProps
+    }) => /*#__PURE__*/jsx(FocusTrap, _extends({
+      open: open,
+      disableAutoFocus: true
+      // pickers are managing focus position manually
+      // without this prop the focus is returned to the button before `aria-label` is updated
+      // which would force screen readers to read too old label
+      ,
+      disableRestoreFocus: true,
+      disableEnforceFocus: viewContainerRole === 'tooltip',
+      isEnabled: () => true
+    }, slotProps?.desktopTrapFocus, {
+      children: /*#__PURE__*/jsx(Transition, _extends({}, TransitionProps, slotProps?.desktopTransition, {
+        onExited: event => {
+          onPopperExited?.();
+          slotProps?.desktopTransition?.onExited?.(event);
+          TransitionProps?.onExited?.();
+        },
+        children: /*#__PURE__*/jsx(PickerPopperPaperWrapper, {
+          PaperComponent: Paper,
+          ownerState: ownerState,
+          ref: handlePaperRef,
+          onPaperClick: onPaperClick,
+          onPaperTouchStart: onPaperTouchStart,
+          paperClasses: classes.paper,
+          paperSlotProps: slotProps?.desktopPaper,
+          children: children
+        })
+      }))
+    }))
+  }));
+}
+
+export { PickerPopper };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickerPopper/pickerPopperClasses.js

@@ -0,0 +1,9 @@
+import generateUtilityClass from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js';
+import generateUtilityClasses from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js';
+
+function getPickerPopperUtilityClass(slot) {
+  return generateUtilityClass('MuiPickerPopper', slot);
+}
+generateUtilityClasses('MuiPickerPopper', ['root', 'paper']);
+
+export { getPickerPopperUtilityClass };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickerProvider.js

@@ -0,0 +1,71 @@
+import * as React from 'react';
+import { IsValidValueContext } from '../../hooks/useIsValidValue.js';
+import { PickerFieldPrivateContext } from '../hooks/useNullableFieldPrivateContext.js';
+import { PickerContext } from '../../hooks/usePickerContext.js';
+import { jsx } from 'react/jsx-runtime';
+import { LocalizationProvider } from '../../LocalizationProvider/LocalizationProvider.js';
+
+const PickerActionsContext = /*#__PURE__*/React.createContext(null);
+if (process.env.NODE_ENV !== "production") PickerActionsContext.displayName = "PickerActionsContext";
+const PickerPrivateContext = /*#__PURE__*/React.createContext({
+  ownerState: {
+    isPickerDisabled: false,
+    isPickerReadOnly: false,
+    isPickerValueEmpty: false,
+    isPickerOpen: false,
+    pickerVariant: 'desktop',
+    pickerOrientation: 'portrait'
+  },
+  rootRefObject: {
+    current: null
+  },
+  labelId: undefined,
+  dismissViews: () => {},
+  hasUIView: true,
+  getCurrentViewMode: () => 'UI',
+  triggerElement: null,
+  viewContainerRole: null,
+  defaultActionBarActions: [],
+  onPopperExited: undefined
+});
+
+/**
+ * Provides the context for the various parts of a Picker component:
+ * - contextValue: the context for the Picker sub-components.
+ * - localizationProvider: the translations passed through the props and through a parent LocalizationProvider.
+ *
+ * @ignore - do not document.
+ */
+if (process.env.NODE_ENV !== "production") PickerPrivateContext.displayName = "PickerPrivateContext";
+function PickerProvider(props) {
+  const {
+    contextValue,
+    actionsContextValue,
+    privateContextValue,
+    fieldPrivateContextValue,
+    isValidContextValue,
+    localeText,
+    children
+  } = props;
+  return /*#__PURE__*/jsx(PickerContext.Provider, {
+    value: contextValue,
+    children: /*#__PURE__*/jsx(PickerActionsContext.Provider, {
+      value: actionsContextValue,
+      children: /*#__PURE__*/jsx(PickerPrivateContext.Provider, {
+        value: privateContextValue,
+        children: /*#__PURE__*/jsx(PickerFieldPrivateContext.Provider, {
+          value: fieldPrivateContextValue,
+          children: /*#__PURE__*/jsx(IsValidValueContext.Provider, {
+            value: isValidContextValue,
+            children: /*#__PURE__*/jsx(LocalizationProvider, {
+              localeText: localeText,
+              children: children
+            })
+          })
+        })
+      })
+    })
+  });
+}
+
+export { PickerActionsContext, PickerPrivateContext, PickerProvider };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickerViewRoot/PickerViewRoot.js

@@ -0,0 +1,16 @@
+import { styled } from '@mui/material/styles';
+import { VIEW_HEIGHT, DIALOG_WIDTH } from '../../constants/dimensions.js';
+
+const PickerViewRoot = styled('div', {
+  slot: 'internal',
+  shouldForwardProp: undefined
+})({
+  overflow: 'hidden',
+  width: DIALOG_WIDTH,
+  maxHeight: VIEW_HEIGHT,
+  display: 'flex',
+  flexDirection: 'column',
+  margin: '0 auto'
+});
+
+export { PickerViewRoot };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.js

@@ -0,0 +1,177 @@
+import _extends from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import * as React from 'react';
+import { clsx } from '../../../../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js';
+import Typography from '@mui/material/Typography';
+import { useRtl } from '../../../../../../../../@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/RtlProvider/index.js';
+import { useThemeProps, styled } from '@mui/material/styles';
+import IconButton from '@mui/material/IconButton';
+import { ArrowLeftIcon, ArrowRightIcon } from '../../../icons/index.js';
+import { getPickersArrowSwitcherUtilityClass } from './pickersArrowSwitcherClasses.js';
+import { usePickerPrivateContext } from '../../hooks/usePickerPrivateContext.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import useSlotProps from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js';
+import composeClasses from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.js';
+
+const _excluded = ["children", "className", "slots", "slotProps", "isNextDisabled", "isNextHidden", "onGoToNext", "nextLabel", "isPreviousDisabled", "isPreviousHidden", "onGoToPrevious", "previousLabel", "labelId", "classes"],
+  _excluded2 = ["ownerState"],
+  _excluded3 = ["ownerState"];
+const PickersArrowSwitcherRoot = styled('div', {
+  name: 'MuiPickersArrowSwitcher',
+  slot: 'Root'
+})({
+  display: 'flex'
+});
+const PickersArrowSwitcherSpacer = styled('div', {
+  name: 'MuiPickersArrowSwitcher',
+  slot: 'Spacer'
+})(({
+  theme
+}) => ({
+  width: theme.spacing(3)
+}));
+const PickersArrowSwitcherButton = styled(IconButton, {
+  name: 'MuiPickersArrowSwitcher',
+  slot: 'Button'
+})({
+  variants: [{
+    props: {
+      isButtonHidden: true
+    },
+    style: {
+      visibility: 'hidden'
+    }
+  }]
+});
+const useUtilityClasses = classes => {
+  const slots = {
+    root: ['root'],
+    spacer: ['spacer'],
+    button: ['button'],
+    previousIconButton: ['previousIconButton'],
+    nextIconButton: ['nextIconButton'],
+    leftArrowIcon: ['leftArrowIcon'],
+    rightArrowIcon: ['rightArrowIcon']
+  };
+  return composeClasses(slots, getPickersArrowSwitcherUtilityClass, classes);
+};
+const PickersArrowSwitcher = /*#__PURE__*/React.forwardRef(function PickersArrowSwitcher(inProps, ref) {
+  const isRtl = useRtl();
+  const props = useThemeProps({
+    props: inProps,
+    name: 'MuiPickersArrowSwitcher'
+  });
+  const {
+      children,
+      className,
+      slots,
+      slotProps,
+      isNextDisabled,
+      isNextHidden,
+      onGoToNext,
+      nextLabel,
+      isPreviousDisabled,
+      isPreviousHidden,
+      onGoToPrevious,
+      previousLabel,
+      labelId,
+      classes: classesProp
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    ownerState
+  } = usePickerPrivateContext();
+  const classes = useUtilityClasses(classesProp);
+  const nextProps = {
+    isDisabled: isNextDisabled,
+    isHidden: isNextHidden,
+    goTo: onGoToNext,
+    label: nextLabel
+  };
+  const previousProps = {
+    isDisabled: isPreviousDisabled,
+    isHidden: isPreviousHidden,
+    goTo: onGoToPrevious,
+    label: previousLabel
+  };
+  const PreviousIconButton = slots?.previousIconButton ?? PickersArrowSwitcherButton;
+  const previousIconButtonProps = useSlotProps({
+    elementType: PreviousIconButton,
+    externalSlotProps: slotProps?.previousIconButton,
+    additionalProps: {
+      size: 'medium',
+      title: previousProps.label,
+      'aria-label': previousProps.label,
+      disabled: previousProps.isDisabled,
+      edge: 'end',
+      onClick: previousProps.goTo
+    },
+    ownerState: _extends({}, ownerState, {
+      isButtonHidden: previousProps.isHidden ?? false
+    }),
+    className: clsx(classes.button, classes.previousIconButton)
+  });
+  const NextIconButton = slots?.nextIconButton ?? PickersArrowSwitcherButton;
+  const nextIconButtonProps = useSlotProps({
+    elementType: NextIconButton,
+    externalSlotProps: slotProps?.nextIconButton,
+    additionalProps: {
+      size: 'medium',
+      title: nextProps.label,
+      'aria-label': nextProps.label,
+      disabled: nextProps.isDisabled,
+      edge: 'start',
+      onClick: nextProps.goTo
+    },
+    ownerState: _extends({}, ownerState, {
+      isButtonHidden: nextProps.isHidden ?? false
+    }),
+    className: clsx(classes.button, classes.nextIconButton)
+  });
+  const LeftArrowIcon = slots?.leftArrowIcon ?? ArrowLeftIcon;
+  // The spread is here to avoid this bug mui/material-ui#34056
+  const _useSlotProps = useSlotProps({
+      elementType: LeftArrowIcon,
+      externalSlotProps: slotProps?.leftArrowIcon,
+      additionalProps: {
+        fontSize: 'inherit'
+      },
+      ownerState,
+      className: classes.leftArrowIcon
+    }),
+    leftArrowIconProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded2);
+  const RightArrowIcon = slots?.rightArrowIcon ?? ArrowRightIcon;
+  // The spread is here to avoid this bug mui/material-ui#34056
+  const _useSlotProps2 = useSlotProps({
+      elementType: RightArrowIcon,
+      externalSlotProps: slotProps?.rightArrowIcon,
+      additionalProps: {
+        fontSize: 'inherit'
+      },
+      ownerState,
+      className: classes.rightArrowIcon
+    }),
+    rightArrowIconProps = _objectWithoutPropertiesLoose(_useSlotProps2, _excluded3);
+  return /*#__PURE__*/jsxs(PickersArrowSwitcherRoot, _extends({
+    ref: ref,
+    className: clsx(classes.root, className),
+    ownerState: ownerState
+  }, other, {
+    children: [/*#__PURE__*/jsx(PreviousIconButton, _extends({}, previousIconButtonProps, {
+      children: isRtl ? /*#__PURE__*/jsx(RightArrowIcon, _extends({}, rightArrowIconProps)) : /*#__PURE__*/jsx(LeftArrowIcon, _extends({}, leftArrowIconProps))
+    })), children ? /*#__PURE__*/jsx(Typography, {
+      variant: "subtitle1",
+      component: "span",
+      id: labelId,
+      children: children
+    }) : /*#__PURE__*/jsx(PickersArrowSwitcherSpacer, {
+      className: classes.spacer,
+      ownerState: ownerState
+    }), /*#__PURE__*/jsx(NextIconButton, _extends({}, nextIconButtonProps, {
+      children: isRtl ? /*#__PURE__*/jsx(LeftArrowIcon, _extends({}, leftArrowIconProps)) : /*#__PURE__*/jsx(RightArrowIcon, _extends({}, rightArrowIconProps))
+    }))]
+  }));
+});
+if (process.env.NODE_ENV !== "production") PickersArrowSwitcher.displayName = "PickersArrowSwitcher";
+
+export { PickersArrowSwitcher };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickersArrowSwitcher/pickersArrowSwitcherClasses.js

@@ -0,0 +1,9 @@
+import generateUtilityClass from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js';
+import generateUtilityClasses from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js';
+
+function getPickersArrowSwitcherUtilityClass(slot) {
+  return generateUtilityClass('MuiPickersArrowSwitcher', slot);
+}
+generateUtilityClasses('MuiPickersArrowSwitcher', ['root', 'spacer', 'button', 'previousIconButton', 'nextIconButton', 'leftArrowIcon', 'rightArrowIcon']);
+
+export { getPickersArrowSwitcherUtilityClass };