@astryx-vue/core 0.3.0 → 0.4.1

package/dist/utils-z3Q6BGIJ.js

@@ -0,0 +1,819 @@
+//#region src/utils/chainEventHandlers.ts
+/**
+* 把多个事件处理函数串成一个。每个函数都会按参数顺序执行。
+*
+* 和「前一个调用了 preventDefault 就跳过后面」不同：组件自己的处理函数
+* 不能把事件藏起来，调用方也不能用 preventDefault 取消组件的行为。
+*/
+function chainEventHandlers(...handlers) {
+	return (event) => {
+		for (const handler of handlers) handler?.(event);
+	};
+}
+//#endregion
+//#region src/utils/plainDate.ts
+function plainDateCreate(year, month, day) {
+	if (!Number.isInteger(year) || year < 1) throw new RangeError(`year must be a positive integer, got ${year}`);
+	if (!Number.isInteger(month) || month < 1 || month > 12) throw new RangeError(`month must be 1–12, got ${month}`);
+	const maxDay = getDaysInMonth(year, month);
+	if (!Number.isInteger(day) || day < 1 || day > maxDay) throw new RangeError(`day must be 1–${maxDay} for ${year}-${String(month).padStart(2, "0")}, got ${day}`);
+	return {
+		year,
+		month,
+		day
+	};
+}
+function plainDateFromISO(str) {
+	const [year, month, day] = str.split("-").map(Number);
+	return plainDateCreate(year, month, day);
+}
+function plainDateToISO(pd) {
+	return `${String(pd.year).padStart(4, "0")}-${String(pd.month).padStart(2, "0")}-${String(pd.day).padStart(2, "0")}`;
+}
+function plainDateToDate(pd) {
+	const d = new Date(0, 0, 1);
+	d.setFullYear(pd.year, pd.month - 1, pd.day);
+	return d;
+}
+function plainDateFromDate(d) {
+	return {
+		year: d.getFullYear(),
+		month: d.getMonth() + 1,
+		day: d.getDate()
+	};
+}
+function plainDateToday() {
+	return plainDateFromDate(/* @__PURE__ */ new Date());
+}
+function getDaysInMonth(year, month) {
+	if (month === 2) return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28;
+	return [
+		0,
+		31,
+		0,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	][month];
+}
+function plainDateDayOfWeek(pd) {
+	return plainDateToDate(pd).getDay();
+}
+function plainDateAddMonths(pd, n) {
+	const totalMonths = pd.year * 12 + (pd.month - 1) + n;
+	const year = Math.floor(totalMonths / 12);
+	const month = (totalMonths % 12 + 12) % 12 + 1;
+	return {
+		year,
+		month,
+		day: Math.min(pd.day, getDaysInMonth(year, month))
+	};
+}
+function plainDateAddDays(pd, n) {
+	const d = plainDateToDate(pd);
+	d.setDate(d.getDate() + n);
+	return plainDateFromDate(d);
+}
+/**
+* `Date.UTC` with years 0-99 kept as given; `Date.UTC` itself reads them as
+* 1900-1999.
+*/
+function utcTime(year, monthIndex, day, hour = 0, minute = 0, second = 0) {
+	const d = /* @__PURE__ */ new Date(0);
+	d.setUTCFullYear(year, monthIndex, day);
+	d.setUTCHours(hour, minute, second);
+	return d.getTime();
+}
+/**
+* Whole calendar days from `a` to `b`, ignoring time of day. Positive when
+* `b` is after `a`, negative when before. Uses UTC midnight so DST shifts
+* never add or drop a day.
+*/
+function plainDateDiffDays(a, b) {
+	const msPerDay = 864e5;
+	const aUTC = utcTime(a.year, a.month - 1, a.day);
+	const bUTC = utcTime(b.year, b.month - 1, b.day);
+	return Math.round((bUTC - aUTC) / msPerDay);
+}
+/**
+* The wall-clock fields an instant reads as in a given zone.
+*
+* A fixed `'en-US'` locale with `hourCycle: 'h23'` keeps the parts numeric and
+* stable whatever locale the viewer has, so callers can assemble machine
+* shapes (`YYYY-MM-DD`, `HH:mm:ss`) from them. Exported for Timestamp, whose
+* `system_*` formats are built from these fields rather than through `Intl`
+* formatting.
+*/
+function getTimeZoneParts(instant, timezoneID) {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezoneID,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hourCycle: "h23",
+		calendar: "gregory"
+	}).formatToParts(new Date(instant));
+	const lookup = Object.fromEntries(parts.filter((part) => part.type !== "literal").map((part) => [part.type, Number(part.value)]));
+	return {
+		year: lookup.year,
+		month: lookup.month,
+		day: lookup.day,
+		hour: lookup.hour,
+		minute: lookup.minute,
+		second: lookup.second
+	};
+}
+function getTimezoneOffsetMS(timezoneID, instant) {
+	const parts = getTimeZoneParts(instant, timezoneID);
+	return utcTime(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second) - instant;
+}
+const DAY_MS = 864e5;
+function plainDateToInstant(date, timezoneID, hour = 0, minute = 0) {
+	const wallTime = utcTime(date.year, date.month - 1, date.day, hour, minute);
+	const offsetBefore = getTimezoneOffsetMS(timezoneID, wallTime - DAY_MS);
+	const offsetAfter = getTimezoneOffsetMS(timezoneID, wallTime + DAY_MS);
+	const candidates = [offsetBefore, offsetAfter].map((offset) => wallTime - offset).filter((instant, index) => getTimezoneOffsetMS(timezoneID, instant) === (index === 0 ? offsetBefore : offsetAfter));
+	return candidates.length > 0 ? Math.min(...candidates) : wallTime - offsetBefore;
+}
+function plainDateFromInstant(instant, timezoneID) {
+	const parts = getTimeZoneParts(instant, timezoneID);
+	return plainDateCreate(parts.year, parts.month, parts.day);
+}
+function compare(a, b) {
+	if (a.year !== b.year) return a.year - b.year;
+	if (a.month !== b.month) return a.month - b.month;
+	return a.day - b.day;
+}
+function plainDateIsBefore(a, b) {
+	return compare(a, b) < 0;
+}
+function plainDateIsAfter(a, b) {
+	return compare(a, b) > 0;
+}
+function plainDateIsEqual(a, b) {
+	return compare(a, b) === 0;
+}
+function plainDateMax(a, b) {
+	return compare(a, b) >= 0 ? a : b;
+}
+function plainDateMin(a, b) {
+	return compare(a, b) <= 0 ? a : b;
+}
+function plainDateIsInRange(pd, range) {
+	return compare(pd, range[0]) >= 0 && compare(pd, range[1]) <= 0;
+}
+function plainDateSetFirstOfMonth(pd) {
+	return {
+		year: pd.year,
+		month: pd.month,
+		day: 1
+	};
+}
+function plainDateSetStartOfWeek(pd, weekStartsOn) {
+	return plainDateAddDays(pd, -((plainDateDayOfWeek(pd) - weekStartsOn + 7) % 7));
+}
+function plainDateSetEndOfWeekExclusive(pd, weekStartsOn) {
+	return plainDateAddDays(plainDateSetStartOfWeek(pd, weekStartsOn), 7);
+}
+function plainDateGetWeekNumber(pd) {
+	const d = plainDateToDate(pd);
+	const dayNum = d.getDay() || 7;
+	d.setDate(d.getDate() + 4 - dayNum);
+	const yearStart = plainDateToDate({
+		year: d.getFullYear(),
+		month: 1,
+		day: 1
+	});
+	return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+const DATE_FORMAT_WITH_WEEKDAY = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+const DATE_FORMAT_SHORT_WITH_WEEKDAY = {
+	weekday: "short",
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+};
+const DATE_FORMAT_LONG = {
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+const DATE_FORMAT_MONTH_YEAR = {
+	year: "numeric",
+	month: "long"
+};
+const DATE_FORMAT_WEEKDAY_ONLY = { weekday: "short" };
+const DATE_FORMAT_MONTH_ONLY = { month: "long" };
+const DATE_FORMAT_SHORT = {
+	month: "short",
+	day: "numeric"
+};
+const DATE_FORMAT_SHORT_WITH_YEAR = {
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+};
+/**
+* Format a `PlainDate` for display.
+*
+* The locale defaults to the same `'en'` fallback as `useLocale()`, avoiding
+* runtime-dependent output when no provider locale is available. Astryx date
+* APIs currently model Gregorian dates, so this helper defaults to Gregorian
+* when `options.calendar` is omitted. The explicit option remains supported for
+* compatibility with the public `Intl.DateTimeFormatOptions` signature; it is a
+* display-only escape hatch and does not change PlainDate arithmetic, parsing,
+* serialization, or any Astryx component's calendar semantics.
+*/
+function plainDateFormat(pd, options, locale = "en") {
+	return new Intl.DateTimeFormat(locale, {
+		...options,
+		calendar: options.calendar ?? "gregory"
+	}).format(plainDateToDate(pd));
+}
+/**
+* The locale's name for the "week of year" date field ("week", "Woche", "週"),
+* from CLDR through `Intl.DisplayNames`. Calendar names its week-number
+* column header with it, so no catalog string is needed for a word the
+* platform already carries in every locale.
+*
+* `Intl.DisplayNames` with `type: 'dateTimeField'` is inside the Baseline − 2
+* support tier (Chrome 106, Safari 15.4, Firefox 110). Should a host lack it
+* or return nothing, the field's English CLDR name stands in rather than an
+* empty header.
+*/
+function plainDateWeekFieldName(locale = "en") {
+	try {
+		const name = new Intl.DisplayNames(locale, { type: "dateTimeField" }).of("weekOfYear");
+		if (name != null && name !== "") return name;
+	} catch {}
+	return "week";
+}
+/**
+* Intl option bags for the locale-aware shared date members. `system_date` is
+* intentionally absent — it is emitted as a fixed ISO `YYYY-MM-DD` string, not
+* via `Intl` — and is handled directly by {@link formatSharedDate}.
+*
+* This is the single source of truth consumed by both Timestamp's
+* `formatTimestamp` switch and DateInput's display path, so the two never
+* drift for the members they share.
+*/
+const SHARED_DATE_FORMAT_OPTIONS = {
+	date: DATE_FORMAT_SHORT_WITH_YEAR,
+	date_long: DATE_FORMAT_LONG,
+	date_weekday: DATE_FORMAT_SHORT_WITH_WEEKDAY
+};
+/**
+* Renders a {@link PlainDate} using one of the {@link SharedDateFormat}
+* members. The shared entry point DateInput uses for the named-format path;
+* Timestamp maps the same members onto {@link SHARED_DATE_FORMAT_OPTIONS} in
+* its own `formatTimestamp` switch (its input is a `Date`, not a `PlainDate`).
+*/
+function formatSharedDate(pd, format, locale = "en") {
+	if (format === "system_date") return plainDateToISO(pd);
+	return plainDateFormat(pd, SHARED_DATE_FORMAT_OPTIONS[format], locale);
+}
+//#endregion
+//#region src/utils/dateParser.ts
+/**
+* Detects if the locale uses day-first date format (DD/MM/YYYY).
+* US and a few others use month-first (MM/DD/YYYY).
+*/
+function isLocaleDayFirst(locale = "en") {
+	const parts = new Intl.DateTimeFormat(locale, { calendar: "gregory" }).formatToParts(new Date(2e3, 0, 15));
+	return parts.findIndex((p) => p.type === "day") < parts.findIndex((p) => p.type === "month");
+}
+/**
+* Parses user input into a PlainDate.
+*
+* Supports ISO dates, English month names, and ASCII numeric dates with or
+* without a year. For ambiguous ASCII numeric input where both fields are at
+* most 12, `locale` selects month-first versus day-first order. It does not
+* localize month-name parsing, accept non-ASCII digits, or provide a general
+* locale-aware parser.
+*
+* @returns PlainDate if valid, null if unparseable
+*/
+function parseDateInput(input, locale = "en") {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+	const isoMatch = trimmed.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+	if (isoMatch) {
+		const [, year, month, day] = isoMatch;
+		return tryCreatePlainDate(+year, +month, +day);
+	}
+	const monthFirstWithYearMatch = trimmed.match(/^([A-Z]+)\s+(\d{1,2}),?\s+(\d{4})$/i);
+	if (monthFirstWithYearMatch) {
+		const [, monthName, day, year] = monthFirstWithYearMatch;
+		const month = parseMonthName(monthName);
+		if (month !== null) return tryCreatePlainDate(+year, month, +day);
+	}
+	const dayFirstWithYearMatch = trimmed.match(/^(\d{1,2})\s+([A-Z]+),?\s+(\d{4})$/i);
+	if (dayFirstWithYearMatch) {
+		const [, day, monthName, year] = dayFirstWithYearMatch;
+		const month = parseMonthName(monthName);
+		if (month !== null) return tryCreatePlainDate(+year, month, +day);
+	}
+	const monthFirstNoYearMatch = trimmed.match(/^([A-Z]+)\s+(\d{1,2})$/i);
+	if (monthFirstNoYearMatch) {
+		const [, monthName, day] = monthFirstNoYearMatch;
+		const month = parseMonthName(monthName);
+		if (month !== null) return tryCreatePlainDate(currentYear, month, +day);
+	}
+	const dayFirstNoYearMatch = trimmed.match(/^(\d{1,2})\s+([A-Z]+)$/i);
+	if (dayFirstNoYearMatch) {
+		const [, day, monthName] = dayFirstNoYearMatch;
+		const month = parseMonthName(monthName);
+		if (month !== null) return tryCreatePlainDate(currentYear, month, +day);
+	}
+	const numericWithYearMatch = trimmed.match(/^(\d{1,2})([-/.])(\d{1,2})([-/.])(\d{4})$/);
+	if (numericWithYearMatch) {
+		const [, first, sep1, second, sep2, year] = numericWithYearMatch;
+		if (sep1 !== sep2) return null;
+		return parseNumericDate(+first, +second, +year, locale);
+	}
+	const numericNoYearMatch = trimmed.match(/^(\d{1,2})[-/.](\d{1,2})$/);
+	if (numericNoYearMatch) {
+		const [, first, second] = numericNoYearMatch;
+		return parseNumericDate(+first, +second, currentYear, locale);
+	}
+	if (/^\d+$/.test(trimmed)) return null;
+	const parsed = new Date(trimmed);
+	if (!Number.isNaN(parsed.getTime())) {
+		const fromDate = plainDateFromDate(parsed);
+		return tryCreatePlainDate(fromDate.year, fromDate.month, fromDate.day);
+	}
+	return null;
+}
+function parseNumericDate(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 tryCreatePlainDate(year, month, day);
+}
+function parseMonthName(name) {
+	return {
+		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
+	}[name.toLowerCase()] ?? null;
+}
+function tryCreatePlainDate(year, month, day) {
+	try {
+		return plainDateCreate(year, month, day);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/utils/dateTypes.ts
+/** Weekday names indexed by {@link DayOfWeek} (0 = Sunday). */
+const WEEKDAY_NAMES = [
+	"sun",
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat"
+];
+/**
+* Normalize a weekday to its numeric {@link DayOfWeek}. Accepts either a
+* number (0–6) or a three-letter day name ('sun'–'sat', case-insensitive),
+* so APIs like `weekStartsOn` can take whichever is more readable at the
+* call site. Unrecognized values fall back to 0 (Sunday).
+*/
+function normalizeDayOfWeek(value) {
+	if (typeof value === "number") return value;
+	const index = WEEKDAY_NAMES.indexOf(value.toLowerCase());
+	return index === -1 ? 0 : index;
+}
+//#endregion
+//#region src/utils/groupItems.ts
+/** 读出条目上的组名。不是字符串就不算分组。空字符串仍算一个组名。 */
+function getItemGroup(item) {
+	const aux = item.auxiliaryData;
+	if (aux == null || typeof aux !== "object") return void 0;
+	const group = aux.group;
+	return typeof group === "string" ? group : void 0;
+}
+/**
+* 按 `auxiliaryData.group` 分组，组的先后跟它们第一次出现的顺序。
+* 没有任何组名时，返回一组 `heading: null`。
+*/
+function groupItems(items, { ungroupedFirst = false } = {}) {
+	if (!items.some((item) => getItemGroup(item) != null)) return [{
+		heading: null,
+		items: [...items]
+	}];
+	const groupOrder = [];
+	const groups = /* @__PURE__ */ new Map();
+	const ungrouped = [];
+	for (const item of items) {
+		const group = getItemGroup(item);
+		if (group != null) {
+			const list = groups.get(group);
+			if (list) list.push(item);
+			else {
+				groupOrder.push(group);
+				groups.set(group, [item]);
+			}
+		} else ungrouped.push(item);
+	}
+	const namedGroups = groupOrder.map((heading) => ({
+		heading,
+		items: groups.get(heading) ?? []
+	}));
+	const ungroupedGroup = ungrouped.length > 0 ? [{
+		heading: null,
+		items: ungrouped
+	}] : [];
+	return ungroupedFirst ? [...ungroupedGroup, ...namedGroups] : [...namedGroups, ...ungroupedGroup];
+}
+//#endregion
+//#region src/utils/inputAria.ts
+function joinAriaIDs(...values) {
+	const ids = values.flatMap((value) => typeof value === "string" ? value.trim().split(/\s+/) : []).filter(Boolean);
+	if (ids.length === 0) return;
+	return Array.from(new Set(ids)).join(" ");
+}
+/**
+* Builds ARIA label/description wiring for an input.
+*
+* Standalone inputs keep their normal native label association. Grouped inputs
+* are named by the visible InputGroup label plus their own input label, and
+* inherit group description/status text in addition to input-local text.
+*/
+function getInputARIA(labelID, describedByIDs = [], inputGroup) {
+	return {
+		ariaLabelledBy: inputGroup ? joinAriaIDs(inputGroup.labelID, labelID) : void 0,
+		ariaDescribedBy: joinAriaIDs(inputGroup?.describedByIDs, ...describedByIDs)
+	};
+}
+//#endregion
+//#region src/utils/parseStyleKey.ts
+/** 把驼峰属性名变成主题用的 data 属性名，例如 listStyle → data-list-style。 */
+function themeDataAttributeName(prop) {
+	return `data-${prop.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}`;
+}
+/** 双引号 CSS 属性选择器里的值转义。 */
+function escapeAttributeValue(value) {
+	let escaped = "";
+	for (const char of value) {
+		const codePoint = char.codePointAt(0) ?? 0;
+		if (char === "\"" || char === "\\" || codePoint < 32 || codePoint === 127) escaped += `\\${(codePoint === 0 ? 65533 : codePoint).toString(16)} `;
+		else escaped += char;
+	}
+	return escaped;
+}
+/**
+* 把组件样式键编成 data 属性选择器后缀。
+*
+* `prop:value` 选择 `[data-prop="value"]`。裸状态选择 `[data-state="state"]`。
+* `+` 把多个条件接在同一个组件目标上。轴名留在选择器里，避免不同属性的相同值撞在一起。
+*
+* @example
+* parseStyleKey('base') // ''
+* parseStyleKey('variant:secondary') // '[data-variant="secondary"]'
+* parseStyleKey('checked+disabled') // '[data-checked="checked"][data-disabled="disabled"]'
+*/
+function parseStyleKey(key) {
+	if (key === "base") return "";
+	return key.split("+").map((part) => {
+		const separator = part.indexOf(":");
+		const prop = separator === -1 ? part : part.slice(0, separator);
+		const value = separator === -1 ? part : part.slice(separator + 1);
+		return `[${themeDataAttributeName(prop)}="${escapeAttributeValue(value)}"]`;
+	}).join("");
+}
+//#endregion
+//#region src/utils/sharedResizeObserver.ts
+let observer = null;
+const callbacks = /* @__PURE__ */ new Map();
+/**
+* The shared observer, or null where the API does not exist (jsdom, an old
+* browser). Callers still get the one-shot measurement `observeResize` fires
+* on registration; live resize updates are the part that needs the API.
+*/
+function getObserver() {
+	if (typeof ResizeObserver === "undefined") return null;
+	if (!observer) observer = new ResizeObserver((entries) => {
+		for (const entry of entries) {
+			const targetCallbacks = callbacks.get(entry.target);
+			if (targetCallbacks) for (const cb of [...targetCallbacks.keys()]) cb(entry);
+		}
+	});
+	return observer;
+}
+/**
+* Observe an element's size via a shared ResizeObserver singleton.
+*
+* Fires the callback once synchronously on registration (with a
+* synthetic entry) so callers don't need separate initial-measurement
+* logic. Subsequent callbacks fire on actual resizes.
+*
+* Returns an unsubscribe function that removes only this registration, leaving
+* every other observer of the same element intact — prefer it over
+* `unobserveResize(element)`, which drops them all. The shared observer is
+* destroyed when the last element is unobserved.
+*
+* @example
+* ```
+* const unsubscribe = observeResize(element, (entry) => {
+*   console.log(entry.contentBoxSize);
+* });
+*
+* // Cleanup:
+* unsubscribe();
+* ```
+*/
+function observeResize(element, callback) {
+	const existing = callbacks.get(element);
+	if (existing) existing.set(callback, (existing.get(callback) ?? 0) + 1);
+	else callbacks.set(element, /* @__PURE__ */ new Map([[callback, 1]]));
+	getObserver()?.observe(element);
+	callback({ target: element });
+	let isSubscribed = true;
+	return () => {
+		if (!isSubscribed) return;
+		isSubscribed = false;
+		unobserveResize(element, callback);
+	};
+}
+/**
+* Stop observing an element.
+*
+* Pass the callback to remove only that registration — the unsubscribe returned
+* by `observeResize` does this for you. Omitting it removes EVERY callback on
+* the element, which silences peers that are still mounted, so it is only
+* correct for a caller that owns the element outright.
+*
+* If no elements remain, the shared observer is disconnected and released for
+* garbage collection.
+*/
+function unobserveResize(element, callback) {
+	const targetCallbacks = callbacks.get(element);
+	if (callback != null) {
+		const registrationCount = targetCallbacks?.get(callback);
+		if (targetCallbacks == null || registrationCount == null) return;
+		if (registrationCount > 1) {
+			targetCallbacks.set(callback, registrationCount - 1);
+			return;
+		}
+		targetCallbacks.delete(callback);
+		if (targetCallbacks.size > 0) return;
+	}
+	callbacks.delete(element);
+	if (observer) {
+		observer.unobserve(element);
+		if (callbacks.size === 0) {
+			observer.disconnect();
+			observer = null;
+		}
+	}
+}
+//#endregion
+//#region src/utils/timeParser.ts
+/**
+* Validates and creates an ISOTimeString from a string.
+* Returns null if the string is not a valid time format.
+*/
+function createISOTimeString(value) {
+	const parsed = parseISOTime(value);
+	if (!parsed) return null;
+	return formatISOTime(parsed, value.split(":").length === 3);
+}
+/**
+* Parses an ISO time string into a ParsedTime object.
+* Accepts HH:MM or HH:MM:SS format.
+*/
+function parseISOTime(time) {
+	if (!time) return null;
+	const parts = time.split(":");
+	if (parts.length < 2 || parts.length > 3) return null;
+	const hour = parseInt(parts[0], 10);
+	const minute = parseInt(parts[1], 10);
+	const second = parts.length === 3 ? parseInt(parts[2], 10) : 0;
+	if (Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second) || hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) return null;
+	return {
+		hour,
+		minute,
+		second
+	};
+}
+/**
+* Formats a ParsedTime object into an ISOTimeString.
+*/
+function formatISOTime(time, includeSeconds = false) {
+	const hh = time.hour.toString().padStart(2, "0");
+	const mm = time.minute.toString().padStart(2, "0");
+	if (includeSeconds) return `${hh}:${mm}:${time.second.toString().padStart(2, "0")}`;
+	return `${hh}:${mm}`;
+}
+/**
+* Formats a time for display in 12-hour format.
+* Example: "14:30" -> "2:30 PM"
+*/
+function formatDisplayTime12h(time, includeSeconds = false) {
+	if (!time) return "";
+	const parsed = parseISOTime(time);
+	if (!parsed) return "";
+	const hour12 = parsed.hour === 0 ? 12 : parsed.hour > 12 ? parsed.hour - 12 : parsed.hour;
+	const meridiem = parsed.hour < 12 ? "AM" : "PM";
+	const mm = parsed.minute.toString().padStart(2, "0");
+	if (includeSeconds) return `${hour12}:${mm}:${parsed.second.toString().padStart(2, "0")} ${meridiem}`;
+	return `${hour12}:${mm} ${meridiem}`;
+}
+/**
+* Formats a time for display in 24-hour format.
+* Example: "14:30" -> "14:30"
+*/
+function formatDisplayTime24h(time, includeSeconds = false) {
+	if (!time) return "";
+	const parsed = parseISOTime(time);
+	if (!parsed) return "";
+	const hh = parsed.hour.toString().padStart(2, "0");
+	const mm = parsed.minute.toString().padStart(2, "0");
+	if (includeSeconds) return `${hh}:${mm}:${parsed.second.toString().padStart(2, "0")}`;
+	return `${hh}:${mm}`;
+}
+/**
+* Parses user input into an ISOTimeString.
+* Accepts various formats:
+* - "2:30 PM", "2:30pm", "2:30 pm"
+* - "14:30", "1430"
+* - "2pm", "2 PM"
+*/
+function parseTimeInput(input, includeSeconds = false) {
+	if (!input) return null;
+	const trimmed = input.trim().toLowerCase();
+	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 convertHourTo24Hour = (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 = parseInt(timeStr, 10);
+		if (hasMeridiem) {
+			const hour24 = convertHourTo24Hour(hour);
+			if (hour24 === null) return null;
+			return formatISOTime({
+				hour: hour24,
+				minute: 0,
+				second: 0
+			}, includeSeconds);
+		}
+		if (hour >= 0 && hour <= 23 && !hasMeridiem) return formatISOTime({
+			hour,
+			minute: 0,
+			second: 0
+		}, includeSeconds);
+		return null;
+	}
+	if (/^\d{4}$/.test(timeStr)) {
+		const hour = parseInt(timeStr.slice(0, 2), 10);
+		const minute = parseInt(timeStr.slice(2, 4), 10);
+		const hour24 = convertHourTo24Hour(hour);
+		if (hour24 !== null && hour24 >= 0 && hour24 <= 23 && minute >= 0 && minute <= 59) return formatISOTime({
+			hour: hour24,
+			minute,
+			second: 0
+		}, includeSeconds);
+		return null;
+	}
+	if (/^\d{6}$/.test(timeStr)) {
+		const hour = parseInt(timeStr.slice(0, 2), 10);
+		const minute = parseInt(timeStr.slice(2, 4), 10);
+		const second = parseInt(timeStr.slice(4, 6), 10);
+		const hour24 = convertHourTo24Hour(hour);
+		if (hour24 !== null && hour24 >= 0 && hour24 <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59) return formatISOTime({
+			hour: hour24,
+			minute,
+			second
+		}, includeSeconds);
+		return null;
+	}
+	const colonParts = timeStr.split(":");
+	if (colonParts.length >= 2 && colonParts.length <= 3) {
+		let hour = parseInt(colonParts[0], 10);
+		const minute = parseInt(colonParts[1], 10);
+		const second = colonParts.length === 3 ? parseInt(colonParts[2], 10) : 0;
+		if (Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second)) return null;
+		if (minute < 0 || minute > 59 || second < 0 || second > 59) return null;
+		if (hasMeridiem) {
+			if (hour < 1 || hour > 12) return null;
+			if (isPM && hour !== 12) hour += 12;
+			if (isAM && hour === 12) hour = 0;
+		} else if (hour < 0 || hour > 23) return null;
+		return formatISOTime({
+			hour,
+			minute,
+			second
+		}, includeSeconds);
+	}
+	return null;
+}
+/**
+* Compares two times. Returns:
+* - negative if a < b
+* - 0 if a === b
+* - positive if a > b
+*/
+function compareTime(a, b) {
+	if (!a && !b) return 0;
+	if (!a) return -1;
+	if (!b) return 1;
+	const parsedA = parseISOTime(a);
+	const parsedB = parseISOTime(b);
+	if (!parsedA && !parsedB) return 0;
+	if (!parsedA) return -1;
+	if (!parsedB) return 1;
+	return parsedA.hour * 3600 + parsedA.minute * 60 + parsedA.second - (parsedB.hour * 3600 + parsedB.minute * 60 + parsedB.second);
+}
+/**
+* Clamps a time to a min/max range.
+*/
+function clampTime(time, min, max, includeSeconds = false) {
+	if (!parseISOTime(time)) return time;
+	if (min && compareTime(time, min) < 0) {
+		const parsedMin = parseISOTime(min);
+		if (parsedMin) return formatISOTime(parsedMin, includeSeconds);
+	}
+	if (max && compareTime(time, max) > 0) {
+		const parsedMax = parseISOTime(max);
+		if (parsedMax) return formatISOTime(parsedMax, includeSeconds);
+	}
+	return time;
+}
+/**
+* Adjusts a time by adding/subtracting minutes.
+*/
+function adjustTime(time, deltaMinutes, includeSeconds = false) {
+	const parsed = parseISOTime(time);
+	if (!parsed) return time;
+	if (!Number.isFinite(deltaMinutes)) return time;
+	let totalMinutes = parsed.hour * 60 + parsed.minute + deltaMinutes;
+	totalMinutes = (totalMinutes % 1440 + 1440) % 1440;
+	return formatISOTime({
+		hour: Math.floor(totalMinutes / 60),
+		minute: totalMinutes % 60,
+		second: parsed.second
+	}, includeSeconds);
+}
+//#endregion
+export { plainDateWeekFieldName as $, plainDateAddDays as A, plainDateIsAfter as B, DATE_FORMAT_SHORT_WITH_YEAR as C, formatSharedDate as D, SHARED_DATE_FORMAT_OPTIONS as E, plainDateFormat as F, plainDateMin as G, plainDateIsEqual as H, plainDateFromDate as I, plainDateSetStartOfWeek as J, plainDateSetEndOfWeekExclusive as K, plainDateFromISO as L, plainDateCreate as M, plainDateDayOfWeek as N, getDaysInMonth as O, plainDateDiffDays as P, plainDateToday as Q, plainDateFromInstant as R, DATE_FORMAT_SHORT_WITH_WEEKDAY as S, DATE_FORMAT_WITH_WEEKDAY as T, plainDateIsInRange as U, plainDateIsBefore as V, plainDateMax as W, plainDateToISO as X, plainDateToDate as Y, plainDateToInstant as Z, parseDateInput as _, formatDisplayTime12h as a, DATE_FORMAT_MONTH_YEAR as b, observeResize as c, getInputARIA as d, chainEventHandlers as et, joinAriaIDs as f, isLocaleDayFirst as g, normalizeDayOfWeek as h, createISOTimeString as i, plainDateAddMonths as j, getTimeZoneParts as k, unobserveResize as l, groupItems as m, clampTime as n, formatDisplayTime24h as o, getItemGroup as p, plainDateSetFirstOfMonth as q, compareTime as r, parseTimeInput as s, adjustTime as t, parseStyleKey as u, DATE_FORMAT_LONG as v, DATE_FORMAT_WEEKDAY_ONLY as w, DATE_FORMAT_SHORT as x, DATE_FORMAT_MONTH_ONLY as y, plainDateGetWeekNumber as z };