@sprawlify/primitives 0.0.1

package/dist/date-utils-D2xPHa_I.cjs

@@ -0,0 +1,738 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+let __internationalized_date = require("@internationalized/date");
+
+//#region src/shared/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) {
+	let constrainedDate = (0, __internationalized_date.toCalendarDate)(date);
+	if (minValue) constrainedDate = (0, __internationalized_date.maxDate)(constrainedDate, (0, __internationalized_date.toCalendarDate)(minValue));
+	if (maxValue) constrainedDate = (0, __internationalized_date.minDate)(constrainedDate, (0, __internationalized_date.toCalendarDate)(maxValue));
+	return constrainedDate;
+}
+
+//#endregion
+//#region src/shared/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);
+		case "center":
+		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/shared/date-utils/assertion.ts
+function isDateEqual(dateA, dateB) {
+	if (dateA == null || dateB == null) return dateA === dateB;
+	return (0, __internationalized_date.isSameDay)(dateA, dateB);
+}
+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/shared/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/shared/date-utils/get-era-format.ts
+function getEraFormat(date) {
+	return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : void 0;
+}
+
+//#endregion
+//#region src/shared/date-utils/formatter.ts
+function getDayFormatter(locale, timeZone) {
+	return new __internationalized_date.DateFormatter(locale, {
+		weekday: "long",
+		month: "long",
+		year: "numeric",
+		day: "numeric",
+		era: getEraFormat((0, __internationalized_date.toCalendarDateTime)((0, __internationalized_date.today)(timeZone))),
+		timeZone
+	});
+}
+function getMonthFormatter(locale, timeZone) {
+	const date = (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/shared/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$1, end$1) => `${start$1} – ${end$1}`, 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/shared/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 [...new Array(monthWeeks).keys()].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 = [...new Array(7).keys()];
+	const format = getWeekdayFormats(locale, timeZone);
+	return weeks.map((index) => format(firstDayOfWeek.add({ days: index })));
+}
+function getMonthNames(locale, format = "long") {
+	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;
+}
+
+//#endregion
+//#region src/shared/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 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/shared/date-utils/mutation.ts
+function getTodayDate(timeZone) {
+	return (0, __internationalized_date.today)(timeZone ?? (0, __internationalized_date.getLocalTimeZone)());
+}
+function setCalendar(date, calendar) {
+	return (0, __internationalized_date.toCalendar)((0, __internationalized_date.toCalendarDateTime)(date), calendar);
+}
+function setDate(date, startDate, isDateUnavailable$1, locale, minValue, maxValue) {
+	let result;
+	result = constrainValue(date, minValue, maxValue);
+	result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable$1);
+	return result;
+}
+function getPreviousAvailableDate(date, minValue, locale, isDateUnavailable$1) {
+	if (!isDateUnavailable$1) return date;
+	while (date.compare(minValue) >= 0 && isDateUnavailable$1(date, locale)) date = date.subtract({ days: 1 });
+	if (date.compare(minValue) >= 0) return date;
+}
+
+//#endregion
+//#region src/shared/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/shared/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 || (year = curr.getFullYear().toString());
+		month || (month = (curr.getMonth() + 1).toString());
+		day || (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$1 = new Date(time);
+		return new __internationalized_date.CalendarDate(date$1.getFullYear(), date$1.getMonth() + 1, date$1.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/shared/date-utils/preset.ts
+function getDateRangePreset(preset, locale, timeZone) {
+	const today$2 = (0, __internationalized_date.toCalendarDate)((0, __internationalized_date.now)(timeZone));
+	switch (preset) {
+		case "thisWeek": return [(0, __internationalized_date.startOfWeek)(today$2, locale), (0, __internationalized_date.endOfWeek)(today$2, locale)];
+		case "thisMonth": return [(0, __internationalized_date.startOfMonth)(today$2), today$2];
+		case "thisQuarter": return [(0, __internationalized_date.startOfMonth)(today$2).add({ months: -((today$2.month - 1) % 3) }), today$2];
+		case "thisYear": return [(0, __internationalized_date.startOfYear)(today$2), today$2];
+		case "last3Days": return [today$2.add({ days: -2 }), today$2];
+		case "last7Days": return [today$2.add({ days: -6 }), today$2];
+		case "last14Days": return [today$2.add({ days: -13 }), today$2];
+		case "last30Days": return [today$2.add({ days: -29 }), today$2];
+		case "last90Days": return [today$2.add({ days: -89 }), today$2];
+		case "lastMonth": return [(0, __internationalized_date.startOfMonth)(today$2.add({ months: -1 })), (0, __internationalized_date.endOfMonth)(today$2.add({ months: -1 }))];
+		case "lastQuarter": return [(0, __internationalized_date.startOfMonth)(today$2.add({ months: -((today$2.month - 1) % 3) - 3 })), (0, __internationalized_date.endOfMonth)(today$2.add({ months: -((today$2.month - 1) % 3) - 1 }))];
+		case "lastWeek": return [(0, __internationalized_date.startOfWeek)(today$2, locale).add({ weeks: -1 }), (0, __internationalized_date.endOfWeek)(today$2, locale).add({ weeks: -1 })];
+		case "lastYear": return [(0, __internationalized_date.startOfYear)(today$2.add({ years: -1 })), (0, __internationalized_date.endOfYear)(today$2.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, 'constrainStart', {
+  enumerable: true,
+  get: function () {
+    return constrainStart;
+  }
+});
+Object.defineProperty(exports, 'constrainValue', {
+  enumerable: true,
+  get: function () {
+    return constrainValue;
+  }
+});
+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, 'getEndDate', {
+  enumerable: true,
+  get: function () {
+    return getEndDate;
+  }
+});
+Object.defineProperty(exports, 'getEndOfWeek', {
+  enumerable: true,
+  get: function () {
+    return getEndOfWeek;
+  }
+});
+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, '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, '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;
+  }
+});