@erpsquad/common 1.8.40 → 1.8.41

package/dist/node_modules/@mui/x-date-pickers/internals/hooks/useField/useField.utils/index.esm.js

@@ -0,0 +1,672 @@
+import _extends from "../../../../../../@babel/runtime/helpers/esm/extends/index.esm.js";
+import { getMonthsInYear } from "../../../utils/date-utils/index.esm.js";
+var define_process_env_default = {};
+const getDateSectionConfigFromFormatToken = (utils, formatToken) => {
+  const config = utils.formatTokenMap[formatToken];
+  if (config == null) {
+    throw new Error([`MUI: The token "${formatToken}" is not supported by the Date and Time Pickers.`, "Please try using another token or open an issue on https://github.com/mui/mui-x/issues/new/choose if you think it should be supported."].join("\n"));
+  }
+  if (typeof config === "string") {
+    return {
+      type: config,
+      contentType: config === "meridiem" ? "letter" : "digit",
+      maxLength: void 0
+    };
+  }
+  return {
+    type: config.sectionType,
+    contentType: config.contentType,
+    maxLength: config.maxLength
+  };
+};
+const getDeltaFromKeyCode = (keyCode) => {
+  switch (keyCode) {
+    case "ArrowUp":
+      return 1;
+    case "ArrowDown":
+      return -1;
+    case "PageUp":
+      return 5;
+    case "PageDown":
+      return -5;
+    default:
+      return 0;
+  }
+};
+const getDaysInWeekStr = (utils, timezone, format) => {
+  const elements = [];
+  const now = utils.dateWithTimezone(void 0, timezone);
+  const startDate = utils.startOfWeek(now);
+  const endDate = utils.endOfWeek(now);
+  let current = startDate;
+  while (utils.isBefore(current, endDate)) {
+    elements.push(current);
+    current = utils.addDays(current, 1);
+  }
+  return elements.map((weekDay) => utils.formatByString(weekDay, format));
+};
+const getLetterEditingOptions = (utils, timezone, sectionType, format) => {
+  switch (sectionType) {
+    case "month": {
+      return getMonthsInYear(utils, utils.dateWithTimezone(void 0, timezone)).map((month) => utils.formatByString(month, format));
+    }
+    case "weekDay": {
+      return getDaysInWeekStr(utils, timezone, format);
+    }
+    case "meridiem": {
+      const now = utils.dateWithTimezone(void 0, timezone);
+      return [utils.startOfDay(now), utils.endOfDay(now)].map((date) => utils.formatByString(date, format));
+    }
+    default: {
+      return [];
+    }
+  }
+};
+const cleanLeadingZeros = (utils, valueStr, size) => {
+  let cleanValueStr = valueStr;
+  cleanValueStr = Number(cleanValueStr).toString();
+  while (cleanValueStr.length < size) {
+    cleanValueStr = `0${cleanValueStr}`;
+  }
+  return cleanValueStr;
+};
+const cleanDigitSectionValue = (utils, timezone, value, sectionBoundaries, section) => {
+  if (define_process_env_default.NODE_ENV !== "production") {
+    if (section.type !== "day" && section.contentType === "digit-with-letter") {
+      throw new Error([`MUI: The token "${section.format}" is a digit format with letter in it.'
+             This type of format is only supported for 'day' sections`].join("\n"));
+    }
+  }
+  if (section.type === "day" && section.contentType === "digit-with-letter") {
+    const date = utils.setDate(sectionBoundaries.longestMonth, value);
+    return utils.formatByString(date, section.format);
+  }
+  const valueStr = value.toString();
+  if (section.hasLeadingZerosInInput) {
+    return cleanLeadingZeros(utils, valueStr, section.maxLength);
+  }
+  return valueStr;
+};
+const adjustSectionValue = (utils, timezone, section, keyCode, sectionsValueBoundaries, activeDate, stepsAttributes) => {
+  const delta = getDeltaFromKeyCode(keyCode);
+  const isStart = keyCode === "Home";
+  const isEnd = keyCode === "End";
+  const shouldSetAbsolute = section.value === "" || isStart || isEnd;
+  const adjustDigitSection = () => {
+    const sectionBoundaries = sectionsValueBoundaries[section.type]({
+      currentDate: activeDate,
+      format: section.format,
+      contentType: section.contentType
+    });
+    const getCleanValue = (value) => cleanDigitSectionValue(utils, timezone, value, sectionBoundaries, section);
+    const step = section.type === "minutes" && stepsAttributes != null && stepsAttributes.minutesStep ? stepsAttributes.minutesStep : 1;
+    const currentSectionValue = parseInt(section.value, 10);
+    let newSectionValueNumber = currentSectionValue + delta * step;
+    if (shouldSetAbsolute) {
+      if (section.type === "year" && !isEnd && !isStart) {
+        return utils.formatByString(utils.dateWithTimezone(void 0, timezone), section.format);
+      }
+      if (delta > 0 || isStart) {
+        newSectionValueNumber = sectionBoundaries.minimum;
+      } else {
+        newSectionValueNumber = sectionBoundaries.maximum;
+      }
+    }
+    if (newSectionValueNumber % step !== 0) {
+      if (delta < 0 || isStart) {
+        newSectionValueNumber += step - (step + newSectionValueNumber) % step;
+      }
+      if (delta > 0 || isEnd) {
+        newSectionValueNumber -= newSectionValueNumber % step;
+      }
+    }
+    if (newSectionValueNumber > sectionBoundaries.maximum) {
+      return getCleanValue(sectionBoundaries.minimum + (newSectionValueNumber - sectionBoundaries.maximum - 1) % (sectionBoundaries.maximum - sectionBoundaries.minimum + 1));
+    }
+    if (newSectionValueNumber < sectionBoundaries.minimum) {
+      return getCleanValue(sectionBoundaries.maximum - (sectionBoundaries.minimum - newSectionValueNumber - 1) % (sectionBoundaries.maximum - sectionBoundaries.minimum + 1));
+    }
+    return getCleanValue(newSectionValueNumber);
+  };
+  const adjustLetterSection = () => {
+    const options = getLetterEditingOptions(utils, timezone, section.type, section.format);
+    if (options.length === 0) {
+      return section.value;
+    }
+    if (shouldSetAbsolute) {
+      if (delta > 0 || isStart) {
+        return options[0];
+      }
+      return options[options.length - 1];
+    }
+    const currentOptionIndex = options.indexOf(section.value);
+    const newOptionIndex = (currentOptionIndex + options.length + delta) % options.length;
+    return options[newOptionIndex];
+  };
+  if (section.contentType === "digit" || section.contentType === "digit-with-letter") {
+    return adjustDigitSection();
+  }
+  return adjustLetterSection();
+};
+const getSectionVisibleValue = (section, target) => {
+  let value = section.value || section.placeholder;
+  const hasLeadingZeros = target === "non-input" ? section.hasLeadingZerosInFormat : section.hasLeadingZerosInInput;
+  if (target === "non-input" && section.hasLeadingZerosInInput && !section.hasLeadingZerosInFormat) {
+    value = Number(value).toString();
+  }
+  const shouldAddInvisibleSpace = ["input-rtl", "input-ltr"].includes(target) && section.contentType === "digit" && !hasLeadingZeros && value.length === 1;
+  if (shouldAddInvisibleSpace) {
+    value = `${value}‎`;
+  }
+  if (target === "input-rtl") {
+    value = `⁨${value}⁩`;
+  }
+  return value;
+};
+const cleanString = (dirtyString) => dirtyString.replace(/[\u2066\u2067\u2068\u2069]/g, "");
+const addPositionPropertiesToSections = (sections, isRTL) => {
+  let position = 0;
+  let positionInInput = isRTL ? 1 : 0;
+  const newSections = [];
+  for (let i = 0; i < sections.length; i += 1) {
+    const section = sections[i];
+    const renderedValue = getSectionVisibleValue(section, isRTL ? "input-rtl" : "input-ltr");
+    const sectionStr = `${section.startSeparator}${renderedValue}${section.endSeparator}`;
+    const sectionLength = cleanString(sectionStr).length;
+    const sectionLengthInInput = sectionStr.length;
+    const cleanedValue = cleanString(renderedValue);
+    const startInInput = positionInInput + renderedValue.indexOf(cleanedValue[0]) + section.startSeparator.length;
+    const endInInput = startInInput + cleanedValue.length;
+    newSections.push(_extends({}, section, {
+      start: position,
+      end: position + sectionLength,
+      startInInput,
+      endInInput
+    }));
+    position += sectionLength;
+    positionInInput += sectionLengthInInput;
+  }
+  return newSections;
+};
+const getSectionPlaceholder = (utils, timezone, localeText, sectionConfig, sectionFormat) => {
+  switch (sectionConfig.type) {
+    case "year": {
+      return localeText.fieldYearPlaceholder({
+        digitAmount: utils.formatByString(utils.dateWithTimezone(void 0, timezone), sectionFormat).length,
+        format: sectionFormat
+      });
+    }
+    case "month": {
+      return localeText.fieldMonthPlaceholder({
+        contentType: sectionConfig.contentType,
+        format: sectionFormat
+      });
+    }
+    case "day": {
+      return localeText.fieldDayPlaceholder({
+        format: sectionFormat
+      });
+    }
+    case "weekDay": {
+      return localeText.fieldWeekDayPlaceholder({
+        contentType: sectionConfig.contentType,
+        format: sectionFormat
+      });
+    }
+    case "hours": {
+      return localeText.fieldHoursPlaceholder({
+        format: sectionFormat
+      });
+    }
+    case "minutes": {
+      return localeText.fieldMinutesPlaceholder({
+        format: sectionFormat
+      });
+    }
+    case "seconds": {
+      return localeText.fieldSecondsPlaceholder({
+        format: sectionFormat
+      });
+    }
+    case "meridiem": {
+      return localeText.fieldMeridiemPlaceholder({
+        format: sectionFormat
+      });
+    }
+    default: {
+      return sectionFormat;
+    }
+  }
+};
+const changeSectionValueFormat = (utils, valueStr, currentFormat, newFormat) => {
+  if (define_process_env_default.NODE_ENV !== "production") {
+    if (getDateSectionConfigFromFormatToken(utils, currentFormat).type === "weekDay") {
+      throw new Error("changeSectionValueFormat doesn't support week day formats");
+    }
+  }
+  return utils.formatByString(utils.parse(valueStr, currentFormat), newFormat);
+};
+const isFourDigitYearFormat = (utils, timezone, format) => utils.formatByString(utils.dateWithTimezone(void 0, timezone), format).length === 4;
+const doesSectionFormatHaveLeadingZeros = (utils, timezone, contentType, sectionType, format) => {
+  if (contentType !== "digit") {
+    return false;
+  }
+  const now = utils.dateWithTimezone(void 0, timezone);
+  switch (sectionType) {
+    case "year": {
+      if (isFourDigitYearFormat(utils, timezone, format)) {
+        const formatted0001 = utils.formatByString(utils.setYear(now, 1), format);
+        return formatted0001 === "0001";
+      }
+      const formatted2001 = utils.formatByString(utils.setYear(now, 2001), format);
+      return formatted2001 === "01";
+    }
+    case "month": {
+      return utils.formatByString(utils.startOfYear(now), format).length > 1;
+    }
+    case "day": {
+      return utils.formatByString(utils.startOfMonth(now), format).length > 1;
+    }
+    case "weekDay": {
+      return utils.formatByString(utils.startOfWeek(now), format).length > 1;
+    }
+    case "hours": {
+      return utils.formatByString(utils.setHours(now, 1), format).length > 1;
+    }
+    case "minutes": {
+      return utils.formatByString(utils.setMinutes(now, 1), format).length > 1;
+    }
+    case "seconds": {
+      return utils.formatByString(utils.setSeconds(now, 1), format).length > 1;
+    }
+    default: {
+      throw new Error("Invalid section type");
+    }
+  }
+};
+const getEscapedPartsFromFormat = (utils, format) => {
+  const escapedParts = [];
+  const {
+    start: startChar,
+    end: endChar
+  } = utils.escapedCharacters;
+  const regExp = new RegExp(`(\\${startChar}[^\\${endChar}]*\\${endChar})+`, "g");
+  let match = null;
+  while (match = regExp.exec(format)) {
+    escapedParts.push({
+      start: match.index,
+      end: regExp.lastIndex - 1
+    });
+  }
+  return escapedParts;
+};
+const splitFormatIntoSections = (utils, timezone, localeText, format, date, formatDensity, shouldRespectLeadingZeros, isRTL) => {
+  let startSeparator = "";
+  const sections = [];
+  const now = utils.date();
+  const commitToken = (token) => {
+    if (token === "") {
+      return null;
+    }
+    const sectionConfig = getDateSectionConfigFromFormatToken(utils, token);
+    const hasLeadingZerosInFormat = doesSectionFormatHaveLeadingZeros(utils, timezone, sectionConfig.contentType, sectionConfig.type, token);
+    const hasLeadingZerosInInput = shouldRespectLeadingZeros ? hasLeadingZerosInFormat : sectionConfig.contentType === "digit";
+    const isValidDate = date != null && utils.isValid(date);
+    let sectionValue = isValidDate ? utils.formatByString(date, token) : "";
+    let maxLength = null;
+    if (hasLeadingZerosInInput) {
+      if (hasLeadingZerosInFormat) {
+        maxLength = sectionValue === "" ? utils.formatByString(now, token).length : sectionValue.length;
+      } else {
+        if (sectionConfig.maxLength == null) {
+          throw new Error(`MUI: The token ${token} should have a 'maxDigitNumber' property on it's adapter`);
+        }
+        maxLength = sectionConfig.maxLength;
+        if (isValidDate) {
+          sectionValue = cleanLeadingZeros(utils, sectionValue, maxLength);
+        }
+      }
+    }
+    sections.push(_extends({}, sectionConfig, {
+      format: token,
+      maxLength,
+      value: sectionValue,
+      placeholder: getSectionPlaceholder(utils, timezone, localeText, sectionConfig, token),
+      hasLeadingZeros: hasLeadingZerosInFormat,
+      hasLeadingZerosInFormat,
+      hasLeadingZerosInInput,
+      startSeparator: sections.length === 0 ? startSeparator : "",
+      endSeparator: "",
+      modified: false
+    }));
+    return null;
+  };
+  let formatExpansionOverflow = 10;
+  let prevFormat = format;
+  let nextFormat = utils.expandFormat(format);
+  while (nextFormat !== prevFormat) {
+    prevFormat = nextFormat;
+    nextFormat = utils.expandFormat(prevFormat);
+    formatExpansionOverflow -= 1;
+    if (formatExpansionOverflow < 0) {
+      throw new Error("MUI: The format expansion seems to be  enter in an infinite loop. Please open an issue with the format passed to the picker component");
+    }
+  }
+  const expandedFormat = nextFormat;
+  const escapedParts = getEscapedPartsFromFormat(utils, expandedFormat);
+  const isTokenStartRegExp = new RegExp(`^(${Object.keys(utils.formatTokenMap).sort((a, b) => b.length - a.length).join("|")})`, "g");
+  let currentTokenValue = "";
+  for (let i = 0; i < expandedFormat.length; i += 1) {
+    const escapedPartOfCurrentChar = escapedParts.find((escapeIndex) => escapeIndex.start <= i && escapeIndex.end >= i);
+    const char = expandedFormat[i];
+    const isEscapedChar = escapedPartOfCurrentChar != null;
+    const potentialToken = `${currentTokenValue}${expandedFormat.slice(i)}`;
+    const regExpMatch = isTokenStartRegExp.test(potentialToken);
+    if (!isEscapedChar && char.match(/([A-Za-z]+)/) && regExpMatch) {
+      currentTokenValue = potentialToken.slice(0, isTokenStartRegExp.lastIndex);
+      i += isTokenStartRegExp.lastIndex - 1;
+    } else {
+      const isEscapeBoundary = isEscapedChar && (escapedPartOfCurrentChar == null ? void 0 : escapedPartOfCurrentChar.start) === i || (escapedPartOfCurrentChar == null ? void 0 : escapedPartOfCurrentChar.end) === i;
+      if (!isEscapeBoundary) {
+        commitToken(currentTokenValue);
+        currentTokenValue = "";
+        if (sections.length === 0) {
+          startSeparator += char;
+        } else {
+          sections[sections.length - 1].endSeparator += char;
+        }
+      }
+    }
+  }
+  commitToken(currentTokenValue);
+  return sections.map((section) => {
+    const cleanSeparator = (separator) => {
+      let cleanedSeparator = separator;
+      if (isRTL && cleanedSeparator !== null && cleanedSeparator.includes(" ")) {
+        cleanedSeparator = `⁩${cleanedSeparator}⁦`;
+      }
+      if (formatDensity === "spacious" && ["/", ".", "-"].includes(cleanedSeparator)) {
+        cleanedSeparator = ` ${cleanedSeparator} `;
+      }
+      return cleanedSeparator;
+    };
+    section.startSeparator = cleanSeparator(section.startSeparator);
+    section.endSeparator = cleanSeparator(section.endSeparator);
+    return section;
+  });
+};
+const getDateFromDateSections = (utils, sections) => {
+  const shouldSkipWeekDays = sections.some((section) => section.type === "day");
+  const sectionFormats = [];
+  const sectionValues = [];
+  for (let i = 0; i < sections.length; i += 1) {
+    const section = sections[i];
+    const shouldSkip = shouldSkipWeekDays && section.type === "weekDay";
+    if (!shouldSkip) {
+      sectionFormats.push(section.format);
+      sectionValues.push(getSectionVisibleValue(section, "non-input"));
+    }
+  }
+  const formatWithoutSeparator = sectionFormats.join(" ");
+  const dateWithoutSeparatorStr = sectionValues.join(" ");
+  return utils.parse(dateWithoutSeparatorStr, formatWithoutSeparator);
+};
+const createDateStrForInputFromSections = (sections, isRTL) => {
+  const formattedSections = sections.map((section) => {
+    const dateValue = getSectionVisibleValue(section, isRTL ? "input-rtl" : "input-ltr");
+    return `${section.startSeparator}${dateValue}${section.endSeparator}`;
+  });
+  const dateStr = formattedSections.join("");
+  if (!isRTL) {
+    return dateStr;
+  }
+  return `⁦${dateStr}⁩`;
+};
+const getSectionsBoundaries = (utils, timezone) => {
+  const today = utils.dateWithTimezone(void 0, timezone);
+  const endOfYear = utils.endOfYear(today);
+  const endOfDay = utils.endOfDay(today);
+  const {
+    maxDaysInMonth,
+    longestMonth
+  } = getMonthsInYear(utils, today).reduce((acc, month) => {
+    const daysInMonth = utils.getDaysInMonth(month);
+    if (daysInMonth > acc.maxDaysInMonth) {
+      return {
+        maxDaysInMonth: daysInMonth,
+        longestMonth: month
+      };
+    }
+    return acc;
+  }, {
+    maxDaysInMonth: 0,
+    longestMonth: null
+  });
+  return {
+    year: ({
+      format
+    }) => ({
+      minimum: 0,
+      maximum: isFourDigitYearFormat(utils, timezone, format) ? 9999 : 99
+    }),
+    month: () => ({
+      minimum: 1,
+      // Assumption: All years have the same amount of months
+      maximum: utils.getMonth(endOfYear) + 1
+    }),
+    day: ({
+      currentDate
+    }) => ({
+      minimum: 1,
+      maximum: currentDate != null && utils.isValid(currentDate) ? utils.getDaysInMonth(currentDate) : maxDaysInMonth,
+      longestMonth
+    }),
+    weekDay: ({
+      format,
+      contentType
+    }) => {
+      if (contentType === "digit") {
+        const daysInWeek = getDaysInWeekStr(utils, timezone, format).map(Number);
+        return {
+          minimum: Math.min(...daysInWeek),
+          maximum: Math.max(...daysInWeek)
+        };
+      }
+      return {
+        minimum: 1,
+        maximum: 7
+      };
+    },
+    hours: ({
+      format
+    }) => {
+      const lastHourInDay = utils.getHours(endOfDay);
+      const hasMeridiem = utils.formatByString(utils.endOfDay(today), format) !== lastHourInDay.toString();
+      if (hasMeridiem) {
+        return {
+          minimum: 1,
+          maximum: Number(utils.formatByString(utils.startOfDay(today), format))
+        };
+      }
+      return {
+        minimum: 0,
+        maximum: lastHourInDay
+      };
+    },
+    minutes: () => ({
+      minimum: 0,
+      // Assumption: All years have the same amount of minutes
+      maximum: utils.getMinutes(endOfDay)
+    }),
+    seconds: () => ({
+      minimum: 0,
+      // Assumption: All years have the same amount of seconds
+      maximum: utils.getSeconds(endOfDay)
+    }),
+    meridiem: () => ({
+      minimum: 0,
+      maximum: 0
+    })
+  };
+};
+let warnedOnceInvalidSection = false;
+const validateSections = (sections, valueType) => {
+  if (define_process_env_default.NODE_ENV !== "production") {
+    if (!warnedOnceInvalidSection) {
+      const supportedSections = [];
+      if (["date", "date-time"].includes(valueType)) {
+        supportedSections.push("weekDay", "day", "month", "year");
+      }
+      if (["time", "date-time"].includes(valueType)) {
+        supportedSections.push("hours", "minutes", "seconds", "meridiem");
+      }
+      const invalidSection = sections.find((section) => !supportedSections.includes(section.type));
+      if (invalidSection) {
+        console.warn(`MUI: The field component you are using is not compatible with the "${invalidSection.type} date section.`, `The supported date sections are ["${supportedSections.join('", "')}"]\`.`);
+        warnedOnceInvalidSection = true;
+      }
+    }
+  }
+};
+const transferDateSectionValue = (utils, timezone, section, dateToTransferFrom, dateToTransferTo) => {
+  switch (section.type) {
+    case "year": {
+      return utils.setYear(dateToTransferTo, utils.getYear(dateToTransferFrom));
+    }
+    case "month": {
+      return utils.setMonth(dateToTransferTo, utils.getMonth(dateToTransferFrom));
+    }
+    case "weekDay": {
+      const formattedDaysInWeek = getDaysInWeekStr(utils, timezone, section.format);
+      const dayInWeekStrOfActiveDate = utils.formatByString(dateToTransferFrom, section.format);
+      const dayInWeekOfActiveDate = formattedDaysInWeek.indexOf(dayInWeekStrOfActiveDate);
+      const dayInWeekOfNewSectionValue = formattedDaysInWeek.indexOf(section.value);
+      const diff = dayInWeekOfNewSectionValue - dayInWeekOfActiveDate;
+      return utils.addDays(dateToTransferFrom, diff);
+    }
+    case "day": {
+      return utils.setDate(dateToTransferTo, utils.getDate(dateToTransferFrom));
+    }
+    case "meridiem": {
+      const isAM = utils.getHours(dateToTransferFrom) < 12;
+      const mergedDateHours = utils.getHours(dateToTransferTo);
+      if (isAM && mergedDateHours >= 12) {
+        return utils.addHours(dateToTransferTo, -12);
+      }
+      if (!isAM && mergedDateHours < 12) {
+        return utils.addHours(dateToTransferTo, 12);
+      }
+      return dateToTransferTo;
+    }
+    case "hours": {
+      return utils.setHours(dateToTransferTo, utils.getHours(dateToTransferFrom));
+    }
+    case "minutes": {
+      return utils.setMinutes(dateToTransferTo, utils.getMinutes(dateToTransferFrom));
+    }
+    case "seconds": {
+      return utils.setSeconds(dateToTransferTo, utils.getSeconds(dateToTransferFrom));
+    }
+    default: {
+      return dateToTransferTo;
+    }
+  }
+};
+const reliableSectionModificationOrder = {
+  year: 1,
+  month: 2,
+  day: 3,
+  weekDay: 4,
+  hours: 5,
+  minutes: 6,
+  seconds: 7,
+  meridiem: 8
+};
+const mergeDateIntoReferenceDate = (utils, timezone, dateToTransferFrom, sections, referenceDate, shouldLimitToEditedSections) => (
+  // cloning sections before sort to avoid mutating it
+  [...sections].sort((a, b) => reliableSectionModificationOrder[a.type] - reliableSectionModificationOrder[b.type]).reduce((mergedDate, section) => {
+    if (!shouldLimitToEditedSections || section.modified) {
+      return transferDateSectionValue(utils, timezone, section, dateToTransferFrom, mergedDate);
+    }
+    return mergedDate;
+  }, referenceDate)
+);
+const isAndroid = () => navigator.userAgent.toLowerCase().indexOf("android") > -1;
+const getSectionOrder = (sections, isRTL) => {
+  const neighbors = {};
+  if (!isRTL) {
+    sections.forEach((_, index) => {
+      const leftIndex = index === 0 ? null : index - 1;
+      const rightIndex = index === sections.length - 1 ? null : index + 1;
+      neighbors[index] = {
+        leftIndex,
+        rightIndex
+      };
+    });
+    return {
+      neighbors,
+      startIndex: 0,
+      endIndex: sections.length - 1
+    };
+  }
+  const rtl2ltr = {};
+  const ltr2rtl = {};
+  let groupedSectionsStart = 0;
+  let groupedSectionsEnd = 0;
+  let RTLIndex = sections.length - 1;
+  while (RTLIndex >= 0) {
+    groupedSectionsEnd = sections.findIndex(
+      // eslint-disable-next-line @typescript-eslint/no-loop-func
+      (section, index) => {
+        var _section$endSeparator;
+        return index >= groupedSectionsStart && ((_section$endSeparator = section.endSeparator) == null ? void 0 : _section$endSeparator.includes(" ")) && // Special case where the spaces were not there in the initial input
+        section.endSeparator !== " / ";
+      }
+    );
+    if (groupedSectionsEnd === -1) {
+      groupedSectionsEnd = sections.length - 1;
+    }
+    for (let i = groupedSectionsEnd; i >= groupedSectionsStart; i -= 1) {
+      ltr2rtl[i] = RTLIndex;
+      rtl2ltr[RTLIndex] = i;
+      RTLIndex -= 1;
+    }
+    groupedSectionsStart = groupedSectionsEnd + 1;
+  }
+  sections.forEach((_, index) => {
+    const rtlIndex = ltr2rtl[index];
+    const leftIndex = rtlIndex === 0 ? null : rtl2ltr[rtlIndex - 1];
+    const rightIndex = rtlIndex === sections.length - 1 ? null : rtl2ltr[rtlIndex + 1];
+    neighbors[index] = {
+      leftIndex,
+      rightIndex
+    };
+  });
+  return {
+    neighbors,
+    startIndex: rtl2ltr[0],
+    endIndex: rtl2ltr[sections.length - 1]
+  };
+};
+export {
+  addPositionPropertiesToSections,
+  adjustSectionValue,
+  changeSectionValueFormat,
+  cleanDigitSectionValue,
+  cleanLeadingZeros,
+  cleanString,
+  createDateStrForInputFromSections,
+  doesSectionFormatHaveLeadingZeros,
+  getDateFromDateSections,
+  getDateSectionConfigFromFormatToken,
+  getDaysInWeekStr,
+  getLetterEditingOptions,
+  getSectionOrder,
+  getSectionVisibleValue,
+  getSectionsBoundaries,
+  isAndroid,
+  mergeDateIntoReferenceDate,
+  splitFormatIntoSections,
+  validateSections
+};
+//# sourceMappingURL=index.esm.js.map