@wirekyt/dom 0.0.1 → 0.0.2

package/dist/date-utils-D-JJHedx.cjs

@@ -0,0 +1,868 @@
+let _internationalized_date = require("@internationalized/date");
+//#region src/common/date-utils/constrain.ts
+function alignCenter(date, duration, locale, min, max) {
+	const halfDuration = {};
+	for (let prop in duration) {
+		const key = prop;
+		const value = duration[key];
+		if (value == null) continue;
+		halfDuration[key] = Math.floor(value / 2);
+		if (halfDuration[key] > 0 && value % 2 === 0) halfDuration[key]--;
+	}
+	return constrainStart(date, alignStart(date, duration, locale).subtract(halfDuration), duration, locale, min, max);
+}
+function alignStart(date, duration, locale, min, max) {
+	let aligned = date;
+	if (duration.years) aligned = (0, _internationalized_date.startOfYear)(date);
+	else if (duration.months) aligned = (0, _internationalized_date.startOfMonth)(date);
+	else if (duration.weeks) aligned = (0, _internationalized_date.startOfWeek)(date, locale);
+	return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignEnd(date, duration, locale, min, max) {
+	let d = { ...duration };
+	if (d.days) d.days--;
+	else if (d.weeks) d.weeks--;
+	else if (d.months) d.months--;
+	else if (d.years) d.years--;
+	return constrainStart(date, alignStart(date, duration, locale).subtract(d), duration, locale, min, max);
+}
+function constrainStart(date, aligned, duration, locale, min, max) {
+	if (min && date.compare(min) >= 0) aligned = (0, _internationalized_date.maxDate)(aligned, alignStart((0, _internationalized_date.toCalendarDate)(min), duration, locale));
+	if (max && date.compare(max) <= 0) aligned = (0, _internationalized_date.minDate)(aligned, alignEnd((0, _internationalized_date.toCalendarDate)(max), duration, locale));
+	return aligned;
+}
+function constrainValue(date, minValue, maxValue) {
+	const dateOnly = (0, _internationalized_date.toCalendarDate)(date);
+	const minOnly = minValue ? (0, _internationalized_date.toCalendarDate)(minValue) : void 0;
+	const maxOnly = maxValue ? (0, _internationalized_date.toCalendarDate)(maxValue) : void 0;
+	let constrainedDateOnly = dateOnly;
+	if (minOnly) constrainedDateOnly = (0, _internationalized_date.maxDate)(constrainedDateOnly, minOnly);
+	if (maxOnly) constrainedDateOnly = (0, _internationalized_date.minDate)(constrainedDateOnly, maxOnly);
+	if (constrainedDateOnly.compare(dateOnly) === 0) return date;
+	if ("hour" in date) return date.set({
+		year: constrainedDateOnly.year,
+		month: constrainedDateOnly.month,
+		day: constrainedDateOnly.day
+	});
+	return constrainedDateOnly;
+}
+function constrainSegments(date, minValue, maxValue) {
+	const dateOnly = (0, _internationalized_date.toCalendarDate)(date);
+	const minOnly = minValue ? (0, _internationalized_date.toCalendarDate)(minValue) : void 0;
+	const maxOnly = maxValue ? (0, _internationalized_date.toCalendarDate)(maxValue) : void 0;
+	let result = dateOnly;
+	if (minOnly && result.compare(minOnly) < 0) {
+		if (result.year < minOnly.year) result = result.set({ year: minOnly.year });
+		if (result.compare(minOnly) < 0 && result.month < minOnly.month) result = result.set({ month: minOnly.month });
+		if (result.compare(minOnly) < 0 && result.day < minOnly.day) result = result.set({ day: minOnly.day });
+	}
+	if (maxOnly && result.compare(maxOnly) > 0) {
+		if (result.year > maxOnly.year) result = result.set({ year: maxOnly.year });
+		if (result.compare(maxOnly) > 0 && result.month > maxOnly.month) result = result.set({ month: maxOnly.month });
+		if (result.compare(maxOnly) > 0 && result.day > maxOnly.day) result = result.set({ day: maxOnly.day });
+	}
+	if (result.compare(dateOnly) === 0) return date;
+	if ("hour" in date) return date.set({
+		year: result.year,
+		month: result.month,
+		day: result.day
+	});
+	return result;
+}
+//#endregion
+//#region src/common/date-utils/align.ts
+function alignDate(date, alignment, duration, locale, min, max) {
+	switch (alignment) {
+		case "start": return alignStart(date, duration, locale, min, max);
+		case "end": return alignEnd(date, duration, locale, min, max);
+		default: return alignCenter(date, duration, locale, min, max);
+	}
+}
+function alignStartDate(date, startDate, endDate, duration, locale, min, max) {
+	if (date.compare(startDate) < 0) return alignEnd(date, duration, locale, min, max);
+	if (date.compare(endDate) > 0) return alignStart(date, duration, locale, min, max);
+	return startDate;
+}
+//#endregion
+//#region src/common/date-utils/assertion.ts
+function isDateEqual(dateA, dateB) {
+	if (dateA == null || dateB == null) return dateA === dateB;
+	if (!("hour" in dateA) && !("hour" in dateB)) return (0, _internationalized_date.isSameDay)(dateA, dateB);
+	return (0, _internationalized_date.toCalendarDateTime)(dateA).compare((0, _internationalized_date.toCalendarDateTime)(dateB)) === 0;
+}
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
+	if (!date) return false;
+	if (isUnavailable?.(date, locale)) return true;
+	return isDateOutsideRange(date, minValue, maxValue);
+}
+function isDateOutsideRange(date, startDate, endDate) {
+	return startDate != null && date.compare(startDate) < 0 || endDate != null && date.compare(endDate) > 0;
+}
+function isPreviousRangeInvalid(startDate, minValue, maxValue) {
+	const prevDate = startDate.subtract({ days: 1 });
+	return (0, _internationalized_date.isSameDay)(prevDate, startDate) || isDateOutsideRange(prevDate, minValue, maxValue);
+}
+function isNextRangeInvalid(endDate, minValue, maxValue) {
+	const nextDate = endDate.add({ days: 1 });
+	return (0, _internationalized_date.isSameDay)(nextDate, endDate) || isDateOutsideRange(nextDate, minValue, maxValue);
+}
+//#endregion
+//#region src/common/date-utils/duration.ts
+function getUnitDuration(duration) {
+	let clone = { ...duration };
+	for (let key in clone) clone[key] = 1;
+	return clone;
+}
+function getEndDate(startDate, duration) {
+	let clone = { ...duration };
+	if (clone.days) clone.days--;
+	else clone.days = -1;
+	return startDate.add(clone);
+}
+//#endregion
+//#region src/common/date-utils/get-era-format.ts
+function getEraFormat(date) {
+	if (!date) return void 0;
+	const id = date.calendar.identifier;
+	if (id === "gregory" || id === "iso8601") return date.era === "BC" ? "short" : void 0;
+	return "short";
+}
+//#endregion
+//#region src/common/date-utils/formatter.ts
+function getDayFormatter(locale, timeZone, referenceDate) {
+	const date = referenceDate ?? (0, _internationalized_date.toCalendarDateTime)((0, _internationalized_date.today)(timeZone));
+	return new _internationalized_date.DateFormatter(locale, {
+		weekday: "long",
+		month: "long",
+		year: "numeric",
+		day: "numeric",
+		era: getEraFormat(date),
+		calendar: date.calendar.identifier,
+		timeZone
+	});
+}
+function getMonthFormatter(locale, timeZone, referenceDate) {
+	const date = referenceDate ?? (0, _internationalized_date.today)(timeZone);
+	return new _internationalized_date.DateFormatter(locale, {
+		month: "long",
+		year: "numeric",
+		era: getEraFormat(date),
+		calendar: date.calendar.identifier,
+		timeZone
+	});
+}
+//#endregion
+//#region src/common/date-utils/format.ts
+function formatRange(startDate, endDate, formatter, toString, timeZone) {
+	let parts = formatter.formatRangeToParts(startDate.toDate(timeZone), endDate.toDate(timeZone));
+	let separatorIndex = -1;
+	for (let i = 0; i < parts.length; i++) {
+		let part = parts[i];
+		if (part.source === "shared" && part.type === "literal") separatorIndex = i;
+		else if (part.source === "endRange") break;
+	}
+	let start = "";
+	let end = "";
+	for (let i = 0; i < parts.length; i++) if (i < separatorIndex) start += parts[i].value;
+	else if (i > separatorIndex) end += parts[i].value;
+	return toString(start, end);
+}
+function formatSelectedDate(startDate, endDate, locale, timeZone) {
+	if (!startDate) return "";
+	let start = startDate;
+	let end = endDate ?? startDate;
+	let formatter = getDayFormatter(locale, timeZone);
+	if ((0, _internationalized_date.isSameDay)(start, end)) return formatter.format(start.toDate(timeZone));
+	return formatRange(start, end, formatter, (start, end) => `${start} – ${end}`, timeZone);
+}
+function formatVisibleRange(startDate, endDate, locale, timeZone) {
+	const start = startDate;
+	const end = endDate ?? startDate;
+	const dayFormatter = getDayFormatter(locale, timeZone);
+	if (!(0, _internationalized_date.isSameDay)(start, (0, _internationalized_date.startOfMonth)(start))) return dayFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+	const monthFormatter = getMonthFormatter(locale, timeZone);
+	if ((0, _internationalized_date.isSameDay)(end, (0, _internationalized_date.endOfMonth)(start))) return monthFormatter.format(start.toDate(timeZone));
+	if ((0, _internationalized_date.isSameDay)(end, (0, _internationalized_date.endOfMonth)(end))) return monthFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+	return "";
+}
+//#endregion
+//#region src/common/date-utils/date-month.ts
+const daysOfTheWeek = [
+	"sun",
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat"
+];
+function normalizeFirstDayOfWeek(firstDayOfWeek) {
+	return firstDayOfWeek != null ? daysOfTheWeek[firstDayOfWeek] : void 0;
+}
+function getStartOfWeek(date, locale, firstDayOfWeek) {
+	return (0, _internationalized_date.startOfWeek)(date, locale, normalizeFirstDayOfWeek(firstDayOfWeek));
+}
+function getEndOfWeek(date, locale, firstDayOfWeek = 0) {
+	return (0, _internationalized_date.endOfWeek)(date, locale, normalizeFirstDayOfWeek(firstDayOfWeek));
+}
+function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
+	const weekDate = from.add({ weeks: weekIndex });
+	const dates = [];
+	let date = getStartOfWeek(weekDate, locale, firstDayOfWeek);
+	while (dates.length < 7) {
+		dates.push(date);
+		let nextDate = date.add({ days: 1 });
+		if ((0, _internationalized_date.isSameDay)(date, nextDate)) break;
+		date = nextDate;
+	}
+	return dates;
+}
+function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
+	const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+	const monthWeeks = numOfWeeks ?? (0, _internationalized_date.getWeeksInMonth)(from, locale, firstDay);
+	return Array.from({ length: monthWeeks }, (_, week) => week).map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek));
+}
+function getWeekdayFormats(locale, timeZone) {
+	const longFormat = new _internationalized_date.DateFormatter(locale, {
+		weekday: "long",
+		timeZone
+	});
+	const shortFormat = new _internationalized_date.DateFormatter(locale, {
+		weekday: "short",
+		timeZone
+	});
+	const narrowFormat = new _internationalized_date.DateFormatter(locale, {
+		weekday: "narrow",
+		timeZone
+	});
+	return (value) => {
+		const date = value instanceof Date ? value : value.toDate(timeZone);
+		return {
+			value,
+			short: shortFormat.format(date),
+			long: longFormat.format(date),
+			narrow: narrowFormat.format(date)
+		};
+	};
+}
+function getWeekDays(date, startOfWeekProp, timeZone, locale) {
+	const firstDayOfWeek = getStartOfWeek(date, locale, startOfWeekProp);
+	const weeks = Array.from({ length: 7 }, (_, week) => week);
+	const format = getWeekdayFormats(locale, timeZone);
+	return weeks.map((index) => format(firstDayOfWeek.add({ days: index })));
+}
+function getMonthNames(locale, format = "long", referenceDate) {
+	if (!referenceDate || referenceDate.calendar.identifier === "gregory" || referenceDate.calendar.identifier === "iso8601") {
+		const date = new Date(2021, 0, 1);
+		const monthNames = [];
+		for (let i = 0; i < 12; i++) {
+			monthNames.push(date.toLocaleString(locale, { month: format }));
+			date.setMonth(date.getMonth() + 1);
+		}
+		return monthNames;
+	}
+	const monthCount = referenceDate.calendar.getMonthsInYear(referenceDate);
+	const formatter = new _internationalized_date.DateFormatter(locale, {
+		month: format,
+		calendar: referenceDate.calendar.identifier
+	});
+	const monthNames = [];
+	for (let month = 1; month <= monthCount; month++) {
+		const d = referenceDate.set({ month });
+		monthNames.push(formatter.format(d.toDate("UTC")));
+	}
+	return monthNames;
+}
+function getWeekOfYear(date, locale) {
+	const mondayOfWeek = (0, _internationalized_date.startOfWeek)(date, locale, "mon");
+	const year = mondayOfWeek.year;
+	const week1Monday = (0, _internationalized_date.startOfWeek)(mondayOfWeek.set({
+		month: 1,
+		day: 4
+	}), locale, "mon");
+	const julianMonday = mondayOfWeek.calendar.toJulianDay(mondayOfWeek);
+	const julianWeek1 = week1Monday.calendar.toJulianDay(week1Monday);
+	if (julianMonday >= julianWeek1) return 1 + Math.floor((julianMonday - julianWeek1) / 7);
+	const prevWeek1Monday = (0, _internationalized_date.startOfWeek)(mondayOfWeek.set({
+		year: year - 1,
+		month: 1,
+		day: 4
+	}), locale, "mon");
+	const julianPrevWeek1 = prevWeek1Monday.calendar.toJulianDay(prevWeek1Monday);
+	return 1 + Math.floor((julianMonday - julianPrevWeek1) / 7);
+}
+//#endregion
+//#region src/common/date-utils/date-year.ts
+function getYearsRange(range) {
+	const years = [];
+	for (let year = range.from; year <= range.to; year += 1) years.push(year);
+	return years;
+}
+const DEFAULT_MIN_YEAR = 1900;
+const DEFAULT_MAX_YEAR = 2099;
+function getDefaultYearRange(referenceDate, min, max) {
+	const calendar = referenceDate.calendar;
+	return {
+		from: min?.year ?? (0, _internationalized_date.toCalendar)(new _internationalized_date.CalendarDate(DEFAULT_MIN_YEAR, 1, 1), calendar).year,
+		to: max?.year ?? (0, _internationalized_date.toCalendar)(new _internationalized_date.CalendarDate(DEFAULT_MAX_YEAR, 12, 31), calendar).year
+	};
+}
+const FUTURE_YEAR_COERCION = 10;
+function normalizeYear(year) {
+	if (!year) return;
+	if (year.length === 3) return year.padEnd(4, "0");
+	if (year.length === 2) {
+		const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+		const fullYear = Math.floor(currentYear / 100) * 100 + parseInt(year.slice(-2), 10);
+		return fullYear > currentYear + FUTURE_YEAR_COERCION ? (fullYear - 100).toString() : fullYear.toString();
+	}
+	return year;
+}
+function getDecadeRange(year, opts) {
+	const chunkSize = opts?.strict ? 10 : 12;
+	const computedYear = year - year % 10;
+	const years = [];
+	for (let i = 0; i < chunkSize; i += 1) {
+		const value = computedYear + i;
+		years.push(value);
+	}
+	return years;
+}
+//#endregion
+//#region src/common/date-utils/mutation.ts
+function getTodayDate(timeZone, calendar) {
+	const tod = (0, _internationalized_date.today)(timeZone ?? (0, _internationalized_date.getLocalTimeZone)());
+	if (calendar) return (0, _internationalized_date.toCalendar)(tod, calendar);
+	return tod;
+}
+function setCalendar(date, calendar) {
+	return (0, _internationalized_date.toCalendar)((0, _internationalized_date.toCalendarDateTime)(date), calendar);
+}
+function setDate(date, startDate, isDateUnavailable, locale, minValue, maxValue) {
+	let result;
+	result = constrainValue(date, minValue, maxValue);
+	result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable);
+	return result;
+}
+function getPreviousAvailableDate(date, minValue, locale, isDateUnavailable) {
+	if (!isDateUnavailable) return date;
+	while (date.compare(minValue) >= 0 && isDateUnavailable(date, locale)) date = date.subtract({ days: 1 });
+	if (date.compare(minValue) >= 0) return date;
+}
+//#endregion
+//#region src/common/date-utils/pagination.ts
+function getAdjustedDateFn(visibleDuration, locale, minValue, maxValue) {
+	return function getDate(options) {
+		const { startDate, focusedDate } = options;
+		const endDate = getEndDate(startDate, visibleDuration);
+		if (isDateOutsideRange(focusedDate, minValue, maxValue)) return {
+			startDate,
+			focusedDate: constrainValue(focusedDate, minValue, maxValue),
+			endDate
+		};
+		if (focusedDate.compare(startDate) < 0) return {
+			startDate: alignEnd(focusedDate, visibleDuration, locale, minValue, maxValue),
+			focusedDate: constrainValue(focusedDate, minValue, maxValue),
+			endDate
+		};
+		if (focusedDate.compare(endDate) > 0) return {
+			startDate: alignStart(focusedDate, visibleDuration, locale, minValue, maxValue),
+			endDate,
+			focusedDate: constrainValue(focusedDate, minValue, maxValue)
+		};
+		return {
+			startDate,
+			endDate,
+			focusedDate: constrainValue(focusedDate, minValue, maxValue)
+		};
+	};
+}
+function getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	const start = startDate.add(visibleDuration);
+	return adjust({
+		focusedDate: focusedDate.add(visibleDuration),
+		startDate: alignStart(constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue), visibleDuration, locale)
+	});
+}
+function getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	let start = startDate.subtract(visibleDuration);
+	return adjust({
+		focusedDate: focusedDate.subtract(visibleDuration),
+		startDate: alignStart(constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue), visibleDuration, locale)
+	});
+}
+function getNextRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.days) return getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.add({ weeks: 1 }),
+		startDate
+	});
+}
+function getPreviousRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.days) return getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.subtract({ weeks: 1 }),
+		startDate
+	});
+}
+function getSectionStart(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.days) return adjust({
+		focusedDate: startDate,
+		startDate
+	});
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: (0, _internationalized_date.startOfWeek)(focusedDate, locale),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: (0, _internationalized_date.startOfMonth)(focusedDate),
+		startDate
+	});
+}
+function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	const endDate = getEndDate(startDate, visibleDuration);
+	if (visibleDuration.days) return adjust({
+		focusedDate: endDate,
+		startDate
+	});
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: (0, _internationalized_date.endOfWeek)(focusedDate, locale),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: (0, _internationalized_date.endOfMonth)(focusedDate),
+		startDate
+	});
+}
+function getNextSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (!larger && !visibleDuration.days) return adjust({
+		focusedDate: focusedDate.add(getUnitDuration(visibleDuration)),
+		startDate
+	});
+	if (visibleDuration.days) return getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: focusedDate.add({ months: 1 }),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.add({ years: 1 }),
+		startDate
+	});
+}
+function getPreviousSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (!larger && !visibleDuration.days) return adjust({
+		focusedDate: focusedDate.subtract(getUnitDuration(visibleDuration)),
+		startDate
+	});
+	if (visibleDuration.days) return getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: focusedDate.subtract({ months: 1 }),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.subtract({ years: 1 }),
+		startDate
+	});
+}
+//#endregion
+//#region src/common/date-utils/locale.ts
+const digitsCache = /* @__PURE__ */ new Map();
+function getLocaleDigits(locale) {
+	let digits = digitsCache.get(locale);
+	if (digits != null) return digits;
+	digits = "0123456789" + new Intl.NumberFormat(locale, { useGrouping: false }).format(1234567890);
+	digitsCache.set(locale, digits);
+	return digits;
+}
+const isDigit = (char, locale) => {
+	return locale ? getLocaleDigits(locale).includes(char) : /\d/.test(char);
+};
+const isValidCharacter = (char, separator, locale) => {
+	if (!char) return true;
+	if (char.length !== 1) return true;
+	return isDigit(char, locale) || separator.includes(char);
+};
+const ensureValidCharacters = (value, separator, locale) => {
+	return value.split("").filter((char) => isValidCharacter(char, separator, locale)).join("");
+};
+const separatorCache = /* @__PURE__ */ new Map();
+function getLocaleSeparator(locale) {
+	let separator = separatorCache.get(locale);
+	if (separator != null) return separator;
+	const literal = new Intl.DateTimeFormat(locale).formatToParts(/* @__PURE__ */ new Date()).find((part) => part.type === "literal");
+	separator = literal ? literal.value : "/";
+	separatorCache.set(locale, separator);
+	return separator;
+}
+//#endregion
+//#region src/common/date-utils/parse-date.ts
+const isValidYear = (year) => year != null && year.length === 4;
+const isValidMonth = (month) => month != null && parseFloat(month) <= 12;
+const isValidDay = (day) => day != null && parseFloat(day) <= 31;
+function parseDateString(date, locale, timeZone) {
+	let { year, month, day } = extract(createRegex(locale, timeZone), date) ?? {};
+	if (year != null || month != null || day != null) {
+		const curr = /* @__PURE__ */ new Date();
+		year ||= curr.getFullYear().toString();
+		month ||= (curr.getMonth() + 1).toString();
+		day ||= curr.getDate().toString();
+	}
+	if (!isValidYear(year)) year = normalizeYear(year);
+	if (isValidYear(year) && isValidMonth(month) && isValidDay(day)) return new _internationalized_date.CalendarDate(+year, +month, +day);
+	const time = Date.parse(date);
+	if (!isNaN(time)) {
+		const date = new Date(time);
+		return new _internationalized_date.CalendarDate(date.getFullYear(), date.getMonth() + 1, date.getDate());
+	}
+}
+function createRegex(locale, timeZone) {
+	return new _internationalized_date.DateFormatter(locale, {
+		day: "numeric",
+		month: "numeric",
+		year: "numeric",
+		timeZone
+	}).formatToParts(new Date(2e3, 11, 25)).map(({ type, value }) => type === "literal" ? `${value}?` : `((?!=<${type}>)\\d+)?`).join("");
+}
+function extract(pattern, str) {
+	const matches = str.match(pattern);
+	return pattern.toString().match(/<(.+?)>/g)?.map((group) => {
+		const groupMatches = group.match(/<(.+)>/);
+		if (!groupMatches || groupMatches.length <= 0) return null;
+		return group.match(/<(.+)>/)?.[1];
+	}).reduce((acc, curr, index) => {
+		if (!curr) return acc;
+		if (matches && matches.length > index) acc[curr] = matches[index + 1];
+		else acc[curr] = null;
+		return acc;
+	}, {});
+}
+//#endregion
+//#region src/common/date-utils/preset.ts
+function getDateRangePreset(preset, locale, timeZone) {
+	const today = (0, _internationalized_date.toCalendarDate)((0, _internationalized_date.now)(timeZone));
+	switch (preset) {
+		case "thisWeek": return [(0, _internationalized_date.startOfWeek)(today, locale), (0, _internationalized_date.endOfWeek)(today, locale)];
+		case "thisMonth": return [(0, _internationalized_date.startOfMonth)(today), today];
+		case "thisQuarter": return [(0, _internationalized_date.startOfMonth)(today).add({ months: -((today.month - 1) % 3) }), today];
+		case "thisYear": return [(0, _internationalized_date.startOfYear)(today), today];
+		case "last3Days": return [today.add({ days: -2 }), today];
+		case "last7Days": return [today.add({ days: -6 }), today];
+		case "last14Days": return [today.add({ days: -13 }), today];
+		case "last30Days": return [today.add({ days: -29 }), today];
+		case "last90Days": return [today.add({ days: -89 }), today];
+		case "lastMonth": return [(0, _internationalized_date.startOfMonth)(today.add({ months: -1 })), (0, _internationalized_date.endOfMonth)(today.add({ months: -1 }))];
+		case "lastQuarter": return [(0, _internationalized_date.startOfMonth)(today.add({ months: -((today.month - 1) % 3) - 3 })), (0, _internationalized_date.endOfMonth)(today.add({ months: -((today.month - 1) % 3) - 1 }))];
+		case "lastWeek": return [(0, _internationalized_date.startOfWeek)(today, locale).add({ weeks: -1 }), (0, _internationalized_date.endOfWeek)(today, locale).add({ weeks: -1 })];
+		case "lastYear": return [(0, _internationalized_date.startOfYear)(today.add({ years: -1 })), (0, _internationalized_date.endOfYear)(today.add({ years: -1 }))];
+		default: throw new Error(`Invalid date range preset: ${preset}`);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "alignCenter", {
+	enumerable: true,
+	get: function() {
+		return alignCenter;
+	}
+});
+Object.defineProperty(exports, "alignDate", {
+	enumerable: true,
+	get: function() {
+		return alignDate;
+	}
+});
+Object.defineProperty(exports, "alignEnd", {
+	enumerable: true,
+	get: function() {
+		return alignEnd;
+	}
+});
+Object.defineProperty(exports, "alignStart", {
+	enumerable: true,
+	get: function() {
+		return alignStart;
+	}
+});
+Object.defineProperty(exports, "alignStartDate", {
+	enumerable: true,
+	get: function() {
+		return alignStartDate;
+	}
+});
+Object.defineProperty(exports, "constrainSegments", {
+	enumerable: true,
+	get: function() {
+		return constrainSegments;
+	}
+});
+Object.defineProperty(exports, "constrainStart", {
+	enumerable: true,
+	get: function() {
+		return constrainStart;
+	}
+});
+Object.defineProperty(exports, "constrainValue", {
+	enumerable: true,
+	get: function() {
+		return constrainValue;
+	}
+});
+Object.defineProperty(exports, "ensureValidCharacters", {
+	enumerable: true,
+	get: function() {
+		return ensureValidCharacters;
+	}
+});
+Object.defineProperty(exports, "formatRange", {
+	enumerable: true,
+	get: function() {
+		return formatRange;
+	}
+});
+Object.defineProperty(exports, "formatSelectedDate", {
+	enumerable: true,
+	get: function() {
+		return formatSelectedDate;
+	}
+});
+Object.defineProperty(exports, "formatVisibleRange", {
+	enumerable: true,
+	get: function() {
+		return formatVisibleRange;
+	}
+});
+Object.defineProperty(exports, "getAdjustedDateFn", {
+	enumerable: true,
+	get: function() {
+		return getAdjustedDateFn;
+	}
+});
+Object.defineProperty(exports, "getDateRangePreset", {
+	enumerable: true,
+	get: function() {
+		return getDateRangePreset;
+	}
+});
+Object.defineProperty(exports, "getDayFormatter", {
+	enumerable: true,
+	get: function() {
+		return getDayFormatter;
+	}
+});
+Object.defineProperty(exports, "getDaysInWeek", {
+	enumerable: true,
+	get: function() {
+		return getDaysInWeek;
+	}
+});
+Object.defineProperty(exports, "getDecadeRange", {
+	enumerable: true,
+	get: function() {
+		return getDecadeRange;
+	}
+});
+Object.defineProperty(exports, "getDefaultYearRange", {
+	enumerable: true,
+	get: function() {
+		return getDefaultYearRange;
+	}
+});
+Object.defineProperty(exports, "getEndDate", {
+	enumerable: true,
+	get: function() {
+		return getEndDate;
+	}
+});
+Object.defineProperty(exports, "getEndOfWeek", {
+	enumerable: true,
+	get: function() {
+		return getEndOfWeek;
+	}
+});
+Object.defineProperty(exports, "getLocaleSeparator", {
+	enumerable: true,
+	get: function() {
+		return getLocaleSeparator;
+	}
+});
+Object.defineProperty(exports, "getMonthDays", {
+	enumerable: true,
+	get: function() {
+		return getMonthDays;
+	}
+});
+Object.defineProperty(exports, "getMonthFormatter", {
+	enumerable: true,
+	get: function() {
+		return getMonthFormatter;
+	}
+});
+Object.defineProperty(exports, "getMonthNames", {
+	enumerable: true,
+	get: function() {
+		return getMonthNames;
+	}
+});
+Object.defineProperty(exports, "getNextPage", {
+	enumerable: true,
+	get: function() {
+		return getNextPage;
+	}
+});
+Object.defineProperty(exports, "getNextRow", {
+	enumerable: true,
+	get: function() {
+		return getNextRow;
+	}
+});
+Object.defineProperty(exports, "getNextSection", {
+	enumerable: true,
+	get: function() {
+		return getNextSection;
+	}
+});
+Object.defineProperty(exports, "getPreviousAvailableDate", {
+	enumerable: true,
+	get: function() {
+		return getPreviousAvailableDate;
+	}
+});
+Object.defineProperty(exports, "getPreviousPage", {
+	enumerable: true,
+	get: function() {
+		return getPreviousPage;
+	}
+});
+Object.defineProperty(exports, "getPreviousRow", {
+	enumerable: true,
+	get: function() {
+		return getPreviousRow;
+	}
+});
+Object.defineProperty(exports, "getPreviousSection", {
+	enumerable: true,
+	get: function() {
+		return getPreviousSection;
+	}
+});
+Object.defineProperty(exports, "getSectionEnd", {
+	enumerable: true,
+	get: function() {
+		return getSectionEnd;
+	}
+});
+Object.defineProperty(exports, "getSectionStart", {
+	enumerable: true,
+	get: function() {
+		return getSectionStart;
+	}
+});
+Object.defineProperty(exports, "getStartOfWeek", {
+	enumerable: true,
+	get: function() {
+		return getStartOfWeek;
+	}
+});
+Object.defineProperty(exports, "getTodayDate", {
+	enumerable: true,
+	get: function() {
+		return getTodayDate;
+	}
+});
+Object.defineProperty(exports, "getUnitDuration", {
+	enumerable: true,
+	get: function() {
+		return getUnitDuration;
+	}
+});
+Object.defineProperty(exports, "getWeekDays", {
+	enumerable: true,
+	get: function() {
+		return getWeekDays;
+	}
+});
+Object.defineProperty(exports, "getWeekOfYear", {
+	enumerable: true,
+	get: function() {
+		return getWeekOfYear;
+	}
+});
+Object.defineProperty(exports, "getWeekdayFormats", {
+	enumerable: true,
+	get: function() {
+		return getWeekdayFormats;
+	}
+});
+Object.defineProperty(exports, "getYearsRange", {
+	enumerable: true,
+	get: function() {
+		return getYearsRange;
+	}
+});
+Object.defineProperty(exports, "isDateEqual", {
+	enumerable: true,
+	get: function() {
+		return isDateEqual;
+	}
+});
+Object.defineProperty(exports, "isDateOutsideRange", {
+	enumerable: true,
+	get: function() {
+		return isDateOutsideRange;
+	}
+});
+Object.defineProperty(exports, "isDateUnavailable", {
+	enumerable: true,
+	get: function() {
+		return isDateUnavailable;
+	}
+});
+Object.defineProperty(exports, "isNextRangeInvalid", {
+	enumerable: true,
+	get: function() {
+		return isNextRangeInvalid;
+	}
+});
+Object.defineProperty(exports, "isPreviousRangeInvalid", {
+	enumerable: true,
+	get: function() {
+		return isPreviousRangeInvalid;
+	}
+});
+Object.defineProperty(exports, "isValidCharacter", {
+	enumerable: true,
+	get: function() {
+		return isValidCharacter;
+	}
+});
+Object.defineProperty(exports, "normalizeYear", {
+	enumerable: true,
+	get: function() {
+		return normalizeYear;
+	}
+});
+Object.defineProperty(exports, "parseDateString", {
+	enumerable: true,
+	get: function() {
+		return parseDateString;
+	}
+});
+Object.defineProperty(exports, "setCalendar", {
+	enumerable: true,
+	get: function() {
+		return setCalendar;
+	}
+});
+Object.defineProperty(exports, "setDate", {
+	enumerable: true,
+	get: function() {
+		return setDate;
+	}
+});