tp-react-elements-dev 1.14.3 → 1.14.4

package/dist/node_modules/date-fns/parse/_lib/parsers/YearParser.esm.js

@@ -0,0 +1,62 @@
+import { Parser } from '../Parser.esm.js';
+import { mapValue, parseNDigits, normalizeTwoDigitYear } from '../utils.esm.js';
+
+// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns
+// | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+// |----------|-------|----|-------|-------|-------|
+// | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+// | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+// | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+// | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+class YearParser extends Parser {
+  priority = 130;
+  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+
+  parse(dateString, token, match) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "yy",
+    });
+
+    switch (token) {
+      case "y":
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+      case "yo":
+        return mapValue(
+          match.ordinalNumber(dateString, {
+            unit: "year",
+          }),
+          valueCallback,
+        );
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+
+  set(date, flags, value) {
+    const currentYear = date.getFullYear();
+
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(
+        value.year,
+        currentYear,
+      );
+      date.setFullYear(normalizedTwoDigitYear, 0, 1);
+      date.setHours(0, 0, 0, 0);
+      return date;
+    }
+
+    const year =
+      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date.setFullYear(year, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+}
+
+export { YearParser };

package/dist/node_modules/date-fns/parse/_lib/parsers/YearParser.esm2.js

@@ -0,0 +1,82 @@
+import { __exports as YearParser } from '../../../../../_virtual/YearParser.esm.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredYearParser;
+
+function requireYearParser () {
+	if (hasRequiredYearParser) return YearParser;
+	hasRequiredYearParser = 1;
+	YearParser.YearParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns
+	// | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+	// |----------|-------|----|-------|-------|-------|
+	// | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+	// | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+	// | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+	// | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+	// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+	let YearParser$1 = class YearParser extends _Parser.Parser {
+	  priority = 130;
+	  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (year) => ({
+	      year,
+	      isTwoDigitYear: token === "yy",
+	    });
+
+	    switch (token) {
+	      case "y":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(4, dateString),
+	          valueCallback,
+	        );
+	      case "yo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "year",
+	          }),
+	          valueCallback,
+	        );
+	      default:
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(token.length, dateString),
+	          valueCallback,
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value.isTwoDigitYear || value.year > 0;
+	  }
+
+	  set(date, flags, value) {
+	    const currentYear = date.getFullYear();
+
+	    if (value.isTwoDigitYear) {
+	      const normalizedTwoDigitYear = (0, _utils.normalizeTwoDigitYear)(
+	        value.year,
+	        currentYear,
+	      );
+	      date.setFullYear(normalizedTwoDigitYear, 0, 1);
+	      date.setHours(0, 0, 0, 0);
+	      return date;
+	    }
+
+	    const year =
+	      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+	    date.setFullYear(year, 0, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+	};
+	YearParser.YearParser = YearParser$1;
+	return YearParser;
+}
+
+export { requireYearParser as __require };

package/dist/node_modules/date-fns/parse/_lib/parsers.esm.js

@@ -0,0 +1,110 @@
+import { EraParser } from './parsers/EraParser.esm.js';
+import { YearParser } from './parsers/YearParser.esm.js';
+import { LocalWeekYearParser } from './parsers/LocalWeekYearParser.esm.js';
+import { ISOWeekYearParser } from './parsers/ISOWeekYearParser.esm.js';
+import { ExtendedYearParser } from './parsers/ExtendedYearParser.esm.js';
+import { QuarterParser } from './parsers/QuarterParser.esm.js';
+import { StandAloneQuarterParser } from './parsers/StandAloneQuarterParser.esm.js';
+import { MonthParser } from './parsers/MonthParser.esm.js';
+import { StandAloneMonthParser } from './parsers/StandAloneMonthParser.esm.js';
+import { LocalWeekParser } from './parsers/LocalWeekParser.esm.js';
+import { ISOWeekParser } from './parsers/ISOWeekParser.esm.js';
+import { DateParser } from './parsers/DateParser.esm.js';
+import { DayOfYearParser } from './parsers/DayOfYearParser.esm.js';
+import { DayParser } from './parsers/DayParser.esm.js';
+import { LocalDayParser } from './parsers/LocalDayParser.esm.js';
+import { StandAloneLocalDayParser } from './parsers/StandAloneLocalDayParser.esm.js';
+import { ISODayParser } from './parsers/ISODayParser.esm.js';
+import { AMPMParser } from './parsers/AMPMParser.esm.js';
+import { AMPMMidnightParser } from './parsers/AMPMMidnightParser.esm.js';
+import { DayPeriodParser } from './parsers/DayPeriodParser.esm.js';
+import { Hour1to12Parser } from './parsers/Hour1to12Parser.esm.js';
+import { Hour0to23Parser } from './parsers/Hour0to23Parser.esm.js';
+import { Hour0To11Parser } from './parsers/Hour0To11Parser.esm.js';
+import { Hour1To24Parser } from './parsers/Hour1To24Parser.esm.js';
+import { MinuteParser } from './parsers/MinuteParser.esm.js';
+import { SecondParser } from './parsers/SecondParser.esm.js';
+import { FractionOfSecondParser } from './parsers/FractionOfSecondParser.esm.js';
+import { ISOTimezoneWithZParser } from './parsers/ISOTimezoneWithZParser.esm.js';
+import { ISOTimezoneParser } from './parsers/ISOTimezoneParser.esm.js';
+import { TimestampSecondsParser } from './parsers/TimestampSecondsParser.esm.js';
+import { TimestampMillisecondsParser } from './parsers/TimestampMillisecondsParser.esm.js';
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O* | Timezone (GMT)                 |
+ * |  p  |                                |  P  |                                |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z* | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ */
+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(),
+};
+
+export { parsers };

package/dist/node_modules/date-fns/parse/_lib/parsers.esm2.js

@@ -0,0 +1,151 @@
+import { __exports as parsers } from '../../../../_virtual/parsers.esm.js';
+import { __require as requireEraParser } from './parsers/EraParser.esm2.js';
+import { __require as requireYearParser } from './parsers/YearParser.esm2.js';
+import { __require as requireLocalWeekYearParser } from './parsers/LocalWeekYearParser.esm2.js';
+import { __require as requireISOWeekYearParser } from './parsers/ISOWeekYearParser.esm2.js';
+import { __require as requireExtendedYearParser } from './parsers/ExtendedYearParser.esm2.js';
+import { __require as requireQuarterParser } from './parsers/QuarterParser.esm2.js';
+import { __require as requireStandAloneQuarterParser } from './parsers/StandAloneQuarterParser.esm2.js';
+import { __require as requireMonthParser } from './parsers/MonthParser.esm2.js';
+import { __require as requireStandAloneMonthParser } from './parsers/StandAloneMonthParser.esm2.js';
+import { __require as requireLocalWeekParser } from './parsers/LocalWeekParser.esm2.js';
+import { __require as requireISOWeekParser } from './parsers/ISOWeekParser.esm2.js';
+import { __require as requireDateParser } from './parsers/DateParser.esm2.js';
+import { __require as requireDayOfYearParser } from './parsers/DayOfYearParser.esm2.js';
+import { __require as requireDayParser } from './parsers/DayParser.esm2.js';
+import { __require as requireLocalDayParser } from './parsers/LocalDayParser.esm2.js';
+import { __require as requireStandAloneLocalDayParser } from './parsers/StandAloneLocalDayParser.esm2.js';
+import { __require as requireISODayParser } from './parsers/ISODayParser.esm2.js';
+import { __require as requireAMPMParser } from './parsers/AMPMParser.esm2.js';
+import { __require as requireAMPMMidnightParser } from './parsers/AMPMMidnightParser.esm2.js';
+import { __require as requireDayPeriodParser } from './parsers/DayPeriodParser.esm2.js';
+import { __require as requireHour1to12Parser } from './parsers/Hour1to12Parser.esm2.js';
+import { __require as requireHour0to23Parser } from './parsers/Hour0to23Parser.esm2.js';
+import { __require as requireHour0To11Parser } from './parsers/Hour0To11Parser.esm2.js';
+import { __require as requireHour1To24Parser } from './parsers/Hour1To24Parser.esm2.js';
+import { __require as requireMinuteParser } from './parsers/MinuteParser.esm2.js';
+import { __require as requireSecondParser } from './parsers/SecondParser.esm2.js';
+import { __require as requireFractionOfSecondParser } from './parsers/FractionOfSecondParser.esm2.js';
+import { __require as requireISOTimezoneWithZParser } from './parsers/ISOTimezoneWithZParser.esm2.js';
+import { __require as requireISOTimezoneParser } from './parsers/ISOTimezoneParser.esm2.js';
+import { __require as requireTimestampSecondsParser } from './parsers/TimestampSecondsParser.esm2.js';
+import { __require as requireTimestampMillisecondsParser } from './parsers/TimestampMillisecondsParser.esm2.js';
+
+var hasRequiredParsers;
+
+function requireParsers () {
+	if (hasRequiredParsers) return parsers;
+	hasRequiredParsers = 1;
+	parsers.parsers = void 0;
+	var _EraParser = /*@__PURE__*/ requireEraParser();
+	var _YearParser = /*@__PURE__*/ requireYearParser();
+	var _LocalWeekYearParser = /*@__PURE__*/ requireLocalWeekYearParser();
+	var _ISOWeekYearParser = /*@__PURE__*/ requireISOWeekYearParser();
+	var _ExtendedYearParser = /*@__PURE__*/ requireExtendedYearParser();
+	var _QuarterParser = /*@__PURE__*/ requireQuarterParser();
+	var _StandAloneQuarterParser = /*@__PURE__*/ requireStandAloneQuarterParser();
+	var _MonthParser = /*@__PURE__*/ requireMonthParser();
+	var _StandAloneMonthParser = /*@__PURE__*/ requireStandAloneMonthParser();
+	var _LocalWeekParser = /*@__PURE__*/ requireLocalWeekParser();
+	var _ISOWeekParser = /*@__PURE__*/ requireISOWeekParser();
+	var _DateParser = /*@__PURE__*/ requireDateParser();
+	var _DayOfYearParser = /*@__PURE__*/ requireDayOfYearParser();
+	var _DayParser = /*@__PURE__*/ requireDayParser();
+	var _LocalDayParser = /*@__PURE__*/ requireLocalDayParser();
+	var _StandAloneLocalDayParser = /*@__PURE__*/ requireStandAloneLocalDayParser();
+	var _ISODayParser = /*@__PURE__*/ requireISODayParser();
+	var _AMPMParser = /*@__PURE__*/ requireAMPMParser();
+	var _AMPMMidnightParser = /*@__PURE__*/ requireAMPMMidnightParser();
+	var _DayPeriodParser = /*@__PURE__*/ requireDayPeriodParser();
+	var _Hour1to12Parser = /*@__PURE__*/ requireHour1to12Parser();
+	var _Hour0to23Parser = /*@__PURE__*/ requireHour0to23Parser();
+	var _Hour0To11Parser = /*@__PURE__*/ requireHour0To11Parser();
+	var _Hour1To24Parser = /*@__PURE__*/ requireHour1To24Parser();
+	var _MinuteParser = /*@__PURE__*/ requireMinuteParser();
+	var _SecondParser = /*@__PURE__*/ requireSecondParser();
+	var _FractionOfSecondParser = /*@__PURE__*/ requireFractionOfSecondParser();
+	var _ISOTimezoneWithZParser = /*@__PURE__*/ requireISOTimezoneWithZParser();
+	var _ISOTimezoneParser = /*@__PURE__*/ requireISOTimezoneParser();
+	var _TimestampSecondsParser = /*@__PURE__*/ requireTimestampSecondsParser();
+	var _TimestampMillisecondsParser = /*@__PURE__*/ requireTimestampMillisecondsParser();
+
+	/*
+	 * |     | Unit                           |     | Unit                           |
+	 * |-----|--------------------------------|-----|--------------------------------|
+	 * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+	 * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+	 * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+	 * |  d  | Day of month                   |  D  | Day of year                    |
+	 * |  e  | Local day of week              |  E  | Day of week                    |
+	 * |  f  |                                |  F* | Day of week in month           |
+	 * |  g* | Modified Julian day            |  G  | Era                            |
+	 * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+	 * |  i! | ISO day of week                |  I! | ISO week of year               |
+	 * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+	 * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+	 * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+	 * |  m  | Minute                         |  M  | Month                          |
+	 * |  n  |                                |  N  |                                |
+	 * |  o! | Ordinal number modifier        |  O* | Timezone (GMT)                 |
+	 * |  p  |                                |  P  |                                |
+	 * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+	 * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+	 * |  s  | Second                         |  S  | Fraction of second             |
+	 * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+	 * |  u  | Extended year                  |  U* | Cyclic year                    |
+	 * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+	 * |  w  | Local week of year             |  W* | Week of month                  |
+	 * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+	 * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+	 * |  z* | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+	 *
+	 * Letters marked by * are not implemented but reserved by Unicode standard.
+	 *
+	 * Letters marked by ! are non-standard, but implemented by date-fns:
+	 * - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)
+	 * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+	 *   i.e. 7 for Sunday, 1 for Monday, etc.
+	 * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+	 * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+	 *   `R` is supposed to be used in conjunction with `I` and `i`
+	 *   for universal ISO week-numbering date, whereas
+	 *   `Y` is supposed to be used in conjunction with `w` and `e`
+	 *   for week-numbering date specific to the locale.
+	 */
+	(parsers.parsers = {
+	  G: new _EraParser.EraParser(),
+	  y: new _YearParser.YearParser(),
+	  Y: new _LocalWeekYearParser.LocalWeekYearParser(),
+	  R: new _ISOWeekYearParser.ISOWeekYearParser(),
+	  u: new _ExtendedYearParser.ExtendedYearParser(),
+	  Q: new _QuarterParser.QuarterParser(),
+	  q: new _StandAloneQuarterParser.StandAloneQuarterParser(),
+	  M: new _MonthParser.MonthParser(),
+	  L: new _StandAloneMonthParser.StandAloneMonthParser(),
+	  w: new _LocalWeekParser.LocalWeekParser(),
+	  I: new _ISOWeekParser.ISOWeekParser(),
+	  d: new _DateParser.DateParser(),
+	  D: new _DayOfYearParser.DayOfYearParser(),
+	  E: new _DayParser.DayParser(),
+	  e: new _LocalDayParser.LocalDayParser(),
+	  c: new _StandAloneLocalDayParser.StandAloneLocalDayParser(),
+	  i: new _ISODayParser.ISODayParser(),
+	  a: new _AMPMParser.AMPMParser(),
+	  b: new _AMPMMidnightParser.AMPMMidnightParser(),
+	  B: new _DayPeriodParser.DayPeriodParser(),
+	  h: new _Hour1to12Parser.Hour1to12Parser(),
+	  H: new _Hour0to23Parser.Hour0to23Parser(),
+	  K: new _Hour0To11Parser.Hour0To11Parser(),
+	  k: new _Hour1To24Parser.Hour1To24Parser(),
+	  m: new _MinuteParser.MinuteParser(),
+	  s: new _SecondParser.SecondParser(),
+	  S: new _FractionOfSecondParser.FractionOfSecondParser(),
+	  X: new _ISOTimezoneWithZParser.ISOTimezoneWithZParser(),
+	  x: new _ISOTimezoneParser.ISOTimezoneParser(),
+	  t: new _TimestampSecondsParser.TimestampSecondsParser(),
+	  T: new _TimestampMillisecondsParser.TimestampMillisecondsParser(),
+	});
+	return parsers;
+}
+
+export { requireParsers as __require };

package/dist/node_modules/date-fns/parse/_lib/utils.esm.js

@@ -0,0 +1,135 @@
+import { millisecondsInHour, millisecondsInMinute, millisecondsInSecond } from '../../constants.esm.js';
+import { numericPatterns } from './constants.esm.js';
+
+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;
+  }
+
+  // Input is 'Z'
+  if (matchResult[0] === "Z") {
+    return {
+      value: 0,
+      rest: dateString.slice(1),
+    };
+  }
+
+  const sign = 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:
+      sign *
+      (hours * millisecondsInHour +
+        minutes * millisecondsInMinute +
+        seconds * millisecondsInSecond),
+    rest: dateString.slice(matchResult[0].length),
+  };
+}
+
+function parseAnyDigitsSigned(dateString) {
+  return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
+}
+
+function parseNDigits(n, dateString) {
+  switch (n) {
+    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," + n + "}"), dateString);
+  }
+}
+
+function parseNDigitsSigned(n, dateString) {
+  switch (n) {
+    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," + n + "}"), 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;
+  // Absolute number of the current year:
+  // 1 -> 1 AC
+  // 0 -> 1 BC
+  // -1 -> 2 BC
+  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(year) {
+  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+}
+
+export { dayPeriodEnumToHours, isLeapYearIndex, mapValue, normalizeTwoDigitYear, parseAnyDigitsSigned, parseNDigits, parseNDigitsSigned, parseNumericPattern, parseTimezonePattern };