@servicetitan/anvil2 1.42.1 → 1.43.0

package/dist/{DateFieldYearless-DU0z2fEA-ByR2ixI5.js → usePopoverSupport-B9Lsqryr-DhZHMoNb.js}

@@ -1,14 +1,5 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { useState, useCallback, useRef, useLayoutEffect, useEffect, useMemo, forwardRef, useImperativeHandle } from 'react';
-import { T as TextField } from './TextField-CRTh0gL_-D2CjcYXX.js';
-import { u as useMergeRefs$1 } from './floating-ui.react-BFNinq1w.js';
-import { D as DateTime, f as Calendar } from './Calendar-DD5kmVd3-CBGTR11R.js';
-import { I as Icon } from './Icon-B6HmlQiR-BxQkO3X5.js';
-import { u as usePopoverCloseDelayWorkaround, S as SvgEvent } from './usePopoverCloseDelayWorkaround-BhhG-xEB-hfJZaXHC.js';
-import { d as Popover } from './Popover-CU2cGVD8-FWJOuFRj.js';
-import { u as useOptionallyControlledState } from './useOptionallyControlledState-DAv5LXXh-DAv5LXXh.js';
-import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
-import { s as supportsPopover, u as useKeyboardFocusables } from './ProgressBar-BRvB-bD4-DppwBrFg.js';
+import { useState, useCallback, useRef, useLayoutEffect, useEffect } from 'react';
+import { s as supportsPopover } from './ProgressBar-BRvB-bD4-DppwBrFg.js';
 
 function getContentEditableSelection(element) {
     const { anchorOffset = 0, focusOffset = 0 } = element.ownerDocument.getSelection() || {};
@@ -984,6 +975,19 @@ const DATE_SEGMENTS_MAX_VALUES = {
 const DEFAULT_MIN_DATE = new Date('0001-01-01T00:00');
 const DEFAULT_MAX_DATE = new Date('9999-12-31T23:59:59.999');
 
+const DEFAULT_TIME_SEGMENT_MAX_VALUES = {
+    hours: 23,
+    minutes: 59,
+    seconds: 59,
+    milliseconds: 999,
+};
+const DEFAULT_TIME_SEGMENT_MIN_VALUES = {
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0,
+};
+
 /**
  * {@link https://unicode-table.com/en/00A0/ Non-breaking space}.
  */
@@ -1022,9 +1026,31 @@ const CHAR_MINUS = '\u2212';
  * is used as prolonged sounds in Japanese.
  */
 const CHAR_JP_HYPHEN = '\u30FC';
+/**
+ * {@link https://symbl.cc/en/003A/ Colon}
+ * is a punctuation mark that connects parts of a text logically.
+ * ---
+ * is also used as separator in time.
+ */
+const CHAR_COLON = '\u003A';
+/**
+ * {@link https://symbl.cc/en/FF1A/ Full-width colon}
+ * is a full-width punctuation mark used to separate parts of a text commonly in Japanese.
+ */
+const CHAR_JP_COLON = '\uFF1A';
+
+const ANY_MERIDIEM_CHARACTER_RE = new RegExp(`[${CHAR_NO_BREAK_SPACE}APM]+$`, 'g');
+const ALL_MERIDIEM_CHARACTERS_RE = new RegExp(`${CHAR_NO_BREAK_SPACE}[AP]M$`, 'g');
 
 const TIME_FIXED_CHARACTERS = [':', '.'];
 
+const TIME_SEGMENT_VALUE_LENGTHS = {
+    hours: 2,
+    minutes: 2,
+    seconds: 2,
+    milliseconds: 3,
+};
+
 function validateDateString({ dateString, dateModeTemplate, dateSegmentsSeparator, offset, selection: [from, to], }) {
     var _a, _b;
     const parsedDate = parseDateString(dateString, dateModeTemplate);
@@ -1078,6 +1104,8 @@ function validateDateString({ dateString, dateModeTemplate, dateSegmentsSeparato
 function identity(x) {
     return x;
 }
+// eslint-disable-next-line  @typescript-eslint/no-empty-function
+function noop() { }
 
 /**
  * Copy-pasted solution from lodash
@@ -1091,6 +1119,17 @@ function escapeRegExp(str) {
         : str;
 }
 
+function findCommonBeginningSubstr(a, b) {
+    let res = '';
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return res;
+        }
+        res += a[i];
+    }
+    return res;
+}
+
 function isEmpty(entity) {
     return !entity || (typeof entity === 'object' && Object.keys(entity).length === 0);
 }
@@ -1113,6 +1152,15 @@ function padWithZeroesUntilValid(segmentValue, paddedMaxValue, prefixedZeroesCou
     return padWithZeroesUntilValid(`${valueWithoutLastChar}0`, paddedMaxValue, prefixedZeroesCount);
 }
 
+/**
+ * Replace fullwidth colon with half width colon
+ * @param fullWidthColon full width colon
+ * @returns processed half width colon
+ */
+function toHalfWidthColon(fullWidthColon) {
+    return fullWidthColon.replaceAll(new RegExp(CHAR_JP_COLON, 'g'), CHAR_COLON);
+}
+
 /**
  * Replace fullwidth numbers with half width number
  * @param fullWidthNumber full width number
@@ -1122,6 +1170,22 @@ function toHalfWidthNumber(fullWidthNumber) {
     return fullWidthNumber.replaceAll(/[０-９]/g, (s) => String.fromCharCode(s.charCodeAt(0) - 0xfee0));
 }
 
+/**
+ * Convert full width colon (：) to half width one (:)
+ */
+function createColonConvertPreprocessor() {
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        return {
+            elementState: {
+                selection,
+                value: toHalfWidthColon(value),
+            },
+            data: toHalfWidthColon(data),
+        };
+    };
+}
+
 function createDateSegmentsZeroPaddingPostprocessor({ dateModeTemplate, dateSegmentSeparator, splitFn, uniteFn, }) {
     return ({ value, selection }) => {
         var _a;
@@ -1205,7 +1269,184 @@ function createFullWidthToHalfWidthPreprocessor() {
     };
 }
 
-new RegExp(`[${TIME_FIXED_CHARACTERS.map(escapeRegExp).join('')}]$`);
+function createTimeMaskExpression(mode) {
+    return Array.from(mode.replace(' AA', ''))
+        .map((char) => (TIME_FIXED_CHARACTERS.includes(char) ? char : /\d/))
+        .concat(mode.includes('AA') ? [CHAR_NO_BREAK_SPACE, /[AP]/i, /M/i] : []);
+}
+
+function padTimeSegments(timeSegments, pad) {
+    return Object.fromEntries(Object.entries(timeSegments).map(([segmentName, segmentValue]) => [
+        segmentName,
+        pad(String(segmentValue), TIME_SEGMENT_VALUE_LENGTHS[segmentName]),
+    ]));
+}
+
+function padStartTimeSegments(timeSegments) {
+    return padTimeSegments(timeSegments, (value, length) => value.padStart(length, '0'));
+}
+
+const SEGMENT_FULL_NAME = {
+    HH: 'hours',
+    MM: 'minutes',
+    SS: 'seconds',
+    MSS: 'milliseconds',
+};
+/**
+ * @param timeString can be with/without fixed characters
+ */
+function parseTimeString(timeString, timeMode) {
+    const onlyDigits = timeString.replaceAll(/\D+/g, '');
+    let offset = 0;
+    return Object.fromEntries(timeMode
+        .split(/\W/)
+        .filter((segmentAbbr) => SEGMENT_FULL_NAME[segmentAbbr])
+        .map((segmentAbbr) => {
+        const segmentValue = onlyDigits.slice(offset, offset + segmentAbbr.length);
+        offset += segmentAbbr.length;
+        return [SEGMENT_FULL_NAME[segmentAbbr], segmentValue];
+    }));
+}
+
+const LEADING_NON_DIGITS = /^\D*/;
+const TRAILING_NON_DIGITS = /\D*$/;
+function toTimeString({ hours = '', minutes = '', seconds = '', milliseconds = '', }) {
+    return `${hours}:${minutes}:${seconds}.${milliseconds}`
+        .replace(LEADING_NON_DIGITS, '')
+        .replace(TRAILING_NON_DIGITS, '');
+}
+
+const TRAILING_TIME_SEGMENT_SEPARATOR_REG = new RegExp(`[${TIME_FIXED_CHARACTERS.map(escapeRegExp).join('')}]$`);
+/**
+ * Pads invalid time segment with zero to make it valid.
+ * @example 00:|00 => Type 9 (too much for the first digit of minutes) => 00:09|
+ * @example |19:00 => Type 2 (29 - invalid value for hours) => 2|0:00
+ */
+function enrichTimeSegmentsWithZeroes({ value, selection }, { mode, timeSegmentMaxValues = DEFAULT_TIME_SEGMENT_MAX_VALUES, }) {
+    const [from, to] = selection;
+    const parsedTime = parseTimeString(value, mode);
+    const possibleTimeSegments = Object.entries(parsedTime);
+    const paddedMaxValues = padStartTimeSegments(timeSegmentMaxValues);
+    const validatedTimeSegments = {};
+    let paddedZeroes = 0;
+    for (const [segmentName, segmentValue] of possibleTimeSegments) {
+        const maxSegmentValue = paddedMaxValues[segmentName];
+        const { validatedSegmentValue, prefixedZeroesCount } = padWithZeroesUntilValid(segmentValue, String(maxSegmentValue));
+        paddedZeroes += prefixedZeroesCount;
+        validatedTimeSegments[segmentName] = validatedSegmentValue;
+    }
+    const [leadingNonDigitCharacters = ''] = value.match(/^\D+(?=\d)/g) || []; // prefix
+    const [trailingNonDigitCharacters = ''] = value.match(/\D+$/g) || []; // trailing segment separators / meridiem characters / postfix
+    const validatedTimeString = leadingNonDigitCharacters +
+        toTimeString(validatedTimeSegments) +
+        trailingNonDigitCharacters;
+    const addedDateSegmentSeparators = Math.max(validatedTimeString.length - value.length - paddedZeroes, 0);
+    let newFrom = from + paddedZeroes + addedDateSegmentSeparators;
+    let newTo = to + paddedZeroes + addedDateSegmentSeparators;
+    if (newFrom === newTo &&
+        paddedZeroes &&
+        // if next character after cursor is time segment separator
+        validatedTimeString.slice(0, newTo + 1).match(TRAILING_TIME_SEGMENT_SEPARATOR_REG)) {
+        newFrom++;
+        newTo++;
+    }
+    return {
+        value: validatedTimeString,
+        selection: [newFrom, newTo],
+    };
+}
+
+/**
+ * Prevent insertion if any time segment will become invalid
+ * (and even zero padding won't help with it).
+ * @example 2|0:00 => Type 9 => 2|0:00
+ */
+function createInvalidTimeSegmentInsertionPreprocessor({ timeMode, timeSegmentMinValues = DEFAULT_TIME_SEGMENT_MIN_VALUES, timeSegmentMaxValues = DEFAULT_TIME_SEGMENT_MAX_VALUES, parseValue = (x) => ({ timeString: x }), }) {
+    const invalidCharsRegExp = new RegExp(`[^\\d${TIME_FIXED_CHARACTERS.map(escapeRegExp).join('')}]+`);
+    return ({ elementState, data }, actionType) => {
+        if (actionType !== 'insert') {
+            return { elementState, data };
+        }
+        const { value, selection } = elementState;
+        const [from, rawTo] = selection;
+        const newCharacters = data.replace(invalidCharsRegExp, '');
+        const to = rawTo + newCharacters.length; // to be conformed with `overwriteMode: replace`
+        const newPossibleValue = value.slice(0, from) + newCharacters + value.slice(to);
+        const { timeString, restValue = '' } = parseValue(newPossibleValue);
+        const timeSegments = Object.entries(parseTimeString(timeString, timeMode));
+        let offset = restValue.length;
+        for (const [segmentName, stringifiedSegmentValue] of timeSegments) {
+            const minSegmentValue = timeSegmentMinValues[segmentName];
+            const maxSegmentValue = timeSegmentMaxValues[segmentName];
+            const segmentValue = Number(stringifiedSegmentValue);
+            const lastSegmentDigitIndex = offset + TIME_SEGMENT_VALUE_LENGTHS[segmentName];
+            if (lastSegmentDigitIndex >= from &&
+                lastSegmentDigitIndex <= to &&
+                segmentValue !== clamp(segmentValue, minSegmentValue, maxSegmentValue)) {
+                return { elementState, data: '' }; // prevent insertion
+            }
+            offset +=
+                stringifiedSegmentValue.length +
+                    // any time segment separator
+                    1;
+        }
+        return { elementState, data };
+    };
+}
+
+function createMeridiemPreprocessor(timeMode) {
+    if (!timeMode.includes('AA')) {
+        return identity;
+    }
+    const mainMeridiemCharRE = /^[AP]$/gi;
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const newValue = value.toUpperCase();
+        const newData = data.toUpperCase();
+        if (newValue.match(ALL_MERIDIEM_CHARACTERS_RE) &&
+            newData.match(mainMeridiemCharRE)) {
+            return {
+                elementState: {
+                    value: newValue.replaceAll(ALL_MERIDIEM_CHARACTERS_RE, ''),
+                    selection,
+                },
+                data: `${newData}M`,
+            };
+        }
+        return { elementState: { selection, value: newValue }, data: newData };
+    };
+}
+function createMeridiemPostprocessor(timeMode) {
+    if (!timeMode.includes('AA')) {
+        return identity;
+    }
+    return ({ value, selection }, initialElementState) => {
+        if (!value.match(ANY_MERIDIEM_CHARACTER_RE) ||
+            value.match(ALL_MERIDIEM_CHARACTERS_RE)) {
+            return { value, selection };
+        }
+        const [from, to] = selection;
+        // any meridiem character was deleted
+        if (initialElementState.value.match(ALL_MERIDIEM_CHARACTERS_RE)) {
+            const newValue = value.replace(ANY_MERIDIEM_CHARACTER_RE, '');
+            return {
+                value: newValue,
+                selection: [
+                    Math.min(from, newValue.length),
+                    Math.min(to, newValue.length),
+                ],
+            };
+        }
+        const fullMeridiem = `${CHAR_NO_BREAK_SPACE}${value.includes('P') ? 'P' : 'A'}M`;
+        const newValue = value.replace(ANY_MERIDIEM_CHARACTER_RE, (x) => x !== CHAR_NO_BREAK_SPACE ? fullMeridiem : x);
+        return {
+            value: newValue,
+            selection: to >= newValue.indexOf(fullMeridiem)
+                ? [newValue.length, newValue.length]
+                : selection,
+        };
+    };
+}
 
 function raiseSegmentValueToMin(segments, fullMode) {
     const segmentsLength = getDateSegmentValueLength(fullMode);
@@ -1284,6 +1525,59 @@ function normalizeDatePreprocessor({ dateModeTemplate, dateSegmentsSeparator, ra
     };
 }
 
+function maskitoPostfixPostprocessorGenerator(postfix) {
+    const postfixRE = new RegExp(`${escapeRegExp(postfix)}$`);
+    return postfix
+        ? ({ value, selection }, initialElementState) => {
+            if (!value && !initialElementState.value.endsWith(postfix)) {
+                // cases when developer wants input to be empty (programmatically)
+                return { value, selection };
+            }
+            if (!value.endsWith(postfix) &&
+                !initialElementState.value.endsWith(postfix)) {
+                return { selection, value: value + postfix };
+            }
+            const initialValueBeforePostfix = initialElementState.value.replace(postfixRE, '');
+            const postfixWasModified = initialElementState.selection[1] > initialValueBeforePostfix.length;
+            const alreadyExistedValueBeforePostfix = findCommonBeginningSubstr(initialValueBeforePostfix, value);
+            return {
+                selection,
+                value: Array.from(postfix)
+                    .reverse()
+                    .reduce((newValue, char, index) => {
+                    const i = newValue.length - 1 - index;
+                    const isInitiallyMirroredChar = alreadyExistedValueBeforePostfix[i] === char &&
+                        postfixWasModified;
+                    return newValue[i] !== char || isInitiallyMirroredChar
+                        ? newValue.slice(0, i + 1) + char + newValue.slice(i + 1)
+                        : newValue;
+                }, value),
+            };
+        }
+        : identity;
+}
+
+function maskitoPrefixPostprocessorGenerator(prefix) {
+    return prefix
+        ? ({ value, selection }, initialElementState) => {
+            if (value.startsWith(prefix) || // already valid
+                (!value && !initialElementState.value.startsWith(prefix)) // cases when developer wants input to be empty
+            ) {
+                return { value, selection };
+            }
+            const [from, to] = selection;
+            const prefixedValue = Array.from(prefix).reduce((modifiedValue, char, i) => modifiedValue[i] === char
+                ? modifiedValue
+                : modifiedValue.slice(0, i) + char + modifiedValue.slice(i), value);
+            const addedCharsCount = prefixedValue.length - value.length;
+            return {
+                selection: [from + addedCharsCount, to + addedCharsCount],
+                value: prefixedValue,
+            };
+        }
+        : identity;
+}
+
 function createValidDatePreprocessor({ dateModeTemplate, dateSegmentsSeparator, rangeSeparator = '', }) {
     return ({ elementState, data }) => {
         const { value, selection } = elementState;
@@ -1390,6 +1684,108 @@ function maskitoCaretGuard(guard) {
     });
 }
 
+function createMeridiemSteppingPlugin(meridiemStartIndex) {
+    if (meridiemStartIndex < 0) {
+        return noop;
+    }
+    return (element) => {
+        const listener = (event) => {
+            const caretIndex = Number(element.selectionStart);
+            const value = element.value.toUpperCase();
+            if ((event.key !== 'ArrowUp' && event.key !== 'ArrowDown') ||
+                caretIndex < meridiemStartIndex) {
+                return;
+            }
+            event.preventDefault();
+            // eslint-disable-next-line no-nested-ternary
+            const meridiemMainCharacter = value.includes('A')
+                ? 'P'
+                : value.includes('P') || event.key === 'ArrowUp'
+                    ? 'A'
+                    : 'P';
+            const newMeridiem = `${CHAR_NO_BREAK_SPACE}${meridiemMainCharacter}M`;
+            maskitoUpdateElement(element, {
+                value: value.length === meridiemStartIndex
+                    ? value + newMeridiem
+                    : value.replace(ANY_MERIDIEM_CHARACTER_RE, newMeridiem),
+                selection: [caretIndex, caretIndex],
+            });
+        };
+        element.addEventListener('keydown', listener);
+        return () => element.removeEventListener('keydown', listener);
+    };
+}
+
+function createTimeSegmentsSteppingPlugin({ step, fullMode, timeSegmentMaxValues, }) {
+    const segmentsIndexes = createTimeSegmentsIndexes(fullMode);
+    return step <= 0
+        ? noop
+        : (element) => {
+            const listener = (event) => {
+                var _a;
+                if (event.key !== 'ArrowUp' && event.key !== 'ArrowDown') {
+                    return;
+                }
+                event.preventDefault();
+                const selectionStart = (_a = element.selectionStart) !== null && _a !== void 0 ? _a : 0;
+                const activeSegment = getActiveSegment({
+                    segmentsIndexes,
+                    selectionStart,
+                });
+                if (!activeSegment) {
+                    return;
+                }
+                const updatedValue = updateSegmentValue({
+                    selection: segmentsIndexes.get(activeSegment),
+                    value: element.value,
+                    toAdd: event.key === 'ArrowUp' ? step : -step,
+                    max: timeSegmentMaxValues[activeSegment],
+                });
+                maskitoUpdateElement(element, {
+                    value: updatedValue,
+                    selection: [selectionStart, selectionStart],
+                });
+            };
+            element.addEventListener('keydown', listener);
+            return () => element.removeEventListener('keydown', listener);
+        };
+}
+function createTimeSegmentsIndexes(fullMode) {
+    return new Map([
+        ['hours', getSegmentRange(fullMode, 'HH')],
+        ['milliseconds', getSegmentRange(fullMode, 'MSS')],
+        ['minutes', getSegmentRange(fullMode, 'MM')],
+        ['seconds', getSegmentRange(fullMode, 'SS')],
+    ]);
+}
+function getSegmentRange(mode, segment) {
+    const index = mode.indexOf(segment);
+    return index === -1 ? [-1, -1] : [index, index + segment.length];
+}
+function getActiveSegment({ segmentsIndexes, selectionStart, }) {
+    for (const [segmentName, segmentRange] of segmentsIndexes.entries()) {
+        const [from, to] = segmentRange;
+        if (from <= selectionStart && selectionStart <= to) {
+            return segmentName;
+        }
+    }
+    return null;
+}
+function updateSegmentValue({ selection, value, toAdd, max, }) {
+    const [from, to] = selection;
+    const segmentValue = Number(value.slice(from, to).padEnd(to - from, '0'));
+    const newSegmentValue = mod(segmentValue + toAdd, max + 1);
+    return (value.slice(0, from) +
+        String(newSegmentValue).padStart(to - from, '0') +
+        value.slice(to, value.length));
+}
+function mod(value, max) {
+    if (value < 0) {
+        value += Math.floor(Math.abs(value) / max + 1) * max;
+    }
+    return value % max;
+}
+
 function maskitoWithPlaceholder(placeholder, focusedOnly = false) {
     let lastClearValue = '';
     let action = 'validation';
@@ -1652,6 +2048,66 @@ function maskitoDateRangeOptionsGenerator({ mode, min, max, minLength, maxLength
         ] });
 }
 
+function maskitoTimeOptionsGenerator({ mode, timeSegmentMaxValues = {}, timeSegmentMinValues = {}, step = 0, prefix = '', postfix = '', }) {
+    const hasMeridiem = mode.includes('AA');
+    const enrichedTimeSegmentMaxValues = Object.assign(Object.assign(Object.assign({}, DEFAULT_TIME_SEGMENT_MAX_VALUES), (hasMeridiem ? { hours: 12 } : {})), timeSegmentMaxValues);
+    const enrichedTimeSegmentMinValues = Object.assign(Object.assign(Object.assign({}, DEFAULT_TIME_SEGMENT_MIN_VALUES), (hasMeridiem ? { hours: 1 } : {})), timeSegmentMinValues);
+    const maskExpression = [...prefix, ...createTimeMaskExpression(mode)];
+    return {
+        mask: postfix
+            ? ({ value }) => cutExpression(maskExpression, value).concat(...postfix)
+            : maskExpression,
+        preprocessors: [
+            createFullWidthToHalfWidthPreprocessor(),
+            createColonConvertPreprocessor(),
+            createZeroPlaceholdersPreprocessor(postfix),
+            createMeridiemPreprocessor(mode),
+            createInvalidTimeSegmentInsertionPreprocessor({
+                timeMode: mode,
+                timeSegmentMinValues: enrichedTimeSegmentMinValues,
+                timeSegmentMaxValues: enrichedTimeSegmentMaxValues,
+            }),
+        ],
+        postprocessors: [
+            createMeridiemPostprocessor(mode),
+            (elementState) => enrichTimeSegmentsWithZeroes(elementState, {
+                mode,
+                timeSegmentMaxValues: enrichedTimeSegmentMaxValues,
+            }),
+            maskitoPrefixPostprocessorGenerator(prefix),
+            maskitoPostfixPostprocessorGenerator(postfix),
+        ],
+        plugins: [
+            createTimeSegmentsSteppingPlugin({
+                fullMode: mode,
+                step,
+                timeSegmentMaxValues: enrichedTimeSegmentMaxValues,
+            }),
+            createMeridiemSteppingPlugin(mode.indexOf('AA')),
+        ],
+        overwriteMode: 'replace',
+    };
+}
+/**
+ * Without cutting, the mask expression removes postfix on the last digit deletion
+ * ___
+ * Case 1 (static pattern mask expression)
+ * Mask expression is [/\d/, /\d/, ':', /\d/, /\d/, ' left']
+ * 12:34| left => Press Backspace => 12:3|
+ * Mask correctly removes postfix because it's fixed characters after not yet inserted 4th digit.
+ * ___
+ * Case 2 (dynamic pattern mask expression)
+ * Mask expression is [/\d/, /\d/, ':', /\d/, /\d/, ' left'] & textfield contains `12:34 left`
+ * 12:34| left => Press Backspace => Mask expression becomes [/\d/, /\d/, ':', /\d/, ' left']  => 12:3| left
+ * Mask correctly does not remove postfix because it's trailing fixed characters
+ * and all non-fixed characters were already inserted.
+ */
+function cutExpression(expression, value) {
+    let digitsCount = Math.min(value.replaceAll(/\D/g, '').length, expression.filter((x) => typeof x !== 'string').length) || 1;
+    const afterLastDigit = expression.findIndex((x) => typeof x !== 'string' && !--digitsCount) + 1;
+    return expression.slice(0, afterLastDigit);
+}
+
 /**
  * React adds `_valueTracker` property to every textfield elements for its internal logic with controlled inputs.
  * Also, React monkey-patches `value`-setter of the native textfield elements to update state inside its `_valueTracker`.
@@ -1765,14 +2221,6 @@ const useMaskito = ({
   return onRefChange;
 };
 
-function usePrevious(value) {
-  const ref = useRef();
-  useEffect(() => {
-    ref.current = value;
-  }, [value]);
-  return ref.current;
-}
-
 function usePopoverSupport() {
   const [popoverSupported, setPopoverSupported] = useState(
     void 0
@@ -1783,1430 +2231,5 @@ function usePopoverSupport() {
   return popoverSupported;
 }
 
-const makeZeroShortcutPreprocessor = (templateString, separator) => {
-  const zeroShortcutPreprocessor = ({ elementState, data }, actionType) => {
-    if (actionType === "insert" && // the user is inserting a character
-    data === separator && // the user typed the separator character
-    elementState.selection[0] === elementState.selection[1]) {
-      const selectionIndex = elementState.selection[0];
-      const separatorPositions = templateString.split("").map((char, index) => char === separator ? index : null).filter((position) => position !== null).filter((position) => position > selectionIndex);
-      const noRemainingSegments = !separatorPositions.length;
-      const nothingEnteredYet = !elementState.value.length;
-      const previousCharacterIsNotADigit = !/^\d$/.test(
-        elementState.value.slice(-1)
-      );
-      const currentCharacterIsSeparator = templateString[selectionIndex] === separator;
-      if (noRemainingSegments || nothingEnteredYet || previousCharacterIsNotADigit || currentCharacterIsSeparator) {
-        return { elementState, data };
-      }
-      const firstIndexOfSegment = Math.max(
-        elementState.value.lastIndexOf(separator) + 1,
-        elementState.value.lastIndexOf(" ") + 1,
-        0
-      );
-      const lastIndexOfSegment = separatorPositions[0];
-      const digitsCurrentlyInSegment = elementState.value.slice(firstIndexOfSegment);
-      const targetNumberOfDigitsInSegment = templateString.slice(
-        firstIndexOfSegment,
-        lastIndexOfSegment
-      ).length;
-      const newSegment = digitsCurrentlyInSegment.padStart(
-        targetNumberOfDigitsInSegment,
-        "0"
-      );
-      const newValue = `${elementState.value.slice(0, firstIndexOfSegment)}${newSegment}`;
-      return {
-        elementState: {
-          value: newValue + data,
-          selection: [newValue.length, newValue.length]
-        },
-        data
-      };
-    }
-    return { elementState, data };
-  };
-  return zeroShortcutPreprocessor;
-};
-
-const datePlaceholderMask$1 = ({
-  mode,
-  separator = "/",
-  placeholder
-}) => {
-  const dateOptions = maskitoDateOptionsGenerator({
-    mode,
-    separator
-  });
-  const { plugins, removePlaceholder, ...placeholderOptions } = maskitoWithPlaceholder(placeholder);
-  const datePlaceholderMask2 = {
-    ...dateOptions,
-    plugins: plugins.concat(dateOptions.plugins || []),
-    preprocessors: [
-      ...placeholderOptions.preprocessors,
-      ...dateOptions.preprocessors,
-      makeZeroShortcutPreprocessor(mode, separator)
-    ],
-    postprocessors: [
-      ...dateOptions.postprocessors,
-      ...placeholderOptions.postprocessors
-    ]
-  };
-  return { options: datePlaceholderMask2, removePlaceholder };
-};
-
-const DateModeToFormatMap = {
-  "mm/dd/yyyy": "MM/dd/yyyy",
-  "dd/mm/yyyy": "dd/MM/yyyy",
-  "yyyy/mm/dd": "yyyy/MM/dd"
-};
-const DateModeToPlaceholderMap = {
-  "dd/mm/yyyy": "__/__/____",
-  "mm/dd/yyyy": "__/__/____",
-  "yyyy/mm/dd": "____/__/__"
-};
-
-const MaskedDateInput = forwardRef(
-  ({
-    onChange,
-    mode = "mm/dd/yyyy",
-    lastValidDate,
-    disableHint = false,
-    ...props
-  }, ref) => {
-    const placeholder = DateModeToPlaceholderMap[mode];
-    const [inputValue, setInputValue] = useState(placeholder);
-    const { options, removePlaceholder } = datePlaceholderMask$1({
-      mode,
-      placeholder
-    });
-    const maskedInputRef = useMaskito({ options });
-    const inputRef = useRef(null);
-    const combinedRef = useMergeRefs$1([maskedInputRef, inputRef, ref]);
-    const previousDateRef = useRef(null);
-    const previousMode = usePrevious(mode);
-    useEffect(() => {
-      if (mode !== previousMode) {
-        setInputValue(
-          (oldInputValue) => swapMode$2(oldInputValue, previousMode ?? mode, mode)
-        );
-      }
-    }, [mode, previousMode]);
-    useEffect(() => {
-      if (lastValidDate === void 0) return;
-      if (lastValidDate === previousDateRef.current) return;
-      if (!lastValidDate?.equals(previousDateRef.current ?? DateTime.now())) {
-        setInputValue(
-          lastValidDate?.toFormat(DateModeToFormatMap[mode]) ?? placeholder
-        );
-        previousDateRef.current = lastValidDate;
-      }
-    }, [lastValidDate, mode, placeholder]);
-    const currentParsedData = useMemo(() => {
-      return parseInputValue$1(inputValue, mode, removePlaceholder);
-    }, [inputValue, mode, removePlaceholder]);
-    const handleChange = (event) => {
-      setInputValue(event.target.value);
-      const { date, isInputValid, isInputEmpty } = parseInputValue$1(
-        event.target.value,
-        mode,
-        removePlaceholder
-      );
-      const isValueDifferent = isInputValid !== currentParsedData.isInputValid || // The input has changed validity
-      isInputEmpty !== currentParsedData.isInputEmpty || // The input has changed emptiness
-      date === null !== (lastValidDate === null) || // The input has changed from empty to non-empty or vice versa
-      date !== null && lastValidDate !== null && !date.equals(lastValidDate);
-      if (!isValueDifferent) return;
-      onChange?.({
-        date: date ?? lastValidDate ?? null,
-        isInputValid,
-        isInputEmpty
-      });
-    };
-    useImperativeHandle(ref, () => {
-      const input = inputRef.current;
-      if (!input) return null;
-      return Object.assign(input, {
-        setDate: (date) => {
-          setInputValue(
-            date?.toFormat(DateModeToFormatMap[mode]) ?? placeholder
-          );
-        }
-      });
-    }, [mode, placeholder]);
-    return /* @__PURE__ */ jsx(
-      TextField,
-      {
-        ref: combinedRef,
-        "data-date": lastValidDate?.toISODate() ?? "",
-        "data-input-valid": currentParsedData.isInputValid,
-        "data-input-empty": currentParsedData.isInputEmpty,
-        ...props,
-        showCounter: false,
-        value: inputValue,
-        onChange: handleChange,
-        prefix: /* @__PURE__ */ jsx(Icon, { svg: SvgEvent }),
-        hint: disableHint ? void 0 : `Format: ${mode}`
-      }
-    );
-  }
-);
-MaskedDateInput.displayName = "MaskedDateInput";
-function parseInputValue$1(value, mode, removePlaceholder) {
-  const valueMinusPlaceholder = removePlaceholder(value);
-  const jsDate = maskitoParseDate(valueMinusPlaceholder, { mode });
-  const luxonDate = jsDate ? DateTime.fromJSDate(jsDate, { zone: "utc" }) : null;
-  return {
-    date: luxonDate,
-    isInputValid: !!luxonDate,
-    isInputEmpty: valueMinusPlaceholder === ""
-  };
-}
-function swapMode$2(inputString, previousMode, mode) {
-  const { day, month, year } = divideSegments$1(inputString, previousMode);
-  return orderSegmentsByMode(day, month, year, mode);
-}
-function divideSegments$1(value, mode) {
-  const [segment1, segment2, segment3] = value.split("/");
-  if (mode === "dd/mm/yyyy") {
-    return { day: segment1, month: segment2, year: segment3 };
-  } else if (mode === "mm/dd/yyyy") {
-    return { day: segment2, month: segment1, year: segment3 };
-  } else if (mode === "yyyy/mm/dd") {
-    return { day: segment3, month: segment2, year: segment1 };
-  }
-  return { day: "__", month: "__", year: "____" };
-}
-function orderSegmentsByMode(day, month, year, mode) {
-  if (mode === "dd/mm/yyyy") {
-    return `${day}/${month}/${year}`;
-  } else if (mode === "mm/dd/yyyy") {
-    return `${month}/${day}/${year}`;
-  } else if (mode === "yyyy/mm/dd") {
-    return `${year}/${month}/${day}`;
-  } else {
-    return "";
-  }
-}
-
-function containsRelatedTarget(event) {
-  if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {
-    return event.currentTarget.contains(event.relatedTarget);
-  }
-  return false;
-}
-function useFocusWithin({
-  onBlur,
-  onFocus
-} = {}) {
-  const [focused, setFocused] = useState(false);
-  const focusedRef = useRef(false);
-  const elementRef = useRef(null);
-  const _setFocused = useCallback((value) => {
-    setFocused(value);
-    focusedRef.current = value;
-  }, []);
-  const handleFocusIn = useCallback(
-    (event) => {
-      if (!focusedRef.current) {
-        _setFocused(true);
-        onFocus?.(event);
-      }
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [onFocus]
-  );
-  const handleFocusOut = useCallback(
-    (event) => {
-      if (focusedRef.current && !containsRelatedTarget(event)) {
-        _setFocused(false);
-        onBlur?.(event);
-      }
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [onBlur]
-  );
-  useEffect(() => {
-    const element = elementRef.current;
-    if (!element) {
-      return;
-    }
-    element.addEventListener("focusin", handleFocusIn);
-    element.addEventListener("focusout", handleFocusOut);
-    return () => {
-      element.removeEventListener("focusin", handleFocusIn);
-      element.removeEventListener("focusout", handleFocusOut);
-    };
-  }, [handleFocusIn, handleFocusOut]);
-  return { ref: elementRef, focused };
-}
-
-function convertStringToDate(v) {
-  if (v === void 0 || v === null) {
-    return v;
-  }
-  const date = DateTime.fromISO(v, { setZone: true, zone: "utc" }).startOf(
-    "day"
-  );
-  if (date.isValid) {
-    return date;
-  }
-  return null;
-}
-function validateDate({
-  date,
-  constraints
-}) {
-  const { required, unavailable, minDate, maxDate } = constraints;
-  if (!date) {
-    return required ? false : true;
-  }
-  if (unavailable?.dates?.some((d) => d.equals(date))) {
-    return false;
-  }
-  if (unavailable?.daysOfWeek?.includes(date.weekday)) {
-    return false;
-  }
-  if (minDate && date < minDate) {
-    return false;
-  }
-  if (maxDate && date > maxDate) {
-    return false;
-  }
-  return true;
-}
-function validateYearlessDate({
-  value,
-  constraints
-}) {
-  const { required, unavailable, minDate, maxDate } = constraints;
-  if (!value || !value?.day && !value?.month) {
-    return required ? false : true;
-  }
-  if (value.day === null || value.month === null) {
-    return false;
-  }
-  if (unavailable?.dates?.some(
-    (d) => d.day === value.day && d.month === value.month
-  )) {
-    return false;
-  }
-  const minDateMonth = minDate?.month ?? 1;
-  const minDateDay = minDate?.day ?? 1;
-  const maxDateMonth = maxDate?.month ?? 12;
-  const maxDateDay = maxDate?.day ?? 31;
-  if (value.month < minDateMonth || // Earlier month
-  value.month === minDateMonth && value.day < minDateDay) {
-    return false;
-  }
-  if (value.month > maxDateMonth || // Later month
-  value.month === maxDateMonth && value.day > maxDateDay) {
-    return false;
-  }
-  return true;
-}
-
-function useDateFieldSingleConversion({
-  value,
-  defaultValue,
-  minDate,
-  maxDate,
-  unavailable,
-  onChange
-}) {
-  const normalizedValue = useMemo(() => convertStringToDate(value), [value]);
-  const normalizedDefaultValue = useMemo(
-    () => convertStringToDate(defaultValue),
-    [defaultValue]
-  );
-  const normalizedMinDate = useMemo(
-    () => convertStringToDate(minDate),
-    [minDate]
-  );
-  const normalizedMaxDate = useMemo(
-    () => convertStringToDate(maxDate),
-    [maxDate]
-  );
-  const normalizedUnavailableDates = useMemo(
-    () => unavailable?.dates?.map((d) => convertStringToDate(d)).filter((d) => d !== null && d !== void 0),
-    [unavailable?.dates]
-  );
-  const handleChange = useCallback(
-    (change) => {
-      onChange?.({
-        ...change,
-        date: change.date?.toISODate() ?? null
-      });
-    },
-    [onChange]
-  );
-  return {
-    value: normalizedValue,
-    defaultValue: normalizedDefaultValue,
-    minDate: normalizedMinDate,
-    maxDate: normalizedMaxDate,
-    unavailable: {
-      dates: normalizedUnavailableDates,
-      daysOfWeek: unavailable?.daysOfWeek
-    },
-    onChange: handleChange
-  };
-}
-
-function DateFieldSingleCalendar({
-  onKeyDown,
-  value,
-  onSelection,
-  minDate,
-  maxDate,
-  unavailable,
-  ...rest
-}) {
-  const handleCalendarSelection = (data) => {
-    if (data.value) {
-      const date = DateTime.fromISO(data.value, { zone: "utc" });
-      onSelection(date);
-    }
-  };
-  return /* @__PURE__ */ jsx(
-    Calendar,
-    {
-      ...rest,
-      range: false,
-      onKeyDown,
-      defaultFocusedDate: value?.toISODate() || DateTime.now().toISODate(),
-      value: value?.toISODate() || void 0,
-      onSelection: handleCalendarSelection,
-      defaultTimeZone: "UTC",
-      minDate: minDate?.toISODate() ?? void 0,
-      maxDate: maxDate?.toISODate() ?? void 0,
-      unavailable: unavailable ? {
-        dates: unavailable.dates?.map((d) => d.toISODate() ?? ""),
-        daysOfWeek: unavailable.daysOfWeek
-      } : void 0,
-      _disableAutofocus: true
-    }
-  );
-}
-
-const useDateFieldOrchestration = ({
-  inputRef,
-  calendarDefaultOpen,
-  popoverContentRef,
-  disableCalendar = false
-}) => {
-  const documentRef = useRef(document.body);
-  const [calendarOpen, setCalendarOpen] = useState(calendarDefaultOpen);
-  const { focusables } = useKeyboardFocusables(documentRef, {
-    observeChange: true
-  });
-  const { focusables: popoverFocusables } = useKeyboardFocusables(
-    popoverContentRef,
-    {
-      observeChange: true
-    }
-  );
-  const pageFocusables = focusables?.filter(
-    (item) => !popoverFocusables?.includes(item)
-  );
-  const handleCalendarKeyDown = (event) => {
-    if (event.key === "Escape") {
-      inputRef.current?.focus();
-    }
-  };
-  const focusToCalendar = () => {
-    if (popoverContentRef.current) {
-      const currentFocusable = popoverContentRef.current.querySelectorAll('[tabindex = "0"]')[0];
-      if (currentFocusable) {
-        currentFocusable.focus();
-      }
-    }
-  };
-  const handleInputKeyDown = (ev) => {
-    if (disableCalendar) {
-      return;
-    }
-    let currentFocusIndex = 0;
-    switch (ev.key) {
-      case "Escape":
-        setCalendarOpen(false);
-        break;
-      case "Tab":
-        if (!calendarOpen || !pageFocusables?.length) {
-          break;
-        }
-        ev.preventDefault();
-        currentFocusIndex = pageFocusables.indexOf(inputRef.current) || 0;
-        setCalendarOpen(false);
-        if (ev.shiftKey) {
-          if (currentFocusIndex === 0) {
-            requestAnimationFrame(
-              () => pageFocusables[pageFocusables.length - 1].focus()
-            );
-          } else {
-            requestAnimationFrame(
-              () => pageFocusables[currentFocusIndex - 1].focus()
-            );
-          }
-          break;
-        }
-        if (pageFocusables.length > currentFocusIndex + 1) {
-          requestAnimationFrame(
-            () => pageFocusables[currentFocusIndex + 1].focus()
-          );
-        } else {
-          requestAnimationFrame(() => pageFocusables[0].focus());
-        }
-        break;
-      case "ArrowDown":
-        if (!calendarOpen) {
-          setCalendarOpen(true);
-          setTimeout(focusToCalendar, 200);
-        } else {
-          focusToCalendar();
-        }
-    }
-  };
-  return {
-    calendarOpen,
-    setCalendarOpen,
-    handleCalendarKeyDown,
-    handleInputKeyDown
-  };
-};
-
-function useDateFieldSingleState({
-  valueProp,
-  defaultValueProp,
-  inputRef,
-  onChange
-}) {
-  const [value, setValue] = useOptionallyControlledState({
-    controlledValue: valueProp,
-    defaultValue: defaultValueProp
-  });
-  const setSharedValue = (date) => {
-    inputRef.current?.setDate(date);
-    setValue(date);
-  };
-  const handleInputChange = (change) => {
-    const date = change.isInputEmpty ? null : change.date?.startOf("day") ?? null;
-    onChange?.({
-      date,
-      isInputValid: change.isInputValid,
-      isInputEmpty: change.isInputEmpty
-    });
-    if (change.isInputValid) {
-      setSharedValue(change.isInputEmpty ? null : change.date);
-    }
-    if (change.isInputEmpty) {
-      setSharedValue(null);
-      return;
-    }
-    if (change.date) {
-      setSharedValue(change.date);
-    }
-  };
-  const handleCalendarSelection = (date) => {
-    setSharedValue(date);
-    onChange?.({
-      date,
-      isInputValid: true,
-      isInputEmpty: false
-    });
-  };
-  return {
-    value,
-    setValue: setSharedValue,
-    handleInputChange,
-    handleCalendarSelection
-  };
-}
-
-const DateFieldSingle = ({
-  onFocus,
-  onBlur,
-  disableCalendar,
-  required,
-  mode,
-  value: valueProp,
-  defaultValue: defaultValueProp,
-  minDate: minDateProp,
-  maxDate: maxDateProp,
-  unavailable: unavailableProp,
-  onChange: onChangeProp,
-  ...rest
-}) => {
-  const inputRef = useRef(null);
-  const {
-    value: normalizedValue,
-    defaultValue: normalizedDefaultValue,
-    minDate,
-    maxDate,
-    unavailable,
-    onChange
-  } = useDateFieldSingleConversion({
-    value: valueProp,
-    defaultValue: defaultValueProp,
-    onChange: onChangeProp,
-    minDate: minDateProp,
-    maxDate: maxDateProp,
-    unavailable: unavailableProp
-  });
-  const handleChange = (change) => {
-    onChange?.({
-      ...change,
-      isDateValid: validateDate({
-        date: change.date,
-        constraints: {
-          required,
-          unavailable,
-          minDate: minDate ?? void 0,
-          maxDate: maxDate ?? void 0
-        }
-      })
-    });
-  };
-  const { value, handleInputChange, handleCalendarSelection } = useDateFieldSingleState({
-    valueProp: normalizedValue,
-    defaultValueProp: normalizedDefaultValue,
-    inputRef,
-    onChange: handleChange
-  });
-  const { ref: wrapperRef } = useFocusWithin({
-    onBlur,
-    onFocus
-  });
-  const [popoverTriggerRef, setPopoverTriggerRef] = useState();
-  const popoverContentRef = useRef(null);
-  const combinedRef = useMergeRefs([popoverTriggerRef, inputRef]);
-  const {
-    calendarOpen,
-    setCalendarOpen,
-    handleCalendarKeyDown,
-    handleInputKeyDown
-  } = useDateFieldOrchestration({
-    inputRef,
-    calendarDefaultOpen: false,
-    popoverContentRef,
-    disableCalendar
-  });
-  const popoverSupported = usePopoverSupport();
-  const shouldShowCalendar = usePopoverCloseDelayWorkaround(calendarOpen);
-  const currentValidity = useMemo(
-    () => validateDate({
-      date: value,
-      constraints: {
-        required,
-        unavailable,
-        minDate: minDate ?? void 0,
-        maxDate: maxDate ?? void 0
-      }
-    }),
-    [value, required, unavailable, minDate, maxDate]
-  );
-  const justTheField = /* @__PURE__ */ jsx(
-    MaskedDateInput,
-    {
-      ...rest,
-      mode,
-      ref: combinedRef,
-      onChange: handleInputChange,
-      onKeyDown: handleInputKeyDown,
-      onClick: () => setCalendarOpen(true),
-      lastValidDate: value,
-      required,
-      autoComplete: "off",
-      "data-date-valid": currentValidity
-    }
-  );
-  if (disableCalendar) {
-    return justTheField;
-  }
-  if (!popoverSupported) {
-    return justTheField;
-  }
-  return /* @__PURE__ */ jsx("div", { ref: wrapperRef, children: /* @__PURE__ */ jsxs(
-    Popover,
-    {
-      open: calendarOpen,
-      modal: true,
-      placement: "bottom-start",
-      disableFlipFallback: true,
-      disableTriggerFocus: true,
-      onClose: () => setCalendarOpen(false),
-      disableAutoUpdate: true,
-      onClickOutside: () => setCalendarOpen(false),
-      children: [
-        /* @__PURE__ */ jsx(Popover.Trigger, { children: ({ ref: iRef }) => {
-          setPopoverTriggerRef(iRef);
-          return justTheField;
-        } }),
-        /* @__PURE__ */ jsx(Popover.Content, { ref: popoverContentRef, "data-testid": "calendar-popover", children: shouldShowCalendar && /* @__PURE__ */ jsx(
-          DateFieldSingleCalendar,
-          {
-            onKeyDown: handleCalendarKeyDown,
-            value,
-            onSelection: handleCalendarSelection,
-            minDate,
-            maxDate,
-            unavailable
-          }
-        ) })
-      ]
-    }
-  ) });
-};
-DateFieldSingle.displayName = "DateFieldSingle";
-
-const datePlaceholderMask = ({
-  mode,
-  dateSeparator = "/",
-  rangeSeparator = " - ",
-  placeholder
-}) => {
-  const dateRangeOptions = maskitoDateRangeOptionsGenerator({
-    mode,
-    dateSeparator,
-    rangeSeparator
-  });
-  const { plugins, removePlaceholder, ...placeholderOptions } = maskitoWithPlaceholder(placeholder);
-  const datePlaceholderMask2 = {
-    ...dateRangeOptions,
-    plugins: plugins.concat(dateRangeOptions.plugins || []),
-    preprocessors: [
-      ...placeholderOptions.preprocessors,
-      ...dateRangeOptions.preprocessors,
-      makeZeroShortcutPreprocessor(placeholder, dateSeparator)
-    ],
-    postprocessors: [
-      // NOTE this is super fragile. If Maskito maintainers change the order of the post-processors, this will break.
-      // The last postprocessor is the date swap postprocessor, which we don't want to run.
-      // A unit test is added to ensure this doesn't break on a dependency update.
-      ...dateRangeOptions.postprocessors.slice(0, -1),
-      ...placeholderOptions.postprocessors
-    ]
-  };
-  return { options: datePlaceholderMask2, removePlaceholder };
-};
-
-const RANGE_SEPARATOR = " - ";
-const MaskedDateRangeInput = forwardRef(
-  ({
-    onChange,
-    mode = "mm/dd/yyyy",
-    startDate,
-    endDate,
-    disableHint = false,
-    ...props
-  }, ref) => {
-    const halfPlaceholder = DateModeToPlaceholderMap[mode];
-    const fullPlaceholder = `${halfPlaceholder}${RANGE_SEPARATOR}${halfPlaceholder}`;
-    const [inputValue, setInputValue] = useState(fullPlaceholder);
-    const { options, removePlaceholder } = datePlaceholderMask({
-      mode,
-      placeholder: fullPlaceholder,
-      dateSeparator: "/",
-      rangeSeparator: RANGE_SEPARATOR
-    });
-    const maskedInputRef = useMaskito({ options });
-    const inputRef = useRef(null);
-    const combinedRef = useMergeRefs$1([maskedInputRef, inputRef, ref]);
-    const previousStartDate = usePrevious(startDate);
-    const previousEndDate = usePrevious(endDate);
-    const previousMode = usePrevious(mode);
-    useEffect(() => {
-      if (mode !== previousMode) {
-        setInputValue(
-          (previousInputValue) => swapMode$1(previousInputValue, previousMode ?? mode, mode)
-        );
-      }
-    }, [mode, fullPlaceholder, previousMode]);
-    useEffect(() => {
-      if (startDate === void 0 || endDate === void 0) return;
-      if (startDate === previousStartDate && endDate === previousEndDate)
-        return;
-      if (
-        // plus one just represents a date that is guaranteed to be different.
-        startDate?.equals(previousStartDate ?? startDate?.plus({ days: 1 })) && (endDate?.equals(previousEndDate ?? endDate?.plus({ days: 1 })) || endDate === previousEndDate)
-      )
-        return;
-      const startDateString = startDate?.toFormat(DateModeToFormatMap[mode]) ?? halfPlaceholder;
-      const endDateString = endDate?.toFormat(DateModeToFormatMap[mode]) ?? halfPlaceholder;
-      const newInputValue = `${startDateString}${RANGE_SEPARATOR}${endDateString}`;
-      setInputValue(newInputValue);
-    }, [
-      startDate,
-      endDate,
-      mode,
-      halfPlaceholder,
-      previousStartDate,
-      previousEndDate
-    ]);
-    const currentParsedData = useMemo(() => {
-      return parseRangeInputValue(inputValue, mode, removePlaceholder);
-    }, [inputValue, mode, removePlaceholder]);
-    const handleChange = (event) => {
-      setInputValue(event.target.value);
-      const {
-        startDate: parsedStartDate,
-        endDate: parsedEndDate,
-        isInputValid,
-        isInputEmpty,
-        isHalfEmpty
-      } = parseRangeInputValue(event.target.value, mode, removePlaceholder);
-      const isValueDifferent = isInputValid !== currentParsedData.isInputValid || // The input has changed validity
-      isInputEmpty !== currentParsedData.isInputEmpty || // The input has changed emptiness
-      parsedStartDate === null !== (startDate === null) || // The start date has changed from empty to non-empty or vice versa
-      parsedEndDate === null !== (endDate === null) || // The end date has changed from empty to non-empty or vice versa
-      parsedStartDate !== null && startDate !== null && !parsedStartDate.equals(startDate) || // The start date has changed
-      parsedEndDate !== null && endDate !== null && !parsedEndDate.equals(endDate);
-      if (!isValueDifferent) return;
-      onChange?.({
-        startDate: isInputEmpty ? null : parsedStartDate ?? startDate ?? null,
-        endDate: isInputEmpty || isHalfEmpty ? null : parsedEndDate ?? endDate ?? null,
-        isInputValid,
-        isInputEmpty
-      });
-    };
-    useImperativeHandle(ref, () => {
-      const input = inputRef.current;
-      if (!input) return null;
-      return Object.assign(input, {
-        setDateRange: (startDate2, endDate2) => {
-          const startDateString = startDate2?.toFormat(
-            DateModeToFormatMap[mode]
-          );
-          const endDateString = endDate2?.toFormat(DateModeToFormatMap[mode]);
-          const newInputValue = `${startDateString ?? halfPlaceholder}${RANGE_SEPARATOR}${endDateString ?? halfPlaceholder}`;
-          setInputValue(newInputValue);
-        }
-      });
-    }, [mode, halfPlaceholder]);
-    return /* @__PURE__ */ jsx(
-      TextField,
-      {
-        ref: combinedRef,
-        "data-start-date": startDate?.toISODate() ?? "",
-        "data-end-date": endDate?.toISODate() ?? "",
-        "data-input-valid": currentParsedData.isInputValid,
-        "data-input-empty": currentParsedData.isInputEmpty,
-        ...props,
-        showCounter: false,
-        value: inputValue,
-        onChange: handleChange,
-        prefix: /* @__PURE__ */ jsx(Icon, { svg: SvgEvent }),
-        hint: disableHint ? void 0 : `Format: ${mode}`
-      }
-    );
-  }
-);
-MaskedDateRangeInput.displayName = "MaskedDateRangeInput";
-function parseRangeInputValue(value, mode, removePlaceholder) {
-  const valueMinusPlaceholder = removePlaceholder(value);
-  const [startDate, endDate] = valueMinusPlaceholder.split(RANGE_SEPARATOR);
-  const startJsDate = maskitoParseDate(startDate, { mode });
-  const endJsDate = endDate ? maskitoParseDate(endDate, { mode }) : null;
-  const startLuxonDate = startJsDate ? DateTime.fromJSDate(startJsDate, { zone: "utc" }) : null;
-  const endLuxonDate = endJsDate ? DateTime.fromJSDate(endJsDate, { zone: "utc" }) : null;
-  return {
-    startDate: startLuxonDate,
-    endDate: endLuxonDate,
-    isInputValid: !!(startLuxonDate && endLuxonDate),
-    // input valid if both dates are filled
-    isInputEmpty: valueMinusPlaceholder === "",
-    // input empty if nothing is typed
-    isHalfEmpty: endDate === void 0
-  };
-}
-function swapMode$1(inputString, previousMode, mode) {
-  const halves = inputString.split(RANGE_SEPARATOR);
-  const segments = halves.map((half) => half.split("/"));
-  let startDay, startMonth, startYear, endDay, endMonth, endYear;
-  if (previousMode === "mm/dd/yyyy") {
-    startDay = segments[0][1];
-    startMonth = segments[0][0];
-    startYear = segments[0][2];
-    endDay = segments[1][1];
-    endMonth = segments[1][0];
-    endYear = segments[1][2];
-  }
-  if (previousMode === "dd/mm/yyyy") {
-    startDay = segments[0][0];
-    startMonth = segments[0][1];
-    startYear = segments[0][2];
-    endDay = segments[1][0];
-    endMonth = segments[1][1];
-    endYear = segments[1][2];
-  }
-  if (previousMode === "yyyy/mm/dd") {
-    startDay = segments[0][2];
-    startMonth = segments[0][1];
-    startYear = segments[0][0];
-    endDay = segments[1][2];
-    endMonth = segments[1][1];
-    endYear = segments[1][0];
-  }
-  if (mode === "mm/dd/yyyy") {
-    return `${startMonth}/${startDay}/${startYear}${RANGE_SEPARATOR}${endMonth}/${endDay}/${endYear}`;
-  }
-  if (mode === "dd/mm/yyyy") {
-    return `${startDay}/${startMonth}/${startYear}${RANGE_SEPARATOR}${endDay}/${endMonth}/${endYear}`;
-  }
-  if (mode === "yyyy/mm/dd") {
-    return `${startYear}/${startMonth}/${startDay}${RANGE_SEPARATOR}${endYear}/${endMonth}/${endDay}`;
-  }
-  return inputString;
-}
-
-const useDateFieldRangeConversion = (props) => {
-  const { value, defaultValue, minDate, maxDate, unavailable, onChange } = props;
-  const normalizedValue = useMemo(() => {
-    if (value === null || value === void 0) return value;
-    return {
-      startDate: convertStringToDate(value.startDate) ?? null,
-      endDate: convertStringToDate(value.endDate) ?? null
-    };
-  }, [value]);
-  const normalizedDefaultValue = useMemo(() => {
-    if (defaultValue === null || defaultValue === void 0)
-      return defaultValue;
-    return {
-      startDate: convertStringToDate(defaultValue.startDate) ?? null,
-      endDate: convertStringToDate(defaultValue.endDate) ?? null
-    };
-  }, [defaultValue]);
-  const normalizedMinDate = useMemo(
-    () => convertStringToDate(minDate),
-    [minDate]
-  );
-  const normalizedMaxDate = useMemo(
-    () => convertStringToDate(maxDate),
-    [maxDate]
-  );
-  const normalizedUnavailableDates = useMemo(() => {
-    return unavailable?.dates?.map((date) => convertStringToDate(date)).filter((date) => date !== null && date !== void 0);
-  }, [unavailable?.dates]);
-  const handleChange = useCallback(
-    (change) => {
-      onChange?.({
-        ...change,
-        startDate: change.startDate?.toISODate() ?? null,
-        endDate: change.endDate?.toISODate() ?? null
-      });
-    },
-    [onChange]
-  );
-  return {
-    value: normalizedValue,
-    defaultValue: normalizedDefaultValue,
-    minDate: normalizedMinDate,
-    maxDate: normalizedMaxDate,
-    unavailable: {
-      dates: normalizedUnavailableDates,
-      daysOfWeek: unavailable?.daysOfWeek
-    },
-    onChange: handleChange
-  };
-};
-
-function useDateFieldRangeState({
-  valueProp,
-  defaultValueProp,
-  inputRef,
-  onChange
-}) {
-  const [startDate, setStartDate] = useOptionallyControlledState({
-    controlledValue: valueProp !== void 0 ? valueProp?.startDate : void 0,
-    defaultValue: defaultValueProp !== void 0 ? defaultValueProp?.startDate : void 0
-  });
-  const [endDate, setEndDate] = useOptionallyControlledState({
-    controlledValue: valueProp !== void 0 ? valueProp?.endDate : void 0,
-    defaultValue: defaultValueProp !== void 0 ? defaultValueProp?.endDate : void 0
-  });
-  const setSharedValue = (value) => {
-    inputRef.current?.setDateRange(value.startDate, value.endDate);
-    setStartDate(value.startDate);
-    setEndDate(value.endDate);
-  };
-  const handleInputChange = (change) => {
-    const range = change.isInputEmpty ? null : {
-      startDate: change.startDate?.startOf("day") ?? null,
-      endDate: change.endDate?.startOf("day") ?? null
-    };
-    setStartDate(range?.startDate ?? null);
-    setEndDate(range?.endDate ?? null);
-    onChange?.({
-      startDate: range?.startDate ?? null,
-      endDate: range?.endDate ?? null,
-      isInputValid: change.isInputValid,
-      isInputEmpty: change.isInputEmpty
-    });
-  };
-  const handleCalendarSelection = ({
-    startDate: startDate2,
-    endDate: endDate2
-  }) => {
-    setSharedValue({ startDate: startDate2, endDate: endDate2 });
-    onChange?.({
-      startDate: startDate2,
-      endDate: endDate2,
-      isInputValid: true,
-      isInputEmpty: false
-    });
-  };
-  return {
-    startDate,
-    endDate,
-    setStartDate,
-    setEndDate,
-    handleInputChange,
-    handleCalendarSelection
-  };
-}
-
-const DateFieldRangeCalendar = ({
-  startDate,
-  endDate,
-  onKeyDown,
-  onSelection,
-  minDate,
-  maxDate,
-  unavailable
-}) => {
-  const previousStartDate = usePrevious(startDate);
-  const previousEndDate = usePrevious(endDate);
-  const handleCalendarSelection = (data) => {
-    if (!data.value) return;
-    const calStartDate = data.value.start ? DateTime.fromISO(data.value.start, { zone: "utc" }) : null;
-    const calEndDate = data.value.end ? DateTime.fromISO(data.value.end, { zone: "utc" }) : null;
-    onSelection({
-      startDate: calStartDate,
-      endDate: calEndDate
-    });
-  };
-  const defaultFocusedDate = useMemo(() => {
-    if (!startDate && !endDate) return DateTime.now().toISODate();
-    if (!startDate) return endDate?.toISODate();
-    if (!endDate) return startDate?.toISODate();
-    if (endDate && !previousEndDate?.equals(endDate)) {
-      return endDate.toISODate();
-    } else if (startDate && !previousStartDate?.equals(startDate)) {
-      return startDate.toISODate();
-    }
-    if (endDate) return endDate.toISODate();
-    if (startDate) return startDate.toISODate();
-    return DateTime.now().toISODate();
-  }, [previousStartDate, previousEndDate, startDate, endDate]);
-  return /* @__PURE__ */ jsx(
-    Calendar,
-    {
-      range: true,
-      onKeyDown,
-      defaultFocusedDate,
-      value: {
-        start: startDate?.toISODate() || void 0,
-        end: endDate?.toISODate() || void 0
-      },
-      onSelection: handleCalendarSelection,
-      defaultTimeZone: "UTC",
-      minDate: minDate?.toISODate() ?? void 0,
-      maxDate: maxDate?.toISODate() ?? void 0,
-      unavailable: unavailable ? {
-        dates: unavailable.dates?.map((d) => d.toISODate() ?? ""),
-        daysOfWeek: unavailable.daysOfWeek
-      } : void 0,
-      _disableAutofocus: true
-    },
-    `${startDate?.toISODate()}-${endDate?.toISODate()}`
-  );
-};
-
-const DateFieldRange = ({
-  onFocus,
-  onBlur,
-  disableCalendar,
-  required,
-  mode,
-  value: valueProp,
-  defaultValue: defaultValueProp,
-  minDate: minDateProp,
-  maxDate: maxDateProp,
-  unavailable: unavailableProp,
-  onChange: onChangeProp,
-  ...rest
-}) => {
-  const { ref: wrapperRef } = useFocusWithin({
-    onBlur,
-    onFocus
-  });
-  const { value, defaultValue, minDate, maxDate, unavailable, onChange } = useDateFieldRangeConversion({
-    value: valueProp,
-    defaultValue: defaultValueProp,
-    minDate: minDateProp,
-    maxDate: maxDateProp,
-    unavailable: unavailableProp,
-    onChange: onChangeProp
-  });
-  const inputRef = useRef(null);
-  const [popoverTriggerRef, setPopoverTriggerRef] = useState();
-  const popoverContentRef = useRef(null);
-  const combinedRef = useMergeRefs([popoverTriggerRef, inputRef]);
-  const popoverSupported = usePopoverSupport();
-  const handleChange = (change) => {
-    const sharedConstraints = {
-      unavailable,
-      minDate: minDate ?? void 0,
-      maxDate: maxDate ?? void 0
-    };
-    onChange?.({
-      startDate: change.startDate?.startOf("day") ?? null,
-      endDate: change.endDate?.startOf("day") ?? null,
-      isInputValid: change.isInputValid,
-      isInputEmpty: change.isInputEmpty,
-      isDateRangeValid: validateDateRange({
-        required,
-        startDate: change.startDate?.startOf("day") ?? null,
-        endDate: change.endDate?.startOf("day") ?? null,
-        startDateConstraints: sharedConstraints,
-        endDateConstraints: sharedConstraints
-      })
-    });
-  };
-  const { startDate, endDate, handleInputChange, handleCalendarSelection } = useDateFieldRangeState({
-    valueProp: value,
-    defaultValueProp: defaultValue,
-    inputRef,
-    onChange: handleChange
-  });
-  const {
-    calendarOpen,
-    setCalendarOpen,
-    handleCalendarKeyDown,
-    handleInputKeyDown
-  } = useDateFieldOrchestration({
-    inputRef,
-    calendarDefaultOpen: false,
-    popoverContentRef,
-    disableCalendar
-  });
-  const shouldShowCalendar = usePopoverCloseDelayWorkaround(calendarOpen);
-  const currentValidity = useMemo(() => {
-    return validateDateRange({
-      required,
-      startDate,
-      endDate,
-      startDateConstraints: {
-        unavailable,
-        minDate: minDate ?? void 0,
-        maxDate: maxDate ?? void 0
-      },
-      endDateConstraints: {
-        unavailable,
-        minDate: minDate ?? void 0,
-        maxDate: maxDate ?? void 0
-      }
-    });
-  }, [required, startDate, endDate, minDate, maxDate, unavailable]);
-  const justTheField = /* @__PURE__ */ jsx(
-    MaskedDateRangeInput,
-    {
-      ...rest,
-      mode,
-      ref: combinedRef,
-      startDate: startDate ?? null,
-      endDate: endDate ?? null,
-      onChange: handleInputChange,
-      disableHint: rest.disableHint,
-      onKeyDown: handleInputKeyDown,
-      onClick: () => setCalendarOpen(true),
-      required,
-      autoComplete: "off",
-      "data-date-range-valid": currentValidity
-    }
-  );
-  if (disableCalendar) {
-    return justTheField;
-  }
-  if (!popoverSupported) {
-    return justTheField;
-  }
-  return /* @__PURE__ */ jsx("div", { ref: wrapperRef, children: /* @__PURE__ */ jsxs(
-    Popover,
-    {
-      open: calendarOpen,
-      modal: true,
-      placement: "bottom-start",
-      disableFlipFallback: true,
-      disableTriggerFocus: true,
-      onClose: () => setCalendarOpen(false),
-      disableAutoUpdate: true,
-      onOutsidePress: () => setCalendarOpen(false),
-      children: [
-        /* @__PURE__ */ jsx(Popover.Trigger, { children: ({ ref: iRef }) => {
-          setPopoverTriggerRef(iRef);
-          return justTheField;
-        } }),
-        /* @__PURE__ */ jsx(Popover.Content, { ref: popoverContentRef, "data-testid": "calendar-popover", children: shouldShowCalendar && /* @__PURE__ */ jsx(
-          DateFieldRangeCalendar,
-          {
-            startDate,
-            endDate,
-            onKeyDown: handleCalendarKeyDown,
-            onSelection: handleCalendarSelection,
-            minDate,
-            maxDate,
-            unavailable
-          }
-        ) })
-      ]
-    }
-  ) });
-};
-DateFieldRange.displayName = "DateFieldRange";
-function validateDateRange({
-  required,
-  startDate,
-  endDate,
-  startDateConstraints,
-  endDateConstraints
-}) {
-  if (!required && !startDate && !endDate) return true;
-  return validateDate({
-    date: startDate,
-    constraints: { ...startDateConstraints, required: true }
-  }) && validateDate({
-    date: endDate,
-    constraints: { ...endDateConstraints, required: true }
-  }) && (!startDate || !endDate || startDate <= endDate);
-}
-
-const yearlessDatePlaceholderMask = ({
-  mode,
-  separator = "/",
-  placeholder
-}) => {
-  const dateOptions = maskitoDateOptionsGenerator({
-    mode,
-    separator
-  });
-  const { plugins, removePlaceholder, ...placeholderOptions } = maskitoWithPlaceholder(placeholder);
-  const datePlaceholderMask = {
-    ...dateOptions,
-    plugins: plugins.concat(dateOptions.plugins || []),
-    preprocessors: [
-      ...placeholderOptions.preprocessors,
-      ...dateOptions.preprocessors,
-      makeZeroShortcutPreprocessor(mode, separator)
-    ],
-    postprocessors: [
-      ...dateOptions.postprocessors,
-      ...placeholderOptions.postprocessors
-    ]
-  };
-  return { options: datePlaceholderMask, removePlaceholder };
-};
-
-const MaskedYearlessDateInput = forwardRef(({ onChange, mode = "mm/dd", value, disableHint = false, ...props }, ref) => {
-  const placeholder = "__/__";
-  const [inputValue, setInputValue] = useState(placeholder);
-  const { options, removePlaceholder } = yearlessDatePlaceholderMask({
-    mode,
-    placeholder
-  });
-  const maskedInputRef = useMaskito({ options });
-  const inputRef = useRef(null);
-  const combinedRef = useMergeRefs$1([maskedInputRef, inputRef, ref]);
-  const previousValue = usePrevious(value);
-  const previousMode = usePrevious(mode);
-  useEffect(() => {
-    if (mode !== previousMode) {
-      setInputValue(
-        (oldInputValue) => swapMode(oldInputValue, previousMode ?? mode, mode)
-      );
-    }
-  }, [mode, previousMode]);
-  useEffect(() => {
-    if (previousValue?.day !== value?.day || previousValue?.month !== value?.month) {
-      if (value?.day && value?.month) {
-        setInputValue(stringifyYearlessDate(value.day, value.month, mode));
-      } else if (previousValue !== null && previousValue !== void 0 && (value === null || value?.day === null && value?.month === null)) {
-        setInputValue(placeholder);
-      } else {
-        return;
-      }
-    }
-  }, [value, mode, previousValue]);
-  const currentParsedData = useMemo(() => {
-    return parseInputValue(inputValue, mode, removePlaceholder);
-  }, [inputValue, mode, removePlaceholder]);
-  const handleChange = (event) => {
-    setInputValue(event.target.value);
-    const {
-      value: v,
-      isInputValid,
-      isInputEmpty
-    } = parseInputValue(event.target.value, mode, removePlaceholder);
-    onChange?.({
-      event,
-      value: v ?? currentParsedData.value ?? null,
-      isInputValid,
-      isInputEmpty
-    });
-  };
-  useImperativeHandle(ref, () => {
-    const input = inputRef.current;
-    if (!input) return null;
-    return Object.assign(input, {
-      setValue: (value2) => {
-        if (!value2) {
-          setInputValue(placeholder);
-          return;
-        }
-        setInputValue(
-          stringifyYearlessDate(value2.day ?? 1, value2.month ?? 1, mode)
-        );
-      }
-    });
-  }, [mode, placeholder]);
-  return /* @__PURE__ */ jsx(
-    TextField,
-    {
-      ref: combinedRef,
-      "data-month-value": value?.month,
-      "data-day-value": value?.day,
-      "data-input-valid": currentParsedData.isInputValid,
-      "data-input-empty": currentParsedData.isInputEmpty,
-      ...props,
-      showCounter: false,
-      value: inputValue,
-      onChange: handleChange,
-      hint: disableHint ? void 0 : `Format: ${mode}`
-    }
-  );
-});
-MaskedYearlessDateInput.displayName = "MaskedYearlessDateInput";
-function parseInputValue(value, mode, removePlaceholder) {
-  const valueMinusPlaceholder = removePlaceholder(value);
-  const [segment1, segment2] = valueMinusPlaceholder.split("/");
-  const incompleteFirstSegment = segment1?.length !== 2;
-  const incompleteSecondSegment = segment2?.length !== 2;
-  if (mode === "dd/mm") {
-    return {
-      value: {
-        day: incompleteFirstSegment ? null : parseInt(segment1),
-        month: incompleteSecondSegment ? null : parseInt(segment2)
-      },
-      isInputValid: !incompleteFirstSegment && !incompleteSecondSegment,
-      isInputEmpty: valueMinusPlaceholder === ""
-    };
-  }
-  return {
-    value: {
-      day: incompleteSecondSegment ? null : parseInt(segment2),
-      month: incompleteFirstSegment ? null : parseInt(segment1)
-    },
-    isInputValid: !incompleteFirstSegment && !incompleteSecondSegment,
-    isInputEmpty: valueMinusPlaceholder === ""
-  };
-}
-function swapMode(inputString, previousMode, mode) {
-  const { day, month } = divideSegments(inputString, previousMode);
-  return stringifyYearlessDate(day, month, mode);
-}
-function divideSegments(value, mode) {
-  const [segment1, segment2] = value.split("/");
-  if (mode === "dd/mm") {
-    return { day: segment1, month: segment2 };
-  }
-  return { day: segment2, month: segment1 };
-}
-function stringifyYearlessDate(day, month, mode) {
-  const dd = day.toString().padStart(2, "0");
-  const mm = month.toString().padStart(2, "0");
-  if (mode === "dd/mm") {
-    return `${dd}/${mm}`;
-  }
-  return `${mm}/${dd}`;
-}
-
-const useConditionalChange = ({
-  changeHandler,
-  compareFn
-}) => {
-  const lastChangeRef = useRef(null);
-  const onChange = useCallback(
-    (change) => {
-      if (!!lastChangeRef.current && !compareFn(lastChangeRef.current, change)) {
-        return;
-      }
-      changeHandler?.(change);
-      lastChangeRef.current = change;
-    },
-    [changeHandler, compareFn]
-  );
-  return onChange;
-};
-
-const DateFieldYearless = ({
-  value: valueProp,
-  defaultValue: defaultValueProp,
-  onChange,
-  minDate,
-  maxDate,
-  unavailable,
-  required,
-  ...restProps
-}) => {
-  const [value, setValue] = useOptionallyControlledState({
-    controlledValue: valueProp,
-    defaultValue: defaultValueProp
-  });
-  const currentValidity = useMemo(
-    () => validateYearlessDate({
-      value: value ?? null,
-      constraints: {
-        required,
-        unavailable,
-        minDate,
-        maxDate
-      }
-    }),
-    [value, required, unavailable, minDate, maxDate]
-  );
-  const conditionalChange = useConditionalChange({
-    changeHandler: onChange,
-    compareFn: (a, b) => a.isInputValid !== b.isInputValid || a.isInputEmpty !== b.isInputEmpty || a.isValid !== b.isValid || a.value?.day !== b.value?.day || a.value?.month !== b.value?.month
-  });
-  const handleInputChange = (change) => {
-    const { event, value: value2, ...restChange } = change;
-    setValue(value2);
-    return conditionalChange({
-      ...restChange,
-      value: value2,
-      isValid: validateYearlessDate({
-        value: value2,
-        constraints: {
-          required,
-          unavailable,
-          minDate,
-          maxDate
-        }
-      })
-    });
-  };
-  return /* @__PURE__ */ jsx(
-    MaskedYearlessDateInput,
-    {
-      required,
-      ...restProps,
-      autoComplete: "off",
-      onChange: handleInputChange,
-      value,
-      "data-valid": currentValidity
-    }
-  );
-};
-DateFieldYearless.displayName = "DateFieldYearless";
-
-export { DateFieldRange as D, DateFieldSingle as a, DateFieldYearless as b };
-//# sourceMappingURL=DateFieldYearless-DU0z2fEA-ByR2ixI5.js.map
+export { useMaskito as a, maskitoWithPlaceholder as b, maskitoParseDate as c, maskitoDateOptionsGenerator as d, maskitoTimeOptionsGenerator as e, maskitoDateRangeOptionsGenerator as m, usePopoverSupport as u };
+//# sourceMappingURL=usePopoverSupport-B9Lsqryr-DhZHMoNb.js.map