tp-react-elements-dev 1.14.3 → 1.14.4

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

@@ -0,0 +1,59 @@
+import { __exports as differenceInMinutes } from '../../_virtual/differenceInMinutes.esm.js';
+import { __require as requireGetRoundingMethod } from './_lib/getRoundingMethod.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+import { __require as requireDifferenceInMilliseconds } from './differenceInMilliseconds.esm.js';
+
+var hasRequiredDifferenceInMinutes;
+
+function requireDifferenceInMinutes () {
+	if (hasRequiredDifferenceInMinutes) return differenceInMinutes;
+	hasRequiredDifferenceInMinutes = 1;
+	differenceInMinutes.differenceInMinutes = differenceInMinutes$1;
+	var _index = /*@__PURE__*/ requireGetRoundingMethod();
+	var _index2 = /*@__PURE__*/ requireConstants();
+	var _index3 = /*@__PURE__*/ requireDifferenceInMilliseconds();
+
+	/**
+	 * The {@link differenceInMinutes} function options.
+	 */
+
+	/**
+	 * @name differenceInMinutes
+	 * @category Minute Helpers
+	 * @summary Get the number of minutes between the given dates.
+	 *
+	 * @description
+	 * Get the signed number of full (rounded towards 0) minutes between the given dates.
+	 *
+	 * @param dateLeft - The later date
+	 * @param dateRight - The earlier date
+	 * @param options - An object with options.
+	 *
+	 * @returns The number of minutes
+	 *
+	 * @example
+	 * // How many minutes are between 2 July 2014 12:07:59 and 2 July 2014 12:20:00?
+	 * const result = differenceInMinutes(
+	 *   new Date(2014, 6, 2, 12, 20, 0),
+	 *   new Date(2014, 6, 2, 12, 7, 59)
+	 * )
+	 * //=> 12
+	 *
+	 * @example
+	 * // How many minutes are between 10:01:59 and 10:00:00
+	 * const result = differenceInMinutes(
+	 *   new Date(2000, 0, 1, 10, 0, 0),
+	 *   new Date(2000, 0, 1, 10, 1, 59)
+	 * )
+	 * //=> -1
+	 */
+	function differenceInMinutes$1(dateLeft, dateRight, options) {
+	  const diff =
+	    (0, _index3.differenceInMilliseconds)(dateLeft, dateRight) /
+	    _index2.millisecondsInMinute;
+	  return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff);
+	}
+	return differenceInMinutes;
+}
+
+export { requireDifferenceInMinutes as __require };

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

@@ -0,0 +1,70 @@
+import { __exports as differenceInMonths } from '../../_virtual/differenceInMonths.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireCompareAsc } from './compareAsc.esm.js';
+import { __require as requireDifferenceInCalendarMonths } from './differenceInCalendarMonths.esm.js';
+import { __require as requireIsLastDayOfMonth } from './isLastDayOfMonth.esm.js';
+
+var hasRequiredDifferenceInMonths;
+
+function requireDifferenceInMonths () {
+	if (hasRequiredDifferenceInMonths) return differenceInMonths;
+	hasRequiredDifferenceInMonths = 1;
+	differenceInMonths.differenceInMonths = differenceInMonths$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireCompareAsc();
+	var _index3 = /*@__PURE__*/ requireDifferenceInCalendarMonths();
+	var _index4 = /*@__PURE__*/ requireIsLastDayOfMonth();
+
+	/**
+	 * The {@link differenceInMonths} function options.
+	 */
+
+	/**
+	 * @name differenceInMonths
+	 * @category Month Helpers
+	 * @summary Get the number of full 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 full months
+	 *
+	 * @example
+	 * // How many full months are between 31 January 2014 and 1 September 2014?
+	 * const result = differenceInMonths(new Date(2014, 8, 1), new Date(2014, 0, 31))
+	 * //=> 7
+	 */
+	function differenceInMonths$1(laterDate, earlierDate, options) {
+	  const [laterDate_, workingLaterDate, earlierDate_] = (0, _index.normalizeDates)(options?.in, laterDate, laterDate, earlierDate);
+
+	  const sign = (0, _index2.compareAsc)(workingLaterDate, earlierDate_);
+	  const difference = Math.abs(
+	    (0, _index3.differenceInCalendarMonths)(workingLaterDate, earlierDate_),
+	  );
+
+	  if (difference < 1) return 0;
+
+	  if (workingLaterDate.getMonth() === 1 && workingLaterDate.getDate() > 27)
+	    workingLaterDate.setDate(30);
+
+	  workingLaterDate.setMonth(workingLaterDate.getMonth() - sign * difference);
+
+	  let isLastMonthNotFull =
+	    (0, _index2.compareAsc)(workingLaterDate, earlierDate_) === -sign;
+
+	  if (
+	    (0, _index4.isLastDayOfMonth)(laterDate_) &&
+	    difference === 1 &&
+	    (0, _index2.compareAsc)(laterDate_, earlierDate_) === 1
+	  ) {
+	    isLastMonthNotFull = false;
+	  }
+
+	  const result = sign * (difference - +isLastMonthNotFull);
+	  return result === 0 ? 0 : result;
+	}
+	return differenceInMonths;
+}
+
+export { requireDifferenceInMonths as __require };

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

@@ -0,0 +1,45 @@
+import { __exports as differenceInQuarters } from '../../_virtual/differenceInQuarters.esm.js';
+import { __require as requireGetRoundingMethod } from './_lib/getRoundingMethod.esm.js';
+import { __require as requireDifferenceInMonths } from './differenceInMonths.esm.js';
+
+var hasRequiredDifferenceInQuarters;
+
+function requireDifferenceInQuarters () {
+	if (hasRequiredDifferenceInQuarters) return differenceInQuarters;
+	hasRequiredDifferenceInQuarters = 1;
+	differenceInQuarters.differenceInQuarters = differenceInQuarters$1;
+	var _index = /*@__PURE__*/ requireGetRoundingMethod();
+	var _index2 = /*@__PURE__*/ requireDifferenceInMonths();
+
+	/**
+	 * The {@link differenceInQuarters} function options.
+	 */
+
+	/**
+	 * @name differenceInQuarters
+	 * @category Quarter Helpers
+	 * @summary Get the number of quarters between the given dates.
+	 *
+	 * @description
+	 * Get the number of 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 full quarters
+	 *
+	 * @example
+	 * // How many full quarters are between 31 December 2013 and 2 July 2014?
+	 * const result = differenceInQuarters(new Date(2014, 6, 2), new Date(2013, 11, 31))
+	 * //=> 2
+	 */
+	function differenceInQuarters$1(laterDate, earlierDate, options) {
+	  const diff =
+	    (0, _index2.differenceInMonths)(laterDate, earlierDate, options) / 3;
+	  return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff);
+	}
+	return differenceInQuarters;
+}
+
+export { requireDifferenceInQuarters as __require };

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

@@ -0,0 +1,49 @@
+import { __exports as differenceInSeconds } from '../../_virtual/differenceInSeconds.esm.js';
+import { __require as requireGetRoundingMethod } from './_lib/getRoundingMethod.esm.js';
+import { __require as requireDifferenceInMilliseconds } from './differenceInMilliseconds.esm.js';
+
+var hasRequiredDifferenceInSeconds;
+
+function requireDifferenceInSeconds () {
+	if (hasRequiredDifferenceInSeconds) return differenceInSeconds;
+	hasRequiredDifferenceInSeconds = 1;
+	differenceInSeconds.differenceInSeconds = differenceInSeconds$1;
+	var _index = /*@__PURE__*/ requireGetRoundingMethod();
+	var _index2 = /*@__PURE__*/ requireDifferenceInMilliseconds();
+
+	/**
+	 * The {@link differenceInSeconds} function options.
+	 */
+
+	/**
+	 * @name differenceInSeconds
+	 * @category Second Helpers
+	 * @summary Get the number of seconds between the given dates.
+	 *
+	 * @description
+	 * Get the number of seconds between the given dates.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options.
+	 *
+	 * @returns The number of seconds
+	 *
+	 * @example
+	 * // How many seconds are between
+	 * // 2 July 2014 12:30:07.999 and 2 July 2014 12:30:20.000?
+	 * const result = differenceInSeconds(
+	 *   new Date(2014, 6, 2, 12, 30, 20, 0),
+	 *   new Date(2014, 6, 2, 12, 30, 7, 999)
+	 * )
+	 * //=> 12
+	 */
+	function differenceInSeconds$1(laterDate, earlierDate, options) {
+	  const diff =
+	    (0, _index2.differenceInMilliseconds)(laterDate, earlierDate) / 1000;
+	  return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff);
+	}
+	return differenceInSeconds;
+}
+
+export { requireDifferenceInSeconds as __require };

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

@@ -0,0 +1,66 @@
+import { __exports as differenceInWeeks } from '../../_virtual/differenceInWeeks.esm.js';
+import { __require as requireGetRoundingMethod } from './_lib/getRoundingMethod.esm.js';
+import { __require as requireDifferenceInDays } from './differenceInDays.esm.js';
+
+var hasRequiredDifferenceInWeeks;
+
+function requireDifferenceInWeeks () {
+	if (hasRequiredDifferenceInWeeks) return differenceInWeeks;
+	hasRequiredDifferenceInWeeks = 1;
+	differenceInWeeks.differenceInWeeks = differenceInWeeks$1;
+	var _index = /*@__PURE__*/ requireGetRoundingMethod();
+	var _index2 = /*@__PURE__*/ requireDifferenceInDays();
+
+	/**
+	 * The {@link differenceInWeeks} function options.
+	 */
+
+	/**
+	 * @name differenceInWeeks
+	 * @category Week Helpers
+	 * @summary Get the number of full weeks between the given dates.
+	 *
+	 * @description
+	 * Get the number of full weeks between two dates. Fractional weeks are
+	 * truncated towards zero by default.
+	 *
+	 * One "full week" is the distance between a local time in one day to the same
+	 * local time 7 days earlier or later. A full week can sometimes be less than
+	 * or more than 7*24 hours if a daylight savings change happens between two dates.
+	 *
+	 * To ignore DST and only measure exact 7*24-hour periods, use this instead:
+	 * `Math.trunc(differenceInHours(dateLeft, dateRight)/(7*24))|0`.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of full weeks
+	 *
+	 * @example
+	 * // How many full weeks are between 5 July 2014 and 20 July 2014?
+	 * const result = differenceInWeeks(new Date(2014, 6, 20), new Date(2014, 6, 5))
+	 * //=> 2
+	 *
+	 * @example
+	 * // How many full weeks are between
+	 * // 1 March 2020 0:00 and 6 June 2020 0:00 ?
+	 * // Note: because local time is used, the
+	 * // result will always be 8 weeks (54 days),
+	 * // even if DST starts and the period has
+	 * // only 54*24-1 hours.
+	 * const result = differenceInWeeks(
+	 *   new Date(2020, 5, 1),
+	 *   new Date(2020, 2, 6)
+	 * )
+	 * //=> 8
+	 */
+	function differenceInWeeks$1(laterDate, earlierDate, options) {
+	  const diff =
+	    (0, _index2.differenceInDays)(laterDate, earlierDate, options) / 7;
+	  return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff);
+	}
+	return differenceInWeeks;
+}
+
+export { requireDifferenceInWeeks as __require };

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

@@ -0,0 +1,77 @@
+import { __exports as differenceInYears } from '../../_virtual/differenceInYears.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireCompareAsc } from './compareAsc.esm.js';
+import { __require as requireDifferenceInCalendarYears } from './differenceInCalendarYears.esm.js';
+
+var hasRequiredDifferenceInYears;
+
+function requireDifferenceInYears () {
+	if (hasRequiredDifferenceInYears) return differenceInYears;
+	hasRequiredDifferenceInYears = 1;
+	differenceInYears.differenceInYears = differenceInYears$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireCompareAsc();
+	var _index3 = /*@__PURE__*/ requireDifferenceInCalendarYears();
+
+	/**
+	 * The {@link differenceInYears} function options.
+	 */
+
+	/**
+	 * @name differenceInYears
+	 * @category Year Helpers
+	 * @summary Get the number of full years between the given dates.
+	 *
+	 * @description
+	 * Get the number of full 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 full years
+	 *
+	 * @example
+	 * // How many full years are between 31 December 2013 and 11 February 2015?
+	 * const result = differenceInYears(new Date(2015, 1, 11), new Date(2013, 11, 31))
+	 * //=> 1
+	 */
+	function differenceInYears$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  // -1 if the left date is earlier than the right date
+	  // 2023-12-31 - 2024-01-01 = -1
+	  const sign = (0, _index2.compareAsc)(laterDate_, earlierDate_);
+
+	  // First calculate the difference in calendar years
+	  // 2024-01-01 - 2023-12-31 = 1 year
+	  const diff = Math.abs(
+	    (0, _index3.differenceInCalendarYears)(laterDate_, earlierDate_),
+	  );
+
+	  // Now we need to calculate if the difference is full. To do that we set
+	  // both dates to the same year and check if the both date's month and day
+	  // form a full year.
+	  laterDate_.setFullYear(1584);
+	  earlierDate_.setFullYear(1584);
+
+	  // For it to be true, when the later date is indeed later than the earlier date
+	  // (2026-02-01 - 2023-12-10 = 3 years), the difference is full if
+	  // the normalized later date is also later than the normalized earlier date.
+	  // In our example, 1584-02-01 is earlier than 1584-12-10, so the difference
+	  // is partial, hence we need to subtract 1 from the difference 3 - 1 = 2.
+	  const partial = (0, _index2.compareAsc)(laterDate_, earlierDate_) === -sign;
+
+	  const result = sign * (diff - +partial);
+
+	  // Prevent negative zero
+	  return result === 0 ? 0 : result;
+	}
+	return differenceInYears;
+}
+
+export { requireDifferenceInYears as __require };

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

@@ -0,0 +1,83 @@
+import { __exports as eachDayOfInterval } from '../../_virtual/eachDayOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredEachDayOfInterval;
+
+function requireEachDayOfInterval () {
+	if (hasRequiredEachDayOfInterval) return eachDayOfInterval;
+	hasRequiredEachDayOfInterval = 1;
+	eachDayOfInterval.eachDayOfInterval = eachDayOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link eachDayOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachDayOfInterval} 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 eachDayOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of dates within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of dates 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 days from the day of the interval start to the day of the interval end
+	 *
+	 * @example
+	 * // Each day between 6 October 2014 and 10 October 2014:
+	 * const result = eachDayOfInterval({
+	 *   start: new Date(2014, 9, 6),
+	 *   end: new Date(2014, 9, 10)
+	 * })
+	 * //=> [
+	 * //   Mon Oct 06 2014 00:00:00,
+	 * //   Tue Oct 07 2014 00:00:00,
+	 * //   Wed Oct 08 2014 00:00:00,
+	 * //   Thu Oct 09 2014 00:00:00,
+	 * //   Fri Oct 10 2014 00:00:00
+	 * // ]
+	 */
+	function eachDayOfInterval$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);
+
+	  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.setDate(date.getDate() + step);
+	    date.setHours(0, 0, 0, 0);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachDayOfInterval;
+}
+
+export { requireEachDayOfInterval as __require };

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

@@ -0,0 +1,79 @@
+import { __exports as eachHourOfInterval } from '../../_virtual/eachHourOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredEachHourOfInterval;
+
+function requireEachHourOfInterval () {
+	if (hasRequiredEachHourOfInterval) return eachHourOfInterval;
+	hasRequiredEachHourOfInterval = 1;
+	eachHourOfInterval.eachHourOfInterval = eachHourOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link eachHourOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachHourOfInterval} function result type.
+	 * Resolves to the appropriate date type based on inputs.
+	 */
+
+	/**
+	 * @name eachHourOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of hours within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of hours 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 hours from the hour of the interval start to the hour of the interval end
+	 *
+	 * @example
+	 * // Each hour between 6 October 2014, 12:00 and 6 October 2014, 15:00
+	 * const result = eachHourOfInterval({
+	 *   start: new Date(2014, 9, 6, 12),
+	 *   end: new Date(2014, 9, 6, 15)
+	 * });
+	 * //=> [
+	 * //   Mon Oct 06 2014 12:00:00,
+	 * //   Mon Oct 06 2014 13:00:00,
+	 * //   Mon Oct 06 2014 14:00:00,
+	 * //   Mon Oct 06 2014 15:00:00
+	 * // ]
+	 */
+	function eachHourOfInterval$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.setMinutes(0, 0, 0);
+
+	  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.setHours(date.getHours() + step);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachHourOfInterval;
+}
+
+export { requireEachHourOfInterval as __require };

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

@@ -0,0 +1,84 @@
+import { __exports as eachMinuteOfInterval } from '../../_virtual/eachMinuteOfInterval.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireAddMinutes } from './addMinutes.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredEachMinuteOfInterval;
+
+function requireEachMinuteOfInterval () {
+	if (hasRequiredEachMinuteOfInterval) return eachMinuteOfInterval;
+	hasRequiredEachMinuteOfInterval = 1;
+	eachMinuteOfInterval.eachMinuteOfInterval = eachMinuteOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireAddMinutes();
+	var _index3 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link eachMinuteOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachMinuteOfInterval} 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 eachMinuteOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of minutes within the specified time interval.
+	 *
+	 * @description
+	 * Returns the array of minutes 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 minutes from the minute of the interval start to the minute of the interval end
+	 *
+	 * @example
+	 * // Each minute between 14 October 2020, 13:00 and 14 October 2020, 13:03
+	 * const result = eachMinuteOfInterval({
+	 *   start: new Date(2014, 9, 14, 13),
+	 *   end: new Date(2014, 9, 14, 13, 3)
+	 * })
+	 * //=> [
+	 * //   Wed Oct 14 2014 13:00:00,
+	 * //   Wed Oct 14 2014 13:01:00,
+	 * //   Wed Oct 14 2014 13:02:00,
+	 * //   Wed Oct 14 2014 13:03:00
+	 * // ]
+	 */
+	function eachMinuteOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+	  // Set to the start of the minute
+	  start.setSeconds(0, 0);
+
+	  let reversed = +start > +end;
+	  const endTime = reversed ? +start : +end;
+	  let date = reversed ? end : 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.addMinutes)(date, step);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachMinuteOfInterval;
+}
+
+export { requireEachMinuteOfInterval as __require };