2532 lines
68 KiB
JavaScript
2532 lines
68 KiB
JavaScript
import {
|
|
__spreadProps,
|
|
__spreadValues
|
|
} from "./chunk-TKSB4YUA.js";
|
|
|
|
// node_modules/date-fns/constants.js
|
|
var daysInYear = 365.2425;
|
|
var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1e3;
|
|
var minTime = -maxTime;
|
|
var millisecondsInWeek = 6048e5;
|
|
var millisecondsInDay = 864e5;
|
|
var millisecondsInMinute = 6e4;
|
|
var millisecondsInHour = 36e5;
|
|
var millisecondsInSecond = 1e3;
|
|
var secondsInHour = 3600;
|
|
var secondsInDay = secondsInHour * 24;
|
|
var secondsInWeek = secondsInDay * 7;
|
|
var secondsInYear = secondsInDay * daysInYear;
|
|
var secondsInMonth = secondsInYear / 12;
|
|
var secondsInQuarter = secondsInMonth * 3;
|
|
var constructFromSymbol = Symbol.for("constructDateFrom");
|
|
|
|
// node_modules/date-fns/constructFrom.js
|
|
function constructFrom(date, value) {
|
|
if (typeof date === "function") return date(value);
|
|
if (date && typeof date === "object" && constructFromSymbol in date)
|
|
return date[constructFromSymbol](value);
|
|
if (date instanceof Date) return new date.constructor(value);
|
|
return new Date(value);
|
|
}
|
|
|
|
// node_modules/date-fns/toDate.js
|
|
function toDate(argument, context) {
|
|
return constructFrom(context || argument, argument);
|
|
}
|
|
|
|
// node_modules/date-fns/addDays.js
|
|
function addDays(date, amount, options) {
|
|
const _date = toDate(date, options?.in);
|
|
if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
|
|
if (!amount) return _date;
|
|
_date.setDate(_date.getDate() + amount);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/addMonths.js
|
|
function addMonths(date, amount, options) {
|
|
const _date = toDate(date, options?.in);
|
|
if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
|
|
if (!amount) {
|
|
return _date;
|
|
}
|
|
const dayOfMonth = _date.getDate();
|
|
const endOfDesiredMonth = constructFrom(options?.in || date, _date.getTime());
|
|
endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
|
|
const daysInMonth = endOfDesiredMonth.getDate();
|
|
if (dayOfMonth >= daysInMonth) {
|
|
return endOfDesiredMonth;
|
|
} else {
|
|
_date.setFullYear(
|
|
endOfDesiredMonth.getFullYear(),
|
|
endOfDesiredMonth.getMonth(),
|
|
dayOfMonth
|
|
);
|
|
return _date;
|
|
}
|
|
}
|
|
|
|
// node_modules/date-fns/addMilliseconds.js
|
|
function addMilliseconds(date, amount, options) {
|
|
return constructFrom(options?.in || date, +toDate(date) + amount);
|
|
}
|
|
|
|
// node_modules/date-fns/addHours.js
|
|
function addHours(date, amount, options) {
|
|
return addMilliseconds(date, amount * millisecondsInHour, options);
|
|
}
|
|
|
|
// node_modules/date-fns/_lib/defaultOptions.js
|
|
var defaultOptions = {};
|
|
function getDefaultOptions() {
|
|
return defaultOptions;
|
|
}
|
|
|
|
// node_modules/date-fns/startOfWeek.js
|
|
function startOfWeek(date, options) {
|
|
const defaultOptions2 = getDefaultOptions();
|
|
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
|
|
const _date = toDate(date, options?.in);
|
|
const day = _date.getDay();
|
|
const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
|
|
_date.setDate(_date.getDate() - diff);
|
|
_date.setHours(0, 0, 0, 0);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/startOfISOWeek.js
|
|
function startOfISOWeek(date, options) {
|
|
return startOfWeek(date, __spreadProps(__spreadValues({}, options), { weekStartsOn: 1 }));
|
|
}
|
|
|
|
// node_modules/date-fns/getISOWeekYear.js
|
|
function getISOWeekYear(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const year = _date.getFullYear();
|
|
const fourthOfJanuaryOfNextYear = constructFrom(_date, 0);
|
|
fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
|
|
fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
|
|
const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
|
|
const fourthOfJanuaryOfThisYear = constructFrom(_date, 0);
|
|
fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
|
|
fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
|
|
const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
|
|
if (_date.getTime() >= startOfNextYear.getTime()) {
|
|
return year + 1;
|
|
} else if (_date.getTime() >= startOfThisYear.getTime()) {
|
|
return year;
|
|
} else {
|
|
return year - 1;
|
|
}
|
|
}
|
|
|
|
// node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js
|
|
function getTimezoneOffsetInMilliseconds(date) {
|
|
const _date = toDate(date);
|
|
const utcDate = new Date(
|
|
Date.UTC(
|
|
_date.getFullYear(),
|
|
_date.getMonth(),
|
|
_date.getDate(),
|
|
_date.getHours(),
|
|
_date.getMinutes(),
|
|
_date.getSeconds(),
|
|
_date.getMilliseconds()
|
|
)
|
|
);
|
|
utcDate.setUTCFullYear(_date.getFullYear());
|
|
return +date - +utcDate;
|
|
}
|
|
|
|
// node_modules/date-fns/_lib/normalizeDates.js
|
|
function normalizeDates(context, ...dates) {
|
|
const normalize = constructFrom.bind(
|
|
null,
|
|
context || dates.find((date) => typeof date === "object")
|
|
);
|
|
return dates.map(normalize);
|
|
}
|
|
|
|
// node_modules/date-fns/startOfDay.js
|
|
function startOfDay(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
_date.setHours(0, 0, 0, 0);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/differenceInCalendarDays.js
|
|
function differenceInCalendarDays(laterDate, earlierDate, options) {
|
|
const [laterDate_, earlierDate_] = normalizeDates(
|
|
options?.in,
|
|
laterDate,
|
|
earlierDate
|
|
);
|
|
const laterStartOfDay = startOfDay(laterDate_);
|
|
const earlierStartOfDay = startOfDay(earlierDate_);
|
|
const laterTimestamp = +laterStartOfDay - getTimezoneOffsetInMilliseconds(laterStartOfDay);
|
|
const earlierTimestamp = +earlierStartOfDay - getTimezoneOffsetInMilliseconds(earlierStartOfDay);
|
|
return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInDay);
|
|
}
|
|
|
|
// node_modules/date-fns/startOfISOWeekYear.js
|
|
function startOfISOWeekYear(date, options) {
|
|
const year = getISOWeekYear(date, options);
|
|
const fourthOfJanuary = constructFrom(options?.in || date, 0);
|
|
fourthOfJanuary.setFullYear(year, 0, 4);
|
|
fourthOfJanuary.setHours(0, 0, 0, 0);
|
|
return startOfISOWeek(fourthOfJanuary);
|
|
}
|
|
|
|
// node_modules/date-fns/addMinutes.js
|
|
function addMinutes(date, amount, options) {
|
|
const _date = toDate(date, options?.in);
|
|
_date.setTime(_date.getTime() + amount * millisecondsInMinute);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/addSeconds.js
|
|
function addSeconds(date, amount, options) {
|
|
return addMilliseconds(date, amount * 1e3, options);
|
|
}
|
|
|
|
// node_modules/date-fns/addWeeks.js
|
|
function addWeeks(date, amount, options) {
|
|
return addDays(date, amount * 7, options);
|
|
}
|
|
|
|
// node_modules/date-fns/max.js
|
|
function max(dates, options) {
|
|
let result;
|
|
let context = options?.in;
|
|
dates.forEach((date) => {
|
|
if (!context && typeof date === "object")
|
|
context = constructFrom.bind(null, date);
|
|
const date_ = toDate(date, context);
|
|
if (!result || result < date_ || isNaN(+date_)) result = date_;
|
|
});
|
|
return constructFrom(context, result || NaN);
|
|
}
|
|
|
|
// node_modules/date-fns/isSameDay.js
|
|
function isSameDay(laterDate, earlierDate, options) {
|
|
const [dateLeft_, dateRight_] = normalizeDates(
|
|
options?.in,
|
|
laterDate,
|
|
earlierDate
|
|
);
|
|
return +startOfDay(dateLeft_) === +startOfDay(dateRight_);
|
|
}
|
|
|
|
// node_modules/date-fns/differenceInDays.js
|
|
function differenceInDays(laterDate, earlierDate, options) {
|
|
const [laterDate_, earlierDate_] = normalizeDates(
|
|
options?.in,
|
|
laterDate,
|
|
earlierDate
|
|
);
|
|
const sign = compareLocalAsc(laterDate_, earlierDate_);
|
|
const difference = Math.abs(
|
|
differenceInCalendarDays(laterDate_, earlierDate_)
|
|
);
|
|
laterDate_.setDate(laterDate_.getDate() - sign * difference);
|
|
const isLastDayNotFull = Number(
|
|
compareLocalAsc(laterDate_, earlierDate_) === -sign
|
|
);
|
|
const result = sign * (difference - isLastDayNotFull);
|
|
return result === 0 ? 0 : result;
|
|
}
|
|
function compareLocalAsc(laterDate, earlierDate) {
|
|
const diff = laterDate.getFullYear() - earlierDate.getFullYear() || laterDate.getMonth() - earlierDate.getMonth() || laterDate.getDate() - earlierDate.getDate() || laterDate.getHours() - earlierDate.getHours() || laterDate.getMinutes() - earlierDate.getMinutes() || laterDate.getSeconds() - earlierDate.getSeconds() || laterDate.getMilliseconds() - earlierDate.getMilliseconds();
|
|
if (diff < 0) return -1;
|
|
if (diff > 0) return 1;
|
|
return diff;
|
|
}
|
|
|
|
// node_modules/date-fns/_lib/getRoundingMethod.js
|
|
function getRoundingMethod(method) {
|
|
return (number) => {
|
|
const round = method ? Math[method] : Math.trunc;
|
|
const result = round(number);
|
|
return result === 0 ? 0 : result;
|
|
};
|
|
}
|
|
|
|
// node_modules/date-fns/differenceInMilliseconds.js
|
|
function differenceInMilliseconds(laterDate, earlierDate) {
|
|
return +toDate(laterDate) - +toDate(earlierDate);
|
|
}
|
|
|
|
// node_modules/date-fns/differenceInMinutes.js
|
|
function differenceInMinutes(dateLeft, dateRight, options) {
|
|
const diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
|
|
return getRoundingMethod(options?.roundingMethod)(diff);
|
|
}
|
|
|
|
// node_modules/date-fns/endOfDay.js
|
|
function endOfDay(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
_date.setHours(23, 59, 59, 999);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/endOfMonth.js
|
|
function endOfMonth(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const month = _date.getMonth();
|
|
_date.setFullYear(_date.getFullYear(), month + 1, 0);
|
|
_date.setHours(23, 59, 59, 999);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/differenceInSeconds.js
|
|
function differenceInSeconds(laterDate, earlierDate, options) {
|
|
const diff = differenceInMilliseconds(laterDate, earlierDate) / 1e3;
|
|
return getRoundingMethod(options?.roundingMethod)(diff);
|
|
}
|
|
|
|
// node_modules/date-fns/startOfMonth.js
|
|
function startOfMonth(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
_date.setDate(1);
|
|
_date.setHours(0, 0, 0, 0);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/endOfWeek.js
|
|
function endOfWeek(date, options) {
|
|
const defaultOptions2 = getDefaultOptions();
|
|
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
|
|
const _date = toDate(date, options?.in);
|
|
const day = _date.getDay();
|
|
const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
|
|
_date.setDate(_date.getDate() + diff);
|
|
_date.setHours(23, 59, 59, 999);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/locale/_lib/buildFormatLongFn.js
|
|
function buildFormatLongFn(args) {
|
|
return (options = {}) => {
|
|
const width = options.width ? String(options.width) : args.defaultWidth;
|
|
const format2 = args.formats[width] || args.formats[args.defaultWidth];
|
|
return format2;
|
|
};
|
|
}
|
|
|
|
// node_modules/date-fns/locale/en-US/_lib/formatLong.js
|
|
var dateFormats = {
|
|
full: "EEEE, MMMM do, y",
|
|
long: "MMMM do, y",
|
|
medium: "MMM d, y",
|
|
short: "MM/dd/yyyy"
|
|
};
|
|
var timeFormats = {
|
|
full: "h:mm:ss a zzzz",
|
|
long: "h:mm:ss a z",
|
|
medium: "h:mm:ss a",
|
|
short: "h:mm a"
|
|
};
|
|
var dateTimeFormats = {
|
|
full: "{{date}} 'at' {{time}}",
|
|
long: "{{date}} 'at' {{time}}",
|
|
medium: "{{date}}, {{time}}",
|
|
short: "{{date}}, {{time}}"
|
|
};
|
|
var formatLong = {
|
|
date: buildFormatLongFn({
|
|
formats: dateFormats,
|
|
defaultWidth: "full"
|
|
}),
|
|
time: buildFormatLongFn({
|
|
formats: timeFormats,
|
|
defaultWidth: "full"
|
|
}),
|
|
dateTime: buildFormatLongFn({
|
|
formats: dateTimeFormats,
|
|
defaultWidth: "full"
|
|
})
|
|
};
|
|
|
|
// node_modules/date-fns/locale/_lib/buildLocalizeFn.js
|
|
function buildLocalizeFn(args) {
|
|
return (value, options) => {
|
|
const context = options?.context ? String(options.context) : "standalone";
|
|
let valuesArray;
|
|
if (context === "formatting" && args.formattingValues) {
|
|
const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
|
|
const width = options?.width ? String(options.width) : defaultWidth;
|
|
valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
|
|
} else {
|
|
const defaultWidth = args.defaultWidth;
|
|
const width = options?.width ? String(options.width) : args.defaultWidth;
|
|
valuesArray = args.values[width] || args.values[defaultWidth];
|
|
}
|
|
const index = args.argumentCallback ? args.argumentCallback(value) : value;
|
|
return valuesArray[index];
|
|
};
|
|
}
|
|
|
|
// node_modules/date-fns/locale/en-US/_lib/localize.js
|
|
var eraValues = {
|
|
narrow: ["B", "A"],
|
|
abbreviated: ["BC", "AD"],
|
|
wide: ["Before Christ", "Anno Domini"]
|
|
};
|
|
var quarterValues = {
|
|
narrow: ["1", "2", "3", "4"],
|
|
abbreviated: ["Q1", "Q2", "Q3", "Q4"],
|
|
wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
|
|
};
|
|
var monthValues = {
|
|
narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
|
|
abbreviated: [
|
|
"Jan",
|
|
"Feb",
|
|
"Mar",
|
|
"Apr",
|
|
"May",
|
|
"Jun",
|
|
"Jul",
|
|
"Aug",
|
|
"Sep",
|
|
"Oct",
|
|
"Nov",
|
|
"Dec"
|
|
],
|
|
wide: [
|
|
"January",
|
|
"February",
|
|
"March",
|
|
"April",
|
|
"May",
|
|
"June",
|
|
"July",
|
|
"August",
|
|
"September",
|
|
"October",
|
|
"November",
|
|
"December"
|
|
]
|
|
};
|
|
var dayValues = {
|
|
narrow: ["S", "M", "T", "W", "T", "F", "S"],
|
|
short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
|
|
abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
|
|
wide: [
|
|
"Sunday",
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday"
|
|
]
|
|
};
|
|
var dayPeriodValues = {
|
|
narrow: {
|
|
am: "a",
|
|
pm: "p",
|
|
midnight: "mi",
|
|
noon: "n",
|
|
morning: "morning",
|
|
afternoon: "afternoon",
|
|
evening: "evening",
|
|
night: "night"
|
|
},
|
|
abbreviated: {
|
|
am: "AM",
|
|
pm: "PM",
|
|
midnight: "midnight",
|
|
noon: "noon",
|
|
morning: "morning",
|
|
afternoon: "afternoon",
|
|
evening: "evening",
|
|
night: "night"
|
|
},
|
|
wide: {
|
|
am: "a.m.",
|
|
pm: "p.m.",
|
|
midnight: "midnight",
|
|
noon: "noon",
|
|
morning: "morning",
|
|
afternoon: "afternoon",
|
|
evening: "evening",
|
|
night: "night"
|
|
}
|
|
};
|
|
var formattingDayPeriodValues = {
|
|
narrow: {
|
|
am: "a",
|
|
pm: "p",
|
|
midnight: "mi",
|
|
noon: "n",
|
|
morning: "in the morning",
|
|
afternoon: "in the afternoon",
|
|
evening: "in the evening",
|
|
night: "at night"
|
|
},
|
|
abbreviated: {
|
|
am: "AM",
|
|
pm: "PM",
|
|
midnight: "midnight",
|
|
noon: "noon",
|
|
morning: "in the morning",
|
|
afternoon: "in the afternoon",
|
|
evening: "in the evening",
|
|
night: "at night"
|
|
},
|
|
wide: {
|
|
am: "a.m.",
|
|
pm: "p.m.",
|
|
midnight: "midnight",
|
|
noon: "noon",
|
|
morning: "in the morning",
|
|
afternoon: "in the afternoon",
|
|
evening: "in the evening",
|
|
night: "at night"
|
|
}
|
|
};
|
|
var ordinalNumber = (dirtyNumber, _options) => {
|
|
const number = Number(dirtyNumber);
|
|
const rem100 = number % 100;
|
|
if (rem100 > 20 || rem100 < 10) {
|
|
switch (rem100 % 10) {
|
|
case 1:
|
|
return number + "st";
|
|
case 2:
|
|
return number + "nd";
|
|
case 3:
|
|
return number + "rd";
|
|
}
|
|
}
|
|
return number + "th";
|
|
};
|
|
var localize = {
|
|
ordinalNumber,
|
|
era: buildLocalizeFn({
|
|
values: eraValues,
|
|
defaultWidth: "wide"
|
|
}),
|
|
quarter: buildLocalizeFn({
|
|
values: quarterValues,
|
|
defaultWidth: "wide",
|
|
argumentCallback: (quarter) => quarter - 1
|
|
}),
|
|
month: buildLocalizeFn({
|
|
values: monthValues,
|
|
defaultWidth: "wide"
|
|
}),
|
|
day: buildLocalizeFn({
|
|
values: dayValues,
|
|
defaultWidth: "wide"
|
|
}),
|
|
dayPeriod: buildLocalizeFn({
|
|
values: dayPeriodValues,
|
|
defaultWidth: "wide",
|
|
formattingValues: formattingDayPeriodValues,
|
|
defaultFormattingWidth: "wide"
|
|
})
|
|
};
|
|
|
|
// node_modules/date-fns/locale/_lib/buildMatchFn.js
|
|
function buildMatchFn(args) {
|
|
return (string, options = {}) => {
|
|
const width = options.width;
|
|
const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
|
|
const matchResult = string.match(matchPattern);
|
|
if (!matchResult) {
|
|
return null;
|
|
}
|
|
const matchedString = matchResult[0];
|
|
const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
|
|
const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : (
|
|
// [TODO] -- I challenge you to fix the type
|
|
findKey(parsePatterns, (pattern) => pattern.test(matchedString))
|
|
);
|
|
let value;
|
|
value = args.valueCallback ? args.valueCallback(key) : key;
|
|
value = options.valueCallback ? (
|
|
// [TODO] -- I challenge you to fix the type
|
|
options.valueCallback(value)
|
|
) : value;
|
|
const rest = string.slice(matchedString.length);
|
|
return { value, rest };
|
|
};
|
|
}
|
|
function findKey(object, predicate) {
|
|
for (const key in object) {
|
|
if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
|
|
return key;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function findIndex(array, predicate) {
|
|
for (let key = 0; key < array.length; key++) {
|
|
if (predicate(array[key])) {
|
|
return key;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// node_modules/date-fns/locale/_lib/buildMatchPatternFn.js
|
|
function buildMatchPatternFn(args) {
|
|
return (string, options = {}) => {
|
|
const matchResult = string.match(args.matchPattern);
|
|
if (!matchResult) return null;
|
|
const matchedString = matchResult[0];
|
|
const parseResult = string.match(args.parsePattern);
|
|
if (!parseResult) return null;
|
|
let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
|
|
value = options.valueCallback ? options.valueCallback(value) : value;
|
|
const rest = string.slice(matchedString.length);
|
|
return { value, rest };
|
|
};
|
|
}
|
|
|
|
// node_modules/date-fns/locale/en-US/_lib/match.js
|
|
var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
|
|
var parseOrdinalNumberPattern = /\d+/i;
|
|
var matchEraPatterns = {
|
|
narrow: /^(b|a)/i,
|
|
abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
|
|
wide: /^(before christ|before common era|anno domini|common era)/i
|
|
};
|
|
var parseEraPatterns = {
|
|
any: [/^b/i, /^(a|c)/i]
|
|
};
|
|
var matchQuarterPatterns = {
|
|
narrow: /^[1234]/i,
|
|
abbreviated: /^q[1234]/i,
|
|
wide: /^[1234](th|st|nd|rd)? quarter/i
|
|
};
|
|
var parseQuarterPatterns = {
|
|
any: [/1/i, /2/i, /3/i, /4/i]
|
|
};
|
|
var matchMonthPatterns = {
|
|
narrow: /^[jfmasond]/i,
|
|
abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
|
|
wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
|
|
};
|
|
var parseMonthPatterns = {
|
|
narrow: [
|
|
/^j/i,
|
|
/^f/i,
|
|
/^m/i,
|
|
/^a/i,
|
|
/^m/i,
|
|
/^j/i,
|
|
/^j/i,
|
|
/^a/i,
|
|
/^s/i,
|
|
/^o/i,
|
|
/^n/i,
|
|
/^d/i
|
|
],
|
|
any: [
|
|
/^ja/i,
|
|
/^f/i,
|
|
/^mar/i,
|
|
/^ap/i,
|
|
/^may/i,
|
|
/^jun/i,
|
|
/^jul/i,
|
|
/^au/i,
|
|
/^s/i,
|
|
/^o/i,
|
|
/^n/i,
|
|
/^d/i
|
|
]
|
|
};
|
|
var matchDayPatterns = {
|
|
narrow: /^[smtwf]/i,
|
|
short: /^(su|mo|tu|we|th|fr|sa)/i,
|
|
abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
|
|
wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
|
|
};
|
|
var parseDayPatterns = {
|
|
narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
|
|
any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
|
|
};
|
|
var matchDayPeriodPatterns = {
|
|
narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
|
|
any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
|
|
};
|
|
var parseDayPeriodPatterns = {
|
|
any: {
|
|
am: /^a/i,
|
|
pm: /^p/i,
|
|
midnight: /^mi/i,
|
|
noon: /^no/i,
|
|
morning: /morning/i,
|
|
afternoon: /afternoon/i,
|
|
evening: /evening/i,
|
|
night: /night/i
|
|
}
|
|
};
|
|
var match = {
|
|
ordinalNumber: buildMatchPatternFn({
|
|
matchPattern: matchOrdinalNumberPattern,
|
|
parsePattern: parseOrdinalNumberPattern,
|
|
valueCallback: (value) => parseInt(value, 10)
|
|
}),
|
|
era: buildMatchFn({
|
|
matchPatterns: matchEraPatterns,
|
|
defaultMatchWidth: "wide",
|
|
parsePatterns: parseEraPatterns,
|
|
defaultParseWidth: "any"
|
|
}),
|
|
quarter: buildMatchFn({
|
|
matchPatterns: matchQuarterPatterns,
|
|
defaultMatchWidth: "wide",
|
|
parsePatterns: parseQuarterPatterns,
|
|
defaultParseWidth: "any",
|
|
valueCallback: (index) => index + 1
|
|
}),
|
|
month: buildMatchFn({
|
|
matchPatterns: matchMonthPatterns,
|
|
defaultMatchWidth: "wide",
|
|
parsePatterns: parseMonthPatterns,
|
|
defaultParseWidth: "any"
|
|
}),
|
|
day: buildMatchFn({
|
|
matchPatterns: matchDayPatterns,
|
|
defaultMatchWidth: "wide",
|
|
parsePatterns: parseDayPatterns,
|
|
defaultParseWidth: "any"
|
|
}),
|
|
dayPeriod: buildMatchFn({
|
|
matchPatterns: matchDayPeriodPatterns,
|
|
defaultMatchWidth: "any",
|
|
parsePatterns: parseDayPeriodPatterns,
|
|
defaultParseWidth: "any"
|
|
})
|
|
};
|
|
|
|
// node_modules/date-fns/getISOWeek.js
|
|
function getISOWeek(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
|
|
return Math.round(diff / millisecondsInWeek) + 1;
|
|
}
|
|
|
|
// node_modules/date-fns/getWeekYear.js
|
|
function getWeekYear(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const year = _date.getFullYear();
|
|
const defaultOptions2 = getDefaultOptions();
|
|
const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
|
|
const firstWeekOfNextYear = constructFrom(options?.in || date, 0);
|
|
firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
|
|
firstWeekOfNextYear.setHours(0, 0, 0, 0);
|
|
const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
|
|
const firstWeekOfThisYear = constructFrom(options?.in || date, 0);
|
|
firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
|
|
firstWeekOfThisYear.setHours(0, 0, 0, 0);
|
|
const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
|
|
if (+_date >= +startOfNextYear) {
|
|
return year + 1;
|
|
} else if (+_date >= +startOfThisYear) {
|
|
return year;
|
|
} else {
|
|
return year - 1;
|
|
}
|
|
}
|
|
|
|
// node_modules/date-fns/startOfWeekYear.js
|
|
function startOfWeekYear(date, options) {
|
|
const defaultOptions2 = getDefaultOptions();
|
|
const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
|
|
const year = getWeekYear(date, options);
|
|
const firstWeek = constructFrom(options?.in || date, 0);
|
|
firstWeek.setFullYear(year, 0, firstWeekContainsDate);
|
|
firstWeek.setHours(0, 0, 0, 0);
|
|
const _date = startOfWeek(firstWeek, options);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/getWeek.js
|
|
function getWeek(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
|
|
return Math.round(diff / millisecondsInWeek) + 1;
|
|
}
|
|
|
|
// node_modules/date-fns/getDate.js
|
|
function getDate(date, options) {
|
|
return toDate(date, options?.in).getDate();
|
|
}
|
|
|
|
// node_modules/date-fns/getDay.js
|
|
function getDay(date, options) {
|
|
return toDate(date, options?.in).getDay();
|
|
}
|
|
|
|
// node_modules/date-fns/getDaysInMonth.js
|
|
function getDaysInMonth(date, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const year = _date.getFullYear();
|
|
const monthIndex = _date.getMonth();
|
|
const lastDayOfMonth2 = constructFrom(_date, 0);
|
|
lastDayOfMonth2.setFullYear(year, monthIndex + 1, 0);
|
|
lastDayOfMonth2.setHours(0, 0, 0, 0);
|
|
return lastDayOfMonth2.getDate();
|
|
}
|
|
|
|
// node_modules/date-fns/getHours.js
|
|
function getHours(date, options) {
|
|
return toDate(date, options?.in).getHours();
|
|
}
|
|
|
|
// node_modules/date-fns/getISODay.js
|
|
function getISODay(date, options) {
|
|
const day = toDate(date, options?.in).getDay();
|
|
return day === 0 ? 7 : day;
|
|
}
|
|
|
|
// node_modules/date-fns/getMinutes.js
|
|
function getMinutes(date, options) {
|
|
return toDate(date, options?.in).getMinutes();
|
|
}
|
|
|
|
// node_modules/date-fns/getMonth.js
|
|
function getMonth(date, options) {
|
|
return toDate(date, options?.in).getMonth();
|
|
}
|
|
|
|
// node_modules/date-fns/getYear.js
|
|
function getYear(date, options) {
|
|
return toDate(date, options?.in).getFullYear();
|
|
}
|
|
|
|
// node_modules/date-fns/parse/_lib/Setter.js
|
|
var Setter = class {
|
|
subPriority = 0;
|
|
validate(_utcDate, _options) {
|
|
return true;
|
|
}
|
|
};
|
|
var ValueSetter = class 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(date, options) {
|
|
return this.validateValue(date, this.value, options);
|
|
}
|
|
set(date, flags, options) {
|
|
return this.setValue(date, flags, this.value, options);
|
|
}
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/Parser.js
|
|
var Parser = class {
|
|
run(dateString, token, match2, options) {
|
|
const result = this.parse(dateString, token, match2, 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;
|
|
}
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/EraParser.js
|
|
var EraParser = class extends Parser {
|
|
priority = 140;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
// AD, BC
|
|
case "G":
|
|
case "GG":
|
|
case "GGG":
|
|
return match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
|
|
// A, B
|
|
case "GGGGG":
|
|
return match2.era(dateString, { width: "narrow" });
|
|
// Anno Domini, Before Christ
|
|
case "GGGG":
|
|
default:
|
|
return match2.era(dateString, { width: "wide" }) || match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
|
|
}
|
|
}
|
|
set(date, flags, value) {
|
|
flags.era = value;
|
|
date.setFullYear(value, 0, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["R", "u", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/constants.js
|
|
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/
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/utils.js
|
|
function mapValue(parseFnResult, mapFn) {
|
|
if (!parseFnResult) {
|
|
return parseFnResult;
|
|
}
|
|
return {
|
|
value: mapFn(parseFnResult.value),
|
|
rest: parseFnResult.rest
|
|
};
|
|
}
|
|
function parseNumericPattern(pattern, dateString) {
|
|
const matchResult = dateString.match(pattern);
|
|
if (!matchResult) {
|
|
return null;
|
|
}
|
|
return {
|
|
value: parseInt(matchResult[0], 10),
|
|
rest: dateString.slice(matchResult[0].length)
|
|
};
|
|
}
|
|
function parseTimezonePattern(pattern, dateString) {
|
|
const matchResult = dateString.match(pattern);
|
|
if (!matchResult) {
|
|
return null;
|
|
}
|
|
if (matchResult[0] === "Z") {
|
|
return {
|
|
value: 0,
|
|
rest: dateString.slice(1)
|
|
};
|
|
}
|
|
const sign = matchResult[1] === "+" ? 1 : -1;
|
|
const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
|
|
const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
|
|
const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
|
|
return {
|
|
value: sign * (hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
|
|
rest: dateString.slice(matchResult[0].length)
|
|
};
|
|
}
|
|
function parseAnyDigitsSigned(dateString) {
|
|
return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
|
|
}
|
|
function parseNDigits(n, dateString) {
|
|
switch (n) {
|
|
case 1:
|
|
return parseNumericPattern(numericPatterns.singleDigit, dateString);
|
|
case 2:
|
|
return parseNumericPattern(numericPatterns.twoDigits, dateString);
|
|
case 3:
|
|
return parseNumericPattern(numericPatterns.threeDigits, dateString);
|
|
case 4:
|
|
return parseNumericPattern(numericPatterns.fourDigits, dateString);
|
|
default:
|
|
return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
|
|
}
|
|
}
|
|
function parseNDigitsSigned(n, dateString) {
|
|
switch (n) {
|
|
case 1:
|
|
return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
|
|
case 2:
|
|
return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
|
|
case 3:
|
|
return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
|
|
case 4:
|
|
return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
|
|
default:
|
|
return parseNumericPattern(new RegExp("^-?\\d{1," + n + "}"), dateString);
|
|
}
|
|
}
|
|
function dayPeriodEnumToHours(dayPeriod) {
|
|
switch (dayPeriod) {
|
|
case "morning":
|
|
return 4;
|
|
case "evening":
|
|
return 17;
|
|
case "pm":
|
|
case "noon":
|
|
case "afternoon":
|
|
return 12;
|
|
case "am":
|
|
case "midnight":
|
|
case "night":
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
function normalizeTwoDigitYear(twoDigitYear, currentYear) {
|
|
const isCommonEra = currentYear > 0;
|
|
const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
|
|
let result;
|
|
if (absCurrentYear <= 50) {
|
|
result = twoDigitYear || 100;
|
|
} else {
|
|
const rangeEnd = absCurrentYear + 50;
|
|
const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
|
|
const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
|
|
result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
|
|
}
|
|
return isCommonEra ? result : 1 - result;
|
|
}
|
|
function isLeapYearIndex(year) {
|
|
return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
|
|
}
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/YearParser.js
|
|
var YearParser = class extends Parser {
|
|
priority = 130;
|
|
incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
|
|
parse(dateString, token, match2) {
|
|
const valueCallback = (year) => ({
|
|
year,
|
|
isTwoDigitYear: token === "yy"
|
|
});
|
|
switch (token) {
|
|
case "y":
|
|
return mapValue(parseNDigits(4, dateString), valueCallback);
|
|
case "yo":
|
|
return mapValue(
|
|
match2.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) {
|
|
const currentYear = date.getFullYear();
|
|
if (value.isTwoDigitYear) {
|
|
const normalizedTwoDigitYear = normalizeTwoDigitYear(
|
|
value.year,
|
|
currentYear
|
|
);
|
|
date.setFullYear(normalizedTwoDigitYear, 0, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
|
|
date.setFullYear(year, 0, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.js
|
|
var LocalWeekYearParser = class extends Parser {
|
|
priority = 130;
|
|
parse(dateString, token, match2) {
|
|
const valueCallback = (year) => ({
|
|
year,
|
|
isTwoDigitYear: token === "YY"
|
|
});
|
|
switch (token) {
|
|
case "Y":
|
|
return mapValue(parseNDigits(4, dateString), valueCallback);
|
|
case "Yo":
|
|
return mapValue(
|
|
match2.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) {
|
|
const currentYear = getWeekYear(date, options);
|
|
if (value.isTwoDigitYear) {
|
|
const normalizedTwoDigitYear = normalizeTwoDigitYear(
|
|
value.year,
|
|
currentYear
|
|
);
|
|
date.setFullYear(
|
|
normalizedTwoDigitYear,
|
|
0,
|
|
options.firstWeekContainsDate
|
|
);
|
|
date.setHours(0, 0, 0, 0);
|
|
return startOfWeek(date, options);
|
|
}
|
|
const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
|
|
date.setFullYear(year, 0, options.firstWeekContainsDate);
|
|
date.setHours(0, 0, 0, 0);
|
|
return startOfWeek(date, options);
|
|
}
|
|
incompatibleTokens = [
|
|
"y",
|
|
"R",
|
|
"u",
|
|
"Q",
|
|
"q",
|
|
"M",
|
|
"L",
|
|
"I",
|
|
"d",
|
|
"D",
|
|
"i",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.js
|
|
var ISOWeekYearParser = class extends Parser {
|
|
priority = 130;
|
|
parse(dateString, token) {
|
|
if (token === "R") {
|
|
return parseNDigitsSigned(4, dateString);
|
|
}
|
|
return parseNDigitsSigned(token.length, dateString);
|
|
}
|
|
set(date, _flags, value) {
|
|
const firstWeekOfYear = constructFrom(date, 0);
|
|
firstWeekOfYear.setFullYear(value, 0, 4);
|
|
firstWeekOfYear.setHours(0, 0, 0, 0);
|
|
return startOfISOWeek(firstWeekOfYear);
|
|
}
|
|
incompatibleTokens = [
|
|
"G",
|
|
"y",
|
|
"Y",
|
|
"u",
|
|
"Q",
|
|
"q",
|
|
"M",
|
|
"L",
|
|
"w",
|
|
"d",
|
|
"D",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.js
|
|
var ExtendedYearParser = class extends Parser {
|
|
priority = 130;
|
|
parse(dateString, token) {
|
|
if (token === "u") {
|
|
return parseNDigitsSigned(4, dateString);
|
|
}
|
|
return parseNDigitsSigned(token.length, dateString);
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setFullYear(value, 0, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/QuarterParser.js
|
|
var QuarterParser = class extends Parser {
|
|
priority = 120;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
// 1, 2, 3, 4
|
|
case "Q":
|
|
case "QQ":
|
|
return parseNDigits(token.length, dateString);
|
|
// 1st, 2nd, 3rd, 4th
|
|
case "Qo":
|
|
return match2.ordinalNumber(dateString, { unit: "quarter" });
|
|
// Q1, Q2, Q3, Q4
|
|
case "QQQ":
|
|
return match2.quarter(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.quarter(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
|
|
case "QQQQQ":
|
|
return match2.quarter(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
// 1st quarter, 2nd quarter, ...
|
|
case "QQQQ":
|
|
default:
|
|
return match2.quarter(dateString, {
|
|
width: "wide",
|
|
context: "formatting"
|
|
}) || match2.quarter(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.quarter(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 4;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMonth((value - 1) * 3, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"Y",
|
|
"R",
|
|
"q",
|
|
"M",
|
|
"L",
|
|
"w",
|
|
"I",
|
|
"d",
|
|
"D",
|
|
"i",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/StandAloneQuarterParser.js
|
|
var StandAloneQuarterParser = class extends Parser {
|
|
priority = 120;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
// 1, 2, 3, 4
|
|
case "q":
|
|
case "qq":
|
|
return parseNDigits(token.length, dateString);
|
|
// 1st, 2nd, 3rd, 4th
|
|
case "qo":
|
|
return match2.ordinalNumber(dateString, { unit: "quarter" });
|
|
// Q1, Q2, Q3, Q4
|
|
case "qqq":
|
|
return match2.quarter(dateString, {
|
|
width: "abbreviated",
|
|
context: "standalone"
|
|
}) || match2.quarter(dateString, {
|
|
width: "narrow",
|
|
context: "standalone"
|
|
});
|
|
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
|
|
case "qqqqq":
|
|
return match2.quarter(dateString, {
|
|
width: "narrow",
|
|
context: "standalone"
|
|
});
|
|
// 1st quarter, 2nd quarter, ...
|
|
case "qqqq":
|
|
default:
|
|
return match2.quarter(dateString, {
|
|
width: "wide",
|
|
context: "standalone"
|
|
}) || match2.quarter(dateString, {
|
|
width: "abbreviated",
|
|
context: "standalone"
|
|
}) || match2.quarter(dateString, {
|
|
width: "narrow",
|
|
context: "standalone"
|
|
});
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 4;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMonth((value - 1) * 3, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"Y",
|
|
"R",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"w",
|
|
"I",
|
|
"d",
|
|
"D",
|
|
"i",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/MonthParser.js
|
|
var MonthParser = class extends Parser {
|
|
incompatibleTokens = [
|
|
"Y",
|
|
"R",
|
|
"q",
|
|
"Q",
|
|
"L",
|
|
"w",
|
|
"I",
|
|
"D",
|
|
"i",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
priority = 110;
|
|
parse(dateString, token, match2) {
|
|
const valueCallback = (value) => 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(
|
|
match2.ordinalNumber(dateString, {
|
|
unit: "month"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// Jan, Feb, ..., Dec
|
|
case "MMM":
|
|
return match2.month(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.month(dateString, { width: "narrow", context: "formatting" });
|
|
// J, F, ..., D
|
|
case "MMMMM":
|
|
return match2.month(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
// January, February, ..., December
|
|
case "MMMM":
|
|
default:
|
|
return match2.month(dateString, { width: "wide", context: "formatting" }) || match2.month(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.month(dateString, { width: "narrow", context: "formatting" });
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 11;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMonth(value, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/StandAloneMonthParser.js
|
|
var StandAloneMonthParser = class extends Parser {
|
|
priority = 110;
|
|
parse(dateString, token, match2) {
|
|
const valueCallback = (value) => value - 1;
|
|
switch (token) {
|
|
// 1, 2, ..., 12
|
|
case "L":
|
|
return mapValue(
|
|
parseNumericPattern(numericPatterns.month, dateString),
|
|
valueCallback
|
|
);
|
|
// 01, 02, ..., 12
|
|
case "LL":
|
|
return mapValue(parseNDigits(2, dateString), valueCallback);
|
|
// 1st, 2nd, ..., 12th
|
|
case "Lo":
|
|
return mapValue(
|
|
match2.ordinalNumber(dateString, {
|
|
unit: "month"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// Jan, Feb, ..., Dec
|
|
case "LLL":
|
|
return match2.month(dateString, {
|
|
width: "abbreviated",
|
|
context: "standalone"
|
|
}) || match2.month(dateString, { width: "narrow", context: "standalone" });
|
|
// J, F, ..., D
|
|
case "LLLLL":
|
|
return match2.month(dateString, {
|
|
width: "narrow",
|
|
context: "standalone"
|
|
});
|
|
// January, February, ..., December
|
|
case "LLLL":
|
|
default:
|
|
return match2.month(dateString, { width: "wide", context: "standalone" }) || match2.month(dateString, {
|
|
width: "abbreviated",
|
|
context: "standalone"
|
|
}) || match2.month(dateString, { width: "narrow", context: "standalone" });
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 11;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMonth(value, 1);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"Y",
|
|
"R",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"w",
|
|
"I",
|
|
"D",
|
|
"i",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/setWeek.js
|
|
function setWeek(date, week, options) {
|
|
const date_ = toDate(date, options?.in);
|
|
const diff = getWeek(date_, options) - week;
|
|
date_.setDate(date_.getDate() - diff * 7);
|
|
return toDate(date_, options?.in);
|
|
}
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.js
|
|
var LocalWeekParser = class extends Parser {
|
|
priority = 100;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "w":
|
|
return parseNumericPattern(numericPatterns.week, dateString);
|
|
case "wo":
|
|
return match2.ordinalNumber(dateString, { unit: "week" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 53;
|
|
}
|
|
set(date, _flags, value, options) {
|
|
return startOfWeek(setWeek(date, value, options), options);
|
|
}
|
|
incompatibleTokens = [
|
|
"y",
|
|
"R",
|
|
"u",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"I",
|
|
"d",
|
|
"D",
|
|
"i",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/setISOWeek.js
|
|
function setISOWeek(date, week, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const diff = getISOWeek(_date, options) - week;
|
|
_date.setDate(_date.getDate() - diff * 7);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.js
|
|
var ISOWeekParser = class extends Parser {
|
|
priority = 100;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "I":
|
|
return parseNumericPattern(numericPatterns.week, dateString);
|
|
case "Io":
|
|
return match2.ordinalNumber(dateString, { unit: "week" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 53;
|
|
}
|
|
set(date, _flags, value) {
|
|
return startOfISOWeek(setISOWeek(date, value));
|
|
}
|
|
incompatibleTokens = [
|
|
"y",
|
|
"Y",
|
|
"u",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"w",
|
|
"d",
|
|
"D",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/DateParser.js
|
|
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
|
|
];
|
|
var DateParser = class extends Parser {
|
|
priority = 90;
|
|
subPriority = 1;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "d":
|
|
return parseNumericPattern(numericPatterns.date, dateString);
|
|
case "do":
|
|
return match2.ordinalNumber(dateString, { unit: "date" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(date, value) {
|
|
const year = date.getFullYear();
|
|
const isLeapYear2 = isLeapYearIndex(year);
|
|
const month = date.getMonth();
|
|
if (isLeapYear2) {
|
|
return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
|
|
} else {
|
|
return value >= 1 && value <= DAYS_IN_MONTH[month];
|
|
}
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setDate(value);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"Y",
|
|
"R",
|
|
"q",
|
|
"Q",
|
|
"w",
|
|
"I",
|
|
"D",
|
|
"i",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.js
|
|
var DayOfYearParser = class extends Parser {
|
|
priority = 90;
|
|
subpriority = 1;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "D":
|
|
case "DD":
|
|
return parseNumericPattern(numericPatterns.dayOfYear, dateString);
|
|
case "Do":
|
|
return match2.ordinalNumber(dateString, { unit: "date" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(date, value) {
|
|
const year = date.getFullYear();
|
|
const isLeapYear2 = isLeapYearIndex(year);
|
|
if (isLeapYear2) {
|
|
return value >= 1 && value <= 366;
|
|
} else {
|
|
return value >= 1 && value <= 365;
|
|
}
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMonth(0, value);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"Y",
|
|
"R",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"w",
|
|
"I",
|
|
"d",
|
|
"E",
|
|
"i",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/setDay.js
|
|
function setDay(date, day, options) {
|
|
const defaultOptions2 = getDefaultOptions();
|
|
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
|
|
const date_ = toDate(date, options?.in);
|
|
const currentDay = date_.getDay();
|
|
const remainder = day % 7;
|
|
const dayIndex = (remainder + 7) % 7;
|
|
const delta = 7 - weekStartsOn;
|
|
const diff = day < 0 || day > 6 ? day - (currentDay + delta) % 7 : (dayIndex + delta) % 7 - (currentDay + delta) % 7;
|
|
return addDays(date_, diff, options);
|
|
}
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/DayParser.js
|
|
var DayParser = class extends Parser {
|
|
priority = 90;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
// Tue
|
|
case "E":
|
|
case "EE":
|
|
case "EEE":
|
|
return match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
|
|
// T
|
|
case "EEEEE":
|
|
return match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
// Tu
|
|
case "EEEEEE":
|
|
return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
|
|
// Tuesday
|
|
case "EEEE":
|
|
default:
|
|
return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 6;
|
|
}
|
|
set(date, _flags, value, options) {
|
|
date = setDay(date, value, options);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/LocalDayParser.js
|
|
var LocalDayParser = class extends Parser {
|
|
priority = 90;
|
|
parse(dateString, token, match2, options) {
|
|
const valueCallback = (value) => {
|
|
const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
|
|
return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
|
|
};
|
|
switch (token) {
|
|
// 3
|
|
case "e":
|
|
case "ee":
|
|
return mapValue(parseNDigits(token.length, dateString), valueCallback);
|
|
// 3rd
|
|
case "eo":
|
|
return mapValue(
|
|
match2.ordinalNumber(dateString, {
|
|
unit: "day"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// Tue
|
|
case "eee":
|
|
return match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
|
|
// T
|
|
case "eeeee":
|
|
return match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
// Tu
|
|
case "eeeeee":
|
|
return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
|
|
// Tuesday
|
|
case "eeee":
|
|
default:
|
|
return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 6;
|
|
}
|
|
set(date, _flags, value, options) {
|
|
date = setDay(date, value, options);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"y",
|
|
"R",
|
|
"u",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"I",
|
|
"d",
|
|
"D",
|
|
"E",
|
|
"i",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/StandAloneLocalDayParser.js
|
|
var StandAloneLocalDayParser = class extends Parser {
|
|
priority = 90;
|
|
parse(dateString, token, match2, options) {
|
|
const valueCallback = (value) => {
|
|
const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
|
|
return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
|
|
};
|
|
switch (token) {
|
|
// 3
|
|
case "c":
|
|
case "cc":
|
|
return mapValue(parseNDigits(token.length, dateString), valueCallback);
|
|
// 3rd
|
|
case "co":
|
|
return mapValue(
|
|
match2.ordinalNumber(dateString, {
|
|
unit: "day"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// Tue
|
|
case "ccc":
|
|
return match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "standalone"
|
|
}) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
|
|
// T
|
|
case "ccccc":
|
|
return match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "standalone"
|
|
});
|
|
// Tu
|
|
case "cccccc":
|
|
return match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
|
|
// Tuesday
|
|
case "cccc":
|
|
default:
|
|
return match2.day(dateString, { width: "wide", context: "standalone" }) || match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "standalone"
|
|
}) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 6;
|
|
}
|
|
set(date, _flags, value, options) {
|
|
date = setDay(date, value, options);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"y",
|
|
"R",
|
|
"u",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"I",
|
|
"d",
|
|
"D",
|
|
"E",
|
|
"i",
|
|
"e",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/setISODay.js
|
|
function setISODay(date, day, options) {
|
|
const date_ = toDate(date, options?.in);
|
|
const currentDay = getISODay(date_, options);
|
|
const diff = day - currentDay;
|
|
return addDays(date_, diff, options);
|
|
}
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/ISODayParser.js
|
|
var ISODayParser = class extends Parser {
|
|
priority = 90;
|
|
parse(dateString, token, match2) {
|
|
const valueCallback = (value) => {
|
|
if (value === 0) {
|
|
return 7;
|
|
}
|
|
return value;
|
|
};
|
|
switch (token) {
|
|
// 2
|
|
case "i":
|
|
case "ii":
|
|
return parseNDigits(token.length, dateString);
|
|
// 2nd
|
|
case "io":
|
|
return match2.ordinalNumber(dateString, { unit: "day" });
|
|
// Tue
|
|
case "iii":
|
|
return mapValue(
|
|
match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, {
|
|
width: "short",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// T
|
|
case "iiiii":
|
|
return mapValue(
|
|
match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// Tu
|
|
case "iiiiii":
|
|
return mapValue(
|
|
match2.day(dateString, {
|
|
width: "short",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
}),
|
|
valueCallback
|
|
);
|
|
// Tuesday
|
|
case "iiii":
|
|
default:
|
|
return mapValue(
|
|
match2.day(dateString, {
|
|
width: "wide",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, {
|
|
width: "short",
|
|
context: "formatting"
|
|
}) || match2.day(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
}),
|
|
valueCallback
|
|
);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 7;
|
|
}
|
|
set(date, _flags, value) {
|
|
date = setISODay(date, value);
|
|
date.setHours(0, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = [
|
|
"y",
|
|
"Y",
|
|
"u",
|
|
"q",
|
|
"Q",
|
|
"M",
|
|
"L",
|
|
"w",
|
|
"d",
|
|
"D",
|
|
"E",
|
|
"e",
|
|
"c",
|
|
"t",
|
|
"T"
|
|
];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/AMPMParser.js
|
|
var AMPMParser = class extends Parser {
|
|
priority = 80;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "a":
|
|
case "aa":
|
|
case "aaa":
|
|
return match2.dayPeriod(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
case "aaaaa":
|
|
return match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
case "aaaa":
|
|
default:
|
|
return match2.dayPeriod(dateString, {
|
|
width: "wide",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
}
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.js
|
|
var AMPMMidnightParser = class extends Parser {
|
|
priority = 80;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "b":
|
|
case "bb":
|
|
case "bbb":
|
|
return match2.dayPeriod(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
case "bbbbb":
|
|
return match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
case "bbbb":
|
|
default:
|
|
return match2.dayPeriod(dateString, {
|
|
width: "wide",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
}
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.js
|
|
var DayPeriodParser = class extends Parser {
|
|
priority = 80;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "B":
|
|
case "BB":
|
|
case "BBB":
|
|
return match2.dayPeriod(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
case "BBBBB":
|
|
return match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
case "BBBB":
|
|
default:
|
|
return match2.dayPeriod(dateString, {
|
|
width: "wide",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "abbreviated",
|
|
context: "formatting"
|
|
}) || match2.dayPeriod(dateString, {
|
|
width: "narrow",
|
|
context: "formatting"
|
|
});
|
|
}
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["a", "b", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.js
|
|
var Hour1to12Parser = class extends Parser {
|
|
priority = 70;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "h":
|
|
return parseNumericPattern(numericPatterns.hour12h, dateString);
|
|
case "ho":
|
|
return match2.ordinalNumber(dateString, { unit: "hour" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 12;
|
|
}
|
|
set(date, _flags, value) {
|
|
const isPM = date.getHours() >= 12;
|
|
if (isPM && value < 12) {
|
|
date.setHours(value + 12, 0, 0, 0);
|
|
} else if (!isPM && value === 12) {
|
|
date.setHours(0, 0, 0, 0);
|
|
} else {
|
|
date.setHours(value, 0, 0, 0);
|
|
}
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["H", "K", "k", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.js
|
|
var Hour0to23Parser = class extends Parser {
|
|
priority = 70;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "H":
|
|
return parseNumericPattern(numericPatterns.hour23h, dateString);
|
|
case "Ho":
|
|
return match2.ordinalNumber(dateString, { unit: "hour" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 23;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setHours(value, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.js
|
|
var Hour0To11Parser = class extends Parser {
|
|
priority = 70;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "K":
|
|
return parseNumericPattern(numericPatterns.hour11h, dateString);
|
|
case "Ko":
|
|
return match2.ordinalNumber(dateString, { unit: "hour" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 11;
|
|
}
|
|
set(date, _flags, value) {
|
|
const isPM = date.getHours() >= 12;
|
|
if (isPM && value < 12) {
|
|
date.setHours(value + 12, 0, 0, 0);
|
|
} else {
|
|
date.setHours(value, 0, 0, 0);
|
|
}
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["h", "H", "k", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.js
|
|
var Hour1To24Parser = class extends Parser {
|
|
priority = 70;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "k":
|
|
return parseNumericPattern(numericPatterns.hour24h, dateString);
|
|
case "ko":
|
|
return match2.ordinalNumber(dateString, { unit: "hour" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 1 && value <= 24;
|
|
}
|
|
set(date, _flags, value) {
|
|
const hours = value <= 24 ? value % 24 : value;
|
|
date.setHours(hours, 0, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/MinuteParser.js
|
|
var MinuteParser = class extends Parser {
|
|
priority = 60;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "m":
|
|
return parseNumericPattern(numericPatterns.minute, dateString);
|
|
case "mo":
|
|
return match2.ordinalNumber(dateString, { unit: "minute" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 59;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMinutes(value, 0, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/SecondParser.js
|
|
var SecondParser = class extends Parser {
|
|
priority = 50;
|
|
parse(dateString, token, match2) {
|
|
switch (token) {
|
|
case "s":
|
|
return parseNumericPattern(numericPatterns.second, dateString);
|
|
case "so":
|
|
return match2.ordinalNumber(dateString, { unit: "second" });
|
|
default:
|
|
return parseNDigits(token.length, dateString);
|
|
}
|
|
}
|
|
validate(_date, value) {
|
|
return value >= 0 && value <= 59;
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setSeconds(value, 0);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.js
|
|
var FractionOfSecondParser = class extends Parser {
|
|
priority = 30;
|
|
parse(dateString, token) {
|
|
const valueCallback = (value) => Math.trunc(value * Math.pow(10, -token.length + 3));
|
|
return mapValue(parseNDigits(token.length, dateString), valueCallback);
|
|
}
|
|
set(date, _flags, value) {
|
|
date.setMilliseconds(value);
|
|
return date;
|
|
}
|
|
incompatibleTokens = ["t", "T"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.js
|
|
var ISOTimezoneWithZParser = class extends Parser {
|
|
priority = 10;
|
|
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 constructFrom(
|
|
date,
|
|
date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
|
|
);
|
|
}
|
|
incompatibleTokens = ["t", "T", "x"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.js
|
|
var ISOTimezoneParser = class extends Parser {
|
|
priority = 10;
|
|
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 constructFrom(
|
|
date,
|
|
date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
|
|
);
|
|
}
|
|
incompatibleTokens = ["t", "T", "X"];
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/TimestampSecondsParser.js
|
|
var TimestampSecondsParser = class extends Parser {
|
|
priority = 40;
|
|
parse(dateString) {
|
|
return parseAnyDigitsSigned(dateString);
|
|
}
|
|
set(date, _flags, value) {
|
|
return [constructFrom(date, value * 1e3), { timestampIsSet: true }];
|
|
}
|
|
incompatibleTokens = "*";
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers/TimestampMillisecondsParser.js
|
|
var TimestampMillisecondsParser = class extends Parser {
|
|
priority = 20;
|
|
parse(dateString) {
|
|
return parseAnyDigitsSigned(dateString);
|
|
}
|
|
set(date, _flags, value) {
|
|
return [constructFrom(date, value), { timestampIsSet: true }];
|
|
}
|
|
incompatibleTokens = "*";
|
|
};
|
|
|
|
// node_modules/date-fns/parse/_lib/parsers.js
|
|
var parsers = {
|
|
G: new EraParser(),
|
|
y: new YearParser(),
|
|
Y: new LocalWeekYearParser(),
|
|
R: new ISOWeekYearParser(),
|
|
u: new ExtendedYearParser(),
|
|
Q: new QuarterParser(),
|
|
q: new StandAloneQuarterParser(),
|
|
M: new MonthParser(),
|
|
L: new StandAloneMonthParser(),
|
|
w: new LocalWeekParser(),
|
|
I: new ISOWeekParser(),
|
|
d: new DateParser(),
|
|
D: new DayOfYearParser(),
|
|
E: new DayParser(),
|
|
e: new LocalDayParser(),
|
|
c: new StandAloneLocalDayParser(),
|
|
i: new ISODayParser(),
|
|
a: new AMPMParser(),
|
|
b: new AMPMMidnightParser(),
|
|
B: new DayPeriodParser(),
|
|
h: new Hour1to12Parser(),
|
|
H: new Hour0to23Parser(),
|
|
K: new Hour0To11Parser(),
|
|
k: new Hour1To24Parser(),
|
|
m: new MinuteParser(),
|
|
s: new SecondParser(),
|
|
S: new FractionOfSecondParser(),
|
|
X: new ISOTimezoneWithZParser(),
|
|
x: new ISOTimezoneParser(),
|
|
t: new TimestampSecondsParser(),
|
|
T: new TimestampMillisecondsParser()
|
|
};
|
|
|
|
// node_modules/date-fns/startOfMinute.js
|
|
function startOfMinute(date, options) {
|
|
const date_ = toDate(date, options?.in);
|
|
date_.setSeconds(0, 0);
|
|
return date_;
|
|
}
|
|
|
|
// node_modules/date-fns/isSameMonth.js
|
|
function isSameMonth(laterDate, earlierDate, options) {
|
|
const [laterDate_, earlierDate_] = normalizeDates(
|
|
options?.in,
|
|
laterDate,
|
|
earlierDate
|
|
);
|
|
return laterDate_.getFullYear() === earlierDate_.getFullYear() && laterDate_.getMonth() === earlierDate_.getMonth();
|
|
}
|
|
|
|
// node_modules/date-fns/startOfSecond.js
|
|
function startOfSecond(date, options) {
|
|
const date_ = toDate(date, options?.in);
|
|
date_.setMilliseconds(0);
|
|
return date_;
|
|
}
|
|
|
|
// node_modules/date-fns/isSameSecond.js
|
|
function isSameSecond(laterDate, earlierDate) {
|
|
return +startOfSecond(laterDate) === +startOfSecond(earlierDate);
|
|
}
|
|
|
|
// node_modules/date-fns/subDays.js
|
|
function subDays(date, amount, options) {
|
|
return addDays(date, -amount, options);
|
|
}
|
|
|
|
// node_modules/date-fns/setMonth.js
|
|
function setMonth(date, month, options) {
|
|
const _date = toDate(date, options?.in);
|
|
const year = _date.getFullYear();
|
|
const day = _date.getDate();
|
|
const midMonth = constructFrom(options?.in || date, 0);
|
|
midMonth.setFullYear(year, month, 15);
|
|
midMonth.setHours(0, 0, 0, 0);
|
|
const daysInMonth = getDaysInMonth(midMonth);
|
|
_date.setMonth(month, Math.min(day, daysInMonth));
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/setDate.js
|
|
function setDate(date, dayOfMonth, options) {
|
|
const _date = toDate(date, options?.in);
|
|
_date.setDate(dayOfMonth);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/setHours.js
|
|
function setHours(date, hours, options) {
|
|
const _date = toDate(date, options?.in);
|
|
_date.setHours(hours);
|
|
return _date;
|
|
}
|
|
|
|
// node_modules/date-fns/setMinutes.js
|
|
function setMinutes(date, minutes, options) {
|
|
const date_ = toDate(date, options?.in);
|
|
date_.setMinutes(minutes);
|
|
return date_;
|
|
}
|
|
|
|
// node_modules/date-fns/setYear.js
|
|
function setYear(date, year, options) {
|
|
const date_ = toDate(date, options?.in);
|
|
if (isNaN(+date_)) return constructFrom(options?.in || date, NaN);
|
|
date_.setFullYear(year);
|
|
return date_;
|
|
}
|
|
|
|
// node_modules/date-fns/subMonths.js
|
|
function subMonths(date, amount, options) {
|
|
return addMonths(date, -amount, options);
|
|
}
|
|
|
|
// node_modules/date-fns/subWeeks.js
|
|
function subWeeks(date, amount, options) {
|
|
return addWeeks(date, -amount, options);
|
|
}
|
|
|
|
// node_modules/calendar-utils/date-adapters/esm/date-fns/index.js
|
|
function getTimezoneOffset(date) {
|
|
return new Date(date).getTimezoneOffset();
|
|
}
|
|
function adapterFactory() {
|
|
return {
|
|
addDays,
|
|
addHours,
|
|
addMinutes,
|
|
addSeconds,
|
|
differenceInDays,
|
|
differenceInMinutes,
|
|
differenceInSeconds,
|
|
endOfDay,
|
|
endOfMonth,
|
|
endOfWeek,
|
|
getDay,
|
|
getMonth,
|
|
isSameDay,
|
|
isSameMonth,
|
|
isSameSecond,
|
|
max,
|
|
setHours,
|
|
setMinutes,
|
|
startOfDay,
|
|
startOfMinute,
|
|
startOfMonth,
|
|
startOfWeek,
|
|
getHours,
|
|
getMinutes,
|
|
getTimezoneOffset
|
|
};
|
|
}
|
|
|
|
// node_modules/angular-calendar/date-adapters/esm/date-fns/index.js
|
|
function adapterFactory2() {
|
|
return Object.assign(Object.assign({}, adapterFactory()), {
|
|
addWeeks,
|
|
addMonths,
|
|
subDays,
|
|
subWeeks,
|
|
subMonths,
|
|
getISOWeek,
|
|
setDate,
|
|
setMonth,
|
|
setYear,
|
|
getDate,
|
|
getYear
|
|
});
|
|
}
|
|
export {
|
|
adapterFactory2 as adapterFactory
|
|
};
|
|
//# sourceMappingURL=angular-calendar_date-adapters_date-fns.js.map
|