tp-react-elements-dev 1.14.2 → 1.14.4

package/dist/node_modules/date-fns/constants.esm2.js

@@ -0,0 +1,252 @@
+import { __exports as constants } from '../../_virtual/constants.esm.js';
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	constants.secondsInYear =
+	  constants.secondsInWeek =
+	  constants.secondsInQuarter =
+	  constants.secondsInMonth =
+	  constants.secondsInMinute =
+	  constants.secondsInHour =
+	  constants.secondsInDay =
+	  constants.quartersInYear =
+	  constants.monthsInYear =
+	  constants.monthsInQuarter =
+	  constants.minutesInYear =
+	  constants.minutesInMonth =
+	  constants.minutesInHour =
+	  constants.minutesInDay =
+	  constants.minTime =
+	  constants.millisecondsInWeek =
+	  constants.millisecondsInSecond =
+	  constants.millisecondsInMinute =
+	  constants.millisecondsInHour =
+	  constants.millisecondsInDay =
+	  constants.maxTime =
+	  constants.daysInYear =
+	  constants.daysInWeek =
+	  constants.constructFromSymbol =
+	    void 0; /**
+	 * @module constants
+	 * @summary Useful constants
+	 * @description
+	 * Collection of useful date constants.
+	 *
+	 * The constants could be imported from `date-fns/constants`:
+	 *
+	 * ```ts
+	 * import { maxTime, minTime } from "date-fns/constants";
+	 *
+	 * function isAllowedTime(time) {
+	 *   return time <= maxTime && time >= minTime;
+	 * }
+	 * ```
+	 */
+
+	/**
+	 * @constant
+	 * @name daysInWeek
+	 * @summary Days in 1 week.
+	 */
+	(constants.daysInWeek = 7);
+
+	/**
+	 * @constant
+	 * @name daysInYear
+	 * @summary Days in 1 year.
+	 *
+	 * @description
+	 * How many days in a year.
+	 *
+	 * One years equals 365.2425 days according to the formula:
+	 *
+	 * > Leap year occurs every 4 years, except for years that are divisible by 100 and not divisible by 400.
+	 * > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days
+	 */
+	const daysInYear = (constants.daysInYear = 365.2425);
+
+	/**
+	 * @constant
+	 * @name maxTime
+	 * @summary Maximum allowed time.
+	 *
+	 * @example
+	 * import { maxTime } from "date-fns/constants";
+	 *
+	 * const isValid = 8640000000000001 <= maxTime;
+	 * //=> false
+	 *
+	 * new Date(8640000000000001);
+	 * //=> Invalid Date
+	 */
+	const maxTime = (constants.maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000);
+
+	/**
+	 * @constant
+	 * @name minTime
+	 * @summary Minimum allowed time.
+	 *
+	 * @example
+	 * import { minTime } from "date-fns/constants";
+	 *
+	 * const isValid = -8640000000000001 >= minTime;
+	 * //=> false
+	 *
+	 * new Date(-8640000000000001)
+	 * //=> Invalid Date
+	 */
+	(constants.minTime = -maxTime);
+
+	/**
+	 * @constant
+	 * @name millisecondsInWeek
+	 * @summary Milliseconds in 1 week.
+	 */
+	(constants.millisecondsInWeek = 604800000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInDay
+	 * @summary Milliseconds in 1 day.
+	 */
+	(constants.millisecondsInDay = 86400000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInMinute
+	 * @summary Milliseconds in 1 minute
+	 */
+	(constants.millisecondsInMinute = 60000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInHour
+	 * @summary Milliseconds in 1 hour
+	 */
+	(constants.millisecondsInHour = 3600000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInSecond
+	 * @summary Milliseconds in 1 second
+	 */
+	(constants.millisecondsInSecond = 1000);
+
+	/**
+	 * @constant
+	 * @name minutesInYear
+	 * @summary Minutes in 1 year.
+	 */
+	(constants.minutesInYear = 525600);
+
+	/**
+	 * @constant
+	 * @name minutesInMonth
+	 * @summary Minutes in 1 month.
+	 */
+	(constants.minutesInMonth = 43200);
+
+	/**
+	 * @constant
+	 * @name minutesInDay
+	 * @summary Minutes in 1 day.
+	 */
+	(constants.minutesInDay = 1440);
+
+	/**
+	 * @constant
+	 * @name minutesInHour
+	 * @summary Minutes in 1 hour.
+	 */
+	(constants.minutesInHour = 60);
+
+	/**
+	 * @constant
+	 * @name monthsInQuarter
+	 * @summary Months in 1 quarter.
+	 */
+	(constants.monthsInQuarter = 3);
+
+	/**
+	 * @constant
+	 * @name monthsInYear
+	 * @summary Months in 1 year.
+	 */
+	(constants.monthsInYear = 12);
+
+	/**
+	 * @constant
+	 * @name quartersInYear
+	 * @summary Quarters in 1 year
+	 */
+	(constants.quartersInYear = 4);
+
+	/**
+	 * @constant
+	 * @name secondsInHour
+	 * @summary Seconds in 1 hour.
+	 */
+	const secondsInHour = (constants.secondsInHour = 3600);
+
+	/**
+	 * @constant
+	 * @name secondsInMinute
+	 * @summary Seconds in 1 minute.
+	 */
+	(constants.secondsInMinute = 60);
+
+	/**
+	 * @constant
+	 * @name secondsInDay
+	 * @summary Seconds in 1 day.
+	 */
+	const secondsInDay = (constants.secondsInDay = secondsInHour * 24);
+
+	/**
+	 * @constant
+	 * @name secondsInWeek
+	 * @summary Seconds in 1 week.
+	 */
+	(constants.secondsInWeek = secondsInDay * 7);
+
+	/**
+	 * @constant
+	 * @name secondsInYear
+	 * @summary Seconds in 1 year.
+	 */
+	const secondsInYear = (constants.secondsInYear = secondsInDay * daysInYear);
+
+	/**
+	 * @constant
+	 * @name secondsInMonth
+	 * @summary Seconds in 1 month
+	 */
+	const secondsInMonth = (constants.secondsInMonth = secondsInYear / 12);
+
+	/**
+	 * @constant
+	 * @name secondsInQuarter
+	 * @summary Seconds in 1 quarter.
+	 */
+	(constants.secondsInQuarter = secondsInMonth * 3);
+
+	/**
+	 * @constant
+	 * @name constructFromSymbol
+	 * @summary Symbol enabling Date extensions to inherit properties from the reference date.
+	 *
+	 * The symbol is used to enable the `constructFrom` function to construct a date
+	 * using a reference date and a value. It allows to transfer extra properties
+	 * from the reference date to the new date. It's useful for extensions like
+	 * [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as
+	 * a constructor argument.
+	 */
+	(constants.constructFromSymbol =
+	  Symbol.for("constructDateFrom"));
+	return constants;
+}
+
+export { requireConstants as __require };

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

@@ -0,0 +1,49 @@
+import { constructFromSymbol } from './constants.esm.js';
+
+/**
+ * @name constructFrom
+ * @category Generic Helpers
+ * @summary Constructs a date using the reference date and the value
+ *
+ * @description
+ * The function constructs a new date using the constructor from the reference
+ * date and the given value. It helps to build generic functions that accept
+ * date extensions.
+ *
+ * It defaults to `Date` if the passed reference date is a number or a string.
+ *
+ * Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]`
+ * enabling to transfer extra properties from the reference date to the new date.
+ * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+ * that accept a time zone as a constructor argument.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The reference date to take constructor from
+ * @param value - The value to create the date
+ *
+ * @returns Date initialized using the given date and value
+ *
+ * @example
+ * import { constructFrom } from "./constructFrom/date-fns";
+ *
+ * // A function that clones a date preserving the original type
+ * function cloneDate<DateType extends Date>(date: DateType): DateType {
+ *   return constructFrom(
+ *     date, // Use constructor from the given date
+ *     date.getTime() // Use the date value to create a new date
+ *   );
+ * }
+ */
+function constructFrom(date, value) {
+  if (typeof date === "function") return date(value);
+
+  if (date && typeof date === "object" && constructFromSymbol in date)
+    return date[constructFromSymbol](value);
+
+  if (date instanceof Date) return new date.constructor(value);
+
+  return new Date(value);
+}
+
+export { constructFrom, constructFrom as default };

package/dist/node_modules/date-fns/constructFrom.esm2.js

@@ -0,0 +1,60 @@
+import { __exports as constructFrom } from '../../_virtual/constructFrom.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredConstructFrom;
+
+function requireConstructFrom () {
+	if (hasRequiredConstructFrom) return constructFrom;
+	hasRequiredConstructFrom = 1;
+	constructFrom.constructFrom = constructFrom$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name constructFrom
+	 * @category Generic Helpers
+	 * @summary Constructs a date using the reference date and the value
+	 *
+	 * @description
+	 * The function constructs a new date using the constructor from the reference
+	 * date and the given value. It helps to build generic functions that accept
+	 * date extensions.
+	 *
+	 * It defaults to `Date` if the passed reference date is a number or a string.
+	 *
+	 * Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]`
+	 * enabling to transfer extra properties from the reference date to the new date.
+	 * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+	 * that accept a time zone as a constructor argument.
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 *
+	 * @param date - The reference date to take constructor from
+	 * @param value - The value to create the date
+	 *
+	 * @returns Date initialized using the given date and value
+	 *
+	 * @example
+	 * import { constructFrom } from "date-fns";
+	 *
+	 * // A function that clones a date preserving the original type
+	 * function cloneDate<DateType extends Date>(date: DateType): DateType {
+	 *   return constructFrom(
+	 *     date, // Use constructor from the given date
+	 *     date.getTime() // Use the date value to create a new date
+	 *   );
+	 * }
+	 */
+	function constructFrom$1(date, value) {
+	  if (typeof date === "function") return date(value);
+
+	  if (date && typeof date === "object" && _index.constructFromSymbol in date)
+	    return date[_index.constructFromSymbol](value);
+
+	  if (date instanceof Date) return new date.constructor(value);
+
+	  return new Date(value);
+	}
+	return constructFrom;
+}
+
+export { requireConstructFrom as __require };

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

@@ -0,0 +1,46 @@
+import { __exports as constructNow } from '../../_virtual/constructNow.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredConstructNow;
+
+function requireConstructNow () {
+	if (hasRequiredConstructNow) return constructNow;
+	hasRequiredConstructNow = 1;
+	constructNow.constructNow = constructNow$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * @name constructNow
+	 * @category Generic Helpers
+	 * @summary Constructs a new current date using the passed value constructor.
+	 * @pure false
+	 *
+	 * @description
+	 * The function constructs a new current date using the constructor from
+	 * the reference date. It helps to build generic functions that accept date
+	 * extensions and use the current date.
+	 *
+	 * It defaults to `Date` if the passed reference date is a number or a string.
+	 *
+	 * @param date - The reference date to take constructor from
+	 *
+	 * @returns Current date initialized using the given date constructor
+	 *
+	 * @example
+	 * import { constructNow, isSameDay } from 'date-fns'
+	 *
+	 * function isToday<DateType extends Date>(
+	 *   date: DateArg<DateType>,
+	 * ): boolean {
+	 *   // If we were to use `new Date()` directly, the function would  behave
+	 *   // differently in different timezones and return false for the same date.
+	 *   return isSameDay(date, constructNow(date));
+	 * }
+	 */
+	function constructNow$1(date) {
+	  return (0, _index.constructFrom)(date, Date.now());
+	}
+	return constructNow;
+}
+
+export { requireConstructNow as __require };

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

@@ -0,0 +1,42 @@
+import { __exports as daysToWeeks } from '../../_virtual/daysToWeeks.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredDaysToWeeks;
+
+function requireDaysToWeeks () {
+	if (hasRequiredDaysToWeeks) return daysToWeeks;
+	hasRequiredDaysToWeeks = 1;
+	daysToWeeks.daysToWeeks = daysToWeeks$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name daysToWeeks
+	 * @category Conversion Helpers
+	 * @summary Convert days to weeks.
+	 *
+	 * @description
+	 * Convert a number of days to a full number of weeks.
+	 *
+	 * @param days - The number of days to be converted
+	 *
+	 * @returns The number of days converted in weeks
+	 *
+	 * @example
+	 * // Convert 14 days to weeks:
+	 * const result = daysToWeeks(14)
+	 * //=> 2
+	 *
+	 * @example
+	 * // It uses trunc rounding:
+	 * const result = daysToWeeks(13)
+	 * //=> 1
+	 */
+	function daysToWeeks$1(days) {
+	  const result = Math.trunc(days / _index.daysInWeek);
+	  // Prevent negative zero
+	  return result === 0 ? 0 : result;
+	}
+	return daysToWeeks;
+}
+
+export { requireDaysToWeeks as __require };

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

@@ -0,0 +1,106 @@
+import { __exports as differenceInBusinessDays } from '../../_virtual/differenceInBusinessDays.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireAddDays } from './addDays.esm2.js';
+import { __require as requireDifferenceInCalendarDays } from './differenceInCalendarDays.esm2.js';
+import { __require as requireIsSameDay } from './isSameDay.esm.js';
+import { __require as requireIsValid } from './isValid.esm2.js';
+import { __require as requireIsWeekend } from './isWeekend.esm.js';
+
+var hasRequiredDifferenceInBusinessDays;
+
+function requireDifferenceInBusinessDays () {
+	if (hasRequiredDifferenceInBusinessDays) return differenceInBusinessDays;
+	hasRequiredDifferenceInBusinessDays = 1;
+	differenceInBusinessDays.differenceInBusinessDays = differenceInBusinessDays$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireAddDays();
+	var _index3 = /*@__PURE__*/ requireDifferenceInCalendarDays();
+	var _index4 = /*@__PURE__*/ requireIsSameDay();
+	var _index5 = /*@__PURE__*/ requireIsValid();
+	var _index6 = /*@__PURE__*/ requireIsWeekend();
+
+	/**
+	 * The {@link differenceInBusinessDays} function options.
+	 */
+
+	/**
+	 * @name differenceInBusinessDays
+	 * @category Day Helpers
+	 * @summary Get the number of business days between the given dates.
+	 *
+	 * @description
+	 * Get the number of business day periods between the given dates.
+	 * Business days being days that aren't in the weekend.
+	 * Like `differenceInCalendarDays`, the function removes the times from
+	 * the dates before calculating the difference.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of business days
+	 *
+	 * @example
+	 * // How many business days are between
+	 * // 10 January 2014 and 20 July 2014?
+	 * const result = differenceInBusinessDays(
+	 *   new Date(2014, 6, 20),
+	 *   new Date(2014, 0, 10)
+	 * )
+	 * //=> 136
+	 *
+	 * // How many business days are between
+	 * // 30 November 2021 and 1 November 2021?
+	 * const result = differenceInBusinessDays(
+	 *   new Date(2021, 10, 30),
+	 *   new Date(2021, 10, 1)
+	 * )
+	 * //=> 21
+	 *
+	 * // How many business days are between
+	 * // 1 November 2021 and 1 December 2021?
+	 * const result = differenceInBusinessDays(
+	 *   new Date(2021, 10, 1),
+	 *   new Date(2021, 11, 1)
+	 * )
+	 * //=> -22
+	 *
+	 * // How many business days are between
+	 * // 1 November 2021 and 1 November 2021 ?
+	 * const result = differenceInBusinessDays(
+	 *   new Date(2021, 10, 1),
+	 *   new Date(2021, 10, 1)
+	 * )
+	 * //=> 0
+	 */
+	function differenceInBusinessDays$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  if (!(0, _index5.isValid)(laterDate_) || !(0, _index5.isValid)(earlierDate_))
+	    return NaN;
+
+	  const diff = (0, _index3.differenceInCalendarDays)(laterDate_, earlierDate_);
+	  const sign = diff < 0 ? -1 : 1;
+	  const weeks = Math.trunc(diff / 7);
+
+	  let result = weeks * 5;
+	  let movingDate = (0, _index2.addDays)(earlierDate_, weeks * 7);
+
+	  // the loop below will run at most 6 times to account for the remaining days that don't makeup a full week
+	  while (!(0, _index4.isSameDay)(laterDate_, movingDate)) {
+	    // sign is used to account for both negative and positive differences
+	    result += (0, _index6.isWeekend)(movingDate, options) ? 0 : sign;
+	    movingDate = (0, _index2.addDays)(movingDate, sign);
+	  }
+
+	  // Prevent negative zero
+	  return result === 0 ? 0 : result;
+	}
+	return differenceInBusinessDays;
+}
+
+export { requireDifferenceInBusinessDays as __require };

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

@@ -0,0 +1,62 @@
+import { getTimezoneOffsetInMilliseconds } from './_lib/getTimezoneOffsetInMilliseconds.esm.js';
+import { normalizeDates } from './_lib/normalizeDates.esm.js';
+import { millisecondsInDay } from './constants.esm.js';
+import { startOfDay } from './startOfDay.esm.js';
+
+/**
+ * The {@link differenceInCalendarDays} function options.
+ */
+
+/**
+ * @name differenceInCalendarDays
+ * @category Day Helpers
+ * @summary Get the number of calendar days between the given dates.
+ *
+ * @description
+ * Get the number of calendar days between the given dates. This means that the times are removed
+ * from the dates and then the difference in days is calculated.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - The options object
+ *
+ * @returns The number of calendar days
+ *
+ * @example
+ * // How many calendar days are between
+ * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+ * const result = differenceInCalendarDays(
+ *   new Date(2012, 6, 2, 0, 0),
+ *   new Date(2011, 6, 2, 23, 0)
+ * )
+ * //=> 366
+ * // How many calendar days are between
+ * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+ * const result = differenceInCalendarDays(
+ *   new Date(2011, 6, 3, 0, 1),
+ *   new Date(2011, 6, 2, 23, 59)
+ * )
+ * //=> 1
+ */
+function differenceInCalendarDays(laterDate, earlierDate, options) {
+  const [laterDate_, earlierDate_] = normalizeDates(
+    options?.in,
+    laterDate,
+    earlierDate,
+  );
+
+  const laterStartOfDay = startOfDay(laterDate_);
+  const earlierStartOfDay = startOfDay(earlierDate_);
+
+  const laterTimestamp =
+    +laterStartOfDay - getTimezoneOffsetInMilliseconds(laterStartOfDay);
+  const earlierTimestamp =
+    +earlierStartOfDay - getTimezoneOffsetInMilliseconds(earlierStartOfDay);
+
+  // Round the number of days to the nearest integer because the number of
+  // milliseconds in a day is not constant (e.g. it's different in the week of
+  // the daylight saving time clock shift).
+  return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInDay);
+}
+
+export { differenceInCalendarDays as default, differenceInCalendarDays };

package/dist/node_modules/date-fns/differenceInCalendarDays.esm2.js

@@ -0,0 +1,80 @@
+import { __exports as differenceInCalendarDays } from '../../_virtual/differenceInCalendarDays.esm.js';
+import { __require as requireGetTimezoneOffsetInMilliseconds } from './_lib/getTimezoneOffsetInMilliseconds.esm2.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireConstants } from './constants.esm2.js';
+import { __require as requireStartOfDay } from './startOfDay.esm2.js';
+
+var hasRequiredDifferenceInCalendarDays;
+
+function requireDifferenceInCalendarDays () {
+	if (hasRequiredDifferenceInCalendarDays) return differenceInCalendarDays;
+	hasRequiredDifferenceInCalendarDays = 1;
+	differenceInCalendarDays.differenceInCalendarDays = differenceInCalendarDays$1;
+	var _index = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _index2 = /*@__PURE__*/ requireNormalizeDates();
+	var _index3 = /*@__PURE__*/ requireConstants();
+	var _index4 = /*@__PURE__*/ requireStartOfDay();
+
+	/**
+	 * The {@link differenceInCalendarDays} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarDays
+	 * @category Day Helpers
+	 * @summary Get the number of calendar days between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar days between the given dates. This means that the times are removed
+	 * from the dates and then the difference in days is calculated.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - The options object
+	 *
+	 * @returns The number of calendar days
+	 *
+	 * @example
+	 * // How many calendar days are between
+	 * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+	 * const result = differenceInCalendarDays(
+	 *   new Date(2012, 6, 2, 0, 0),
+	 *   new Date(2011, 6, 2, 23, 0)
+	 * )
+	 * //=> 366
+	 * // How many calendar days are between
+	 * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+	 * const result = differenceInCalendarDays(
+	 *   new Date(2011, 6, 3, 0, 1),
+	 *   new Date(2011, 6, 2, 23, 59)
+	 * )
+	 * //=> 1
+	 */
+	function differenceInCalendarDays$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const laterStartOfDay = (0, _index4.startOfDay)(laterDate_);
+	  const earlierStartOfDay = (0, _index4.startOfDay)(earlierDate_);
+
+	  const laterTimestamp =
+	    +laterStartOfDay -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(laterStartOfDay);
+	  const earlierTimestamp =
+	    +earlierStartOfDay -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(earlierStartOfDay);
+
+	  // Round the number of days to the nearest integer because the number of
+	  // milliseconds in a day is not constant (e.g. it's different in the week of
+	  // the daylight saving time clock shift).
+	  return Math.round(
+	    (laterTimestamp - earlierTimestamp) / _index3.millisecondsInDay,
+	  );
+	}
+	return differenceInCalendarDays;
+}
+
+export { requireDifferenceInCalendarDays as __require };