tp-react-elements-dev 1.14.3 → 1.14.5

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

@@ -0,0 +1,99 @@
+import { __exports as LocalWeekYearParser } from '../../../../../_virtual/LocalWeekYearParser.esm.js';
+import { __require as requireGetWeekYear } from '../../../getWeekYear.esm2.js';
+import { __require as requireStartOfWeek } from '../../../startOfWeek.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredLocalWeekYearParser;
+
+function requireLocalWeekYearParser () {
+	if (hasRequiredLocalWeekYearParser) return LocalWeekYearParser;
+	hasRequiredLocalWeekYearParser = 1;
+	LocalWeekYearParser.LocalWeekYearParser = void 0;
+	var _index = /*@__PURE__*/ requireGetWeekYear();
+
+	var _index2 = /*@__PURE__*/ requireStartOfWeek();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Local week-numbering year
+	let LocalWeekYearParser$1 = class LocalWeekYearParser extends _Parser.Parser {
+	  priority = 130;
+
+	  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, options) {
+	    const currentYear = (0, _index.getWeekYear)(date, options);
+
+	    if (value.isTwoDigitYear) {
+	      const normalizedTwoDigitYear = (0, _utils.normalizeTwoDigitYear)(
+	        value.year,
+	        currentYear,
+	      );
+	      date.setFullYear(
+	        normalizedTwoDigitYear,
+	        0,
+	        options.firstWeekContainsDate,
+	      );
+	      date.setHours(0, 0, 0, 0);
+	      return (0, _index2.startOfWeek)(date, options);
+	    }
+
+	    const year =
+	      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+	    date.setFullYear(year, 0, options.firstWeekContainsDate);
+	    date.setHours(0, 0, 0, 0);
+	    return (0, _index2.startOfWeek)(date, options);
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "Q",
+	    "q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "t",
+	    "T",
+	  ];
+	};
+	LocalWeekYearParser.LocalWeekYearParser = LocalWeekYearParser$1;
+	return LocalWeekYearParser;
+}
+
+export { requireLocalWeekYearParser as __require };

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

@@ -0,0 +1,31 @@
+import { numericPatterns } from '../constants.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { parseNDigits, parseNumericPattern } from '../utils.esm.js';
+
+class MinuteParser extends Parser {
+  priority = 60;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "m":
+        return parseNumericPattern(numericPatterns.minute, dateString);
+      case "mo":
+        return match.ordinalNumber(dateString, { unit: "minute" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+
+  set(date, _flags, value) {
+    date.setMinutes(value, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}
+
+export { MinuteParser };

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

@@ -0,0 +1,49 @@
+import { __exports as MinuteParser } from '../../../../../_virtual/MinuteParser.esm.js';
+import { __require as requireConstants } from '../constants.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredMinuteParser;
+
+function requireMinuteParser () {
+	if (hasRequiredMinuteParser) return MinuteParser;
+	hasRequiredMinuteParser = 1;
+	MinuteParser.MinuteParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let MinuteParser$1 = class MinuteParser extends _Parser.Parser {
+	  priority = 60;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "m":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.minute,
+	          dateString,
+	        );
+	      case "mo":
+	        return match.ordinalNumber(dateString, { unit: "minute" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 59;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMinutes(value, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["t", "T"];
+	};
+	MinuteParser.MinuteParser = MinuteParser$1;
+	return MinuteParser;
+}
+
+export { requireMinuteParser as __require };

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

@@ -0,0 +1,86 @@
+import { numericPatterns } from '../constants.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { mapValue, parseNDigits, parseNumericPattern } from '../utils.esm.js';
+
+class MonthParser extends Parser {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+
+  priority = 110;
+
+  parse(dateString, token, match) {
+    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(
+          match.ordinalNumber(dateString, {
+            unit: "month",
+          }),
+          valueCallback,
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return (
+          match.month(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.month(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // J, F, ..., D
+      case "MMMMM":
+        return match.month(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return (
+          match.month(dateString, { width: "wide", context: "formatting" }) ||
+          match.month(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.month(dateString, { width: "narrow", context: "formatting" })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+
+  set(date, _flags, value) {
+    date.setMonth(value, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+}
+
+export { MonthParser };

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

@@ -0,0 +1,107 @@
+import { __exports as MonthParser } from '../../../../../_virtual/MonthParser.esm.js';
+import { __require as requireConstants } from '../constants.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredMonthParser;
+
+function requireMonthParser () {
+	if (hasRequiredMonthParser) return MonthParser;
+	hasRequiredMonthParser = 1;
+	MonthParser.MonthParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let MonthParser$1 = class MonthParser extends _Parser.Parser {
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "Q",
+	    "L",
+	    "w",
+	    "I",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+
+	  priority = 110;
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (value) => value - 1;
+
+	    switch (token) {
+	      // 1, 2, ..., 12
+	      case "M":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNumericPattern)(
+	            _constants.numericPatterns.month,
+	            dateString,
+	          ),
+	          valueCallback,
+	        );
+	      // 01, 02, ..., 12
+	      case "MM":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(2, dateString),
+	          valueCallback,
+	        );
+	      // 1st, 2nd, ..., 12th
+	      case "Mo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "month",
+	          }),
+	          valueCallback,
+	        );
+	      // Jan, Feb, ..., Dec
+	      case "MMM":
+	        return (
+	          match.month(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.month(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // J, F, ..., D
+	      case "MMMMM":
+	        return match.month(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // January, February, ..., December
+	      case "MMMM":
+	      default:
+	        return (
+	          match.month(dateString, { width: "wide", context: "formatting" }) ||
+	          match.month(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.month(dateString, { width: "narrow", context: "formatting" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 11;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth(value, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+	};
+	MonthParser.MonthParser = MonthParser$1;
+	return MonthParser;
+}
+
+export { requireMonthParser as __require };

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

@@ -0,0 +1,83 @@
+import { Parser } from '../Parser.esm.js';
+import { parseNDigits } from '../utils.esm.js';
+
+class QuarterParser extends Parser {
+  priority = 120;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ": // 01, 02, 03, 04
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return match.ordinalNumber(dateString, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return (
+          match.quarter(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.quarter(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return match.quarter(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return (
+          match.quarter(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.quarter(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.quarter(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+
+  set(date, _flags, value) {
+    date.setMonth((value - 1) * 3, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+
+export { QuarterParser };

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

@@ -0,0 +1,97 @@
+import { __exports as QuarterParser } from '../../../../../_virtual/QuarterParser.esm.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredQuarterParser;
+
+function requireQuarterParser () {
+	if (hasRequiredQuarterParser) return QuarterParser;
+	hasRequiredQuarterParser = 1;
+	QuarterParser.QuarterParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let QuarterParser$1 = class QuarterParser extends _Parser.Parser {
+	  priority = 120;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case "Q":
+	      case "QQ": // 01, 02, 03, 04
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	      // 1st, 2nd, 3rd, 4th
+	      case "Qo":
+	        return match.ordinalNumber(dateString, { unit: "quarter" });
+	      // Q1, Q2, Q3, Q4
+	      case "QQQ":
+	        return (
+	          match.quarter(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+	      case "QQQQQ":
+	        return match.quarter(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // 1st quarter, 2nd quarter, ...
+	      case "QQQQ":
+	      default:
+	        return (
+	          match.quarter(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 4;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth((value - 1) * 3, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "M",
+	    "L",
+	    "w",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	QuarterParser.QuarterParser = QuarterParser$1;
+	return QuarterParser;
+}
+
+export { requireQuarterParser as __require };

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

@@ -0,0 +1,31 @@
+import { numericPatterns } from '../constants.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { parseNDigits, parseNumericPattern } from '../utils.esm.js';
+
+class SecondParser extends Parser {
+  priority = 50;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "s":
+        return parseNumericPattern(numericPatterns.second, dateString);
+      case "so":
+        return match.ordinalNumber(dateString, { unit: "second" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+
+  set(date, _flags, value) {
+    date.setSeconds(value, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}
+
+export { SecondParser };

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

@@ -0,0 +1,49 @@
+import { __exports as SecondParser } from '../../../../../_virtual/SecondParser.esm.js';
+import { __require as requireConstants } from '../constants.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredSecondParser;
+
+function requireSecondParser () {
+	if (hasRequiredSecondParser) return SecondParser;
+	hasRequiredSecondParser = 1;
+	SecondParser.SecondParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let SecondParser$1 = class SecondParser extends _Parser.Parser {
+	  priority = 50;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "s":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.second,
+	          dateString,
+	        );
+	      case "so":
+	        return match.ordinalNumber(dateString, { unit: "second" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 59;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setSeconds(value, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["t", "T"];
+	};
+	SecondParser.SecondParser = SecondParser$1;
+	return SecondParser;
+}
+
+export { requireSecondParser as __require };