tp-react-elements-dev 1.14.2 → 1.14.4

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

@@ -0,0 +1,36 @@
+import { __exports as isPast } from '../../_virtual/isPast.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsPast;
+
+function requireIsPast () {
+	if (hasRequiredIsPast) return isPast;
+	hasRequiredIsPast = 1;
+	isPast.isPast = isPast$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name isPast
+	 * @category Common Helpers
+	 * @summary Is the given date in the past?
+	 * @pure false
+	 *
+	 * @description
+	 * Is the given date in the past?
+	 *
+	 * @param date - The date to check
+	 *
+	 * @returns The date is in the past
+	 *
+	 * @example
+	 * // If today is 6 October 2014, is 2 July 2014 in the past?
+	 * const result = isPast(new Date(2014, 6, 2))
+	 * //=> true
+	 */
+	function isPast$1(date) {
+	  return +(0, _index.toDate)(date) < Date.now();
+	}
+	return isPast;
+}
+
+export { requireIsPast as __require };

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

@@ -0,0 +1,60 @@
+import { __exports as isSameDay } from '../../_virtual/isSameDay.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireStartOfDay } from './startOfDay.esm2.js';
+
+var hasRequiredIsSameDay;
+
+function requireIsSameDay () {
+	if (hasRequiredIsSameDay) return isSameDay;
+	hasRequiredIsSameDay = 1;
+	isSameDay.isSameDay = isSameDay$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireStartOfDay();
+
+	/**
+	 * The {@link isSameDay} function options.
+	 */
+
+	/**
+	 * @name isSameDay
+	 * @category Day Helpers
+	 * @summary Are the given dates in the same day (and year and month)?
+	 *
+	 * @description
+	 * Are the given dates in the same day (and year and month)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same day (and year and month)
+	 *
+	 * @example
+	 * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
+	 * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 4 September and 4 October in the same day?
+	 * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
+	 * //=> false
+	 *
+	 * @example
+	 * // Are 4 September, 2014 and 4 September, 2015 in the same day?
+	 * const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))
+	 * //=> false
+	 */
+	function isSameDay$1(laterDate, earlierDate, options) {
+	  const [dateLeft_, dateRight_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    +(0, _index2.startOfDay)(dateLeft_) === +(0, _index2.startOfDay)(dateRight_)
+	  );
+	}
+	return isSameDay;
+}
+
+export { requireIsSameDay as __require };

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

@@ -0,0 +1,56 @@
+import { __exports as isSameHour } from '../../_virtual/isSameHour.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireStartOfHour } from './startOfHour.esm.js';
+
+var hasRequiredIsSameHour;
+
+function requireIsSameHour () {
+	if (hasRequiredIsSameHour) return isSameHour;
+	hasRequiredIsSameHour = 1;
+	isSameHour.isSameHour = isSameHour$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireStartOfHour();
+
+	/**
+	 * The {@link isSameHour} function options.
+	 */
+
+	/**
+	 * @name isSameHour
+	 * @category Hour Helpers
+	 * @summary Are the given dates in the same hour (and same day)?
+	 *
+	 * @description
+	 * Are the given dates in the same hour (and same day)?
+	 *
+	 * @param dateLeft - The first date to check
+	 * @param dateRight - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same hour (and same day)
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:00:00 and 4 September 06:30:00 in the same hour?
+	 * const result = isSameHour(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 6, 30))
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:00:00 and 5 September 06:00:00 in the same hour?
+	 * const result = isSameHour(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 5, 6, 0))
+	 * //=> false
+	 */
+	function isSameHour$1(dateLeft, dateRight, options) {
+	  const [dateLeft_, dateRight_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    dateLeft,
+	    dateRight,
+	  );
+	  return (
+	    +(0, _index2.startOfHour)(dateLeft_) ===
+	    +(0, _index2.startOfHour)(dateRight_)
+	  );
+	}
+	return isSameHour;
+}
+
+export { requireIsSameHour as __require };

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

@@ -0,0 +1,51 @@
+import { __exports as isSameISOWeek } from '../../_virtual/isSameISOWeek.esm.js';
+import { __require as requireIsSameWeek } from './isSameWeek.esm.js';
+
+var hasRequiredIsSameISOWeek;
+
+function requireIsSameISOWeek () {
+	if (hasRequiredIsSameISOWeek) return isSameISOWeek;
+	hasRequiredIsSameISOWeek = 1;
+	isSameISOWeek.isSameISOWeek = isSameISOWeek$1;
+	var _index = /*@__PURE__*/ requireIsSameWeek();
+
+	/**
+	 * The {@link isSameISOWeek} function options.
+	 */
+
+	/**
+	 * @name isSameISOWeek
+	 * @category ISO Week Helpers
+	 * @summary Are the given dates in the same ISO week (and year)?
+	 *
+	 * @description
+	 * Are the given dates in the same ISO week (and year)?
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same ISO week (and year)
+	 *
+	 * @example
+	 * // Are 1 September 2014 and 7 September 2014 in the same ISO week?
+	 * const result = isSameISOWeek(new Date(2014, 8, 1), new Date(2014, 8, 7))
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 1 September 2014 and 1 September 2015 in the same ISO week?
+	 * const result = isSameISOWeek(new Date(2014, 8, 1), new Date(2015, 8, 1))
+	 * //=> false
+	 */
+	function isSameISOWeek$1(laterDate, earlierDate, options) {
+	  return (0, _index.isSameWeek)(laterDate, earlierDate, {
+	    ...options,
+	    weekStartsOn: 1,
+	  });
+	}
+	return isSameISOWeek;
+}
+
+export { requireIsSameISOWeek as __require };

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

@@ -0,0 +1,54 @@
+import { __exports as isSameISOWeekYear } from '../../_virtual/isSameISOWeekYear.esm.js';
+import { __require as requireStartOfISOWeekYear } from './startOfISOWeekYear.esm2.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+
+var hasRequiredIsSameISOWeekYear;
+
+function requireIsSameISOWeekYear () {
+	if (hasRequiredIsSameISOWeekYear) return isSameISOWeekYear;
+	hasRequiredIsSameISOWeekYear = 1;
+	isSameISOWeekYear.isSameISOWeekYear = isSameISOWeekYear$1;
+	var _index = /*@__PURE__*/ requireStartOfISOWeekYear();
+
+	var _index2 = /*@__PURE__*/ requireNormalizeDates();
+
+	/**
+	 * The {@link isSameISOWeekYear} function options.
+	 */
+
+	/**
+	 * @name isSameISOWeekYear
+	 * @category ISO Week-Numbering Year Helpers
+	 * @summary Are the given dates in the same ISO week-numbering year?
+	 *
+	 * @description
+	 * Are the given dates in the same ISO week-numbering year?
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same ISO week-numbering year
+	 *
+	 * @example
+	 * // Are 29 December 2003 and 2 January 2005 in the same ISO week-numbering year?
+	 * const result = isSameISOWeekYear(new Date(2003, 11, 29), new Date(2005, 0, 2))
+	 * //=> true
+	 */
+	function isSameISOWeekYear$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    +(0, _index.startOfISOWeekYear)(laterDate_) ===
+	    +(0, _index.startOfISOWeekYear)(earlierDate_)
+	  );
+	}
+	return isSameISOWeekYear;
+}
+
+export { requireIsSameISOWeekYear as __require };

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

@@ -0,0 +1,50 @@
+import { __exports as isSameMinute } from '../../_virtual/isSameMinute.esm.js';
+import { __require as requireStartOfMinute } from './startOfMinute.esm.js';
+
+var hasRequiredIsSameMinute;
+
+function requireIsSameMinute () {
+	if (hasRequiredIsSameMinute) return isSameMinute;
+	hasRequiredIsSameMinute = 1;
+	isSameMinute.isSameMinute = isSameMinute$1;
+	var _index = /*@__PURE__*/ requireStartOfMinute();
+
+	/**
+	 * @name isSameMinute
+	 * @category Minute Helpers
+	 * @summary Are the given dates in the same minute (and hour and day)?
+	 *
+	 * @description
+	 * Are the given dates in the same minute (and hour and day)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 *
+	 * @returns The dates are in the same minute (and hour and day)
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:30:00 and 4 September 2014 06:30:15 in the same minute?
+	 * const result = isSameMinute(
+	 *   new Date(2014, 8, 4, 6, 30),
+	 *   new Date(2014, 8, 4, 6, 30, 15)
+	 * )
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:30:00 and 5 September 2014 06:30:00 in the same minute?
+	 * const result = isSameMinute(
+	 *   new Date(2014, 8, 4, 6, 30),
+	 *   new Date(2014, 8, 5, 6, 30)
+	 * )
+	 * //=> false
+	 */
+	function isSameMinute$1(laterDate, earlierDate) {
+	  return (
+	    +(0, _index.startOfMinute)(laterDate) ===
+	    +(0, _index.startOfMinute)(earlierDate)
+	  );
+	}
+	return isSameMinute;
+}
+
+export { requireIsSameMinute as __require };

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

@@ -0,0 +1,54 @@
+import { __exports as isSameMonth } from '../../_virtual/isSameMonth.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+
+var hasRequiredIsSameMonth;
+
+function requireIsSameMonth () {
+	if (hasRequiredIsSameMonth) return isSameMonth;
+	hasRequiredIsSameMonth = 1;
+	isSameMonth.isSameMonth = isSameMonth$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	/**
+	 * The {@link isSameMonth} function options.
+	 */
+
+	/**
+	 * @name isSameMonth
+	 * @category Month Helpers
+	 * @summary Are the given dates in the same month (and year)?
+	 *
+	 * @description
+	 * Are the given dates in the same month (and year)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same month (and year)
+	 *
+	 * @example
+	 * // Are 2 September 2014 and 25 September 2014 in the same month?
+	 * const result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25))
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 2 September 2014 and 25 September 2015 in the same month?
+	 * const result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))
+	 * //=> false
+	 */
+	function isSameMonth$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    laterDate_.getFullYear() === earlierDate_.getFullYear() &&
+	    laterDate_.getMonth() === earlierDate_.getMonth()
+	  );
+	}
+	return isSameMonth;
+}
+
+export { requireIsSameMonth as __require };

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

@@ -0,0 +1,56 @@
+import { __exports as isSameQuarter } from '../../_virtual/isSameQuarter.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireStartOfQuarter } from './startOfQuarter.esm.js';
+
+var hasRequiredIsSameQuarter;
+
+function requireIsSameQuarter () {
+	if (hasRequiredIsSameQuarter) return isSameQuarter;
+	hasRequiredIsSameQuarter = 1;
+	isSameQuarter.isSameQuarter = isSameQuarter$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireStartOfQuarter();
+
+	/**
+	 * The {@link isSameQuarter} function options.
+	 */
+
+	/**
+	 * @name isSameQuarter
+	 * @category Quarter Helpers
+	 * @summary Are the given dates in the same quarter (and year)?
+	 *
+	 * @description
+	 * Are the given dates in the same quarter (and year)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same quarter (and year)
+	 *
+	 * @example
+	 * // Are 1 January 2014 and 8 March 2014 in the same quarter?
+	 * const result = isSameQuarter(new Date(2014, 0, 1), new Date(2014, 2, 8))
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 1 January 2014 and 1 January 2015 in the same quarter?
+	 * const result = isSameQuarter(new Date(2014, 0, 1), new Date(2015, 0, 1))
+	 * //=> false
+	 */
+	function isSameQuarter$1(laterDate, earlierDate, options) {
+	  const [dateLeft_, dateRight_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    +(0, _index2.startOfQuarter)(dateLeft_) ===
+	    +(0, _index2.startOfQuarter)(dateRight_)
+	  );
+	}
+	return isSameQuarter;
+}
+
+export { requireIsSameQuarter as __require };

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

@@ -0,0 +1,58 @@
+import { __exports as isSameSecond } from '../../_virtual/isSameSecond.esm.js';
+import { __require as requireStartOfSecond } from './startOfSecond.esm.js';
+
+var hasRequiredIsSameSecond;
+
+function requireIsSameSecond () {
+	if (hasRequiredIsSameSecond) return isSameSecond;
+	hasRequiredIsSameSecond = 1;
+	isSameSecond.isSameSecond = isSameSecond$1;
+	var _index = /*@__PURE__*/ requireStartOfSecond();
+
+	/**
+	 * @name isSameSecond
+	 * @category Second Helpers
+	 * @summary Are the given dates in the same second (and hour and day)?
+	 *
+	 * @description
+	 * Are the given dates in the same second (and hour and day)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 *
+	 * @returns The dates are in the same second (and hour and day)
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:30:15.000 and 4 September 2014 06:30.15.500 in the same second?
+	 * const result = isSameSecond(
+	 *   new Date(2014, 8, 4, 6, 30, 15),
+	 *   new Date(2014, 8, 4, 6, 30, 15, 500)
+	 * )
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:00:15.000 and 4 September 2014 06:01.15.000 in the same second?
+	 * const result = isSameSecond(
+	 *   new Date(2014, 8, 4, 6, 0, 15),
+	 *   new Date(2014, 8, 4, 6, 1, 15)
+	 * )
+	 * //=> false
+	 *
+	 * @example
+	 * // Are 4 September 2014 06:00:15.000 and 5 September 2014 06:00.15.000 in the same second?
+	 * const result = isSameSecond(
+	 *   new Date(2014, 8, 4, 6, 0, 15),
+	 *   new Date(2014, 8, 5, 6, 0, 15)
+	 * )
+	 * //=> false
+	 */
+	function isSameSecond$1(laterDate, earlierDate) {
+	  return (
+	    +(0, _index.startOfSecond)(laterDate) ===
+	    +(0, _index.startOfSecond)(earlierDate)
+	  );
+	}
+	return isSameSecond;
+}
+
+export { requireIsSameSecond as __require };

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

@@ -0,0 +1,64 @@
+import { __exports as isSameWeek } from '../../_virtual/isSameWeek.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireStartOfWeek } from './startOfWeek.esm2.js';
+
+var hasRequiredIsSameWeek;
+
+function requireIsSameWeek () {
+	if (hasRequiredIsSameWeek) return isSameWeek;
+	hasRequiredIsSameWeek = 1;
+	isSameWeek.isSameWeek = isSameWeek$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireStartOfWeek();
+
+	/**
+	 * The {@link isSameWeek} function options.
+	 */
+
+	/**
+	 * @name isSameWeek
+	 * @category Week Helpers
+	 * @summary Are the given dates in the same week (and month and year)?
+	 *
+	 * @description
+	 * Are the given dates in the same week (and month and year)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same week (and month and year)
+	 *
+	 * @example
+	 * // Are 31 August 2014 and 4 September 2014 in the same week?
+	 * const result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4))
+	 * //=> true
+	 *
+	 * @example
+	 * // If week starts with Monday,
+	 * // are 31 August 2014 and 4 September 2014 in the same week?
+	 * const result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4), {
+	 *   weekStartsOn: 1
+	 * })
+	 * //=> false
+	 *
+	 * @example
+	 * // Are 1 January 2014 and 1 January 2015 in the same week?
+	 * const result = isSameWeek(new Date(2014, 0, 1), new Date(2015, 0, 1))
+	 * //=> false
+	 */
+	function isSameWeek$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    +(0, _index2.startOfWeek)(laterDate_, options) ===
+	    +(0, _index2.startOfWeek)(earlierDate_, options)
+	  );
+	}
+	return isSameWeek;
+}
+
+export { requireIsSameWeek as __require };

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

@@ -0,0 +1,46 @@
+import { __exports as isSameYear } from '../../_virtual/isSameYear.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+
+var hasRequiredIsSameYear;
+
+function requireIsSameYear () {
+	if (hasRequiredIsSameYear) return isSameYear;
+	hasRequiredIsSameYear = 1;
+	isSameYear.isSameYear = isSameYear$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	/**
+	 * The {@link isSameYear} function options.
+	 */
+
+	/**
+	 * @name isSameYear
+	 * @category Year Helpers
+	 * @summary Are the given dates in the same year?
+	 *
+	 * @description
+	 * Are the given dates in the same year?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same year
+	 *
+	 * @example
+	 * // Are 2 September 2014 and 25 September 2014 in the same year?
+	 * const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))
+	 * //=> true
+	 */
+	function isSameYear$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return laterDate_.getFullYear() === earlierDate_.getFullYear();
+	}
+	return isSameYear;
+}
+
+export { requireIsSameYear as __require };

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

@@ -0,0 +1,40 @@
+import { __exports as isSaturday } from '../../_virtual/isSaturday.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsSaturday;
+
+function requireIsSaturday () {
+	if (hasRequiredIsSaturday) return isSaturday;
+	hasRequiredIsSaturday = 1;
+	isSaturday.isSaturday = isSaturday$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link isSaturday} function options.
+	 */
+
+	/**
+	 * @name isSaturday
+	 * @category Weekday Helpers
+	 * @summary Is the given date Saturday?
+	 *
+	 * @description
+	 * Is the given date Saturday?
+	 *
+	 * @param date - The date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The date is Saturday
+	 *
+	 * @example
+	 * // Is 27 September 2014 Saturday?
+	 * const result = isSaturday(new Date(2014, 8, 27))
+	 * //=> true
+	 */
+	function isSaturday$1(date, options) {
+	  return (0, _index.toDate)(date, options?.in).getDay() === 6;
+	}
+	return isSaturday;
+}
+
+export { requireIsSaturday as __require };

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

@@ -0,0 +1,40 @@
+import { __exports as isSunday } from '../../_virtual/isSunday.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsSunday;
+
+function requireIsSunday () {
+	if (hasRequiredIsSunday) return isSunday;
+	hasRequiredIsSunday = 1;
+	isSunday.isSunday = isSunday$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link isSunday} function options.
+	 */
+
+	/**
+	 * @name isSunday
+	 * @category Weekday Helpers
+	 * @summary Is the given date Sunday?
+	 *
+	 * @description
+	 * Is the given date Sunday?
+	 *
+	 * @param date - The date to check
+	 * @param options - The options object
+	 *
+	 * @returns The date is Sunday
+	 *
+	 * @example
+	 * // Is 21 September 2014 Sunday?
+	 * const result = isSunday(new Date(2014, 8, 21))
+	 * //=> true
+	 */
+	function isSunday$1(date, options) {
+	  return (0, _index.toDate)(date, options?.in).getDay() === 0;
+	}
+	return isSunday;
+}
+
+export { requireIsSunday as __require };