@economic/taco 2.60.1-date-fns.0 → 2.61.0

package/dist/taco.js

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import * as React from "react";
 import React__default, { createContext, useMemo, createElement, useContext, useCallback, useLayoutEffect, useRef, useEffect, useState, forwardRef, Children, isValidElement, cloneElement, Fragment, useReducer, memo as memo$2, PureComponent, useImperativeHandle, Component } from "react";
 import * as ReactDOM from "react-dom";
@@ -4543,7 +4546,7 @@ var zeroGap = {
   right: 0,
   gap: 0
 };
-var parse$2 = function(x2) {
+var parse$3 = function(x2) {
   return parseInt(x2 || "", 10) || 0;
 };
 var getOffset$1 = function(gapMode) {
@@ -4551,7 +4554,7 @@ var getOffset$1 = function(gapMode) {
   var left = cs[gapMode === "padding" ? "paddingLeft" : "marginLeft"];
   var top = cs[gapMode === "padding" ? "paddingTop" : "marginTop"];
   var right = cs[gapMode === "padding" ? "paddingRight" : "marginRight"];
-  return [parse$2(left), parse$2(top), parse$2(right)];
+  return [parse$3(left), parse$3(top), parse$3(right)];
 };
 var getGapWidth = function(gapMode) {
   if (gapMode === void 0) {
@@ -9752,7 +9755,7 @@ const useMergedRef = (ref) => {
   return internalRef;
 };
 const FOCUSABLE_ELEMENTS = [
-  "[tabindex]:not([disabled])",
+  '[tabindex]:not([tabindex="-1"]):not([disabled])',
   "input:not([disabled])",
   "select:not([disabled])",
   "textarea:not([disabled])",
@@ -9765,7 +9768,7 @@ const FOCUSABLE_ELEMENTS = [
   "embed",
   "audio[controls]",
   "video[controls]",
-  "[contenteditable]",
+  '[contenteditable]:not([contenteditable="false"]):not([disabled])',
   "details:not([disabled])",
   "summary:not(:disabled)"
 ];
@@ -9790,14 +9793,14 @@ const getIndexOfFirstChildOverflowingParent = (element, overscan = 0) => {
   }
   return boundaryChildIndex;
 };
-const getNextFocussableElement = (currentElement) => {
+const getNextFocussableElement = (currentElement, direction = 1) => {
   if (!currentElement) {
     return null;
   }
   let focussableElements = [...document.querySelectorAll(FOCUSABLE_ELEMENTS.join(","))];
   const currentElementIndex = focussableElements.indexOf(currentElement);
   if (currentElementIndex > -1) {
-    focussableElements = focussableElements.slice(currentElementIndex + 1).filter((element) => element.getAttribute("tabindex") !== "-1");
+    focussableElements = focussableElements.slice(currentElementIndex + direction).filter((element) => element.getAttribute("tabindex") !== "-1");
     if (focussableElements.length) {
       focussableElements = focussableElements.filter((element) => {
         var _a;
@@ -9846,6 +9849,9 @@ function isSiblingElementInsideSameParentOverlay(element, sibling) {
   var _a;
   return !!((_a = element == null ? void 0 : element.closest("[role=dialog],[role=menu]")) == null ? void 0 : _a.contains(sibling));
 }
+function isElementInsideExternalRelatedOverlay(element, tableRef) {
+  return isElementInsideOverlay(element) && !isSiblingElementInsideSameParentOverlay(element, tableRef.current) || isElementInteractive(element) && !isElementInsideOrTriggeredFromContainer(element, tableRef.current);
+}
 function isElementInteractive(element) {
   if (!element) {
     return false;
@@ -11868,13 +11874,16 @@ function addMonths(date2, amount) {
 }
 const millisecondsInWeek = 6048e5;
 const millisecondsInDay = 864e5;
+const millisecondsInMinute = 6e4;
+const millisecondsInHour = 36e5;
+const millisecondsInSecond = 1e3;
 let defaultOptions$3 = {};
-function getDefaultOptions() {
+function getDefaultOptions$1() {
   return defaultOptions$3;
 }
 function startOfWeek(date2, options) {
   var _a, _b, _c, _d;
-  const defaultOptions2 = getDefaultOptions();
+  const defaultOptions2 = getDefaultOptions$1();
   const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
   const _date = toDate(date2);
   const day = _date.getDay();
@@ -12018,7 +12027,7 @@ function startOfYear(date2) {
 }
 function endOfWeek(date2, options) {
   var _a, _b, _c, _d;
-  const defaultOptions2 = getDefaultOptions();
+  const defaultOptions2 = getDefaultOptions$1();
   const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
   const _date = toDate(date2);
   const day = _date.getDay();
@@ -12534,7 +12543,7 @@ function getWeekYear(date2, options) {
   var _a, _b, _c, _d;
   const _date = toDate(date2);
   const year = _date.getFullYear();
-  const defaultOptions2 = getDefaultOptions();
+  const defaultOptions2 = getDefaultOptions$1();
   const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
   const firstWeekOfNextYear = constructFrom(date2, 0);
   firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
@@ -12554,7 +12563,7 @@ function getWeekYear(date2, options) {
 }
 function startOfWeekYear(date2, options) {
   var _a, _b, _c, _d;
-  const defaultOptions2 = getDefaultOptions();
+  const defaultOptions2 = getDefaultOptions$1();
   const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
   const year = getWeekYear(date2, options);
   const firstWeek = constructFrom(date2, 0);
@@ -13236,222 +13245,1977 @@ const formatters$1 = {
       // Long
       case "zzzz":
       default:
-        return "GMT" + formatTimezone(timezoneOffset, ":");
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+  // Seconds timestamp
+  t: function(date2, token, _localize) {
+    const timestamp = Math.trunc(date2.getTime() / 1e3);
+    return addLeadingZeros(timestamp, token.length);
+  },
+  // Milliseconds timestamp
+  T: function(date2, token, _localize) {
+    const timestamp = date2.getTime();
+    return addLeadingZeros(timestamp, token.length);
+  }
+};
+function formatTimezoneShort(offset2, delimiter = "") {
+  const sign2 = offset2 > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset2);
+  const hours = Math.trunc(absOffset / 60);
+  const minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign2 + String(hours);
+  }
+  return sign2 + String(hours) + delimiter + addLeadingZeros(minutes, 2);
+}
+function formatTimezoneWithOptionalMinutes(offset2, delimiter) {
+  if (offset2 % 60 === 0) {
+    const sign2 = offset2 > 0 ? "-" : "+";
+    return sign2 + addLeadingZeros(Math.abs(offset2) / 60, 2);
+  }
+  return formatTimezone(offset2, delimiter);
+}
+function formatTimezone(offset2, delimiter = "") {
+  const sign2 = offset2 > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset2);
+  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
+  const minutes = addLeadingZeros(absOffset % 60, 2);
+  return sign2 + hours + delimiter + minutes;
+}
+const dateLongFormatter = (pattern, formatLong2) => {
+  switch (pattern) {
+    case "P":
+      return formatLong2.date({ width: "short" });
+    case "PP":
+      return formatLong2.date({ width: "medium" });
+    case "PPP":
+      return formatLong2.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong2.date({ width: "full" });
+  }
+};
+const timeLongFormatter = (pattern, formatLong2) => {
+  switch (pattern) {
+    case "p":
+      return formatLong2.time({ width: "short" });
+    case "pp":
+      return formatLong2.time({ width: "medium" });
+    case "ppp":
+      return formatLong2.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong2.time({ width: "full" });
+  }
+};
+const dateTimeLongFormatter = (pattern, formatLong2) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong2);
+  }
+  let dateTimeFormat;
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong2.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong2.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong2.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong2.dateTime({ width: "full" });
+      break;
+  }
+  return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
+};
+const longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter
+};
+const dayOfYearTokenRE = /^D+$/;
+const weekYearTokenRE = /^Y+$/;
+const throwTokens = ["D", "DD", "YY", "YYYY"];
+function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+function warnOrThrowProtectedError(token, format2, input) {
+  const _message = message(token, format2, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+function message(token, format2, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format2}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+const formattingTokensRegExp$1 = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
+const longFormattingTokensRegExp$1 = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+const escapedStringRegExp$1 = /^'([^]*?)'?$/;
+const doubleQuoteRegExp$1 = /''/g;
+const unescapedLatinCharacterRegExp$1 = /[a-zA-Z]/;
+function format$2(date2, formatStr, options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const defaultOptions2 = getDefaultOptions$1();
+  const locale2 = (options == null ? void 0 : options.locale) ?? defaultOptions2.locale ?? enUS;
+  const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
+  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_f = (_e = options == null ? void 0 : options.locale) == null ? void 0 : _e.options) == null ? void 0 : _f.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_h = (_g = defaultOptions2.locale) == null ? void 0 : _g.options) == null ? void 0 : _h.weekStartsOn) ?? 0;
+  const originalDate = toDate(date2);
+  if (!isValid(originalDate)) {
+    throw new RangeError("Invalid time value");
+  }
+  let parts = formatStr.match(longFormattingTokensRegExp$1).map((substring) => {
+    const firstCharacter = substring[0];
+    if (firstCharacter === "p" || firstCharacter === "P") {
+      const longFormatter = longFormatters[firstCharacter];
+      return longFormatter(substring, locale2.formatLong);
+    }
+    return substring;
+  }).join("").match(formattingTokensRegExp$1).map((substring) => {
+    if (substring === "''") {
+      return { isToken: false, value: "'" };
+    }
+    const firstCharacter = substring[0];
+    if (firstCharacter === "'") {
+      return { isToken: false, value: cleanEscapedString$1(substring) };
+    }
+    if (formatters$1[firstCharacter]) {
+      return { isToken: true, value: substring };
+    }
+    if (firstCharacter.match(unescapedLatinCharacterRegExp$1)) {
+      throw new RangeError(
+        "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
+      );
+    }
+    return { isToken: false, value: substring };
+  });
+  if (locale2.localize.preprocessor) {
+    parts = locale2.localize.preprocessor(originalDate, parts);
+  }
+  const formatterOptions = {
+    firstWeekContainsDate,
+    weekStartsOn,
+    locale: locale2
+  };
+  return parts.map((part) => {
+    if (!part.isToken) return part.value;
+    const token = part.value;
+    if (!(options == null ? void 0 : options.useAdditionalWeekYearTokens) && isProtectedWeekYearToken(token) || !(options == null ? void 0 : options.useAdditionalDayOfYearTokens) && isProtectedDayOfYearToken(token)) {
+      warnOrThrowProtectedError(token, formatStr, String(date2));
+    }
+    const formatter = formatters$1[token[0]];
+    return formatter(originalDate, token, locale2.localize, formatterOptions);
+  }).join("");
+}
+function cleanEscapedString$1(input) {
+  const matched = input.match(escapedStringRegExp$1);
+  if (!matched) {
+    return input;
+  }
+  return matched[1].replace(doubleQuoteRegExp$1, "'");
+}
+function getDaysInMonth(date2) {
+  const _date = toDate(date2);
+  const year = _date.getFullYear();
+  const monthIndex = _date.getMonth();
+  const lastDayOfMonth2 = constructFrom(date2, 0);
+  lastDayOfMonth2.setFullYear(year, monthIndex + 1, 0);
+  lastDayOfMonth2.setHours(0, 0, 0, 0);
+  return lastDayOfMonth2.getDate();
+}
+function getDefaultOptions() {
+  return Object.assign({}, getDefaultOptions$1());
+}
+function getISODay(date2) {
+  const _date = toDate(date2);
+  let day = _date.getDay();
+  if (day === 0) {
+    day = 7;
+  }
+  return day;
+}
+function getUnixTime(date2) {
+  return Math.trunc(+toDate(date2) / 1e3);
+}
+function lastDayOfMonth(date2) {
+  const _date = toDate(date2);
+  const month = _date.getMonth();
+  _date.setFullYear(_date.getFullYear(), month + 1, 0);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function getWeeksInMonth(date2, options) {
+  return differenceInCalendarWeeks(
+    lastDayOfMonth(date2),
+    startOfMonth(date2),
+    options
+  ) + 1;
+}
+function isAfter(date2, dateToCompare) {
+  const _date = toDate(date2);
+  const _dateToCompare = toDate(dateToCompare);
+  return _date.getTime() > _dateToCompare.getTime();
+}
+function isBefore(date2, dateToCompare) {
+  const _date = toDate(date2);
+  const _dateToCompare = toDate(dateToCompare);
+  return +_date < +_dateToCompare;
+}
+function transpose(fromDate, constructor) {
+  const date2 = constructor instanceof Date ? constructFrom(constructor, 0) : new constructor(0);
+  date2.setFullYear(
+    fromDate.getFullYear(),
+    fromDate.getMonth(),
+    fromDate.getDate()
+  );
+  date2.setHours(
+    fromDate.getHours(),
+    fromDate.getMinutes(),
+    fromDate.getSeconds(),
+    fromDate.getMilliseconds()
+  );
+  return date2;
+}
+const TIMEZONE_UNIT_PRIORITY = 10;
+class Setter {
+  constructor() {
+    __publicField(this, "subPriority", 0);
+  }
+  validate(_utcDate, _options) {
+    return true;
+  }
+}
+class ValueSetter extends Setter {
+  constructor(value, validateValue, setValue, priority, subPriority) {
+    super();
+    this.value = value;
+    this.validateValue = validateValue;
+    this.setValue = setValue;
+    this.priority = priority;
+    if (subPriority) {
+      this.subPriority = subPriority;
+    }
+  }
+  validate(date2, options) {
+    return this.validateValue(date2, this.value, options);
+  }
+  set(date2, flags, options) {
+    return this.setValue(date2, flags, this.value, options);
+  }
+}
+class DateToSystemTimezoneSetter extends Setter {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", TIMEZONE_UNIT_PRIORITY);
+    __publicField(this, "subPriority", -1);
+  }
+  set(date2, flags) {
+    if (flags.timestampIsSet) return date2;
+    return constructFrom(date2, transpose(date2, Date));
+  }
+}
+class Parser {
+  run(dateString, token, match2, options) {
+    const result = this.parse(dateString, token, match2, options);
+    if (!result) {
+      return null;
+    }
+    return {
+      setter: new ValueSetter(
+        result.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: result.rest
+    };
+  }
+  validate(_utcDate, _value, _options) {
+    return true;
+  }
+}
+class EraParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 140);
+    __publicField(this, "incompatibleTokens", ["R", "u", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return match2.era(dateString, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return match2.era(dateString, { width: "wide" }) || match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
+    }
+  }
+  set(date2, flags, value) {
+    flags.era = value;
+    date2.setFullYear(value, 0, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+const numericPatterns = {
+  month: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/,
+  // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
+  // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/,
+  // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/,
+  // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/,
+  // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/,
+  // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  minute: /^[0-5]?\d/,
+  // 0 to 59
+  second: /^[0-5]?\d/,
+  // 0 to 59
+  singleDigit: /^\d/,
+  // 0 to 9
+  twoDigits: /^\d{1,2}/,
+  // 0 to 99
+  threeDigits: /^\d{1,3}/,
+  // 0 to 999
+  fourDigits: /^\d{1,4}/,
+  // 0 to 9999
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/,
+  // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/,
+  // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/,
+  // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/
+  // 0 to 9999, -0 to -9999
+};
+const timezonePatterns = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
+};
+function mapValue(parseFnResult, mapFn) {
+  if (!parseFnResult) {
+    return parseFnResult;
+  }
+  return {
+    value: mapFn(parseFnResult.value),
+    rest: parseFnResult.rest
+  };
+}
+function parseNumericPattern(pattern, dateString) {
+  const matchResult = dateString.match(pattern);
+  if (!matchResult) {
+    return null;
+  }
+  return {
+    value: parseInt(matchResult[0], 10),
+    rest: dateString.slice(matchResult[0].length)
+  };
+}
+function parseTimezonePattern(pattern, dateString) {
+  const matchResult = dateString.match(pattern);
+  if (!matchResult) {
+    return null;
+  }
+  if (matchResult[0] === "Z") {
+    return {
+      value: 0,
+      rest: dateString.slice(1)
+    };
+  }
+  const sign2 = matchResult[1] === "+" ? 1 : -1;
+  const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
+  const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
+  const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
+  return {
+    value: sign2 * (hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
+    rest: dateString.slice(matchResult[0].length)
+  };
+}
+function parseAnyDigitsSigned(dateString) {
+  return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
+}
+function parseNDigits(n2, dateString) {
+  switch (n2) {
+    case 1:
+      return parseNumericPattern(numericPatterns.singleDigit, dateString);
+    case 2:
+      return parseNumericPattern(numericPatterns.twoDigits, dateString);
+    case 3:
+      return parseNumericPattern(numericPatterns.threeDigits, dateString);
+    case 4:
+      return parseNumericPattern(numericPatterns.fourDigits, dateString);
+    default:
+      return parseNumericPattern(new RegExp("^\\d{1," + n2 + "}"), dateString);
+  }
+}
+function parseNDigitsSigned(n2, dateString) {
+  switch (n2) {
+    case 1:
+      return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
+    case 2:
+      return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
+    case 3:
+      return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
+    case 4:
+      return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
+    default:
+      return parseNumericPattern(new RegExp("^-?\\d{1," + n2 + "}"), dateString);
+  }
+}
+function dayPeriodEnumToHours(dayPeriod) {
+  switch (dayPeriod) {
+    case "morning":
+      return 4;
+    case "evening":
+      return 17;
+    case "pm":
+    case "noon":
+    case "afternoon":
+      return 12;
+    case "am":
+    case "midnight":
+    case "night":
+    default:
+      return 0;
+  }
+}
+function normalizeTwoDigitYear(twoDigitYear, currentYear) {
+  const isCommonEra = currentYear > 0;
+  const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
+  let result;
+  if (absCurrentYear <= 50) {
+    result = twoDigitYear || 100;
+  } else {
+    const rangeEnd = absCurrentYear + 50;
+    const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
+    const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
+    result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
+  }
+  return isCommonEra ? result : 1 - result;
+}
+function isLeapYearIndex$1(year) {
+  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+class YearParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "yy"
+    });
+    switch (token) {
+      case "y":
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+      case "yo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "year"
+          }),
+          valueCallback
+        );
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+  set(date2, flags, value) {
+    const currentYear = date2.getFullYear();
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(
+        value.year,
+        currentYear
+      );
+      date2.setFullYear(normalizedTwoDigitYear, 0, 1);
+      date2.setHours(0, 0, 0, 0);
+      return date2;
+    }
+    const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date2.setFullYear(year, 0, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class LocalWeekYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "Q",
+      "q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "i",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "YY"
+    });
+    switch (token) {
+      case "Y":
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+      case "Yo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "year"
+          }),
+          valueCallback
+        );
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+  set(date2, flags, value, options) {
+    const currentYear = getWeekYear(date2, options);
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(
+        value.year,
+        currentYear
+      );
+      date2.setFullYear(
+        normalizedTwoDigitYear,
+        0,
+        options.firstWeekContainsDate
+      );
+      date2.setHours(0, 0, 0, 0);
+      return startOfWeek(date2, options);
+    }
+    const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date2.setFullYear(year, 0, options.firstWeekContainsDate);
+    date2.setHours(0, 0, 0, 0);
+    return startOfWeek(date2, options);
+  }
+}
+class ISOWeekYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", [
+      "G",
+      "y",
+      "Y",
+      "u",
+      "Q",
+      "q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token) {
+    if (token === "R") {
+      return parseNDigitsSigned(4, dateString);
+    }
+    return parseNDigitsSigned(token.length, dateString);
+  }
+  set(date2, _flags, value) {
+    const firstWeekOfYear = constructFrom(date2, 0);
+    firstWeekOfYear.setFullYear(value, 0, 4);
+    firstWeekOfYear.setHours(0, 0, 0, 0);
+    return startOfISOWeek(firstWeekOfYear);
+  }
+}
+class ExtendedYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"]);
+  }
+  parse(dateString, token) {
+    if (token === "u") {
+      return parseNDigitsSigned(4, dateString);
+    }
+    return parseNDigitsSigned(token.length, dateString);
+  }
+  set(date2, _flags, value) {
+    date2.setFullYear(value, 0, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class QuarterParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 120);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return match2.ordinalNumber(dateString, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return match2.quarter(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return match2.quarter(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+  set(date2, _flags, value) {
+    date2.setMonth((value - 1) * 3, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class StandAloneQuarterParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 120);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return match2.ordinalNumber(dateString, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return match2.quarter(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return match2.quarter(dateString, {
+          width: "wide",
+          context: "standalone"
+        }) || match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+  set(date2, _flags, value) {
+    date2.setMonth((value - 1) * 3, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class MonthParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "L",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+    __publicField(this, "priority", 110);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (value) => value - 1;
+    switch (token) {
+      // 1, 2, ..., 12
+      case "M":
+        return mapValue(
+          parseNumericPattern(numericPatterns.month, dateString),
+          valueCallback
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "month"
+          }),
+          valueCallback
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return match2.month(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.month(dateString, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return match2.month(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return match2.month(dateString, { width: "wide", context: "formatting" }) || match2.month(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.month(dateString, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+  set(date2, _flags, value) {
+    date2.setMonth(value, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class StandAloneMonthParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 110);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (value) => value - 1;
+    switch (token) {
+      // 1, 2, ..., 12
+      case "L":
+        return mapValue(
+          parseNumericPattern(numericPatterns.month, dateString),
+          valueCallback
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "month"
+          }),
+          valueCallback
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return match2.month(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.month(dateString, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return match2.month(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return match2.month(dateString, { width: "wide", context: "standalone" }) || match2.month(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.month(dateString, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+  set(date2, _flags, value) {
+    date2.setMonth(value, 1);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+function setWeek(date2, week, options) {
+  const _date = toDate(date2);
+  const diff = getWeek(_date, options) - week;
+  _date.setDate(_date.getDate() - diff * 7);
+  return _date;
+}
+class LocalWeekParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 100);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "i",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "w":
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case "wo":
+        return match2.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+  set(date2, _flags, value, options) {
+    return startOfWeek(setWeek(date2, value, options), options);
+  }
+}
+function setISOWeek(date2, week) {
+  const _date = toDate(date2);
+  const diff = getISOWeek(_date) - week;
+  _date.setDate(_date.getDate() - diff * 7);
+  return _date;
+}
+class ISOWeekParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 100);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "Y",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "I":
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case "Io":
+        return match2.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+  set(date2, _flags, value) {
+    return startOfISOWeek(setISOWeek(date2, value));
+  }
+}
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DAYS_IN_MONTH_LEAP_YEAR = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class DateParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "subPriority", 1);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "d":
+        return parseNumericPattern(numericPatterns.date, dateString);
+      case "do":
+        return match2.ordinalNumber(dateString, { unit: "date" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(date2, value) {
+    const year = date2.getFullYear();
+    const isLeapYear = isLeapYearIndex$1(year);
+    const month = date2.getMonth();
+    if (isLeapYear) {
+      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+    } else {
+      return value >= 1 && value <= DAYS_IN_MONTH[month];
+    }
+  }
+  set(date2, _flags, value) {
+    date2.setDate(value);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class DayOfYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "subpriority", 1);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "E",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "D":
+      case "DD":
+        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
+      case "Do":
+        return match2.ordinalNumber(dateString, { unit: "date" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(date2, value) {
+    const year = date2.getFullYear();
+    const isLeapYear = isLeapYearIndex$1(year);
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+  set(date2, _flags, value) {
+    date2.setMonth(0, value);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+function setDay(date2, day, options) {
+  var _a, _b, _c, _d;
+  const defaultOptions2 = getDefaultOptions$1();
+  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
+  const _date = toDate(date2);
+  const currentDay = _date.getDay();
+  const remainder = day % 7;
+  const dayIndex = (remainder + 7) % 7;
+  const delta = 7 - weekStartsOn;
+  const diff = day < 0 || day > 6 ? day - (currentDay + delta) % 7 : (dayIndex + delta) % 7 - (currentDay + delta) % 7;
+  return addDays(_date, diff);
+}
+class DayParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", ["D", "i", "e", "c", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return match2.day(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "EEEE":
+      default:
+        return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+  set(date2, _flags, value, options) {
+    date2 = setDay(date2, value, options);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class LocalDayParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "E",
+      "i",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2, options) {
+    const valueCallback = (value) => {
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
+    };
+    switch (token) {
+      // 3
+      case "e":
+      case "ee":
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+      case "eo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "day"
+          }),
+          valueCallback
+        );
+      // Tue
+      case "eee":
+        return match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return match2.day(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "eeee":
+      default:
+        return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+  set(date2, _flags, value, options) {
+    date2 = setDay(date2, value, options);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class StandAloneLocalDayParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "E",
+      "i",
+      "e",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2, options) {
+    const valueCallback = (value) => {
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
+    };
+    switch (token) {
+      // 3
+      case "c":
+      case "cc":
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+      case "co":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "day"
+          }),
+          valueCallback
+        );
+      // Tue
+      case "ccc":
+        return match2.day(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
+      // T
+      case "ccccc":
+        return match2.day(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
+      // Tuesday
+      case "cccc":
+      default:
+        return match2.day(dateString, { width: "wide", context: "standalone" }) || match2.day(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+  set(date2, _flags, value, options) {
+    date2 = setDay(date2, value, options);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+function setISODay(date2, day) {
+  const _date = toDate(date2);
+  const currentDay = getISODay(_date);
+  const diff = day - currentDay;
+  return addDays(_date, diff);
+}
+class ISODayParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "Y",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "E",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (value) => {
+      if (value === 0) {
+        return 7;
+      }
+      return value;
+    };
+    switch (token) {
+      // 2
+      case "i":
+      case "ii":
+        return parseNDigits(token.length, dateString);
+      // 2nd
+      case "io":
+        return match2.ordinalNumber(dateString, { unit: "day" });
+      // Tue
+      case "iii":
+        return mapValue(
+          match2.day(dateString, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "short",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+      // T
+      case "iiiii":
+        return mapValue(
+          match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+      // Tu
+      case "iiiiii":
+        return mapValue(
+          match2.day(dateString, {
+            width: "short",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+      // Tuesday
+      case "iiii":
+      default:
+        return mapValue(
+          match2.day(dateString, {
+            width: "wide",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "short",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 7;
+  }
+  set(date2, _flags, value) {
+    date2 = setISODay(date2, value);
+    date2.setHours(0, 0, 0, 0);
+    return date2;
+  }
+}
+class AMPMParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 80);
+    __publicField(this, "incompatibleTokens", ["b", "B", "H", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return match2.dayPeriod(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(date2, _flags, value) {
+    date2.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date2;
+  }
+}
+class AMPMMidnightParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 80);
+    __publicField(this, "incompatibleTokens", ["a", "B", "H", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return match2.dayPeriod(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(date2, _flags, value) {
+    date2.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date2;
+  }
+}
+class DayPeriodParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 80);
+    __publicField(this, "incompatibleTokens", ["a", "b", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return match2.dayPeriod(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(date2, _flags, value) {
+    date2.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date2;
+  }
+}
+class Hour1to12Parser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["H", "K", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "h":
+        return parseNumericPattern(numericPatterns.hour12h, dateString);
+      case "ho":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 12;
+  }
+  set(date2, _flags, value) {
+    const isPM = date2.getHours() >= 12;
+    if (isPM && value < 12) {
+      date2.setHours(value + 12, 0, 0, 0);
+    } else if (!isPM && value === 12) {
+      date2.setHours(0, 0, 0, 0);
+    } else {
+      date2.setHours(value, 0, 0, 0);
+    }
+    return date2;
+  }
+}
+class Hour0to23Parser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["a", "b", "h", "K", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "H":
+        return parseNumericPattern(numericPatterns.hour23h, dateString);
+      case "Ho":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 23;
+  }
+  set(date2, _flags, value) {
+    date2.setHours(value, 0, 0, 0);
+    return date2;
+  }
+}
+class Hour0To11Parser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["h", "H", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "K":
+        return parseNumericPattern(numericPatterns.hour11h, dateString);
+      case "Ko":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+  set(date2, _flags, value) {
+    const isPM = date2.getHours() >= 12;
+    if (isPM && value < 12) {
+      date2.setHours(value + 12, 0, 0, 0);
+    } else {
+      date2.setHours(value, 0, 0, 0);
+    }
+    return date2;
+  }
+}
+class Hour1To24Parser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["a", "b", "h", "H", "K", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "k":
+        return parseNumericPattern(numericPatterns.hour24h, dateString);
+      case "ko":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 24;
+  }
+  set(date2, _flags, value) {
+    const hours = value <= 24 ? value % 24 : value;
+    date2.setHours(hours, 0, 0, 0);
+    return date2;
+  }
+}
+class MinuteParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 60);
+    __publicField(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "m":
+        return parseNumericPattern(numericPatterns.minute, dateString);
+      case "mo":
+        return match2.ordinalNumber(dateString, { unit: "minute" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+  set(date2, _flags, value) {
+    date2.setMinutes(value, 0, 0);
+    return date2;
+  }
+}
+class SecondParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 50);
+    __publicField(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "s":
+        return parseNumericPattern(numericPatterns.second, dateString);
+      case "so":
+        return match2.ordinalNumber(dateString, { unit: "second" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+  set(date2, _flags, value) {
+    date2.setSeconds(value, 0);
+    return date2;
+  }
+}
+class FractionOfSecondParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 30);
+    __publicField(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(dateString, token) {
+    const valueCallback = (value) => Math.trunc(value * Math.pow(10, -token.length + 3));
+    return mapValue(parseNDigits(token.length, dateString), valueCallback);
+  }
+  set(date2, _flags, value) {
+    date2.setMilliseconds(value);
+    return date2;
+  }
+}
+class ISOTimezoneWithZParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 10);
+    __publicField(this, "incompatibleTokens", ["t", "T", "x"]);
+  }
+  parse(dateString, token) {
+    switch (token) {
+      case "X":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalMinutes,
+          dateString
+        );
+      case "XX":
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+      case "XXXX":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalSeconds,
+          dateString
+        );
+      case "XXXXX":
+        return parseTimezonePattern(
+          timezonePatterns.extendedOptionalSeconds,
+          dateString
+        );
+      case "XXX":
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
     }
-  },
-  // Seconds timestamp
-  t: function(date2, token, _localize) {
-    const timestamp = Math.trunc(date2.getTime() / 1e3);
-    return addLeadingZeros(timestamp, token.length);
-  },
-  // Milliseconds timestamp
-  T: function(date2, token, _localize) {
-    const timestamp = date2.getTime();
-    return addLeadingZeros(timestamp, token.length);
   }
-};
-function formatTimezoneShort(offset2, delimiter = "") {
-  const sign2 = offset2 > 0 ? "-" : "+";
-  const absOffset = Math.abs(offset2);
-  const hours = Math.trunc(absOffset / 60);
-  const minutes = absOffset % 60;
-  if (minutes === 0) {
-    return sign2 + String(hours);
+  set(date2, flags, value) {
+    if (flags.timestampIsSet) return date2;
+    return constructFrom(
+      date2,
+      date2.getTime() - getTimezoneOffsetInMilliseconds(date2) - value
+    );
   }
-  return sign2 + String(hours) + delimiter + addLeadingZeros(minutes, 2);
 }
-function formatTimezoneWithOptionalMinutes(offset2, delimiter) {
-  if (offset2 % 60 === 0) {
-    const sign2 = offset2 > 0 ? "-" : "+";
-    return sign2 + addLeadingZeros(Math.abs(offset2) / 60, 2);
+class ISOTimezoneParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 10);
+    __publicField(this, "incompatibleTokens", ["t", "T", "X"]);
   }
-  return formatTimezone(offset2, delimiter);
-}
-function formatTimezone(offset2, delimiter = "") {
-  const sign2 = offset2 > 0 ? "-" : "+";
-  const absOffset = Math.abs(offset2);
-  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
-  const minutes = addLeadingZeros(absOffset % 60, 2);
-  return sign2 + hours + delimiter + minutes;
-}
-const dateLongFormatter = (pattern, formatLong2) => {
-  switch (pattern) {
-    case "P":
-      return formatLong2.date({ width: "short" });
-    case "PP":
-      return formatLong2.date({ width: "medium" });
-    case "PPP":
-      return formatLong2.date({ width: "long" });
-    case "PPPP":
-    default:
-      return formatLong2.date({ width: "full" });
+  parse(dateString, token) {
+    switch (token) {
+      case "x":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalMinutes,
+          dateString
+        );
+      case "xx":
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+      case "xxxx":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalSeconds,
+          dateString
+        );
+      case "xxxxx":
+        return parseTimezonePattern(
+          timezonePatterns.extendedOptionalSeconds,
+          dateString
+        );
+      case "xxx":
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
   }
-};
-const timeLongFormatter = (pattern, formatLong2) => {
-  switch (pattern) {
-    case "p":
-      return formatLong2.time({ width: "short" });
-    case "pp":
-      return formatLong2.time({ width: "medium" });
-    case "ppp":
-      return formatLong2.time({ width: "long" });
-    case "pppp":
-    default:
-      return formatLong2.time({ width: "full" });
+  set(date2, flags, value) {
+    if (flags.timestampIsSet) return date2;
+    return constructFrom(
+      date2,
+      date2.getTime() - getTimezoneOffsetInMilliseconds(date2) - value
+    );
   }
-};
-const dateTimeLongFormatter = (pattern, formatLong2) => {
-  const matchResult = pattern.match(/(P+)(p+)?/) || [];
-  const datePattern = matchResult[1];
-  const timePattern = matchResult[2];
-  if (!timePattern) {
-    return dateLongFormatter(pattern, formatLong2);
+}
+class TimestampSecondsParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 40);
+    __publicField(this, "incompatibleTokens", "*");
   }
-  let dateTimeFormat;
-  switch (datePattern) {
-    case "P":
-      dateTimeFormat = formatLong2.dateTime({ width: "short" });
-      break;
-    case "PP":
-      dateTimeFormat = formatLong2.dateTime({ width: "medium" });
-      break;
-    case "PPP":
-      dateTimeFormat = formatLong2.dateTime({ width: "long" });
-      break;
-    case "PPPP":
-    default:
-      dateTimeFormat = formatLong2.dateTime({ width: "full" });
-      break;
+  parse(dateString) {
+    return parseAnyDigitsSigned(dateString);
+  }
+  set(date2, _flags, value) {
+    return [constructFrom(date2, value * 1e3), { timestampIsSet: true }];
   }
-  return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
-};
-const longFormatters = {
-  p: timeLongFormatter,
-  P: dateTimeLongFormatter
-};
-const dayOfYearTokenRE = /^D+$/;
-const weekYearTokenRE = /^Y+$/;
-const throwTokens = ["D", "DD", "YY", "YYYY"];
-function isProtectedDayOfYearToken(token) {
-  return dayOfYearTokenRE.test(token);
-}
-function isProtectedWeekYearToken(token) {
-  return weekYearTokenRE.test(token);
-}
-function warnOrThrowProtectedError(token, format2, input) {
-  const _message = message(token, format2, input);
-  console.warn(_message);
-  if (throwTokens.includes(token)) throw new RangeError(_message);
-}
-function message(token, format2, input) {
-  const subject = token[0] === "Y" ? "years" : "days of the month";
-  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format2}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
 }
+class TimestampMillisecondsParser extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 20);
+    __publicField(this, "incompatibleTokens", "*");
+  }
+  parse(dateString) {
+    return parseAnyDigitsSigned(dateString);
+  }
+  set(date2, _flags, value) {
+    return [constructFrom(date2, value), { timestampIsSet: true }];
+  }
+}
+const parsers = {
+  G: new EraParser(),
+  y: new YearParser(),
+  Y: new LocalWeekYearParser(),
+  R: new ISOWeekYearParser(),
+  u: new ExtendedYearParser(),
+  Q: new QuarterParser(),
+  q: new StandAloneQuarterParser(),
+  M: new MonthParser(),
+  L: new StandAloneMonthParser(),
+  w: new LocalWeekParser(),
+  I: new ISOWeekParser(),
+  d: new DateParser(),
+  D: new DayOfYearParser(),
+  E: new DayParser(),
+  e: new LocalDayParser(),
+  c: new StandAloneLocalDayParser(),
+  i: new ISODayParser(),
+  a: new AMPMParser(),
+  b: new AMPMMidnightParser(),
+  B: new DayPeriodParser(),
+  h: new Hour1to12Parser(),
+  H: new Hour0to23Parser(),
+  K: new Hour0To11Parser(),
+  k: new Hour1To24Parser(),
+  m: new MinuteParser(),
+  s: new SecondParser(),
+  S: new FractionOfSecondParser(),
+  X: new ISOTimezoneWithZParser(),
+  x: new ISOTimezoneParser(),
+  t: new TimestampSecondsParser(),
+  T: new TimestampMillisecondsParser()
+};
 const formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
 const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
 const escapedStringRegExp = /^'([^]*?)'?$/;
 const doubleQuoteRegExp = /''/g;
+const notWhitespaceRegExp = /\S/;
 const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
-function format$2(date2, formatStr, options) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+function parse$2(dateStr, formatStr, referenceDate, options) {
+  var _a, _b, _c, _d;
   const defaultOptions2 = getDefaultOptions();
-  const locale2 = (options == null ? void 0 : options.locale) ?? defaultOptions2.locale ?? enUS;
-  const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
-  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_f = (_e = options == null ? void 0 : options.locale) == null ? void 0 : _e.options) == null ? void 0 : _f.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_h = (_g = defaultOptions2.locale) == null ? void 0 : _g.options) == null ? void 0 : _h.weekStartsOn) ?? 0;
-  const originalDate = toDate(date2);
-  if (!isValid(originalDate)) {
-    throw new RangeError("Invalid time value");
+  const locale2 = defaultOptions2.locale ?? enUS;
+  const firstWeekContainsDate = defaultOptions2.firstWeekContainsDate ?? ((_b = (_a = defaultOptions2.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.firstWeekContainsDate) ?? 1;
+  const weekStartsOn = defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
+  if (formatStr === "") {
+    if (dateStr === "") {
+      return toDate(referenceDate);
+    } else {
+      return constructFrom(referenceDate, NaN);
+    }
   }
-  let parts = formatStr.match(longFormattingTokensRegExp).map((substring) => {
+  const subFnOptions = {
+    firstWeekContainsDate,
+    weekStartsOn,
+    locale: locale2
+  };
+  const setters = [new DateToSystemTimezoneSetter()];
+  const tokens = formatStr.match(longFormattingTokensRegExp).map((substring) => {
     const firstCharacter = substring[0];
-    if (firstCharacter === "p" || firstCharacter === "P") {
+    if (firstCharacter in longFormatters) {
       const longFormatter = longFormatters[firstCharacter];
       return longFormatter(substring, locale2.formatLong);
     }
     return substring;
-  }).join("").match(formattingTokensRegExp).map((substring) => {
-    if (substring === "''") {
-      return { isToken: false, value: "'" };
-    }
-    const firstCharacter = substring[0];
-    if (firstCharacter === "'") {
-      return { isToken: false, value: cleanEscapedString(substring) };
-    }
-    if (formatters$1[firstCharacter]) {
-      return { isToken: true, value: substring };
-    }
-    if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
-      throw new RangeError(
-        "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
+  }).join("").match(formattingTokensRegExp);
+  const usedTokens = [];
+  for (let token of tokens) {
+    if (isProtectedWeekYearToken(token)) {
+      warnOrThrowProtectedError(token, formatStr, dateStr);
+    }
+    if (isProtectedDayOfYearToken(token)) {
+      warnOrThrowProtectedError(token, formatStr, dateStr);
+    }
+    const firstCharacter = token[0];
+    const parser = parsers[firstCharacter];
+    if (parser) {
+      const { incompatibleTokens } = parser;
+      if (Array.isArray(incompatibleTokens)) {
+        const incompatibleToken = usedTokens.find(
+          (usedToken) => incompatibleTokens.includes(usedToken.token) || usedToken.token === firstCharacter
+        );
+        if (incompatibleToken) {
+          throw new RangeError(
+            `The format string mustn't contain \`${incompatibleToken.fullToken}\` and \`${token}\` at the same time`
+          );
+        }
+      } else if (parser.incompatibleTokens === "*" && usedTokens.length > 0) {
+        throw new RangeError(
+          `The format string mustn't contain \`${token}\` and any other token at the same time`
+        );
+      }
+      usedTokens.push({ token: firstCharacter, fullToken: token });
+      const parseResult = parser.run(
+        dateStr,
+        token,
+        locale2.match,
+        subFnOptions
       );
+      if (!parseResult) {
+        return constructFrom(referenceDate, NaN);
+      }
+      setters.push(parseResult.setter);
+      dateStr = parseResult.rest;
+    } else {
+      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+        throw new RangeError(
+          "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
+        );
+      }
+      if (token === "''") {
+        token = "'";
+      } else if (firstCharacter === "'") {
+        token = cleanEscapedString(token);
+      }
+      if (dateStr.indexOf(token) === 0) {
+        dateStr = dateStr.slice(token.length);
+      } else {
+        return constructFrom(referenceDate, NaN);
+      }
     }
-    return { isToken: false, value: substring };
-  });
-  if (locale2.localize.preprocessor) {
-    parts = locale2.localize.preprocessor(originalDate, parts);
   }
-  const formatterOptions = {
-    firstWeekContainsDate,
-    weekStartsOn,
-    locale: locale2
-  };
-  return parts.map((part) => {
-    if (!part.isToken) return part.value;
-    const token = part.value;
-    if (!(options == null ? void 0 : options.useAdditionalWeekYearTokens) && isProtectedWeekYearToken(token) || !(options == null ? void 0 : options.useAdditionalDayOfYearTokens) && isProtectedDayOfYearToken(token)) {
-      warnOrThrowProtectedError(token, formatStr, String(date2));
+  if (dateStr.length > 0 && notWhitespaceRegExp.test(dateStr)) {
+    return constructFrom(referenceDate, NaN);
+  }
+  const uniquePrioritySetters = setters.map((setter) => setter.priority).sort((a2, b2) => b2 - a2).filter((priority, index2, array2) => array2.indexOf(priority) === index2).map(
+    (priority) => setters.filter((setter) => setter.priority === priority).sort((a2, b2) => b2.subPriority - a2.subPriority)
+  ).map((setterArray) => setterArray[0]);
+  let date2 = toDate(referenceDate);
+  if (isNaN(date2.getTime())) {
+    return constructFrom(referenceDate, NaN);
+  }
+  const flags = {};
+  for (const setter of uniquePrioritySetters) {
+    if (!setter.validate(date2, subFnOptions)) {
+      return constructFrom(referenceDate, NaN);
+    }
+    const result = setter.set(date2, flags, subFnOptions);
+    if (Array.isArray(result)) {
+      date2 = result[0];
+      Object.assign(flags, result[1]);
+    } else {
+      date2 = result;
     }
-    const formatter = formatters$1[token[0]];
-    return formatter(originalDate, token, locale2.localize, formatterOptions);
-  }).join("");
-}
-function cleanEscapedString(input) {
-  const matched = input.match(escapedStringRegExp);
-  if (!matched) {
-    return input;
   }
-  return matched[1].replace(doubleQuoteRegExp, "'");
+  return constructFrom(referenceDate, date2);
 }
-function getDaysInMonth(date2) {
-  const _date = toDate(date2);
-  const year = _date.getFullYear();
-  const monthIndex = _date.getMonth();
-  const lastDayOfMonth2 = constructFrom(date2, 0);
-  lastDayOfMonth2.setFullYear(year, monthIndex + 1, 0);
-  lastDayOfMonth2.setHours(0, 0, 0, 0);
-  return lastDayOfMonth2.getDate();
-}
-function getUnixTime(date2) {
-  return Math.trunc(+toDate(date2) / 1e3);
-}
-function lastDayOfMonth(date2) {
-  const _date = toDate(date2);
-  const month = _date.getMonth();
-  _date.setFullYear(_date.getFullYear(), month + 1, 0);
-  _date.setHours(0, 0, 0, 0);
-  return _date;
-}
-function getWeeksInMonth(date2, options) {
-  return differenceInCalendarWeeks(
-    lastDayOfMonth(date2),
-    startOfMonth(date2),
-    options
-  ) + 1;
-}
-function isAfter(date2, dateToCompare) {
-  const _date = toDate(date2);
-  const _dateToCompare = toDate(dateToCompare);
-  return _date.getTime() > _dateToCompare.getTime();
-}
-function isBefore(date2, dateToCompare) {
-  const _date = toDate(date2);
-  const _dateToCompare = toDate(dateToCompare);
-  return +_date < +_dateToCompare;
-}
-function isEqual$2(leftDate, rightDate) {
-  const _dateLeft = toDate(leftDate);
-  const _dateRight = toDate(rightDate);
-  return +_dateLeft === +_dateRight;
+function cleanEscapedString(input) {
+  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
 }
 function isSameMonth(dateLeft, dateRight) {
   const _dateLeft = toDate(dateLeft);
@@ -13466,6 +15230,184 @@ function isSameYear(dateLeft, dateRight) {
 function subDays(date2, amount) {
   return addDays(date2, -amount);
 }
+function parseISO(argument, options) {
+  const additionalDigits = 2;
+  const dateStrings = splitDateString(argument);
+  let date2;
+  if (dateStrings.date) {
+    const parseYearResult = parseYear$1(dateStrings.date, additionalDigits);
+    date2 = parseDate(parseYearResult.restDateString, parseYearResult.year);
+  }
+  if (!date2 || isNaN(date2.getTime())) {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+  const timestamp = date2.getTime();
+  let time2 = 0;
+  let offset2;
+  if (dateStrings.time) {
+    time2 = parseTime(dateStrings.time);
+    if (isNaN(time2)) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+  }
+  if (dateStrings.timezone) {
+    offset2 = parseTimezone(dateStrings.timezone);
+    if (isNaN(offset2)) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+  } else {
+    const dirtyDate = new Date(timestamp + time2);
+    const result = /* @__PURE__ */ new Date(0);
+    result.setFullYear(
+      dirtyDate.getUTCFullYear(),
+      dirtyDate.getUTCMonth(),
+      dirtyDate.getUTCDate()
+    );
+    result.setHours(
+      dirtyDate.getUTCHours(),
+      dirtyDate.getUTCMinutes(),
+      dirtyDate.getUTCSeconds(),
+      dirtyDate.getUTCMilliseconds()
+    );
+    return result;
+  }
+  return new Date(timestamp + time2 + offset2);
+}
+const patterns = {
+  dateTimeDelimiter: /[T ]/,
+  timeZoneDelimiter: /[Z ]/i,
+  timezone: /([Z+-].*)$/
+};
+const dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+const timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function splitDateString(dateString) {
+  const dateStrings = {};
+  const array2 = dateString.split(patterns.dateTimeDelimiter);
+  let timeString;
+  if (array2.length > 2) {
+    return dateStrings;
+  }
+  if (/:/.test(array2[0])) {
+    timeString = array2[0];
+  } else {
+    dateStrings.date = array2[0];
+    timeString = array2[1];
+    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+      timeString = dateString.substr(
+        dateStrings.date.length,
+        dateString.length
+      );
+    }
+  }
+  if (timeString) {
+    const token = patterns.timezone.exec(timeString);
+    if (token) {
+      dateStrings.time = timeString.replace(token[1], "");
+      dateStrings.timezone = token[1];
+    } else {
+      dateStrings.time = timeString;
+    }
+  }
+  return dateStrings;
+}
+function parseYear$1(dateString, additionalDigits) {
+  const regex = new RegExp(
+    "^(?:(\\d{4}|[+-]\\d{" + (4 + additionalDigits) + "})|(\\d{2}|[+-]\\d{" + (2 + additionalDigits) + "})$)"
+  );
+  const captures = dateString.match(regex);
+  if (!captures) return { year: NaN, restDateString: "" };
+  const year = captures[1] ? parseInt(captures[1]) : null;
+  const century = captures[2] ? parseInt(captures[2]) : null;
+  return {
+    year: century === null ? year : century * 100,
+    restDateString: dateString.slice((captures[1] || captures[2]).length)
+  };
+}
+function parseDate(dateString, year) {
+  if (year === null) return /* @__PURE__ */ new Date(NaN);
+  const captures = dateString.match(dateRegex);
+  if (!captures) return /* @__PURE__ */ new Date(NaN);
+  const isWeekDate = !!captures[4];
+  const dayOfYear = parseDateUnit(captures[1]);
+  const month = parseDateUnit(captures[2]) - 1;
+  const day = parseDateUnit(captures[3]);
+  const week = parseDateUnit(captures[4]);
+  const dayOfWeek = parseDateUnit(captures[5]) - 1;
+  if (isWeekDate) {
+    if (!validateWeekDate(year, week, dayOfWeek)) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    return dayOfISOWeekYear(year, week, dayOfWeek);
+  } else {
+    const date2 = /* @__PURE__ */ new Date(0);
+    if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    date2.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+    return date2;
+  }
+}
+function parseDateUnit(value) {
+  return value ? parseInt(value) : 1;
+}
+function parseTime(timeString) {
+  const captures = timeString.match(timeRegex);
+  if (!captures) return NaN;
+  const hours = parseTimeUnit(captures[1]);
+  const minutes = parseTimeUnit(captures[2]);
+  const seconds = parseTimeUnit(captures[3]);
+  if (!validateTime(hours, minutes, seconds)) {
+    return NaN;
+  }
+  return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1e3;
+}
+function parseTimeUnit(value) {
+  return value && parseFloat(value.replace(",", ".")) || 0;
+}
+function parseTimezone(timezoneString) {
+  if (timezoneString === "Z") return 0;
+  const captures = timezoneString.match(timezoneRegex);
+  if (!captures) return 0;
+  const sign2 = captures[1] === "+" ? -1 : 1;
+  const hours = parseInt(captures[2]);
+  const minutes = captures[3] && parseInt(captures[3]) || 0;
+  if (!validateTimezone(hours, minutes)) {
+    return NaN;
+  }
+  return sign2 * (hours * millisecondsInHour + minutes * millisecondsInMinute);
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+  const date2 = /* @__PURE__ */ new Date(0);
+  date2.setUTCFullYear(isoWeekYear, 0, 4);
+  const fourthOfJanuaryDay = date2.getUTCDay() || 7;
+  const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+  date2.setUTCDate(date2.getUTCDate() + diff);
+  return date2;
+}
+const daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeapYearIndex(year) {
+  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+function validateDate(year, month, date2) {
+  return month >= 0 && month <= 11 && date2 >= 1 && date2 <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
+}
+function validateDayOfYearDate(year, dayOfYear) {
+  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+}
+function validateWeekDate(_year, week, day) {
+  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+}
+function validateTime(hours, minutes, seconds) {
+  if (hours === 24) {
+    return minutes === 0 && seconds === 0;
+  }
+  return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
+}
+function validateTimezone(_hours, minutes) {
+  return minutes >= 0 && minutes <= 59;
+}
 function setMonth(date2, month) {
   const _date = toDate(date2);
   const year = _date.getFullYear();
@@ -16562,6 +18504,9 @@ const useCombobox = (props, ref) => {
   };
   const handleInputKeyDown = (event) => {
     event.persist();
+    if (isElementInsideTable3OrReport(event.currentTarget) && (event.key === "ArrowUp" || event.key === "ArrowDown") && open) {
+      event.stopPropagation();
+    }
     if (!event.ctrlKey && !event.metaKey) {
       switch (event.key) {
         case "Backspace": {
@@ -16865,11 +18810,12 @@ const useDatepicker = ({ defaultValue: _, calendar: calendar2, onBlur, onChange,
     );
     const formattedValue = valueAsDate ? format$1(valueAsDate) || "" : "";
     event.target.value = formattedValue;
+    const isEmpty = !event.target.value.trim();
     if (onChange) {
-      event.detail = valueAsDate;
+      event.detail = !isEmpty ? valueAsDate : null;
       onChange(event);
     } else {
-      setInternalValue(formattedValue);
+      setInternalValue(!isEmpty ? formattedValue : "");
     }
     if (onBlur) {
       onBlur(event);
@@ -32742,6 +34688,121 @@ var TableFilterComparator = /* @__PURE__ */ ((TableFilterComparator2) => {
   TableFilterComparator2[TableFilterComparator2["IsNoneOf"] = 15] = "IsNoneOf";
   return TableFilterComparator2;
 })(TableFilterComparator || {});
+class DataType {
+}
+const localeNumberSeparators = /* @__PURE__ */ new Map();
+class NumericDataType extends DataType {
+  static format(value, locale2, options) {
+    const localisedValue = new Intl.NumberFormat(locale2, options).format(value);
+    return localisedValue.replace(/[\u00A0\u202F]/g, " ");
+  }
+  static parse(value, locale2) {
+    if (value === void 0 || value === null || typeof value !== "string") {
+      return void 0;
+    }
+    if (value === "Infinity" || value === "-Infinity") {
+      return Number(value);
+    }
+    let sanitizedValue = value.replaceAll(" ", "").replace(/[^0-9.,-]+/g, "");
+    if (!sanitizedValue.length) {
+      return void 0;
+    }
+    const decimalSeparator = this.getSeparator(locale2);
+    if (decimalSeparator === ",") {
+      sanitizedValue = sanitizedValue.replaceAll(".", "").replace(",", ".");
+    } else {
+      sanitizedValue = sanitizedValue.replaceAll(",", "");
+    }
+    const output = Number(sanitizedValue);
+    if (isNaN(output)) {
+      return void 0;
+    }
+    return output;
+  }
+  static getSeparator(locale2) {
+    var _a;
+    if (localeNumberSeparators.has(locale2)) {
+      return localeNumberSeparators.get(locale2);
+    }
+    const decimalSeparator = ((_a = new Intl.NumberFormat(locale2).formatToParts(1.1).find((part) => part.type === "decimal")) == null ? void 0 : _a.value) ?? ".";
+    localeNumberSeparators.set(locale2, decimalSeparator);
+    return decimalSeparator;
+  }
+}
+const localeDateMasks = /* @__PURE__ */ new Map();
+class DateTimeDataType extends DataType {
+  static format(value, locale2, options) {
+    let date2;
+    if (typeof value === "string") {
+      date2 = new Date(value);
+    } else if (value instanceof Date) {
+      date2 = value;
+    } else {
+      return "";
+    }
+    if (isNaN(date2.getTime())) {
+      return "";
+    }
+    return new Intl.DateTimeFormat(locale2, options).format(date2).replace(/[\u00A0\u202F]/g, " ");
+  }
+  static parse(value, locale2) {
+    if (value === void 0 || value === null || typeof value !== "string") {
+      return void 0;
+    }
+    const sanitizedValue = value == null ? void 0 : value.trim();
+    if (!(sanitizedValue == null ? void 0 : sanitizedValue.length)) {
+      return void 0;
+    }
+    const setHoursToMidday = (date2) => {
+      date2.setHours(12 - date2.getTimezoneOffset() / 60);
+    };
+    try {
+      const date2 = parseISO(sanitizedValue);
+      if (isValid(date2)) {
+        const timeRegex2 = /^\d{2}:\d{2}(?::\d{2}\.\d+|:\d{2})?(?:Z)?$/;
+        const time2 = sanitizedValue.split("T")[1];
+        if (!time2 || !timeRegex2.test(time2)) {
+          setHoursToMidday(date2);
+        }
+        return date2;
+      }
+    } catch {
+    }
+    const mask = this.getMask(locale2);
+    if (mask) {
+      try {
+        const date2 = parse$2(sanitizedValue, mask, /* @__PURE__ */ new Date());
+        if (isValid(date2)) {
+          setHoursToMidday(date2);
+          return date2;
+        }
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  static getMask(locale2) {
+    if (localeDateMasks.has(locale2)) {
+      return localeDateMasks.get(locale2);
+    }
+    const parts = new Intl.DateTimeFormat(locale2).formatToParts(/* @__PURE__ */ new Date());
+    const mask = parts.reduce((mask2, part) => {
+      switch (part.type) {
+        case "literal":
+          return mask2 + part.value;
+        case "day":
+          return mask2 + "dd";
+        case "month":
+          return mask2 + "MM";
+        case "year":
+          return mask2 + "yyyy";
+      }
+      return mask2;
+    }, "");
+    localeDateMasks.set(locale2, mask);
+    return mask;
+  }
+}
 const dataTypes = {
   auto: {
     sortingFn: "auto",
@@ -32806,15 +34867,13 @@ function createDatetimeDataType(defaultOptions2) {
       TableFilterComparator.IsEmpty,
       TableFilterComparator.IsNotEmpty
     ],
-    getDisplayValue: (value, row, options) => {
-      var _a;
+    getDisplayValue: (value, _, options) => {
       if (value === void 0) {
         return "";
       }
-      return new Intl.DateTimeFormat((_a = options == null ? void 0 : options.localization) == null ? void 0 : _a.locale, defaultOptions2).format(
-        typeof value === "string" ? Date.parse(value) : value
-      );
-    }
+      return DateTimeDataType.format(value, options == null ? void 0 : options.localization.locale, defaultOptions2);
+    },
+    parse: (value, locale2) => DateTimeDataType.parse(value, locale2)
   };
 }
 function createNumberDataType(align, defaultOptions2) {
@@ -32822,6 +34881,8 @@ function createNumberDataType(align, defaultOptions2) {
     align,
     sortingFn: "basic",
     filterComparators: [
+      TableFilterComparator.Contains,
+      TableFilterComparator.DoesNotContain,
       TableFilterComparator.IsEqualTo,
       TableFilterComparator.IsNotEqualTo,
       TableFilterComparator.IsGreaterThan,
@@ -32833,10 +34894,6 @@ function createNumberDataType(align, defaultOptions2) {
       TableFilterComparator.IsNotEmpty
     ],
     getDisplayValue: (value, row, options) => {
-      var _a, _b;
-      if (value === void 0) {
-        return "";
-      }
       const dataTypeOptions = typeof (options == null ? void 0 : options.dataTypeOptions) === "function" ? options == null ? void 0 : options.dataTypeOptions(row) : options == null ? void 0 : options.dataTypeOptions;
       const numberFormatOptions = {
         // format
@@ -32852,20 +34909,14 @@ function createNumberDataType(align, defaultOptions2) {
         numberFormatOptions.currency = dataTypeOptions.currency;
         numberFormatOptions.currencyDisplay = "code";
       }
-      let localisedValue = new Intl.NumberFormat((_a = options == null ? void 0 : options.localization) == null ? void 0 : _a.locale, numberFormatOptions).format(Number(value));
-      if (!numberFormatOptions.useGrouping) {
-        return localisedValue;
-      }
-      let localisedValueWithoutThousandsSeperator = new Intl.NumberFormat((_b = options == null ? void 0 : options.localization) == null ? void 0 : _b.locale, {
+      const localisedValue = NumericDataType.format(value, options == null ? void 0 : options.localization.locale, numberFormatOptions);
+      const localisedValueWithoutThousandsSeperator = NumericDataType.format(value, options == null ? void 0 : options.localization.locale, {
         ...numberFormatOptions,
         useGrouping: false
-      }).format(Number(value));
-      if (numberFormatOptions.style === "percent" || numberFormatOptions.style === "currency") {
-        localisedValue = localisedValue.replace(/\u00A0/g, " ");
-        localisedValueWithoutThousandsSeperator = localisedValueWithoutThousandsSeperator.replace(/\u00A0/g, " ");
-      }
+      });
       return [localisedValue, localisedValueWithoutThousandsSeperator];
-    }
+    },
+    parse: (value, locale2) => NumericDataType.parse(value, locale2)
   };
 }
 function getDataTypeProperties(dataType) {
@@ -32883,103 +34934,121 @@ function getSortingFn(dataType, customFnOrBuiltIn) {
 const toLowerCase = (value) => String(value ?? "").toLocaleLowerCase();
 const isWeakContains = (left, right) => toLowerCase(left).includes(toLowerCase(right));
 const isWeakEqual = (left, right) => toLowerCase(left) === toLowerCase(right);
-function columnFilterFn(value, filter2) {
+function columnFilterFn(row, cellValue, meta, filter2, localization) {
   try {
+    const query = filter2.value;
+    const { dataType, dataTypeOptions } = meta ?? {};
     if (filter2.comparator === TableFilterComparator.IsEmpty || filter2.comparator === TableFilterComparator.IsNotEmpty) {
-      const isEmpty = value === void 0 || value === null || value === "";
+      const isEmpty = cellValue === void 0 || cellValue === null || cellValue === "";
       return filter2.comparator === TableFilterComparator.IsEmpty ? isEmpty : !isEmpty;
     }
-    if (filter2.value === void 0 || filter2.value === null || filter2.value === "") {
+    if (query === void 0 || query === null || query === "") {
       return true;
     }
-    const valueAsDate = new Date(value);
+    const evaluate = (matcher) => {
+      return isMatched(query, cellValue, row, dataType, dataTypeOptions, localization, matcher);
+    };
+    const isDateColumn = dataType === "date" || dataType === "datetime";
+    const valueAsDate = new Date(cellValue);
+    const isNumberColumn = dataType === "number" || dataType === "amount";
+    const compareNumbers2 = (fn) => {
+      const input = typeof query === "number" ? query : NumericDataType.parse(query, localization.locale);
+      const value = cellValue;
+      if (input === void 0) {
+        return false;
+      }
+      return fn(input, value);
+    };
     switch (filter2.comparator) {
       case TableFilterComparator.Contains:
-        return isWeakContains(value, filter2.value);
+        return evaluate(isWeakContains);
       case TableFilterComparator.DoesNotContain:
-        return !isWeakContains(value, filter2.value);
+        return !evaluate(isWeakContains);
       case TableFilterComparator.IsEqualTo: {
-        if (isDate(valueAsDate)) {
-          return isDate(filter2.value) && isWeakEqual$1(valueAsDate, filter2.value);
-        } else if (typeof filter2.value === "boolean") {
-          return value === filter2.value;
+        if (dataType === "boolean") {
+          return cellValue === query;
+        } else if (isDateColumn) {
+          return isWeakEqual$1(query, valueAsDate);
         }
-        return isWeakEqual(value, filter2.value);
+        return evaluate(isWeakEqual);
       }
       case TableFilterComparator.IsNotEqualTo: {
-        if (isDate(valueAsDate)) {
-          return isDate(filter2.value) && isWeakEqual$1(valueAsDate, filter2.value) === false;
-        } else if (typeof filter2.value === "boolean") {
-          return value !== filter2.value;
+        if (dataType === "boolean") {
+          return cellValue !== query;
+        } else if (isDateColumn) {
+          return !isWeakEqual$1(query, valueAsDate);
         }
-        return !isWeakEqual(value, filter2.value);
+        return !evaluate(isWeakEqual);
       }
       case TableFilterComparator.IsGreaterThan: {
-        if (isDate(valueAsDate)) {
-          return isDate(filter2.value) && isAfter(valueAsDate, filter2.value);
-        } else {
-          const valueAsNumber = parseInt(value);
-          return !isNaN(valueAsNumber) && filter2.value !== void 0 && valueAsNumber > filter2.value;
+        if (isDateColumn) {
+          return query.getTime() < valueAsDate.getTime();
+        } else if (isNumberColumn) {
+          return compareNumbers2((q, v2) => q < v2);
         }
+        return false;
       }
       case TableFilterComparator.IsLessThan: {
-        if (isDate(valueAsDate)) {
-          return isDate(filter2.value) && isBefore(valueAsDate, filter2.value);
-        } else {
-          const valueAsNumber = parseInt(value);
-          return !isNaN(valueAsNumber) && filter2.value !== void 0 && valueAsNumber < filter2.value;
+        if (isDateColumn) {
+          return query.getTime() > valueAsDate.getTime();
+        } else if (isNumberColumn) {
+          return compareNumbers2((q, v2) => q > v2);
         }
+        return false;
       }
       case TableFilterComparator.IsLessThanOrEqualTo: {
-        if (isDate(valueAsDate)) {
-          return isDate(filter2.value) && (isBefore(valueAsDate, filter2.value) || isEqual$2(valueAsDate, filter2.value));
-        } else {
-          const valueAsNumber = parseInt(value);
-          return !isNaN(valueAsNumber) && filter2.value !== void 0 && valueAsNumber <= filter2.value;
+        if (isDateColumn) {
+          return query.getTime() > valueAsDate.getTime() || isWeakEqual$1(valueAsDate, query);
+        } else if (isNumberColumn) {
+          return compareNumbers2((q, v2) => q >= v2);
         }
+        return false;
       }
       case TableFilterComparator.IsGreaterThanOrEqualTo: {
-        if (isDate(valueAsDate)) {
-          return isDate(filter2.value) && (isAfter(valueAsDate, filter2.value) || isEqual$2(valueAsDate, filter2.value));
-        } else {
-          const valueAsNumber = parseInt(value);
-          return !isNaN(valueAsNumber) && filter2.value !== void 0 && valueAsNumber >= filter2.value;
+        if (isDateColumn) {
+          return query.getTime() < valueAsDate.getTime() || isWeakEqual$1(valueAsDate, query);
+        } else if (isNumberColumn) {
+          return compareNumbers2((q, v2) => q <= v2);
         }
+        return false;
       }
       case TableFilterComparator.IsBetween: {
-        const [fromValue, toValue2] = filter2.value;
-        if (isDate(valueAsDate)) {
-          if (isDate(fromValue) && isBefore(valueAsDate, fromValue)) {
+        const [fromValue, toValue2] = query;
+        if (isDateColumn) {
+          if (fromValue !== void 0 && valueAsDate.getTime() < fromValue.getTime()) {
             return false;
-          } else if (isDate(toValue2) && isAfter(valueAsDate, toValue2)) {
+          } else if (toValue2 !== void 0 && valueAsDate.getTime() > toValue2.getTime()) {
             return false;
           }
           return true;
-        } else {
-          const valueAsNumber = parseInt(value);
-          if (isNaN(valueAsNumber)) {
-            return false;
-          }
-          if (fromValue !== void 0 && valueAsNumber < fromValue) {
+        } else if (isNumberColumn) {
+          if (fromValue !== void 0 && cellValue < fromValue) {
             return false;
-          } else if (toValue2 !== void 0 && valueAsNumber > toValue2) {
+          } else if (toValue2 !== void 0 && cellValue > toValue2) {
             return false;
           }
           return true;
         }
+        return false;
       }
       case TableFilterComparator.HasAnyOf:
-        return Array.isArray(filter2.value) && Array.isArray(value) ? filter2.value.some((item) => value.includes(item)) : false;
+        return Array.isArray(query) && Array.isArray(cellValue) ? query.some((item) => cellValue.includes(item)) : false;
       case TableFilterComparator.HasNoneOf:
-        return Array.isArray(filter2.value) && Array.isArray(value) ? filter2.value.every((item) => value.includes(item) === false) : false;
+        return Array.isArray(query) && Array.isArray(cellValue) ? query.every((item) => cellValue.includes(item) === false) : false;
       case TableFilterComparator.HasAllOf:
-        return Array.isArray(filter2.value) && Array.isArray(value) ? filter2.value.filter((v2) => value.includes(v2)).length === filter2.value.length : false;
-      case TableFilterComparator.IsOneOf:
-        if (!Array.isArray(filter2.value)) return false;
-        return filter2.value.some((v2) => isWeakEqual(value, v2));
-      case TableFilterComparator.IsNoneOf:
-        if (!Array.isArray(filter2.value)) return false;
-        return filter2.value.every((v2) => !isWeakEqual(value, v2));
+        return Array.isArray(query) && Array.isArray(cellValue) ? query.filter((v2) => cellValue.includes(v2)).length === query.length : false;
+      case TableFilterComparator.IsOneOf: {
+        if (!Array.isArray(query)) {
+          return false;
+        }
+        return query.some((v2) => isWeakEqual(String(cellValue), v2));
+      }
+      case TableFilterComparator.IsNoneOf: {
+        if (!Array.isArray(query)) {
+          return false;
+        }
+        return query.every((v2) => !isWeakEqual(String(cellValue), v2));
+      }
     }
     return false;
   } catch (e3) {
@@ -32990,12 +35059,12 @@ function columnFilterFn(value, filter2) {
 const flattenCellValue = (cellValue) => {
   return typeof cellValue === "object" ? Object.values(cellValue).map(flattenCellValue) : cellValue;
 };
-function isMatched(searchQuery, cellValue, rowValue, dataType, dataTypeOptions, localization) {
+function isMatched(query, cellValue, rowValue, dataType, dataTypeOptions, localization, matcher = isWeakContains) {
   if (typeof cellValue === "object") {
-    return flattenCellValue(cellValue).flat(Infinity).find((y2) => isWeakContains(y2, searchQuery));
+    return flattenCellValue(cellValue).flat(Infinity).find((y2) => matcher(y2, query));
   } else {
     const cellValueAsString = String(cellValue ?? "");
-    if (cellValueAsString !== void 0 && isWeakContains(cellValueAsString, searchQuery)) {
+    if (cellValueAsString !== void 0 && matcher(cellValueAsString, query)) {
       return true;
     } else {
       const dataTypeProperties = getDataTypeProperties(dataType);
@@ -33005,12 +35074,14 @@ function isMatched(searchQuery, cellValue, rowValue, dataType, dataTypeOptions,
           localization
         });
         if (Array.isArray(cellDisplayValue)) {
-          for (const displayValue of cellDisplayValue) {
-            if (isWeakContains(displayValue, searchQuery)) {
-              return true;
-            }
-          }
-        } else if (cellDisplayValue !== void 0 && isWeakContains(cellDisplayValue, searchQuery)) {
+          return cellDisplayValue.some((cdv) => matcher(cdv, query));
+        } else if (cellDisplayValue !== void 0 && isWeakContains(cellDisplayValue, query)) {
+          return true;
+        }
+      }
+      if (typeof query !== typeof cellValue && dataTypeProperties.parse) {
+        const parsedQuery = dataTypeProperties.parse(query, localization.locale);
+        if (parsedQuery !== void 0 && matcher(cellValue, parsedQuery)) {
           return true;
         }
       }
@@ -33456,7 +35527,11 @@ function configureReactTableOptions(options, props, localization) {
     else {
       tableOptions.getFilteredRowModel = getFilteredRowModel();
       tableOptions.filterFns = {
-        tacoFilter: (row, columnId, filter2) => columnFilterFn(row.getValue(columnId), filter2)
+        tacoFilter: (row, columnId, filter2) => {
+          var _a;
+          const meta = (_a = row._getAllCellsByColumnId()[columnId]) == null ? void 0 : _a.column.columnDef.meta;
+          return columnFilterFn(row.original, row.getValue(columnId), meta, filter2, localization);
+        }
       };
     }
   }
@@ -33972,8 +36047,10 @@ function useTableRowSelection(isEnabled = false) {
     lastSelectedRowIndex
   };
 }
-function useTableSearch(isEnabled = false, onChangeSearch, defaultEnableGlobalFilter = false) {
-  const [enableGlobalFilter, _setEnableGlobalFilter] = React__default.useState(defaultEnableGlobalFilter);
+function useTableSearch(isEnabled = false, onChangeSearch, defaultEnableGlobalFilter = false, _experimentalDataLoader2 = false) {
+  const [enableGlobalFilter, _setEnableGlobalFilter] = React__default.useState(
+    _experimentalDataLoader2 || defaultEnableGlobalFilter
+  );
   function setEnableGlobalFilter(enabled, instance) {
     _setEnableGlobalFilter(enabled);
     const currentFilter = instance.getState().globalFilter;
@@ -34548,7 +36625,12 @@ function useTableManager(props, ref, meta, internalColumns) {
   const rowGroups = useTableRowGroups(props.rowActionsForGroup);
   const rowHeight = useTableRowHeight(options.enableRowHeight, settings.rowHeight);
   const rowSelection = useTableRowSelection(!!options.enableRowSelection);
-  const search = useTableSearch(options.enableSearch, props.onChangeSearch, settings.excludeUnmatchedRecordsInSearch);
+  const search = useTableSearch(
+    options.enableSearch,
+    props.onChangeSearch,
+    settings.excludeUnmatchedRecordsInSearch,
+    props._experimentalDataLoader2
+  );
   const server = useTableServerLoading(
     length,
     data,
@@ -34814,10 +36896,11 @@ function useTableGlobalShortcuts(table, tableRef, scrollToIndex, localShortcuts
       const handleKeyDown = (event) => {
         var _a;
         const trigger = event.target;
-        if (isElementInsideOverlay(trigger) && !isSiblingElementInsideSameParentOverlay(trigger, tableRef.current) || isElementInteractive(trigger) && !isElementInsideOrTriggeredFromContainer(trigger, tableRef.current)) {
+        if (isElementInsideExternalRelatedOverlay(trigger, tableRef)) {
           return;
         }
-        tableMeta.rowActive.handleKeyDown(event, tableMeta.length, scrollToIndex);
+        const reachableRows = tableMeta.length + table.getBottomRows().length;
+        tableMeta.rowActive.handleKeyDown(event, reachableRows, scrollToIndex);
         tableMeta.rowSelection.handleKeyDown(event, table);
         if (tableMeta.rowActive.rowActiveIndex !== void 0) {
           tableMeta.rowClick.handleKeyDown(event, (_a = rows[tableMeta.rowActive.rowActiveIndex]) == null ? void 0 : _a.original);
@@ -35848,12 +37931,35 @@ function Actions(props) {
   const { actions, actionsLength, data, isActiveRow, rowId, table } = props;
   const { texts } = useLocalization();
   const tableMeta = table.options.meta;
-  const visibleActions = actions.map((action) => action(data, rowId, tableMeta.rowActions.handlers["cleanup"], table)).filter((action) => !!action);
-  const actionsOnRow = visibleActions.length === actionsLength ? visibleActions : visibleActions.slice(0, actionsLength - 1);
-  const actionsInMenu = visibleActions.slice(visibleActions.length === actionsLength ? actionsLength : actionsLength - 1);
-  const className = clsx(
-    "flex justify-end text-right bg-[inherit] shadow-[-6px_0px_6px_var(--table-row-actions-shadow)] print:hidden"
-  );
+  const visibleActions = actions.map(
+    (action) => action(data, {
+      cleanup: tableMeta.rowActions.handlers["cleanup"] ?? (() => void 0),
+      isEditing: tableMeta.editing.isEditing,
+      rowId,
+      table
+    })
+  ).filter((action) => !!action);
+  let length = actionsLength;
+  if (tableMeta.editing.isEditing) {
+    const lengthWithoutEditingItems = visibleActions.length - 1;
+    if (lengthWithoutEditingItems < actionsLength) {
+      length = lengthWithoutEditingItems;
+    }
+  }
+  const handleMenuButtonKeyDown = (event) => {
+    const isLastRowActive = tableMeta.rowActive.rowActiveIndex === tableMeta.length - 1;
+    if (event.key === "Tab" && isLastRowActive && tableMeta.editing.isEditing && tableMeta.editing.hasChanges()) {
+      tableMeta.editing.saveChanges(table);
+    }
+  };
+  const handleMenuContentKeyDown = (event) => {
+    if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+      event.stopPropagation();
+    }
+  };
+  const actionsOnRow = visibleActions.length === length ? visibleActions : visibleActions.slice(0, length - 1);
+  const actionsInMenu = visibleActions.slice(visibleActions.length === length ? length : length - 1);
+  const className = clsx("flex justify-end text-right bg-[inherit] print:hidden");
   return /* @__PURE__ */ React__default.createElement("span", { className }, actionsOnRow.map((button, index2) => {
     const tooltip = String(button.props.tooltip ?? button.props["aria-label"] ?? "");
     return React__default.cloneElement(button, {
@@ -35868,8 +37974,16 @@ function Actions(props) {
       appearance: "transparent",
       "aria-label": texts.table.columns.actions.tooltip,
       icon: "more",
+      onKeyDown: handleMenuButtonKeyDown,
       tabIndex: isActiveRow ? 0 : -1,
-      menu: (menuProps) => /* @__PURE__ */ React__default.createElement(Menu$1, { ...menuProps }, /* @__PURE__ */ React__default.createElement(Menu$1.Content, null, actionsInMenu.map((action, i2) => /* @__PURE__ */ React__default.createElement(Menu$1.Item, { key: i2, ...action.props, shortcut: action.props.shortcut }, action.props["aria-label"]))))
+      menu: (menuProps) => /* @__PURE__ */ React__default.createElement(Menu$1, { ...menuProps }, /* @__PURE__ */ React__default.createElement(Menu$1.Content, { onKeyDown: handleMenuContentKeyDown }, actionsInMenu.map((action, i2) => {
+        const item = /* @__PURE__ */ React__default.createElement(Menu$1.Item, { key: i2, ...action.props, shortcut: action.props.shortcut }, action.props["aria-label"]);
+        const isFirstEditingMenuItem = tableMeta.editing.isEditing && actionsInMenu.length > 2 && i2 === actionsInMenu.length - 2;
+        if (isFirstEditingMenuItem) {
+          return /* @__PURE__ */ React__default.createElement(React__default.Fragment, { key: i2 }, /* @__PURE__ */ React__default.createElement(Menu$1.Separator, null), item);
+        }
+        return item;
+      })))
     }
   ) : null);
 }
@@ -35910,7 +38024,8 @@ const renderer$3 = {
       'print:opacity-0 !px-0 !pr-1 overflow-hidden [table_&]:group-[[data-row-active="true"]]/row:sticky right-0',
       'group-[[data-row-active="true"][data-selected="false"]]/row:text-grey-200',
       'group-[[data-row-selected="true"]]/row:text-blue-100',
-      'group-[[data-row-selected="false"]:hover]/row:text-grey-100'
+      'group-[[data-row-selected="false"]:hover]/row:text-grey-100',
+      "shadow-[-6px_0px_6px_var(--table-row-actions-shadow)]"
     ),
     // TODO: remove when table3 is migrated, this satisfies the legacy table3 type
     enableSearch: false,
@@ -36408,7 +38523,7 @@ function DisplayCell(props) {
   } else {
     content = typeof cell.column.columnDef.cell === "function" ? cell.column.columnDef.cell(cell.getContext()) : cell.getValue();
   }
-  return /* @__PURE__ */ React__default.createElement(MemoedDisplayCell, { ...cellAttributes, ...attributes, cellRef, isTruncated }, content);
+  return /* @__PURE__ */ React__default.createElement(MemoedDisplayCell, { ...cellAttributes, ...attributes, cellRef, isTruncated }, content ?? columnMeta.emptyState);
 }
 const MemoedDisplayCell = React__default.memo(function MemoedDisplayCell2(props) {
   const { cellRef, children, isTruncated, ...cellAttributes } = props;
@@ -36962,7 +39077,20 @@ function useAugmentedFocusManager() {
   const focusManager = $9bf71ea28793e738$export$10c5169755ce7bd7();
   const focusPrevious = (arrowNavigation = false) => focusManager == null ? void 0 : focusManager.focusPrevious(arrowNavigation ? FOCUS_MANAGER_OPTIONS_ARROW_KEYS : FOCUS_MANAGER_OPTIONS_TAB);
   const focusNext = (arrowNavigation = false) => focusManager == null ? void 0 : focusManager.focusNext(arrowNavigation ? FOCUS_MANAGER_OPTIONS_ARROW_KEYS : FOCUS_MANAGER_OPTIONS_TAB);
-  const focusFirst = () => focusManager == null ? void 0 : focusManager.focusFirst(FOCUS_MANAGER_OPTIONS_TAB);
+  const focusFirst = () => {
+    return focusManager == null ? void 0 : focusManager.focusFirst({
+      ...FOCUS_MANAGER_OPTIONS_TAB,
+      accept: (element) => {
+        if (!FOCUS_MANAGER_OPTIONS_TAB.accept(element)) {
+          return false;
+        }
+        if (element.closest('[data-taco="cell-control"]')) {
+          return true;
+        }
+        return false;
+      }
+    });
+  };
   const focusLast = () => focusManager == null ? void 0 : focusManager.focusLast(FOCUS_MANAGER_OPTIONS_TAB);
   return {
     focusPrevious,
@@ -36982,7 +39110,8 @@ function Body(props) {
     }
     if (tableMeta.rowActive.rowActiveIndex !== void 0) {
       const isFirstRow = tableMeta.rowActive.rowActiveIndex === 0;
-      const isLastRow = tableMeta.rowActive.rowActiveIndex === tableMeta.length - 1;
+      const reachableRows = tableMeta.length + table.getBottomRows().length;
+      const isLastRow = tableMeta.rowActive.rowActiveIndex === reachableRows - 1;
       if (event.key === "Tab" || enableHorizontalArrowKeyNavigation && (event.key === "ArrowLeft" || event.key === "ArrowRight")) {
         if (event.key === "Tab" && !hasFocusableElement(event.target.closest("tr[data-row-id]"))) {
           return;
@@ -37425,7 +39554,7 @@ function Search$1(props) {
     tableMeta.search.setCurrentHighlightColumnIndex(nextIndex);
     scrollTo2(tableMeta.search.highlightedColumnIndexes[nextIndex][0]);
   };
-  const settings = /* @__PURE__ */ React__default.createElement(
+  const settings = tableMeta.server._experimentalDataLoader2 ? void 0 : /* @__PURE__ */ React__default.createElement(
     Switch$1,
     {
       label: texts.table.search.excludeUnmatchedResults,
@@ -42335,6 +44464,9 @@ const Search = React__default.forwardRef(function ListboxSearch(props, ref) {
     if (event.key === " ") {
       return;
     }
+    if ((event.key === "ArrowLeft" || event.key === "ArrowRight") && event.currentTarget.value.length) {
+      event.stopPropagation();
+    }
     if (isAriaSelectionKey(event) || event.key === "ArrowDown" || event.key === "ArrowUp") {
       event.preventDefault();
       (_a = listboxRef == null ? void 0 : listboxRef.current) == null ? void 0 : _a.dispatchEvent(createCustomKeyboardEvent(event));
@@ -42598,14 +44730,28 @@ const Select22 = React__default.forwardRef(function Select222(props, ref) {
     }
     (_a = listboxRef.current) == null ? void 0 : _a.dispatchEvent(createCustomKeyboardEvent(event));
   };
-  const shouldFocusNextRef = React__default.useRef(false);
+  const shouldFocusNextRef = React__default.useRef(void 0);
+  React__default.useEffect(() => {
+    const handleKeyDown2 = (event) => {
+      if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+        shouldFocusNextRef.current = event.key === "ArrowLeft" ? -1 : 1;
+        setOpen(false);
+      }
+    };
+    if (isElementInsideTable3OrReport(internalRef.current)) {
+      document.addEventListener("keydown", handleKeyDown2);
+    }
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown2);
+    };
+  }, []);
   const handleListboxKeyDown = (event) => {
     if (isAriaDirectionKey(event)) {
       setShouldPauseHoverState(true);
       return;
     }
     if (event.key === "Tab") {
-      shouldFocusNextRef.current = true;
+      shouldFocusNextRef.current = event.shiftKey ? -1 : 1;
       setOpen(false);
       return;
     }
@@ -42616,11 +44762,11 @@ const Select22 = React__default.forwardRef(function Select222(props, ref) {
   };
   const handleCloseAutoFocus = (event) => {
     var _a, _b;
-    if (shouldFocusNextRef.current) {
+    if (shouldFocusNextRef.current !== void 0) {
       event.preventDefault();
-      shouldFocusNextRef.current = false;
       (_a = otherProps.onBlur) == null ? void 0 : _a.call(otherProps, event);
-      (_b = getNextFocussableElement(internalRef.current)) == null ? void 0 : _b.focus();
+      (_b = getNextFocussableElement(internalRef.current, shouldFocusNextRef.current)) == null ? void 0 : _b.focus();
+      shouldFocusNextRef.current = void 0;
       return;
     }
   };
@@ -43021,8 +45167,8 @@ function FilterComparator(props) {
   return /* @__PURE__ */ React__default.createElement(Select22, { ...attributes, className: "!w-32 flex-shrink-0", disabled: !column, onChange: handleChange, value }, validComparators.map((comparator) => /* @__PURE__ */ React__default.createElement(Select22.Option, { key: comparator, value: comparator }, getComparatorText(comparator, texts, column))));
 }
 function getComparatorText(comparator, texts, column) {
-  var _a, _b;
-  const isDate2 = ((_b = (_a = column == null ? void 0 : column.columnDef) == null ? void 0 : _a.meta) == null ? void 0 : _b.control) === "datepicker";
+  var _a, _b, _c;
+  const isDate2 = ((_a = column == null ? void 0 : column.columnDef.meta) == null ? void 0 : _a.dataType) === "date" || ((_b = column == null ? void 0 : column.columnDef.meta) == null ? void 0 : _b.dataType) === "time" || ((_c = column == null ? void 0 : column.columnDef.meta) == null ? void 0 : _c.dataType) === "datetime";
   switch (comparator) {
     case TableFilterComparator.Contains:
       return texts.table.filters.comparators.contains;
@@ -51646,7 +53792,7 @@ function willRowMove(cell, change, rowIndex, localization) {
   const { table } = cell.getContext();
   if (willRowMoveAfterSearch(cell, change, table, localization)) {
     return "search";
-  } else if (willRowMoveAfterFilter(cell, change)) {
+  } else if (willRowMoveAfterFilter(cell, change, localization)) {
     return "filter";
   } else if (willRowMoveAfterSorting(cell, change, rowIndex)) {
     return "sorting";
@@ -51661,11 +53807,17 @@ function willRowMoveAfterSearch(cell, change, table, localization) {
   const rowWithChange = { ...cell.row, original: { ...cell.row.original, [cell.column.id]: change } };
   return !globalFilterFn(rowWithChange, cell.column.id, searchQuery, localization);
 }
-function willRowMoveAfterFilter(cell, change) {
+function willRowMoveAfterFilter(cell, change, localization) {
   if (!cell.column.getIsFiltered()) {
     return false;
   }
-  return !columnFilterFn(change, cell.column.getFilterValue());
+  return !columnFilterFn(
+    cell.row.original,
+    change,
+    cell.column.columnDef.meta,
+    cell.column.getFilterValue(),
+    localization
+  );
 }
 function willRowMoveAfterSorting(cell, change, rowIndex) {
   var _a;
@@ -51961,8 +54113,8 @@ function requireIsBuffer() {
     var freeExports = exports && !exports.nodeType && exports;
     var freeModule = freeExports && true && module && !module.nodeType && module;
     var moduleExports = freeModule && freeModule.exports === freeExports;
-    var Buffer = moduleExports ? root.Buffer : void 0;
-    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var Buffer2 = moduleExports ? root.Buffer : void 0;
+    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
     var isBuffer2 = nativeIsBuffer || stubFalse;
     module.exports = isBuffer2;
   })(isBuffer, isBuffer.exports);
@@ -52241,7 +54393,7 @@ function require_cloneBuffer() {
     var freeExports = exports && !exports.nodeType && exports;
     var freeModule = freeExports && true && module && !module.nodeType && module;
     var moduleExports = freeModule && freeModule.exports === freeExports;
-    var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+    var Buffer2 = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
     function cloneBuffer(buffer, isDeep) {
       if (isDeep) {
         return buffer.slice();
@@ -53092,17 +55244,18 @@ function usePendingChangesState(handleSave, handleChange, handleDiscard, rowIden
   async function onCellChanged(cell, rowIndex, nextValue, shouldRunUpdaters = true) {
     var _a;
     const changes = nextValue !== void 0 ? { ...state.changes.rows[cell.row.id], [cell.column.id]: nextValue } : { ...state.changes.rows[cell.row.id] };
+    const original = cell.row.original;
     if (!Object.keys(changes).length) {
       return;
     }
     let updatesForOtherCells = {};
     if (typeof handleChange === "function" && shouldRunUpdaters) {
       const previousRowValue = {
-        ...state.changes.originals[cell.row.id]
+        ...original
         //...getRowChangeset(updatersRef.current[cell.row.id], rowIdentityAccessor),
       };
       const nextRowValue = {
-        ...state.changes.originals[cell.row.id],
+        ...original,
         ...changes
       };
       updatesForOtherCells = await handleChange(
@@ -53116,8 +55269,8 @@ function usePendingChangesState(handleSave, handleChange, handleDiscard, rowIden
     const nextMoveReasons = { ...state.changes.moveReasons[cell.row.id] };
     const nextCellErrors = { ...(_a = state.changes.errors[cell.row.id]) == null ? void 0 : _a.cells };
     let validationErrors = {};
-    if (validator && Object.keys(nextChanges).length && state.changes.originals[cell.row.id]) {
-      const nextRowValue = { ...state.changes.originals[cell.row.id], ...changes, ...updatesForOtherCells };
+    if (validator && Object.keys(nextChanges).length && original) {
+      const nextRowValue = { ...original, ...changes, ...updatesForOtherCells };
       validationErrors = await validator(nextRowValue) ?? {};
     }
     const cellsToActOn = [cell.column.id, ...Object.keys(updatesForOtherCells)];
@@ -53146,7 +55299,8 @@ function usePendingChangesState(handleSave, handleChange, handleDiscard, rowIden
         cellErrors: nextCellErrors,
         index: rowIndex,
         moveReasons: nextMoveReasons,
-        value: nextChanges
+        value: nextChanges,
+        original
       }
     });
   }
@@ -53556,6 +55710,7 @@ function EditingControlCell(props) {
   const type = columnMeta.control ?? "input";
   const handleFocus = useEditingCellAutofocus(props);
   const value = cell.getValue();
+  const rowChanges = tableMeta.editing.getRowValue(cell.row.id);
   const hasNonTextControl = React__default.useMemo(() => {
     var _a;
     return typeof type === "function" && !!((_a = cellRef.current) == null ? void 0 : _a.querySelector('[data-taco="Select2"],[data-taco="switch"],[data-taco="checkbox"]'));
@@ -53571,35 +55726,22 @@ function EditingControlCell(props) {
     },
     [hasNonTextControl, cell.row.id, cell.column.id, cell.row.original, rowIndex, value]
   );
-  const blur = React__default.useCallback(
-    function blur2() {
-      requestAnimationFrame(() => {
-        tableMeta.editing.toggleDetailedMode(false);
-        tableMeta.editing.onCellChanged(cell, rowIndex, void 0, !hasNonTextControl);
-      });
-    },
-    [hasNonTextControl, cell.row.id, cell.column.id, cell.row.original, rowIndex]
-  );
   const handleBlur = React__default.useCallback(
     (event) => {
       if (isElementInsideOrTriggeredFromContainer(event.relatedTarget, event.currentTarget)) {
         return;
       }
-      blur();
+      requestAnimationFrame(() => {
+        tableMeta.editing.toggleDetailedMode(false);
+        tableMeta.editing.onCellChanged(cell, rowIndex, void 0, !hasNonTextControl);
+      });
     },
-    [blur]
+    [hasNonTextControl, cell.row.id, JSON.stringify(rowChanges), rowIndex, cell.column.id, cell.row.original]
   );
-  React__default.useEffect(() => {
-    const ref = cellRef.current;
-    return () => {
-      if (document.activeElement === ref || isElementInsideOrTriggeredFromContainer(document.activeElement, ref)) {
-        blur();
-      }
-    };
-  }, []);
   const error = tableMeta.editing.getCellError(cell);
   const controlProps = {
     dataType: columnMeta.dataType,
+    disabled: tableMeta.editing.getRowStatus(cell.row.id) === "saving",
     fontSize: tableMeta.fontSize.size,
     id: cell.column.id,
     invalid: !!error,
@@ -53627,6 +55769,7 @@ function EditingControlCell(props) {
 const MemoedEditingCell = React__default.memo(function MemoedEditingCell2(props) {
   const {
     dataType,
+    disabled,
     fontSize,
     id: id2,
     invalid,
@@ -53644,6 +55787,7 @@ const MemoedEditingCell = React__default.memo(function MemoedEditingCell2(props)
   const controlRef = React__default.useRef(null);
   const currentValue = row[id2];
   const commonProps = {
+    disabled,
     onBlur,
     ref: controlRef,
     tabIndex
@@ -53821,6 +55965,22 @@ function Cell$1(props) {
   }
   return /* @__PURE__ */ React__default.createElement(DisplayCell, { ...props });
 }
+function SaveStatus(props) {
+  const { rowId, table } = props;
+  const { texts } = useLocalization();
+  const tableMeta = table.options.meta;
+  const status = tableMeta.editing.getRowStatus(rowId);
+  const className = clsx(
+    "col-span-full sticky ml-auto right-0 top-0 -mb-[100%] z-10 h-8 bg-[inherit] flex items-center px-1.5 shadow-[-6px_0px_6px_var(--table-row-actions-shadow)]",
+    {
+      "mt-0.5": tableMeta.rowHeight.height === "short",
+      "mt-1": tableMeta.rowHeight.height === "medium",
+      "mt-1.5": tableMeta.rowHeight.height === "tall",
+      "mt-2": tableMeta.rowHeight.height === "extra-tall"
+    }
+  );
+  return /* @__PURE__ */ React__default.createElement("td", { className: "!contents" }, /* @__PURE__ */ React__default.createElement("span", { className }, status === "saving" ? /* @__PURE__ */ React__default.createElement(Tooltip$3, { title: texts.table3.editing.saving.progress }, /* @__PURE__ */ React__default.createElement(Spinner, { delay: 0, className: "mr-1 !h-5 !w-5" })) : /* @__PURE__ */ React__default.createElement(Tooltip$3, { title: texts.table3.editing.saving.complete }, /* @__PURE__ */ React__default.createElement(BadgeIcon, { icon: "tick", color: "green", subtle: true, className: "mr-1" }))));
+}
 function DiscardChangesConfirmationDialog(props) {
   const { onDiscard: handleDiscard, ...dialogProps } = props;
   const { texts } = useLocalization();
@@ -53844,54 +56004,6 @@ function DiscardChangesConfirmationDialog(props) {
     /* @__PURE__ */ React__default.createElement(Dialog.Footer, null, /* @__PURE__ */ React__default.createElement(Group$6, null, /* @__PURE__ */ React__default.createElement(Dialog.Close, null, /* @__PURE__ */ React__default.createElement(Button$4, { tabIndex: 0 }, texts.table3.editing.clearChangesConfirmationDialog.cancel)), /* @__PURE__ */ React__default.createElement(Dialog.Close, null, /* @__PURE__ */ React__default.createElement(Button$4, { tabIndex: 0, appearance: "primary", onClick: handleDiscard }, texts.table3.editing.clearChangesConfirmationDialog.confirm))))
   ));
 }
-function EditingActionsMenu(props) {
-  const { hasChanges, hasErrors, onDiscard: handleDiscard, onEditingSave: handleSave, isLastRow } = props;
-  const { texts } = useLocalization();
-  const handleKeyDown = (event) => {
-    if (isLastRow && hasChanges && event.key === "Tab") {
-      handleSave();
-    }
-  };
-  const handleMenuContentKeyDown = (event) => {
-    if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
-      event.stopPropagation();
-    }
-  };
-  return /* @__PURE__ */ React__default.createElement(
-    IconButton,
-    {
-      appearance: "transparent",
-      "aria-label": texts.table3.editing.actions.tooltip,
-      icon: "more",
-      onKeyDown: handleKeyDown,
-      menu: (menuProps) => /* @__PURE__ */ React__default.createElement(Menu$1, { ...menuProps }, /* @__PURE__ */ React__default.createElement(Menu$1.Content, { onKeyDown: handleMenuContentKeyDown }, /* @__PURE__ */ React__default.createElement(Menu$1.Item, { icon: "tick", disabled: !hasChanges || hasErrors, onClick: handleSave }, texts.table3.editing.actions.save), /* @__PURE__ */ React__default.createElement(
-        Menu$1.Item,
-        {
-          icon: "close",
-          disabled: !hasChanges,
-          dialog: (props2) => /* @__PURE__ */ React__default.createElement(DiscardChangesConfirmationDialog, { ...props2, onDiscard: handleDiscard })
-        },
-        texts.table3.editing.actions.clear
-      )))
-    }
-  );
-}
-function SaveStatus(props) {
-  const { rowId, table } = props;
-  const { texts } = useLocalization();
-  const tableMeta = table.options.meta;
-  const status = tableMeta.editing.getRowStatus(rowId);
-  const className = clsx(
-    "col-span-full sticky ml-auto right-0 top-0 -mb-[100%] z-10 h-8 bg-[inherit] flex items-center px-1.5 shadow-[-6px_0px_6px_var(--table-row-actions-shadow)]",
-    {
-      "mt-0.5": tableMeta.rowHeight.height === "short",
-      "mt-1": tableMeta.rowHeight.height === "medium",
-      "mt-1.5": tableMeta.rowHeight.height === "tall",
-      "mt-2": tableMeta.rowHeight.height === "extra-tall"
-    }
-  );
-  return /* @__PURE__ */ React__default.createElement("td", { className: "!contents" }, /* @__PURE__ */ React__default.createElement("span", { className }, status === "saving" ? /* @__PURE__ */ React__default.createElement(Tooltip$3, { title: texts.table3.editing.saving.progress }, /* @__PURE__ */ React__default.createElement(Spinner, { delay: 0, className: "mr-1 !h-5 !w-5" })) : /* @__PURE__ */ React__default.createElement(Tooltip$3, { title: texts.table3.editing.saving.complete }, /* @__PURE__ */ React__default.createElement(BadgeIcon, { icon: "tick", color: "green", subtle: true, className: "mr-1" }))));
-}
 function Row(props) {
   const { row, index: index2, table } = props;
   const focusManager = useAugmentedFocusManager();
@@ -53962,6 +56074,7 @@ const RENDERERS = {
   cell: Cell$1
 };
 function useTable3(props, ref) {
+  const { texts } = useLocalization();
   const editing = useTableEditing(
     props.enableEditing,
     props.onEditingSave,
@@ -53971,7 +56084,6 @@ function useTable3(props, ref) {
     props.rowIdentityAccessor,
     props.validator
   );
-  const creationEnabled = editing.isEnabled && !!props.onEditingCreate;
   const data = React__default.useMemo(() => {
     if (editing.temporaryRows.length) {
       return (props.data ?? []).concat(editing.temporaryRows);
@@ -53983,31 +56095,42 @@ function useTable3(props, ref) {
     data,
     enableRowActions: editing.isEditing ? true : props.enableRowActions,
     // Display EditingActionMenu instead of row actions while editing
-    rowActions: editing.isEditing ? [
-      (_, rowId, __, table2) => {
-        const tableMeta = table2.options.meta;
-        return /* @__PURE__ */ React__default.createElement(
-          EditingActionsMenu,
-          {
-            hasChanges: editing.hasChanges(rowId),
-            hasErrors: editing.hasRowErrors(rowId),
-            onDiscard: () => {
-              editing.discardChanges(rowId, table2);
-              if (editing.temporaryRows.length) {
-                requestAnimationFrame(() => {
-                  var _a;
-                  return (_a = editing.createRowButtonRef.current) == null ? void 0 : _a.focus();
-                });
-              }
-            },
-            onEditingSave: async () => {
-              await editing.saveChanges(table2, rowId);
-            },
-            isLastRow: !creationEnabled && tableMeta.rowActive.rowActiveIndex === tableMeta.length - 1
+    rowActions: editing.isEditing ? (props.rowActions ?? []).concat([
+      (_1, helpers) => /* @__PURE__ */ React__default.createElement(
+        IconButton,
+        {
+          "aria-label": texts.table3.editing.actions.save,
+          icon: "tick",
+          disabled: !editing.hasChanges(helpers.rowId) || editing.hasRowErrors(helpers.rowId),
+          onClick: async () => {
+            await editing.saveChanges(helpers.table, helpers.rowId);
           }
-        );
-      }
-    ] : props.rowActions
+        }
+      ),
+      (_1, helpers) => /* @__PURE__ */ React__default.createElement(
+        IconButton,
+        {
+          "aria-label": texts.table3.editing.actions.clear,
+          icon: "close",
+          disabled: !editing.hasChanges(helpers.rowId),
+          dialog: (props2) => /* @__PURE__ */ React__default.createElement(
+            DiscardChangesConfirmationDialog,
+            {
+              ...props2,
+              onDiscard: () => {
+                editing.discardChanges(helpers.rowId, helpers.table);
+                if (editing.temporaryRows.length) {
+                  requestAnimationFrame(() => {
+                    var _a;
+                    return (_a = editing.createRowButtonRef.current) == null ? void 0 : _a.focus();
+                  });
+                }
+              }
+            }
+          )
+        }
+      )
+    ]) : props.rowActions
   };
   const meta = { editing };
   const options = {
@@ -54153,16 +56276,15 @@ function CreateNewRow(props) {
   } else {
     tooltip = /* @__PURE__ */ React__default.createElement(Shortcut, { keys: shortcut2 });
   }
-  const className = clsx("group/row border-grey-300 !sticky z-[21]", {
+  const className = clsx("group/row !sticky z-[21]", {
     "bottom-10": tableMeta.footer.isEnabled,
-    "bottom-0": !tableMeta.footer.isEnabled,
-    "border-b": !isScrolled
+    "bottom-0": !tableMeta.footer.isEnabled
   });
-  return /* @__PURE__ */ React__default.createElement("tr", { "data-row-create": true, className, tabIndex: -1 }, /* @__PURE__ */ React__default.createElement("td", { className: "!bg-grey-50 col-span-full !border-b-0 !px-1" }, /* @__PURE__ */ React__default.createElement(
+  return /* @__PURE__ */ React__default.createElement("tr", { "data-row-create": true, className, tabIndex: -1 }, /* @__PURE__ */ React__default.createElement("td", { className: "!bg-grey-50 col-span-full !px-1" }, /* @__PURE__ */ React__default.createElement(
     Button$4,
     {
       appearance: "transparent",
-      className: "group-hover:bg-grey-200 sticky left-[4px]",
+      className: "group-hover:bg-grey-200 sticky left-[4px] font-bold",
       disabled: isDisabled,
       onClick: handleCreate,
       ref: buttonRef,
@@ -54173,13 +56295,20 @@ function CreateNewRow(props) {
     texts.table3.editing.buttons.create.label
   )));
 }
+function TemporaryRows(props) {
+  return props.table.getBottomRows().map((row) => /* @__PURE__ */ React__default.createElement(TemporaryRow, { key: row.id, row, ...props }));
+}
 function TemporaryRow(props) {
-  const { createRowButtonRef, isScrolled, table, tableMeta, tableRef } = props;
+  const { createRowButtonRef, row, table, tableMeta, tableRef } = props;
   const handleKeyDown = async (event) => {
-    var _a, _b;
+    var _a;
+    const target = event.target;
+    if (isAriaDirectionKey(event) && isElementInsideExternalRelatedOverlay(target, tableRef)) {
+      return;
+    }
     if (event.key === "ArrowDown") {
       event.preventDefault();
-      if (!isElementTriggeredFromContainer(event.target, event.currentTarget)) {
+      if (!isElementTriggeredFromContainer(target, event.currentTarget)) {
         const saved = await tableMeta.editing.saveChanges(table);
         if (saved) {
           (_a = createRowButtonRef.current) == null ? void 0 : _a.focus();
@@ -54188,28 +56317,15 @@ function TemporaryRow(props) {
     } else if (event.key === "ArrowUp") {
       event.preventDefault();
       event.stopPropagation();
+      const lastIndex = tableMeta.length - 1;
+      tableMeta.rowActive.setRowActiveIndex(lastIndex);
       if (tableRef.current) {
-        const availableRows = Array.from(
-          tableRef.current.querySelectorAll(`tbody tr:not([data-row-id^='${TEMPORARY_ROW_ID_PREFIX}'])`) ?? []
-        );
-        const footerHeight = ((_b = tableRef.current.querySelector("tfoot")) == null ? void 0 : _b.getBoundingClientRect().height) ?? 0;
-        const newRowHeight = event.currentTarget.getBoundingClientRect().height;
-        const visibleHeight = tableRef.current.clientHeight - footerHeight - newRowHeight;
-        const tableTopOffset = tableRef.current.getBoundingClientRect().top;
-        let nextRowIndex;
-        for (let index2 = availableRows.length - 1; index2 >= 0; index2--) {
-          const rowRect = availableRows[index2].getBoundingClientRect();
-          const topPlusHalfRow = rowRect.top + rowRect.height / 2;
-          if (topPlusHalfRow - tableTopOffset <= visibleHeight) {
-            nextRowIndex = index2;
-            break;
+        tableRef.current.scrollTop = tableRef.current.scrollHeight;
+        requestAnimationFrame(() => {
+          if (tableRef.current) {
+            tableRef.current.scrollTop = tableRef.current.scrollHeight;
           }
-        }
-        if (nextRowIndex) {
-          tableMeta.rowActive.setRowActiveIndex(
-            Number(availableRows[nextRowIndex < 0 ? 0 : nextRowIndex].getAttribute("data-row-index"))
-          );
-        }
+        });
       }
     }
   };
@@ -54224,12 +56340,11 @@ function TemporaryRow(props) {
       }
     }
   };
-  const className = clsx("group/row border-grey-300 !sticky z-[22] print:hidden", {
-    "bottom-[calc(5rem_+_2px)] data-[row-editing-move]:bottom-[calc(5rem_+_2px)]": tableMeta.footer.isEnabled,
-    "bottom-[calc(2.5rem_+_2px)] data-[row-editing-move]:bottom-[calc(2.5rem_+_2px)]": !tableMeta.footer.isEnabled,
-    "border-t-2 shadow-[0px_-5px_20px_0px_rgba(0,0,0,0.1)] [&>td]:!border-b-0": isScrolled
+  const className = clsx("group/row border-grey-300 !sticky z-[22] print:hidden border-t-2", {
+    "bottom-[calc(5rem_+_5px)] data-[row-editing-move]:bottom-[calc(5rem_+_5px)]": tableMeta.footer.isEnabled,
+    "bottom-[calc(2.5rem_+_5px)] data-[row-editing-move]:bottom-[calc(2.5rem_+_5px)]": !tableMeta.footer.isEnabled
   });
-  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, table.getBottomRows().map((row) => /* @__PURE__ */ React__default.createElement(
+  return /* @__PURE__ */ React__default.createElement(
     Row$2,
     {
       key: row.id,
@@ -54246,7 +56361,7 @@ function TemporaryRow(props) {
       hideRowActions: !tableMeta.editing.isEditing,
       skipPageLoading: true
     }
-  )));
+  );
 }
 const Column = () => null;
 Column.displayName = "Table3Column";
@@ -54299,10 +56414,9 @@ const BaseTable3 = fixedForwardRef(function BaseTable32(props, ref) {
       table: table3
     },
     hasCreateWorkflow ? /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement(
-      TemporaryRow,
+      TemporaryRows,
       {
         createRowButtonRef: table3.meta.editing.createRowButtonRef,
-        isScrolled,
         table: table3.instance,
         tableMeta: table3.meta,
         tableRef: table3.ref
@@ -59130,9 +61244,9 @@ _defineProperty$J(ReactFloater, "propTypes", { autoOpen: PropTypes.bool, callbac
   return !props.component;
 }), debug: PropTypes.bool, disableAnimation: PropTypes.bool, disableFlip: PropTypes.bool, disableHoverToClick: PropTypes.bool, event: PropTypes.oneOf(["hover", "click"]), eventDelay: PropTypes.number, footer: PropTypes.node, getPopper: PropTypes.func, hideArrow: PropTypes.bool, id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]), offset: PropTypes.number, open: PropTypes.bool, options: PropTypes.object, placement: PropTypes.oneOf(["top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end", "right", "right-start", "right-end", "auto", "center"]), showCloseButton: PropTypes.bool, style: PropTypes.object, styles: PropTypes.object, target: PropTypes.oneOfType([PropTypes.object, PropTypes.string]), title: PropTypes.node, wrapperOptions: PropTypes.shape({ offset: PropTypes.number, placement: PropTypes.oneOf(["top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end", "right", "right-start", "right-end", "auto"]), position: PropTypes.bool }) });
 _defineProperty$J(ReactFloater, "defaultProps", { autoOpen: false, callback: noop$2, debug: false, disableAnimation: false, disableFlip: false, disableHoverToClick: false, event: "click", eventDelay: 0.4, getPopper: noop$2, hideArrow: false, offset: 15, placement: "bottom", showCloseButton: false, styles: {}, target: null, wrapperOptions: { position: false } });
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
 var ACTIONS = {
   INIT: "init",
   START: "start",
@@ -59835,15 +61949,15 @@ var defaultState = {
 var validKeys = objectKeys(omit(defaultState, "controlled", "size"));
 var Store = class {
   constructor(options) {
-    __publicField(this, "beaconPopper");
-    __publicField(this, "tooltipPopper");
-    __publicField(this, "data", /* @__PURE__ */ new Map());
-    __publicField(this, "listener");
-    __publicField(this, "store", /* @__PURE__ */ new Map());
-    __publicField(this, "addListener", (listener) => {
+    __publicField2(this, "beaconPopper");
+    __publicField2(this, "tooltipPopper");
+    __publicField2(this, "data", /* @__PURE__ */ new Map());
+    __publicField2(this, "listener");
+    __publicField2(this, "store", /* @__PURE__ */ new Map());
+    __publicField2(this, "addListener", (listener) => {
       this.listener = listener;
     });
-    __publicField(this, "setSteps", (steps3) => {
+    __publicField2(this, "setSteps", (steps3) => {
       const { size: size2, status } = this.getState();
       const state = {
         size: steps3.length,
@@ -59855,24 +61969,24 @@ var Store = class {
       }
       this.setState(state);
     });
-    __publicField(this, "getPopper", (name) => {
+    __publicField2(this, "getPopper", (name) => {
       if (name === "beacon") {
         return this.beaconPopper;
       }
       return this.tooltipPopper;
     });
-    __publicField(this, "setPopper", (name, popper) => {
+    __publicField2(this, "setPopper", (name, popper) => {
       if (name === "beacon") {
         this.beaconPopper = popper;
       } else {
         this.tooltipPopper = popper;
       }
     });
-    __publicField(this, "cleanupPoppers", () => {
+    __publicField2(this, "cleanupPoppers", () => {
       this.beaconPopper = null;
       this.tooltipPopper = null;
     });
-    __publicField(this, "close", (origin = null) => {
+    __publicField2(this, "close", (origin = null) => {
       const { index: index2, status } = this.getState();
       if (status !== STATUS.RUNNING) {
         return;
@@ -59881,7 +61995,7 @@ var Store = class {
         ...this.getNextState({ action: ACTIONS.CLOSE, index: index2 + 1, origin })
       });
     });
-    __publicField(this, "go", (nextIndex) => {
+    __publicField2(this, "go", (nextIndex) => {
       const { controlled, status } = this.getState();
       if (controlled || status !== STATUS.RUNNING) {
         return;
@@ -59892,15 +62006,15 @@ var Store = class {
         status: step ? status : STATUS.FINISHED
       });
     });
-    __publicField(this, "info", () => this.getState());
-    __publicField(this, "next", () => {
+    __publicField2(this, "info", () => this.getState());
+    __publicField2(this, "next", () => {
       const { index: index2, status } = this.getState();
       if (status !== STATUS.RUNNING) {
         return;
       }
       this.setState(this.getNextState({ action: ACTIONS.NEXT, index: index2 + 1 }));
     });
-    __publicField(this, "open", () => {
+    __publicField2(this, "open", () => {
       const { status } = this.getState();
       if (status !== STATUS.RUNNING) {
         return;
@@ -59909,7 +62023,7 @@ var Store = class {
         ...this.getNextState({ action: ACTIONS.UPDATE, lifecycle: LIFECYCLE.TOOLTIP })
       });
     });
-    __publicField(this, "prev", () => {
+    __publicField2(this, "prev", () => {
       const { index: index2, status } = this.getState();
       if (status !== STATUS.RUNNING) {
         return;
@@ -59918,7 +62032,7 @@ var Store = class {
         ...this.getNextState({ action: ACTIONS.PREV, index: index2 - 1 })
       });
     });
-    __publicField(this, "reset", (restart = false) => {
+    __publicField2(this, "reset", (restart = false) => {
       const { controlled } = this.getState();
       if (controlled) {
         return;
@@ -59928,7 +62042,7 @@ var Store = class {
         status: restart ? STATUS.RUNNING : STATUS.READY
       });
     });
-    __publicField(this, "skip", () => {
+    __publicField2(this, "skip", () => {
       const { status } = this.getState();
       if (status !== STATUS.RUNNING) {
         return;
@@ -59939,7 +62053,7 @@ var Store = class {
         status: STATUS.SKIPPED
       });
     });
-    __publicField(this, "start", (nextIndex) => {
+    __publicField2(this, "start", (nextIndex) => {
       const { index: index2, size: size2 } = this.getState();
       this.setState({
         ...this.getNextState(
@@ -59952,7 +62066,7 @@ var Store = class {
         status: size2 ? STATUS.RUNNING : STATUS.WAITING
       });
     });
-    __publicField(this, "stop", (advance = false) => {
+    __publicField2(this, "stop", (advance = false) => {
       const { index: index2, status } = this.getState();
       if ([STATUS.FINISHED, STATUS.SKIPPED].includes(status)) {
         return;
@@ -59962,7 +62076,7 @@ var Store = class {
         status: STATUS.PAUSED
       });
     });
-    __publicField(this, "update", (state) => {
+    __publicField2(this, "update", (state) => {
       var _a, _b;
       if (!hasValidKeys(state, validKeys)) {
         throw new Error(`State is not valid. Valid keys: ${validKeys.join(", ")}`);
@@ -60093,16 +62207,16 @@ var Spotlight_default = JoyrideSpotlight;
 var JoyrideOverlay = class extends React.Component {
   constructor() {
     super(...arguments);
-    __publicField(this, "isActive", false);
-    __publicField(this, "resizeTimeout");
-    __publicField(this, "scrollTimeout");
-    __publicField(this, "scrollParent");
-    __publicField(this, "state", {
+    __publicField2(this, "isActive", false);
+    __publicField2(this, "resizeTimeout");
+    __publicField2(this, "scrollTimeout");
+    __publicField2(this, "scrollParent");
+    __publicField2(this, "state", {
       isScrolling: false,
       mouseOverSpotlight: false,
       showSpotlight: true
     });
-    __publicField(this, "hideSpotlight", () => {
+    __publicField2(this, "hideSpotlight", () => {
       const { continuous: continuous2, disableOverlay, lifecycle } = this.props;
       const hiddenLifecycles = [
         LIFECYCLE.INIT,
@@ -60112,7 +62226,7 @@ var JoyrideOverlay = class extends React.Component {
       ];
       return disableOverlay || (continuous2 ? hiddenLifecycles.includes(lifecycle) : lifecycle !== LIFECYCLE.TOOLTIP);
     });
-    __publicField(this, "handleMouseMove", (event) => {
+    __publicField2(this, "handleMouseMove", (event) => {
       const { mouseOverSpotlight } = this.state;
       const { height, left, position, top, width } = this.spotlightStyles;
       const offsetY = position === "fixed" ? event.clientY : event.pageY;
@@ -60124,7 +62238,7 @@ var JoyrideOverlay = class extends React.Component {
         this.updateState({ mouseOverSpotlight: inSpotlight });
       }
     });
-    __publicField(this, "handleScroll", () => {
+    __publicField2(this, "handleScroll", () => {
       const { target } = this.props;
       const element = getElement(target);
       if (this.scrollParent !== document) {
@@ -60140,7 +62254,7 @@ var JoyrideOverlay = class extends React.Component {
         this.updateState({});
       }
     });
-    __publicField(this, "handleResize", () => {
+    __publicField2(this, "handleResize", () => {
       clearTimeout(this.resizeTimeout);
       this.resizeTimeout = window.setTimeout(() => {
         if (!this.isActive) {
@@ -60275,7 +62389,7 @@ var JoyrideOverlay = class extends React.Component {
 var JoyridePortal = class extends React.Component {
   constructor() {
     super(...arguments);
-    __publicField(this, "node", null);
+    __publicField2(this, "node", null);
   }
   componentDidMount() {
     const { id: id2 } = this.props;
@@ -60337,29 +62451,29 @@ var JoyridePortal = class extends React.Component {
 };
 var Scope = class {
   constructor(element, options) {
-    __publicField(this, "element");
-    __publicField(this, "options");
-    __publicField(this, "canBeTabbed", (element2) => {
+    __publicField2(this, "element");
+    __publicField2(this, "options");
+    __publicField2(this, "canBeTabbed", (element2) => {
       const { tabIndex } = element2;
       if (tabIndex === null || tabIndex < 0) {
         return false;
       }
       return this.canHaveFocus(element2);
     });
-    __publicField(this, "canHaveFocus", (element2) => {
+    __publicField2(this, "canHaveFocus", (element2) => {
       const validTabNodes = /input|select|textarea|button|object/;
       const nodeName = element2.nodeName.toLowerCase();
       const isValid2 = validTabNodes.test(nodeName) && !element2.getAttribute("disabled") || nodeName === "a" && !!element2.getAttribute("href");
       return isValid2 && this.isVisible(element2);
     });
-    __publicField(this, "findValidTabElements", () => [].slice.call(this.element.querySelectorAll("*"), 0).filter(this.canBeTabbed));
-    __publicField(this, "handleKeyDown", (event) => {
+    __publicField2(this, "findValidTabElements", () => [].slice.call(this.element.querySelectorAll("*"), 0).filter(this.canBeTabbed));
+    __publicField2(this, "handleKeyDown", (event) => {
       const { code = "Tab" } = this.options;
       if (event.code === code) {
         this.interceptTab(event);
       }
     });
-    __publicField(this, "interceptTab", (event) => {
+    __publicField2(this, "interceptTab", (event) => {
       event.preventDefault();
       const elements = this.findValidTabElements();
       const { shiftKey } = event;
@@ -60376,7 +62490,7 @@ var Scope = class {
       }
       elements[x2].focus();
     });
-    __publicField(this, "isHidden", (element2) => {
+    __publicField2(this, "isHidden", (element2) => {
       const noSize = element2.offsetWidth <= 0 && element2.offsetHeight <= 0;
       const style = window.getComputedStyle(element2);
       if (noSize && !element2.innerHTML) {
@@ -60384,7 +62498,7 @@ var Scope = class {
       }
       return noSize && style.getPropertyValue("overflow") !== "visible" || style.getPropertyValue("display") === "none";
     });
-    __publicField(this, "isVisible", (element2) => {
+    __publicField2(this, "isVisible", (element2) => {
       let parentElement = element2;
       while (parentElement) {
         if (parentElement instanceof HTMLElement) {
@@ -60399,16 +62513,16 @@ var Scope = class {
       }
       return true;
     });
-    __publicField(this, "removeScope", () => {
+    __publicField2(this, "removeScope", () => {
       window.removeEventListener("keydown", this.handleKeyDown);
     });
-    __publicField(this, "checkFocus", (target) => {
+    __publicField2(this, "checkFocus", (target) => {
       if (document.activeElement !== target) {
         target.focus();
         window.requestAnimationFrame(() => this.checkFocus(target));
       }
     });
-    __publicField(this, "setFocus", () => {
+    __publicField2(this, "setFocus", () => {
       const { selector } = this.options;
       if (!selector) {
         return;
@@ -60430,8 +62544,8 @@ var Scope = class {
 var JoyrideBeacon = class extends React.Component {
   constructor(props) {
     super(props);
-    __publicField(this, "beacon", null);
-    __publicField(this, "setBeaconRef", (c2) => {
+    __publicField2(this, "beacon", null);
+    __publicField2(this, "setBeaconRef", (c2) => {
       this.beacon = c2;
     });
     if (props.beaconComponent) {
@@ -60613,17 +62727,17 @@ var Container_default = JoyrideTooltipContainer;
 var JoyrideTooltip = class extends React.Component {
   constructor() {
     super(...arguments);
-    __publicField(this, "handleClickBack", (event) => {
+    __publicField2(this, "handleClickBack", (event) => {
       event.preventDefault();
       const { helpers } = this.props;
       helpers.prev();
     });
-    __publicField(this, "handleClickClose", (event) => {
+    __publicField2(this, "handleClickClose", (event) => {
       event.preventDefault();
       const { helpers } = this.props;
       helpers.close("button_close");
     });
-    __publicField(this, "handleClickPrimary", (event) => {
+    __publicField2(this, "handleClickPrimary", (event) => {
       event.preventDefault();
       const { continuous: continuous2, helpers } = this.props;
       if (!continuous2) {
@@ -60632,12 +62746,12 @@ var JoyrideTooltip = class extends React.Component {
       }
       helpers.next();
     });
-    __publicField(this, "handleClickSkip", (event) => {
+    __publicField2(this, "handleClickSkip", (event) => {
       event.preventDefault();
       const { helpers } = this.props;
       helpers.skip();
     });
-    __publicField(this, "getElementsProps", () => {
+    __publicField2(this, "getElementsProps", () => {
       const { continuous: continuous2, index: index2, isLastStep, setTooltipRef, size: size2, step } = this.props;
       const { back, close, last: last2, next, nextLabelWithProgress, skip } = step.locale;
       const backText = getReactNodeText(back);
@@ -60739,19 +62853,19 @@ var JoyrideTooltip = class extends React.Component {
 var JoyrideStep = class extends React.Component {
   constructor() {
     super(...arguments);
-    __publicField(this, "scope", null);
-    __publicField(this, "tooltip", null);
-    __publicField(this, "handleClickHoverBeacon", (event) => {
+    __publicField2(this, "scope", null);
+    __publicField2(this, "tooltip", null);
+    __publicField2(this, "handleClickHoverBeacon", (event) => {
       const { step, store } = this.props;
       if (event.type === "mouseenter" && step.event !== "hover") {
         return;
       }
       store.update({ lifecycle: LIFECYCLE.TOOLTIP });
     });
-    __publicField(this, "setTooltipRef", (element) => {
+    __publicField2(this, "setTooltipRef", (element) => {
       this.tooltip = element;
     });
-    __publicField(this, "setPopper", (popper, type) => {
+    __publicField2(this, "setPopper", (popper, type) => {
       var _a;
       const { action, lifecycle, step, store } = this.props;
       if (type === "wrapper") {
@@ -60769,7 +62883,7 @@ var JoyrideStep = class extends React.Component {
         step.floaterProps.getPopper(popper, type);
       }
     });
-    __publicField(this, "renderTooltip", (renderProps) => {
+    __publicField2(this, "renderTooltip", (renderProps) => {
       const { continuous: continuous2, helpers, index: index2, size: size2, step } = this.props;
       return /* @__PURE__ */ React.createElement(
         JoyrideTooltip,
@@ -60941,15 +63055,15 @@ var JoyrideStep = class extends React.Component {
 var Joyride = class extends React.Component {
   constructor(props) {
     super(props);
-    __publicField(this, "helpers");
-    __publicField(this, "store");
-    __publicField(this, "callback", (data) => {
+    __publicField2(this, "helpers");
+    __publicField2(this, "store");
+    __publicField2(this, "callback", (data) => {
       const { callback } = this.props;
       if (src_default.function(callback)) {
         callback(data);
       }
     });
-    __publicField(this, "handleKeyboard", (event) => {
+    __publicField2(this, "handleKeyboard", (event) => {
       const { index: index2, lifecycle } = this.state;
       const { steps: steps2 } = this.props;
       const step = steps2[index2];
@@ -60959,7 +63073,7 @@ var Joyride = class extends React.Component {
         }
       }
     });
-    __publicField(this, "handleClickOverlay", () => {
+    __publicField2(this, "handleClickOverlay", () => {
       const { index: index2 } = this.state;
       const { steps: steps2 } = this.props;
       const step = getMergedStep(this.props, steps2[index2]);
@@ -60967,7 +63081,7 @@ var Joyride = class extends React.Component {
         this.helpers.close("overlay");
       }
     });
-    __publicField(this, "syncState", (state) => {
+    __publicField2(this, "syncState", (state) => {
       this.setState(state);
     });
     const { debug: debug2, getHelpers, run = true, stepIndex } = props;
@@ -61217,7 +63331,7 @@ var Joyride = class extends React.Component {
     return /* @__PURE__ */ React.createElement("div", { className: "react-joyride" }, content.step, content.overlay);
   }
 };
-__publicField(Joyride, "defaultProps", defaultProps$4);
+__publicField2(Joyride, "defaultProps", defaultProps$4);
 var components_default = Joyride;
 const Tooltip$2 = ({
   continuous: continuous2,
@@ -86199,7 +88313,7 @@ function getDataKey(sorting, filters, hiddenColumns, search) {
 function useTableDataLoader2(fetchPage, fetchAll, options = { pageSize: DEFAULT_PAGE_SIZE$1 }) {
   const { pageSize } = options;
   const DATASET_SIZE = DATASET_SIZE_MULTIPLIER * pageSize;
-  const length = React__default.useRef(0);
+  const length = React__default.useRef(void 0);
   const [data, setData] = React__default.useState({ rows: [], pages: [], cache: {}, lastFetchedPage: void 0 });
   const _pendingPageRequests = React__default.useRef({});
   const _lastUsedSorting = React__default.useRef([]);