cnhis-design-vue 3.1.11 → 3.1.12-beta.2

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

@@ -0,0 +1,99 @@
+import { Parser } from '../Parser.js';
+import { mapValue, parseNDigits } from '../utils.js';
+import setUTCISODay from '../../../_lib/setUTCISODay/index.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 ISODayParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'E', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    var valueCallback = function (value) {
+      if (value === 0) {
+        return 7;
+      }
+
+      return value;
+    };
+
+    switch (token) {
+      // 2
+      case 'i':
+      case 'ii':
+        // 02
+        return parseNDigits(token.length, dateString);
+      // 2nd
+
+      case 'io':
+        return match.ordinalNumber(dateString, {
+          unit: 'day'
+        });
+      // Tue
+
+      case 'iii':
+        return mapValue(match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+      // T
+
+      case 'iiiii':
+        return mapValue(match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+      // Tu
+
+      case 'iiiiii':
+        return mapValue(match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+      // Tuesday
+
+      case 'iiii':
+      default:
+        return mapValue(match.day(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 7;
+  }
+
+  set(date, _flags, value) {
+    date = setUTCISODay(date, value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { ISODayParser };

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

@@ -0,0 +1,46 @@
+import { Parser } from '../Parser.js';
+import { timezonePatterns } from '../constants.js';
+import { parseTimezonePattern } 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 ISOTimezoneParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 10);
+
+    _defineProperty(this, "incompatibleTokens", ['t', 'T', 'X']);
+  }
+
+  parse(dateString, token) {
+    switch (token) {
+      case 'x':
+        return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
+
+      case 'xx':
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+
+      case 'xxxx':
+        return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
+
+      case 'xxxxx':
+        return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
+
+      case 'xxx':
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
+  }
+
+  set(date, flags, value) {
+    if (flags.timestampIsSet) {
+      return date;
+    }
+
+    return new Date(date.getTime() - value);
+  }
+
+}
+
+export { ISOTimezoneParser };

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

@@ -0,0 +1,46 @@
+import { Parser } from '../Parser.js';
+import { timezonePatterns } from '../constants.js';
+import { parseTimezonePattern } 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 ISOTimezoneWithZParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 10);
+
+    _defineProperty(this, "incompatibleTokens", ['t', 'T', 'x']);
+  }
+
+  parse(dateString, token) {
+    switch (token) {
+      case 'X':
+        return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
+
+      case 'XX':
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+
+      case 'XXXX':
+        return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
+
+      case 'XXXXX':
+        return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
+
+      case 'XXX':
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
+  }
+
+  set(date, flags, value) {
+    if (flags.timestampIsSet) {
+      return date;
+    }
+
+    return new Date(date.getTime() - value);
+  }
+
+}
+
+export { ISOTimezoneWithZParser };

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

@@ -0,0 +1,43 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+import setUTCISOWeek from '../../../_lib/setUTCISOWeek/index.js';
+import startOfUTCISOWeek from '../../../_lib/startOfUTCISOWeek/index.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 ISOWeekParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 100);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'I':
+        return parseNumericPattern(numericPatterns.week, dateString);
+
+      case 'Io':
+        return match.ordinalNumber(dateString, {
+          unit: 'week'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+
+  set(date, _flags, value) {
+    return startOfUTCISOWeek(setUTCISOWeek(date, value));
+  }
+
+}
+
+export { ISOWeekParser };

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

@@ -0,0 +1,33 @@
+import { Parser } from '../Parser.js';
+import { parseNDigitsSigned } from '../utils.js';
+import startOfUTCISOWeek from '../../../_lib/startOfUTCISOWeek/index.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 ISOWeekYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 130);
+
+    _defineProperty(this, "incompatibleTokens", ['G', 'y', 'Y', 'u', 'Q', 'q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token) {
+    if (token === 'R') {
+      return parseNDigitsSigned(4, dateString);
+    }
+
+    return parseNDigitsSigned(token.length, dateString);
+  }
+
+  set(_date, _flags, value) {
+    var firstWeekOfYear = new Date(0);
+    firstWeekOfYear.setUTCFullYear(value, 0, 4);
+    firstWeekOfYear.setUTCHours(0, 0, 0, 0);
+    return startOfUTCISOWeek(firstWeekOfYear);
+  }
+
+}
+
+export { ISOWeekYearParser };

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

@@ -0,0 +1,96 @@
+import { Parser } from '../Parser.js';
+import { mapValue, parseNDigits } from '../utils.js';
+import setUTCDay from '../../../_lib/setUTCDay/index.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 LocalDayParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'E', 'i', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match, options) {
+    var valueCallback = function (value) {
+      var wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
+    };
+
+    switch (token) {
+      // 3
+      case 'e':
+      case 'ee':
+        // 03
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+
+      case 'eo':
+        return mapValue(match.ordinalNumber(dateString, {
+          unit: 'day'
+        }), valueCallback);
+      // Tue
+
+      case 'eee':
+        return match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // T
+
+      case 'eeeee':
+        return match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // Tu
+
+      case 'eeeeee':
+        return match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // Tuesday
+
+      case 'eeee':
+      default:
+        return match.day(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+
+  set(date, _flags, value, options) {
+    date = setUTCDay(date, value, options);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { LocalDayParser };

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

@@ -0,0 +1,43 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+import setUTCWeek from '../../../_lib/setUTCWeek/index.js';
+import startOfUTCWeek from '../../../_lib/startOfUTCWeek/index.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 LocalWeekParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 100);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'w':
+        return parseNumericPattern(numericPatterns.week, dateString);
+
+      case 'wo':
+        return match.ordinalNumber(dateString, {
+          unit: 'week'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+
+  set(date, _flags, value, options) {
+    return startOfUTCWeek(setUTCWeek(date, value, options), options);
+  }
+
+}
+
+export { LocalWeekParser };

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

@@ -0,0 +1,61 @@
+import { Parser } from '../Parser.js';
+import { mapValue, parseNDigits, normalizeTwoDigitYear } from '../utils.js';
+import getUTCWeekYear from '../../../_lib/getUTCWeekYear/index.js';
+import startOfUTCWeek from '../../../_lib/startOfUTCWeek/index.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; }
+// Local week-numbering year
+class LocalWeekYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 130);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'R', 'u', 'Q', 'q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    var valueCallback = function (year) {
+      return {
+        year: year,
+        isTwoDigitYear: token === 'YY'
+      };
+    };
+
+    switch (token) {
+      case 'Y':
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+
+      case 'Yo':
+        return mapValue(match.ordinalNumber(dateString, {
+          unit: 'year'
+        }), valueCallback);
+
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+
+  set(date, flags, value, options) {
+    var currentYear = getUTCWeekYear(date, options);
+
+    if (value.isTwoDigitYear) {
+      var normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
+      date.setUTCFullYear(normalizedTwoDigitYear, 0, options.firstWeekContainsDate);
+      date.setUTCHours(0, 0, 0, 0);
+      return startOfUTCWeek(date, options);
+    }
+
+    var year = !('era' in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date.setUTCFullYear(year, 0, options.firstWeekContainsDate);
+    date.setUTCHours(0, 0, 0, 0);
+    return startOfUTCWeek(date, options);
+  }
+
+}
+
+export { LocalWeekYearParser };

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

@@ -0,0 +1,41 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } 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 MinuteParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 60);
+
+    _defineProperty(this, "incompatibleTokens", ['t', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'm':
+        return parseNumericPattern(numericPatterns.minute, dateString);
+
+      case 'mo':
+        return match.ordinalNumber(dateString, {
+          unit: 'minute'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+
+  set(date, _flags, value) {
+    date.setUTCMinutes(value, 0, 0);
+    return date;
+  }
+
+}
+
+export { MinuteParser };

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

@@ -0,0 +1,80 @@
+import { mapValue, parseNDigits, parseNumericPattern } 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; }
+class MonthParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "incompatibleTokens", ['Y', 'R', 'q', 'Q', 'L', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T']);
+
+    _defineProperty(this, "priority", 110);
+  }
+
+  parse(dateString, token, match) {
+    var valueCallback = function (value) {
+      return value - 1;
+    };
+
+    switch (token) {
+      // 1, 2, ..., 12
+      case 'M':
+        return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
+      // 01, 02, ..., 12
+
+      case 'MM':
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+
+      case 'Mo':
+        return mapValue(match.ordinalNumber(dateString, {
+          unit: 'month'
+        }), valueCallback);
+      // Jan, Feb, ..., Dec
+
+      case 'MMM':
+        return match.month(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.month(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // J, F, ..., D
+
+      case 'MMMMM':
+        return match.month(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // January, February, ..., December
+
+      case 'MMMM':
+      default:
+        return match.month(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.month(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.month(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+
+  set(date, _flags, value) {
+    date.setUTCMonth(value, 1);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { MonthParser };

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

@@ -0,0 +1,73 @@
+import { Parser } from '../Parser.js';
+import { parseNDigits } 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 QuarterParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 120);
+
+    _defineProperty(this, "incompatibleTokens", ['Y', 'R', 'q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case 'Q':
+      case 'QQ':
+        // 01, 02, 03, 04
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+
+      case 'Qo':
+        return match.ordinalNumber(dateString, {
+          unit: 'quarter'
+        });
+      // Q1, Q2, Q3, Q4
+
+      case 'QQQ':
+        return match.quarter(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.quarter(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+
+      case 'QQQQQ':
+        return match.quarter(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // 1st quarter, 2nd quarter, ...
+
+      case 'QQQQ':
+      default:
+        return match.quarter(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.quarter(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.quarter(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+
+  set(date, _flags, value) {
+    date.setUTCMonth((value - 1) * 3, 1);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { QuarterParser };