cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/node_modules/date-fns/esm/differenceInCalendarYears/index.js

@@ -0,0 +1,33 @@
+import toDate from '../toDate/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+
+/**
+ * @name differenceInCalendarYears
+ * @category Year Helpers
+ * @summary Get the number of calendar years between the given dates.
+ *
+ * @description
+ * Get the number of calendar years between the given dates.
+ *
+ * @param {Date|Number} dateLeft - the later date
+ * @param {Date|Number} dateRight - the earlier date
+ * @returns {Number} the number of calendar years
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // How many calendar years are between 31 December 2013 and 11 February 2015?
+ * const result = differenceInCalendarYears(
+ *   new Date(2015, 1, 11),
+ *   new Date(2013, 11, 31)
+ * )
+ * //=> 2
+ */
+
+function differenceInCalendarYears(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  return dateLeft.getFullYear() - dateRight.getFullYear();
+}
+
+export { differenceInCalendarYears as default };

package/es/node_modules/date-fns/esm/differenceInDays/index.js

@@ -0,0 +1,86 @@
+import toDate from '../toDate/index.js';
+import differenceInCalendarDays from '../differenceInCalendarDays/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+
+// for accurate equality comparisons of UTC timestamps that end up
+// having the same representation in local time, e.g. one hour before
+// DST ends vs. the instant that DST ends.
+
+function compareLocalAsc(dateLeft, dateRight) {
+  var diff = dateLeft.getFullYear() - dateRight.getFullYear() || dateLeft.getMonth() - dateRight.getMonth() || dateLeft.getDate() - dateRight.getDate() || dateLeft.getHours() - dateRight.getHours() || dateLeft.getMinutes() - dateRight.getMinutes() || dateLeft.getSeconds() - dateRight.getSeconds() || dateLeft.getMilliseconds() - dateRight.getMilliseconds();
+
+  if (diff < 0) {
+    return -1;
+  } else if (diff > 0) {
+    return 1; // Return 0 if diff is 0; return NaN if diff is NaN
+  } else {
+    return diff;
+  }
+}
+/**
+ * @name differenceInDays
+ * @category Day Helpers
+ * @summary Get the number of full days between the given dates.
+ *
+ * @description
+ * Get the number of full day periods between two dates. Fractional days are
+ * truncated towards zero.
+ *
+ * One "full day" is the distance between a local time in one day to the same
+ * local time on the next or previous day. A full day can sometimes be less than
+ * or more than 24 hours if a daylight savings change happens between two dates.
+ *
+ * To ignore DST and only measure exact 24-hour periods, use this instead:
+ * `Math.floor(differenceInHours(dateLeft, dateRight)/24)|0`.
+ *
+ *
+ * @param {Date|Number} dateLeft - the later date
+ * @param {Date|Number} dateRight - the earlier date
+ * @returns {Number} the number of full days according to the local timezone
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // How many full days are between
+ * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+ * const result = differenceInDays(
+ *   new Date(2012, 6, 2, 0, 0),
+ *   new Date(2011, 6, 2, 23, 0)
+ * )
+ * //=> 365
+ * // How many full days are between
+ * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+ * const result = differenceInDays(
+ *   new Date(2011, 6, 3, 0, 1),
+ *   new Date(2011, 6, 2, 23, 59)
+ * )
+ * //=> 0
+ * // How many full days are between
+ * // 1 March 2020 0:00 and 1 June 2020 0:00 ?
+ * // Note: because local time is used, the
+ * // result will always be 92 days, even in
+ * // time zones where DST starts and the
+ * // period has only 92*24-1 hours.
+ * const result = differenceInDays(
+ *   new Date(2020, 5, 1),
+ *   new Date(2020, 2, 1)
+ * )
+//=> 92
+ */
+
+
+function differenceInDays(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var sign = compareLocalAsc(dateLeft, dateRight);
+  var difference = Math.abs(differenceInCalendarDays(dateLeft, dateRight));
+  dateLeft.setDate(dateLeft.getDate() - sign * difference); // Math.abs(diff in full days - diff in calendar days) === 1 if last calendar day is not full
+  // If so, result must be decreased by 1 in absolute value
+
+  var isLastDayNotFull = Number(compareLocalAsc(dateLeft, dateRight) === -sign);
+  var result = sign * (difference - isLastDayNotFull); // Prevent negative zero
+
+  return result === 0 ? 0 : result;
+}
+
+export { differenceInDays as default };

package/es/node_modules/date-fns/esm/differenceInMonths/index.js

@@ -0,0 +1,59 @@
+import toDate from '../toDate/index.js';
+import differenceInCalendarMonths from '../differenceInCalendarMonths/index.js';
+import compareAsc from '../compareAsc/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+import isLastDayOfMonth from '../isLastDayOfMonth/index.js';
+
+/**
+ * @name differenceInMonths
+ * @category Month Helpers
+ * @summary Get the number of full months between the given dates.
+ *
+ * @description
+ * Get the number of full months between the given dates using trunc as a default rounding method.
+ *
+ * @param {Date|Number} dateLeft - the later date
+ * @param {Date|Number} dateRight - the earlier date
+ * @returns {Number} the number of full months
+ * @throws {TypeError} 2 arguments required
+ *
+ * @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(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var sign = compareAsc(dateLeft, dateRight);
+  var difference = Math.abs(differenceInCalendarMonths(dateLeft, dateRight));
+  var result; // Check for the difference of less than month
+
+  if (difference < 1) {
+    result = 0;
+  } else {
+    if (dateLeft.getMonth() === 1 && dateLeft.getDate() > 27) {
+      // This will check if the date is end of Feb and assign a higher end of month date
+      // to compare it with Jan
+      dateLeft.setDate(30);
+    }
+
+    dateLeft.setMonth(dateLeft.getMonth() - sign * difference); // Math.abs(diff in full months - diff in calendar months) === 1 if last calendar month is not full
+    // If so, result must be decreased by 1 in absolute value
+
+    var isLastMonthNotFull = compareAsc(dateLeft, dateRight) === -sign; // Check for cases of one full calendar month
+
+    if (isLastDayOfMonth(toDate(dirtyDateLeft)) && difference === 1 && compareAsc(dirtyDateLeft, dateRight) === 1) {
+      isLastMonthNotFull = false;
+    }
+
+    result = sign * (difference - Number(isLastMonthNotFull));
+  } // Prevent negative zero
+
+
+  return result === 0 ? 0 : result;
+}
+
+export { differenceInMonths as default };

package/es/node_modules/date-fns/esm/differenceInYears/index.js

@@ -0,0 +1,43 @@
+import toDate from '../toDate/index.js';
+import differenceInCalendarYears from '../differenceInCalendarYears/index.js';
+import compareAsc from '../compareAsc/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+
+/**
+ * @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 {Date|Number} dateLeft - the later date
+ * @param {Date|Number} dateRight - the earlier date
+ * @returns {Number} the number of full years
+ * @throws {TypeError} 2 arguments required
+ *
+ * @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(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var sign = compareAsc(dateLeft, dateRight);
+  var difference = Math.abs(differenceInCalendarYears(dateLeft, dateRight)); // Set both dates to a valid leap year for accurate comparison when dealing
+  // with leap days
+
+  dateLeft.setFullYear(1584);
+  dateRight.setFullYear(1584); // Math.abs(diff in full years - diff in calendar years) === 1 if last calendar year is not full
+  // If so, result must be decreased by 1 in absolute value
+
+  var isLastYearNotFull = compareAsc(dateLeft, dateRight) === -sign;
+  var result = sign * (difference - Number(isLastYearNotFull)); // Prevent negative zero
+
+  return result === 0 ? 0 : result;
+}
+
+export { differenceInYears as default };

package/es/node_modules/date-fns/esm/endOfDay/index.js

@@ -0,0 +1,30 @@
+import toDate from '../toDate/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+
+/**
+ * @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.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the end of a day
+ * @throws {TypeError} 1 argument required
+ *
+ * @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(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+export { endOfDay as default };

package/es/node_modules/date-fns/esm/endOfMonth/index.js

@@ -0,0 +1,32 @@
+import toDate from '../toDate/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+
+/**
+ * @name endOfMonth
+ * @category Month Helpers
+ * @summary Return the end of a month for the given date.
+ *
+ * @description
+ * Return the end of a month for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the end of a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // The end of a month for 2 September 2014 11:55:00:
+ * const result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Tue Sep 30 2014 23:59:59.999
+ */
+
+function endOfMonth(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var month = date.getMonth();
+  date.setFullYear(date.getFullYear(), month + 1, 0);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+export { endOfMonth as default };

package/es/node_modules/date-fns/esm/isLastDayOfMonth/index.js

@@ -0,0 +1,30 @@
+import toDate from '../toDate/index.js';
+import endOfDay from '../endOfDay/index.js';
+import endOfMonth from '../endOfMonth/index.js';
+import requiredArgs from '../_lib/requiredArgs/index.js';
+
+/**
+ * @name isLastDayOfMonth
+ * @category Month Helpers
+ * @summary Is the given date the last day of a month?
+ *
+ * @description
+ * Is the given date the last day of a month?
+ *
+ * @param {Date|Number} date - the date to check
+ * @returns {Boolean} the date is the last day of a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Is 28 February 2014 the last day of a month?
+ * const result = isLastDayOfMonth(new Date(2014, 1, 28))
+ * //=> true
+ */
+
+function isLastDayOfMonth(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  return endOfDay(date).getTime() === endOfMonth(date).getTime();
+}
+
+export { isLastDayOfMonth as default };

package/es/node_modules/date-fns/esm/parse/_lib/Parser.js

@@ -0,0 +1,32 @@
+import { ValueSetter } from './Setter.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class Parser {
+  constructor() {
+    _defineProperty(this, "incompatibleTokens", void 0);
+
+    _defineProperty(this, "priority", void 0);
+
+    _defineProperty(this, "subPriority", void 0);
+  }
+
+  run(dateString, token, match, options) {
+    var result = this.parse(dateString, token, match, options);
+
+    if (!result) {
+      return null;
+    }
+
+    return {
+      setter: new ValueSetter(result.value, this.validate, this.set, this.priority, this.subPriority),
+      rest: result.rest
+    };
+  }
+
+  validate(_utcDate, _value, _options) {
+    return true;
+  }
+
+}
+
+export { Parser };

package/es/node_modules/date-fns/esm/parse/_lib/Setter.js

@@ -0,0 +1,37 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class Setter {
+  constructor() {
+    _defineProperty(this, "priority", void 0);
+
+    _defineProperty(this, "subPriority", 0);
+  }
+
+  validate(_utcDate, _options) {
+    return true;
+  }
+
+}
+class ValueSetter extends Setter {
+  constructor(value, validateValue, setValue, priority, subPriority) {
+    super();
+    this.value = value;
+    this.validateValue = validateValue;
+    this.setValue = setValue;
+    this.priority = priority;
+
+    if (subPriority) {
+      this.subPriority = subPriority;
+    }
+  }
+
+  validate(utcDate, options) {
+    return this.validateValue(utcDate, this.value, options);
+  }
+
+  set(utcDate, flags, options) {
+    return this.setValue(utcDate, flags, this.value, options);
+  }
+
+}
+
+export { Setter, ValueSetter };

package/es/node_modules/date-fns/esm/parse/_lib/constants.js

@@ -0,0 +1,48 @@
+var numericPatterns = {
+  month: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/,
+  // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
+  // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/,
+  // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/,
+  // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/,
+  // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/,
+  // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  minute: /^[0-5]?\d/,
+  // 0 to 59
+  second: /^[0-5]?\d/,
+  // 0 to 59
+  singleDigit: /^\d/,
+  // 0 to 9
+  twoDigits: /^\d{1,2}/,
+  // 0 to 99
+  threeDigits: /^\d{1,3}/,
+  // 0 to 999
+  fourDigits: /^\d{1,4}/,
+  // 0 to 9999
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/,
+  // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/,
+  // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/,
+  // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/ // 0 to 9999, -0 to -9999
+
+};
+var timezonePatterns = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
+};
+
+export { numericPatterns, timezonePatterns };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/AMPMMidnightParser.js

@@ -0,0 +1,55 @@
+import { Parser } from '../Parser.js';
+import { dayPeriodEnumToHours } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class AMPMMidnightParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 80);
+
+    _defineProperty(this, "incompatibleTokens", ['a', 'B', 'H', 'k', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'b':
+      case 'bb':
+      case 'bbb':
+        return match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'bbbbb':
+        return match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'bbbb':
+      default:
+        return match.dayPeriod(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { AMPMMidnightParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/AMPMParser.js

@@ -0,0 +1,55 @@
+import { Parser } from '../Parser.js';
+import { dayPeriodEnumToHours } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class AMPMParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 80);
+
+    _defineProperty(this, "incompatibleTokens", ['b', 'B', 'H', 'k', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'a':
+      case 'aa':
+      case 'aaa':
+        return match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'aaaaa':
+        return match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'aaaa':
+      default:
+        return match.dayPeriod(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { AMPMParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/DateParser.js

@@ -0,0 +1,55 @@
+import { parseNDigits, parseNumericPattern, isLeapYearIndex } from '../utils.js';
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var DAYS_IN_MONTH_LEAP_YEAR = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; // Day of the month
+
+class DateParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "subPriority", 1);
+
+    _defineProperty(this, "incompatibleTokens", ['Y', 'R', 'q', 'Q', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'd':
+        return parseNumericPattern(numericPatterns.date, dateString);
+
+      case 'do':
+        return match.ordinalNumber(dateString, {
+          unit: 'date'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(date, value) {
+    var year = date.getUTCFullYear();
+    var isLeapYear = isLeapYearIndex(year);
+    var month = date.getUTCMonth();
+
+    if (isLeapYear) {
+      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+    } else {
+      return value >= 1 && value <= DAYS_IN_MONTH[month];
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCDate(value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { DateParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/DayOfYearParser.js

@@ -0,0 +1,52 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern, isLeapYearIndex } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class DayOfYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "subpriority", 1);
+
+    _defineProperty(this, "incompatibleTokens", ['Y', 'R', 'q', 'Q', 'M', 'L', 'w', 'I', 'd', 'E', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'D':
+      case 'DD':
+        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
+
+      case 'Do':
+        return match.ordinalNumber(dateString, {
+          unit: 'date'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(date, value) {
+    var year = date.getUTCFullYear();
+    var isLeapYear = isLeapYearIndex(year);
+
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCMonth(0, value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { DayOfYearParser };