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

package/lib/cjs/DatePicker.cjs

@@ -3,7 +3,7 @@
 var _tslib = require('./_tslib-ByDtMVOd.js');
 var jsxRuntime = require('react/jsx-runtime');
 var React = require('react');
-var InlineDatePicker = require('./InlineDatePicker-DFv_uHo9.js');
+var InlineDatePicker = require('./InlineDatePicker-CQ9t1bfe.js');
 var useMeasure = require('./useMeasure-CDq3dPfD.js');
 var showLabel = require('./showLabel-BkZISyqw.js');
 var Inputs = require('./Inputs-IaHMnBKw.js');

package/lib/cjs/Form.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var FormWrapper = require('./FormStyles-CxgYRZOl.js');
-var FormikContainer = require('./FormikContainer-CY2nLsAs.js');
+var FormikContainer = require('./FormikContainer-Gc8nGlEW.js');
 var FormFieldTypeEnum = require('./FormFieldTypeEnum.cjs');
 require('./_tslib-ByDtMVOd.js');
 require('styled-components');
@@ -94,7 +94,7 @@ require('./cardValidationStateMachine.cjs');
 require('./CurrencyInput-D_QGbxkC.js');
 require('./InlineCurrencyInput-UjEz4U3A.js');
 require('./DatePicker.cjs');
-require('./InlineDatePicker-DFv_uHo9.js');
+require('./InlineDatePicker-CQ9t1bfe.js');
 require('./Calendar.cjs');
 require('./ClickOutHandler-b5mI7kuA.js');
 require('./CaretLeft.cjs');

package/lib/cjs/{FormikContainer-CY2nLsAs.js → FormikContainer-Gc8nGlEW.js}

@@ -39,7 +39,7 @@ var CurrencyInput = require('./CurrencyInput-D_QGbxkC.js');
 var InlineCurrencyInput = require('./InlineCurrencyInput-UjEz4U3A.js');
 var formatBytesToString = require('./formatBytesToString.cjs');
 var DatePicker = require('./DatePicker.cjs');
-var InlineDatePicker = require('./InlineDatePicker-DFv_uHo9.js');
+var InlineDatePicker = require('./InlineDatePicker-CQ9t1bfe.js');
 require('./CheckboxStyles-CAzemGXD.js');
 require('./RadioStyles-2mVDOf96.js');
 require('./ToggleStyles-DsqemdEf.js');
@@ -1580,4 +1580,4 @@ var FormikContainer = function (props) {
 exports.FormikContainer = FormikContainer;
 exports.NationalityDropdown = NationalityDropdown;
 exports.nationalityList = nationalityList;
-//# sourceMappingURL=FormikContainer-CY2nLsAs.js.map
+//# sourceMappingURL=FormikContainer-Gc8nGlEW.js.map

package/lib/cjs/{FormikContainer-CY2nLsAs.js.map → FormikContainer-Gc8nGlEW.js.map}

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

package/lib/cjs/{InlineDatePicker-DFv_uHo9.js → InlineDatePicker-CQ9t1bfe.js}

@@ -7521,34 +7521,40 @@ 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(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
 }
+const tableElements = /*#__PURE__*/new Set(['table', 'td', 'th']);
 function isTableElement(element) {
-  return ['table', 'td', 'th'].includes(getNodeName(element));
+  return tableElements.has(getNodeName(element));
 }
+const topLayerSelectors = [':popover-open', ':modal'];
 function isTopLayer(element) {
-  return [':popover-open', ':modal'].some(selector => {
+  return topLayerSelectors.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(elementOrCss) : elementOrCss;
+  const css = isElement(elementOrCss) ? getComputedStyle$1(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 ['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));
+  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));
 }
 function getContainingBlock(element) {
   let currentNode = getParentNode(element);
@@ -7566,10 +7572,11 @@ 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 ['html', 'body', '#document'].includes(getNodeName(node));
+  return lastTraversableNodeNames.has(getNodeName(node));
 }
-function getComputedStyle(element) {
+function getComputedStyle$1(element) {
   return getWindow(element).getComputedStyle(element);
 }
 function getNodeScroll(element) {
@@ -7671,8 +7678,9 @@ function getOppositeAxis(axis) {
 function getAxisLength(axis) {
   return axis === 'y' ? 'height' : 'width';
 }
+const yAxisSides = /*#__PURE__*/new Set(['top', 'bottom']);
 function getSideAxis(placement) {
-  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+  return yAxisSides.has(getSide(placement)) ? 'y' : 'x';
 }
 function getAlignmentAxis(placement) {
   return getOppositeAxis(getSideAxis(placement));
@@ -7697,19 +7705,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 ? rl : lr;
-      return isStart ? lr : rl;
+      if (rtl) return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
     case 'left':
     case 'right':
-      return isStart ? tb : bt;
+      return isStart ? tbPlacement : btPlacement;
     default:
       return [];
   }
@@ -8161,7 +8169,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 => d.overflows[0] > 0 && getSideAxis(d.placement) === initialSideAxis)) {
+          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
             // Try next placement and re-run the lifecycle.
             return {
               data: {
@@ -8218,6 +8226,8 @@ const flip$2 = function (options) {
   };
 };
 
+const originSides = /*#__PURE__*/new Set(['left', 'top']);
+
 // For type backwards-compatibility, the `OffsetOptions` type was also
 // Derivable.
 
@@ -8231,7 +8241,7 @@ async function convertValueToCoords(state, options) {
   const side = getSide(placement);
   const alignment = getAlignment(placement);
   const isVertical = getSideAxis(placement) === 'y';
-  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
+  const mainAxisMulti = originSides.has(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
   const rawValue = evaluate(options, state);
 
@@ -8303,7 +8313,7 @@ const offset$2 = function (options) {
 };
 
 function getCssDimensions(element) {
-  const css = getComputedStyle(element);
+  const css = getComputedStyle$1(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;
@@ -8408,7 +8418,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
     while (currentIFrame && offsetParent && offsetWin !== currentWin) {
       const iframeScale = getScale(currentIFrame);
       const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = getComputedStyle(currentIFrame);
+      const css = getComputedStyle$1(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;
@@ -8439,14 +8449,9 @@ function getWindowScrollBarX(element, rect) {
   return rect.left + leftScroll;
 }
 
-function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
-  if (ignoreScrollbarX === void 0) {
-    ignoreScrollbarX = false;
-  }
+function getHTMLOffset(documentElement, scroll) {
   const htmlRect = documentElement.getBoundingClientRect();
-  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
-  // RTL <body> scrollbar.
-  getWindowScrollBarX(documentElement, htmlRect));
+  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
   const y = htmlRect.top + scroll.scrollTop;
   return {
     x,
@@ -8485,7 +8490,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -8508,7 +8513,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(body).direction === 'rtl') {
+  if (getComputedStyle$1(body).direction === 'rtl') {
     x += max(html.clientWidth, body.clientWidth) - width;
   }
   return {
@@ -8519,6 +8524,10 @@ 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);
@@ -8536,6 +8545,24 @@ 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,
@@ -8544,6 +8571,7 @@ 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');
@@ -8585,7 +8613,7 @@ function hasFixedPositionAncestor(element, stopNode) {
   if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
     return false;
   }
-  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+  return getComputedStyle$1(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
 }
 
 // A "clipping ancestor" is an `overflow` element with the characteristic of
@@ -8598,17 +8626,17 @@ function getClippingElementAncestors(element, cache) {
   }
   let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
   let currentContainingBlockComputedStyle = null;
-  const elementIsFixed = getComputedStyle(element).position === 'fixed';
+  const elementIsFixed = getComputedStyle$1(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(currentNode);
+    const computedStyle = getComputedStyle$1(currentNode);
     const currentNodeIsContaining = isContainingBlock(currentNode);
     if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
       currentContainingBlockComputedStyle = null;
     }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
     if (shouldDropCurrentNode) {
       // Drop non-containing blocks.
       result = result.filter(ancestor => ancestor !== currentNode);
@@ -8704,11 +8732,11 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 }
 
 function isStaticPositioned(element) {
-  return getComputedStyle(element).position === 'static';
+  return getComputedStyle$1(element).position === 'static';
 }
 
 function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
+  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
     return null;
   }
   if (polyfill) {
@@ -8769,7 +8797,7 @@ const getElementRects = async function (data) {
 };
 
 function isRTL(element) {
-  return getComputedStyle(element).direction === 'rtl';
+  return getComputedStyle$1(element).direction === 'rtl';
 }
 
 const platform = {
@@ -9409,7 +9437,7 @@ const FloatingArrow = /*#__PURE__*/React__namespace.forwardRef(function Floating
   // https://github.com/floating-ui/floating-ui/issues/2932
   index$1(() => {
     if (!floating) return;
-    const isRTL = getComputedStyle(floating).direction === 'rtl';
+    const isRTL = getComputedStyle$1(floating).direction === 'rtl';
     if (isRTL) {
       setIsRTL(true);
     }
@@ -9668,7 +9696,7 @@ function useFloating(options) {
 }
 
 /*!
-  react-datepicker v8.4.0
+  react-datepicker v8.5.0
   https://github.com/Hacker0x01/react-datepicker
   Released under the MIT License.
 */
@@ -9903,12 +9931,13 @@ var DATE_RANGE_SEPARATOR = " - ";
  * @returns - The formatted date range or an empty string.
  */
 function safeDateRangeFormat(startDate, endDate, props) {
-    if (!startDate) {
+    if (!startDate && !endDate) {
         return "";
     }
-    var formattedStartDate = safeDateFormat(startDate, props);
+    var formattedStartDate = startDate ? safeDateFormat(startDate, props) : "";
     var formattedEndDate = endDate ? safeDateFormat(endDate, props) : "";
-    return "".concat(formattedStartDate).concat(DATE_RANGE_SEPARATOR).concat(formattedEndDate);
+    var dateRangeSeparator = props.rangeSeparator || DATE_RANGE_SEPARATOR;
+    return "".concat(formattedStartDate).concat(dateRangeSeparator).concat(formattedEndDate);
 }
 /**
  * Safely formats multiple dates.
@@ -11429,7 +11458,10 @@ var Week = /** @class */ (function (_super) {
             "react-datepicker__week--selected": isSameDay(this.startOfWeek(), this.props.selected),
             "react-datepicker__week--keyboard-selected": this.isKeyboardSelected(),
         };
-        return React__namespace.default.createElement("div", { className: clsx(weekNumberClasses) }, this.renderDays());
+        var customWeekClassName = this.props.weekClassName
+            ? this.props.weekClassName(this.startOfWeek())
+            : undefined;
+        return (React__namespace.default.createElement("div", { className: clsx(weekNumberClasses, customWeekClassName) }, this.renderDays()));
     };
     return Week;
 }(React.Component));
@@ -12649,19 +12681,20 @@ var Year$1 = /** @class */ (function (_super) {
             return isSameYear(_year, endDate !== null && endDate !== void 0 ? endDate : null);
         };
         _this.isKeyboardSelected = function (y) {
-            if (_this.props.date === undefined ||
-                _this.props.selected == null ||
+            if (_this.props.disabledKeyboardNavigation ||
+                _this.props.date === undefined ||
                 _this.props.preSelection == null) {
                 return;
             }
-            var _a = _this.props, minDate = _a.minDate, maxDate = _a.maxDate, excludeDates = _a.excludeDates, includeDates = _a.includeDates, filterDate = _a.filterDate;
+            var _a = _this.props, minDate = _a.minDate, maxDate = _a.maxDate, excludeDates = _a.excludeDates, includeDates = _a.includeDates, filterDate = _a.filterDate, selected = _a.selected;
             var date = getStartOfYear(setYear(_this.props.date, y));
             var isDisabled = (minDate || maxDate || excludeDates || includeDates || filterDate) &&
                 isYearDisabled(y, _this.props);
-            return (!_this.props.disabledKeyboardNavigation &&
-                !_this.props.inline &&
-                !isSameDay(date, getStartOfYear(_this.props.selected)) &&
-                isSameDay(date, getStartOfYear(_this.props.preSelection)) &&
+            var isSelectedDay = !!selected && isSameDay(date, getStartOfYear(selected));
+            var isKeyboardSelectedDay = isSameDay(date, getStartOfYear(_this.props.preSelection));
+            return (!_this.props.inline &&
+                !isSelectedDay &&
+                isKeyboardSelectedDay &&
                 !isDisabled);
         };
         _this.isSelectedYear = function (year) {
@@ -13010,6 +13043,7 @@ 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; });
@@ -13161,7 +13195,9 @@ var Calendar = /** @class */ (function (_super) {
             var startOfWeek = getStartOfWeek(date, _this.props.locale, _this.props.calendarStartDay);
             var dayNames = [];
             if (_this.props.showWeekNumbers) {
-                dayNames.push(React__namespace.default.createElement("div", { key: "W", className: "react-datepicker__day-name" }, _this.props.weekLabel || "#"));
+                dayNames.push(React__namespace.default.createElement("div", { key: "W", className: "react-datepicker__day-name", role: "columnheader" },
+                    React__namespace.default.createElement("span", { className: "sr-only" }, "Week number"),
+                    React__namespace.default.createElement("span", { "aria-hidden": "true" }, _this.props.weekLabel || "#")));
             }
             return dayNames.concat([0, 1, 2, 3, 4, 5, 6].map(function (offset) {
                 var day = addDays(startOfWeek, offset);
@@ -13169,7 +13205,9 @@ var Calendar = /** @class */ (function (_super) {
                 var weekDayClassName = _this.props.weekDayClassName
                     ? _this.props.weekDayClassName(day)
                     : undefined;
-                return (React__namespace.default.createElement("div", { key: offset, "aria-label": formatDate(day, "EEEE", _this.props.locale), className: clsx("react-datepicker__day-name", weekDayClassName) }, weekDayName));
+                return (React__namespace.default.createElement("div", { key: offset, role: "columnheader", className: clsx("react-datepicker__day-name", weekDayClassName) },
+                    React__namespace.default.createElement("span", { className: "sr-only" }, formatDate(day, "EEEE", _this.props.locale)),
+                    React__namespace.default.createElement("span", { "aria-hidden": "true" }, weekDayName)));
             }));
         };
         _this.formatWeekday = function (day, locale) {
@@ -13384,7 +13422,7 @@ var Calendar = /** @class */ (function (_super) {
                     _this.renderMonthDropdown(i !== 0),
                     _this.renderMonthYearDropdown(i !== 0),
                     _this.renderYearDropdown(i !== 0)),
-                React__namespace.default.createElement("div", { className: "react-datepicker__day-names" }, _this.header(monthDate))));
+                React__namespace.default.createElement("div", { className: "react-datepicker__day-names", role: "row" }, _this.header(monthDate))));
         };
         _this.renderCustomHeader = function (headerArgs) {
             var _a, _b;
@@ -13393,6 +13431,15 @@ 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);
@@ -13401,7 +13448,7 @@ var Calendar = /** @class */ (function (_super) {
                 !_this.props.showQuarterYearPicker &&
                 !_this.props.showYearPicker;
             return (React__namespace.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({}, _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 })),
+                _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 })),
                 showDayNames && (React__namespace.default.createElement("div", { className: "react-datepicker__day-names" }, _this.header(monthDate)))));
         };
         _this.renderYearHeader = function (_a) {
@@ -13521,6 +13568,7 @@ var Calendar = /** @class */ (function (_super) {
             return {
                 monthsShown: 1,
                 forceShowMonthNavigation: false,
+                outsideClickIgnoreClass: OUTSIDE_CLICK_IGNORE_CLASS,
                 timeCaption: "Time",
                 previousYearButtonLabel: "Previous Year",
                 nextYearButtonLabel: "Next Year",
@@ -13809,7 +13857,6 @@ var PopperComponent = /** @class */ (function (_super) {
 }(React.Component));
 var PopperComponent$1 = withFloating(PopperComponent);
 
-var outsideClickIgnoreClass = "react-datepicker-ignore-onclickoutside";
 // Compares dates year+month combinations
 function hasPreSelectionChanged(date1, date2) {
     if (date1 && date2) {
@@ -13875,6 +13922,35 @@ 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 }));
         };
@@ -13974,11 +14050,15 @@ 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);
             }
@@ -14019,11 +14099,17 @@ 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("-") ? DATE_RANGE_SEPARATOR : "-", 2)
+                    .split(dateFormat.includes(trimmedRangeSeparator)
+                    ? rangeSeparator
+                    : trimmedRangeSeparator, 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 = parseDate(valueEnd !== null && valueEnd !== void 0 ? valueEnd : "", dateFormat, _this.props.locale, strictParsing);
+                var endDateNew = startDateNew
+                    ? parseDate(valueEnd !== null && valueEnd !== void 0 ? valueEnd : "", dateFormat, _this.props.locale, strictParsing)
+                    : null;
                 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) {
@@ -14138,6 +14224,7 @@ 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);
@@ -14158,6 +14245,14 @@ 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);
                     }
@@ -14531,10 +14626,12 @@ var DatePicker = /** @class */ (function (_super) {
             }
             return (React__namespace.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: 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: _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.renderAriaLiveRegion = function () {
-            var _a = _this.props, _b = _a.dateFormat, dateFormat = _b === void 0 ? DatePicker.defaultProps.dateFormat : _b, locale = _a.locale;
+            var _a;
+            var locale = _this.props.locale;
+            var dateFormat = (_a = _this.props.dateFormat) !== null && _a !== void 0 ? _a : DatePicker.defaultProps.dateFormat;
             var isContainsTime = _this.props.showTimeInput || _this.props.showTimeSelect;
             var longDateFormat = isContainsTime ? "PPPPp" : "PPPP";
             var ariaLiveMessage;
@@ -14577,36 +14674,17 @@ var DatePicker = /** @class */ (function (_super) {
         };
         _this.renderDateInput = function () {
             var _a, _b;
-            var _c;
             var className = clsx(_this.props.className, (_a = {},
-                _a[outsideClickIgnoreClass] = _this.state.open,
+                _a[_this.props.outsideClickIgnoreClass ||
+                    DatePicker.defaultProps.outsideClickIgnoreClass] = _this.state.open,
                 _a));
             var customInput = _this.props.customInput || React__namespace.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 React.cloneElement(customInput, (_b = {},
                 _b[customInputRef] = function (input) {
                     _this.input = input;
                 },
-                _b.value = inputValue,
+                _b.value = _this.getInputValue(),
                 _b.onBlur = _this.handleBlur,
                 _b.onChange = _this.handleChange,
                 _b.onClick = _this.onInputClick,
@@ -14659,7 +14737,9 @@ 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,
@@ -15175,4 +15255,4 @@ exports.DatePickerGroup = DatePickerGroup;
 exports.HelperText = HelperText;
 exports.InlineDatePicker = InlineDatePicker;
 exports.ValidationText = ValidationText;
-//# sourceMappingURL=InlineDatePicker-DFv_uHo9.js.map
+//# sourceMappingURL=InlineDatePicker-CQ9t1bfe.js.map