@cerebruminc/cerebellum 16.0.0-beta.dangerous.b3c9c8c → 16.0.0-beta.dangerous.c8b4799

package/lib/esm/DatePicker.js

@@ -1,7 +1,7 @@
 import { _ as __assign } from './_tslib-CcAXazg4.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { useRef, useState, useEffect } from 'react';
-import { D as DatePickerGroup, I as InlineDatePicker, V as ValidationText, H as HelperText } from './InlineDatePicker-BeRq7pJP.js';
+import { D as DatePickerGroup, I as InlineDatePicker, V as ValidationText, H as HelperText } from './InlineDatePicker-ClVBWEzW.js';
 import { u as useMeasure } from './useMeasure-D89v6c_A.js';
 import { s as showLabel } from './showLabel-D6KgNem4.js';
 import { L as LabelBox, A as Asterisk } from './Inputs-C6OWHviY.js';

package/lib/esm/Form.js

@@ -1,5 +1,5 @@
 export { F as FormWrapper } from './FormStyles-BQJPyTS0.js';
-export { F as Form } from './FormikContainer-C75cvTmz.js';
+export { F as Form } from './FormikContainer-SJPYfIkF.js';
 export { FormFieldTypeEnum, RemovableFieldTypeEnum, isAddress, isCheckbox, isCheckboxGroup, isConfigurableInput, isCountrySelect, isCountySelect, isCreditCard, isCurrency, isDatePicker, isDescriptiveDropdownInput, isEmail, isFormFieldType, isImagePicker, isMultiSelect, isNationalitySelect, isNumber, isPassword, isPhone, isRadioGroup, isRemovable, isSectionHeader, isSelect, isSocialSecurity, isSplitLine, isStateSelect, isTextarea, isToggle, isToggleGroup, isZipCode } from './FormFieldTypeEnum.js';
 import './_tslib-CcAXazg4.js';
 import 'styled-components';
@@ -92,7 +92,7 @@ import './cardValidationStateMachine.js';
 import './CurrencyInput-CzI4uaoz.js';
 import './InlineCurrencyInput-DPpU3QyZ.js';
 import './DatePicker.js';
-import './InlineDatePicker-BeRq7pJP.js';
+import './InlineDatePicker-ClVBWEzW.js';
 import './Calendar.js';
 import './ClickOutHandler-CcKVoXIs.js';
 import './CaretLeft.js';

package/lib/esm/{FormikContainer-C75cvTmz.js → FormikContainer-SJPYfIkF.js}

@@ -37,7 +37,7 @@ import { C as CurrencyInput } from './CurrencyInput-CzI4uaoz.js';
 import { I as InlineCurrencyInput } from './InlineCurrencyInput-DPpU3QyZ.js';
 import { getFloatValueFromString } from './formatBytesToString.js';
 import { DatePicker } from './DatePicker.js';
-import { I as InlineDatePicker } from './InlineDatePicker-BeRq7pJP.js';
+import { I as InlineDatePicker } from './InlineDatePicker-ClVBWEzW.js';
 import './CheckboxStyles-Cx6hCn3t.js';
 import './RadioStyles-CjeGoQU0.js';
 import './ToggleStyles-DxTKSAXl.js';
@@ -1576,4 +1576,4 @@ var FormikContainer = function (props) {
 };
 
 export { FormikContainer as F, NationalityDropdown as N, nationalityList as n };
-//# sourceMappingURL=FormikContainer-C75cvTmz.js.map
+//# sourceMappingURL=FormikContainer-SJPYfIkF.js.map

package/lib/esm/{FormikContainer-C75cvTmz.js.map → FormikContainer-SJPYfIkF.js.map}

@@ -1 +1 @@
-{"version":3,"file":"FormikContainer-C75cvTmz.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"FormikContainer-SJPYfIkF.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/esm/{InlineDatePicker-BeRq7pJP.js → InlineDatePicker-ClVBWEzW.js}

@@ -7497,40 +7497,34 @@ function isShadowRoot(value) {
   }
   return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
 }
-const invalidOverflowDisplayValues = /*#__PURE__*/new Set(['inline', 'contents']);
 function isOverflowElement(element) {
   const {
     overflow,
     overflowX,
     overflowY,
     display
-  } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
 }
-const tableElements = /*#__PURE__*/new Set(['table', 'td', 'th']);
 function isTableElement(element) {
-  return tableElements.has(getNodeName(element));
+  return ['table', 'td', 'th'].includes(getNodeName(element));
 }
-const topLayerSelectors = [':popover-open', ':modal'];
 function isTopLayer(element) {
-  return topLayerSelectors.some(selector => {
+  return [':popover-open', ':modal'].some(selector => {
     try {
       return element.matches(selector);
-    } catch (_e) {
+    } catch (e) {
       return false;
     }
   });
 }
-const transformProperties = ['transform', 'translate', 'scale', 'rotate', 'perspective'];
-const willChangeValues = ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'];
-const containValues = ['paint', 'layout', 'strict', 'content'];
 function isContainingBlock(elementOrCss) {
   const webkit = isWebKit();
-  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
 
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
   // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-  return transformProperties.some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || willChangeValues.some(value => (css.willChange || '').includes(value)) || containValues.some(value => (css.contain || '').includes(value));
+  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
 }
 function getContainingBlock(element) {
   let currentNode = getParentNode(element);
@@ -7548,11 +7542,10 @@ function isWebKit() {
   if (typeof CSS === 'undefined' || !CSS.supports) return false;
   return CSS.supports('-webkit-backdrop-filter', 'none');
 }
-const lastTraversableNodeNames = /*#__PURE__*/new Set(['html', 'body', '#document']);
 function isLastTraversableNode(node) {
-  return lastTraversableNodeNames.has(getNodeName(node));
+  return ['html', 'body', '#document'].includes(getNodeName(node));
 }
-function getComputedStyle$1(element) {
+function getComputedStyle(element) {
   return getWindow(element).getComputedStyle(element);
 }
 function getNodeScroll(element) {
@@ -7654,9 +7647,8 @@ function getOppositeAxis(axis) {
 function getAxisLength(axis) {
   return axis === 'y' ? 'height' : 'width';
 }
-const yAxisSides = /*#__PURE__*/new Set(['top', 'bottom']);
 function getSideAxis(placement) {
-  return yAxisSides.has(getSide(placement)) ? 'y' : 'x';
+  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
 }
 function getAlignmentAxis(placement) {
   return getOppositeAxis(getSideAxis(placement));
@@ -7681,19 +7673,19 @@ function getExpandedPlacements(placement) {
 function getOppositeAlignmentPlacement(placement) {
   return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
 }
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
 function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
   switch (side) {
     case 'top':
     case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
     case 'left':
     case 'right':
-      return isStart ? tbPlacement : btPlacement;
+      return isStart ? tb : bt;
     default:
       return [];
   }
@@ -8145,7 +8137,7 @@ const flip$2 = function (options) {
           if (!ignoreCrossAxisOverflow ||
           // We leave the current main axis only if every placement on that axis
           // overflows the main axis.
-          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
+          overflowsData.every(d => d.overflows[0] > 0 && getSideAxis(d.placement) === initialSideAxis)) {
             // Try next placement and re-run the lifecycle.
             return {
               data: {
@@ -8202,8 +8194,6 @@ const flip$2 = function (options) {
   };
 };
 
-const originSides = /*#__PURE__*/new Set(['left', 'top']);
-
 // For type backwards-compatibility, the `OffsetOptions` type was also
 // Derivable.
 
@@ -8217,7 +8207,7 @@ async function convertValueToCoords(state, options) {
   const side = getSide(placement);
   const alignment = getAlignment(placement);
   const isVertical = getSideAxis(placement) === 'y';
-  const mainAxisMulti = originSides.has(side) ? -1 : 1;
+  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
   const rawValue = evaluate(options, state);
 
@@ -8289,7 +8279,7 @@ const offset$2 = function (options) {
 };
 
 function getCssDimensions(element) {
-  const css = getComputedStyle$1(element);
+  const css = getComputedStyle(element);
   // In testing environments, the `width` and `height` properties are empty
   // strings for SVG elements, returning NaN. Fallback to `0` in this case.
   let width = parseFloat(css.width) || 0;
@@ -8394,7 +8384,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
     while (currentIFrame && offsetParent && offsetWin !== currentWin) {
       const iframeScale = getScale(currentIFrame);
       const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = getComputedStyle$1(currentIFrame);
+      const css = getComputedStyle(currentIFrame);
       const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
       const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
       x *= iframeScale.x;
@@ -8425,9 +8415,14 @@ function getWindowScrollBarX(element, rect) {
   return rect.left + leftScroll;
 }
 
-function getHTMLOffset(documentElement, scroll) {
+function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
+  if (ignoreScrollbarX === void 0) {
+    ignoreScrollbarX = false;
+  }
   const htmlRect = documentElement.getBoundingClientRect();
-  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
+  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
+  // RTL <body> scrollbar.
+  getWindowScrollBarX(documentElement, htmlRect));
   const y = htmlRect.top + scroll.scrollTop;
   return {
     x,
@@ -8466,7 +8461,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -8489,7 +8484,7 @@ function getDocumentRect(element) {
   const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
   let x = -scroll.scrollLeft + getWindowScrollBarX(element);
   const y = -scroll.scrollTop;
-  if (getComputedStyle$1(body).direction === 'rtl') {
+  if (getComputedStyle(body).direction === 'rtl') {
     x += max(html.clientWidth, body.clientWidth) - width;
   }
   return {
@@ -8500,10 +8495,6 @@ function getDocumentRect(element) {
   };
 }
 
-// Safety check: ensure the scrollbar space is reasonable in case this
-// calculation is affected by unusual styles.
-// Most scrollbars leave 15-18px of space.
-const SCROLLBAR_MAX = 25;
 function getViewportRect(element, strategy) {
   const win = getWindow(element);
   const html = getDocumentElement(element);
@@ -8521,24 +8512,6 @@ function getViewportRect(element, strategy) {
       y = visualViewport.offsetTop;
     }
   }
-  const windowScrollbarX = getWindowScrollBarX(html);
-  // <html> `overflow: hidden` + `scrollbar-gutter: stable` reduces the
-  // visual width of the <html> but this is not considered in the size
-  // of `html.clientWidth`.
-  if (windowScrollbarX <= 0) {
-    const doc = html.ownerDocument;
-    const body = doc.body;
-    const bodyStyles = getComputedStyle(body);
-    const bodyMarginInline = doc.compatMode === 'CSS1Compat' ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
-    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
-    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
-      width -= clippingStableScrollbarWidth;
-    }
-  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
-    // If the <body> scrollbar is on the left, the width needs to be extended
-    // by the scrollbar amount so there isn't extra space on the right.
-    width += windowScrollbarX;
-  }
   return {
     width,
     height,
@@ -8547,7 +8520,6 @@ function getViewportRect(element, strategy) {
   };
 }
 
-const absoluteOrFixed = /*#__PURE__*/new Set(['absolute', 'fixed']);
 // Returns the inner client rect, subtracting scrollbars if present.
 function getInnerBoundingClientRect(element, strategy) {
   const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
@@ -8589,7 +8561,7 @@ function hasFixedPositionAncestor(element, stopNode) {
   if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
     return false;
   }
-  return getComputedStyle$1(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
 }
 
 // A "clipping ancestor" is an `overflow` element with the characteristic of
@@ -8602,17 +8574,17 @@ function getClippingElementAncestors(element, cache) {
   }
   let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
   let currentContainingBlockComputedStyle = null;
-  const elementIsFixed = getComputedStyle$1(element).position === 'fixed';
+  const elementIsFixed = getComputedStyle(element).position === 'fixed';
   let currentNode = elementIsFixed ? getParentNode(element) : element;
 
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
   while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    const computedStyle = getComputedStyle$1(currentNode);
+    const computedStyle = getComputedStyle(currentNode);
     const currentNodeIsContaining = isContainingBlock(currentNode);
     if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
       currentContainingBlockComputedStyle = null;
     }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
     if (shouldDropCurrentNode) {
       // Drop non-containing blocks.
       result = result.filter(ancestor => ancestor !== currentNode);
@@ -8708,11 +8680,11 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 }
 
 function isStaticPositioned(element) {
-  return getComputedStyle$1(element).position === 'static';
+  return getComputedStyle(element).position === 'static';
 }
 
 function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
     return null;
   }
   if (polyfill) {
@@ -8773,7 +8745,7 @@ const getElementRects = async function (data) {
 };
 
 function isRTL(element) {
-  return getComputedStyle$1(element).direction === 'rtl';
+  return getComputedStyle(element).direction === 'rtl';
 }
 
 const platform = {
@@ -9413,7 +9385,7 @@ const FloatingArrow = /*#__PURE__*/React.forwardRef(function FloatingArrow(props
   // https://github.com/floating-ui/floating-ui/issues/2932
   index$1(() => {
     if (!floating) return;
-    const isRTL = getComputedStyle$1(floating).direction === 'rtl';
+    const isRTL = getComputedStyle(floating).direction === 'rtl';
     if (isRTL) {
       setIsRTL(true);
     }
@@ -9672,7 +9644,7 @@ function useFloating(options) {
 }
 
 /*!
-  react-datepicker v8.5.0
+  react-datepicker v8.4.0
   https://github.com/Hacker0x01/react-datepicker
   Released under the MIT License.
 */
@@ -9907,13 +9879,12 @@ var DATE_RANGE_SEPARATOR = " - ";
  * @returns - The formatted date range or an empty string.
  */
 function safeDateRangeFormat(startDate, endDate, props) {
-    if (!startDate && !endDate) {
+    if (!startDate) {
         return "";
     }
-    var formattedStartDate = startDate ? safeDateFormat(startDate, props) : "";
+    var formattedStartDate = safeDateFormat(startDate, props);
     var formattedEndDate = endDate ? safeDateFormat(endDate, props) : "";
-    var dateRangeSeparator = props.rangeSeparator || DATE_RANGE_SEPARATOR;
-    return "".concat(formattedStartDate).concat(dateRangeSeparator).concat(formattedEndDate);
+    return "".concat(formattedStartDate).concat(DATE_RANGE_SEPARATOR).concat(formattedEndDate);
 }
 /**
  * Safely formats multiple dates.
@@ -11434,10 +11405,7 @@ var Week = /** @class */ (function (_super) {
             "react-datepicker__week--selected": isSameDay(this.startOfWeek(), this.props.selected),
             "react-datepicker__week--keyboard-selected": this.isKeyboardSelected(),
         };
-        var customWeekClassName = this.props.weekClassName
-            ? this.props.weekClassName(this.startOfWeek())
-            : undefined;
-        return (React__default.createElement("div", { className: clsx(weekNumberClasses, customWeekClassName) }, this.renderDays()));
+        return React__default.createElement("div", { className: clsx(weekNumberClasses) }, this.renderDays());
     };
     return Week;
 }(Component));
@@ -12657,20 +12625,19 @@ var Year$1 = /** @class */ (function (_super) {
             return isSameYear(_year, endDate !== null && endDate !== void 0 ? endDate : null);
         };
         _this.isKeyboardSelected = function (y) {
-            if (_this.props.disabledKeyboardNavigation ||
-                _this.props.date === undefined ||
+            if (_this.props.date === undefined ||
+                _this.props.selected == null ||
                 _this.props.preSelection == null) {
                 return;
             }
-            var _a = _this.props, minDate = _a.minDate, maxDate = _a.maxDate, excludeDates = _a.excludeDates, includeDates = _a.includeDates, filterDate = _a.filterDate, selected = _a.selected;
+            var _a = _this.props, minDate = _a.minDate, maxDate = _a.maxDate, excludeDates = _a.excludeDates, includeDates = _a.includeDates, filterDate = _a.filterDate;
             var date = getStartOfYear(setYear(_this.props.date, y));
             var isDisabled = (minDate || maxDate || excludeDates || includeDates || filterDate) &&
                 isYearDisabled(y, _this.props);
-            var isSelectedDay = !!selected && isSameDay(date, getStartOfYear(selected));
-            var isKeyboardSelectedDay = isSameDay(date, getStartOfYear(_this.props.preSelection));
-            return (!_this.props.inline &&
-                !isSelectedDay &&
-                isKeyboardSelectedDay &&
+            return (!_this.props.disabledKeyboardNavigation &&
+                !_this.props.inline &&
+                !isSameDay(date, getStartOfYear(_this.props.selected)) &&
+                isSameDay(date, getStartOfYear(_this.props.preSelection)) &&
                 !isDisabled);
         };
         _this.isSelectedYear = function (year) {
@@ -13019,7 +12986,6 @@ var DROPDOWN_FOCUS_CLASSNAMES = [
     "react-datepicker__month-select",
     "react-datepicker__month-year-select",
 ];
-var OUTSIDE_CLICK_IGNORE_CLASS = "react-datepicker-ignore-onclickoutside";
 var isDropdownSelect = function (element) {
     var classNames = (element.className || "").split(/\s+/);
     return DROPDOWN_FOCUS_CLASSNAMES.some(function (testClassname) { return classNames.indexOf(testClassname) >= 0; });
@@ -13171,9 +13137,7 @@ var Calendar = /** @class */ (function (_super) {
             var startOfWeek = getStartOfWeek(date, _this.props.locale, _this.props.calendarStartDay);
             var dayNames = [];
             if (_this.props.showWeekNumbers) {
-                dayNames.push(React__default.createElement("div", { key: "W", className: "react-datepicker__day-name", role: "columnheader" },
-                    React__default.createElement("span", { className: "sr-only" }, "Week number"),
-                    React__default.createElement("span", { "aria-hidden": "true" }, _this.props.weekLabel || "#")));
+                dayNames.push(React__default.createElement("div", { key: "W", className: "react-datepicker__day-name" }, _this.props.weekLabel || "#"));
             }
             return dayNames.concat([0, 1, 2, 3, 4, 5, 6].map(function (offset) {
                 var day = addDays(startOfWeek, offset);
@@ -13181,9 +13145,7 @@ var Calendar = /** @class */ (function (_super) {
                 var weekDayClassName = _this.props.weekDayClassName
                     ? _this.props.weekDayClassName(day)
                     : undefined;
-                return (React__default.createElement("div", { key: offset, role: "columnheader", className: clsx("react-datepicker__day-name", weekDayClassName) },
-                    React__default.createElement("span", { className: "sr-only" }, formatDate(day, "EEEE", _this.props.locale)),
-                    React__default.createElement("span", { "aria-hidden": "true" }, weekDayName)));
+                return (React__default.createElement("div", { key: offset, "aria-label": formatDate(day, "EEEE", _this.props.locale), className: clsx("react-datepicker__day-name", weekDayClassName) }, weekDayName));
             }));
         };
         _this.formatWeekday = function (day, locale) {
@@ -13398,7 +13360,7 @@ var Calendar = /** @class */ (function (_super) {
                     _this.renderMonthDropdown(i !== 0),
                     _this.renderMonthYearDropdown(i !== 0),
                     _this.renderYearDropdown(i !== 0)),
-                React__default.createElement("div", { className: "react-datepicker__day-names", role: "row" }, _this.header(monthDate))));
+                React__default.createElement("div", { className: "react-datepicker__day-names" }, _this.header(monthDate))));
         };
         _this.renderCustomHeader = function (headerArgs) {
             var _a, _b;
@@ -13407,15 +13369,6 @@ var Calendar = /** @class */ (function (_super) {
                 _this.props.showTimeSelectOnly) {
                 return null;
             }
-            var _c = _this.props, showYearPicker = _c.showYearPicker, yearItemNumber = _c.yearItemNumber;
-            var visibleYearsRange;
-            if (showYearPicker) {
-                var _d = getYearsPeriod(monthDate, yearItemNumber), startYear = _d.startPeriod, endYear = _d.endPeriod;
-                visibleYearsRange = {
-                    startYear: startYear,
-                    endYear: endYear,
-                };
-            }
             var prevMonthButtonDisabled = monthDisabledBefore(_this.state.date, _this.props);
             var nextMonthButtonDisabled = monthDisabledAfter(_this.state.date, _this.props);
             var prevYearButtonDisabled = yearDisabledBefore(_this.state.date, _this.props);
@@ -13424,7 +13377,7 @@ var Calendar = /** @class */ (function (_super) {
                 !_this.props.showQuarterYearPicker &&
                 !_this.props.showYearPicker;
             return (React__default.createElement("div", { className: "react-datepicker__header react-datepicker__header--custom", onFocus: _this.props.onDropdownFocus }, (_b = (_a = _this.props).renderCustomHeader) === null || _b === void 0 ? void 0 :
-                _b.call(_a, _assign(_assign(_assign({}, _this.state), (showYearPicker && { visibleYearsRange: visibleYearsRange })), { customHeaderCount: i, monthDate: monthDate, changeMonth: _this.changeMonth, changeYear: _this.changeYear, decreaseMonth: _this.decreaseMonth, increaseMonth: _this.increaseMonth, decreaseYear: _this.decreaseYear, increaseYear: _this.increaseYear, prevMonthButtonDisabled: prevMonthButtonDisabled, nextMonthButtonDisabled: nextMonthButtonDisabled, prevYearButtonDisabled: prevYearButtonDisabled, nextYearButtonDisabled: nextYearButtonDisabled })),
+                _b.call(_a, _assign(_assign({}, _this.state), { customHeaderCount: i, monthDate: monthDate, changeMonth: _this.changeMonth, changeYear: _this.changeYear, decreaseMonth: _this.decreaseMonth, increaseMonth: _this.increaseMonth, decreaseYear: _this.decreaseYear, increaseYear: _this.increaseYear, prevMonthButtonDisabled: prevMonthButtonDisabled, nextMonthButtonDisabled: nextMonthButtonDisabled, prevYearButtonDisabled: prevYearButtonDisabled, nextYearButtonDisabled: nextYearButtonDisabled })),
                 showDayNames && (React__default.createElement("div", { className: "react-datepicker__day-names" }, _this.header(monthDate)))));
         };
         _this.renderYearHeader = function (_a) {
@@ -13544,7 +13497,6 @@ var Calendar = /** @class */ (function (_super) {
             return {
                 monthsShown: 1,
                 forceShowMonthNavigation: false,
-                outsideClickIgnoreClass: OUTSIDE_CLICK_IGNORE_CLASS,
                 timeCaption: "Time",
                 previousYearButtonLabel: "Previous Year",
                 nextYearButtonLabel: "Next Year",
@@ -13833,6 +13785,7 @@ var PopperComponent = /** @class */ (function (_super) {
 }(Component));
 var PopperComponent$1 = withFloating(PopperComponent);
 
+var outsideClickIgnoreClass = "react-datepicker-ignore-onclickoutside";
 // Compares dates year+month combinations
 function hasPreSelectionChanged(date1, date2) {
     if (date1 && date2) {
@@ -13898,35 +13851,6 @@ var DatePicker = /** @class */ (function (_super) {
                 wasHidden: false,
             };
         };
-        _this.getInputValue = function () {
-            var _a;
-            var _b = _this.props, locale = _b.locale, startDate = _b.startDate, endDate = _b.endDate, rangeSeparator = _b.rangeSeparator, selected = _b.selected, selectedDates = _b.selectedDates, selectsMultiple = _b.selectsMultiple, selectsRange = _b.selectsRange, value = _b.value;
-            var dateFormat = (_a = _this.props.dateFormat) !== null && _a !== void 0 ? _a : DatePicker.defaultProps.dateFormat;
-            var inputValue = _this.state.inputValue;
-            if (typeof value === "string") {
-                return value;
-            }
-            else if (typeof inputValue === "string") {
-                return inputValue;
-            }
-            else if (selectsRange) {
-                return safeDateRangeFormat(startDate, endDate, {
-                    dateFormat: dateFormat,
-                    locale: locale,
-                    rangeSeparator: rangeSeparator,
-                });
-            }
-            else if (selectsMultiple) {
-                return safeMultipleDatesFormat(selectedDates !== null && selectedDates !== void 0 ? selectedDates : [], {
-                    dateFormat: dateFormat,
-                    locale: locale,
-                });
-            }
-            return safeDateFormat(selected, {
-                dateFormat: dateFormat,
-                locale: locale,
-            });
-        };
         _this.resetHiddenStatus = function () {
             _this.setState(_assign(_assign({}, _this.state), { wasHidden: false }));
         };
@@ -14026,15 +13950,11 @@ var DatePicker = /** @class */ (function (_super) {
         _this.handleDropdownFocus = function () {
             _this.cancelFocusInput();
         };
-        _this.resetInputValue = function () {
-            _this.setState(_assign(_assign({}, _this.state), { inputValue: null }));
-        };
         _this.handleBlur = function (event) {
             var _a, _b;
             if (!_this.state.open || _this.props.withPortal || _this.props.showTimeInput) {
                 (_b = (_a = _this.props).onBlur) === null || _b === void 0 ? void 0 : _b.call(_a, event);
             }
-            _this.resetInputValue();
             if (_this.state.open && _this.props.open === false) {
                 _this.setOpen(false);
             }
@@ -14075,17 +13995,11 @@ var DatePicker = /** @class */ (function (_super) {
             var strictParsing = (_b = _this.props.strictParsing) !== null && _b !== void 0 ? _b : DatePicker.defaultProps.strictParsing;
             var value = (event === null || event === void 0 ? void 0 : event.target) instanceof HTMLInputElement ? event.target.value : "";
             if (selectsRange) {
-                var rangeSeparator = _this.props.rangeSeparator;
-                var trimmedRangeSeparator = rangeSeparator.trim();
                 var _g = value
-                    .split(dateFormat.includes(trimmedRangeSeparator)
-                    ? rangeSeparator
-                    : trimmedRangeSeparator, 2)
+                    .split(dateFormat.includes("-") ? DATE_RANGE_SEPARATOR : "-", 2)
                     .map(function (val) { return val.trim(); }), valueStart = _g[0], valueEnd = _g[1];
                 var startDateNew = parseDate(valueStart !== null && valueStart !== void 0 ? valueStart : "", dateFormat, _this.props.locale, strictParsing);
-                var endDateNew = startDateNew
-                    ? parseDate(valueEnd !== null && valueEnd !== void 0 ? valueEnd : "", dateFormat, _this.props.locale, strictParsing)
-                    : null;
+                var endDateNew = parseDate(valueEnd !== null && valueEnd !== void 0 ? valueEnd : "", dateFormat, _this.props.locale, strictParsing);
                 var startChanged = (startDate === null || startDate === void 0 ? void 0 : startDate.getTime()) !== (startDateNew === null || startDateNew === void 0 ? void 0 : startDateNew.getTime());
                 var endChanged = (endDate === null || endDate === void 0 ? void 0 : endDate.getTime()) !== (endDateNew === null || endDateNew === void 0 ? void 0 : endDateNew.getTime());
                 if (!startChanged && !endChanged) {
@@ -14200,7 +14114,6 @@ var DatePicker = /** @class */ (function (_super) {
                 if (selectsRange) {
                     var noRanges = !startDate && !endDate;
                     var hasStartRange = startDate && !endDate;
-                    var hasOnlyEndRange = !startDate && !!endDate;
                     var isRangeFilled = startDate && endDate;
                     if (noRanges) {
                         onChange === null || onChange === void 0 ? void 0 : onChange([changedDate, null], event);
@@ -14221,14 +14134,6 @@ var DatePicker = /** @class */ (function (_super) {
                             onChange === null || onChange === void 0 ? void 0 : onChange([startDate, changedDate], event);
                         }
                     }
-                    else if (hasOnlyEndRange) {
-                        if (changedDate && isDateBefore(changedDate, endDate)) {
-                            onChange === null || onChange === void 0 ? void 0 : onChange([changedDate, endDate], event);
-                        }
-                        else {
-                            onChange === null || onChange === void 0 ? void 0 : onChange([changedDate, null], event);
-                        }
-                    }
                     if (isRangeFilled) {
                         onChange === null || onChange === void 0 ? void 0 : onChange([changedDate, null], event);
                     }
@@ -14602,12 +14507,10 @@ var DatePicker = /** @class */ (function (_super) {
             }
             return (React__default.createElement(Calendar, _assign({ showMonthYearDropdown: undefined, ref: function (elem) {
                     _this.calendar = elem;
-                } }, _this.props, _this.state, { setOpen: _this.setOpen, dateFormat: (_a = _this.props.dateFormatCalendar) !== null && _a !== void 0 ? _a : DatePicker.defaultProps.dateFormatCalendar, onSelect: _this.handleSelect, onClickOutside: _this.handleCalendarClickOutside, holidays: getHolidaysMap(_this.modifyHolidays()), outsideClickIgnoreClass: _this.props.outsideClickIgnoreClass, onDropdownFocus: _this.handleDropdownFocus, onTimeChange: _this.handleTimeChange, className: _this.props.calendarClassName, container: _this.props.calendarContainer, handleOnKeyDown: _this.props.onKeyDown, handleOnDayKeyDown: _this.onDayKeyDown, setPreSelection: _this.setPreSelection, dropdownMode: (_b = _this.props.dropdownMode) !== null && _b !== void 0 ? _b : DatePicker.defaultProps.dropdownMode }), _this.props.children));
+                } }, _this.props, _this.state, { setOpen: _this.setOpen, dateFormat: (_a = _this.props.dateFormatCalendar) !== null && _a !== void 0 ? _a : DatePicker.defaultProps.dateFormatCalendar, onSelect: _this.handleSelect, onClickOutside: _this.handleCalendarClickOutside, holidays: getHolidaysMap(_this.modifyHolidays()), outsideClickIgnoreClass: outsideClickIgnoreClass, onDropdownFocus: _this.handleDropdownFocus, onTimeChange: _this.handleTimeChange, className: _this.props.calendarClassName, container: _this.props.calendarContainer, handleOnKeyDown: _this.props.onKeyDown, handleOnDayKeyDown: _this.onDayKeyDown, setPreSelection: _this.setPreSelection, dropdownMode: (_b = _this.props.dropdownMode) !== null && _b !== void 0 ? _b : DatePicker.defaultProps.dropdownMode }), _this.props.children));
         };
         _this.renderAriaLiveRegion = function () {
-            var _a;
-            var locale = _this.props.locale;
-            var dateFormat = (_a = _this.props.dateFormat) !== null && _a !== void 0 ? _a : DatePicker.defaultProps.dateFormat;
+            var _a = _this.props, _b = _a.dateFormat, dateFormat = _b === void 0 ? DatePicker.defaultProps.dateFormat : _b, locale = _a.locale;
             var isContainsTime = _this.props.showTimeInput || _this.props.showTimeSelect;
             var longDateFormat = isContainsTime ? "PPPPp" : "PPPP";
             var ariaLiveMessage;
@@ -14650,17 +14553,36 @@ var DatePicker = /** @class */ (function (_super) {
         };
         _this.renderDateInput = function () {
             var _a, _b;
+            var _c;
             var className = clsx(_this.props.className, (_a = {},
-                _a[_this.props.outsideClickIgnoreClass ||
-                    DatePicker.defaultProps.outsideClickIgnoreClass] = _this.state.open,
+                _a[outsideClickIgnoreClass] = _this.state.open,
                 _a));
             var customInput = _this.props.customInput || React__default.createElement("input", { type: "text" });
             var customInputRef = _this.props.customInputRef || "ref";
+            var _d = _this.props, _e = _d.dateFormat, dateFormat = _e === void 0 ? DatePicker.defaultProps.dateFormat : _e, locale = _d.locale;
+            var inputValue = typeof _this.props.value === "string"
+                ? _this.props.value
+                : typeof _this.state.inputValue === "string"
+                    ? _this.state.inputValue
+                    : _this.props.selectsRange
+                        ? safeDateRangeFormat(_this.props.startDate, _this.props.endDate, {
+                            dateFormat: dateFormat,
+                            locale: locale,
+                        })
+                        : _this.props.selectsMultiple
+                            ? safeMultipleDatesFormat((_c = _this.props.selectedDates) !== null && _c !== void 0 ? _c : [], {
+                                dateFormat: dateFormat,
+                                locale: locale,
+                            })
+                            : safeDateFormat(_this.props.selected, {
+                                dateFormat: dateFormat,
+                                locale: locale,
+                            });
             return cloneElement(customInput, (_b = {},
                 _b[customInputRef] = function (input) {
                     _this.input = input;
                 },
-                _b.value = _this.getInputValue(),
+                _b.value = inputValue,
                 _b.onBlur = _this.handleBlur,
                 _b.onChange = _this.handleChange,
                 _b.onClick = _this.onInputClick,
@@ -14713,9 +14635,7 @@ var DatePicker = /** @class */ (function (_super) {
                 dropdownMode: "scroll",
                 preventOpenOnFocus: false,
                 monthsShown: 1,
-                outsideClickIgnoreClass: OUTSIDE_CLICK_IGNORE_CLASS,
                 readOnly: false,
-                rangeSeparator: DATE_RANGE_SEPARATOR,
                 withPortal: false,
                 selectsDisabledDaysInRange: false,
                 shouldCloseOnSelect: true,
@@ -15228,4 +15148,4 @@ var InlineDatePicker = function (props) {
 };
 
 export { DatePickerGroup as D, HelperText as H, InlineDatePicker as I, ValidationText as V };
-//# sourceMappingURL=InlineDatePicker-BeRq7pJP.js.map
+//# sourceMappingURL=InlineDatePicker-ClVBWEzW.js.map