tp-react-elements-dev 1.14.3 → 1.14.4

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

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

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

@@ -0,0 +1,41 @@
+import { __exports as isWeekend } from '../../_virtual/isWeekend.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsWeekend;
+
+function requireIsWeekend () {
+	if (hasRequiredIsWeekend) return isWeekend;
+	hasRequiredIsWeekend = 1;
+	isWeekend.isWeekend = isWeekend$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link isWeekend} function options.
+	 */
+
+	/**
+	 * @name isWeekend
+	 * @category Weekday Helpers
+	 * @summary Does the given date fall on a weekend?
+	 *
+	 * @description
+	 * Does the given date fall on a weekend? A weekend is either Saturday (`6`) or Sunday (`0`).
+	 *
+	 * @param date - The date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The date falls on a weekend
+	 *
+	 * @example
+	 * // Does 5 October 2014 fall on a weekend?
+	 * const result = isWeekend(new Date(2014, 9, 5))
+	 * //=> true
+	 */
+	function isWeekend$1(date, options) {
+	  const day = (0, _index.toDate)(date, options?.in).getDay();
+	  return day === 0 || day === 6;
+	}
+	return isWeekend;
+}
+
+export { requireIsWeekend as __require };

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

@@ -0,0 +1,68 @@
+import { __exports as isWithinInterval } from '../../_virtual/isWithinInterval.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredIsWithinInterval;
+
+function requireIsWithinInterval () {
+	if (hasRequiredIsWithinInterval) return isWithinInterval;
+	hasRequiredIsWithinInterval = 1;
+	isWithinInterval.isWithinInterval = isWithinInterval$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link isWithinInterval} function options.
+	 */
+
+	/**
+	 * @name isWithinInterval
+	 * @category Interval Helpers
+	 * @summary Is the given date within the interval?
+	 *
+	 * @description
+	 * Is the given date within the interval? (Including start and end.)
+	 *
+	 * @param date - The date to check
+	 * @param interval - The interval to check
+	 * @param options - An object with options
+	 *
+	 * @returns The date is within the interval
+	 *
+	 * @example
+	 * // For the date within the interval:
+	 * isWithinInterval(new Date(2014, 0, 3), {
+	 *   start: new Date(2014, 0, 1),
+	 *   end: new Date(2014, 0, 7)
+	 * })
+	 * // => true
+	 *
+	 * @example
+	 * // For the date outside of the interval:
+	 * isWithinInterval(new Date(2014, 0, 10), {
+	 *   start: new Date(2014, 0, 1),
+	 *   end: new Date(2014, 0, 7)
+	 * })
+	 * // => false
+	 *
+	 * @example
+	 * // For date equal to the interval start:
+	 * isWithinInterval(date, { start, end: date })
+	 * // => true
+	 *
+	 * @example
+	 * // For date equal to the interval end:
+	 * isWithinInterval(date, { start: date, end })
+	 * // => true
+	 */
+	function isWithinInterval$1(date, interval, options) {
+	  const time = +(0, _index.toDate)(date, options?.in);
+	  const [startTime, endTime] = [
+	    +(0, _index.toDate)(interval.start, options?.in),
+	    +(0, _index.toDate)(interval.end, options?.in),
+	  ].sort((a, b) => a - b);
+
+	  return time >= startTime && time <= endTime;
+	}
+	return isWithinInterval;
+}
+
+export { requireIsWithinInterval as __require };

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

@@ -0,0 +1,50 @@
+import { __exports as isYesterday } from '../../_virtual/isYesterday.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+import { __require as requireConstructNow } from './constructNow.esm.js';
+import { __require as requireIsSameDay } from './isSameDay.esm.js';
+import { __require as requireSubDays } from './subDays.esm.js';
+
+var hasRequiredIsYesterday;
+
+function requireIsYesterday () {
+	if (hasRequiredIsYesterday) return isYesterday;
+	hasRequiredIsYesterday = 1;
+	isYesterday.isYesterday = isYesterday$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireConstructNow();
+	var _index3 = /*@__PURE__*/ requireIsSameDay();
+	var _index4 = /*@__PURE__*/ requireSubDays();
+
+	/**
+	 * The {@link isYesterday} function options.
+	 */
+
+	/**
+	 * @name isYesterday
+	 * @category Day Helpers
+	 * @summary Is the given date yesterday?
+	 * @pure false
+	 *
+	 * @description
+	 * Is the given date yesterday?
+	 *
+	 * @param date - The date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The date is yesterday
+	 *
+	 * @example
+	 * // If today is 6 October 2014, is 5 October 14:00:00 yesterday?
+	 * const result = isYesterday(new Date(2014, 9, 5, 14, 0))
+	 * //=> true
+	 */
+	function isYesterday$1(date, options) {
+	  return (0, _index3.isSameDay)(
+	    (0, _index.constructFrom)(options?.in || date, date),
+	    (0, _index4.subDays)((0, _index2.constructNow)(options?.in || date), 1),
+	  );
+	}
+	return isYesterday;
+}
+
+export { requireIsYesterday as __require };

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

@@ -0,0 +1,48 @@
+import { __exports as lastDayOfDecade } from '../../_virtual/lastDayOfDecade.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredLastDayOfDecade;
+
+function requireLastDayOfDecade () {
+	if (hasRequiredLastDayOfDecade) return lastDayOfDecade;
+	hasRequiredLastDayOfDecade = 1;
+	lastDayOfDecade.lastDayOfDecade = lastDayOfDecade$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link lastDayOfDecade} function options.
+	 */
+
+	/**
+	 * @name lastDayOfDecade
+	 * @category Decade Helpers
+	 * @summary Return the last day of a decade for the given date.
+	 *
+	 * @description
+	 * Return the last day of a decade for the given date.
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type; inferred from arguments or specified by context.
+	 *
+	 * @param date - The original date
+	 * @param options - The options
+	 *
+	 * @returns The last day of a decade
+	 *
+	 * @example
+	 * // The last day of a decade for 21 December 2012 21:12:00:
+	 * const result = lastDayOfDecade(new Date(2012, 11, 21, 21, 12, 00))
+	 * //=> Wed Dec 31 2019 00:00:00
+	 */
+	function lastDayOfDecade$1(date, options) {
+	  const _date = (0, _index.toDate)(date, options?.in);
+	  const year = _date.getFullYear();
+	  const decade = 9 + Math.floor(year / 10) * 10;
+	  _date.setFullYear(decade + 1, 0, 0);
+	  _date.setHours(0, 0, 0, 0);
+	  return (0, _index.toDate)(_date, options?.in);
+	}
+	return lastDayOfDecade;
+}
+
+export { requireLastDayOfDecade as __require };

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

@@ -0,0 +1,46 @@
+import { __exports as lastDayOfISOWeek } from '../../_virtual/lastDayOfISOWeek.esm.js';
+import { __require as requireLastDayOfWeek } from './lastDayOfWeek.esm.js';
+
+var hasRequiredLastDayOfISOWeek;
+
+function requireLastDayOfISOWeek () {
+	if (hasRequiredLastDayOfISOWeek) return lastDayOfISOWeek;
+	hasRequiredLastDayOfISOWeek = 1;
+	lastDayOfISOWeek.lastDayOfISOWeek = lastDayOfISOWeek$1;
+	var _index = /*@__PURE__*/ requireLastDayOfWeek();
+
+	/**
+	 * The {@link lastDayOfISOWeek} function options.
+	 */
+
+	/**
+	 * @name lastDayOfISOWeek
+	 * @category ISO Week Helpers
+	 * @summary Return the last day of an ISO week for the given date.
+	 *
+	 * @description
+	 * Return the last day of an ISO week for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_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 last day of an ISO week
+	 *
+	 * @example
+	 * // The last day of an ISO week for 2 September 2014 11:55:00:
+	 * const result = lastDayOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Sun Sep 07 2014 00:00:00
+	 */
+	function lastDayOfISOWeek$1(date, options) {
+	  return (0, _index.lastDayOfWeek)(date, { ...options, weekStartsOn: 1 });
+	}
+	return lastDayOfISOWeek;
+}
+
+export { requireLastDayOfISOWeek as __require };

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

@@ -0,0 +1,58 @@
+import { __exports as lastDayOfISOWeekYear } from '../../_virtual/lastDayOfISOWeekYear.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+import { __require as requireGetISOWeekYear } from './getISOWeekYear.esm2.js';
+import { __require as requireStartOfISOWeek } from './startOfISOWeek.esm2.js';
+
+var hasRequiredLastDayOfISOWeekYear;
+
+function requireLastDayOfISOWeekYear () {
+	if (hasRequiredLastDayOfISOWeekYear) return lastDayOfISOWeekYear;
+	hasRequiredLastDayOfISOWeekYear = 1;
+	lastDayOfISOWeekYear.lastDayOfISOWeekYear = lastDayOfISOWeekYear$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireGetISOWeekYear();
+	var _index3 = /*@__PURE__*/ requireStartOfISOWeek();
+
+	/**
+	 * The {@link lastDayOfISOWeekYear} function options.
+	 */
+
+	/**
+	 * @name lastDayOfISOWeekYear
+	 * @category ISO Week-Numbering Year Helpers
+	 * @summary Return the last day of an ISO week-numbering year for the given date.
+	 *
+	 * @description
+	 * Return the last day of an ISO week-numbering year,
+	 * which always starts 3 days before the year's first Thursday.
+	 * The result will be in the local timezone.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_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 an ISO week-numbering year
+	 *
+	 * @example
+	 * // The last day of an ISO week-numbering year for 2 July 2005:
+	 * const result = lastDayOfISOWeekYear(new Date(2005, 6, 2))
+	 * //=> Sun Jan 01 2006 00:00:00
+	 */
+	function lastDayOfISOWeekYear$1(date, options) {
+	  const year = (0, _index2.getISOWeekYear)(date, options);
+	  const fourthOfJanuary = (0, _index.constructFrom)(options?.in || date, 0);
+	  fourthOfJanuary.setFullYear(year + 1, 0, 4);
+	  fourthOfJanuary.setHours(0, 0, 0, 0);
+
+	  const date_ = (0, _index3.startOfISOWeek)(fourthOfJanuary, options);
+	  date_.setDate(date_.getDate() - 1);
+	  return date_;
+	}
+	return lastDayOfISOWeekYear;
+}
+
+export { requireLastDayOfISOWeekYear as __require };

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

@@ -0,0 +1,48 @@
+import { __exports as lastDayOfMonth } from '../../_virtual/lastDayOfMonth.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredLastDayOfMonth;
+
+function requireLastDayOfMonth () {
+	if (hasRequiredLastDayOfMonth) return lastDayOfMonth;
+	hasRequiredLastDayOfMonth = 1;
+	lastDayOfMonth.lastDayOfMonth = lastDayOfMonth$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link lastDayOfMonth} function options.
+	 */
+
+	/**
+	 * @name lastDayOfMonth
+	 * @category Month Helpers
+	 * @summary Return the last day of a month for the given date.
+	 *
+	 * @description
+	 * Return the last day of a month 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 last day of a month
+	 *
+	 * @example
+	 * // The last day of a month for 2 September 2014 11:55:00:
+	 * const result = lastDayOfMonth(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Tue Sep 30 2014 00:00:00
+	 */
+	function lastDayOfMonth$1(date, options) {
+	  const _date = (0, _index.toDate)(date, options?.in);
+	  const month = _date.getMonth();
+	  _date.setFullYear(_date.getFullYear(), month + 1, 0);
+	  _date.setHours(0, 0, 0, 0);
+	  return (0, _index.toDate)(_date, options?.in);
+	}
+	return lastDayOfMonth;
+}
+
+export { requireLastDayOfMonth as __require };

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

@@ -0,0 +1,49 @@
+import { __exports as lastDayOfQuarter } from '../../_virtual/lastDayOfQuarter.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredLastDayOfQuarter;
+
+function requireLastDayOfQuarter () {
+	if (hasRequiredLastDayOfQuarter) return lastDayOfQuarter;
+	hasRequiredLastDayOfQuarter = 1;
+	lastDayOfQuarter.lastDayOfQuarter = lastDayOfQuarter$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link lastDayOfQuarter} function options.
+	 */
+
+	/**
+	 * @name lastDayOfQuarter
+	 * @category Quarter Helpers
+	 * @summary Return the last day of a year quarter for the given date.
+	 *
+	 * @description
+	 * Return the last day of a year quarter 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 - The options
+	 *
+	 * @returns The last day of a quarter
+	 *
+	 * @example
+	 * // The last day of a quarter for 2 September 2014 11:55:00:
+	 * const result = lastDayOfQuarter(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Tue Sep 30 2014 00:00:00
+	 */
+	function lastDayOfQuarter$1(date, options) {
+	  const date_ = (0, _index.toDate)(date, options?.in);
+	  const currentMonth = date_.getMonth();
+	  const month = currentMonth - (currentMonth % 3) + 3;
+	  date_.setMonth(month, 0);
+	  date_.setHours(0, 0, 0, 0);
+	  return date_;
+	}
+	return lastDayOfQuarter;
+}
+
+export { requireLastDayOfQuarter as __require };

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

@@ -0,0 +1,56 @@
+import { __exports as lastDayOfWeek } from '../../_virtual/lastDayOfWeek.esm.js';
+import { __require as requireDefaultOptions } from './_lib/defaultOptions.esm2.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredLastDayOfWeek;
+
+function requireLastDayOfWeek () {
+	if (hasRequiredLastDayOfWeek) return lastDayOfWeek;
+	hasRequiredLastDayOfWeek = 1;
+	lastDayOfWeek.lastDayOfWeek = lastDayOfWeek$1;
+	var _index = /*@__PURE__*/ requireDefaultOptions();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link lastDayOfWeek} function options.
+	 */
+
+	/**
+	 * @name lastDayOfWeek
+	 * @category Week Helpers
+	 * @summary Return the last day of a week for the given date.
+	 *
+	 * @description
+	 * Return the last day of a week for the given date.
+	 * The result will be in the local timezone unless a context is specified.
+	 *
+	 * @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 last day of a week
+	 */
+	function lastDayOfWeek$1(date, options) {
+	  const defaultOptions = (0, _index.getDefaultOptions)();
+	  const weekStartsOn =
+	    options?.weekStartsOn ??
+	    options?.locale?.options?.weekStartsOn ??
+	    defaultOptions.weekStartsOn ??
+	    defaultOptions.locale?.options?.weekStartsOn ??
+	    0;
+
+	  const _date = (0, _index2.toDate)(date, options?.in);
+	  const day = _date.getDay();
+	  const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
+
+	  _date.setHours(0, 0, 0, 0);
+	  _date.setDate(_date.getDate() + diff);
+
+	  return _date;
+	}
+	return lastDayOfWeek;
+}
+
+export { requireLastDayOfWeek as __require };

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

@@ -0,0 +1,48 @@
+import { __exports as lastDayOfYear } from '../../_virtual/lastDayOfYear.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredLastDayOfYear;
+
+function requireLastDayOfYear () {
+	if (hasRequiredLastDayOfYear) return lastDayOfYear;
+	hasRequiredLastDayOfYear = 1;
+	lastDayOfYear.lastDayOfYear = lastDayOfYear$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link lastDayOfYear} function options.
+	 */
+
+	/**
+	 * @name lastDayOfYear
+	 * @category Year Helpers
+	 * @summary Return the last day of a year for the given date.
+	 *
+	 * @description
+	 * Return the last day of a year 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 last day of a year
+	 *
+	 * @example
+	 * // The last day of a year for 2 September 2014 11:55:00:
+	 * const result = lastDayOfYear(new Date(2014, 8, 2, 11, 55, 00))
+	 * //=> Wed Dec 31 2014 00:00:00
+	 */
+	function lastDayOfYear$1(date, options) {
+	  const date_ = (0, _index.toDate)(date, options?.in);
+	  const year = date_.getFullYear();
+	  date_.setFullYear(year + 1, 0, 0);
+	  date_.setHours(0, 0, 0, 0);
+	  return date_;
+	}
+	return lastDayOfYear;
+}
+
+export { requireLastDayOfYear as __require };