tp-react-elements-dev 1.14.3 → 1.14.4

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

@@ -0,0 +1,64 @@
+import { setDay } from '../../../setDay.esm.js';
+import { Parser } from '../Parser.esm.js';
+
+// Day of week
+class DayParser extends Parser {
+  priority = 90;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return (
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // T
+      case "EEEEE":
+        return match.day(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return (
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // Tuesday
+      case "EEEE":
+      default:
+        return (
+          match.day(dateString, { width: "wide", context: "formatting" }) ||
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+
+  set(date, _flags, value, options) {
+    date = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}
+
+export { DayParser };

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

@@ -0,0 +1,77 @@
+import { __exports as DayParser } from '../../../../../_virtual/DayParser.esm.js';
+import { __require as requireSetDay } from '../../../setDay.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+
+var hasRequiredDayParser;
+
+function requireDayParser () {
+	if (hasRequiredDayParser) return DayParser;
+	hasRequiredDayParser = 1;
+	DayParser.DayParser = void 0;
+	var _index = /*@__PURE__*/ requireSetDay();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	// Day of week
+	let DayParser$1 = class DayParser extends _Parser.Parser {
+	  priority = 90;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // Tue
+	      case "E":
+	      case "EE":
+	      case "EEE":
+	        return (
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // T
+	      case "EEEEE":
+	        return match.day(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // Tu
+	      case "EEEEEE":
+	        return (
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // Tuesday
+	      case "EEEE":
+	      default:
+	        return (
+	          match.day(dateString, { width: "wide", context: "formatting" }) ||
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 6;
+	  }
+
+	  set(date, _flags, value, options) {
+	    date = (0, _index.setDay)(date, value, options);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+	};
+	DayParser.DayParser = DayParser$1;
+	return DayParser;
+}
+
+export { requireDayParser as __require };

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

@@ -0,0 +1,56 @@
+import { Parser } from '../Parser.esm.js';
+import { dayPeriodEnumToHours } from '../utils.esm.js';
+
+// in the morning, in the afternoon, in the evening, at night
+class DayPeriodParser extends Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "BBBBB":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+
+export { DayPeriodParser };

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

@@ -0,0 +1,70 @@
+import { __exports as DayPeriodParser } from '../../../../../_virtual/DayPeriodParser.esm.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredDayPeriodParser;
+
+function requireDayPeriodParser () {
+	if (hasRequiredDayPeriodParser) return DayPeriodParser;
+	hasRequiredDayPeriodParser = 1;
+	DayPeriodParser.DayPeriodParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// in the morning, in the afternoon, in the evening, at night
+	let DayPeriodParser$1 = class DayPeriodParser extends _Parser.Parser {
+	  priority = 80;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "B":
+	      case "BB":
+	      case "BBB":
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+
+	      case "BBBBB":
+	        return match.dayPeriod(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "BBBB":
+	      default:
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+	    }
+	  }
+
+	  set(date, _flags, value) {
+	    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["a", "b", "t", "T"];
+	};
+	DayPeriodParser.DayPeriodParser = DayPeriodParser$1;
+	return DayPeriodParser;
+}
+
+export { requireDayPeriodParser as __require };

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

@@ -0,0 +1,41 @@
+import { Parser } from '../Parser.esm.js';
+
+class EraParser extends Parser {
+  priority = 140;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return (
+          match.era(dateString, { width: "abbreviated" }) ||
+          match.era(dateString, { width: "narrow" })
+        );
+
+      // A, B
+      case "GGGGG":
+        return match.era(dateString, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return (
+          match.era(dateString, { width: "wide" }) ||
+          match.era(dateString, { width: "abbreviated" }) ||
+          match.era(dateString, { width: "narrow" })
+        );
+    }
+  }
+
+  set(date, flags, value) {
+    flags.era = value;
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+
+export { EraParser };

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

@@ -0,0 +1,54 @@
+import { __exports as EraParser } from '../../../../../_virtual/EraParser.esm.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+
+var hasRequiredEraParser;
+
+function requireEraParser () {
+	if (hasRequiredEraParser) return EraParser;
+	hasRequiredEraParser = 1;
+	EraParser.EraParser = void 0;
+
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	let EraParser$1 = class EraParser extends _Parser.Parser {
+	  priority = 140;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // AD, BC
+	      case "G":
+	      case "GG":
+	      case "GGG":
+	        return (
+	          match.era(dateString, { width: "abbreviated" }) ||
+	          match.era(dateString, { width: "narrow" })
+	        );
+
+	      // A, B
+	      case "GGGGG":
+	        return match.era(dateString, { width: "narrow" });
+	      // Anno Domini, Before Christ
+	      case "GGGG":
+	      default:
+	        return (
+	          match.era(dateString, { width: "wide" }) ||
+	          match.era(dateString, { width: "abbreviated" }) ||
+	          match.era(dateString, { width: "narrow" })
+	        );
+	    }
+	  }
+
+	  set(date, flags, value) {
+	    flags.era = value;
+	    date.setFullYear(value, 0, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["R", "u", "t", "T"];
+	};
+	EraParser.EraParser = EraParser$1;
+	return EraParser;
+}
+
+export { requireEraParser as __require };

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

@@ -0,0 +1,24 @@
+import { Parser } from '../Parser.esm.js';
+import { parseNDigitsSigned } from '../utils.esm.js';
+
+class ExtendedYearParser extends Parser {
+  priority = 130;
+
+  parse(dateString, token) {
+    if (token === "u") {
+      return parseNDigitsSigned(4, dateString);
+    }
+
+    return parseNDigitsSigned(token.length, dateString);
+  }
+
+  set(date, _flags, value) {
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+
+export { ExtendedYearParser };

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

@@ -0,0 +1,38 @@
+import { __exports as ExtendedYearParser } from '../../../../../_virtual/ExtendedYearParser.esm.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredExtendedYearParser;
+
+function requireExtendedYearParser () {
+	if (hasRequiredExtendedYearParser) return ExtendedYearParser;
+	hasRequiredExtendedYearParser = 1;
+	ExtendedYearParser.ExtendedYearParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let ExtendedYearParser$1 = class ExtendedYearParser extends _Parser.Parser {
+	  priority = 130;
+
+	  parse(dateString, token) {
+	    if (token === "u") {
+	      return (0, _utils.parseNDigitsSigned)(4, dateString);
+	    }
+
+	    return (0, _utils.parseNDigitsSigned)(token.length, dateString);
+	  }
+
+	  set(date, _flags, value) {
+	    date.setFullYear(value, 0, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+	};
+	ExtendedYearParser.ExtendedYearParser = ExtendedYearParser$1;
+	return ExtendedYearParser;
+}
+
+export { requireExtendedYearParser as __require };

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

@@ -0,0 +1,21 @@
+import { Parser } from '../Parser.esm.js';
+import { mapValue, parseNDigits } from '../utils.esm.js';
+
+class FractionOfSecondParser extends Parser {
+  priority = 30;
+
+  parse(dateString, token) {
+    const valueCallback = (value) =>
+      Math.trunc(value * Math.pow(10, -token.length + 3));
+    return mapValue(parseNDigits(token.length, dateString), valueCallback);
+  }
+
+  set(date, _flags, value) {
+    date.setMilliseconds(value);
+    return date;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}
+
+export { FractionOfSecondParser };

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

@@ -0,0 +1,38 @@
+import { __exports as FractionOfSecondParser } from '../../../../../_virtual/FractionOfSecondParser.esm.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredFractionOfSecondParser;
+
+function requireFractionOfSecondParser () {
+	if (hasRequiredFractionOfSecondParser) return FractionOfSecondParser;
+	hasRequiredFractionOfSecondParser = 1;
+	FractionOfSecondParser.FractionOfSecondParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let FractionOfSecondParser$1 = class FractionOfSecondParser extends _Parser.Parser {
+	  priority = 30;
+
+	  parse(dateString, token) {
+	    const valueCallback = (value) =>
+	      Math.trunc(value * Math.pow(10, -token.length + 3));
+	    return (0, _utils.mapValue)(
+	      (0, _utils.parseNDigits)(token.length, dateString),
+	      valueCallback,
+	    );
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMilliseconds(value);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["t", "T"];
+	};
+	FractionOfSecondParser.FractionOfSecondParser = FractionOfSecondParser$1;
+	return FractionOfSecondParser;
+}
+
+export { requireFractionOfSecondParser as __require };

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

@@ -0,0 +1,36 @@
+import { numericPatterns } from '../constants.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { parseNDigits, parseNumericPattern } from '../utils.esm.js';
+
+class Hour0To11Parser extends Parser {
+  priority = 70;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "K":
+        return parseNumericPattern(numericPatterns.hour11h, dateString);
+      case "Ko":
+        return match.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+
+  set(date, _flags, value) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+
+export { Hour0To11Parser };

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

@@ -0,0 +1,54 @@
+import { __exports as Hour0To11Parser } from '../../../../../_virtual/Hour0To11Parser.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 hasRequiredHour0To11Parser;
+
+function requireHour0To11Parser () {
+	if (hasRequiredHour0To11Parser) return Hour0To11Parser;
+	hasRequiredHour0To11Parser = 1;
+	Hour0To11Parser.Hour0To11Parser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let Hour0To11Parser$1 = class Hour0To11Parser extends _Parser.Parser {
+	  priority = 70;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "K":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.hour11h,
+	          dateString,
+	        );
+	      case "Ko":
+	        return match.ordinalNumber(dateString, { unit: "hour" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 11;
+	  }
+
+	  set(date, _flags, value) {
+	    const isPM = date.getHours() >= 12;
+	    if (isPM && value < 12) {
+	      date.setHours(value + 12, 0, 0, 0);
+	    } else {
+	      date.setHours(value, 0, 0, 0);
+	    }
+	    return date;
+	  }
+
+	  incompatibleTokens = ["h", "H", "k", "t", "T"];
+	};
+	Hour0To11Parser.Hour0To11Parser = Hour0To11Parser$1;
+	return Hour0To11Parser;
+}
+
+export { requireHour0To11Parser as __require };

package/dist/node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.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 Hour0to23Parser extends Parser {
+  priority = 70;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "H":
+        return parseNumericPattern(numericPatterns.hour23h, dateString);
+      case "Ho":
+        return match.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 23;
+  }
+
+  set(date, _flags, value) {
+    date.setHours(value, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+
+export { Hour0to23Parser };

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

@@ -0,0 +1,49 @@
+import { __exports as Hour0to23Parser } from '../../../../../_virtual/Hour0to23Parser.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 hasRequiredHour0to23Parser;
+
+function requireHour0to23Parser () {
+	if (hasRequiredHour0to23Parser) return Hour0to23Parser;
+	hasRequiredHour0to23Parser = 1;
+	Hour0to23Parser.Hour0to23Parser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let Hour0to23Parser$1 = class Hour0to23Parser extends _Parser.Parser {
+	  priority = 70;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "H":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.hour23h,
+	          dateString,
+	        );
+	      case "Ho":
+	        return match.ordinalNumber(dateString, { unit: "hour" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 23;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setHours(value, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+	};
+	Hour0to23Parser.Hour0to23Parser = Hour0to23Parser$1;
+	return Hour0to23Parser;
+}
+
+export { requireHour0to23Parser as __require };