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