tp-react-elements-dev 1.14.3 → 1.14.5

package/dist/node_modules/date-fns/_lib/format/lightFormatters.esm.js

@@ -0,0 +1,94 @@
+import { addLeadingZeros } from '../addLeadingZeros.esm.js';
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* |                                |
+ * |  d  | Day of month                   |  D  |                                |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  y  | Year (abs)                     |  Y  |                                |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ */
+
+const lightFormatters = {
+  // Year
+  y(date, token) {
+    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+    // | 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 |
+
+    const signedYear = date.getFullYear();
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
+  },
+
+  // Month
+  M(date, token) {
+    const month = date.getMonth();
+    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
+  },
+
+  // Day of the month
+  d(date, token) {
+    return addLeadingZeros(date.getDate(), token.length);
+  },
+
+  // AM or PM
+  a(date, token) {
+    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+
+  // Hour [1-12]
+  h(date, token) {
+    return addLeadingZeros(date.getHours() % 12 || 12, token.length);
+  },
+
+  // Hour [0-23]
+  H(date, token) {
+    return addLeadingZeros(date.getHours(), token.length);
+  },
+
+  // Minute
+  m(date, token) {
+    return addLeadingZeros(date.getMinutes(), token.length);
+  },
+
+  // Second
+  s(date, token) {
+    return addLeadingZeros(date.getSeconds(), token.length);
+  },
+
+  // Fraction of second
+  S(date, token) {
+    const numberOfDigits = token.length;
+    const milliseconds = date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(
+      milliseconds * Math.pow(10, numberOfDigits - 3),
+    );
+    return addLeadingZeros(fractionalSeconds, token.length);
+  },
+};
+
+export { lightFormatters };

package/dist/node_modules/date-fns/_lib/format/lightFormatters.esm2.js

@@ -0,0 +1,113 @@
+import { __exports as lightFormatters } from '../../../../_virtual/lightFormatters.esm.js';
+import { __require as requireAddLeadingZeros } from '../addLeadingZeros.esm2.js';
+
+var hasRequiredLightFormatters;
+
+function requireLightFormatters () {
+	if (hasRequiredLightFormatters) return lightFormatters;
+	hasRequiredLightFormatters = 1;
+	lightFormatters.lightFormatters = void 0;
+	var _index = /*@__PURE__*/ requireAddLeadingZeros();
+
+	/*
+	 * |     | Unit                           |     | Unit                           |
+	 * |-----|--------------------------------|-----|--------------------------------|
+	 * |  a  | AM, PM                         |  A* |                                |
+	 * |  d  | Day of month                   |  D  |                                |
+	 * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+	 * |  m  | Minute                         |  M  | Month                          |
+	 * |  s  | Second                         |  S  | Fraction of second             |
+	 * |  y  | Year (abs)                     |  Y  |                                |
+	 *
+	 * Letters marked by * are not implemented but reserved by Unicode standard.
+	 */
+
+	(lightFormatters.lightFormatters = {
+	  // Year
+	  y(date, token) {
+	    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+	    // | 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 |
+
+	    const signedYear = date.getFullYear();
+	    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+	    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+	    return (0, _index.addLeadingZeros)(
+	      token === "yy" ? year % 100 : year,
+	      token.length,
+	    );
+	  },
+
+	  // Month
+	  M(date, token) {
+	    const month = date.getMonth();
+	    return token === "M"
+	      ? String(month + 1)
+	      : (0, _index.addLeadingZeros)(month + 1, 2);
+	  },
+
+	  // Day of the month
+	  d(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getDate(), token.length);
+	  },
+
+	  // AM or PM
+	  a(date, token) {
+	    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+	    switch (token) {
+	      case "a":
+	      case "aa":
+	        return dayPeriodEnumValue.toUpperCase();
+	      case "aaa":
+	        return dayPeriodEnumValue;
+	      case "aaaaa":
+	        return dayPeriodEnumValue[0];
+	      case "aaaa":
+	      default:
+	        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+	    }
+	  },
+
+	  // Hour [1-12]
+	  h(date, token) {
+	    return (0, _index.addLeadingZeros)(
+	      date.getHours() % 12 || 12,
+	      token.length,
+	    );
+	  },
+
+	  // Hour [0-23]
+	  H(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getHours(), token.length);
+	  },
+
+	  // Minute
+	  m(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getMinutes(), token.length);
+	  },
+
+	  // Second
+	  s(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getSeconds(), token.length);
+	  },
+
+	  // Fraction of second
+	  S(date, token) {
+	    const numberOfDigits = token.length;
+	    const milliseconds = date.getMilliseconds();
+	    const fractionalSeconds = Math.trunc(
+	      milliseconds * Math.pow(10, numberOfDigits - 3),
+	    );
+	    return (0, _index.addLeadingZeros)(fractionalSeconds, token.length);
+	  },
+	});
+	return lightFormatters;
+}
+
+export { requireLightFormatters as __require };

package/dist/node_modules/date-fns/_lib/format/longFormatters.esm.js

@@ -0,0 +1,66 @@
+const dateLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "P":
+      return formatLong.date({ width: "short" });
+    case "PP":
+      return formatLong.date({ width: "medium" });
+    case "PPP":
+      return formatLong.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong.date({ width: "full" });
+  }
+};
+
+const timeLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "p":
+      return formatLong.time({ width: "short" });
+    case "pp":
+      return formatLong.time({ width: "medium" });
+    case "ppp":
+      return formatLong.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong.time({ width: "full" });
+  }
+};
+
+const dateTimeLongFormatter = (pattern, formatLong) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong);
+  }
+
+  let dateTimeFormat;
+
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong.dateTime({ width: "full" });
+      break;
+  }
+
+  return dateTimeFormat
+    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+};
+
+const longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter,
+};
+
+export { longFormatters };

package/dist/node_modules/date-fns/_lib/format/longFormatters.esm2.js

@@ -0,0 +1,77 @@
+import { __exports as longFormatters } from '../../../../_virtual/longFormatters.esm.js';
+
+var hasRequiredLongFormatters;
+
+function requireLongFormatters () {
+	if (hasRequiredLongFormatters) return longFormatters;
+	hasRequiredLongFormatters = 1;
+	longFormatters.longFormatters = void 0;
+
+	const dateLongFormatter = (pattern, formatLong) => {
+	  switch (pattern) {
+	    case "P":
+	      return formatLong.date({ width: "short" });
+	    case "PP":
+	      return formatLong.date({ width: "medium" });
+	    case "PPP":
+	      return formatLong.date({ width: "long" });
+	    case "PPPP":
+	    default:
+	      return formatLong.date({ width: "full" });
+	  }
+	};
+
+	const timeLongFormatter = (pattern, formatLong) => {
+	  switch (pattern) {
+	    case "p":
+	      return formatLong.time({ width: "short" });
+	    case "pp":
+	      return formatLong.time({ width: "medium" });
+	    case "ppp":
+	      return formatLong.time({ width: "long" });
+	    case "pppp":
+	    default:
+	      return formatLong.time({ width: "full" });
+	  }
+	};
+
+	const dateTimeLongFormatter = (pattern, formatLong) => {
+	  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+	  const datePattern = matchResult[1];
+	  const timePattern = matchResult[2];
+
+	  if (!timePattern) {
+	    return dateLongFormatter(pattern, formatLong);
+	  }
+
+	  let dateTimeFormat;
+
+	  switch (datePattern) {
+	    case "P":
+	      dateTimeFormat = formatLong.dateTime({ width: "short" });
+	      break;
+	    case "PP":
+	      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+	      break;
+	    case "PPP":
+	      dateTimeFormat = formatLong.dateTime({ width: "long" });
+	      break;
+	    case "PPPP":
+	    default:
+	      dateTimeFormat = formatLong.dateTime({ width: "full" });
+	      break;
+	  }
+
+	  return dateTimeFormat
+	    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+	    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+	};
+
+	(longFormatters.longFormatters = {
+	  p: timeLongFormatter,
+	  P: dateTimeLongFormatter,
+	});
+	return longFormatters;
+}
+
+export { requireLongFormatters as __require };

package/dist/node_modules/date-fns/_lib/getRoundingMethod.esm.js

@@ -0,0 +1,21 @@
+import { __exports as getRoundingMethod } from '../../../_virtual/getRoundingMethod.esm.js';
+
+var hasRequiredGetRoundingMethod;
+
+function requireGetRoundingMethod () {
+	if (hasRequiredGetRoundingMethod) return getRoundingMethod;
+	hasRequiredGetRoundingMethod = 1;
+	getRoundingMethod.getRoundingMethod = getRoundingMethod$1;
+
+	function getRoundingMethod$1(method) {
+	  return (number) => {
+	    const round = method ? Math[method] : Math.trunc;
+	    const result = round(number);
+	    // Prevent negative zero
+	    return result === 0 ? 0 : result;
+	  };
+	}
+	return getRoundingMethod;
+}
+
+export { requireGetRoundingMethod as __require };

package/dist/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.esm.js

@@ -0,0 +1,31 @@
+import { toDate } from '../toDate.esm.js';
+
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+function getTimezoneOffsetInMilliseconds(date) {
+  const _date = toDate(date);
+  const utcDate = new Date(
+    Date.UTC(
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds(),
+    ),
+  );
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}
+
+export { getTimezoneOffsetInMilliseconds };

package/dist/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.esm2.js

@@ -0,0 +1,42 @@
+import { __exports as getTimezoneOffsetInMilliseconds } from '../../../_virtual/getTimezoneOffsetInMilliseconds.esm.js';
+import { __require as requireToDate } from '../toDate.esm2.js';
+
+var hasRequiredGetTimezoneOffsetInMilliseconds;
+
+function requireGetTimezoneOffsetInMilliseconds () {
+	if (hasRequiredGetTimezoneOffsetInMilliseconds) return getTimezoneOffsetInMilliseconds;
+	hasRequiredGetTimezoneOffsetInMilliseconds = 1;
+	getTimezoneOffsetInMilliseconds.getTimezoneOffsetInMilliseconds = getTimezoneOffsetInMilliseconds$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+	 * They usually appear for dates that denote time before the timezones were introduced
+	 * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+	 * and GMT+01:00:00 after that date)
+	 *
+	 * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+	 * which would lead to incorrect calculations.
+	 *
+	 * This function returns the timezone offset in milliseconds that takes seconds in account.
+	 */
+	function getTimezoneOffsetInMilliseconds$1(date) {
+	  const _date = (0, _index.toDate)(date);
+	  const utcDate = new Date(
+	    Date.UTC(
+	      _date.getFullYear(),
+	      _date.getMonth(),
+	      _date.getDate(),
+	      _date.getHours(),
+	      _date.getMinutes(),
+	      _date.getSeconds(),
+	      _date.getMilliseconds(),
+	    ),
+	  );
+	  utcDate.setUTCFullYear(_date.getFullYear());
+	  return +date - +utcDate;
+	}
+	return getTimezoneOffsetInMilliseconds;
+}
+
+export { requireGetTimezoneOffsetInMilliseconds as __require };

package/dist/node_modules/date-fns/_lib/normalizeDates.esm.js

@@ -0,0 +1,11 @@
+import { constructFrom } from '../constructFrom.esm.js';
+
+function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(
+    null,
+    dates.find((date) => typeof date === "object"),
+  );
+  return dates.map(normalize);
+}
+
+export { normalizeDates };

package/dist/node_modules/date-fns/_lib/normalizeDates.esm2.js

@@ -0,0 +1,22 @@
+import { __exports as normalizeDates } from '../../../_virtual/normalizeDates.esm.js';
+import { __require as requireConstructFrom } from '../constructFrom.esm2.js';
+
+var hasRequiredNormalizeDates;
+
+function requireNormalizeDates () {
+	if (hasRequiredNormalizeDates) return normalizeDates;
+	hasRequiredNormalizeDates = 1;
+	normalizeDates.normalizeDates = normalizeDates$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+
+	function normalizeDates$1(context, ...dates) {
+	  const normalize = _index.constructFrom.bind(
+	    null,
+	    context || dates.find((date) => typeof date === "object"),
+	  );
+	  return dates.map(normalize);
+	}
+	return normalizeDates;
+}
+
+export { requireNormalizeDates as __require };

package/dist/node_modules/date-fns/_lib/normalizeInterval.esm.js

@@ -0,0 +1,23 @@
+import { __exports as normalizeInterval } from '../../../_virtual/normalizeInterval.esm.js';
+import { __require as requireNormalizeDates } from './normalizeDates.esm2.js';
+
+var hasRequiredNormalizeInterval;
+
+function requireNormalizeInterval () {
+	if (hasRequiredNormalizeInterval) return normalizeInterval;
+	hasRequiredNormalizeInterval = 1;
+	normalizeInterval.normalizeInterval = normalizeInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	function normalizeInterval$1(context, interval) {
+	  const [start, end] = (0, _index.normalizeDates)(
+	    context,
+	    interval.start,
+	    interval.end,
+	  );
+	  return { start, end };
+	}
+	return normalizeInterval;
+}
+
+export { requireNormalizeInterval as __require };

package/dist/node_modules/date-fns/_lib/protectedTokens.esm.js

@@ -0,0 +1,25 @@
+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, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+
+export { isProtectedDayOfYearToken, isProtectedWeekYearToken, warnOrThrowProtectedError };

package/dist/node_modules/date-fns/_lib/protectedTokens.esm2.js

@@ -0,0 +1,37 @@
+import { __exports as protectedTokens } from '../../../_virtual/protectedTokens.esm.js';
+
+var hasRequiredProtectedTokens;
+
+function requireProtectedTokens () {
+	if (hasRequiredProtectedTokens) return protectedTokens;
+	hasRequiredProtectedTokens = 1;
+	protectedTokens.isProtectedDayOfYearToken = isProtectedDayOfYearToken;
+	protectedTokens.isProtectedWeekYearToken = isProtectedWeekYearToken;
+	protectedTokens.warnOrThrowProtectedError = warnOrThrowProtectedError;
+	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, format, input) {
+	  const _message = message(token, format, input);
+	  console.warn(_message);
+	  if (throwTokens.includes(token)) throw new RangeError(_message);
+	}
+
+	function message(token, format, input) {
+	  const subject = token[0] === "Y" ? "years" : "days of the month";
+	  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+	}
+	return protectedTokens;
+}
+
+export { requireProtectedTokens as __require };

package/dist/node_modules/date-fns/add.esm.js

@@ -0,0 +1,89 @@
+import { __exports as add } from '../../_virtual/add.esm.js';
+import { __require as requireAddDays } from './addDays.esm2.js';
+import { __require as requireAddMonths } from './addMonths.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredAdd;
+
+function requireAdd () {
+	if (hasRequiredAdd) return add;
+	hasRequiredAdd = 1;
+	add.add = add$1;
+	var _index = /*@__PURE__*/ requireAddDays();
+	var _index2 = /*@__PURE__*/ requireAddMonths();
+	var _index3 = /*@__PURE__*/ requireConstructFrom();
+	var _index4 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link add} function options.
+	 */
+
+	/**
+	 * @name add
+	 * @category Common Helpers
+	 * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+	 *
+	 * @description
+	 * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+	 *
+	 * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to be changed
+	 * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+	 * @param options - An object with options
+	 *
+	 * @returns The new date with the seconds added
+	 *
+	 * @example
+	 * // Add the following duration to 1 September 2014, 10:19:50
+	 * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+	 *   years: 2,
+	 *   months: 9,
+	 *   weeks: 1,
+	 *   days: 7,
+	 *   hours: 5,
+	 *   minutes: 9,
+	 *   seconds: 30,
+	 * })
+	 * //=> Thu Jun 15 2017 15:29:20
+	 */
+	function add$1(date, duration, options) {
+	  const {
+	    years = 0,
+	    months = 0,
+	    weeks = 0,
+	    days = 0,
+	    hours = 0,
+	    minutes = 0,
+	    seconds = 0,
+	  } = duration;
+
+	  // Add years and months
+	  const _date = (0, _index4.toDate)(date, options?.in);
+	  const dateWithMonths =
+	    months || years
+	      ? (0, _index2.addMonths)(_date, months + years * 12)
+	      : _date;
+
+	  // Add weeks and days
+	  const dateWithDays =
+	    days || weeks
+	      ? (0, _index.addDays)(dateWithMonths, days + weeks * 7)
+	      : dateWithMonths;
+
+	  // Add days, hours, minutes, and seconds
+	  const minutesToAdd = minutes + hours * 60;
+	  const secondsToAdd = seconds + minutesToAdd * 60;
+	  const msToAdd = secondsToAdd * 1000;
+
+	  return (0, _index3.constructFrom)(
+	    options?.in || date,
+	    +dateWithDays + msToAdd,
+	  );
+	}
+	return add;
+}
+
+export { requireAdd as __require };