@octane-xplat/ui 0.7.3 → 0.10.0

package/dist/web/datetime.js

@@ -0,0 +1,770 @@
+//#region src/datetime.ts
+/** The runtime's best-effort display locale — device locale on native,
+*  runtime locale on web; falls back to 'en' when Intl is reduced. */
+function resolveLocale(locale) {
+	if (locale) try {
+		return new Intl.DateTimeFormat(locale).resolvedOptions().locale;
+	} catch {}
+	try {
+		return new Intl.DateTimeFormat().resolvedOptions().locale || "en";
+	} catch {
+		return "en";
+	}
+}
+var DAY_MS = 864e5;
+function isLeapYear(year) {
+	return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function daysInMonth(year, month) {
+	if (month === 2) return isLeapYear(year) ? 29 : 28;
+	return [
+		4,
+		6,
+		9,
+		11
+	].includes(month) ? 30 : 31;
+}
+function toUTCEpoch(pd) {
+	const d = new Date(Date.UTC(pd.year, pd.month - 1, pd.day));
+	d.setUTCFullYear(pd.year);
+	return d.getTime();
+}
+function fromUTCEpoch(ms) {
+	const d = new Date(ms);
+	return {
+		year: d.getUTCFullYear(),
+		month: d.getUTCMonth() + 1,
+		day: d.getUTCDate()
+	};
+}
+function plainDateCreate(year, month, day) {
+	if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null;
+	if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return null;
+	return {
+		year,
+		month,
+		day
+	};
+}
+function plainDateFromDate(d) {
+	return {
+		year: d.getFullYear(),
+		month: d.getMonth() + 1,
+		day: d.getDate()
+	};
+}
+/** Local midnight — the only `Date` conversion; DST shifts cannot move the
+*  calendar day because the day is read back from the same local zone. */
+function plainDateToDate(pd) {
+	return new Date(pd.year, pd.month - 1, pd.day);
+}
+function plainDateToday() {
+	return plainDateFromDate(/* @__PURE__ */ new Date());
+}
+var ISO_DATE_RE = /^(\d{4,})-(\d{1,2})-(\d{1,2})$/;
+function plainDateFromISO(iso) {
+	const m = iso.match(ISO_DATE_RE);
+	if (!m) return null;
+	return plainDateCreate(Number(m[1]), Number(m[2]), Number(m[3]));
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function plainDateToISO(pd) {
+	return `${String(pd.year).padStart(4, "0")}-${pad2(pd.month)}-${pad2(pd.day)}`;
+}
+function plainDateAddDays(pd, days) {
+	return fromUTCEpoch(toUTCEpoch(pd) + days * DAY_MS);
+}
+/** Month arithmetic clamps to the target month's last day
+*  (Jan 31 + 1mo → Feb 28/29) instead of rolling into the next month. */
+function plainDateAddMonths(pd, months) {
+	const total = pd.year * 12 + (pd.month - 1) + months;
+	const year = Math.floor(total / 12);
+	const month = total % 12 + 1;
+	return {
+		year,
+		month,
+		day: Math.min(pd.day, daysInMonth(year, month))
+	};
+}
+/** Whole-day difference `a − b`; UTC epoch math makes it DST-free. */
+function plainDateDiffDays(a, b) {
+	return Math.round((toUTCEpoch(a) - toUTCEpoch(b)) / DAY_MS);
+}
+function plainDateIsBefore(a, b) {
+	return toUTCEpoch(a) < toUTCEpoch(b);
+}
+function plainDateIsAfter(a, b) {
+	return toUTCEpoch(a) > toUTCEpoch(b);
+}
+function plainDateIsEqual(a, b) {
+	return a.year === b.year && a.month === b.month && a.day === b.day;
+}
+/** ISO-8601 week number. */
+function plainDateGetWeekNumber(pd) {
+	const d = plainDateToDate(pd);
+	const dayNum = d.getDay() || 7;
+	d.setDate(d.getDate() + 4 - dayNum);
+	const yearStart = new Date(d.getFullYear(), 0, 1);
+	return Math.ceil(((d.getTime() - yearStart.getTime()) / DAY_MS + 1) / 7);
+}
+function normalizeDayOfWeek(value) {
+	if (value == null) return 0;
+	if (typeof value === "number") return value >= 0 && value <= 6 ? value : 0;
+	return DAY_NAME_INDEX[value.toLowerCase()] ?? 0;
+}
+var DAY_NAME_INDEX = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6,
+	sunday: 0,
+	monday: 1,
+	tuesday: 2,
+	wednesday: 3,
+	thursday: 4,
+	friday: 5,
+	saturday: 6
+};
+var SHORT_WEEKDAYS = {
+	af: [
+		"So.",
+		"Ma.",
+		"Di.",
+		"Wo.",
+		"Do.",
+		"Vr.",
+		"Sa."
+	],
+	ar: [
+		"أحد",
+		"إثنين",
+		"ثلاثاء",
+		"أربعاء",
+		"خميس",
+		"جمعة",
+		"سبت"
+	],
+	ca: [
+		"dg.",
+		"dl.",
+		"dt.",
+		"dc.",
+		"dj.",
+		"dv.",
+		"ds."
+	],
+	cs: [
+		"ne",
+		"po",
+		"út",
+		"st",
+		"čt",
+		"pá",
+		"so"
+	],
+	da: [
+		"sø.",
+		"ma.",
+		"ti.",
+		"on.",
+		"to.",
+		"fr.",
+		"lø."
+	],
+	de: [
+		"So.",
+		"Mo.",
+		"Di.",
+		"Mi.",
+		"Do.",
+		"Fr.",
+		"Sa."
+	],
+	el: [
+		"Κυ",
+		"Δε",
+		"Τρ",
+		"Τε",
+		"Πέ",
+		"Πα",
+		"Σά"
+	],
+	en: [
+		"Su",
+		"Mo",
+		"Tu",
+		"We",
+		"Th",
+		"Fr",
+		"Sa"
+	],
+	es: [
+		"DO",
+		"LU",
+		"MA",
+		"MI",
+		"JU",
+		"VI",
+		"SA"
+	],
+	fi: [
+		"su",
+		"ma",
+		"ti",
+		"ke",
+		"to",
+		"pe",
+		"la"
+	],
+	fr: [
+		"di",
+		"lu",
+		"ma",
+		"me",
+		"je",
+		"ve",
+		"sa"
+	],
+	he: [
+		"א׳",
+		"ב׳",
+		"ג׳",
+		"ד׳",
+		"ה׳",
+		"ו׳",
+		"ש׳"
+	],
+	hu: [
+		"V",
+		"H",
+		"K",
+		"Sze",
+		"Cs",
+		"P",
+		"Szo"
+	],
+	it: [
+		"dom",
+		"lun",
+		"mar",
+		"mer",
+		"gio",
+		"ven",
+		"sab"
+	],
+	ja: [
+		"日",
+		"月",
+		"火",
+		"水",
+		"木",
+		"金",
+		"土"
+	],
+	ko: [
+		"일",
+		"월",
+		"화",
+		"수",
+		"목",
+		"금",
+		"토"
+	],
+	nl: [
+		"zo",
+		"ma",
+		"di",
+		"wo",
+		"do",
+		"vr",
+		"za"
+	],
+	no: [
+		"sø.",
+		"ma.",
+		"ti.",
+		"on.",
+		"to.",
+		"fr.",
+		"lø."
+	],
+	pl: [
+		"nie",
+		"pon",
+		"wto",
+		"śro",
+		"czw",
+		"pią",
+		"sob"
+	],
+	pt: [
+		"dom.",
+		"seg.",
+		"ter.",
+		"qua.",
+		"qui.",
+		"sex.",
+		"sáb."
+	],
+	ro: [
+		"du.",
+		"lu.",
+		"ma.",
+		"mi.",
+		"joi",
+		"vi.",
+		"sâ."
+	],
+	ru: [
+		"вс",
+		"пн",
+		"вт",
+		"ср",
+		"чт",
+		"пт",
+		"сб"
+	],
+	sr: [
+		"не",
+		"по",
+		"ут",
+		"ср",
+		"че",
+		"пе",
+		"су"
+	],
+	sv: [
+		"sö",
+		"må",
+		"ti",
+		"on",
+		"to",
+		"fr",
+		"lö"
+	],
+	tr: [
+		"Pa",
+		"Pt",
+		"Sa",
+		"Ça",
+		"Pe",
+		"Cu",
+		"Ct"
+	],
+	uk: [
+		"нд",
+		"пн",
+		"вт",
+		"ср",
+		"чт",
+		"пт",
+		"сб"
+	],
+	vi: [
+		"CN",
+		"T2",
+		"T3",
+		"T4",
+		"T5",
+		"T6",
+		"T7"
+	],
+	zh: [
+		"周日",
+		"周一",
+		"周二",
+		"周三",
+		"周四",
+		"周五",
+		"周六"
+	]
+};
+function getStandaloneShortWeekdayNames(locale) {
+	try {
+		const parsed = new Intl.Locale(locale);
+		return SHORT_WEEKDAYS[parsed.baseName] ?? SHORT_WEEKDAYS[parsed.language] ?? SHORT_WEEKDAYS.en;
+	} catch {
+		return SHORT_WEEKDAYS.en;
+	}
+}
+var EN_MONTHS = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+var EN_MONTHS_SHORT = EN_MONTHS.map((m) => m.slice(0, 3));
+var EN_WEEKDAYS = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+function weekdayOf(pd) {
+	return plainDateToDate(pd).getDay();
+}
+function tryIntl(pd, options, locale) {
+	try {
+		return new Intl.DateTimeFormat(locale, {
+			...options,
+			calendar: "gregory"
+		}).format(plainDateToDate(pd));
+	} catch {
+		return null;
+	}
+}
+var DATE_FORMAT_WITH_WEEKDAY = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+var DATE_FORMAT_SHORT_WITH_WEEKDAY = {
+	weekday: "short",
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+};
+var DATE_FORMAT_LONG = {
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+var DATE_FORMAT_MONTH_YEAR = {
+	year: "numeric",
+	month: "long"
+};
+var DATE_FORMAT_SHORT_WITH_YEAR = {
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+};
+/** English fallback mirrors the US-en shape of each named format so a
+*  reduced-Intl runtime still produces a complete date string. */
+function fallbackFormat(pd, options) {
+	const m = EN_MONTHS[pd.month - 1];
+	const ms = EN_MONTHS_SHORT[pd.month - 1];
+	const wd = EN_WEEKDAYS[weekdayOf(pd)];
+	const wds = wd.slice(0, 3);
+	const parts = [];
+	if (options.weekday === "long") parts.push(`${wd},`);
+	else if (options.weekday) parts.push(`${wds},`);
+	if (options.month === "long") parts.push(options.day ? `${m} ${pd.day}` : m);
+	else if (options.month === "short") parts.push(`${ms} ${pd.day}`);
+	else if (options.day) parts.push(String(pd.day));
+	if (options.year) parts.push(String(pd.year));
+	return parts.join(" ");
+}
+function plainDateFormat(pd, options, locale) {
+	return tryIntl(pd, options, locale ?? resolveLocale()) ?? fallbackFormat(pd, options);
+}
+function formatMonthYear(year, month, locale) {
+	return plainDateFormat({
+		year,
+		month,
+		day: 1
+	}, DATE_FORMAT_MONTH_YEAR, locale);
+}
+var SHARED_FORMAT_OPTIONS = {
+	date: DATE_FORMAT_SHORT_WITH_YEAR,
+	date_long: DATE_FORMAT_LONG,
+	date_weekday: DATE_FORMAT_SHORT_WITH_WEEKDAY
+};
+function formatSharedDate(pd, format, locale) {
+	if (format === "system_date") return plainDateToISO(pd);
+	return plainDateFormat(pd, SHARED_FORMAT_OPTIONS[format], locale);
+}
+function formatDateValue(iso, format, locale) {
+	const pd = plainDateFromISO(iso);
+	if (!pd) return iso;
+	if (typeof format === "function") return format(iso);
+	return formatSharedDate(pd, format ?? "date_long", locale);
+}
+function isLocaleDayFirst(locale) {
+	try {
+		const parts = new Intl.DateTimeFormat(locale ?? resolveLocale(), { calendar: "gregory" }).formatToParts(new Date(2e3, 0, 15));
+		return parts.findIndex((p) => p.type === "day") < parts.findIndex((p) => p.type === "month");
+	} catch {
+		return false;
+	}
+}
+var MONTH_NAME_INDEX = {
+	january: 1,
+	jan: 1,
+	february: 2,
+	feb: 2,
+	march: 3,
+	mar: 3,
+	april: 4,
+	apr: 4,
+	may: 5,
+	june: 6,
+	jun: 6,
+	july: 7,
+	jul: 7,
+	august: 8,
+	aug: 8,
+	september: 9,
+	sep: 9,
+	sept: 9,
+	october: 10,
+	oct: 10,
+	november: 11,
+	nov: 11,
+	december: 12,
+	dec: 12
+};
+function parseMonthName(name) {
+	return MONTH_NAME_INDEX[name.toLowerCase()] ?? null;
+}
+function parseNumericPair(first, second, year, locale) {
+	let day;
+	let month;
+	if (first > 12 && second <= 12) {
+		day = first;
+		month = second;
+	} else if (second > 12 && first <= 12) {
+		month = first;
+		day = second;
+	} else if (first > 12 && second > 12) return null;
+	else if (isLocaleDayFirst(locale)) {
+		day = first;
+		month = second;
+	} else {
+		month = first;
+		day = second;
+	}
+	return plainDateCreate(year, month, day);
+}
+/** Parses typed input into a PlainDate — `YYYY-MM-DD`, English month-name
+*  forms ("March 5", "5 March 2026"), and numeric `M/D/YY` or `D/M/YY`
+*  (ambiguity resolved by the locale's day/month order). Returns null for
+*  unparseable or out-of-range input. */
+function parseDateInput(input, locale) {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+	const iso = trimmed.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+	if (iso) return plainDateCreate(Number(iso[1]), Number(iso[2]), Number(iso[3]));
+	let m = trimmed.match(/^([a-zA-Z]+)\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s*(\d{4}))?$/);
+	if (m) {
+		const month = parseMonthName(m[1]);
+		if (month != null) return plainDateCreate(Number(m[3] ?? currentYear), month, Number(m[2]));
+	}
+	m = trimmed.match(/^(\d{1,2})(?:st|nd|rd|th)?\s+([a-zA-Z]+)(?:,?\s*(\d{4}))?$/);
+	if (m) {
+		const month = parseMonthName(m[2]);
+		if (month != null) return plainDateCreate(Number(m[3] ?? currentYear), month, Number(m[1]));
+	}
+	m = trimmed.match(/^(\d{4})[/.\s](\d{1,2})[/.\s](\d{1,2})$/);
+	if (m) return plainDateCreate(Number(m[1]), Number(m[2]), Number(m[3]));
+	m = trimmed.match(/^(\d{1,2})[/.\-\s](\d{1,2})[/.\-\s](\d{4})$/);
+	if (m) return parseNumericPair(Number(m[1]), Number(m[2]), Number(m[3]), locale);
+	m = trimmed.match(/^(\d{1,2})[/.\-\s](\d{1,2})[/.\-\s](\d{2})$/);
+	if (m) {
+		const y = Number(m[3]);
+		return parseNumericPair(Number(m[1]), Number(m[2]), y <= 68 ? 2e3 + y : 1900 + y, locale);
+	}
+	m = trimmed.match(/^(\d{1,2})[/.\-\s](\d{1,2})$/);
+	if (m) return parseNumericPair(Number(m[1]), Number(m[2]), currentYear, locale);
+	return null;
+}
+/** Validate + normalize an `HH:MM[:SS]` string. Returns null when invalid. */
+function parseISOTime(time) {
+	const m = time.match(/^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/);
+	if (!m) return null;
+	const hour = Number(m[1]);
+	const minute = Number(m[2]);
+	const second = m[3] != null ? Number(m[3]) : 0;
+	if (hour > 23 || minute > 59 || second > 59) return null;
+	return {
+		hour,
+		minute,
+		second
+	};
+}
+function formatISOTime(time, includeSeconds = false) {
+	const base = `${pad2(time.hour)}:${pad2(time.minute)}`;
+	return includeSeconds ? `${base}:${pad2(time.second)}` : base;
+}
+function formatDisplayTime12h(time, includeSeconds = false) {
+	const p = parseISOTime(time);
+	if (!p) return time;
+	const h12 = p.hour % 12 || 12;
+	const ampm = p.hour < 12 ? "AM" : "PM";
+	const min = pad2(p.minute);
+	return includeSeconds ? `${h12}:${min}:${pad2(p.second)} ${ampm}` : `${h12}:${min} ${ampm}`;
+}
+function formatDisplayTime24h(time, includeSeconds = false) {
+	const p = parseISOTime(time);
+	if (!p) return time;
+	const base = `${pad2(p.hour)}:${pad2(p.minute)}`;
+	return includeSeconds ? `${base}:${pad2(p.second)}` : base;
+}
+/** Typed time input: accepts "2:30 PM", "14:30", "1430", "2pm", "143000"
+*  and ISO `HH:MM[:SS]`; returns a normalized ISOTimeString or null. */
+function parseTimeInput(input, includeSeconds = false) {
+	const trimmed = input.trim().toLowerCase();
+	if (!trimmed) return null;
+	const isPM = /p\.?m?\.?\s*$/i.test(trimmed);
+	const isAM = /a\.?m?\.?\s*$/i.test(trimmed);
+	const hasMeridiem = isPM || isAM;
+	const timeStr = trimmed.replace(/\s*[ap]\.?m?\.?\s*$/i, "").trim();
+	const to24 = (hour) => {
+		if (!hasMeridiem) return hour;
+		if (hour < 1 || hour > 12) return null;
+		if (isPM && hour !== 12) return hour + 12;
+		if (isAM && hour === 12) return 0;
+		return hour;
+	};
+	if (/^\d{1,2}$/.test(timeStr)) {
+		const hour = Number(timeStr);
+		const hour24 = to24(hour);
+		if (hour24 != null && hour24 >= 0 && hour24 <= 23 && (hasMeridiem || hour <= 23)) return formatISOTime({
+			hour: hour24,
+			minute: 0,
+			second: 0
+		}, includeSeconds);
+		return null;
+	}
+	if (/^\d{4}$/.test(timeStr)) {
+		const hour24 = to24(Number(timeStr.slice(0, 2)));
+		const minute = Number(timeStr.slice(2, 4));
+		if (hour24 != null && hour24 <= 23 && minute <= 59) return formatISOTime({
+			hour: hour24,
+			minute,
+			second: 0
+		}, includeSeconds);
+		return null;
+	}
+	if (/^\d{6}$/.test(timeStr)) {
+		const hour24 = to24(Number(timeStr.slice(0, 2)));
+		const minute = Number(timeStr.slice(2, 4));
+		const second = Number(timeStr.slice(4, 6));
+		if (hour24 != null && hour24 <= 23 && minute <= 59 && second <= 59) return formatISOTime({
+			hour: hour24,
+			minute,
+			second
+		}, includeSeconds);
+		return null;
+	}
+	const parts = timeStr.split(":");
+	if (parts.length >= 2 && parts.length <= 3) {
+		const hour = Number(parts[0]);
+		const minute = Number(parts[1]);
+		const second = parts.length === 3 ? Number(parts[2]) : 0;
+		if (!Number.isFinite(hour) || !Number.isFinite(minute) || !Number.isFinite(second)) return null;
+		if (minute > 59 || second > 59 || minute < 0 || second < 0) return null;
+		const hour24 = hasMeridiem ? to24(hour) : hour <= 23 ? hour : null;
+		if (hour24 == null) return null;
+		return formatISOTime({
+			hour: hour24,
+			minute,
+			second
+		}, includeSeconds);
+	}
+	return null;
+}
+function compareTime(a, b) {
+	const pa = parseISOTime(a);
+	const pb = parseISOTime(b);
+	if (!pa || !pb) return 0;
+	return pa.hour * 3600 + pa.minute * 60 + pa.second - (pb.hour * 3600 + pb.minute * 60 + pb.second);
+}
+function isTimeInRange(time, min, max) {
+	if (min && compareTime(time, min) < 0) return false;
+	if (max && compareTime(time, max) > 0) return false;
+	return true;
+}
+/** Step a time by whole minutes, wrapping around midnight. */
+function adjustTime(time, deltaMinutes, includeSeconds = false) {
+	const p = parseISOTime(time);
+	if (!p || !Number.isFinite(deltaMinutes)) return time;
+	const total = ((p.hour * 60 + p.minute + deltaMinutes) % 1440 + 1440) % 1440;
+	return formatISOTime({
+		hour: Math.floor(total / 60),
+		minute: total % 60,
+		second: p.second
+	}, includeSeconds);
+}
+function splitDateTime(dt) {
+	if (!dt) return {};
+	const i = dt.indexOf("T");
+	if (i === -1) return { date: dt };
+	return {
+		date: dt.slice(0, i),
+		time: dt.slice(i + 1)
+	};
+}
+function combineDateTime(date, time) {
+	if (!date || !time) return;
+	return `${date}T${time}`;
+}
+function currentISOTime(includeSeconds = false) {
+	const now = /* @__PURE__ */ new Date();
+	return formatISOTime({
+		hour: now.getHours(),
+		minute: now.getMinutes(),
+		second: now.getSeconds()
+	}, includeSeconds);
+}
+/** Map the deprecated `nativePicker` vocabulary onto `presentation`
+*  (`touch` → adaptive-native, `always` → native, `never` → the Astryx
+*  surface: bottom-sheet for pickers, text-input for TimeInput). */
+function presentationFromNativePicker(nativePicker, kind) {
+	if (nativePicker === void 0) return;
+	switch (nativePicker) {
+		case "touch": return "adaptive-native";
+		case "always": return "native";
+		case "never": return kind === "time" ? "text-input" : "adaptive-bottom-sheet";
+	}
+}
+/** `presentation` wins over the deprecated `nativePicker`. */
+function effectivePresentation(presentation, nativePicker, kind) {
+	return presentation ?? presentationFromNativePicker(nativePicker, kind) ?? "adaptive-native";
+}
+/**
+* Resolve a presentation + pointer coarseness to a concrete surface.
+* On native targets pass `isCoarsePointer = true`; `native` there is
+* remapped by each component leaf (the OS-authentic pickers live in the
+* `@octane-xplat/date-picker` leaf — ui-internal `native` resolves to the
+* self-drawn `sheet` surface).
+*/
+function resolveInputSurface(effective, isCoarsePointer) {
+	switch (effective) {
+		case "text-input": return "typed";
+		case "popover": return "popover";
+		case "bottom-sheet": return "sheet";
+		case "native": return "native";
+		case "adaptive-bottom-sheet": return isCoarsePointer ? "sheet" : "popover";
+		case "adaptive-native": return isCoarsePointer ? "native" : "popover";
+	}
+}
+/** Localized wall-clock display; ISO time remains zone-free and parsing bounded. */
+function formatLocalizedTime(time, hasSeconds, hourFormat, locale) {
+	const parsed = parseISOTime(time);
+	if (!parsed) return time;
+	return new Intl.DateTimeFormat(locale, {
+		hour: "numeric",
+		minute: "2-digit",
+		...hasSeconds ? { second: "2-digit" } : {},
+		hourCycle: hourFormat === "24h" ? "h23" : "h12",
+		timeZone: "UTC"
+	}).format(new Date(Date.UTC(2e3, 0, 1, parsed.hour, parsed.minute, parsed.second ?? 0)));
+}
+//#endregion
+export { DATE_FORMAT_LONG, DATE_FORMAT_MONTH_YEAR, DATE_FORMAT_SHORT_WITH_WEEKDAY, DATE_FORMAT_SHORT_WITH_YEAR, DATE_FORMAT_WITH_WEEKDAY, adjustTime, combineDateTime, compareTime, currentISOTime, daysInMonth, effectivePresentation, formatDateValue, formatDisplayTime12h, formatDisplayTime24h, formatISOTime, formatLocalizedTime, formatMonthYear, formatSharedDate, getStandaloneShortWeekdayNames, isLocaleDayFirst, isTimeInRange, normalizeDayOfWeek, parseDateInput, parseISOTime, parseTimeInput, plainDateAddDays, plainDateAddMonths, plainDateCreate, plainDateDiffDays, plainDateFormat, plainDateFromDate, plainDateFromISO, plainDateGetWeekNumber, plainDateIsAfter, plainDateIsBefore, plainDateIsEqual, plainDateToDate, plainDateToISO, plainDateToday, presentationFromNativePicker, resolveInputSurface, resolveLocale, splitDateTime };