@wirekyt/dom 0.0.1 → 0.0.2

package/dist/date-utils-D5zXW-Cs.js

@@ -0,0 +1,569 @@
+import { CalendarDate, DateFormatter, endOfMonth, endOfWeek, endOfYear, getLocalTimeZone, getWeeksInMonth, isSameDay, maxDate, minDate, now, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, today } from "@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 = startOfYear(date);
+	else if (duration.months) aligned = startOfMonth(date);
+	else if (duration.weeks) aligned = 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 = maxDate(aligned, alignStart(toCalendarDate(min), duration, locale));
+	if (max && date.compare(max) <= 0) aligned = minDate(aligned, alignEnd(toCalendarDate(max), duration, locale));
+	return aligned;
+}
+function constrainValue(date, minValue, maxValue) {
+	const dateOnly = toCalendarDate(date);
+	const minOnly = minValue ? toCalendarDate(minValue) : void 0;
+	const maxOnly = maxValue ? toCalendarDate(maxValue) : void 0;
+	let constrainedDateOnly = dateOnly;
+	if (minOnly) constrainedDateOnly = maxDate(constrainedDateOnly, minOnly);
+	if (maxOnly) constrainedDateOnly = 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 = toCalendarDate(date);
+	const minOnly = minValue ? toCalendarDate(minValue) : void 0;
+	const maxOnly = maxValue ? 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 isSameDay(dateA, dateB);
+	return toCalendarDateTime(dateA).compare(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 isSameDay(prevDate, startDate) || isDateOutsideRange(prevDate, minValue, maxValue);
+}
+function isNextRangeInvalid(endDate, minValue, maxValue) {
+	const nextDate = endDate.add({ days: 1 });
+	return 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 ?? toCalendarDateTime(today(timeZone));
+	return new 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 ?? today(timeZone);
+	return new 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 (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 (!isSameDay(start, startOfMonth(start))) return dayFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+	const monthFormatter = getMonthFormatter(locale, timeZone);
+	if (isSameDay(end, endOfMonth(start))) return monthFormatter.format(start.toDate(timeZone));
+	if (isSameDay(end, 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 startOfWeek(date, locale, normalizeFirstDayOfWeek(firstDayOfWeek));
+}
+function getEndOfWeek(date, locale, firstDayOfWeek = 0) {
+	return 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 (isSameDay(date, nextDate)) break;
+		date = nextDate;
+	}
+	return dates;
+}
+function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
+	const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+	const monthWeeks = numOfWeeks ?? 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 DateFormatter(locale, {
+		weekday: "long",
+		timeZone
+	});
+	const shortFormat = new DateFormatter(locale, {
+		weekday: "short",
+		timeZone
+	});
+	const narrowFormat = new 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 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 = startOfWeek(date, locale, "mon");
+	const year = mondayOfWeek.year;
+	const week1Monday = 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 = 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 ?? toCalendar(new CalendarDate(DEFAULT_MIN_YEAR, 1, 1), calendar).year,
+		to: max?.year ?? toCalendar(new 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 = today(timeZone ?? getLocalTimeZone());
+	if (calendar) return toCalendar(tod, calendar);
+	return tod;
+}
+function setCalendar(date, calendar) {
+	return toCalendar(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: startOfWeek(focusedDate, locale),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: 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: endOfWeek(focusedDate, locale),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: 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 CalendarDate(+year, +month, +day);
+	const time = Date.parse(date);
+	if (!isNaN(time)) {
+		const date = new Date(time);
+		return new CalendarDate(date.getFullYear(), date.getMonth() + 1, date.getDate());
+	}
+}
+function createRegex(locale, timeZone) {
+	return new 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 = toCalendarDate(now(timeZone));
+	switch (preset) {
+		case "thisWeek": return [startOfWeek(today, locale), endOfWeek(today, locale)];
+		case "thisMonth": return [startOfMonth(today), today];
+		case "thisQuarter": return [startOfMonth(today).add({ months: -((today.month - 1) % 3) }), today];
+		case "thisYear": return [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 [startOfMonth(today.add({ months: -1 })), endOfMonth(today.add({ months: -1 }))];
+		case "lastQuarter": return [startOfMonth(today.add({ months: -((today.month - 1) % 3) - 3 })), endOfMonth(today.add({ months: -((today.month - 1) % 3) - 1 }))];
+		case "lastWeek": return [startOfWeek(today, locale).add({ weeks: -1 }), endOfWeek(today, locale).add({ weeks: -1 })];
+		case "lastYear": return [startOfYear(today.add({ years: -1 })), endOfYear(today.add({ years: -1 }))];
+		default: throw new Error(`Invalid date range preset: ${preset}`);
+	}
+}
+//#endregion
+export { getWeekdayFormats as A, isDateUnavailable as B, getDaysInWeek as C, getStartOfWeek as D, getMonthNames as E, getMonthFormatter as F, alignCenter as G, isPreviousRangeInvalid as H, getEndDate as I, constrainSegments as J, alignEnd as K, getUnitDuration as L, formatSelectedDate as M, formatVisibleRange as N, getWeekDays as O, getDayFormatter as P, isDateEqual as R, normalizeYear as S, getMonthDays as T, alignDate as U, isNextRangeInvalid as V, alignStartDate as W, constrainValue as X, constrainStart as Y, setCalendar as _, isValidCharacter as a, getDefaultYearRange as b, getNextRow as c, getPreviousRow as d, getPreviousSection as f, getTodayDate as g, getPreviousAvailableDate as h, getLocaleSeparator as i, formatRange as j, getWeekOfYear as k, getNextSection as l, getSectionStart as m, parseDateString as n, getAdjustedDateFn as o, getSectionEnd as p, alignStart as q, ensureValidCharacters as r, getNextPage as s, getDateRangePreset as t, getPreviousPage as u, setDate as v, getEndOfWeek as w, getYearsRange as x, getDecadeRange as y, isDateOutsideRange as z };

package/dist/date-utils.cjs

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_date_utils = require("./date-utils-D-JJHedx.cjs");
+exports.alignCenter = require_date_utils.alignCenter;
+exports.alignDate = require_date_utils.alignDate;
+exports.alignEnd = require_date_utils.alignEnd;
+exports.alignStart = require_date_utils.alignStart;
+exports.alignStartDate = require_date_utils.alignStartDate;
+exports.constrainSegments = require_date_utils.constrainSegments;
+exports.constrainStart = require_date_utils.constrainStart;
+exports.constrainValue = require_date_utils.constrainValue;
+exports.ensureValidCharacters = require_date_utils.ensureValidCharacters;
+exports.formatRange = require_date_utils.formatRange;
+exports.formatSelectedDate = require_date_utils.formatSelectedDate;
+exports.formatVisibleRange = require_date_utils.formatVisibleRange;
+exports.getAdjustedDateFn = require_date_utils.getAdjustedDateFn;
+exports.getDateRangePreset = require_date_utils.getDateRangePreset;
+exports.getDayFormatter = require_date_utils.getDayFormatter;
+exports.getDaysInWeek = require_date_utils.getDaysInWeek;
+exports.getDecadeRange = require_date_utils.getDecadeRange;
+exports.getDefaultYearRange = require_date_utils.getDefaultYearRange;
+exports.getEndDate = require_date_utils.getEndDate;
+exports.getEndOfWeek = require_date_utils.getEndOfWeek;
+exports.getLocaleSeparator = require_date_utils.getLocaleSeparator;
+exports.getMonthDays = require_date_utils.getMonthDays;
+exports.getMonthFormatter = require_date_utils.getMonthFormatter;
+exports.getMonthNames = require_date_utils.getMonthNames;
+exports.getNextPage = require_date_utils.getNextPage;
+exports.getNextRow = require_date_utils.getNextRow;
+exports.getNextSection = require_date_utils.getNextSection;
+exports.getPreviousAvailableDate = require_date_utils.getPreviousAvailableDate;
+exports.getPreviousPage = require_date_utils.getPreviousPage;
+exports.getPreviousRow = require_date_utils.getPreviousRow;
+exports.getPreviousSection = require_date_utils.getPreviousSection;
+exports.getSectionEnd = require_date_utils.getSectionEnd;
+exports.getSectionStart = require_date_utils.getSectionStart;
+exports.getStartOfWeek = require_date_utils.getStartOfWeek;
+exports.getTodayDate = require_date_utils.getTodayDate;
+exports.getUnitDuration = require_date_utils.getUnitDuration;
+exports.getWeekDays = require_date_utils.getWeekDays;
+exports.getWeekOfYear = require_date_utils.getWeekOfYear;
+exports.getWeekdayFormats = require_date_utils.getWeekdayFormats;
+exports.getYearsRange = require_date_utils.getYearsRange;
+exports.isDateEqual = require_date_utils.isDateEqual;
+exports.isDateOutsideRange = require_date_utils.isDateOutsideRange;
+exports.isDateUnavailable = require_date_utils.isDateUnavailable;
+exports.isNextRangeInvalid = require_date_utils.isNextRangeInvalid;
+exports.isPreviousRangeInvalid = require_date_utils.isPreviousRangeInvalid;
+exports.isValidCharacter = require_date_utils.isValidCharacter;
+exports.normalizeYear = require_date_utils.normalizeYear;
+exports.parseDateString = require_date_utils.parseDateString;
+exports.setCalendar = require_date_utils.setCalendar;
+exports.setDate = require_date_utils.setDate;

package/dist/date-utils.d.cts

@@ -0,0 +1,7 @@
+import { $ as DateRangePreset, A as getWeekdayFormats, B as alignStart, C as getDaysInWeek, D as getStartOfWeek, E as getMonthNames, F as formatVisibleRange, G as isDateOutsideRange, H as constrainStart, I as getEndDate, J as isPreviousRangeInvalid, K as isDateUnavailable, L as getUnitDuration, M as getMonthFormatter, N as formatRange, O as getWeekDays, P as formatSelectedDate, Q as DateGranularity, R as alignCenter, S as normalizeYear, T as getMonthDays, U as constrainValue, V as constrainSegments, W as isDateEqual, X as alignStartDate, Y as alignDate, Z as DateAdjustFn, _ as setDate, a as getAdjustedDateFn, b as getDefaultYearRange, c as getNextSection, d as getPreviousSection, et as DateValue, f as getSectionEnd, g as setCalendar, h as getTodayDate, i as AdjustDateReturn, j as getDayFormatter, k as getWeekOfYear, l as getPreviousPage, m as getPreviousAvailableDate, n as parseDateString, o as getNextPage, p as getSectionStart, q as isNextRangeInvalid, r as AdjustDateParams, s as getNextRow, t as getDateRangePreset, u as getPreviousRow, v as YearsRange, w as getEndOfWeek, x as getYearsRange, y as getDecadeRange, z as alignEnd } from "./index-BEfvdGE2.cjs";
+//#region src/common/date-utils/locale.d.ts
+declare const isValidCharacter: (char: string | null, separator: string, locale?: string) => boolean;
+declare const ensureValidCharacters: (value: string, separator: string, locale?: string) => string;
+declare function getLocaleSeparator(locale: string): string;
+//#endregion
+export { AdjustDateParams, AdjustDateReturn, type DateAdjustFn, type DateGranularity, type DateRangePreset, type DateValue, YearsRange, alignCenter, alignDate, alignEnd, alignStart, alignStartDate, constrainSegments, constrainStart, constrainValue, ensureValidCharacters, formatRange, formatSelectedDate, formatVisibleRange, getAdjustedDateFn, getDateRangePreset, getDayFormatter, getDaysInWeek, getDecadeRange, getDefaultYearRange, getEndDate, getEndOfWeek, getLocaleSeparator, getMonthDays, getMonthFormatter, getMonthNames, getNextPage, getNextRow, getNextSection, getPreviousAvailableDate, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart, getStartOfWeek, getTodayDate, getUnitDuration, getWeekDays, getWeekOfYear, getWeekdayFormats, getYearsRange, isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid, isValidCharacter, normalizeYear, parseDateString, setCalendar, setDate };

package/dist/date-utils.d.ts

@@ -0,0 +1,7 @@
+import { $ as DateRangePreset, A as getWeekdayFormats, B as alignStart, C as getDaysInWeek, D as getStartOfWeek, E as getMonthNames, F as formatVisibleRange, G as isDateOutsideRange, H as constrainStart, I as getEndDate, J as isPreviousRangeInvalid, K as isDateUnavailable, L as getUnitDuration, M as getMonthFormatter, N as formatRange, O as getWeekDays, P as formatSelectedDate, Q as DateGranularity, R as alignCenter, S as normalizeYear, T as getMonthDays, U as constrainValue, V as constrainSegments, W as isDateEqual, X as alignStartDate, Y as alignDate, Z as DateAdjustFn, _ as setDate, a as getAdjustedDateFn, b as getDefaultYearRange, c as getNextSection, d as getPreviousSection, et as DateValue, f as getSectionEnd, g as setCalendar, h as getTodayDate, i as AdjustDateReturn, j as getDayFormatter, k as getWeekOfYear, l as getPreviousPage, m as getPreviousAvailableDate, n as parseDateString, o as getNextPage, p as getSectionStart, q as isNextRangeInvalid, r as AdjustDateParams, s as getNextRow, t as getDateRangePreset, u as getPreviousRow, v as YearsRange, w as getEndOfWeek, x as getYearsRange, y as getDecadeRange, z as alignEnd } from "./index-BEfvdGE2.js";
+//#region src/common/date-utils/locale.d.ts
+declare const isValidCharacter: (char: string | null, separator: string, locale?: string) => boolean;
+declare const ensureValidCharacters: (value: string, separator: string, locale?: string) => string;
+declare function getLocaleSeparator(locale: string): string;
+//#endregion
+export { AdjustDateParams, AdjustDateReturn, type DateAdjustFn, type DateGranularity, type DateRangePreset, type DateValue, YearsRange, alignCenter, alignDate, alignEnd, alignStart, alignStartDate, constrainSegments, constrainStart, constrainValue, ensureValidCharacters, formatRange, formatSelectedDate, formatVisibleRange, getAdjustedDateFn, getDateRangePreset, getDayFormatter, getDaysInWeek, getDecadeRange, getDefaultYearRange, getEndDate, getEndOfWeek, getLocaleSeparator, getMonthDays, getMonthFormatter, getMonthNames, getNextPage, getNextRow, getNextSection, getPreviousAvailableDate, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart, getStartOfWeek, getTodayDate, getUnitDuration, getWeekDays, getWeekOfYear, getWeekdayFormats, getYearsRange, isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid, isValidCharacter, normalizeYear, parseDateString, setCalendar, setDate };

package/dist/date-utils.js

@@ -0,0 +1,2 @@
+import { A as getWeekdayFormats, B as isDateUnavailable, C as getDaysInWeek, D as getStartOfWeek, E as getMonthNames, F as getMonthFormatter, G as alignCenter, H as isPreviousRangeInvalid, I as getEndDate, J as constrainSegments, K as alignEnd, L as getUnitDuration, M as formatSelectedDate, N as formatVisibleRange, O as getWeekDays, P as getDayFormatter, R as isDateEqual, S as normalizeYear, T as getMonthDays, U as alignDate, V as isNextRangeInvalid, W as alignStartDate, X as constrainValue, Y as constrainStart, _ as setCalendar, a as isValidCharacter, b as getDefaultYearRange, c as getNextRow, d as getPreviousRow, f as getPreviousSection, g as getTodayDate, h as getPreviousAvailableDate, i as getLocaleSeparator, j as formatRange, k as getWeekOfYear, l as getNextSection, m as getSectionStart, n as parseDateString, o as getAdjustedDateFn, p as getSectionEnd, q as alignStart, r as ensureValidCharacters, s as getNextPage, t as getDateRangePreset, u as getPreviousPage, v as setDate, w as getEndOfWeek, x as getYearsRange, y as getDecadeRange, z as isDateOutsideRange } from "./date-utils-D5zXW-Cs.js";
+export { alignCenter, alignDate, alignEnd, alignStart, alignStartDate, constrainSegments, constrainStart, constrainValue, ensureValidCharacters, formatRange, formatSelectedDate, formatVisibleRange, getAdjustedDateFn, getDateRangePreset, getDayFormatter, getDaysInWeek, getDecadeRange, getDefaultYearRange, getEndDate, getEndOfWeek, getLocaleSeparator, getMonthDays, getMonthFormatter, getMonthNames, getNextPage, getNextRow, getNextSection, getPreviousAvailableDate, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart, getStartOfWeek, getTodayDate, getUnitDuration, getWeekDays, getWeekOfYear, getWeekdayFormats, getYearsRange, isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid, isValidCharacter, normalizeYear, parseDateString, setCalendar, setDate };