tp-react-elements-dev 1.14.3 → 1.14.5

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

@@ -0,0 +1,56 @@
+import { __exports as differenceInCalendarISOWeekYears } from '../../_virtual/differenceInCalendarISOWeekYears.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireGetISOWeekYear } from './getISOWeekYear.esm2.js';
+
+var hasRequiredDifferenceInCalendarISOWeekYears;
+
+function requireDifferenceInCalendarISOWeekYears () {
+	if (hasRequiredDifferenceInCalendarISOWeekYears) return differenceInCalendarISOWeekYears;
+	hasRequiredDifferenceInCalendarISOWeekYears = 1;
+	differenceInCalendarISOWeekYears.differenceInCalendarISOWeekYears = differenceInCalendarISOWeekYears$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireGetISOWeekYear();
+
+	/**
+	 * The {@link differenceInCalendarISOWeekYears} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarISOWeekYears
+	 * @category ISO Week-Numbering Year Helpers
+	 * @summary Get the number of calendar ISO week-numbering years between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar ISO week-numbering years between the given dates.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of calendar ISO week-numbering years
+	 *
+	 * @example
+	 * // How many calendar ISO week-numbering years are 1 January 2010 and 1 January 2012?
+	 * const result = differenceInCalendarISOWeekYears(
+	 *   new Date(2012, 0, 1),
+	 *   new Date(2010, 0, 1)
+	 * )
+	 * //=> 2
+	 */
+	function differenceInCalendarISOWeekYears$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    (0, _index2.getISOWeekYear)(laterDate_, options) -
+	    (0, _index2.getISOWeekYear)(earlierDate_, options)
+	  );
+	}
+	return differenceInCalendarISOWeekYears;
+}
+
+export { requireDifferenceInCalendarISOWeekYears as __require };

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

@@ -0,0 +1,73 @@
+import { __exports as differenceInCalendarISOWeeks } from '../../_virtual/differenceInCalendarISOWeeks.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 requireStartOfISOWeek } from './startOfISOWeek.esm2.js';
+
+var hasRequiredDifferenceInCalendarISOWeeks;
+
+function requireDifferenceInCalendarISOWeeks () {
+	if (hasRequiredDifferenceInCalendarISOWeeks) return differenceInCalendarISOWeeks;
+	hasRequiredDifferenceInCalendarISOWeeks = 1;
+	differenceInCalendarISOWeeks.differenceInCalendarISOWeeks = differenceInCalendarISOWeeks$1;
+	var _index = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _index2 = /*@__PURE__*/ requireNormalizeDates();
+	var _index3 = /*@__PURE__*/ requireConstants();
+	var _index4 = /*@__PURE__*/ requireStartOfISOWeek();
+
+	/**
+	 * The {@link differenceInCalendarISOWeeks} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarISOWeeks
+	 * @category ISO Week Helpers
+	 * @summary Get the number of calendar ISO weeks between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar ISO weeks between the given dates.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of calendar ISO weeks
+	 *
+	 * @example
+	 * // How many calendar ISO weeks are between 6 July 2014 and 21 July 2014?
+	 * const result = differenceInCalendarISOWeeks(
+	 *   new Date(2014, 6, 21),
+	 *   new Date(2014, 6, 6),
+	 * );
+	 * //=> 3
+	 */
+	function differenceInCalendarISOWeeks$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const startOfISOWeekLeft = (0, _index4.startOfISOWeek)(laterDate_);
+	  const startOfISOWeekRight = (0, _index4.startOfISOWeek)(earlierDate_);
+
+	  const timestampLeft =
+	    +startOfISOWeekLeft -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(startOfISOWeekLeft);
+	  const timestampRight =
+	    +startOfISOWeekRight -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(startOfISOWeekRight);
+
+	  // Round the number of weeks to the nearest integer because the number of
+	  // milliseconds in a week is not constant (e.g. it's different in the week of
+	  // the daylight saving time clock shift).
+	  return Math.round(
+	    (timestampLeft - timestampRight) / _index3.millisecondsInWeek,
+	  );
+	}
+	return differenceInCalendarISOWeeks;
+}
+
+export { requireDifferenceInCalendarISOWeeks as __require };

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

@@ -0,0 +1,53 @@
+import { __exports as differenceInCalendarMonths } from '../../_virtual/differenceInCalendarMonths.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+
+var hasRequiredDifferenceInCalendarMonths;
+
+function requireDifferenceInCalendarMonths () {
+	if (hasRequiredDifferenceInCalendarMonths) return differenceInCalendarMonths;
+	hasRequiredDifferenceInCalendarMonths = 1;
+	differenceInCalendarMonths.differenceInCalendarMonths = differenceInCalendarMonths$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	/**
+	 * The {@link differenceInCalendarMonths} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarMonths
+	 * @category Month Helpers
+	 * @summary Get the number of calendar months between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar months between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of calendar months
+	 *
+	 * @example
+	 * // How many calendar months are between 31 January 2014 and 1 September 2014?
+	 * const result = differenceInCalendarMonths(
+	 *   new Date(2014, 8, 1),
+	 *   new Date(2014, 0, 31)
+	 * )
+	 * //=> 8
+	 */
+	function differenceInCalendarMonths$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
+	  const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth();
+
+	  return yearsDiff * 12 + monthsDiff;
+	}
+	return differenceInCalendarMonths;
+}
+
+export { requireDifferenceInCalendarMonths as __require };

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

@@ -0,0 +1,56 @@
+import { __exports as differenceInCalendarQuarters } from '../../_virtual/differenceInCalendarQuarters.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireGetQuarter } from './getQuarter.esm.js';
+
+var hasRequiredDifferenceInCalendarQuarters;
+
+function requireDifferenceInCalendarQuarters () {
+	if (hasRequiredDifferenceInCalendarQuarters) return differenceInCalendarQuarters;
+	hasRequiredDifferenceInCalendarQuarters = 1;
+	differenceInCalendarQuarters.differenceInCalendarQuarters = differenceInCalendarQuarters$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireGetQuarter();
+
+	/**
+	 * The {@link differenceInCalendarQuarters} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarQuarters
+	 * @category Quarter Helpers
+	 * @summary Get the number of calendar quarters between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar quarters between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of calendar quarters
+	 *
+	 * @example
+	 * // How many calendar quarters are between 31 December 2013 and 2 July 2014?
+	 * const result = differenceInCalendarQuarters(
+	 *   new Date(2014, 6, 2),
+	 *   new Date(2013, 11, 31)
+	 * )
+	 * //=> 3
+	 */
+	function differenceInCalendarQuarters$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
+	  const quartersDiff =
+	    (0, _index2.getQuarter)(laterDate_) - (0, _index2.getQuarter)(earlierDate_);
+
+	  return yearsDiff * 4 + quartersDiff;
+	}
+	return differenceInCalendarQuarters;
+}
+
+export { requireDifferenceInCalendarQuarters as __require };

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

@@ -0,0 +1,78 @@
+import { __exports as differenceInCalendarWeeks } from '../../_virtual/differenceInCalendarWeeks.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 requireStartOfWeek } from './startOfWeek.esm2.js';
+
+var hasRequiredDifferenceInCalendarWeeks;
+
+function requireDifferenceInCalendarWeeks () {
+	if (hasRequiredDifferenceInCalendarWeeks) return differenceInCalendarWeeks;
+	hasRequiredDifferenceInCalendarWeeks = 1;
+	differenceInCalendarWeeks.differenceInCalendarWeeks = differenceInCalendarWeeks$1;
+	var _index = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _index2 = /*@__PURE__*/ requireNormalizeDates();
+	var _index3 = /*@__PURE__*/ requireConstants();
+	var _index4 = /*@__PURE__*/ requireStartOfWeek();
+
+	/**
+	 * The {@link differenceInCalendarWeeks} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarWeeks
+	 * @category Week Helpers
+	 * @summary Get the number of calendar weeks between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar weeks between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options.
+	 *
+	 * @returns The number of calendar weeks
+	 *
+	 * @example
+	 * // How many calendar weeks are between 5 July 2014 and 20 July 2014?
+	 * const result = differenceInCalendarWeeks(
+	 *   new Date(2014, 6, 20),
+	 *   new Date(2014, 6, 5)
+	 * )
+	 * //=> 3
+	 *
+	 * @example
+	 * // If the week starts on Monday,
+	 * // how many calendar weeks are between 5 July 2014 and 20 July 2014?
+	 * const result = differenceInCalendarWeeks(
+	 *   new Date(2014, 6, 20),
+	 *   new Date(2014, 6, 5),
+	 *   { weekStartsOn: 1 }
+	 * )
+	 * //=> 2
+	 */
+	function differenceInCalendarWeeks$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const laterStartOfWeek = (0, _index4.startOfWeek)(laterDate_, options);
+	  const earlierStartOfWeek = (0, _index4.startOfWeek)(earlierDate_, options);
+
+	  const laterTimestamp =
+	    +laterStartOfWeek -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(laterStartOfWeek);
+	  const earlierTimestamp =
+	    +earlierStartOfWeek -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(earlierStartOfWeek);
+
+	  return Math.round(
+	    (laterTimestamp - earlierTimestamp) / _index3.millisecondsInWeek,
+	  );
+	}
+	return differenceInCalendarWeeks;
+}
+
+export { requireDifferenceInCalendarWeeks as __require };

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

@@ -0,0 +1,49 @@
+import { __exports as differenceInCalendarYears } from '../../_virtual/differenceInCalendarYears.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+
+var hasRequiredDifferenceInCalendarYears;
+
+function requireDifferenceInCalendarYears () {
+	if (hasRequiredDifferenceInCalendarYears) return differenceInCalendarYears;
+	hasRequiredDifferenceInCalendarYears = 1;
+	differenceInCalendarYears.differenceInCalendarYears = differenceInCalendarYears$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	/**
+	 * The {@link differenceInCalendarYears} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarYears
+	 * @category Year Helpers
+	 * @summary Get the number of calendar years between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar years between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+
+	 * @returns The number of calendar years
+	 *
+	 * @example
+	 * // How many calendar years are between 31 December 2013 and 11 February 2015?
+	 * const result = differenceInCalendarYears(
+	 *   new Date(2015, 1, 11),
+	 *   new Date(2013, 11, 31)
+	 * );
+	 * //=> 2
+	 */
+	function differenceInCalendarYears$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return laterDate_.getFullYear() - earlierDate_.getFullYear();
+	}
+	return differenceInCalendarYears;
+}
+
+export { requireDifferenceInCalendarYears as __require };

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

@@ -0,0 +1,119 @@
+import { __exports as differenceInDays } from '../../_virtual/differenceInDays.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireDifferenceInCalendarDays } from './differenceInCalendarDays.esm2.js';
+
+var hasRequiredDifferenceInDays;
+
+function requireDifferenceInDays () {
+	if (hasRequiredDifferenceInDays) return differenceInDays;
+	hasRequiredDifferenceInDays = 1;
+	differenceInDays.differenceInDays = differenceInDays$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireDifferenceInCalendarDays();
+
+	/**
+	 * The {@link differenceInDays} function options.
+	 */
+
+	/**
+	 * @name differenceInDays
+	 * @category Day Helpers
+	 * @summary Get the number of full days between the given dates.
+	 *
+	 * @description
+	 * Get the number of full day periods between two dates. Fractional days are
+	 * truncated towards zero.
+	 *
+	 * One "full day" is the distance between a local time in one day to the same
+	 * local time on the next or previous day. A full day can sometimes be less than
+	 * or more than 24 hours if a daylight savings change happens between two dates.
+	 *
+	 * To ignore DST and only measure exact 24-hour periods, use this instead:
+	 * `Math.trunc(differenceInHours(dateLeft, dateRight)/24)|0`.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of full days according to the local timezone
+	 *
+	 * @example
+	 * // How many full days are between
+	 * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+	 * const result = differenceInDays(
+	 *   new Date(2012, 6, 2, 0, 0),
+	 *   new Date(2011, 6, 2, 23, 0)
+	 * )
+	 * //=> 365
+	 *
+	 * @example
+	 * // How many full days are between
+	 * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+	 * const result = differenceInDays(
+	 *   new Date(2011, 6, 3, 0, 1),
+	 *   new Date(2011, 6, 2, 23, 59)
+	 * )
+	 * //=> 0
+	 *
+	 * @example
+	 * // How many full days are between
+	 * // 1 March 2020 0:00 and 1 June 2020 0:00 ?
+	 * // Note: because local time is used, the
+	 * // result will always be 92 days, even in
+	 * // time zones where DST starts and the
+	 * // period has only 92*24-1 hours.
+	 * const result = differenceInDays(
+	 *   new Date(2020, 5, 1),
+	 *   new Date(2020, 2, 1)
+	 * )
+	 * //=> 92
+	 */
+	function differenceInDays$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const sign = compareLocalAsc(laterDate_, earlierDate_);
+	  const difference = Math.abs(
+	    (0, _index2.differenceInCalendarDays)(laterDate_, earlierDate_),
+	  );
+
+	  laterDate_.setDate(laterDate_.getDate() - sign * difference);
+
+	  // Math.abs(diff in full days - diff in calendar days) === 1 if last calendar day is not full
+	  // If so, result must be decreased by 1 in absolute value
+	  const isLastDayNotFull = Number(
+	    compareLocalAsc(laterDate_, earlierDate_) === -sign,
+	  );
+
+	  const result = sign * (difference - isLastDayNotFull);
+	  // Prevent negative zero
+	  return result === 0 ? 0 : result;
+	}
+
+	// Like `compareAsc` but uses local time not UTC, which is needed
+	// for accurate equality comparisons of UTC timestamps that end up
+	// having the same representation in local time, e.g. one hour before
+	// DST ends vs. the instant that DST ends.
+	function compareLocalAsc(laterDate, earlierDate) {
+	  const diff =
+	    laterDate.getFullYear() - earlierDate.getFullYear() ||
+	    laterDate.getMonth() - earlierDate.getMonth() ||
+	    laterDate.getDate() - earlierDate.getDate() ||
+	    laterDate.getHours() - earlierDate.getHours() ||
+	    laterDate.getMinutes() - earlierDate.getMinutes() ||
+	    laterDate.getSeconds() - earlierDate.getSeconds() ||
+	    laterDate.getMilliseconds() - earlierDate.getMilliseconds();
+
+	  if (diff < 0) return -1;
+	  if (diff > 0) return 1;
+
+	  // Return 0 if diff is 0; return NaN if diff is NaN
+	  return diff;
+	}
+	return differenceInDays;
+}
+
+export { requireDifferenceInDays as __require };

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

@@ -0,0 +1,54 @@
+import { __exports as differenceInHours } from '../../_virtual/differenceInHours.esm.js';
+import { __require as requireGetRoundingMethod } from './_lib/getRoundingMethod.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredDifferenceInHours;
+
+function requireDifferenceInHours () {
+	if (hasRequiredDifferenceInHours) return differenceInHours;
+	hasRequiredDifferenceInHours = 1;
+	differenceInHours.differenceInHours = differenceInHours$1;
+	var _index = /*@__PURE__*/ requireGetRoundingMethod();
+	var _index2 = /*@__PURE__*/ requireNormalizeDates();
+	var _index3 = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * The {@link differenceInHours} function options.
+	 */
+
+	/**
+	 * @name differenceInHours
+	 * @category Hour Helpers
+	 * @summary Get the number of hours between the given dates.
+	 *
+	 * @description
+	 * Get the number of hours between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options.
+	 *
+	 * @returns The number of hours
+	 *
+	 * @example
+	 * // How many hours are between 2 July 2014 06:50:00 and 2 July 2014 19:00:00?
+	 * const result = differenceInHours(
+	 *   new Date(2014, 6, 2, 19, 0),
+	 *   new Date(2014, 6, 2, 6, 50)
+	 * )
+	 * //=> 12
+	 */
+	function differenceInHours$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  const diff = (+laterDate_ - +earlierDate_) / _index3.millisecondsInHour;
+	  return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff);
+	}
+	return differenceInHours;
+}
+
+export { requireDifferenceInHours as __require };

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

@@ -0,0 +1,79 @@
+import { __exports as differenceInISOWeekYears } from '../../_virtual/differenceInISOWeekYears.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireCompareAsc } from './compareAsc.esm.js';
+import { __require as requireDifferenceInCalendarISOWeekYears } from './differenceInCalendarISOWeekYears.esm.js';
+import { __require as requireSubISOWeekYears } from './subISOWeekYears.esm.js';
+
+var hasRequiredDifferenceInISOWeekYears;
+
+function requireDifferenceInISOWeekYears () {
+	if (hasRequiredDifferenceInISOWeekYears) return differenceInISOWeekYears;
+	hasRequiredDifferenceInISOWeekYears = 1;
+	differenceInISOWeekYears.differenceInISOWeekYears = differenceInISOWeekYears$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireCompareAsc();
+	var _index3 = /*@__PURE__*/ requireDifferenceInCalendarISOWeekYears();
+	var _index4 = /*@__PURE__*/ requireSubISOWeekYears();
+
+	/**
+	 * The {@link differenceInISOWeekYears} function options.
+	 */
+
+	/**
+	 * @name differenceInISOWeekYears
+	 * @category ISO Week-Numbering Year Helpers
+	 * @summary Get the number of full ISO week-numbering years between the given dates.
+	 *
+	 * @description
+	 * Get the number of full ISO week-numbering years between the given dates.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - The options
+	 *
+	 * @returns The number of full ISO week-numbering years
+	 *
+	 * @example
+	 * // How many full ISO week-numbering years are between 1 January 2010 and 1 January 2012?
+	 * const result = differenceInISOWeekYears(
+	 *   new Date(2012, 0, 1),
+	 *   new Date(2010, 0, 1)
+	 * )
+	 * // => 1
+	 */
+	function differenceInISOWeekYears$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const sign = (0, _index2.compareAsc)(laterDate_, earlierDate_);
+	  const diff = Math.abs(
+	    (0, _index3.differenceInCalendarISOWeekYears)(
+	      laterDate_,
+	      earlierDate_,
+	      options,
+	    ),
+	  );
+
+	  const adjustedDate = (0, _index4.subISOWeekYears)(
+	    laterDate_,
+	    sign * diff,
+	    options,
+	  );
+
+	  const isLastISOWeekYearNotFull = Number(
+	    (0, _index2.compareAsc)(adjustedDate, earlierDate_) === -sign,
+	  );
+	  const result = sign * (diff - isLastISOWeekYearNotFull);
+
+	  // Prevent negative zero
+	  return result === 0 ? 0 : result;
+	}
+	return differenceInISOWeekYears;
+}
+
+export { requireDifferenceInISOWeekYears as __require };

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

@@ -0,0 +1,40 @@
+import { __exports as differenceInMilliseconds } from '../../_virtual/differenceInMilliseconds.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredDifferenceInMilliseconds;
+
+function requireDifferenceInMilliseconds () {
+	if (hasRequiredDifferenceInMilliseconds) return differenceInMilliseconds;
+	hasRequiredDifferenceInMilliseconds = 1;
+	differenceInMilliseconds.differenceInMilliseconds = differenceInMilliseconds$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name differenceInMilliseconds
+	 * @category Millisecond Helpers
+	 * @summary Get the number of milliseconds between the given dates.
+	 *
+	 * @description
+	 * Get the number of milliseconds between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 *
+	 * @returns The number of milliseconds
+	 *
+	 * @example
+	 * // How many milliseconds are between
+	 * // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700?
+	 * const result = differenceInMilliseconds(
+	 *   new Date(2014, 6, 2, 12, 30, 21, 700),
+	 *   new Date(2014, 6, 2, 12, 30, 20, 600)
+	 * )
+	 * //=> 1100
+	 */
+	function differenceInMilliseconds$1(laterDate, earlierDate) {
+	  return +(0, _index.toDate)(laterDate) - +(0, _index.toDate)(earlierDate);
+	}
+	return differenceInMilliseconds;
+}
+
+export { requireDifferenceInMilliseconds as __require };