@superdispatch/dates 0.16.0-alpha.0 → 0.16.0-alpha.1

package/dist-node/index.js

@@ -16,10 +16,6 @@ var jsxRuntime = require('react/jsx-runtime');
 var iconsMaterial = require('@mui/icons-material');
 var js = require('@mdi/js');
 var hooks = require('@superdispatch/hooks');
-var core = require('@material-ui/core');
-var styles$1 = require('@material-ui/styles');
-var icons = require('@material-ui/icons');
-var lab = require('@material-ui/lab');
 
 function setDefaultTimeZone(offset) {
   if (offset === 'local') {
@@ -805,10 +801,6 @@ var CalendarQuickSelection = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
 if (process.env.NODE_ENV !== "production") CalendarQuickSelection.displayName = "CalendarQuickSelection";
 
 var _excluded$1 = ["id", "api", "onClear", "onClick", "onClose", "onKeyDown", "disabled", "children", "enableClearable", "inputRef", "InputProps"];
-var {
-  mergeRefs,
-  useUID
-} = ui.v5;
 var BaseDatePicker = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   var {
     id,
@@ -825,7 +817,7 @@ var BaseDatePicker = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   } = _ref,
       textFieldProps = _objectWithoutProperties(_ref, _excluded$1);
 
-  var uid = useUID(id);
+  var uid = ui.useUID(id);
   var labelID = "".concat(uid, "-label");
   var clearIconID = "".concat(uid, "-clear-icon");
   var inputRef = react.useRef(null);
@@ -867,9 +859,9 @@ var BaseDatePicker = /*#__PURE__*/react.forwardRef((_ref, ref) => {
       children: children
     }), /*#__PURE__*/jsxRuntime.jsx(material.TextField, _objectSpread(_objectSpread({}, textFieldProps), {}, {
       id: uid,
-      ref: mergeRefs(ref, textFieldRef),
+      ref: ui.mergeRefs(ref, textFieldRef),
       disabled: disabled,
-      inputRef: mergeRefs(inputRef, inputRefProp),
+      inputRef: ui.mergeRefs(inputRef, inputRefProp),
       onClick: event => {
         _onClick === null || _onClick === void 0 ? void 0 : _onClick(event);
 
@@ -1688,1750 +1680,42 @@ var TimeField = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
 });
 if (process.env.NODE_ENV !== "production") TimeField.displayName = "TimeField";
 
-
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Calendar: Calendar,
-  CalendarQuickSelectionItem: CalendarQuickSelectionItem,
-  CalendarQuickSelection: CalendarQuickSelection,
-  setDefaultTimeZone: setDefaultTimeZone,
-  useDefaultTimeZone: useDefaultTimeZone,
-  defaultDateConfig: defaultDateConfig,
-  useDateConfig: useDateConfig,
-  DateConfigProvider: DateConfigProvider,
-  DateField: DateField,
-  DateRangeField: DateRangeField,
-  toPrimitiveDateInput: toPrimitiveDateInput,
-  parseDate: parseDate,
-  stringifyDate: stringifyDate,
-  formatDate: formatDate,
-  formatRelativeTime: formatRelativeTime,
-  toDatePayload: toDatePayload,
-  toPrimitiveDateRangeInput: toPrimitiveDateRangeInput,
-  parseDateRange: parseDateRange,
-  stringifyDateRange: stringifyDateRange,
-  formatDateRange: formatDateRange,
-  toDateRangePayload: toDateRangePayload,
-  isDate: isDate,
-  isDateLike: isDateLike,
-  isValidDate: isValidDate,
-  isDateRange: isDateRange,
-  isDateRangeLike: isDateRangeLike,
-  isValidDateRange: isValidDateRange,
-  toDate: toDate,
-  toDateRange: toDateRange,
-  DateUtils: DateUtils,
-  useDateUtils: useDateUtils,
-  useFormattedDate: useFormattedDate,
-  FormattedDate: FormattedDate,
-  useFormattedRelativeTime: useFormattedRelativeTime,
-  FormattedRelativeTime: FormattedRelativeTime,
-  TimeField: TimeField,
-  useDateTimeRange: useDateTimeRange,
-  useDateTime: useDateTime
-});
-
-function setDefaultTimeZone$1(offset) {
-  if (offset === 'local') {
-    luxon.Settings.defaultZoneName = offset;
-  } else {
-    var zone = luxon.FixedOffsetZone.instance(offset);
-
-    if (zone.isValid) {
-      luxon.Settings.defaultZoneName = zone.name;
-    }
-  }
-
-  return luxon.Settings.defaultZoneName;
-}
-function useDefaultTimeZone$1(offset) {
-  return react.useMemo(() => setDefaultTimeZone$1(offset), [offset]);
-}
-var defaultDateConfig$1 = {
-  format: 'DateTimeISO'
-};
-var Context$1 = /*#__PURE__*/react.createContext(defaultDateConfig$1);
-function useDateConfig$1() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var config = react.useContext(Context$1);
-  var {
-    format = config.format
-  } = options;
-  return react.useMemo(() => ({
-    format
-  }), [format]);
-}
-function DateConfigProvider$1(_ref) {
-  var {
-    format,
-    children
-  } = _ref;
-  var prev = useDateConfig$1();
-  var ctx = react.useMemo(() => ({
-    format: format || prev.format
-  }), [format, prev.format]);
-  return /*#__PURE__*/jsxRuntime.jsx(Context$1.Provider, {
-    value: ctx,
-    children: children
-  });
-}
-
-// Config
-//
-
-var DATE_FORMATS$1 = {
-  DateISO: '',
-  DateTimeISO: '',
-  JodaISO: "yyyy-MM-dd'T'HH:mm:ss.SSSZZZ"
-};
-var DATE_DISPLAY_VARIANTS$1 = {
-  Date: {
-    day: '2-digit',
-    month: 'short',
-    year: 'numeric'
-  },
-  ShortDate: {
-    day: '2-digit',
-    month: 'short'
-  },
-  Time: {
-    hour: 'numeric',
-    minute: 'numeric'
-  },
-  DateTime: {
-    day: '2-digit',
-    month: 'short',
-    year: 'numeric',
-    hour: 'numeric',
-    minute: 'numeric'
-  }
-}; //
-// Date Utils
-//
-
-function toPrimitiveDateInput$1(input) {
-  if (typeof input == 'number' || typeof input == 'string') {
-    return input;
-  }
-
-  if (input instanceof Date || input instanceof luxon.DateTime) {
-    return input.valueOf();
-  }
-
-  return NaN;
-}
-function parseDate$1(input) {
-  var {
-    format
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateConfig$1;
-
-  if (input instanceof luxon.DateTime) {
-    var {
-      defaultZone
-    } = luxon.Settings;
-
-    if (!defaultZone.equals(input.zone)) {
-      return input.setZone(defaultZone);
-    }
-
-    return input;
-  }
-
-  if (input instanceof Date) {
-    return luxon.DateTime.fromJSDate(input);
-  }
-
-  if (typeof input === 'number') {
-    return luxon.DateTime.fromMillis(input);
-  }
-
-  if (typeof input == 'string') {
-    switch (format) {
-      case 'DateISO':
-      case 'DateTimeISO':
-        return luxon.DateTime.fromISO(input);
-
-      default:
-        return luxon.DateTime.fromFormat(input, DATE_FORMATS$1[format]);
-    }
-  }
-
-  return luxon.DateTime.invalid('invalid input');
-}
-function stringifyDate$1(input) {
-  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateConfig$1;
-  var date = parseDate$1(input, config);
-
-  if (date.isValid) {
-    var {
-      format
-    } = config;
-
-    switch (format) {
-      case 'DateISO':
-        return date.toISODate();
-
-      case 'DateTimeISO':
-        return date.toISO();
-
-      default:
-        return date.toFormat(DATE_FORMATS$1[format]);
-    }
-  }
-
-  return null;
-}
-function formatDate$1(input, _ref) {
-  var {
-    variant,
-    fallback = 'Invalid Date'
-  } = _ref;
-  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultDateConfig$1;
-  var date = parseDate$1(input, config);
-
-  if (!date.isValid) {
-    return fallback;
-  }
-
-  return date.toLocaleString(DATE_DISPLAY_VARIANTS$1[variant]);
-}
-
-function formatUnit$1(unit) {
-  switch (unit) {
-    case 'months':
-      return 'mo';
-
-    default:
-      return unit.charAt(0);
-  }
-}
-
-function formatRelativeTime$1(input) {
-  var {
-    round = true,
-    unit: unitOption,
-    base: baseOption,
-    padding: paddingOption,
-    fallback = 'Invalid Date'
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultDateConfig$1;
-  var base = baseOption == null ? luxon.DateTime.now() : parseDate$1(baseOption, config);
-  var date = parseDate$1(input, config);
-  var padding = paddingOption ? date < base ? -paddingOption : paddingOption : 0;
-
-  function format(value, unit) {
-    var isPast = Object.is(value, -0) || value < 0;
-    var diff = Math.abs(!round ? value : Math.trunc(value));
-    var formattedUnit = formatUnit$1(unit);
-    return isPast ? "".concat(diff).concat(formattedUnit, " ago") : "in ".concat(diff).concat(formattedUnit);
-  }
-
-  function differ(unit) {
-    return date.plus(padding).diff(base, unit).get(unit);
-  }
-
-  if (date.isValid && base.isValid) {
-    var units = ['years', 'months', 'days', 'hours', 'minutes', 'seconds'];
-
-    if (unitOption) {
-      return format(differ(unitOption), unitOption);
-    }
-
-    for (var unit of units) {
-      var diff = differ(unit);
-
-      if (Math.abs(diff) >= 1) {
-        return format(diff, unit);
-      }
-    }
-
-    return format(0, 'seconds');
-  }
-
-  return fallback;
-}
-function toDatePayload$1(input) {
-  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateConfig$1;
-  var dateValue = parseDate$1(input, config);
-  return {
-    config,
-    dateValue,
-    stringValue: stringifyDate$1(dateValue, config)
-  };
-} //
-// Date Range Utils
-//
-
-function toPrimitiveDateRangeInput$1(input) {
-  if (!Array.isArray(input)) {
-    return [undefined, undefined];
-  }
-
-  return [toPrimitiveDateInput$1(input[0]), toPrimitiveDateInput$1(input[1])];
-}
-function parseDateRange$1(input, config) {
-  var start = null;
-  var finish = null;
-
-  if (Array.isArray(input)) {
-    [start = null, finish = null] = input.map(value => parseDate$1(value, config)).filter(date => date.isValid).sort((a, b) => a.valueOf() - b.valueOf());
-  }
-
-  return [start, finish];
-}
-function stringifyDateRange$1(input, config) {
-  var [start, finish] = parseDateRange$1(input, config);
-  return [stringifyDate$1(start, config), stringifyDate$1(finish, config)];
-}
-function formatDateRange$1(input, _ref2) {
-  var {
-    fallback = 'Invalid Date Range'
-  } = _ref2;
-  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultDateConfig$1;
-  var [start, finish] = parseDateRange$1(input, config);
-
-  if (!start) {
-    return fallback;
-  }
-
-  var startVariant = !(finish !== null && finish !== void 0 && finish.hasSame(start, 'year')) ? 'Date' : 'ShortDate';
-  var startText = formatDate$1(start, {
-    variant: startVariant
-  }, config);
-  var finishText = !finish ? '…' : formatDate$1(finish, {
-    variant: 'Date'
-  });
-  return "".concat(startText, " - ").concat(finishText);
-}
-function toDateRangePayload$1(input) {
-  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateConfig$1;
-  var dateValue = parseDateRange$1(input, config);
-  return {
-    config,
-    dateValue,
-    stringValue: stringifyDateRange$1(dateValue, config)
-  };
-}
-
-function useDateTime$1(input, options) {
-  var config = useDateConfig$1(options);
-  var primitiveInput = toPrimitiveDateInput$1(input);
-  return react.useMemo(() => {
-    var date = parseDate$1(primitiveInput, config);
-
-    if (process.env.NODE_ENV !== 'production') {
-      if (!date.isValid && typeof primitiveInput === 'string') {
-        // eslint-disable-next-line no-console
-        console.error("[useDateTime] Failed to parse \"".concat(primitiveInput, "\" string with \"").concat(config.format, "\" format."));
-      }
-    }
-
-    return date;
-  }, [config, primitiveInput]);
-}
-
-function CalendarCaption$1(_ref) {
-  var {
-    date,
-    localeUtils,
-    classNames,
-    onClick
-  } = _ref;
-  return /*#__PURE__*/jsxRuntime.jsx(core.Typography, {
-    variant: "h4",
-    onClick: onClick,
-    className: classNames.caption,
-    children: localeUtils.formatMonthTitle(date)
-  });
-}
-function CalendarNavbar$1(_ref2) {
-  var {
-    labels,
-    classNames,
-    onNextClick,
-    onPreviousClick,
-    showNextButton,
-    showPreviousButton
-  } = _ref2;
-  return /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
-    children: [/*#__PURE__*/jsxRuntime.jsx(core.IconButton, {
-      size: "small",
-      color: "primary",
-      disabled: !showPreviousButton,
-      onClick: () => {
-        onPreviousClick();
-      },
-      "aria-label": labels.previousMonth,
-      className: classNames.navButtonPrev,
-      children: /*#__PURE__*/jsxRuntime.jsx(icons.ChevronLeft, {
-        color: "action"
-      })
-    }), /*#__PURE__*/jsxRuntime.jsx(core.IconButton, {
-      size: "small",
-      color: "primary",
-      disabled: !showNextButton,
-      onClick: () => {
-        onNextClick();
-      },
-      "aria-label": labels.nextMonth,
-      className: classNames.navButtonNext,
-      children: /*#__PURE__*/jsxRuntime.jsx(icons.ChevronRight, {
-        color: "action"
-      })
-    })]
-  });
-}
-var SHORT_WEEKDAYS$1 = ['S', 'M', 'T', 'W', 'T', 'F', 'S'];
-function CalendarWeekDay$1(_ref3) {
-  var {
-    weekday,
-    className,
-    localeUtils
-  } = _ref3;
-  return /*#__PURE__*/jsxRuntime.jsx(core.Typography, {
-    variant: "h5",
-    component: "abbr",
-    className: className,
-    title: localeUtils.formatWeekdayLong(weekday),
-    children: SHORT_WEEKDAYS$1[weekday]
-  });
-}
-
-var _excluded$7 = ["footer", "classes", "direction", "quickSelection", "selectedDays", "disabledDays", "onDayClick", "onDayKeyDown", "onDayMouseEnter", "onDayMouseLeave", "onDayMouseDown", "onDayMouseUp", "onDayTouchEnd", "onDayTouchStart", "modifiers", "highlightedDays", "format", "initialTime", "initialMonth"];
-var useStyles$2 = /*#__PURE__*/styles$1.makeStyles(theme => ({
-  container: {
-    display: 'inline-block'
-  },
-  wrapper: {
-    userSelect: 'none',
-    position: 'relative',
-    flexDirection: 'row',
-    paddingBottom: theme.spacing(2),
-    '&:focus': {
-      outline: 'none'
-    }
-  },
-  interactionDisabled: {},
-  navBar: {},
-  navButtonPrev: {
-    position: 'absolute',
-    top: theme.spacing(1.5),
-    left: theme.spacing(1.5)
-  },
-  navButtonNext: {
-    position: 'absolute',
-    top: theme.spacing(1.5),
-    right: theme.spacing(1.5)
-  },
-  navButtonInteractionDisabled: {},
-  months: {
-    display: 'flex',
-    flexWrap: 'wrap',
-    justifyContent: 'center'
-  },
-  month: {
-    userSelect: 'none',
-    margin: theme.spacing(2, 2, 0, 2)
-  },
-  caption: {
-    textAlign: 'center',
-    display: 'table-caption',
-    marginBottom: theme.spacing(1),
-    padding: theme.spacing(0, 1)
-  },
-  weekdays: {
-    display: 'table-header-group'
-  },
-  weekdaysRow: {
-    display: 'flex',
-    margin: theme.spacing(1, 0)
-  },
-  weekday: {
-    margin: '1px',
-    display: 'flex',
-    alignItems: 'center',
-    justifyContent: 'center',
-    textDecoration: 'none',
-    color: ui.Color.Dark300,
-    width: theme.spacing(5),
-    height: theme.spacing(5)
-  },
-  weekNumber: {},
-  body: {
-    display: 'flex',
-    flexDirection: 'column'
-  },
-  week: {
-    display: 'flex'
-  },
-  // Day modifiers.
-  today: {},
-  outside: {},
-  selected: {},
-  disabled: {},
-  firstDayOfMonth: {},
-  lastDayOfMonth: {},
-  blue: {},
-  green: {},
-  purple: {},
-  red: {},
-  teal: {},
-  yellow: {},
-  day: {
-    zIndex: 1,
-    margin: '1px',
-    width: theme.spacing(5),
-    height: theme.spacing(5),
-    borderRadius: theme.spacing(0.5),
-    position: 'relative',
-    display: 'flex',
-    alignItems: 'center',
-    justifyContent: 'center',
-    transition: theme.transitions.create(['color', 'background-color']),
-    '&:before': {
-      content: '""',
-      top: 0,
-      left: -1,
-      right: -1,
-      bottom: 0,
-      zIndex: -1,
-      position: 'absolute',
-      backgroundColor: ui.Color.Transparent,
-      transition: theme.transitions.create('background-color')
-    },
-    '&:first-child, &$firstDayOfMonth': {
-      '&:before': {
-        borderRadius: theme.spacing(0.5, 0, 0, 0.5)
-      }
-    },
-    '&:last-child, &$lastDayOfMonth': {
-      '&:before': {
-        borderRadius: theme.spacing(0, 0.5, 0.5, 0)
-      }
-    },
-    '&:after': {
-      content: '""',
-      borderRadius: theme.spacing(0.5),
-      top: 0,
-      left: 0,
-      right: 0,
-      bottom: 0,
-      zIndex: -1,
-      position: 'absolute',
-      backgroundColor: ui.Color.Transparent,
-      transition: theme.transitions.create('background-color')
-    },
-    '&:hover, &:focus': {
-      outline: 'none'
-    },
-    '&$disabled': {
-      color: ui.Color.Dark100,
-      '&$selected:not($outside):after': {
-        backgroundColor: ui.Color.Silver300
-      }
-    },
-    '&:not($outside):not($disabled)': {
-      cursor: 'pointer',
-      color: ui.Color.Dark500,
-      '&:not($selected):not(:active)': {
-        '&$today': {
-          color: ui.Color.Blue300
-        },
-        '&:hover, &:focus': {
-          backgroundColor: ui.Color.Silver100
-        },
-        '&$blue': {
-          color: ui.Color.Blue500,
-          '&': {
-            backgroundColor: ui.Color.Blue50
-          }
-        },
-        '&$green': {
-          color: ui.Color.Green500,
-          '&': {
-            backgroundColor: ui.Color.Green50
-          }
-        },
-        '&$purple': {
-          color: ui.Color.Purple500,
-          '&': {
-            backgroundColor: ui.Color.Purple50
-          }
-        },
-        '&$red': {
-          color: ui.Color.Red500,
-          '&': {
-            backgroundColor: ui.Color.Red50
-          }
-        },
-        '&$teal': {
-          color: ui.Color.Teal500,
-          '&': {
-            backgroundColor: ui.Color.Teal50
-          }
-        },
-        '&$yellow': {
-          color: ui.Color.Yellow500,
-          '&': {
-            backgroundColor: ui.Color.Yellow50
-          }
-        }
-      },
-      '&:active, &$selected': {
-        color: ui.Color.White,
-        '&:after': {
-          backgroundColor: ui.Color.Blue300
-        }
-      }
-    }
-  },
-  footer: {
-    padding: theme.spacing(2)
-  },
-  todayButton: {}
-}), {
-  name: 'SD-Calendar'
-}); //
-// Utility Types
-//
-//
-// Internal Utils
-//
-
-function toDayPickerModifier$1(config, modifier) {
-  if (!modifier) {
-    return undefined;
-  }
-
-  return localDate => {
-    var dateValue = luxon.DateTime.fromObject({
-      year: localDate.getFullYear(),
-      month: localDate.getMonth() + 1,
-      day: localDate.getDate(),
-      hour: localDate.getHours(),
-      minute: localDate.getMinutes(),
-      second: localDate.getSeconds(),
-      millisecond: localDate.getMilliseconds()
-    });
-    return modifier({
-      config,
-      dateValue,
-      stringValue: stringifyDate$1(dateValue, config)
-    });
-  };
-}
-
-function toDayPickerHandler$1(config, classes, initialTime, handler) {
-  if (!handler) {
-    return undefined;
-  }
-
-  return (localDate, modifiers) => {
-    var dateValue = luxon.DateTime.fromObject({
-      year: localDate.getFullYear(),
-      month: localDate.getMonth() + 1,
-      day: localDate.getDate(),
-      hour: initialTime.hour,
-      minute: initialTime.minute,
-      second: initialTime.second,
-      millisecond: initialTime.millisecond
-    });
-    handler({
-      disabled: !!modifiers[classes.disabled],
-      selected: !!modifiers[classes.selected],
-      config,
-      dateValue,
-      stringValue: stringifyDate$1(dateValue, config)
-    });
-  };
-} //
-// Calendar
-//
-
-
-var Calendar$1 = /*#__PURE__*/react.forwardRef((_ref, ref) => {
-  var {
-    footer,
-    classes,
-    direction,
-    quickSelection,
-    selectedDays,
-    disabledDays,
-    onDayClick,
-    onDayKeyDown,
-    onDayMouseEnter,
-    onDayMouseLeave,
-    onDayMouseDown,
-    onDayMouseUp,
-    onDayTouchEnd,
-    onDayTouchStart,
-    modifiers,
-    highlightedDays,
-    format: formatProp,
-    initialTime: initialTimeInputProp,
-    initialMonth: initialMonthInputProp
-  } = _ref,
-      dayPickerProps = _objectWithoutProperties(_ref, _excluded$7);
-
-  var styles = useStyles$2({
-    classes
-  });
-  var config = useDateConfig$1({
-    format: formatProp
-  });
-  var initialTimeInput = useDateTime$1(initialTimeInputProp, config);
-  var initialMonthInput = useDateTime$1(initialMonthInputProp, config);
-  var [initialTime, initialMonth] = react.useMemo(() => {
-    var time = initialTimeInput;
-    var month = initialMonthInput;
-
-    if (!month.isValid) {
-      month = luxon.DateTime.local().startOf('month');
-    }
-
-    if (!time.isValid) {
-      time = month;
-    }
-
-    return [time, new Date(month.year, month.month - 1, month.day, month.hour, month.minute, month.second, month.millisecond)];
-  }, [initialTimeInput, initialMonthInput]);
-  var wrapModifier = toDayPickerModifier$1.bind(null, config);
-  var wrapHandler = toDayPickerHandler$1.bind(null, config, styles, initialTime);
-  var dayPickerModifiers = {
-    [styles.firstDayOfMonth]: wrapModifier(_ref2 => {
-      var {
-        dateValue
-      } = _ref2;
-      return dateValue.day === 1;
-    }),
-    [styles.lastDayOfMonth]: wrapModifier(_ref3 => {
-      var {
-        dateValue
-      } = _ref3;
-      return dateValue.day === dateValue.daysInMonth;
-    })
-  };
-
-  if (modifiers) {
-    for (var [key, modifier] of Object.entries(modifiers)) {
-      dayPickerModifiers[key] = wrapModifier(modifier);
-    }
-  }
-
-  if (highlightedDays) {
-    for (var [_key, _modifier] of Object.entries(highlightedDays)) {
-      dayPickerModifiers[styles[_key]] = wrapModifier(_modifier);
-    }
-  }
-
-  return /*#__PURE__*/jsxRuntime.jsxs(core.Grid, {
-    ref: ref,
-    container: true,
-    direction: direction,
-    children: [!!quickSelection && /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
-      children: [/*#__PURE__*/jsxRuntime.jsx(core.Grid, {
-        item: true,
-        xs: 12,
-        sm: "auto",
-        children: quickSelection
-      }), /*#__PURE__*/jsxRuntime.jsx(core.Hidden, {
-        xsDown: true,
-        children: /*#__PURE__*/jsxRuntime.jsx(core.Grid, {
-          item: true,
-          sm: "auto",
-          children: /*#__PURE__*/jsxRuntime.jsx(core.Divider, {
-            orientation: "vertical"
-          })
-        })
-      }), /*#__PURE__*/jsxRuntime.jsx(core.Hidden, {
-        smUp: true,
-        children: /*#__PURE__*/jsxRuntime.jsx(core.Grid, {
-          item: true,
-          xs: 12,
-          children: /*#__PURE__*/jsxRuntime.jsx(core.Divider, {
-            orientation: "horizontal"
-          })
-        })
-      })]
-    }), /*#__PURE__*/jsxRuntime.jsxs(core.Grid, {
-      item: true,
-      xs: 12,
-      sm: "auto",
-      children: [/*#__PURE__*/jsxRuntime.jsx(DayPicker, _objectSpread(_objectSpread({}, dayPickerProps), {}, {
-        classNames: styles,
-        navbarElement: CalendarNavbar$1,
-        captionElement: CalendarCaption$1,
-        weekdayElement: CalendarWeekDay$1,
-        initialMonth: initialMonth,
-        modifiers: dayPickerModifiers,
-        selectedDays: wrapModifier(selectedDays),
-        disabledDays: wrapModifier(disabledDays),
-        onDayClick: wrapHandler(onDayClick),
-        onDayKeyDown: wrapHandler(onDayKeyDown),
-        onDayMouseEnter: wrapHandler(onDayMouseEnter),
-        onDayMouseLeave: wrapHandler(onDayMouseLeave),
-        onDayMouseDown: wrapHandler(onDayMouseDown),
-        onDayMouseUp: wrapHandler(onDayMouseUp),
-        onDayTouchEnd: wrapHandler(onDayTouchEnd),
-        onDayTouchStart: wrapHandler(onDayTouchStart)
-      })), !!footer && /*#__PURE__*/jsxRuntime.jsx("div", {
-        className: styles.footer,
-        children: footer
-      })]
-    })]
-  });
-});
-if (process.env.NODE_ENV !== "production") Calendar$1.displayName = "Calendar";
-
-var CalendarQuickSelectionItem$1 = /*#__PURE__*/react.forwardRef((_ref, ref) => {
-  var {
-    onClick,
-    selected,
-    children
-  } = _ref;
-  return /*#__PURE__*/jsxRuntime.jsx(core.ListItem, {
-    ref: ref,
-    button: true,
-    selected: selected,
-    onClick: onClick,
-    children: children
-  });
-});
-if (process.env.NODE_ENV !== "production") CalendarQuickSelectionItem$1.displayName = "CalendarQuickSelectionItem";
-var CalendarQuickSelection$1 = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
-  var {
-    children
-  } = _ref2;
-  return /*#__PURE__*/jsxRuntime.jsxs(core.List, {
-    ref: ref,
-    children: [/*#__PURE__*/jsxRuntime.jsx(core.ListItem, {
-      children: /*#__PURE__*/jsxRuntime.jsx(core.Typography, {
-        variant: "h4",
-        children: "Quick Selection"
-      })
-    }), children]
-  });
-});
-if (process.env.NODE_ENV !== "production") CalendarQuickSelection$1.displayName = "CalendarQuickSelection";
-
-var _excluded$8 = ["id", "api", "onClear", "onClick", "onClose", "onKeyDown", "disabled", "children", "enableClearable", "inputRef", "InputProps"];
-var BaseDatePicker$1 = /*#__PURE__*/react.forwardRef((_ref, ref) => {
-  var {
-    id,
-    api,
-    onClear,
-    onClick: _onClick,
-    onClose,
-    onKeyDown: _onKeyDown,
-    disabled,
-    children,
-    enableClearable,
-    inputRef: inputRefProp,
-    InputProps: inputProps
-  } = _ref,
-      textFieldProps = _objectWithoutProperties(_ref, _excluded$8);
-
-  var uid = ui.useUID(id);
-  var labelID = "".concat(uid, "-label");
-  var clearIconID = "".concat(uid, "-clear-icon");
-  var inputRef = react.useRef(null);
-  var textFieldRef = react.useRef(null);
-  var [popoverAnchor, setPopoverAnchor] = react.useState(null);
-
-  function handleOpen() {
-    if (!disabled && textFieldRef.current) {
-      setPopoverAnchor(textFieldRef.current);
-    }
-  }
-
-  function handleClose() {
-    setPopoverAnchor(null);
-  }
-
-  react.useImperativeHandle(api, () => ({
-    close: handleClose
-  })); // We want to trigger close event only when UI will be ready after updates.
-
-  hooks.useValueObserver(popoverAnchor, () => {
-    if (!popoverAnchor) {
-      onClose === null || onClose === void 0 ? void 0 : onClose();
-    }
-  });
-  return /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
-    children: [/*#__PURE__*/jsxRuntime.jsx(core.Popover, {
-      open: !!popoverAnchor,
-      onClose: handleClose,
-      anchorEl: popoverAnchor,
-      anchorOrigin: {
-        vertical: 'bottom',
-        horizontal: 'left'
-      },
-      transformOrigin: {
-        vertical: 'top',
-        horizontal: 'left'
-      },
-      children: children
-    }), /*#__PURE__*/jsxRuntime.jsx(core.TextField, _objectSpread(_objectSpread({}, textFieldProps), {}, {
-      id: uid,
-      ref: ui.mergeRefs(ref, textFieldRef),
-      disabled: disabled,
-      inputRef: ui.mergeRefs(inputRef, inputRefProp),
-      onClick: event => {
-        _onClick === null || _onClick === void 0 ? void 0 : _onClick(event);
-
-        if (!event.defaultPrevented) {
-          handleOpen();
-        }
-      },
-      onKeyDown: event => {
-        _onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(event);
-
-        if (!event.defaultPrevented && (event.key === ' ' || event.key === 'Enter')) {
-          handleOpen();
-        }
-      },
-      inputProps: {
-        readOnly: true
-      },
-      InputProps: _objectSpread(_objectSpread({}, inputProps), {}, {
-        endAdornment: /*#__PURE__*/jsxRuntime.jsx(core.InputAdornment, {
-          position: "end",
-          children: enableClearable ? /*#__PURE__*/jsxRuntime.jsx(core.IconButton, {
-            disabled: disabled,
-            "aria-labelledby": "".concat(clearIconID, " ").concat(labelID),
-            onClick: event => {
-              // Do not bubble up clicks.
-              event.stopPropagation();
-              onClear === null || onClear === void 0 ? void 0 : onClear();
-            },
-            children: /*#__PURE__*/jsxRuntime.jsx(icons.Clear, {
-              id: clearIconID,
-              "aria-label": "clear"
-            })
-          }) : /*#__PURE__*/jsxRuntime.jsx(core.IconButton, {
-            disabled: disabled,
-            children: /*#__PURE__*/jsxRuntime.jsx(core.SvgIcon, {
-              children: /*#__PURE__*/jsxRuntime.jsx("path", {
-                d: js.mdiCalendarMonth
-              })
-            })
-          })
-        })
-      })
-    }))]
-  });
-});
-if (process.env.NODE_ENV !== "production") BaseDatePicker$1.displayName = "BaseDatePicker";
-
-var _excluded$9 = ["variant", "fallback"],
-    _excluded2$4 = ["date", "fallback"];
-function useFormattedDate$1(input, _ref) {
-  var {
-    variant,
-    fallback
-  } = _ref,
-      dateConfig = _objectWithoutProperties(_ref, _excluded$9);
-
-  var config = useDateConfig$1(dateConfig);
-  var date = useDateTime$1(input, config);
-  return react.useMemo(() => formatDate$1(date, {
-    variant,
-    fallback
-  }, config), [date, config, variant, fallback]);
-}
-function FormattedDate$1(_ref2) {
-  var {
-    date,
-    fallback = 'Invalid Date'
-  } = _ref2,
-      options = _objectWithoutProperties(_ref2, _excluded2$4);
-
-  var formatted = useFormattedDate$1(date, _objectSpread(_objectSpread({}, options), {}, {
-    fallback: ''
-  }));
-  return ui.renderChildren(formatted || fallback);
-}
-
-var _excluded$a = ["onDayClick"],
-    _excluded2$5 = ["onBlur", "onFocus", "onChange", "renderFooter", "renderQuickSelection", "value", "format", "fallback", "variant", "enableClearable", "disableCloseOnSelect", "CalendarProps"];
-var DateField$1 = /*#__PURE__*/react.forwardRef((_ref, ref) => {
-  var {
-    onBlur,
-    onFocus,
-    onChange,
-    renderFooter,
-    renderQuickSelection,
-    value: valueProp,
-    format: formatProp,
-    fallback = '',
-    variant = 'Date',
-    enableClearable,
-    disableCloseOnSelect,
-    CalendarProps: {
-      onDayClick: _onDayClick
-    } = {}
-  } = _ref,
-      calendarProps = _objectWithoutProperties(_ref.CalendarProps, _excluded$a),
-      textFieldProps = _objectWithoutProperties(_ref, _excluded2$5);
-
-  var config = useDateConfig$1({
-    format: formatProp
-  });
-  var apiRef = react.useRef(null);
-  var date = useDateTime$1(valueProp, config);
-  var displayValue = useFormattedDate$1(date, _objectSpread({
-    variant,
-    fallback
-  }, config));
-  var dateString = react.useMemo(() => stringifyDate$1(date, config), [date, config]);
-
-  function handleClose() {
-    var _apiRef$current;
-
-    (_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.close();
-  }
-
-  function handleChange(nextInput) {
-    if (onChange) {
-      onChange(toDatePayload$1(nextInput, config));
-    }
-
-    if (!disableCloseOnSelect) {
-      handleClose();
-    }
-  }
-
-  var api = {
-    config,
-    dateValue: date,
-    stringValue: dateString,
-    close: handleClose,
-    change: handleChange
-  };
-  return /*#__PURE__*/jsxRuntime.jsx(BaseDatePicker$1, _objectSpread(_objectSpread({}, textFieldProps), {}, {
-    ref: ref,
-    api: apiRef,
-    onClose: onBlur,
-    value: displayValue || fallback,
-    enableClearable: enableClearable && date.isValid,
-    onClear: () => {
-      handleChange(undefined);
-    },
-    children: /*#__PURE__*/jsxRuntime.jsx(Calendar$1, _objectSpread(_objectSpread({}, calendarProps), {}, {
-      initialMonth: date,
-      footer: renderFooter === null || renderFooter === void 0 ? void 0 : renderFooter(api),
-      quickSelection: renderQuickSelection === null || renderQuickSelection === void 0 ? void 0 : renderQuickSelection(api),
-      selectedDays: _ref2 => {
-        var {
-          dateValue
-        } = _ref2;
-        return date.hasSame(dateValue, 'day');
-      },
-      onDayClick: event => {
-        _onDayClick === null || _onDayClick === void 0 ? void 0 : _onDayClick(event);
-
-        if (!event.disabled) {
-          handleChange(event.dateValue);
-        }
-      }
-    }))
-  }));
-});
-if (process.env.NODE_ENV !== "production") DateField$1.displayName = "DateField";
-
-function useDateTimeRange$1(input, options) {
-  var config = useDateConfig$1(options);
-  var [startInput, finishInput] = toPrimitiveDateRangeInput$1(input);
-  var startDate = useDateTime$1(startInput, config);
-  var finishDate = useDateTime$1(finishInput, config);
-  return react.useMemo(() => parseDateRange$1([startDate, finishDate], config), [config, startDate, finishDate]);
-}
-
-var _excluded$b = ["modifiers", "onDayClick", "onDayMouseEnter"],
-    _excluded2$6 = ["onBlur", "onFocus", "onChange", "renderFooter", "renderQuickSelection", "value", "format", "fallback", "enableClearable", "disableCloseOnSelect", "CalendarProps"],
-    _excluded3$1 = ["rangeStart", "rangeFinish"];
-var useStyles$3 = /*#__PURE__*/styles$1.makeStyles(theme => ({
-  rangeStart: {},
-  rangeFinish: {},
-  outside: {},
-  disabled: {},
-  selected: {},
-  day: {
-    '&$selected:not($outside)': {
-      '&$rangeStart:before': {
-        left: theme.spacing(0.5)
-      },
-      '&$rangeFinish:before': {
-        right: theme.spacing(0.5)
-      },
-      '&:not($rangeStart):not($rangeFinish)': {
-        '&:after': {
-          backgroundColor: ui.Color.Transparent
-        },
-        '&$disabled': {
-          '&:before': {
-            backgroundColor: ui.Color.Silver100
-          }
-        },
-        '&:not($disabled)': {
-          color: ui.Color.Blue500,
-          '&:before': {
-            backgroundColor: ui.Color.Blue50
-          }
-        }
-      }
-    }
-  }
-}), {
-  name: 'SD-DateRangeField'
-});
-var DateRangeField$1 = /*#__PURE__*/react.forwardRef((_ref, ref) => {
-  var {
-    onBlur,
-    onFocus,
-    onChange,
-    renderFooter,
-    renderQuickSelection,
-    value: valueProp,
-    format: formatProp,
-    fallback = '',
-    enableClearable,
-    disableCloseOnSelect,
-    CalendarProps: {
-      modifiers,
-      onDayClick: _onDayClick,
-      onDayMouseEnter: _onDayMouseEnter
-    } = {}
-  } = _ref,
-      calendarProps = _objectWithoutProperties(_ref.CalendarProps, _excluded$b),
-      textFieldProps = _objectWithoutProperties(_ref, _excluded2$6);
-
-  var apiRef = react.useRef(null);
-
-  var _useStyles = useStyles$3({}),
-      {
-    rangeStart,
-    rangeFinish
-  } = _useStyles,
-      styles = _objectWithoutProperties(_useStyles, _excluded3$1);
-
-  var config = useDateConfig$1({
-    format: formatProp
-  });
-  var [startDate, finishDate] = useDateTimeRange$1(valueProp, config);
-  var [startDateString, finishDateString] = react.useMemo(() => stringifyDateRange$1([startDate, finishDate], config), [config, startDate, finishDate]);
-  var displayValue = react.useMemo(() => formatDateRange$1([startDate, finishDate], {
-    fallback
-  }, config), [config, fallback, startDate, finishDate]);
-  var [hoveredDate, setHoveredDate] = react.useState();
-  var [calendarStartDate, calendarFinishDate] = react.useMemo(() => {
-    var [nextCalendarStartDate, nextCalendarFinishDate] = parseDateRange$1([startDate, finishDate || hoveredDate], config);
-    return [nextCalendarStartDate === null || nextCalendarStartDate === void 0 ? void 0 : nextCalendarStartDate.startOf('day'), nextCalendarFinishDate === null || nextCalendarFinishDate === void 0 ? void 0 : nextCalendarFinishDate.endOf('day')];
-  }, [config, startDate, finishDate, hoveredDate]);
-
-  function handleClose() {
-    var _apiRef$current;
-
-    (_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.close();
-  }
-
-  function handleChange(nextValue) {
-    var _nextFinishDate;
-
-    var [nextStartDate, nextFinishDate] = parseDateRange$1(nextValue, config);
-
-    if (onChange) {
-      if (nextStartDate) {
-        if (startDate) {
-          nextStartDate = nextStartDate.set({
-            hour: startDate.hour,
-            minute: startDate.minute,
-            second: startDate.second,
-            millisecond: startDate.millisecond
-          });
-        } else {
-          nextStartDate = nextStartDate.startOf('day');
-        }
-      }
-
-      if (nextFinishDate) {
-        nextFinishDate = nextFinishDate.endOf('day');
-      }
-
-      onChange(toDateRangePayload$1([nextStartDate, nextFinishDate], config));
-    }
-
-    if (!disableCloseOnSelect && (_nextFinishDate = nextFinishDate) !== null && _nextFinishDate !== void 0 && _nextFinishDate.isValid) {
-      handleClose();
-    }
-  }
-
-  var api = {
-    config,
-    close: handleClose,
-    change: handleChange,
-    dateValue: [startDate, finishDate],
-    stringValue: [startDateString, finishDateString]
-  };
-  return /*#__PURE__*/jsxRuntime.jsx(BaseDatePicker$1, _objectSpread(_objectSpread({}, textFieldProps), {}, {
-    ref: ref,
-    api: apiRef,
-    value: displayValue || fallback,
-    enableClearable: enableClearable && !!startDate && !!finishDate,
-    onClear: () => {
-      handleChange([undefined, undefined]);
-    },
-    onClose: () => {
-      onBlur === null || onBlur === void 0 ? void 0 : onBlur();
-      setHoveredDate(undefined);
-    },
-    children: /*#__PURE__*/jsxRuntime.jsx(Calendar$1, _objectSpread(_objectSpread({
-      numberOfMonths: 2
-    }, calendarProps), {}, {
-      classes: styles,
-      initialMonth: startDateString,
-      modifiers: _objectSpread(_objectSpread({}, modifiers), {}, {
-        [rangeStart]: _ref2 => {
-          var {
-            dateValue
-          } = _ref2;
-          return !!(calendarStartDate !== null && calendarStartDate !== void 0 && calendarStartDate.hasSame(dateValue, 'day'));
-        },
-        [rangeFinish]: _ref3 => {
-          var {
-            dateValue
-          } = _ref3;
-          return !!(calendarFinishDate !== null && calendarFinishDate !== void 0 && calendarFinishDate.hasSame(dateValue, 'day'));
-        }
-      }),
-      selectedDays: _ref4 => {
-        var {
-          dateValue
-        } = _ref4;
-
-        if (calendarStartDate) {
-          if (!calendarFinishDate) {
-            return calendarStartDate.hasSame(dateValue, 'day');
-          }
-
-          return calendarStartDate <= dateValue && dateValue <= calendarFinishDate;
-        }
-
-        return false;
-      },
-      footer: renderFooter === null || renderFooter === void 0 ? void 0 : renderFooter(api),
-      quickSelection: renderQuickSelection === null || renderQuickSelection === void 0 ? void 0 : renderQuickSelection(api),
-      onDayMouseEnter: event => {
-        _onDayMouseEnter === null || _onDayMouseEnter === void 0 ? void 0 : _onDayMouseEnter(event);
-        setHoveredDate(!event.disabled ? event.dateValue.valueOf() : undefined);
-      },
-      onDayClick: event => {
-        _onDayClick === null || _onDayClick === void 0 ? void 0 : _onDayClick(event);
-
-        if (!event.disabled) {
-          if (startDate && !finishDate) {
-            handleChange([startDateString, event.stringValue]);
-          } else {
-            handleChange([event.stringValue, undefined]);
-          }
-        }
-      }
-    }))
-  }));
-});
-if (process.env.NODE_ENV !== "production") DateRangeField$1.displayName = "DateRangeField";
-
-/** @deprecated */
-
-/** @deprecated */
-
-function toDateTime$1(value) {
-  return typeof value === 'number' ? luxon.DateTime.fromMillis(value) : luxon.DateTime.fromJSDate(value);
-}
-/** @deprecated */
-
-
-function isDate$1(value) {
-  return value != null && value instanceof Date;
-}
-/** @deprecated */
-
-function isDateLike$1(value) {
-  return isDate$1(value) || typeof value === 'number' && Number.isInteger(value);
-}
-/** @deprecated */
-
-function isValidDate$1(value) {
-  return isDate$1(value) && Number.isFinite(value.getTime());
-}
-/** @deprecated */
-
-function checkRange$1(range, validator) {
-  if (!Array.isArray(range) || range.length > 2) {
-    return false;
-  }
-
-  var [start, finish] = range;
-  return (start == null || validator(start)) && (finish == null || validator(finish));
-}
-/** @deprecated */
-
-
-function isDateRange$1(range) {
-  return checkRange$1(range, isDate$1);
-}
-/** @deprecated */
-
-function isDateRangeLike$1(range) {
-  return checkRange$1(range, isDateLike$1);
-}
-/** @deprecated */
-
-function isValidDateRange$1(range) {
-  return checkRange$1(range, isValidDate$1);
-}
-/** @deprecated */
-
-function toDate$1(value) {
-  return !isDateLike$1(value) ? new Date(NaN) : new Date(value);
-}
-/** @deprecated */
-
-function toDateRange$1(range) {
-  if (range == null || !isDateRangeLike$1(range)) {
-    return [];
-  }
-
-  return range.filter(x => x != null).map(x => x == null ? undefined : toDate$1(x)).sort((a, b) => !isValidDate$1(a) ? -1 : !isValidDate$1(b) ? 1 : a.valueOf() - b.valueOf());
-}
-/** @deprecated */
-
-/** @deprecated */
-
-class DateUtils$1 {
-  /** @deprecated */
-  toObject(value) {
-    var {
-      year = NaN,
-      month = NaN,
-      day = NaN,
-      hour = NaN,
-      minute = NaN,
-      second = NaN,
-      millisecond = NaN
-    } = toDateTime$1(value).toObject({
-      includeConfig: false
-    });
-    return {
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      millisecond
-    };
-  }
-  /** @deprecated */
-
-
-  fromObject(_ref) {
-    var {
-      year = 0,
-      month = 1,
-      day = 1,
-      hour = 0,
-      minute = 0,
-      second = 0,
-      millisecond = 0
-    } = _ref;
-
-    if (Number.isNaN(year) || Number.isNaN(month) || Number.isNaN(day) || Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second) || Number.isNaN(millisecond)) {
-      return new Date(NaN);
-    }
-
-    return luxon.DateTime.fromObject({
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      millisecond
-    }).toJSDate();
-  }
-  /** @deprecated */
-
-
-  update(value, values) {
-    return toDateTime$1(value).set(values).toJSDate();
-  }
-  /** @deprecated */
-
-
-  mergeDateAndTime(date, time) {
-    var {
-      hour,
-      minute,
-      second,
-      millisecond
-    } = this.toObject(time);
-
-    if (Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second) || Number.isNaN(millisecond)) {
-      return new Date(NaN);
-    }
-
-    return this.update(date, {
-      hour,
-      minute,
-      second,
-      millisecond
-    });
-  }
-  /** @deprecated */
-
-
-  startOf(value, unit) {
-    return toDateTime$1(value).startOf(unit).toJSDate();
-  }
-  /** @deprecated */
-
-
-  endOf(value, unit) {
-    return toDateTime$1(value).endOf(unit).toJSDate();
-  }
-  /** @deprecated */
-
-
-  plus(value, values) {
-    return toDateTime$1(value).plus(values).toJSDate();
-  }
-  /** @deprecated */
-
-
-  minus(value, values) {
-    return toDateTime$1(value).minus(values).toJSDate();
-  }
-  /** @deprecated */
-
-
-  isSameDate(value, compare) {
-    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'millisecond';
-
-    if (value == null && compare == null) {
-      return true;
-    }
-
-    if (value == null || compare == null) {
-      return false;
-    }
-
-    var dateTimeValue = toDateTime$1(value);
-    var dateTimeCompare = toDateTime$1(compare);
-    return dateTimeValue.isValid && dateTimeCompare.isValid && dateTimeValue.startOf(unit).equals(dateTimeCompare.startOf(unit));
-  }
-  /** @deprecated */
-
-
-  isSameDateRange(value, compare, unit) {
-    var range1 = toDateRange$1(value);
-    var range2 = toDateRange$1(compare);
-    return !range1.some((date, idx) => !this.isSameDate(date, range2[idx], unit));
-  }
-  /** @deprecated */
-
-
-  diff(value, compare, unit) {
-    var valueDateTime = toDateTime$1(value);
-    var compareDateTime = toDateTime$1(compare);
-    return valueDateTime.diff(compareDateTime, unit).as(unit);
-  }
-  /** @deprecated */
-
-
-  toLocaleString(value, options) {
-    return toDateTime$1(value).toLocaleString(options);
-  }
-  /** @deprecated */
-
-
-  format(value, variant) {
-    return this.toLocaleString(value, variant === 'date' ? {
-      day: '2-digit',
-      month: 'short',
-      year: 'numeric'
-    } : variant === 'shortDate' ? {
-      day: '2-digit',
-      month: 'short'
-    } : variant === 'time' ? {
-      hour: 'numeric',
-      minute: 'numeric'
-    } : {
-      day: '2-digit',
-      month: 'short',
-      year: 'numeric',
-      hour: 'numeric',
-      minute: 'numeric'
-    });
-  }
-  /** @deprecated */
-
-
-  formatRange(value) {
-    var emptyText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-    var range = toDateRange$1(value);
-
-    if (!isValidDateRange$1(range)) {
-      return 'Invalid Date Range';
-    }
-
-    var [start, finish] = range;
-
-    if (!start) {
-      return emptyText;
-    }
-
-    var startText = this.format(start, !this.isSameDate(start, finish, 'year') ? 'date' : 'shortDate');
-    var finishText = !finish ? '…' : this.format(finish, 'date');
-    return "".concat(startText, " - ").concat(finishText);
-  }
-  /** @deprecated */
-
-
-  formatRelativeTime(value) {
-    var {
-      style = 'long',
-      compare = Date.now()
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var valueDateTime = toDateTime$1(value);
-    var compareDateTime = toDateTime$1(compare);
-    return valueDateTime.toRelative({
-      style,
-      base: compareDateTime
-    });
-  }
-
-}
-function useDateUtils$1() {
-  return react.useMemo(() => new DateUtils$1(), []);
-}
-
-var _excluded$c = ["unit", "round", "padding", "fallback", "base"],
-    _excluded2$7 = ["date", "fallback"];
-function useFormattedRelativeTime$1(input) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-      {
-    unit,
-    round,
-    padding,
-    fallback,
-    base: baseOption
-  } = _ref,
-      dateConfig = _objectWithoutProperties(_ref, _excluded$c);
-
-  var config = useDateConfig$1(dateConfig);
-  var date = useDateTime$1(input, config);
-  var baseOptionDate = useDateTime$1(baseOption, config);
-  var base = baseOption == null ? undefined : baseOptionDate;
-  return react.useMemo(() => formatRelativeTime$1(date, {
-    base,
-    unit,
-    round,
-    padding,
-    fallback
-  }, config), [base, date, unit, round, config, padding, fallback]);
-}
-function FormattedRelativeTime$1(_ref2) {
-  var {
-    date,
-    fallback = 'Invalid Date'
-  } = _ref2,
-      options = _objectWithoutProperties(_ref2, _excluded2$7);
-
-  var formatted = useFormattedRelativeTime$1(date, _objectSpread(_objectSpread({}, options), {}, {
-    fallback: ''
-  }));
-  return ui.renderChildren(formatted || fallback);
-}
-
-var _excluded$d = ["disabled", "onChange", "value", "format"];
-var TIME_MATCH_FORMATS$1 = ['h:mm a', 'h:mma', 'H:mm', 'h:mm', 'hmm', 'Hmm', 'h', 'H'];
-
-function toTimeFieldOption$1(date, config) {
-  return {
-    value: date.valueOf(),
-    label: formatDate$1(date, {
-      variant: 'Time'
-    }, config),
-    pattern: new RegExp("^(".concat(TIME_MATCH_FORMATS$1.map(format => date.toFormat(format)).join('|'), ")"), 'i')
-  };
-}
-
-function normalizeInputValue$1(inputValue) {
-  return inputValue.replace(/[\s]/g, '').toLowerCase();
-}
-
-function makeOptions$1(config) {
-  var options = [];
-  var now = luxon.DateTime.local().startOf('day');
-
-  for (var i = 0; i < 96; i++) {
-    options.push(toTimeFieldOption$1(now.set({
-      minute: i * 15
-    }), config));
-  }
-
-  var cache = new Map();
-  return [options, (_, _ref) => {
-    var {
-      inputValue
-    } = _ref;
-    var query = normalizeInputValue$1(inputValue);
-
-    if (!query) {
-      return options;
-    }
-
-    var filtered = cache.get(query);
-
-    if (!filtered) {
-      filtered = options.filter(option => option.pattern.test(query));
-      cache.set(query, filtered);
-    }
-
-    return filtered;
-  }];
-}
-
-var TimeField$1 = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
-  var {
-    disabled,
-    onChange,
-    value: valueProp,
-    format: formatProp
-  } = _ref2,
-      props = _objectWithoutProperties(_ref2, _excluded$d);
-
-  var config = useDateConfig$1({
-    format: formatProp
-  });
-  var date = useDateTime$1(valueProp, config);
-  var selectedOption = react.useMemo(() => !date.isValid ? undefined : toTimeFieldOption$1(date, config), [date, config]);
-  var [options, filterOptions] = react.useMemo(() => makeOptions$1(config), [config]);
-  var [inputValue, setInputValue] = react.useState('');
-
-  function handleChange(nextValue) {
-    if (onChange) {
-      onChange(toDatePayload$1(nextValue, config));
-    }
-  }
-
-  function handleType(text) {
-    text = normalizeInputValue$1(text);
-
-    for (var timeFormat of TIME_MATCH_FORMATS$1) {
-      var nextDate = luxon.DateTime.fromFormat(text, timeFormat);
-
-      if (nextDate.isValid) {
-        if (onChange) {
-          if (date.isValid) {
-            nextDate = nextDate.set({
-              year: date.year,
-              month: date.month,
-              day: date.day
-            });
-          }
-
-          onChange(toDatePayload$1(nextDate, config));
-        }
-
-        return;
-      }
-    }
-
-    setInputValue((selectedOption === null || selectedOption === void 0 ? void 0 : selectedOption.label) || '');
-  }
-
-  react.useEffect(() => {
-    if (!date.isValid) {
-      setInputValue('');
-    } else {
-      setInputValue(formatDate$1(date, {
-        variant: 'Time'
-      }, config));
-    }
-  }, [date, config]);
-  return /*#__PURE__*/jsxRuntime.jsx(lab.Autocomplete, {
-    ref: ref,
-    disabled: disabled,
-    freeSolo: true,
-    autoComplete: true,
-    value: selectedOption,
-    inputValue: inputValue,
-    options: options,
-    includeInputInList: true,
-    filterOptions: filterOptions,
-    getOptionLabel: option => typeof option === 'string' ? option : option.label,
-    onBlur: event => {
-      handleType(event.target.value);
-    },
-    onChange: (_, nextValue) => {
-      if (typeof nextValue === 'string') {
-        handleType(nextValue);
-      } else {
-        handleChange(nextValue === null || nextValue === void 0 ? void 0 : nextValue.value);
-      }
-    },
-    onInputChange: (_, nextInputValue) => {
-      setInputValue(nextInputValue);
-    },
-    renderInput: params => /*#__PURE__*/jsxRuntime.jsx(core.TextField, _objectSpread(_objectSpread(_objectSpread({
-      variant: "outlined"
-    }, props), params), {}, {
-      InputProps: params.InputProps
-    }))
-  });
-});
-if (process.env.NODE_ENV !== "production") TimeField$1.displayName = "TimeField";
-
-exports.Calendar = Calendar$1;
-exports.CalendarQuickSelection = CalendarQuickSelection$1;
-exports.CalendarQuickSelectionItem = CalendarQuickSelectionItem$1;
-exports.DateConfigProvider = DateConfigProvider$1;
-exports.DateField = DateField$1;
-exports.DateRangeField = DateRangeField$1;
-exports.DateUtils = DateUtils$1;
-exports.FormattedDate = FormattedDate$1;
-exports.FormattedRelativeTime = FormattedRelativeTime$1;
-exports.TimeField = TimeField$1;
-exports.defaultDateConfig = defaultDateConfig$1;
-exports.formatDate = formatDate$1;
-exports.formatDateRange = formatDateRange$1;
-exports.formatRelativeTime = formatRelativeTime$1;
-exports.isDate = isDate$1;
-exports.isDateLike = isDateLike$1;
-exports.isDateRange = isDateRange$1;
-exports.isDateRangeLike = isDateRangeLike$1;
-exports.isValidDate = isValidDate$1;
-exports.isValidDateRange = isValidDateRange$1;
-exports.parseDate = parseDate$1;
-exports.parseDateRange = parseDateRange$1;
-exports.setDefaultTimeZone = setDefaultTimeZone$1;
-exports.stringifyDate = stringifyDate$1;
-exports.stringifyDateRange = stringifyDateRange$1;
-exports.toDate = toDate$1;
-exports.toDatePayload = toDatePayload$1;
-exports.toDateRange = toDateRange$1;
-exports.toDateRangePayload = toDateRangePayload$1;
-exports.toPrimitiveDateInput = toPrimitiveDateInput$1;
-exports.toPrimitiveDateRangeInput = toPrimitiveDateRangeInput$1;
-exports.useDateConfig = useDateConfig$1;
-exports.useDateTime = useDateTime$1;
-exports.useDateTimeRange = useDateTimeRange$1;
-exports.useDateUtils = useDateUtils$1;
-exports.useDefaultTimeZone = useDefaultTimeZone$1;
-exports.useFormattedDate = useFormattedDate$1;
-exports.useFormattedRelativeTime = useFormattedRelativeTime$1;
-exports.v5 = index;
+exports.Calendar = Calendar;
+exports.CalendarQuickSelection = CalendarQuickSelection;
+exports.CalendarQuickSelectionItem = CalendarQuickSelectionItem;
+exports.DateConfigProvider = DateConfigProvider;
+exports.DateField = DateField;
+exports.DateRangeField = DateRangeField;
+exports.DateUtils = DateUtils;
+exports.FormattedDate = FormattedDate;
+exports.FormattedRelativeTime = FormattedRelativeTime;
+exports.TimeField = TimeField;
+exports.defaultDateConfig = defaultDateConfig;
+exports.formatDate = formatDate;
+exports.formatDateRange = formatDateRange;
+exports.formatRelativeTime = formatRelativeTime;
+exports.isDate = isDate;
+exports.isDateLike = isDateLike;
+exports.isDateRange = isDateRange;
+exports.isDateRangeLike = isDateRangeLike;
+exports.isValidDate = isValidDate;
+exports.isValidDateRange = isValidDateRange;
+exports.parseDate = parseDate;
+exports.parseDateRange = parseDateRange;
+exports.setDefaultTimeZone = setDefaultTimeZone;
+exports.stringifyDate = stringifyDate;
+exports.stringifyDateRange = stringifyDateRange;
+exports.toDate = toDate;
+exports.toDatePayload = toDatePayload;
+exports.toDateRange = toDateRange;
+exports.toDateRangePayload = toDateRangePayload;
+exports.toPrimitiveDateInput = toPrimitiveDateInput;
+exports.toPrimitiveDateRangeInput = toPrimitiveDateRangeInput;
+exports.useDateConfig = useDateConfig;
+exports.useDateTime = useDateTime;
+exports.useDateTimeRange = useDateTimeRange;
+exports.useDateUtils = useDateUtils;
+exports.useDefaultTimeZone = useDefaultTimeZone;
+exports.useFormattedDate = useFormattedDate;
+exports.useFormattedRelativeTime = useFormattedRelativeTime;
 //# sourceMappingURL=index.js.map