tp-react-elements-dev 1.14.3 → 1.14.5

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

@@ -0,0 +1,82 @@
+import { __exports as eachMonthOfInterval } from '../../_virtual/eachMonthOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredEachMonthOfInterval;
+
+function requireEachMonthOfInterval () {
+	if (hasRequiredEachMonthOfInterval) return eachMonthOfInterval;
+	hasRequiredEachMonthOfInterval = 1;
+	eachMonthOfInterval.eachMonthOfInterval = eachMonthOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link eachMonthOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachMonthOfInterval} function result type. It resolves the proper data type.
+	 */
+
+	/**
+	 * @name eachMonthOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of months within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of months within the specified time interval.
+	 *
+	 * @typeParam IntervalType - Interval type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param interval - The interval.
+	 * @param options - An object with options.
+	 *
+	 * @returns The array with starts of months from the month of the interval start to the month of the interval end
+	 *
+	 * @example
+	 * // Each month between 6 February 2014 and 10 August 2014:
+	 * const result = eachMonthOfInterval({
+	 *   start: new Date(2014, 1, 6),
+	 *   end: new Date(2014, 7, 10)
+	 * })
+	 * //=> [
+	 * //   Sat Feb 01 2014 00:00:00,
+	 * //   Sat Mar 01 2014 00:00:00,
+	 * //   Tue Apr 01 2014 00:00:00,
+	 * //   Thu May 01 2014 00:00:00,
+	 * //   Sun Jun 01 2014 00:00:00,
+	 * //   Tue Jul 01 2014 00:00:00,
+	 * //   Fri Aug 01 2014 00:00:00
+	 * // ]
+	 */
+	function eachMonthOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+
+	  let reversed = +start > +end;
+	  const endTime = reversed ? +start : +end;
+	  const date = reversed ? end : start;
+	  date.setHours(0, 0, 0, 0);
+	  date.setDate(1);
+
+	  let step = options?.step ?? 1;
+	  if (!step) return [];
+	  if (step < 0) {
+	    step = -step;
+	    reversed = !reversed;
+	  }
+
+	  const dates = [];
+
+	  while (+date <= endTime) {
+	    dates.push((0, _index2.constructFrom)(start, date));
+	    date.setMonth(date.getMonth() + step);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachMonthOfInterval;
+}
+
+export { requireEachMonthOfInterval as __require };

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

@@ -0,0 +1,87 @@
+import { __exports as eachQuarterOfInterval } from '../../_virtual/eachQuarterOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireAddQuarters } from './addQuarters.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+import { __require as requireStartOfQuarter } from './startOfQuarter.esm.js';
+
+var hasRequiredEachQuarterOfInterval;
+
+function requireEachQuarterOfInterval () {
+	if (hasRequiredEachQuarterOfInterval) return eachQuarterOfInterval;
+	hasRequiredEachQuarterOfInterval = 1;
+	eachQuarterOfInterval.eachQuarterOfInterval = eachQuarterOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireAddQuarters();
+	var _index3 = /*@__PURE__*/ requireConstructFrom();
+	var _index4 = /*@__PURE__*/ requireStartOfQuarter();
+
+	/**
+	 * The {@link eachQuarterOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachQuarterOfInterval} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the date argument,
+	 * then the start interval date, and finally the end interval date. If
+	 * a context function is passed, it uses the context function return type.
+	 */
+
+	/**
+	 * @name eachQuarterOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of quarters within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of quarters within the specified time interval.
+	 *
+	 * @typeParam IntervalType - Interval type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param interval - The interval
+	 * @param options - An object with options
+	 *
+	 * @returns The array with starts of quarters from the quarter of the interval start to the quarter of the interval end
+	 *
+	 * @example
+	 * // Each quarter within interval 6 February 2014 - 10 August 2014:
+	 * const result = eachQuarterOfInterval({
+	 *   start: new Date(2014, 1, 6),
+	 *   end: new Date(2014, 7, 10),
+	 * })
+	 * //=> [
+	 * //   Wed Jan 01 2014 00:00:00,
+	 * //   Tue Apr 01 2014 00:00:00,
+	 * //   Tue Jul 01 2014 00:00:00,
+	 * // ]
+	 */
+	function eachQuarterOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+
+	  let reversed = +start > +end;
+	  const endTime = reversed
+	    ? +(0, _index4.startOfQuarter)(start)
+	    : +(0, _index4.startOfQuarter)(end);
+	  let date = reversed
+	    ? (0, _index4.startOfQuarter)(end)
+	    : (0, _index4.startOfQuarter)(start);
+
+	  let step = options?.step ?? 1;
+	  if (!step) return [];
+	  if (step < 0) {
+	    step = -step;
+	    reversed = !reversed;
+	  }
+
+	  const dates = [];
+
+	  while (+date <= endTime) {
+	    dates.push((0, _index3.constructFrom)(start, date));
+	    date = (0, _index2.addQuarters)(date, step);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachQuarterOfInterval;
+}
+
+export { requireEachQuarterOfInterval as __require };

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

@@ -0,0 +1,96 @@
+import { __exports as eachWeekOfInterval } from '../../_virtual/eachWeekOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireAddWeeks } from './addWeeks.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+import { __require as requireStartOfWeek } from './startOfWeek.esm2.js';
+
+var hasRequiredEachWeekOfInterval;
+
+function requireEachWeekOfInterval () {
+	if (hasRequiredEachWeekOfInterval) return eachWeekOfInterval;
+	hasRequiredEachWeekOfInterval = 1;
+	eachWeekOfInterval.eachWeekOfInterval = eachWeekOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireAddWeeks();
+	var _index3 = /*@__PURE__*/ requireConstructFrom();
+	var _index4 = /*@__PURE__*/ requireStartOfWeek();
+
+	/**
+	 * The {@link eachWeekOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachWeekOfInterval} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the interval start date,
+	 * then the end interval date. If a context function is passed, it uses the context function return type.
+	 */
+
+	/**
+	 * @name eachWeekOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of weeks within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of weeks within the specified time interval.
+	 *
+	 * @param interval - The interval.
+	 * @param options - An object with options.
+	 *
+	 * @returns The array with starts of weeks from the week of the interval start to the week of the interval end
+	 *
+	 * @example
+	 * // Each week within interval 6 October 2014 - 23 November 2014:
+	 * const result = eachWeekOfInterval({
+	 *   start: new Date(2014, 9, 6),
+	 *   end: new Date(2014, 10, 23)
+	 * })
+	 * //=> [
+	 * //   Sun Oct 05 2014 00:00:00,
+	 * //   Sun Oct 12 2014 00:00:00,
+	 * //   Sun Oct 19 2014 00:00:00,
+	 * //   Sun Oct 26 2014 00:00:00,
+	 * //   Sun Nov 02 2014 00:00:00,
+	 * //   Sun Nov 09 2014 00:00:00,
+	 * //   Sun Nov 16 2014 00:00:00,
+	 * //   Sun Nov 23 2014 00:00:00
+	 * // ]
+	 */
+	function eachWeekOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+
+	  let reversed = +start > +end;
+	  const startDateWeek = reversed
+	    ? (0, _index4.startOfWeek)(end, options)
+	    : (0, _index4.startOfWeek)(start, options);
+	  const endDateWeek = reversed
+	    ? (0, _index4.startOfWeek)(start, options)
+	    : (0, _index4.startOfWeek)(end, options);
+
+	  startDateWeek.setHours(15);
+	  endDateWeek.setHours(15);
+
+	  const endTime = +endDateWeek.getTime();
+	  let currentDate = startDateWeek;
+
+	  let step = options?.step ?? 1;
+	  if (!step) return [];
+	  if (step < 0) {
+	    step = -step;
+	    reversed = !reversed;
+	  }
+
+	  const dates = [];
+
+	  while (+currentDate <= endTime) {
+	    currentDate.setHours(0);
+	    dates.push((0, _index3.constructFrom)(start, currentDate));
+	    currentDate = (0, _index2.addWeeks)(currentDate, step);
+	    currentDate.setHours(15);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachWeekOfInterval;
+}
+
+export { requireEachWeekOfInterval as __require };

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

@@ -0,0 +1,70 @@
+import { __exports as eachWeekendOfInterval } from '../../_virtual/eachWeekendOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+import { __require as requireEachDayOfInterval } from './eachDayOfInterval.esm.js';
+import { __require as requireIsWeekend } from './isWeekend.esm.js';
+
+var hasRequiredEachWeekendOfInterval;
+
+function requireEachWeekendOfInterval () {
+	if (hasRequiredEachWeekendOfInterval) return eachWeekendOfInterval;
+	hasRequiredEachWeekendOfInterval = 1;
+	eachWeekendOfInterval.eachWeekendOfInterval = eachWeekendOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _index3 = /*@__PURE__*/ requireEachDayOfInterval();
+	var _index4 = /*@__PURE__*/ requireIsWeekend();
+
+	/**
+	 * The {@link eachWeekendOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachWeekendOfInterval} function result type.
+	 */
+
+	/**
+	 * @name eachWeekendOfInterval
+	 * @category Interval Helpers
+	 * @summary List all the Saturdays and Sundays in the given date interval.
+	 *
+	 * @description
+	 * Get all the Saturdays and Sundays in the given date interval.
+	 *
+	 * @typeParam IntervalType - Interval type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param interval - The given interval
+	 * @param options - An object with options
+	 *
+	 * @returns An array containing all the Saturdays and Sundays
+	 *
+	 * @example
+	 * // Lists all Saturdays and Sundays in the given date interval
+	 * const result = eachWeekendOfInterval({
+	 *   start: new Date(2018, 8, 17),
+	 *   end: new Date(2018, 8, 30)
+	 * })
+	 * //=> [
+	 * //   Sat Sep 22 2018 00:00:00,
+	 * //   Sun Sep 23 2018 00:00:00,
+	 * //   Sat Sep 29 2018 00:00:00,
+	 * //   Sun Sep 30 2018 00:00:00
+	 * // ]
+	 */
+	function eachWeekendOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+	  const dateInterval = (0, _index3.eachDayOfInterval)({ start, end }, options);
+	  const weekends = [];
+	  let index = 0;
+	  while (index < dateInterval.length) {
+	    const date = dateInterval[index++];
+	    if ((0, _index4.isWeekend)(date))
+	      weekends.push((0, _index2.constructFrom)(start, date));
+	  }
+	  return weekends;
+	}
+	return eachWeekendOfInterval;
+}
+
+export { requireEachWeekendOfInterval as __require };

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

@@ -0,0 +1,58 @@
+import { __exports as eachWeekendOfMonth } from '../../_virtual/eachWeekendOfMonth.esm.js';
+import { __require as requireEachWeekendOfInterval } from './eachWeekendOfInterval.esm.js';
+import { __require as requireEndOfMonth } from './endOfMonth.esm.js';
+import { __require as requireStartOfMonth } from './startOfMonth.esm.js';
+
+var hasRequiredEachWeekendOfMonth;
+
+function requireEachWeekendOfMonth () {
+	if (hasRequiredEachWeekendOfMonth) return eachWeekendOfMonth;
+	hasRequiredEachWeekendOfMonth = 1;
+	eachWeekendOfMonth.eachWeekendOfMonth = eachWeekendOfMonth$1;
+	var _index = /*@__PURE__*/ requireEachWeekendOfInterval();
+	var _index2 = /*@__PURE__*/ requireEndOfMonth();
+	var _index3 = /*@__PURE__*/ requireStartOfMonth();
+
+	/**
+	 * The {@link eachWeekendOfMonth} function options.
+	 */
+
+	/**
+	 * @name eachWeekendOfMonth
+	 * @category Month Helpers
+	 * @summary List all the Saturdays and Sundays in the given month.
+	 *
+	 * @description
+	 * Get all the Saturdays and Sundays in the given month.
+	 *
+	 * @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).
+	 * @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 given month
+	 * @param options - An object with options
+	 *
+	 * @returns An array containing all the Saturdays and Sundays
+	 *
+	 * @example
+	 * // Lists all Saturdays and Sundays in the given month
+	 * const result = eachWeekendOfMonth(new Date(2022, 1, 1))
+	 * //=> [
+	 * //   Sat Feb 05 2022 00:00:00,
+	 * //   Sun Feb 06 2022 00:00:00,
+	 * //   Sat Feb 12 2022 00:00:00,
+	 * //   Sun Feb 13 2022 00:00:00,
+	 * //   Sat Feb 19 2022 00:00:00,
+	 * //   Sun Feb 20 2022 00:00:00,
+	 * //   Sat Feb 26 2022 00:00:00,
+	 * //   Sun Feb 27 2022 00:00:00
+	 * // ]
+	 */
+	function eachWeekendOfMonth$1(date, options) {
+	  const start = (0, _index3.startOfMonth)(date, options);
+	  const end = (0, _index2.endOfMonth)(date, options);
+	  return (0, _index.eachWeekendOfInterval)({ start, end }, options);
+	}
+	return eachWeekendOfMonth;
+}
+
+export { requireEachWeekendOfMonth as __require };

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

@@ -0,0 +1,55 @@
+import { __exports as eachWeekendOfYear } from '../../_virtual/eachWeekendOfYear.esm.js';
+import { __require as requireEachWeekendOfInterval } from './eachWeekendOfInterval.esm.js';
+import { __require as requireEndOfYear } from './endOfYear.esm.js';
+import { __require as requireStartOfYear } from './startOfYear.esm2.js';
+
+var hasRequiredEachWeekendOfYear;
+
+function requireEachWeekendOfYear () {
+	if (hasRequiredEachWeekendOfYear) return eachWeekendOfYear;
+	hasRequiredEachWeekendOfYear = 1;
+	eachWeekendOfYear.eachWeekendOfYear = eachWeekendOfYear$1;
+	var _index = /*@__PURE__*/ requireEachWeekendOfInterval();
+	var _index2 = /*@__PURE__*/ requireEndOfYear();
+	var _index3 = /*@__PURE__*/ requireStartOfYear();
+
+	/**
+	 * The {@link eachWeekendOfYear} function options.
+	 */
+
+	/**
+	 * @name eachWeekendOfYear
+	 * @category Year Helpers
+	 * @summary List all the Saturdays and Sundays in the year.
+	 *
+	 * @description
+	 * Get all the Saturdays and Sundays in the year.
+	 *
+	 * @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).
+	 * @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 given year
+	 * @param options - An object with options
+	 *
+	 * @returns An array containing all the Saturdays and Sundays
+	 *
+	 * @example
+	 * // Lists all Saturdays and Sundays in the year
+	 * const result = eachWeekendOfYear(new Date(2020, 1, 1))
+	 * //=> [
+	 * //   Sat Jan 03 2020 00:00:00,
+	 * //   Sun Jan 04 2020 00:00:00,
+	 * //   ...
+	 * //   Sun Dec 27 2020 00:00:00
+	 * // ]
+	 * ]
+	 */
+	function eachWeekendOfYear$1(date, options) {
+	  const start = (0, _index3.startOfYear)(date, options);
+	  const end = (0, _index2.endOfYear)(date, options);
+	  return (0, _index.eachWeekendOfInterval)({ start, end }, options);
+	}
+	return eachWeekendOfYear;
+}
+
+export { requireEachWeekendOfYear as __require };

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

@@ -0,0 +1,82 @@
+import { __exports as eachYearOfInterval } from '../../_virtual/eachYearOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredEachYearOfInterval;
+
+function requireEachYearOfInterval () {
+	if (hasRequiredEachYearOfInterval) return eachYearOfInterval;
+	hasRequiredEachYearOfInterval = 1;
+	eachYearOfInterval.eachYearOfInterval = eachYearOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link eachYearOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachYearOfInterval} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the date argument,
+	 * then the start interval date, and finally the end interval date. If
+	 * a context function is passed, it uses the context function return type.
+	 */
+
+	/**
+	 * @name eachYearOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of yearly timestamps within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of yearly timestamps within the specified time interval.
+	 *
+	 * @typeParam IntervalType - Interval type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param interval - The interval.
+	 * @param options - An object with options.
+	 *
+	 * @returns The array with starts of yearly timestamps from the month of the interval start to the month of the interval end
+	 *
+	 * @example
+	 * // Each year between 6 February 2014 and 10 August 2017:
+	 * const result = eachYearOfInterval({
+	 *   start: new Date(2014, 1, 6),
+	 *   end: new Date(2017, 7, 10)
+	 * })
+	 * //=> [
+	 * //   Wed Jan 01 2014 00:00:00,
+	 * //   Thu Jan 01 2015 00:00:00,
+	 * //   Fri Jan 01 2016 00:00:00,
+	 * //   Sun Jan 01 2017 00:00:00
+	 * // ]
+	 */
+	function eachYearOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+
+	  let reversed = +start > +end;
+	  const endTime = reversed ? +start : +end;
+	  const date = reversed ? end : start;
+	  date.setHours(0, 0, 0, 0);
+	  date.setMonth(0, 1);
+
+	  let step = options?.step ?? 1;
+	  if (!step) return [];
+	  if (step < 0) {
+	    step = -step;
+	    reversed = !reversed;
+	  }
+
+	  const dates = [];
+
+	  while (+date <= endTime) {
+	    dates.push((0, _index2.constructFrom)(start, date));
+	    date.setFullYear(date.getFullYear() + step);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachYearOfInterval;
+}
+
+export { requireEachYearOfInterval as __require };

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

@@ -0,0 +1,46 @@
+import { __exports as endOfDay } from '../../_virtual/endOfDay.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredEndOfDay;
+
+function requireEndOfDay () {
+	if (hasRequiredEndOfDay) return endOfDay;
+	hasRequiredEndOfDay = 1;
+	endOfDay.endOfDay = endOfDay$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link endOfDay} function options.
+	 */
+
+	/**
+	 * @name endOfDay
+	 * @category Day Helpers
+	 * @summary Return the end of a day for the given date.
+	 *
+	 * @description
+	 * Return the end of a day for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * @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).
+	 * @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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The end of a day
+	 *
+	 * @example
+	 * // The end of a day for 2 September 2014 11:55:00:
+	 * const result = endOfDay(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Tue Sep 02 2014 23:59:59.999
+	 */
+	function endOfDay$1(date, options) {
+	  const _date = (0, _index.toDate)(date, options?.in);
+	  _date.setHours(23, 59, 59, 999);
+	  return _date;
+	}
+	return endOfDay;
+}
+
+export { requireEndOfDay as __require };

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

@@ -0,0 +1,51 @@
+import { __exports as endOfDecade } from '../../_virtual/endOfDecade.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredEndOfDecade;
+
+function requireEndOfDecade () {
+	if (hasRequiredEndOfDecade) return endOfDecade;
+	hasRequiredEndOfDecade = 1;
+	endOfDecade.endOfDecade = endOfDecade$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link endOfDecade} function options.
+	 */
+
+	/**
+	 * @name endOfDecade
+	 * @category Decade Helpers
+	 * @summary Return the end of a decade for the given date.
+	 *
+	 * @description
+	 * Return the end of a decade for the given date.
+	 *
+	 * @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).
+	 * @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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The end of a decade
+	 *
+	 * @example
+	 * // The end of a decade for 12 May 1984 00:00:00:
+	 * const result = endOfDecade(new Date(1984, 4, 12, 00, 00, 00))
+	 * //=> Dec 31 1989 23:59:59.999
+	 */
+	function endOfDecade$1(date, options) {
+	  // TODO: Switch to more technical definition in of decades that start with 1
+	  // end with 0. I.e. 2001-2010 instead of current 2000-2009. It's a breaking
+	  // change, so it can only be done in 4.0.
+	  const _date = (0, _index.toDate)(date, options?.in);
+	  const year = _date.getFullYear();
+	  const decade = 9 + Math.floor(year / 10) * 10;
+	  _date.setFullYear(decade, 11, 31);
+	  _date.setHours(23, 59, 59, 999);
+	  return _date;
+	}
+	return endOfDecade;
+}
+
+export { requireEndOfDecade as __require };

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

@@ -0,0 +1,46 @@
+import { __exports as endOfHour } from '../../_virtual/endOfHour.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredEndOfHour;
+
+function requireEndOfHour () {
+	if (hasRequiredEndOfHour) return endOfHour;
+	hasRequiredEndOfHour = 1;
+	endOfHour.endOfHour = endOfHour$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link endOfHour} function options.
+	 */
+
+	/**
+	 * @name endOfHour
+	 * @category Hour Helpers
+	 * @summary Return the end of an hour for the given date.
+	 *
+	 * @description
+	 * Return the end of an hour for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * @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).
+	 * @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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The end of an hour
+	 *
+	 * @example
+	 * // The end of an hour for 2 September 2014 11:55:00:
+	 * const result = endOfHour(new Date(2014, 8, 2, 11, 55))
+	 * //=> Tue Sep 02 2014 11:59:59.999
+	 */
+	function endOfHour$1(date, options) {
+	  const _date = (0, _index.toDate)(date, options?.in);
+	  _date.setMinutes(59, 59, 999);
+	  return _date;
+	}
+	return endOfHour;
+}
+
+export { requireEndOfHour as __require };