tp-react-elements-dev 1.14.3 → 1.14.5

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

@@ -0,0 +1,59 @@
+import { __exports as interval } from '../../_virtual/interval.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+
+var hasRequiredInterval;
+
+function requireInterval () {
+	if (hasRequiredInterval) return interval;
+	hasRequiredInterval = 1;
+	interval.interval = interval$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	/**
+	 * The {@link interval} function options.
+	 */
+
+	/**
+	 * The {@link interval} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the start argument,
+	 * then the end interval date. If a context function is passed, it uses the context
+	 * function return type.
+	 */
+
+	/**
+	 * @name interval
+	 * @category Interval Helpers
+	 * @summary Creates an interval object and validates its values.
+	 *
+	 * @description
+	 * Creates a normalized interval object and validates its values. If the interval is invalid, an exception is thrown.
+	 *
+	 * @typeParam StartDate - Start date type.
+	 * @typeParam EndDate - End date type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param start - The start of the interval.
+	 * @param end - The end of the interval.
+	 * @param options - The options object.
+	 *
+	 * @throws `Start date is invalid` when `start` is invalid.
+	 * @throws `End date is invalid` when `end` is invalid.
+	 * @throws `End date must be after start date` when end is before `start` and `options.assertPositive` is true.
+	 *
+	 * @returns The normalized and validated interval object.
+	 */
+	function interval$1(start, end, options) {
+	  const [_start, _end] = (0, _index.normalizeDates)(options?.in, start, end);
+
+	  if (isNaN(+_start)) throw new TypeError("Start date is invalid");
+	  if (isNaN(+_end)) throw new TypeError("End date is invalid");
+
+	  if (options?.assertPositive && +_start > +_end)
+	    throw new TypeError("End date must be after start date");
+
+	  return { start: _start, end: _end };
+	}
+	return interval;
+}
+
+export { requireInterval as __require };

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

@@ -0,0 +1,91 @@
+import { __exports as intervalToDuration } from '../../_virtual/intervalToDuration.esm.js';
+import { __require as requireNormalizeInterval } from './_lib/normalizeInterval.esm.js';
+import { __require as requireAdd } from './add.esm.js';
+import { __require as requireDifferenceInDays } from './differenceInDays.esm.js';
+import { __require as requireDifferenceInHours } from './differenceInHours.esm.js';
+import { __require as requireDifferenceInMinutes } from './differenceInMinutes.esm.js';
+import { __require as requireDifferenceInMonths } from './differenceInMonths.esm.js';
+import { __require as requireDifferenceInSeconds } from './differenceInSeconds.esm.js';
+import { __require as requireDifferenceInYears } from './differenceInYears.esm.js';
+
+var hasRequiredIntervalToDuration;
+
+function requireIntervalToDuration () {
+	if (hasRequiredIntervalToDuration) return intervalToDuration;
+	hasRequiredIntervalToDuration = 1;
+	intervalToDuration.intervalToDuration = intervalToDuration$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireAdd();
+	var _index3 = /*@__PURE__*/ requireDifferenceInDays();
+	var _index4 = /*@__PURE__*/ requireDifferenceInHours();
+	var _index5 = /*@__PURE__*/ requireDifferenceInMinutes();
+	var _index6 = /*@__PURE__*/ requireDifferenceInMonths();
+	var _index7 = /*@__PURE__*/ requireDifferenceInSeconds();
+	var _index8 = /*@__PURE__*/ requireDifferenceInYears();
+
+	/**
+	 * The {@link intervalToDuration} function options.
+	 */
+
+	/**
+	 * @name intervalToDuration
+	 * @category Common Helpers
+	 * @summary Convert interval to duration
+	 *
+	 * @description
+	 * Convert an interval object to a duration object.
+	 *
+	 * @param interval - The interval to convert to duration
+	 * @param options - The context options
+	 *
+	 * @returns The duration object
+	 *
+	 * @example
+	 * // Get the duration between January 15, 1929 and April 4, 1968.
+	 * intervalToDuration({
+	 *   start: new Date(1929, 0, 15, 12, 0, 0),
+	 *   end: new Date(1968, 3, 4, 19, 5, 0)
+	 * });
+	 * //=> { years: 39, months: 2, days: 20, hours: 7, minutes: 5, seconds: 0 }
+	 */
+	function intervalToDuration$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+	  const duration = {};
+
+	  const years = (0, _index8.differenceInYears)(end, start);
+	  if (years) duration.years = years;
+
+	  const remainingMonths = (0, _index2.add)(start, { years: duration.years });
+	  const months = (0, _index6.differenceInMonths)(end, remainingMonths);
+	  if (months) duration.months = months;
+
+	  const remainingDays = (0, _index2.add)(remainingMonths, {
+	    months: duration.months,
+	  });
+	  const days = (0, _index3.differenceInDays)(end, remainingDays);
+	  if (days) duration.days = days;
+
+	  const remainingHours = (0, _index2.add)(remainingDays, {
+	    days: duration.days,
+	  });
+	  const hours = (0, _index4.differenceInHours)(end, remainingHours);
+	  if (hours) duration.hours = hours;
+
+	  const remainingMinutes = (0, _index2.add)(remainingHours, {
+	    hours: duration.hours,
+	  });
+	  const minutes = (0, _index5.differenceInMinutes)(end, remainingMinutes);
+	  if (minutes) duration.minutes = minutes;
+
+	  const remainingSeconds = (0, _index2.add)(remainingMinutes, {
+	    minutes: duration.minutes,
+	  });
+	  const seconds = (0, _index7.differenceInSeconds)(end, remainingSeconds);
+	  if (seconds) duration.seconds = seconds;
+
+	  return duration;
+	}
+	return intervalToDuration;
+}
+
+export { requireIntervalToDuration as __require };

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

@@ -0,0 +1,131 @@
+import { __exports as intlFormat } from '../../_virtual/intlFormat.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIntlFormat;
+
+function requireIntlFormat () {
+	if (hasRequiredIntlFormat) return intlFormat;
+	hasRequiredIntlFormat = 1;
+	intlFormat.intlFormat = intlFormat$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The locale string (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument).
+	 * @deprecated
+	 *
+	 * [TODO] Remove in v4
+	 */
+
+	/**
+	 * The format options (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat#options)
+	 */
+
+	/**
+	 * The locale options.
+	 */
+
+	/**
+	 * @name intlFormat
+	 * @category Common Helpers
+	 * @summary Format the date with Intl.DateTimeFormat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat).
+	 *
+	 * @description
+	 * Return the formatted date string in the given format.
+	 * The method uses [`Intl.DateTimeFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat) inside.
+	 * formatOptions are the same as [`Intl.DateTimeFormat` options](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat#using_options)
+	 *
+	 * > ⚠️ Please note that before Node version 13.0.0, only the locale data for en-US is available by default.
+	 *
+	 * @param date - The date to format
+	 *
+	 * @returns The formatted date string
+	 *
+	 * @throws `date` must not be Invalid Date
+	 *
+	 * @example
+	 * // Represent 4 October 2019 in middle-endian format:
+	 * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456))
+	 * //=> 10/4/2019
+	 */
+
+	/**
+	 * @param date - The date to format
+	 * @param localeOptions - An object with locale
+	 *
+	 * @returns The formatted date string
+	 *
+	 * @throws `date` must not be Invalid Date
+	 *
+	 * @example
+	 * // Represent 4 October 2019 in Korean.
+	 * // Convert the date with locale's options.
+	 * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456), {
+	 *   locale: 'ko-KR',
+	 * })
+	 * //=> 2019. 10. 4.
+	 */
+
+	/**
+	 * @param date - The date to format
+	 * @param formatOptions - The format options
+	 *
+	 * @returns The formatted date string
+	 *
+	 * @throws `date` must not be Invalid Date
+	 *
+	 * @example
+	 * // Represent 4 October 2019.
+	 * // Convert the date with format's options.
+	 * const result = intlFormat.default(new Date(2019, 9, 4, 12, 30, 13, 456), {
+	 *   year: 'numeric',
+	 *   month: 'numeric',
+	 *   day: 'numeric',
+	 *   hour: 'numeric',
+	 * })
+	 * //=> 10/4/2019, 12 PM
+	 */
+
+	/**
+	 * @param date - The date to format
+	 * @param formatOptions - The format options
+	 * @param localeOptions - An object with locale
+	 *
+	 * @returns The formatted date string
+	 *
+	 * @throws `date` must not be Invalid Date
+	 *
+	 * @example
+	 * // Represent 4 October 2019 in German.
+	 * // Convert the date with format's options and locale's options.
+	 * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456), {
+	 *   weekday: 'long',
+	 *   year: 'numeric',
+	 *   month: 'long',
+	 *   day: 'numeric',
+	 * }, {
+	 *   locale: 'de-DE',
+	 * })
+	 * //=> Freitag, 4. Oktober 2019
+	 */
+
+	function intlFormat$1(date, formatOrLocale, localeOptions) {
+	  let formatOptions;
+
+	  if (isFormatOptions(formatOrLocale)) {
+	    formatOptions = formatOrLocale;
+	  } else {
+	    localeOptions = formatOrLocale;
+	  }
+
+	  return new Intl.DateTimeFormat(localeOptions?.locale, formatOptions).format(
+	    (0, _index.toDate)(date),
+	  );
+	}
+
+	function isFormatOptions(opts) {
+	  return opts !== undefined && !("locale" in opts);
+	}
+	return intlFormat;
+}
+
+export { requireIntlFormat as __require };

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

@@ -0,0 +1,238 @@
+import { __exports as intlFormatDistance } from '../../_virtual/intlFormatDistance.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireConstants } from './constants.esm2.js';
+import { __require as requireDifferenceInCalendarDays } from './differenceInCalendarDays.esm2.js';
+import { __require as requireDifferenceInCalendarMonths } from './differenceInCalendarMonths.esm.js';
+import { __require as requireDifferenceInCalendarQuarters } from './differenceInCalendarQuarters.esm.js';
+import { __require as requireDifferenceInCalendarWeeks } from './differenceInCalendarWeeks.esm.js';
+import { __require as requireDifferenceInCalendarYears } from './differenceInCalendarYears.esm.js';
+import { __require as requireDifferenceInHours } from './differenceInHours.esm.js';
+import { __require as requireDifferenceInMinutes } from './differenceInMinutes.esm.js';
+import { __require as requireDifferenceInSeconds } from './differenceInSeconds.esm.js';
+
+var hasRequiredIntlFormatDistance;
+
+function requireIntlFormatDistance () {
+	if (hasRequiredIntlFormatDistance) return intlFormatDistance;
+	hasRequiredIntlFormatDistance = 1;
+	intlFormatDistance.intlFormatDistance = intlFormatDistance$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireConstants();
+
+	var _index3 = /*@__PURE__*/ requireDifferenceInCalendarDays();
+	var _index4 = /*@__PURE__*/ requireDifferenceInCalendarMonths();
+	var _index5 = /*@__PURE__*/ requireDifferenceInCalendarQuarters();
+	var _index6 = /*@__PURE__*/ requireDifferenceInCalendarWeeks();
+	var _index7 = /*@__PURE__*/ requireDifferenceInCalendarYears();
+	var _index8 = /*@__PURE__*/ requireDifferenceInHours();
+	var _index9 = /*@__PURE__*/ requireDifferenceInMinutes();
+	var _index10 = /*@__PURE__*/ requireDifferenceInSeconds();
+
+	/**
+	 * The {@link intlFormatDistance} function options.
+	 */
+
+	/**
+	 * The unit used to format the distance in {@link intlFormatDistance}.
+	 */
+
+	/**
+	 * @name intlFormatDistance
+	 * @category Common Helpers
+	 * @summary Formats distance between two dates in a human-readable format
+	 * @description
+	 * The function calculates the difference between two dates and formats it as a human-readable string.
+	 *
+	 * The function will pick the most appropriate unit depending on the distance between dates. For example, if the distance is a few hours, it might return `x hours`. If the distance is a few months, it might return `x months`.
+	 *
+	 * You can also specify a unit to force using it regardless of the distance to get a result like `123456 hours`.
+	 *
+	 * See the table below for the unit picking logic:
+	 *
+	 * | Distance between dates | Result (past)  | Result (future) |
+	 * | ---------------------- | -------------- | --------------- |
+	 * | 0 seconds              | now            | now             |
+	 * | 1-59 seconds           | X seconds ago  | in X seconds    |
+	 * | 1-59 minutes           | X minutes ago  | in X minutes    |
+	 * | 1-23 hours             | X hours ago    | in X hours      |
+	 * | 1 day                  | yesterday      | tomorrow        |
+	 * | 2-6 days               | X days ago     | in X days       |
+	 * | 7 days                 | last week      | next week       |
+	 * | 8 days-1 month         | X weeks ago    | in X weeks      |
+	 * | 1 month                | last month     | next month      |
+	 * | 2-3 months             | X months ago   | in X months     |
+	 * | 1 quarter              | last quarter   | next quarter    |
+	 * | 2-3 quarters           | X quarters ago | in X quarters   |
+	 * | 1 year                 | last year      | next year       |
+	 * | 2+ years               | X years ago    | in X years      |
+	 *
+	 * @param laterDate - The date
+	 * @param earlierDate - The date to compare with.
+	 * @param options - An object with options.
+	 * See MDN for details [Locale identification and negotiation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation)
+	 * The narrow one could be similar to the short one for some locales.
+	 *
+	 * @returns The distance in words according to language-sensitive relative time formatting.
+	 *
+	 * @throws `date` must not be Invalid Date
+	 * @throws `baseDate` must not be Invalid Date
+	 * @throws `options.unit` must not be invalid Unit
+	 * @throws `options.locale` must not be invalid locale
+	 * @throws `options.localeMatcher` must not be invalid localeMatcher
+	 * @throws `options.numeric` must not be invalid numeric
+	 * @throws `options.style` must not be invalid style
+	 *
+	 * @example
+	 * // What is the distance between the dates when the fist date is after the second?
+	 * intlFormatDistance(
+	 *   new Date(1986, 3, 4, 11, 30, 0),
+	 *   new Date(1986, 3, 4, 10, 30, 0)
+	 * )
+	 * //=> 'in 1 hour'
+	 *
+	 * // What is the distance between the dates when the fist date is before the second?
+	 * intlFormatDistance(
+	 *   new Date(1986, 3, 4, 10, 30, 0),
+	 *   new Date(1986, 3, 4, 11, 30, 0)
+	 * )
+	 * //=> '1 hour ago'
+	 *
+	 * @example
+	 * // Use the unit option to force the function to output the result in quarters. Without setting it, the example would return "next year"
+	 * intlFormatDistance(
+	 *   new Date(1987, 6, 4, 10, 30, 0),
+	 *   new Date(1986, 3, 4, 10, 30, 0),
+	 *   { unit: 'quarter' }
+	 * )
+	 * //=> 'in 5 quarters'
+	 *
+	 * @example
+	 * // Use the locale option to get the result in Spanish. Without setting it, the example would return "in 1 hour".
+	 * intlFormatDistance(
+	 *   new Date(1986, 3, 4, 11, 30, 0),
+	 *   new Date(1986, 3, 4, 10, 30, 0),
+	 *   { locale: 'es' }
+	 * )
+	 * //=> 'dentro de 1 hora'
+	 *
+	 * @example
+	 * // Use the numeric option to force the function to use numeric values. Without setting it, the example would return "tomorrow".
+	 * intlFormatDistance(
+	 *   new Date(1986, 3, 5, 11, 30, 0),
+	 *   new Date(1986, 3, 4, 11, 30, 0),
+	 *   { numeric: 'always' }
+	 * )
+	 * //=> 'in 1 day'
+	 *
+	 * @example
+	 * // Use the style option to force the function to use short values. Without setting it, the example would return "in 2 years".
+	 * intlFormatDistance(
+	 *   new Date(1988, 3, 4, 11, 30, 0),
+	 *   new Date(1986, 3, 4, 11, 30, 0),
+	 *   { style: 'short' }
+	 * )
+	 * //=> 'in 2 yr'
+	 */
+	function intlFormatDistance$1(laterDate, earlierDate, options) {
+	  let value = 0;
+	  let unit;
+
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  if (!options?.unit) {
+	    // Get the unit based on diffInSeconds calculations if no unit is specified
+	    const diffInSeconds = (0, _index10.differenceInSeconds)(
+	      laterDate_,
+	      earlierDate_,
+	    ); // The smallest unit
+
+	    if (Math.abs(diffInSeconds) < _index2.secondsInMinute) {
+	      value = (0, _index10.differenceInSeconds)(laterDate_, earlierDate_);
+	      unit = "second";
+	    } else if (Math.abs(diffInSeconds) < _index2.secondsInHour) {
+	      value = (0, _index9.differenceInMinutes)(laterDate_, earlierDate_);
+	      unit = "minute";
+	    } else if (
+	      Math.abs(diffInSeconds) < _index2.secondsInDay &&
+	      Math.abs(
+	        (0, _index3.differenceInCalendarDays)(laterDate_, earlierDate_),
+	      ) < 1
+	    ) {
+	      value = (0, _index8.differenceInHours)(laterDate_, earlierDate_);
+	      unit = "hour";
+	    } else if (
+	      Math.abs(diffInSeconds) < _index2.secondsInWeek &&
+	      (value = (0, _index3.differenceInCalendarDays)(
+	        laterDate_,
+	        earlierDate_,
+	      )) &&
+	      Math.abs(value) < 7
+	    ) {
+	      unit = "day";
+	    } else if (Math.abs(diffInSeconds) < _index2.secondsInMonth) {
+	      value = (0, _index6.differenceInCalendarWeeks)(laterDate_, earlierDate_);
+	      unit = "week";
+	    } else if (Math.abs(diffInSeconds) < _index2.secondsInQuarter) {
+	      value = (0, _index4.differenceInCalendarMonths)(laterDate_, earlierDate_);
+	      unit = "month";
+	    } else if (Math.abs(diffInSeconds) < _index2.secondsInYear) {
+	      if (
+	        (0, _index5.differenceInCalendarQuarters)(laterDate_, earlierDate_) < 4
+	      ) {
+	        // To filter out cases that are less than a year but match 4 quarters
+	        value = (0, _index5.differenceInCalendarQuarters)(
+	          laterDate_,
+	          earlierDate_,
+	        );
+	        unit = "quarter";
+	      } else {
+	        value = (0, _index7.differenceInCalendarYears)(
+	          laterDate_,
+	          earlierDate_,
+	        );
+	        unit = "year";
+	      }
+	    } else {
+	      value = (0, _index7.differenceInCalendarYears)(laterDate_, earlierDate_);
+	      unit = "year";
+	    }
+	  } else {
+	    // Get the value if unit is specified
+	    unit = options?.unit;
+	    if (unit === "second") {
+	      value = (0, _index10.differenceInSeconds)(laterDate_, earlierDate_);
+	    } else if (unit === "minute") {
+	      value = (0, _index9.differenceInMinutes)(laterDate_, earlierDate_);
+	    } else if (unit === "hour") {
+	      value = (0, _index8.differenceInHours)(laterDate_, earlierDate_);
+	    } else if (unit === "day") {
+	      value = (0, _index3.differenceInCalendarDays)(laterDate_, earlierDate_);
+	    } else if (unit === "week") {
+	      value = (0, _index6.differenceInCalendarWeeks)(laterDate_, earlierDate_);
+	    } else if (unit === "month") {
+	      value = (0, _index4.differenceInCalendarMonths)(laterDate_, earlierDate_);
+	    } else if (unit === "quarter") {
+	      value = (0, _index5.differenceInCalendarQuarters)(
+	        laterDate_,
+	        earlierDate_,
+	      );
+	    } else if (unit === "year") {
+	      value = (0, _index7.differenceInCalendarYears)(laterDate_, earlierDate_);
+	    }
+	  }
+
+	  const rtf = new Intl.RelativeTimeFormat(options?.locale, {
+	    numeric: "auto",
+	    ...options,
+	  });
+
+	  return rtf.format(value, unit);
+	}
+	return intlFormatDistance;
+}
+
+export { requireIntlFormatDistance as __require };

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

@@ -0,0 +1,36 @@
+import { __exports as isAfter } from '../../_virtual/isAfter.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsAfter;
+
+function requireIsAfter () {
+	if (hasRequiredIsAfter) return isAfter;
+	hasRequiredIsAfter = 1;
+	isAfter.isAfter = isAfter$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name isAfter
+	 * @category Common Helpers
+	 * @summary Is the first date after the second one?
+	 *
+	 * @description
+	 * Is the first date after the second one?
+	 *
+	 * @param date - The date that should be after the other one to return true
+	 * @param dateToCompare - The date to compare with
+	 *
+	 * @returns The first date is after the second date
+	 *
+	 * @example
+	 * // Is 10 July 1989 after 11 February 1987?
+	 * const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
+	 * //=> true
+	 */
+	function isAfter$1(date, dateToCompare) {
+	  return +(0, _index.toDate)(date) > +(0, _index.toDate)(dateToCompare);
+	}
+	return isAfter;
+}
+
+export { requireIsAfter as __require };

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

@@ -0,0 +1,36 @@
+import { __exports as isBefore } from '../../_virtual/isBefore.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsBefore;
+
+function requireIsBefore () {
+	if (hasRequiredIsBefore) return isBefore;
+	hasRequiredIsBefore = 1;
+	isBefore.isBefore = isBefore$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name isBefore
+	 * @category Common Helpers
+	 * @summary Is the first date before the second one?
+	 *
+	 * @description
+	 * Is the first date before the second one?
+	 *
+	 * @param date - The date that should be before the other one to return true
+	 * @param dateToCompare - The date to compare with
+	 *
+	 * @returns The first date is before the second date
+	 *
+	 * @example
+	 * // Is 10 July 1989 before 11 February 1987?
+	 * const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
+	 * //=> false
+	 */
+	function isBefore$1(date, dateToCompare) {
+	  return +(0, _index.toDate)(date) < +(0, _index.toDate)(dateToCompare);
+	}
+	return isBefore;
+}
+
+export { requireIsBefore as __require };

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

@@ -0,0 +1,41 @@
+/**
+ * @name isDate
+ * @category Common Helpers
+ * @summary Is the given value a date?
+ *
+ * @description
+ * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+ *
+ * @param value - The value to check
+ *
+ * @returns True if the given value is a date
+ *
+ * @example
+ * // For a valid date:
+ * const result = isDate(new Date())
+ * //=> true
+ *
+ * @example
+ * // For an invalid date:
+ * const result = isDate(new Date(NaN))
+ * //=> true
+ *
+ * @example
+ * // For some value:
+ * const result = isDate('2014-02-31')
+ * //=> false
+ *
+ * @example
+ * // For an object:
+ * const result = isDate({})
+ * //=> false
+ */
+function isDate(value) {
+  return (
+    value instanceof Date ||
+    (typeof value === "object" &&
+      Object.prototype.toString.call(value) === "[object Date]")
+  );
+}
+
+export { isDate as default, isDate };

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

@@ -0,0 +1,50 @@
+import { __exports as isDate } from '../../_virtual/isDate.esm.js';
+
+var hasRequiredIsDate;
+
+function requireIsDate () {
+	if (hasRequiredIsDate) return isDate;
+	hasRequiredIsDate = 1;
+	isDate.isDate = isDate$1; /**
+	 * @name isDate
+	 * @category Common Helpers
+	 * @summary Is the given value a date?
+	 *
+	 * @description
+	 * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+	 *
+	 * @param value - The value to check
+	 *
+	 * @returns True if the given value is a date
+	 *
+	 * @example
+	 * // For a valid date:
+	 * const result = isDate(new Date())
+	 * //=> true
+	 *
+	 * @example
+	 * // For an invalid date:
+	 * const result = isDate(new Date(NaN))
+	 * //=> true
+	 *
+	 * @example
+	 * // For some value:
+	 * const result = isDate('2014-02-31')
+	 * //=> false
+	 *
+	 * @example
+	 * // For an object:
+	 * const result = isDate({})
+	 * //=> false
+	 */
+	function isDate$1(value) {
+	  return (
+	    value instanceof Date ||
+	    (typeof value === "object" &&
+	      Object.prototype.toString.call(value) === "[object Date]")
+	  );
+	}
+	return isDate;
+}
+
+export { requireIsDate as __require };