@tenancy.nz/datepicker 1.3.4

package/dist/cjs/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/PickersTextField/PickersInputBase/PickersInputBase.cjs

@@ -0,0 +1,507 @@
+'use strict';
+
+var objectWithoutPropertiesLoose = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var index = require('../../../../../../../../../_virtual/index.cjs');
+var FormControl = require('@mui/material/FormControl');
+var styles = require('@mui/material/styles');
+var pickersInputBaseClasses = require('./pickersInputBaseClasses.cjs');
+var usePickerTextFieldOwnerState = require('../usePickerTextFieldOwnerState.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var useForkRef = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useForkRef/useForkRef.cjs');
+var useSlotProps = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.cjs');
+var PickersSectionList = require('../../PickersSectionList/PickersSectionList.cjs');
+var capitalize = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/capitalize/capitalize.cjs');
+var composeClasses = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.cjs');
+var visuallyHidden = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/visuallyHidden/visuallyHidden.cjs');
+var refType = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/refType/refType.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const _excluded = ["elements", "areAllSectionsEmpty", "defaultValue", "label", "value", "onChange", "id", "autoFocus", "endAdornment", "startAdornment", "renderSuffix", "slots", "slotProps", "contentEditable", "tabIndex", "onInput", "onPaste", "onKeyDown", "fullWidth", "name", "readOnly", "inputProps", "inputRef", "sectionListRef", "onFocus", "onBlur", "classes", "ownerState"];
+const round = value => Math.round(value * 1e5) / 1e5;
+const PickersInputBaseRoot = styles.styled('div', {
+  name: 'MuiPickersInputBase',
+  slot: 'Root'
+})(({
+  theme
+}) => _extends.default({}, theme.typography.body1, {
+  color: (theme.vars || theme).palette.text.primary,
+  cursor: 'text',
+  padding: 0,
+  display: 'flex',
+  justifyContent: 'flex-start',
+  alignItems: 'center',
+  position: 'relative',
+  boxSizing: 'border-box',
+  // Prevent padding issue with fullWidth.
+  letterSpacing: `${round(0.15 / 16)}em`,
+  variants: [{
+    props: {
+      isInputInFullWidth: true
+    },
+    style: {
+      width: '100%'
+    }
+  }]
+}));
+const PickersInputBaseSectionsContainer = styles.styled(PickersSectionList.PickersSectionListRoot, {
+  name: 'MuiPickersInputBase',
+  slot: 'SectionsContainer'
+})(({
+  theme
+}) => ({
+  padding: '4px 0 5px',
+  fontFamily: theme.typography.fontFamily,
+  fontSize: 'inherit',
+  lineHeight: '1.4375em',
+  // 23px
+  flexGrow: 1,
+  outline: 'none',
+  display: 'flex',
+  flexWrap: 'nowrap',
+  overflow: 'hidden',
+  letterSpacing: 'inherit',
+  // Baseline behavior
+  width: '182px',
+  variants: [{
+    props: {
+      fieldDirection: 'rtl'
+    },
+    style: {
+      justifyContent: 'end'
+    }
+  }, {
+    props: {
+      inputSize: 'small'
+    },
+    style: {
+      paddingTop: 1
+    }
+  }, {
+    props: {
+      hasStartAdornment: false,
+      isFieldFocused: false,
+      isFieldValueEmpty: true
+    },
+    style: {
+      color: 'currentColor',
+      opacity: 0
+    }
+  }, {
+    props: {
+      hasStartAdornment: false,
+      isFieldFocused: false,
+      isFieldValueEmpty: true,
+      inputHasLabel: false
+    },
+    style: theme.vars ? {
+      opacity: theme.vars.opacity.inputPlaceholder
+    } : {
+      opacity: theme.palette.mode === 'light' ? 0.42 : 0.5
+    }
+  }, {
+    props: {
+      hasStartAdornment: false,
+      isFieldFocused: false,
+      isFieldValueEmpty: true,
+      inputHasLabel: true,
+      isLabelShrunk: true
+    },
+    style: theme.vars ? {
+      opacity: theme.vars.opacity.inputPlaceholder
+    } : {
+      opacity: theme.palette.mode === 'light' ? 0.42 : 0.5
+    }
+  }]
+}));
+const PickersInputBaseSection = styles.styled(PickersSectionList.PickersSectionListSection, {
+  name: 'MuiPickersInputBase',
+  slot: 'Section'
+})(({
+  theme
+}) => ({
+  fontFamily: theme.typography.fontFamily,
+  fontSize: 'inherit',
+  letterSpacing: 'inherit',
+  lineHeight: '1.4375em',
+  // 23px
+  display: 'inline-block',
+  whiteSpace: 'nowrap'
+}));
+const PickersInputBaseSectionContent = styles.styled(PickersSectionList.PickersSectionListSectionContent, {
+  name: 'MuiPickersInputBase',
+  slot: 'SectionContent',
+  overridesResolver: (props, styles) => styles.content // FIXME: Inconsistent naming with slot
+})(({
+  theme
+}) => ({
+  fontFamily: theme.typography.fontFamily,
+  lineHeight: '1.4375em',
+  // 23px
+  letterSpacing: 'inherit',
+  width: 'fit-content',
+  outline: 'none'
+}));
+const PickersInputBaseSectionSeparator = styles.styled(PickersSectionList.PickersSectionListSectionSeparator, {
+  name: 'MuiPickersInputBase',
+  slot: 'Separator'
+})(() => ({
+  whiteSpace: 'pre',
+  letterSpacing: 'inherit'
+}));
+const PickersInputBaseInput = styles.styled('input', {
+  name: 'MuiPickersInputBase',
+  slot: 'Input',
+  overridesResolver: (props, styles) => styles.hiddenInput // FIXME: Inconsistent naming with slot
+})(_extends.default({}, visuallyHidden.default));
+const PickersInputBaseActiveBar = styles.styled('div', {
+  name: 'MuiPickersInputBase',
+  slot: 'ActiveBar'
+})(({
+  theme,
+  ownerState
+}) => ({
+  display: 'none',
+  position: 'absolute',
+  height: 2,
+  bottom: 2,
+  borderTopLeftRadius: 2,
+  borderTopRightRadius: 2,
+  transition: theme.transitions.create(['width', 'left'], {
+    duration: theme.transitions.duration.shortest
+  }),
+  backgroundColor: (theme.vars || theme).palette.primary.main,
+  '[data-active-range-position="start"] &, [data-active-range-position="end"] &': {
+    display: 'block'
+  },
+  '[data-active-range-position="start"] &': {
+    left: ownerState.sectionOffsets[0]
+  },
+  '[data-active-range-position="end"] &': {
+    left: ownerState.sectionOffsets[1]
+  }
+}));
+const useUtilityClasses = (classes, ownerState) => {
+  const {
+    isFieldFocused,
+    isFieldDisabled,
+    isFieldReadOnly,
+    hasFieldError,
+    inputSize,
+    isInputInFullWidth,
+    inputColor,
+    hasStartAdornment,
+    hasEndAdornment
+  } = ownerState;
+  const slots = {
+    root: ['root', isFieldFocused && !isFieldDisabled && 'focused', isFieldDisabled && 'disabled', isFieldReadOnly && 'readOnly', hasFieldError && 'error', isInputInFullWidth && 'fullWidth', `color${capitalize.default(inputColor)}`, inputSize === 'small' && 'inputSizeSmall', hasStartAdornment && 'adornedStart', hasEndAdornment && 'adornedEnd'],
+    notchedOutline: ['notchedOutline'],
+    input: ['input'],
+    sectionsContainer: ['sectionsContainer'],
+    sectionContent: ['sectionContent'],
+    sectionBefore: ['sectionBefore'],
+    sectionAfter: ['sectionAfter'],
+    activeBar: ['activeBar']
+  };
+  return composeClasses.default(slots, pickersInputBaseClasses.getPickersInputBaseUtilityClass, classes);
+};
+function resolveSectionElementWidth(sectionElement, rootRef, index, dateRangePosition) {
+  if (sectionElement.content.id) {
+    const activeSectionElements = rootRef.current?.querySelectorAll(`[data-sectionindex="${index}"] [data-range-position="${dateRangePosition}"]`);
+    if (activeSectionElements) {
+      return Array.from(activeSectionElements).reduce((currentActiveBarWidth, element) => {
+        return currentActiveBarWidth + element.offsetWidth;
+      }, 0);
+    }
+  }
+  return 0;
+}
+function resolveSectionWidthAndOffsets(elements, rootRef) {
+  let activeBarWidth = 0;
+  const activeRangePosition = rootRef.current?.getAttribute('data-active-range-position');
+  if (activeRangePosition === 'end') {
+    for (let i = elements.length - 1; i >= elements.length / 2; i -= 1) {
+      activeBarWidth += resolveSectionElementWidth(elements[i], rootRef, i, 'end');
+    }
+  } else {
+    for (let i = 0; i < elements.length / 2; i += 1) {
+      activeBarWidth += resolveSectionElementWidth(elements[i], rootRef, i, 'start');
+    }
+  }
+  return {
+    activeBarWidth,
+    sectionOffsets: [rootRef.current?.querySelector(`[data-sectionindex="0"]`)?.offsetLeft || 0, rootRef.current?.querySelector(`[data-sectionindex="${elements.length / 2}"]`)?.offsetLeft || 0]
+  };
+}
+
+/**
+ * @ignore - internal component.
+ */
+const PickersInputBase = /*#__PURE__*/React__namespace.forwardRef(function PickersInputBase(inProps, ref) {
+  const props = styles.useThemeProps({
+    props: inProps,
+    name: 'MuiPickersInputBase'
+  });
+  const {
+      elements,
+      areAllSectionsEmpty,
+      value,
+      onChange,
+      id,
+      endAdornment,
+      startAdornment,
+      renderSuffix,
+      slots,
+      slotProps,
+      contentEditable,
+      tabIndex,
+      onInput,
+      onPaste,
+      onKeyDown,
+      name,
+      readOnly,
+      inputProps,
+      inputRef,
+      sectionListRef,
+      onFocus,
+      onBlur,
+      classes: classesProp,
+      ownerState: ownerStateProp
+    } = props,
+    other = objectWithoutPropertiesLoose.default(props, _excluded);
+  const ownerStateContext = usePickerTextFieldOwnerState.usePickerTextFieldOwnerState();
+  const rootRef = React__namespace.useRef(null);
+  const activeBarRef = React__namespace.useRef(null);
+  const sectionOffsetsRef = React__namespace.useRef([]);
+  const handleRootRef = useForkRef.default(ref, rootRef);
+  const handleInputRef = useForkRef.default(inputProps?.ref, inputRef);
+  const muiFormControl = FormControl.useFormControl();
+  if (!muiFormControl) {
+    throw new Error('MUI X: PickersInputBase should always be used inside a PickersTextField component');
+  }
+  const ownerState = ownerStateProp ?? ownerStateContext;
+  const handleInputFocus = event => {
+    muiFormControl.onFocus?.(event);
+    onFocus?.(event);
+  };
+  const handleHiddenInputFocus = event => {
+    handleInputFocus(event);
+  };
+  const handleKeyDown = event => {
+    onKeyDown?.(event);
+    if (event.key === 'Enter' && !event.defaultMuiPrevented) {
+      // Do nothing if it's a multi input field
+      if (rootRef.current?.dataset.multiInput) {
+        return;
+      }
+      const closestForm = rootRef.current?.closest('form');
+      const submitTrigger = closestForm?.querySelector('[type="submit"]');
+      if (!closestForm || !submitTrigger) {
+        // do nothing if there is no form or no submit button (trigger)
+        return;
+      }
+      event.preventDefault();
+      // native input trigger submit with the `submitter` field set
+      closestForm.requestSubmit(submitTrigger);
+    }
+  };
+  const handleInputBlur = event => {
+    muiFormControl.onBlur?.(event);
+    onBlur?.(event);
+  };
+  React__namespace.useEffect(() => {
+    if (muiFormControl) {
+      muiFormControl.setAdornedStart(Boolean(startAdornment));
+    }
+  }, [muiFormControl, startAdornment]);
+  React__namespace.useEffect(() => {
+    if (!muiFormControl) {
+      return;
+    }
+    if (areAllSectionsEmpty) {
+      muiFormControl.onEmpty();
+    } else {
+      muiFormControl.onFilled();
+    }
+  }, [muiFormControl, areAllSectionsEmpty]);
+  const classes = useUtilityClasses(classesProp, ownerState);
+  const InputRoot = slots?.root || PickersInputBaseRoot;
+  const inputRootProps = useSlotProps.default({
+    elementType: InputRoot,
+    externalSlotProps: slotProps?.root,
+    externalForwardedProps: other,
+    additionalProps: {
+      'aria-invalid': muiFormControl.error,
+      ref: handleRootRef
+    },
+    className: classes.root,
+    ownerState
+  });
+  const InputSectionsContainer = slots?.input || PickersInputBaseSectionsContainer;
+  const isSingleInputRange = elements.some(element => element.content['data-range-position'] !== undefined);
+  React__namespace.useEffect(() => {
+    if (!isSingleInputRange || !ownerState.isPickerOpen) {
+      return;
+    }
+    const {
+      activeBarWidth,
+      sectionOffsets
+    } = resolveSectionWidthAndOffsets(elements, rootRef);
+    sectionOffsetsRef.current = [sectionOffsets[0], sectionOffsets[1]];
+    if (activeBarRef.current) {
+      activeBarRef.current.style.width = `${activeBarWidth}px`;
+    }
+  }, [elements, isSingleInputRange, ownerState.isPickerOpen]);
+  return /*#__PURE__*/jsxRuntime.jsxs(InputRoot, _extends.default({}, inputRootProps, {
+    children: [startAdornment, /*#__PURE__*/jsxRuntime.jsx(PickersSectionList.PickersSectionList, {
+      sectionListRef: sectionListRef,
+      elements: elements,
+      contentEditable: contentEditable,
+      tabIndex: tabIndex,
+      className: classes.sectionsContainer,
+      onFocus: handleInputFocus,
+      onBlur: handleInputBlur,
+      onInput: onInput,
+      onPaste: onPaste,
+      onKeyDown: handleKeyDown,
+      slots: {
+        root: InputSectionsContainer,
+        section: PickersInputBaseSection,
+        sectionContent: PickersInputBaseSectionContent,
+        sectionSeparator: PickersInputBaseSectionSeparator
+      },
+      slotProps: {
+        root: _extends.default({}, slotProps?.input, {
+          ownerState
+        }),
+        sectionContent: {
+          className: pickersInputBaseClasses.pickersInputBaseClasses.sectionContent
+        },
+        sectionSeparator: ({
+          separatorPosition
+        }) => ({
+          className: separatorPosition === 'before' ? pickersInputBaseClasses.pickersInputBaseClasses.sectionBefore : pickersInputBaseClasses.pickersInputBaseClasses.sectionAfter
+        })
+      }
+    }), endAdornment, renderSuffix ? renderSuffix(_extends.default({}, muiFormControl)) : null, /*#__PURE__*/jsxRuntime.jsx(PickersInputBaseInput, _extends.default({
+      name: name,
+      className: classes.input,
+      value: value,
+      onChange: onChange,
+      id: id,
+      "aria-hidden": "true",
+      tabIndex: -1,
+      readOnly: readOnly,
+      required: muiFormControl.required,
+      disabled: muiFormControl.disabled
+      // Hidden input element cannot be focused, trigger the root focus instead
+      // This allows to maintain the ability to do `inputRef.current.focus()` to focus the field
+      ,
+      onFocus: handleHiddenInputFocus
+    }, inputProps, {
+      ref: handleInputRef
+    })), isSingleInputRange && /*#__PURE__*/jsxRuntime.jsx(PickersInputBaseActiveBar, {
+      className: classes.activeBar,
+      ref: activeBarRef,
+      ownerState: {
+        sectionOffsets: sectionOffsetsRef.current
+      }
+    })]
+  }));
+});
+if (process.env.NODE_ENV !== "production") PickersInputBase.displayName = "PickersInputBase";
+process.env.NODE_ENV !== "production" ? PickersInputBase.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Is `true` if the current values equals the empty value.
+   * For a single item value, it means that `value === null`
+   * For a range value, it means that `value === [null, null]`
+   */
+  areAllSectionsEmpty: index.default.bool.isRequired,
+  className: index.default.string,
+  component: index.default.elementType,
+  /**
+   * If true, the whole element is editable.
+   * Useful when all the sections are selected.
+   */
+  contentEditable: index.default.bool.isRequired,
+  'data-multi-input': index.default.string,
+  /**
+   * The elements to render.
+   * Each element contains the prop to edit a section of the value.
+   */
+  elements: index.default.arrayOf(index.default.shape({
+    after: index.default.object.isRequired,
+    before: index.default.object.isRequired,
+    container: index.default.object.isRequired,
+    content: index.default.object.isRequired
+  })).isRequired,
+  endAdornment: index.default.node,
+  fullWidth: index.default.bool,
+  id: index.default.string,
+  inputProps: index.default.object,
+  inputRef: refType.default,
+  label: index.default.node,
+  margin: index.default.oneOf(['dense', 'none', 'normal']),
+  name: index.default.string,
+  onChange: index.default.func.isRequired,
+  onClick: index.default.func.isRequired,
+  onInput: index.default.func.isRequired,
+  onKeyDown: index.default.func.isRequired,
+  onPaste: index.default.func.isRequired,
+  ownerState: index.default /* @typescript-to-proptypes-ignore */.any,
+  readOnly: index.default.bool,
+  renderSuffix: index.default.func,
+  sectionListRef: index.default.oneOfType([index.default.func, index.default.shape({
+    current: index.default.shape({
+      getRoot: index.default.func.isRequired,
+      getSectionContainer: index.default.func.isRequired,
+      getSectionContent: index.default.func.isRequired,
+      getSectionIndexFromDOMElement: index.default.func.isRequired
+    })
+  })]),
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: index.default.object,
+  /**
+   * The components used for each slot inside.
+   *
+   * @default {}
+   */
+  slots: index.default.object,
+  startAdornment: index.default.node,
+  style: index.default.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: index.default.oneOfType([index.default.arrayOf(index.default.oneOfType([index.default.func, index.default.object, index.default.bool])), index.default.func, index.default.object]),
+  value: index.default.string.isRequired
+} : void 0;
+
+exports.PickersInputBase = PickersInputBase;
+exports.PickersInputBaseRoot = PickersInputBaseRoot;
+exports.PickersInputBaseSectionsContainer = PickersInputBaseSectionsContainer;

package/dist/cjs/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/PickersTextField/PickersInputBase/pickersInputBaseClasses.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var generateUtilityClasses = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.cjs');
+var generateUtilityClass = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.cjs');
+
+function getPickersInputBaseUtilityClass(slot) {
+  return generateUtilityClass.default('MuiPickersInputBase', slot);
+}
+const pickersInputBaseClasses = generateUtilityClasses.default('MuiPickersInputBase', ['root', 'focused', 'disabled', 'error', 'notchedOutline', 'sectionContent', 'sectionBefore', 'sectionAfter', 'adornedStart', 'adornedEnd', 'input', 'inputSizeSmall', 'activeBar']);
+
+exports.getPickersInputBaseUtilityClass = getPickersInputBaseUtilityClass;
+exports.pickersInputBaseClasses = pickersInputBaseClasses;

package/dist/cjs/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/PickersTextField/PickersOutlinedInput/Outline.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var objectWithoutPropertiesLoose = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var styles = require('@mui/material/styles');
+var usePickerTextFieldOwnerState = require('../usePickerTextFieldOwnerState.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var createStyled = require('../../../../../../../@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/createStyled/createStyled.cjs');
+
+const _excluded = ["children", "className", "label", "notched", "shrink"];
+const OutlineRoot = styles.styled('fieldset', {
+  name: 'MuiPickersOutlinedInput',
+  slot: 'NotchedOutline'
+})(({
+  theme
+}) => {
+  const borderColor = theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)';
+  return {
+    textAlign: 'left',
+    position: 'absolute',
+    bottom: 0,
+    right: 0,
+    top: -5,
+    left: 0,
+    margin: 0,
+    padding: '0 8px',
+    pointerEvents: 'none',
+    borderRadius: 'inherit',
+    borderStyle: 'solid',
+    borderWidth: 1,
+    overflow: 'hidden',
+    minWidth: '0%',
+    borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
+  };
+});
+const OutlineLabel = styles.styled('span', {
+  slot: 'internal',
+  shouldForwardProp: undefined
+})(({
+  theme
+}) => ({
+  fontFamily: theme.typography.fontFamily,
+  fontSize: 'inherit'
+}));
+const OutlineLegend = styles.styled('legend', {
+  slot: 'internal',
+  shouldForwardProp: prop => createStyled.shouldForwardProp(prop) && prop !== 'notched'
+})(({
+  theme
+}) => ({
+  float: 'unset',
+  // Fix conflict with bootstrap
+  width: 'auto',
+  // Fix conflict with bootstrap
+  overflow: 'hidden',
+  // Fix Horizontal scroll when label too long
+  variants: [{
+    props: {
+      inputHasLabel: false
+    },
+    style: {
+      padding: 0,
+      lineHeight: '11px',
+      // sync with `height` in `legend` styles
+      transition: theme.transitions.create('width', {
+        duration: 150,
+        easing: theme.transitions.easing.easeOut
+      })
+    }
+  }, {
+    props: {
+      inputHasLabel: true
+    },
+    style: {
+      display: 'block',
+      // Fix conflict with normalize.css and sanitize.css
+      padding: 0,
+      height: 11,
+      // sync with `lineHeight` in `legend` styles
+      fontSize: '0.75em',
+      visibility: 'hidden',
+      maxWidth: 0.01,
+      transition: theme.transitions.create('max-width', {
+        duration: 50,
+        easing: theme.transitions.easing.easeOut
+      }),
+      whiteSpace: 'nowrap',
+      '& > span': {
+        paddingLeft: 5,
+        paddingRight: 5,
+        display: 'inline-block',
+        opacity: 0,
+        visibility: 'visible'
+      }
+    }
+  }, {
+    props: {
+      inputHasLabel: true,
+      notched: true
+    },
+    style: {
+      maxWidth: '100%',
+      transition: theme.transitions.create('max-width', {
+        duration: 100,
+        easing: theme.transitions.easing.easeOut,
+        delay: 50
+      })
+    }
+  }]
+}));
+
+/**
+ * @ignore - internal component.
+ */
+function Outline(props) {
+  const {
+      className,
+      label,
+      notched
+    } = props,
+    other = objectWithoutPropertiesLoose.default(props, _excluded);
+  const ownerState = usePickerTextFieldOwnerState.usePickerTextFieldOwnerState();
+  return /*#__PURE__*/jsxRuntime.jsx(OutlineRoot, _extends.default({
+    "aria-hidden": true,
+    className: className
+  }, other, {
+    ownerState: ownerState,
+    children: /*#__PURE__*/jsxRuntime.jsx(OutlineLegend, {
+      ownerState: ownerState,
+      notched: notched,
+      children: label ? /*#__PURE__*/jsxRuntime.jsx(OutlineLabel, {
+        children: label
+      }) :
+      /*#__PURE__*/
+      // notranslate needed while Google Translate will not fix zero-width space issue
+      jsxRuntime.jsx(OutlineLabel, {
+        className: "notranslate",
+        children: "\u200B"
+      })
+    })
+  }));
+}
+
+exports.default = Outline;