ajo-ui 0.1.0

package/dist/chunks/calendar-q8jZ8Cxr.js

@@ -0,0 +1,1923 @@
+import { DirectionContext } from "../direction.js";
+import { clamp, controlled, dom, grid, remember, statefulRootAttrs } from "ajo-cloves";
+import { Fragment, jsx, jsxs } from "ajo/jsx-runtime";
+//#region packages/ajo-ui/src/segments.ts
+/**
+* segments.ts — the pure engine behind the InputDate family (ai/ui.md).
+*
+* No JSX, no DOM; Intl is the only platform dependency. `input-date.tsx`
+* owns rendering, focus, and events, and consumes this surface:
+*
+* - `derive(opts)` — fixed-probe Intl derivation → ordered `Segment`
+*   descriptors (editable units + verbatim literals), resolved hour cycle,
+*   dayPeriod display strings, and localized month names.
+* - `fromISO` / `toISO` — strict parse/serialize of the native normalized
+*   forms (zero-padded, no milliseconds, no 24:00); year 1–9999.
+* - `typeDigit` / `matchName` / `eraseDigit` / `stepValue` — one pure
+*   segment mutation each (digit buffer, name prefix match, backspace,
+*   spin protocol).
+* - `validate` / `defaultMessage` / `constrain` / `isReversed` — reason-coded
+*   validation with localized default messages, the day clamp, and the range
+*   cross-check (`reversed` is a consumer-raised reason: validate never
+*   returns it).
+* - `formatValue` — human formatting of a committed value (message bounds,
+*   the field's hidden value description).
+* - `inferGranularity` — value → defaultValue → placeholderValue →
+*   granularity arg → 'minute'.
+* - `reconciler()` — lastEmitted/lastObserved external-change detection, so
+*   echoes of self-emitted values never clobber edits.
+* - `field(options)` — the stateful editing record wiring all of the above:
+*   independently nullable units (hour kept in the display cycle, dayPeriod
+*   its own 0/1 unit), the typing buffer, and the eager-constrain commit
+*   pipeline. Every mutation returns an `InputResult` telling the consumer
+*   whether to move focus and what to emit; `emit` is `undefined` when the
+*   public value did not change.
+*/
+var PROBE_YEAR = 2224;
+var PROBE = new Date(PROBE_YEAR, 2, 4, 5, 6, 7);
+var EDITABLE = [
+	"year",
+	"month",
+	"day",
+	"hour",
+	"minute",
+	"second",
+	"dayPeriod"
+];
+var VOCABULARY = {
+	de: [
+		"jjjj",
+		"mm",
+		"tt"
+	],
+	en: [
+		"yyyy",
+		"mm",
+		"dd"
+	],
+	es: [
+		"aaaa",
+		"mm",
+		"dd"
+	],
+	fr: [
+		"aaaa",
+		"mm",
+		"jj"
+	],
+	ja: [
+		"年",
+		"月",
+		"日"
+	]
+};
+var TIME_PLACEHOLDER = "––";
+var boundsOf = (unit, hourCycle) => {
+	switch (unit) {
+		case "year": return [1, 9999];
+		case "month": return [1, 12];
+		case "day": return [1, 31];
+		case "hour": return hourCycle === "h12" ? [1, 12] : [0, 23];
+		case "dayPeriod": return [0, 1];
+		default: return [0, 59];
+	}
+};
+var resolveHourCycle = (locale, override) => {
+	if (override) return override === 12 ? "h12" : "h23";
+	const cycle = new Intl.DateTimeFormat(locale, { hour: "numeric" }).resolvedOptions().hourCycle;
+	return cycle === "h11" || cycle === "h12" ? "h12" : "h23";
+};
+/** Derives ordered segment descriptors for a locale via a fixed-probe formatToParts. */
+var derive = (opts) => {
+	const { kind, locale } = opts;
+	const hourCycle = kind === "date" ? "h23" : resolveHourCycle(locale, opts.hourCycle);
+	const withSeconds = kind !== "date" && opts.granularity === "second";
+	let format;
+	if (kind !== "date") {
+		format = {
+			hour: "numeric",
+			minute: "numeric",
+			hourCycle
+		};
+		if (withSeconds) format.second = "numeric";
+		if (kind === "datetime") Object.assign(format, {
+			year: "numeric",
+			month: "numeric",
+			day: "numeric"
+		});
+	}
+	const vocabulary = VOCABULARY[locale.split("-")[0].toLowerCase()] ?? VOCABULARY.en;
+	const placeholderOf = (unit) => unit === "year" ? vocabulary[0] : unit === "month" ? vocabulary[1] : unit === "day" ? vocabulary[2] : TIME_PLACEHOLDER;
+	const segments = [];
+	for (const part of new Intl.DateTimeFormat(locale, format).formatToParts(PROBE)) if (EDITABLE.includes(part.type)) {
+		const unit = part.type;
+		const [min, max] = boundsOf(unit, hourCycle);
+		segments.push({
+			type: unit,
+			text: "",
+			editable: true,
+			placeholder: placeholderOf(unit),
+			min,
+			max,
+			digits: unit === "dayPeriod" ? 0 : String(max).length,
+			width: part.value.length
+		});
+	} else segments.push({
+		type: "literal",
+		text: part.value,
+		editable: false,
+		placeholder: "",
+		min: 0,
+		max: 0,
+		digits: 0,
+		width: part.value.length
+	});
+	let periods = ["", ""];
+	if (kind !== "date" && hourCycle === "h12") {
+		const formatter = new Intl.DateTimeFormat(locale, {
+			hour: "numeric",
+			hourCycle: "h12"
+		});
+		const periodOf = (hour) => formatter.formatToParts(new Date(PROBE_YEAR, 2, 4, hour)).find((part) => part.type === "dayPeriod")?.value ?? (hour ? "PM" : "AM");
+		periods = [periodOf(0), periodOf(12)];
+	}
+	let monthNames = [];
+	if (kind !== "time") {
+		const formatter = new Intl.DateTimeFormat(locale, { month: "long" });
+		monthNames = Array.from({ length: 12 }, (_, month) => formatter.format(new Date(PROBE_YEAR, month, 4, 12)));
+	}
+	return {
+		segments,
+		units: segments.filter((segment) => segment.editable).map((segment) => segment.type),
+		hourCycle,
+		periods,
+		monthNames,
+		withSeconds
+	};
+};
+var TIME_UNITS = new Set([
+	"dayPeriod",
+	"hour",
+	"minute",
+	"second"
+]);
+/** Returns the contiguous time portion of a derived segment sequence. */
+var timeRun = (segments) => {
+	let first = -1;
+	let last = -1;
+	for (let index = 0; index < segments.length; index++) {
+		if (!TIME_UNITS.has(segments[index].type)) continue;
+		if (first < 0) first = index;
+		last = index;
+	}
+	return first < 0 ? [] : segments.slice(first, last + 1);
+};
+var DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+var TIME_RE = /^(\d{2}):(\d{2})(?::(\d{2}))?$/;
+/** Month length; unknown month falls back to 31, unknown year keeps Feb 29 typable. */
+var daysInMonth$1 = (year, month) => {
+	if (month == null) return 31;
+	const date = new Date(PROBE_YEAR, month, 0);
+	if (year != null) date.setFullYear(year, month, 0);
+	return date.getDate();
+};
+var parseDate = (text) => {
+	const match = DATE_RE.exec(text);
+	if (!match) return null;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	if (year < 1 || month < 1 || month > 12 || day < 1 || day > daysInMonth$1(year, month)) return null;
+	return {
+		year,
+		month,
+		day
+	};
+};
+var parseTime = (text) => {
+	const match = TIME_RE.exec(text);
+	if (!match) return null;
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	const second = match[3] == null ? null : Number(match[3]);
+	if (hour > 23 || minute > 59 || second != null && second > 59) return null;
+	return {
+		hour,
+		minute,
+		second
+	};
+};
+/** A fresh editing record: every unit independently empty. */
+var emptyUnits = () => ({
+	year: null,
+	month: null,
+	day: null,
+	hour: null,
+	minute: null,
+	second: null,
+	dayPeriod: null
+});
+/** Strict parse of the native normalized forms into the editing record; null on anything else. */
+var fromISO = (kind, value, hourCycle = "h23") => {
+	let date = null;
+	let time = null;
+	if (kind === "date") {
+		date = parseDate(value);
+		if (!date) return null;
+	} else if (kind === "time") {
+		time = parseTime(value);
+		if (!time) return null;
+	} else {
+		const at = value.indexOf("T");
+		if (at < 0) return null;
+		date = parseDate(value.slice(0, at));
+		time = parseTime(value.slice(at + 1));
+		if (!date || !time) return null;
+	}
+	const units = emptyUnits();
+	if (date) Object.assign(units, date);
+	if (time) {
+		units.minute = time.minute;
+		units.second = time.second;
+		if (hourCycle === "h12") {
+			units.dayPeriod = time.hour < 12 ? 0 : 1;
+			units.hour = time.hour % 12 || 12;
+		} else units.hour = time.hour;
+	}
+	return units;
+};
+var pad$1 = (value, width) => String(value).padStart(width, "0");
+var filled = (value) => value != null && !Number.isNaN(value);
+/** Serializes complete units to the family's normalized form; null while a required unit is missing. */
+var toISO = (kind, units, opts = {}) => {
+	const parts = [];
+	if (kind !== "time") {
+		if (!filled(units.year) || !filled(units.month) || !filled(units.day)) return null;
+		parts.push(`${pad$1(units.year, 4)}-${pad$1(units.month, 2)}-${pad$1(units.day, 2)}`);
+	}
+	if (kind !== "date") {
+		if (!filled(units.hour) || !filled(units.minute)) return null;
+		if (opts.seconds && !filled(units.second)) return null;
+		const h12 = (opts.hourCycle ?? "h23") === "h12";
+		if (h12 && !filled(units.dayPeriod)) return null;
+		const hour = h12 ? units.dayPeriod === 1 ? units.hour === 12 ? 12 : units.hour + 12 : units.hour % 12 : units.hour;
+		parts.push(`${pad$1(hour, 2)}:${pad$1(units.minute, 2)}${opts.seconds ? `:${pad$1(units.second, 2)}` : ""}`);
+	}
+	return parts.join("T");
+};
+/** Digit protocol: the buffer accumulates, overflow restarts from the last key, full advances. */
+var typeDigit = (buffer, key, min, max, digits) => {
+	const typed = buffer + key;
+	let value = Number(typed);
+	if (Number.isNaN(value) || value > max) value = Number(key);
+	const set = value !== 0 || min === 0;
+	const full = Number(typed) * 10 > max || typed.length >= digits;
+	return {
+		value: set ? value : null,
+		buffer: full ? "" : typed,
+		advance: full && set
+	};
+};
+var nameCollators = /* @__PURE__ */ new Map();
+/** Prefix-matches locale names (Collator sensitivity 'base'); a repeated first letter cycles its matches. */
+var matchName = (locale, names, current, buffer, key) => {
+	let collator = nameCollators.get(locale);
+	if (!collator) {
+		collator = new Intl.Collator(locale, {
+			sensitivity: "base",
+			usage: "search"
+		});
+		remember(nameCollators, locale, collator);
+	}
+	const starts = (name, query) => collator.compare(name.slice(0, query.length), query) === 0;
+	for (const query of buffer ? [buffer + key, key] : [key]) {
+		const matches = [];
+		for (let index = 0; index < names.length; index++) if (starts(names[index], query)) matches.push(index);
+		if (!matches.length) continue;
+		return {
+			index: query.length === 1 && current != null && matches.includes(current) ? matches[(matches.indexOf(current) + 1) % matches.length] : matches[0],
+			buffer: query,
+			unique: matches.length === 1
+		};
+	}
+	return null;
+};
+var PAGE_STEP = {
+	year: 5,
+	month: 2,
+	day: 7,
+	hour: 2,
+	minute: 15,
+	second: 15,
+	dayPeriod: 1
+};
+var cycle = (value, amount, min, max, round) => {
+	if (!round) {
+		value += amount;
+		return value < min ? max - (min - value - 1) : value > max ? min + (value - max - 1) : value;
+	}
+	value += Math.sign(amount);
+	if (value < min) value = max;
+	const grid = Math.abs(amount);
+	value = amount > 0 ? Math.ceil(value / grid) * grid : Math.floor(value / grid) * grid;
+	if (value > max) value = min;
+	return clamp(value, min, max);
+};
+/** Spin protocol: ±1 wraps at the bounds without carrying, pages round to their grid, edges land on min/max. */
+var stepValue = (unit, value, action, min, max, minuteStep = 1) => {
+	if ("edge" in action) return action.edge === "min" ? min : max;
+	if ("page" in action) return cycle(value, PAGE_STEP[unit] * action.page, min, max, true);
+	const step = unit === "minute" ? minuteStep : 1;
+	return cycle(value, action.step * step, min, max, step > 1);
+};
+/** Backspace semantics: strip the last digit, empty shows the placeholder, empty again retreats. */
+var eraseDigit = (value, buffer) => {
+	const text = buffer || (value == null ? "" : String(value));
+	if (!text) return {
+		value: null,
+		buffer: "",
+		retreat: true
+	};
+	const stripped = text.slice(0, -1);
+	const parsed = Number(stripped);
+	if (Number.isNaN(parsed)) return {
+		value: null,
+		buffer: "",
+		retreat: false
+	};
+	return {
+		value: stripped && parsed !== 0 ? parsed : null,
+		buffer: stripped,
+		retreat: false
+	};
+};
+/** Reason-coded validation; null = valid. An all-empty record is valid — required is the consumer's. */
+var validate = (kind, units, order, opts = {}) => {
+	if (order.every((unit) => units[unit] == null)) return null;
+	for (const unit of order) if (units[unit] == null) return {
+		code: "incomplete",
+		unit
+	};
+	if (units.day != null && units.day > daysInMonth$1(units.year, units.month)) return { code: "impossible" };
+	const value = toISO(kind, units, {
+		hourCycle: opts.hourCycle,
+		seconds: opts.seconds
+	});
+	if (value == null) return { code: "impossible" };
+	if (opts.min != null && value < opts.min) return {
+		code: "rangeUnderflow",
+		min: opts.min
+	};
+	if (opts.max != null && value > opts.max) return {
+		code: "rangeOverflow",
+		max: opts.max
+	};
+	if (opts.unavailable?.(value)) return { code: "unavailable" };
+	return null;
+};
+/** Eager constrain: clamps the day into the real month length, in place. */
+var constrain = (units) => {
+	if (units.day != null) units.day = Math.min(units.day, daysInMonth$1(units.year, units.month));
+	return units;
+};
+/** Range cross-check: from > to, in the family's own string format. */
+var isReversed = (from, to) => from != null && to != null && from > to;
+var displayNames = /* @__PURE__ */ new Map();
+/** Localized date/time segment label, shared by field ARIA and validation messages. */
+var unitLabel = (locale, unit) => {
+	let names = displayNames.get(locale);
+	if (!names) {
+		names = new Intl.DisplayNames([locale], { type: "dateTimeField" });
+		remember(displayNames, locale, names);
+	}
+	return names.of(unit) ?? unit;
+};
+var valueFormatters = /* @__PURE__ */ new Map();
+var valueFormatter = (opts, seconds) => {
+	const key = [
+		opts.locale,
+		opts.kind,
+		seconds ? "second" : "",
+		opts.kind === "date" ? "" : opts.hourCycle ?? ""
+	].join("\0");
+	let formatter = valueFormatters.get(key);
+	if (!formatter) {
+		const format = {};
+		if (opts.kind !== "time") format.dateStyle = "medium";
+		if (opts.kind !== "date") {
+			format.timeStyle = seconds ? "medium" : "short";
+			if (opts.hourCycle) format.hourCycle = opts.hourCycle;
+		}
+		formatter = new Intl.DateTimeFormat(opts.locale, format);
+		remember(valueFormatters, key, formatter);
+	}
+	return formatter;
+};
+/** Formats a committed value for humans: message bounds, the hidden value description. */
+var formatValue = (value, opts) => {
+	const units = fromISO(opts.kind, value);
+	if (!units) return value;
+	const date = new Date(PROBE_YEAR, (units.month ?? 3) - 1, units.day ?? 4, units.hour ?? 12, units.minute ?? 0, units.second ?? 0);
+	date.setFullYear(units.year ?? PROBE_YEAR);
+	return valueFormatter(opts, units.second != null).format(date);
+};
+/** Default message builders (GOV.UK hierarchy): localized unit names and bounds, overridable per field. */
+var defaultMessage = (reason, opts) => {
+	switch (reason.code) {
+		case "incomplete": return `Must include a ${unitLabel(opts.locale, reason.unit)}`;
+		case "impossible": return opts.kind === "time" ? "Must be a real time" : "Must be a real date";
+		case "rangeUnderflow": return `Must be ${formatValue(reason.min, opts)} or later`;
+		case "rangeOverflow": return `Must be ${formatValue(reason.max, opts)} or earlier`;
+		case "reversed": return opts.kind === "time" ? "Start time must be before end time" : "Start date must be before end date";
+		case "unavailable": return opts.kind === "time" ? "This time is unavailable" : "This date is unavailable";
+		case "unavailableRange": return "Range includes unavailable dates";
+	}
+};
+/** Controlled ↔ editing-state reconciliation: only genuinely external values clobber edits. */
+var reconciler = () => {
+	let lastEmitted;
+	let lastObserved;
+	return {
+		emit(value) {
+			lastEmitted = lastObserved = value;
+		},
+		observe(value) {
+			if (value === void 0) return false;
+			if (value === lastEmitted || value === lastObserved) {
+				lastObserved = value;
+				return false;
+			}
+			lastEmitted = lastObserved = value;
+			return true;
+		}
+	};
+};
+/** value → defaultValue → placeholderValue → granularity arg → 'minute'; seconds in a value force the segment. */
+var inferGranularity = (kind, opts) => {
+	if (kind === "date") return "day";
+	for (const source of [
+		opts.value,
+		opts.defaultValue,
+		opts.placeholderValue
+	]) {
+		if (typeof source !== "string") continue;
+		const time = kind === "time" ? source : source.indexOf("T") < 0 ? "" : source.slice(source.indexOf("T") + 1);
+		if (TIME_RE.test(time)) return time.length > 5 ? "second" : "minute";
+	}
+	return opts.granularity ?? "minute";
+};
+var convertHour = (units, hourCycle) => {
+	if (units.hour == null) {
+		units.dayPeriod = null;
+		return;
+	}
+	if (hourCycle === "h12") {
+		units.dayPeriod = units.hour < 12 ? 0 : 1;
+		units.hour = units.hour % 12 || 12;
+	} else {
+		units.hour = units.dayPeriod === 1 ? units.hour === 12 ? 12 : units.hour + 12 : units.hour % 12;
+		units.dayPeriod = null;
+	}
+};
+/** The stateful editing record consumed by the InputDate family; one per field side. */
+var field = (options) => {
+	const units = emptyUnits();
+	const rec = reconciler();
+	let opts = options;
+	let derivation;
+	let buffer = "";
+	let bufferUnit = null;
+	let committed = null;
+	let cacheKey = "";
+	let granularity;
+	const locale = () => opts.locale ?? "en-US";
+	const inferFor = (next, value) => inferGranularity(next.kind, {
+		value,
+		defaultValue: next.defaultValue,
+		placeholderValue: next.placeholderValue,
+		granularity: next.granularity
+	});
+	const inferKey = (next) => [
+		next.granularity ?? "",
+		next.defaultValue ?? "",
+		next.placeholderValue ?? ""
+	].join("|");
+	const configure = (next) => {
+		opts = next;
+		const key = [
+			next.kind,
+			locale(),
+			granularity,
+			next.hourCycle ?? 0
+		].join("|");
+		if (key === cacheKey) return;
+		cacheKey = key;
+		const previous = derivation?.hourCycle;
+		derivation = derive({
+			kind: next.kind,
+			locale: locale(),
+			granularity,
+			hourCycle: next.hourCycle
+		});
+		if (previous && previous !== derivation.hourCycle) convertHour(units, derivation.hourCycle);
+		buffer = "";
+		bufferUnit = null;
+	};
+	const adopt = (value) => {
+		const parsed = value == null ? null : fromISO(opts.kind, value, derivation.hourCycle);
+		if (value != null && !parsed) console.warn(`[segments] invalid ${opts.kind} value: "${value}"`);
+		Object.assign(units, parsed ?? emptyUnits());
+		buffer = "";
+		bufferUnit = null;
+		committed = parsed ? value : null;
+	};
+	granularity = inferFor(options);
+	configure(options);
+	if (options.defaultValue != null) adopt(options.defaultValue);
+	rec.emit(committed);
+	const segmentOf = (unit) => derivation.segments.find((segment) => segment.type === unit);
+	const boundsFor = (unit) => {
+		const segment = segmentOf(unit);
+		return {
+			min: segment?.min ?? 0,
+			max: unit === "day" ? daysInMonth$1(units.year, units.month) : segment?.max ?? 0
+		};
+	};
+	const complete = () => derivation.units.every((unit) => units[unit] != null);
+	const resolve = (advance, retreat) => {
+		let emit;
+		if (complete()) {
+			constrain(units);
+			const value = toISO(opts.kind, units, {
+				hourCycle: derivation.hourCycle,
+				seconds: derivation.withSeconds
+			});
+			if (value != null && value !== committed) {
+				committed = value;
+				rec.emit(value);
+				emit = value;
+			}
+		} else if (committed != null) {
+			committed = null;
+			rec.emit(null);
+			emit = null;
+		}
+		return {
+			handled: true,
+			advance,
+			retreat,
+			emit
+		};
+	};
+	const seed = () => {
+		if (opts.placeholderValue != null) {
+			const parsed = fromISO(opts.kind, opts.placeholderValue, derivation.hourCycle);
+			if (parsed) return parsed;
+		}
+		const now = /* @__PURE__ */ new Date();
+		const values = {
+			year: now.getFullYear(),
+			month: now.getMonth() + 1,
+			day: now.getDate(),
+			hour: now.getHours(),
+			minute: now.getMinutes(),
+			second: now.getSeconds(),
+			dayPeriod: null
+		};
+		if (derivation.hourCycle === "h12") convertHour(values, "h12");
+		return values;
+	};
+	const retarget = (unit) => {
+		if (bufferUnit !== unit) {
+			buffer = "";
+			bufferUnit = unit;
+		}
+	};
+	const reason = () => validate(opts.kind, units, derivation.units, {
+		min: opts.min,
+		max: opts.max,
+		unavailable: opts.unavailable,
+		hourCycle: derivation.hourCycle,
+		seconds: derivation.withSeconds
+	});
+	return {
+		get segments() {
+			return derivation.segments;
+		},
+		get units() {
+			return units;
+		},
+		get hourCycle() {
+			return derivation.hourCycle;
+		},
+		get periods() {
+			return derivation.periods;
+		},
+		get monthNames() {
+			return derivation.monthNames;
+		},
+		sync(value, next) {
+			const target = next ?? opts;
+			const external = rec.observe(value);
+			if (external) granularity = inferFor(target, value);
+			else if (inferKey(target) !== inferKey(opts)) {
+				granularity = inferFor(target, committed);
+				if (granularity !== "second" && units.second != null) granularity = "second";
+			}
+			configure(target);
+			if (external) adopt(value);
+		},
+		text(unit) {
+			if (bufferUnit === unit && buffer) return buffer;
+			const value = units[unit];
+			if (value == null) return "";
+			if (unit === "dayPeriod") return derivation.periods[value] ?? "";
+			return pad$1(value, segmentOf(unit)?.width ?? 1);
+		},
+		bounds: boundsFor,
+		type(unit, key) {
+			if (!derivation.units.includes(unit)) return { handled: false };
+			retarget(unit);
+			if (/^\d$/.test(key) && unit !== "dayPeriod") {
+				if (!/^\d*$/.test(buffer)) buffer = "";
+				const { min, max } = boundsFor(unit);
+				const state = typeDigit(buffer, key, min, max, segmentOf(unit)?.digits ?? 2);
+				buffer = state.buffer;
+				if (state.value == null) return { handled: true };
+				units[unit] = state.value;
+				return resolve(state.advance);
+			}
+			if (unit === "month" && derivation.monthNames.length) {
+				const match = matchName(locale(), derivation.monthNames, units.month == null ? null : units.month - 1, buffer, key);
+				if (!match) return { handled: false };
+				buffer = match.buffer;
+				units.month = match.index + 1;
+				return resolve(match.unique);
+			}
+			if (unit === "dayPeriod") {
+				const match = matchName(locale(), derivation.periods, units.dayPeriod, "", key);
+				if (!match) return { handled: false };
+				units.dayPeriod = match.index;
+				return resolve(match.unique);
+			}
+			return { handled: false };
+		},
+		erase(unit) {
+			if (!derivation.units.includes(unit)) return { handled: false };
+			retarget(unit);
+			if (unit === "dayPeriod") {
+				buffer = "";
+				if (units.dayPeriod == null) return {
+					handled: true,
+					retreat: true
+				};
+				units.dayPeriod = null;
+				return resolve();
+			}
+			if (unit === "month" && buffer && !/^\d*$/.test(buffer)) {
+				buffer = buffer.slice(0, -1);
+				const match = buffer ? matchName(locale(), derivation.monthNames, null, "", buffer) : null;
+				units.month = match ? match.index + 1 : null;
+				return resolve();
+			}
+			const state = eraseDigit(units[unit], buffer);
+			if (state.retreat) return {
+				handled: true,
+				retreat: true
+			};
+			buffer = state.buffer;
+			units[unit] = state.value;
+			return resolve();
+		},
+		spin(unit, action) {
+			if (!derivation.units.includes(unit)) return { handled: false };
+			buffer = "";
+			bufferUnit = unit;
+			const { min, max } = boundsFor(unit);
+			const current = units[unit];
+			if ("edge" in action) units[unit] = action.edge === "min" ? min : max;
+			else if (current == null) units[unit] = clamp(seed()[unit] ?? min, min, max);
+			else units[unit] = stepValue(unit, current, action, min, max, opts.step ?? 1);
+			return resolve();
+		},
+		merge(next) {
+			buffer = "";
+			bufferUnit = null;
+			for (const unit of EDITABLE) {
+				const value = next[unit];
+				if (value !== void 0) units[unit] = value;
+			}
+			return resolve();
+		},
+		placeholder: () => seed(),
+		clear() {
+			buffer = "";
+			bufferUnit = null;
+			Object.assign(units, emptyUnits());
+			return resolve();
+		},
+		reset() {
+			adopt(opts.defaultValue ?? null);
+		},
+		blur() {
+			buffer = "";
+			bufferUnit = null;
+		},
+		value: () => committed,
+		complete,
+		reason,
+		message() {
+			const why = reason();
+			if (!why) return null;
+			return opts.errorMessage?.(why) ?? defaultMessage(why, {
+				kind: opts.kind,
+				locale: locale(),
+				hourCycle: derivation.hourCycle
+			});
+		}
+	};
+};
+//#endregion
+//#region packages/ajo-ui/src/availability.ts
+var clock = (value, fallback) => {
+	if (value == null) return fallback;
+	const match = /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(value);
+	if (!match) return NaN;
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	const second = Number(match[3] ?? 0);
+	if (hour > 23 || minute > 59 || second > 59) return NaN;
+	return hour * 3600 + minute * 60 + second;
+};
+var timePredicate = (window) => {
+	const from = clock(window.from, 0);
+	const to = clock(window.to, 24 * 3600);
+	const valid = Number.isFinite(from) && Number.isFinite(to) && from < to;
+	return (parts) => {
+		const value = parts.hour * 3600 + parts.minute * 60 + parts.second;
+		return valid && from <= value && value < to;
+	};
+};
+var partFormatters = /* @__PURE__ */ new Map();
+var partFormatter = (timeZone) => {
+	let formatter = partFormatters.get(timeZone);
+	if (!formatter) {
+		formatter = new Intl.DateTimeFormat("en-CA", {
+			day: "2-digit",
+			hour: "2-digit",
+			hourCycle: "h23",
+			minute: "2-digit",
+			month: "2-digit",
+			second: "2-digit",
+			timeZone,
+			year: "numeric"
+		});
+		remember(partFormatters, timeZone, formatter);
+	}
+	return formatter;
+};
+var partsOf = (date, timeZone) => {
+	if (!Number.isFinite(date.getTime())) return {
+		day: NaN,
+		hour: NaN,
+		minute: NaN,
+		month: NaN,
+		second: NaN,
+		year: NaN
+	};
+	if (!timeZone) return {
+		day: date.getDate(),
+		hour: date.getHours(),
+		minute: date.getMinutes(),
+		month: date.getMonth() + 1,
+		second: date.getSeconds(),
+		year: date.getFullYear()
+	};
+	const parts = partFormatter(timeZone).formatToParts(date);
+	const value = (type) => Number(parts.find((part) => part.type === type)?.value);
+	return {
+		day: value("day"),
+		hour: value("hour"),
+		minute: value("minute"),
+		month: value("month"),
+		second: value("second"),
+		year: value("year")
+	};
+};
+var dayValue = (parts) => parts.year * 1e4 + parts.month * 100 + parts.day;
+var exactUtcDate = (parts) => {
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(parts.year, parts.month - 1, parts.day);
+	date.setUTCHours(parts.hour ?? 0, parts.minute ?? 0, parts.second ?? 0, 0);
+	return date;
+};
+var exactLocalDate = (parts) => {
+	const date = /* @__PURE__ */ new Date(0);
+	date.setFullYear(parts.year, parts.month - 1, parts.day);
+	date.setHours(parts.hour, parts.minute, parts.second, 0);
+	return date;
+};
+var weekday$1 = (parts) => exactUtcDate(parts).getUTCDay();
+/** Constructs a stable instant for one wall-clock value in a calendar time zone. */
+var calendarDate = (parts, timeZone) => {
+	if (!timeZone) return exactLocalDate(parts);
+	const wanted = exactUtcDate(parts).getTime();
+	let instant = wanted;
+	for (let pass = 0; pass < 2; pass++) {
+		const actual = exactUtcDate(partsOf(new Date(instant), timeZone)).getTime();
+		instant += wanted - actual;
+	}
+	return new Date(instant);
+};
+var addDay = (parts) => {
+	const next = exactUtcDate({
+		...parts,
+		day: parts.day + 1,
+		hour: 12
+	});
+	return {
+		day: next.getUTCDate(),
+		hour: 12,
+		minute: 0,
+		month: next.getUTCMonth() + 1,
+		second: 0,
+		year: next.getUTCFullYear()
+	};
+};
+/** Compiles date/time expressions into stable day- and instant-granular predicates. */
+var compile = (matcher, options = {}) => {
+	if (matcher == null) return void 0;
+	const matchers = Array.isArray(matcher) ? matcher : [matcher];
+	if (!matchers.length) return void 0;
+	const timeZone = options.timeZone;
+	const parts = (date) => partsOf(date, timeZone);
+	const compileMatcher = (item) => {
+		if (item instanceof Date) {
+			const expected = dayValue(parts(item));
+			return { date: (_value, current) => dayValue(current()) === expected };
+		}
+		if (Array.isArray(item)) {
+			const expected = new Set(item.map((entry) => dayValue(parts(entry))).filter(Number.isFinite));
+			return { date: (_value, current) => expected.has(dayValue(current())) };
+		}
+		if (typeof item === "function") return { date: item };
+		const { after, before, dayOfWeek, from, to } = item;
+		const afterDay = after == null ? void 0 : dayValue(parts(after));
+		const beforeDay = before == null ? void 0 : dayValue(parts(before));
+		const fromDay = from == null ? void 0 : dayValue(parts(from));
+		const toDay = to == null ? void 0 : dayValue(parts(to));
+		const weekdays = dayOfWeek == null ? void 0 : new Set(dayOfWeek);
+		const hasDate = after != null || before != null || dayOfWeek != null || from != null || to != null;
+		const time = "time" in item ? timePredicate(item.time) : void 0;
+		return {
+			date: (_value, read) => {
+				if (!hasDate) return time != null;
+				const current = read();
+				const currentDay = dayValue(current);
+				if (weekdays != null && !weekdays.has(weekday$1(current))) return false;
+				if (beforeDay != null && !(currentDay < beforeDay)) return false;
+				if (afterDay != null && !(currentDay > afterDay)) return false;
+				if (fromDay != null && toDay != null) return fromDay <= currentDay && currentDay <= toDay;
+				if (fromDay != null) return currentDay === fromDay;
+				if (toDay != null) return currentDay === toDay;
+				return true;
+			},
+			time
+		};
+	};
+	const predicates = matchers.map(compileMatcher);
+	const day = (date) => {
+		let current;
+		const read = () => current ??= parts(date);
+		return predicates.some((predicate) => predicate.time == null && predicate.date(date, read));
+	};
+	const at = (date) => {
+		let current;
+		const read = () => current ??= parts(date);
+		return predicates.some((predicate) => predicate.date(date, read) && (predicate.time?.(read()) ?? true));
+	};
+	return {
+		day,
+		at,
+		value(kind, value) {
+			const units = fromISO(kind, value);
+			if (!units) return false;
+			const now = parts(/* @__PURE__ */ new Date());
+			const date = kind === "time" ? calendarDate({
+				...now,
+				hour: units.hour ?? 0,
+				minute: units.minute ?? 0,
+				second: units.second ?? 0
+			}, timeZone) : calendarDate({
+				day: units.day,
+				hour: units.hour ?? 12,
+				minute: units.minute ?? 0,
+				month: units.month,
+				second: units.second ?? 0,
+				year: units.year
+			}, timeZone);
+			return kind === "date" ? day(date) : at(date);
+		},
+		crosses(from, to) {
+			const end = dayValue(parts(to));
+			let current = parts(from);
+			if (dayValue(current) >= end) return false;
+			for (current = addDay(current); dayValue(current) < end; current = addDay(current)) if (day(calendarDate(current, timeZone))) return true;
+			return false;
+		}
+	};
+};
+//#endregion
+//#region packages/ajo-ui/src/calendar.tsx
+var localeCode = (locale) => typeof locale === "string" ? locale : locale?.code;
+var pad = (value) => String(value).padStart(2, "0");
+var iso = ({ day, month, year }) => `${year}-${pad(month)}-${pad(day)}`;
+var monthIso = ({ month, year }) => `${year}-${pad(month)}`;
+var parseIso = (value) => {
+	const [year, month, day] = value.split("-").map(Number);
+	if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return void 0;
+	return normalize(year, month, day);
+};
+var parseMonthIso = (value) => {
+	const [year, month] = value.split("-").map(Number);
+	if (!Number.isFinite(year) || !Number.isFinite(month) || month < 1 || month > 12) return void 0;
+	return {
+		day: 1,
+		month,
+		year
+	};
+};
+var utcDate = (year, month, day) => {
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(year, month - 1, day);
+	date.setUTCHours(0, 0, 0, 0);
+	return date;
+};
+var normalize = (year, month, day) => {
+	const date = utcDate(year, month, day);
+	return {
+		day: date.getUTCDate(),
+		month: date.getUTCMonth() + 1,
+		year: date.getUTCFullYear()
+	};
+};
+var addDays = (date, days) => normalize(date.year, date.month, date.day + days);
+var addMonths = (date, monthCount) => normalize(date.year, date.month + monthCount, Math.min(date.day, daysInMonth(normalize(date.year, date.month + monthCount, 1))));
+var monthStart = (date) => ({
+	year: date.year,
+	month: date.month,
+	day: 1
+});
+var daysInMonth = (date) => utcDate(date.year, date.month + 1, 0).getUTCDate();
+var comparePlain = (first, second) => iso(first).localeCompare(iso(second));
+var samePlain = (first, second) => first.year === second.year && first.month === second.month && first.day === second.day;
+var viewRank = {
+	day: 0,
+	month: 1,
+	year: 2
+};
+var minimumView = (view) => view ?? "day";
+var clampView = (view, minView) => viewRank[view] < viewRank[minimumView(minView)] ? minimumView(minView) : view;
+var periodStart = (date, view) => {
+	if (view === "year") return {
+		day: 1,
+		month: 1,
+		year: date.year
+	};
+	if (view === "month") return monthStart(date);
+	return date;
+};
+var periodEnd = (date, view) => {
+	if (view === "year") return {
+		day: 31,
+		month: 12,
+		year: date.year
+	};
+	if (view === "month") {
+		const start = monthStart(date);
+		return {
+			...start,
+			day: daysInMonth(start)
+		};
+	}
+	return date;
+};
+var samePeriod = (first, second, view) => {
+	if (view === "year") return first.year === second.year;
+	if (view === "month") return first.year === second.year && first.month === second.month;
+	return samePlain(first, second);
+};
+var periodIntersects = (range, date, view) => Boolean(range.from && range.to && comparePlain(range.from, periodEnd(date, view)) <= 0 && comparePlain(periodStart(date, view), range.to) <= 0);
+var weekday = (date) => utcDate(date.year, date.month, date.day).getUTCDay();
+var plainToDate = (date, timeZone) => calendarDate({
+	...date,
+	hour: 12,
+	minute: 0,
+	second: 0
+}, timeZone);
+var zonedDateFormatters = /* @__PURE__ */ new Map();
+var zonedDateFormatter = (timeZone) => {
+	let format = zonedDateFormatters.get(timeZone);
+	if (!format) {
+		format = new Intl.DateTimeFormat("en-CA", {
+			day: "2-digit",
+			month: "2-digit",
+			timeZone,
+			year: "numeric"
+		});
+		remember(zonedDateFormatters, timeZone, format);
+	}
+	return format;
+};
+var dateToPlain = (date, timeZone) => {
+	if (timeZone) {
+		const parts = zonedDateFormatter(timeZone).formatToParts(date);
+		const value = (type) => Number(parts.find((part) => part.type === type)?.value);
+		return normalize(value("year"), value("month"), value("day"));
+	}
+	return normalize(date.getFullYear(), date.getMonth() + 1, date.getDate());
+};
+var today = (timeZone) => dateToPlain(/* @__PURE__ */ new Date(), timeZone);
+var startOfWeek = (date, weekStartsOn) => addDays(date, -((weekday(date) - weekStartsOn + 7) % 7));
+var startOfGrid = (month, weekStartsOn) => {
+	return startOfWeek(month, weekStartsOn);
+};
+var weeksForMonth = (month, fixedWeeks, weekStartsOn) => {
+	const start = startOfGrid(month, weekStartsOn);
+	const length = fixedWeeks ? 42 : Math.ceil(((weekday(month) - weekStartsOn + 7) % 7 + daysInMonth(month)) / 7) * 7;
+	const weeks = [];
+	for (let index = 0; index < length; index += 7) weeks.push(Array.from({ length: 7 }, (_, day) => addDays(start, index + day)));
+	return weeks;
+};
+var months = (start, count, fixedWeeks, weekStartsOn) => Array.from({ length: Math.max(1, count) }, (_, index) => {
+	const month = monthStart(addMonths(start, index));
+	return {
+		month,
+		weeks: weeksForMonth(month, fixedWeeks, weekStartsOn)
+	};
+});
+var DATE_FORMAT_OPTIONS = {
+	day: { day: "numeric" },
+	fullDate: { dateStyle: "full" },
+	monthCaption: {
+		month: "long",
+		year: "numeric"
+	},
+	monthDropdown: { month: "short" },
+	monthLabel: { month: "long" },
+	weekday: { weekday: "short" }
+};
+var dateFormatters = /* @__PURE__ */ new Map();
+var formatter = (locale, name, timeZone) => {
+	const key = `${locale ?? ""}\0${timeZone ?? ""}`;
+	let formats = dateFormatters.get(key);
+	if (!formats) {
+		formats = {};
+		remember(dateFormatters, key, formats);
+	}
+	return formats[name] ??= new Intl.DateTimeFormat(locale, {
+		...DATE_FORMAT_OPTIONS[name],
+		timeZone
+	});
+};
+var defaultFormatters = {
+	day: (date, locale, timeZone) => formatter(locale, "day", timeZone).format(date),
+	fullDate: (date, locale, timeZone) => formatter(locale, "fullDate", timeZone).format(date),
+	monthCaption: (date, locale, timeZone) => formatter(locale, "monthCaption", timeZone).format(date),
+	monthDropdown: (date, locale, timeZone) => formatter(locale, "monthDropdown", timeZone).format(date),
+	weekNumber: (week) => pad(week),
+	weekday: (date, locale, timeZone) => formatter(locale, "weekday", timeZone).format(date)
+};
+var toPlainArray = (dates, timeZone) => (dates ?? []).map((date) => dateToPlain(date, timeZone));
+var toRangePlain = (range, timeZone) => ({
+	from: range?.from ? dateToPlain(range.from, timeZone) : void 0,
+	to: range?.to ? dateToPlain(range.to, timeZone) : void 0
+});
+var plainIn = (date, dates) => dates.some((item) => samePlain(item, date));
+var rangeContains = (range, date) => Boolean(range.from && range.to && comparePlain(range.from, date) <= 0 && comparePlain(date, range.to) <= 0);
+var rangeMiddle = (range, date) => Boolean(range.from && range.to && comparePlain(range.from, date) < 0 && comparePlain(date, range.to) < 0);
+var weekNumber = (date) => {
+	const target = utcDate(date.year, date.month, date.day);
+	const day = target.getUTCDay() || 7;
+	target.setUTCDate(target.getUTCDate() + 4 - day);
+	const yearStart = utcDate(target.getUTCFullYear(), 1, 1);
+	return Math.ceil(((target.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+};
+var gridTemplate = (showWeekNumber) => showWeekNumber ? "grid-template-columns:var(--cell-size) repeat(7,minmax(var(--cell-size),1fr))" : "grid-template-columns:repeat(7,minmax(var(--cell-size),1fr))";
+var monthOptions = (year) => Array.from({ length: 12 }, (_, month) => ({
+	day: 1,
+	month: month + 1,
+	year
+}));
+var yearBounds = (current, args, now) => {
+	const first = args.startMonth ? dateToPlain(args.startMonth, args.timeZone).year : args.fromYear ?? now.year - 100;
+	const last = args.endMonth ? dateToPlain(args.endMonth, args.timeZone).year : args.toYear ?? Math.max(now.year, current.year);
+	return {
+		first,
+		last: Math.max(first, last)
+	};
+};
+var yearRange = (current, args, now) => {
+	const { first, last } = yearBounds(current, args, now);
+	return Array.from({ length: last - first + 1 }, (_, index) => first + index);
+};
+var yearPage = (current, args, now) => {
+	const allowed = yearRange(current, args, now);
+	const first = allowed[0];
+	const last = allowed[allowed.length - 1];
+	const anchor = Math.min(last, Math.max(first, current.year));
+	const start = first + Math.floor((anchor - first) / 12) * 12;
+	return {
+		allowed,
+		start,
+		years: Array.from({ length: 12 }, (_, index) => start + index)
+	};
+};
+var canNavigateYear = (year, current, args, now) => {
+	const { first, last } = yearBounds(current, args, now);
+	return first <= year && year <= last;
+};
+var canNavigateTo = (month, args) => {
+	const start = args.startMonth ? monthStart(dateToPlain(args.startMonth, args.timeZone)) : args.fromYear ? {
+		day: 1,
+		month: 1,
+		year: args.fromYear
+	} : void 0;
+	const end = args.endMonth ? monthStart(dateToPlain(args.endMonth, args.timeZone)) : args.toYear ? {
+		day: 1,
+		month: 12,
+		year: args.toYear
+	} : void 0;
+	if (start && comparePlain(monthStart(month), start) < 0) return false;
+	if (end && comparePlain(monthStart(month), end) > 0) return false;
+	return true;
+};
+var modifierNames = (modifiers, date) => Array.from(modifiers).filter(([, availability]) => availability.day(date)).map(([name]) => name);
+var modifierAttributes = (names) => Object.fromEntries(names.map((name) => [`data-modifier-${name}`, "true"]));
+var defaultSelectedRange = (value) => value && !Array.isArray(value) && !(value instanceof Date) ? value : void 0;
+var initialMonthDate = (month, defaultMonth, defaultSelected) => {
+	if (month) return month;
+	if (defaultMonth) return defaultMonth;
+	if (defaultSelected instanceof Date) return defaultSelected;
+	if (Array.isArray(defaultSelected)) return defaultSelected[0] ?? /* @__PURE__ */ new Date();
+	return defaultSelectedRange(defaultSelected)?.from ?? /* @__PURE__ */ new Date();
+};
+/** Unstyled native month or year picker used when no custom dropdown is supplied. */
+var CalendarDropdown = ({ label, onValueChange, options, value }) => /* @__PURE__ */ jsx("select", {
+	"aria-label": label,
+	"data-slot": "calendar-dropdown",
+	"set:onchange": (event) => onValueChange(event.currentTarget.value, event),
+	"set:value": value,
+	children: options.map((option) => /* @__PURE__ */ jsx("option", {
+		value: option.value,
+		children: option.label
+	}, option.value))
+});
+var CalendarRoot = function* ({ defaultMonth, defaultSelected, defaultView, minView, month, timeZone, view }) {
+	const initialMonth = monthStart(dateToPlain(initialMonthDate(month, defaultMonth, defaultSelected), timeZone));
+	const initialView = clampView(view ?? defaultView ?? minimumView(minView), minView);
+	const initialSingle = defaultSelected instanceof Date ? dateToPlain(defaultSelected, timeZone) : null;
+	const initialMultiple = Array.isArray(defaultSelected) ? toPlainArray(defaultSelected, timeZone) : [];
+	const initialRange = !Array.isArray(defaultSelected) && !(defaultSelected instanceof Date) ? toRangePlain(defaultSelected, timeZone) : {};
+	let currentArgs = {};
+	let currentView = initialView;
+	let renderedView = initialView;
+	let visible = initialMonth;
+	const domReady = dom(this);
+	let disabledSource;
+	let disabledTimeZone;
+	let disabledAvailability;
+	let modifiersSource;
+	let modifiersTimeZone;
+	let modifierAvailability = /* @__PURE__ */ new Map();
+	let unavailableSource;
+	let unavailableTimeZone;
+	let unavailableAvailability;
+	const syncAvailability = (args) => {
+		if (args.disabled !== disabledSource || args.timeZone !== disabledTimeZone) {
+			disabledSource = args.disabled;
+			disabledTimeZone = args.timeZone;
+			disabledAvailability = compile(args.disabled, { timeZone: args.timeZone });
+		}
+		if (args.modifiers !== modifiersSource || args.timeZone !== modifiersTimeZone) {
+			modifiersSource = args.modifiers;
+			modifiersTimeZone = args.timeZone;
+			modifierAvailability = new Map(Object.entries(args.modifiers ?? {}).flatMap(([name, matcher]) => {
+				const availability = compile(matcher, { timeZone: args.timeZone });
+				return availability ? [[name, availability]] : [];
+			}));
+		}
+		if (args.unavailable !== unavailableSource || args.timeZone !== unavailableTimeZone) {
+			unavailableSource = args.unavailable;
+			unavailableTimeZone = args.timeZone;
+			unavailableAvailability = compile(args.unavailable, { timeZone: args.timeZone });
+		}
+	};
+	const monthState = controlled(this, {
+		fallback: initialMonth,
+		onChange: (next, event) => currentArgs.onMonthChange?.(plainToDate(next, currentArgs.timeZone), event)
+	});
+	const viewState = controlled(this, {
+		fallback: initialView,
+		onChange: (next, event) => currentArgs.onViewChange?.(next, event)
+	});
+	const singleState = controlled(this, {
+		fallback: initialSingle,
+		onChange: (next, event) => {
+			if (currentArgs.mode === "multiple" || currentArgs.mode === "range" || !event) return;
+			currentArgs.onSelect?.(next && plainToDate(next, currentArgs.timeZone), event);
+		}
+	});
+	const multipleState = controlled(this, {
+		fallback: initialMultiple,
+		onChange: (next, event) => {
+			if (currentArgs.mode !== "multiple" || !event) return;
+			currentArgs.onSelect?.(next.map((item) => plainToDate(item, currentArgs.timeZone)), event);
+		}
+	});
+	const rangeState = controlled(this, {
+		fallback: initialRange,
+		onChange: (next, event) => {
+			if (currentArgs.mode !== "range" || !event) return;
+			currentArgs.onSelect?.(next.from || next.to ? {
+				from: next.from ? plainToDate(next.from, currentArgs.timeZone) : void 0,
+				to: next.to ? plainToDate(next.to, currentArgs.timeZone) : void 0
+			} : null, event);
+		}
+	});
+	const focusDay = (date, args) => {
+		queueMicrotask(() => {
+			const find = () => this.querySelector(`button[data-day="${iso(date)}"]:not(:disabled)`);
+			const target = find();
+			if (target) {
+				target.focus();
+				return;
+			}
+			const visible = args.month ? monthStart(dateToPlain(args.month, args.timeZone)) : monthState.value;
+			const count = Math.max(1, args.numberOfMonths ?? 1);
+			const start = monthStart(date);
+			if (comparePlain(start, visible) < 0) moveMonth(addMonths(visible, -1), args);
+			else if (comparePlain(start, addMonths(visible, count - 1)) > 0) moveMonth(addMonths(visible, 1), args);
+			else return;
+			queueMicrotask(() => find()?.focus());
+		});
+	};
+	const focusMonthCell = (month, args, event) => {
+		const target = monthStart(month);
+		queueMicrotask(() => {
+			const find = () => this.querySelector(`button[data-month="${monthIso(target)}"]:not(:disabled)`);
+			const found = find();
+			if (found) {
+				found.focus();
+				return;
+			}
+			if (!canNavigateTo(target, args)) return;
+			moveMonth(target, args, event);
+			queueMicrotask(() => find()?.focus());
+		});
+	};
+	const navigableMonth = (year, args) => {
+		const options = monthOptions(year);
+		return options.find((month) => month.month === visible.month && canNavigateTo(month, args)) ?? options.find((month) => canNavigateTo(month, args));
+	};
+	const canCommitYear = (year, args) => canNavigateTo({
+		day: 1,
+		month: 1,
+		year
+	}, args) && canNavigateTo({
+		day: 1,
+		month: 12,
+		year
+	}, args);
+	const canUseYearCell = (year, args) => minimumView(args.minView) === "year" ? canCommitYear(year, args) : canNavigateYear(year, visible, args, today(args.timeZone));
+	const focusYearCell = (year, args, event) => {
+		queueMicrotask(() => {
+			const find = () => this.querySelector(`button[data-year="${year}"]:not(:disabled)`);
+			const found = find();
+			if (found) {
+				found.focus();
+				return;
+			}
+			if (!canUseYearCell(year, args)) return;
+			const month = navigableMonth(year, args);
+			if (!month) return;
+			moveMonth(month, args, event);
+			queueMicrotask(() => find()?.focus());
+		});
+	};
+	const moveMonth = (next, args, event) => {
+		const target = monthStart(next);
+		if (!canNavigateTo(target, args)) return;
+		monthState.set(target, event);
+	};
+	const selectPeriod = (date, view, args, event) => {
+		const start = periodStart(date, view);
+		const end = periodEnd(date, view);
+		if (args.mode === "multiple") {
+			const current = multipleState.value;
+			const next = current.some((item) => samePeriod(item, start, view)) ? current.filter((item) => !samePeriod(item, start, view)) : [...current, start];
+			if (args.required && !next.length) return;
+			multipleState.set(next, event);
+			return;
+		}
+		if (args.mode === "range") {
+			const current = rangeState.value;
+			let next;
+			if (!current.from || current.to) next = { from: start };
+			else if (comparePlain(start, periodStart(current.from, view)) < 0) next = {
+				from: start,
+				to: periodEnd(current.from, view)
+			};
+			else if (samePeriod(start, current.from, view) && !args.required) next = {};
+			else next = {
+				from: periodStart(current.from, view),
+				to: end
+			};
+			rangeState.set(next, event);
+			return;
+		}
+		const current = singleState.value;
+		const next = current && samePeriod(current, start, view) && !args.required ? null : start;
+		singleState.set(next, event);
+	};
+	const selectDay = (date, args, event) => {
+		if (disabledAvailability?.day(plainToDate(date, args.timeZone))) return;
+		selectPeriod(date, "day", args, event);
+	};
+	const changeView = (next, args, event) => {
+		const target = clampView(next, args.minView);
+		if (target === currentView) return;
+		viewState.set(target, event);
+	};
+	const drillUp = (anchor, args, event) => {
+		if (currentView === "day") {
+			if (!samePeriod(anchor, visible, "month")) moveMonth(anchor, args, event);
+			changeView("month", args, event);
+			focusMonthCell(anchor, args);
+			return;
+		}
+		if (currentView === "month") {
+			changeView("year", args, event);
+			focusYearCell(anchor.year, args);
+		}
+	};
+	const selectMonthCell = (month, args, event) => {
+		if (minimumView(args.minView) === "month") {
+			selectPeriod(month, "month", args, event);
+			return;
+		}
+		moveMonth(month, args, event);
+		changeView("day", args, event);
+		focusDay(monthStart(month), args);
+	};
+	const selectYearCell = (year, args, event) => {
+		if (!canUseYearCell(year, args)) return;
+		const month = navigableMonth(year, args);
+		if (!month) return;
+		if (minimumView(args.minView) === "year") {
+			selectPeriod(month, "year", args, event);
+			return;
+		}
+		moveMonth(month, args, event);
+		changeView("month", args, event);
+		focusMonthCell(month, args);
+	};
+	const onMove = (move, event) => {
+		const button = event.target instanceof Element ? event.target.closest("button[data-day],button[data-month],button[data-year]") : null;
+		const args = currentArgs;
+		const month = button?.dataset.month ? parseMonthIso(button.dataset.month) : void 0;
+		const year = button?.dataset.year ? Number(button.dataset.year) : void 0;
+		if (month) {
+			if ("cols" in move) focusMonthCell(addMonths(month, move.cols), args, event);
+			else if ("rows" in move) focusMonthCell(addMonths(month, move.rows * 3), args, event);
+			else if ("page" in move) focusMonthCell(addMonths(month, move.page * 12), args, event);
+			else {
+				const rowStart = Math.floor((month.month - 1) / 3) * 3 + 1;
+				const candidates = monthOptions(month.year).filter((candidate) => canNavigateTo(candidate, args) && (move.extent === "all" || rowStart <= candidate.month && candidate.month <= rowStart + 2));
+				const target = move.edge === "start" ? candidates[0] : candidates[candidates.length - 1];
+				if (target) focusMonthCell(target, args, event);
+			}
+			return;
+		}
+		if (year != null && Number.isFinite(year)) {
+			if ("cols" in move) focusYearCell(year + move.cols, args, event);
+			else if ("rows" in move) focusYearCell(year + move.rows * 3, args, event);
+			else if ("page" in move) focusYearCell(year + move.page * 12, args, event);
+			else {
+				const page = yearPage(visible, args, today(args.timeZone));
+				const rowStart = page.start + Math.floor((year - page.start) / 3) * 3;
+				const candidates = page.years.filter((candidate) => canUseYearCell(candidate, args) && (move.extent === "all" || rowStart <= candidate && candidate <= rowStart + 2));
+				const target = move.edge === "start" ? candidates[0] : candidates[candidates.length - 1];
+				if (target != null) focusYearCell(target, args, event);
+			}
+			return;
+		}
+		const day = button?.dataset.day ? parseIso(button.dataset.day) : void 0;
+		if (!day) return;
+		if ("cols" in move) {
+			focusDay(addDays(day, move.cols), args);
+			return;
+		}
+		if ("rows" in move) {
+			focusDay(addDays(day, move.rows * 7), args);
+			return;
+		}
+		if ("page" in move) {
+			const count = move.page * (move.large ? 12 : 1);
+			const target = addMonths(day, count);
+			if (!canNavigateTo(monthStart(target), args)) return;
+			moveMonth(addMonths(visible, count), args, event);
+			focusDay(target, args);
+			return;
+		}
+		if (move.extent === "row") {
+			const start = startOfWeek(day, args.weekStartsOn ?? 0);
+			focusDay(move.edge === "start" ? start : addDays(start, 6), args);
+			return;
+		}
+		const start = monthStart(day);
+		focusDay(move.edge === "start" ? start : {
+			...start,
+			day: daysInMonth(start)
+		}, args);
+	};
+	const nav = grid(this, {
+		rtl: () => currentArgs.dir === "rtl",
+		onMove
+	});
+	const onCellKeydown = (event) => {
+		if (event.key !== "Escape" || viewRank[currentView] <= viewRank[minimumView(currentArgs.minView)]) {
+			nav.handle(event);
+			return;
+		}
+		event.preventDefault();
+		event.stopPropagation();
+		if (currentView === "year") {
+			changeView("month", currentArgs, event);
+			focusMonthCell(visible, currentArgs);
+			return;
+		}
+		changeView("day", currentArgs, event);
+		focusDay(visible, currentArgs);
+	};
+	for (const args of this) {
+		currentArgs = args;
+		syncAvailability(args);
+		monthState.sync(args.month ? monthStart(dateToPlain(args.month, args.timeZone)) : void 0);
+		viewState.sync(args.view === void 0 ? void 0 : clampView(args.view, args.minView));
+		const clampedView = clampView(viewState.value, args.minView);
+		if (!viewState.controlled && clampedView !== viewState.value) viewState.init(clampedView);
+		singleState.sync(args.mode === "multiple" || args.mode === "range" || args.selected === void 0 ? void 0 : args.selected && dateToPlain(args.selected, args.timeZone));
+		multipleState.sync(args.mode === "multiple" && args.selected !== void 0 ? toPlainArray(args.selected, args.timeZone) : void 0);
+		rangeState.sync(args.mode === "range" && args.selected !== void 0 ? toRangePlain(args.selected ?? void 0, args.timeZone) : void 0);
+		const now = today(args.timeZone);
+		visible = monthState.value;
+		currentView = clampedView;
+		if (renderedView !== currentView && domReady) {
+			const active = document.activeElement;
+			if (active instanceof HTMLElement && this.contains(active)) if (currentView === "day") focusDay(visible, args);
+			else if (currentView === "month") focusMonthCell(visible, args);
+			else focusYearCell(visible.year, args);
+		}
+		renderedView = currentView;
+		const weekStartsOn = args.weekStartsOn ?? 0;
+		const count = Math.max(1, args.numberOfMonths ?? 1);
+		const locale = localeCode(args.locale);
+		const formats = {
+			...defaultFormatters,
+			...args.formatters ?? {}
+		};
+		const shown = months(visible, count, Boolean(args.fixedWeeks), weekStartsOn);
+		const single = singleState.value;
+		const multiple = multipleState.value;
+		const range = rangeState.value;
+		const years = yearRange(visible, args, now);
+		const dayColumns = gridTemplate(Boolean(args.showWeekNumber));
+		const captionLayout = args.captionLayout ?? "button";
+		const MonthDropdown = args.monthDropdown ?? CalendarDropdown;
+		const YearDropdown = args.yearDropdown ?? CalendarDropdown;
+		const page = yearPage(visible, args, now);
+		const periodFlags = (date, view) => {
+			const range_start = args.mode === "range" && Boolean(range.from && samePeriod(range.from, date, view));
+			const range_end = args.mode === "range" && Boolean(range.to && samePeriod(range.to, date, view));
+			const range_middle = args.mode === "range" && periodIntersects(range, date, view) && !range_start && !range_end;
+			return {
+				range_end,
+				range_middle,
+				range_start,
+				selected: args.mode === "multiple" ? multiple.some((item) => samePeriod(item, date, view)) : args.mode === "range" ? range_start || range_end || range_middle : Boolean(single && samePeriod(single, date, view))
+			};
+		};
+		const canPreviousView = currentView === "day" ? canNavigateTo(addMonths(visible, -1), args) : currentView === "month" ? canNavigateYear(visible.year - 1, visible, args, now) : page.start > page.allowed[0];
+		const canNextView = currentView === "day" ? canNavigateTo(addMonths(visible, count), args) : currentView === "month" ? canNavigateYear(visible.year + 1, visible, args, now) : page.start + 12 <= page.allowed[page.allowed.length - 1];
+		const navigateView = (direction, event) => {
+			if (currentView === "day") {
+				moveMonth(addMonths(visible, direction < 0 ? -1 : count), args, event);
+				return;
+			}
+			const month = navigableMonth(visible.year + direction * (currentView === "month" ? 1 : 12), args);
+			if (month) moveMonth(month, args, event);
+		};
+		const previousLabel = args.previousMonthLabel ?? (currentView === "day" ? "Previous month" : currentView === "month" ? "Previous year" : "Previous 12 years");
+		const nextLabel = args.nextMonthLabel ?? (currentView === "day" ? "Next month" : currentView === "month" ? "Next year" : "Next 12 years");
+		yield /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("div", {
+			class: args.classNames?.months,
+			"data-slot": "calendar-months",
+			children: currentView === "day" ? shown.map(({ month: item, weeks }, monthIndex) => {
+				const monthDate = plainToDate(item, args.timeZone);
+				const showMonthDropdown = captionLayout === "dropdown" || captionLayout === "dropdown-months";
+				const showYearDropdown = captionLayout === "dropdown" || captionLayout === "dropdown-years";
+				const firstMonth = monthIndex === 0;
+				const lastMonth = monthIndex === shown.length - 1;
+				return /* @__PURE__ */ jsxs("div", {
+					class: args.classNames?.month,
+					"data-month": iso(item),
+					"data-slot": "calendar-month",
+					children: [/* @__PURE__ */ jsxs("div", {
+						class: args.classNames?.caption,
+						"data-slot": "calendar-caption",
+						children: [
+							firstMonth ? /* @__PURE__ */ jsx("button", {
+								"aria-disabled": canPreviousView ? void 0 : "true",
+								"aria-label": previousLabel,
+								class: args.navButtonClass,
+								"data-slot": "calendar-previous",
+								disabled: !canPreviousView,
+								type: "button",
+								"set:onclick": (event) => navigateView(-1, event),
+								children: args.previousIcon ?? /* @__PURE__ */ jsx("span", {
+									"aria-hidden": "true",
+									class: args.previousIconClass,
+									"data-slot": "calendar-previous-icon"
+								})
+							}) : /* @__PURE__ */ jsx("span", {
+								"aria-hidden": "true",
+								class: args.navSpacerClass,
+								"data-slot": "calendar-nav-spacer"
+							}),
+							captionLayout === "button" ? /* @__PURE__ */ jsx("button", {
+								class: args.captionLabelClass,
+								"data-slot": "calendar-view-trigger",
+								type: "button",
+								"set:onclick": (event) => drillUp(item, args, event),
+								children: formats.monthCaption(monthDate, locale, args.timeZone)
+							}) : captionLayout === "label" ? /* @__PURE__ */ jsx("div", {
+								class: args.captionLabelClass,
+								"data-slot": "calendar-caption-label",
+								children: formats.monthCaption(monthDate, locale, args.timeZone)
+							}) : /* @__PURE__ */ jsxs("div", {
+								class: args.classNames?.dropdowns,
+								"data-slot": "calendar-dropdowns",
+								children: [showMonthDropdown ? /* @__PURE__ */ jsx(MonthDropdown, {
+									label: args.monthSelectLabel ?? "Month",
+									options: monthOptions(item.year).map((option) => ({
+										label: formats.monthDropdown(plainToDate(option, args.timeZone), locale, args.timeZone),
+										value: String(option.month)
+									})),
+									onValueChange: (value, event) => moveMonth({
+										...item,
+										month: Number(value)
+									}, args, event),
+									value: String(item.month)
+								}) : /* @__PURE__ */ jsx("div", {
+									class: args.monthLabelClass,
+									"data-slot": "calendar-month-label",
+									children: formatter(locale, "monthLabel", args.timeZone).format(monthDate)
+								}), showYearDropdown ? /* @__PURE__ */ jsx(YearDropdown, {
+									label: args.yearSelectLabel ?? "Year",
+									onValueChange: (value, event) => moveMonth({
+										...item,
+										year: Number(value)
+									}, args, event),
+									options: years.map((year) => ({
+										label: year,
+										value: String(year)
+									})),
+									value: String(item.year)
+								}) : /* @__PURE__ */ jsx("div", {
+									class: args.yearLabelClass,
+									"data-slot": "calendar-year-label",
+									children: item.year
+								})]
+							}),
+							lastMonth ? /* @__PURE__ */ jsx("button", {
+								"aria-disabled": canNextView ? void 0 : "true",
+								"aria-label": nextLabel,
+								class: args.navButtonClass,
+								"data-slot": "calendar-next",
+								disabled: !canNextView,
+								type: "button",
+								"set:onclick": (event) => navigateView(1, event),
+								children: args.nextIcon ?? /* @__PURE__ */ jsx("span", {
+									"aria-hidden": "true",
+									class: args.nextIconClass,
+									"data-slot": "calendar-next-icon"
+								})
+							}) : /* @__PURE__ */ jsx("span", {
+								"aria-hidden": "true",
+								class: args.navSpacerClass,
+								"data-slot": "calendar-nav-spacer"
+							})
+						]
+					}), /* @__PURE__ */ jsxs("div", {
+						class: args.classNames?.grid,
+						"data-slot": "calendar-grid",
+						role: "grid",
+						"aria-label": formats.monthCaption(monthDate, locale, args.timeZone),
+						children: [/* @__PURE__ */ jsxs("div", {
+							class: args.classNames?.head,
+							"data-slot": "calendar-weekdays",
+							role: "row",
+							style: dayColumns,
+							children: [args.showWeekNumber && /* @__PURE__ */ jsx("div", {
+								"aria-hidden": "true",
+								class: args.classNames?.week_number,
+								"data-slot": "calendar-week-number-header"
+							}), Array.from({ length: 7 }, (_, index) => addDays({
+								year: 2026,
+								month: 7,
+								day: 5
+							}, weekStartsOn + index)).map((day, index) => /* @__PURE__ */ jsx("div", {
+								class: args.classNames?.weekday,
+								"data-slot": "calendar-weekday",
+								role: "columnheader",
+								children: formats.weekday(plainToDate(day, args.timeZone), locale, args.timeZone)
+							}, index))]
+						}), weeks.map((week, row) => /* @__PURE__ */ jsxs("div", {
+							class: args.classNames?.week,
+							"data-slot": "calendar-week",
+							role: "row",
+							style: dayColumns,
+							children: [args.showWeekNumber && /* @__PURE__ */ jsx("div", {
+								class: args.classNames?.week_number,
+								"data-slot": "calendar-week-number",
+								role: "rowheader",
+								children: formats.weekNumber(weekNumber(week[0]), locale)
+							}), week.map((day) => {
+								const outside = day.month !== item.month || day.year !== item.year;
+								const date = plainToDate(day, args.timeZone);
+								const disabled = outside && args.showOutsideDays === false ? true : Boolean(disabledAvailability?.day(date));
+								const unavailable = Boolean(unavailableAvailability?.day(date));
+								const range_start = !outside && args.mode === "range" && Boolean(range.from && samePlain(range.from, day));
+								const range_end = !outside && args.mode === "range" && Boolean(range.to && samePlain(range.to, day));
+								const rawRangeMiddle = !outside && args.mode === "range" && rangeMiddle(range, day);
+								const rangeGap = rawRangeMiddle && unavailable && Boolean(args.allowNonContiguous);
+								const selected = !rangeGap && !outside && (args.mode === "multiple" ? plainIn(day, multiple) : args.mode === "range" ? Boolean(range.from && samePlain(range.from, day) || range.to && samePlain(range.to, day) || rangeContains(range, day)) : Boolean(single && samePlain(single, day)));
+								const range_middle = rawRangeMiddle && !rangeGap;
+								const current = samePlain(day, now);
+								const modifierList = modifierNames(modifierAvailability, date);
+								const modifiers = {
+									disabled,
+									outside,
+									range_end,
+									range_middle,
+									range_start,
+									selected,
+									today: current,
+									unavailable
+								};
+								const hidden = outside && args.showOutsideDays === false;
+								const state = {
+									date,
+									hidden,
+									modifierNames: modifierList,
+									modifiers,
+									range: args.mode === "range" && Boolean(range.from && range.to)
+								};
+								return /* @__PURE__ */ jsx("div", {
+									class: args.dayClassName?.(state) ?? args.classNames?.day,
+									"data-disabled": disabled ? "true" : void 0,
+									"data-outside": outside ? "true" : void 0,
+									"data-selected": selected ? "true" : void 0,
+									"data-slot": "calendar-day",
+									"data-today": current ? "true" : void 0,
+									"data-unavailable": unavailable ? "true" : void 0,
+									role: "gridcell",
+									...modifierAttributes(modifierList),
+									children: hidden ? /* @__PURE__ */ jsx("span", {
+										"aria-hidden": "true",
+										class: args.hiddenDayClass,
+										children: day.day
+									}) : /* @__PURE__ */ jsx(CalendarDayButton, {
+										"aria-label": formats.fullDate(date, locale, args.timeZone),
+										class: args.dayButtonClass,
+										date,
+										day: args.renderDay?.(date, modifiers) ?? formats.day(date, locale, args.timeZone),
+										timeZone: args.timeZone,
+										disabled: disabled || outside,
+										modifiers,
+										"set:onclick": (event) => selectDay(day, args, event),
+										"set:onkeydown": onCellKeydown
+									})
+								}, iso(day));
+							})]
+						}, row))]
+					})]
+				}, iso(item));
+			}) : /* @__PURE__ */ jsxs("div", {
+				class: args.classNames?.month,
+				children: [/* @__PURE__ */ jsxs("div", {
+					class: args.classNames?.caption,
+					"data-slot": "calendar-caption",
+					children: [
+						/* @__PURE__ */ jsx("button", {
+							"aria-disabled": canPreviousView ? void 0 : "true",
+							"aria-label": previousLabel,
+							class: args.navButtonClass,
+							"data-slot": "calendar-previous",
+							disabled: !canPreviousView,
+							type: "button",
+							"set:onclick": (event) => navigateView(-1, event),
+							children: args.previousIcon ?? /* @__PURE__ */ jsx("span", {
+								"aria-hidden": "true",
+								class: args.previousIconClass,
+								"data-slot": "calendar-previous-icon"
+							})
+						}),
+						captionLayout === "button" ? /* @__PURE__ */ jsx("button", {
+							"aria-disabled": currentView === "year" ? "true" : void 0,
+							class: args.captionLabelClass,
+							"data-slot": "calendar-view-trigger",
+							disabled: currentView === "year",
+							type: "button",
+							"set:onclick": (event) => drillUp(visible, args, event),
+							children: currentView === "month" ? visible.year : `${page.start}–${page.start + 11}`
+						}) : /* @__PURE__ */ jsx("div", {
+							class: args.captionLabelClass,
+							"data-slot": "calendar-caption-label",
+							children: currentView === "month" ? visible.year : `${page.start}–${page.start + 11}`
+						}),
+						/* @__PURE__ */ jsx("button", {
+							"aria-disabled": canNextView ? void 0 : "true",
+							"aria-label": nextLabel,
+							class: args.navButtonClass,
+							"data-slot": "calendar-next",
+							disabled: !canNextView,
+							type: "button",
+							"set:onclick": (event) => navigateView(1, event),
+							children: args.nextIcon ?? /* @__PURE__ */ jsx("span", {
+								"aria-hidden": "true",
+								class: args.nextIconClass,
+								"data-slot": "calendar-next-icon"
+							})
+						})
+					]
+				}), currentView === "month" ? /* @__PURE__ */ jsx("div", {
+					"aria-label": String(visible.year),
+					class: args.classNames?.month_view,
+					"data-slot": "calendar-month-view",
+					role: "grid",
+					style: "display:grid;grid-template-columns:repeat(3,minmax(0,1fr))",
+					children: monthOptions(visible.year).map((month) => {
+						const disabled = !canNavigateTo(month, args);
+						const flags = periodFlags(month, "month");
+						const current = samePeriod(month, now, "month");
+						const value = monthIso(month);
+						return /* @__PURE__ */ jsx("div", {
+							role: "gridcell",
+							children: /* @__PURE__ */ jsx("button", {
+								"aria-disabled": disabled ? "true" : void 0,
+								"aria-label": formats.monthCaption(plainToDate(month, args.timeZone), locale, args.timeZone),
+								class: args.classNames?.month_cell,
+								"data-disabled": disabled ? "true" : void 0,
+								"data-month": value,
+								"data-range-end": flags.range_end ? "true" : void 0,
+								"data-range-middle": flags.range_middle ? "true" : void 0,
+								"data-range-start": flags.range_start ? "true" : void 0,
+								"data-selected": flags.selected ? "true" : void 0,
+								"data-slot": "calendar-month-cell",
+								"data-today": current ? "true" : void 0,
+								disabled,
+								type: "button",
+								"set:onclick": (event) => selectMonthCell(month, args, event),
+								"set:onkeydown": onCellKeydown,
+								children: formatter(locale, "monthLabel", args.timeZone).format(plainToDate(month, args.timeZone))
+							})
+						}, value);
+					})
+				}) : /* @__PURE__ */ jsx("div", {
+					"aria-label": `${page.start}–${page.start + 11}`,
+					class: args.classNames?.year_view,
+					"data-slot": "calendar-year-view",
+					role: "grid",
+					style: "display:grid;grid-template-columns:repeat(3,minmax(0,1fr))",
+					children: page.years.map((year) => {
+						const disabled = !canUseYearCell(year, args);
+						const flags = periodFlags({
+							day: 1,
+							month: 1,
+							year
+						}, "year");
+						const current = year === now.year;
+						return /* @__PURE__ */ jsx("div", {
+							role: "gridcell",
+							children: /* @__PURE__ */ jsx("button", {
+								"aria-disabled": disabled ? "true" : void 0,
+								class: args.classNames?.year_cell,
+								"data-disabled": disabled ? "true" : void 0,
+								"data-range-end": flags.range_end ? "true" : void 0,
+								"data-range-middle": flags.range_middle ? "true" : void 0,
+								"data-range-start": flags.range_start ? "true" : void 0,
+								"data-selected": flags.selected ? "true" : void 0,
+								"data-slot": "calendar-year-cell",
+								"data-today": current ? "true" : void 0,
+								"data-year": String(year),
+								disabled,
+								type: "button",
+								"set:onclick": (event) => selectYearCell(year, args, event),
+								"set:onkeydown": onCellKeydown,
+								children: year
+							})
+						}, year);
+					})
+				})]
+			}, `${currentView}-${currentView === "year" ? page.start : visible.year}`)
+		}) });
+	}
+};
+/** Unstyled calendar with single, multiple, and range selection. */
+var Calendar = ({ allowNonContiguous, captionLabelClass, captionLayout, class: classes, classNames, dayButtonClass, dayClassName, defaultMonth, defaultSelected, defaultView, disabled, endMonth, fixedWeeks, formatters, fromYear, hiddenDayClass, locale, minView, month, monthDropdown, monthLabelClass, monthSelectLabel, nextMonthLabel, previousMonthLabel, yearSelectLabel, modifiers, navButtonClass, navSpacerClass, nextIcon, nextIconClass, numberOfMonths, onMonthChange, onViewChange, previousIcon, previousIconClass, renderDay, required, showOutsideDays = true, showWeekNumber, startMonth, timeZone, toYear, unavailable, view, weekStartsOn, yearDropdown, yearLabelClass, ...attrs }) => {
+	const { dir, mode, onSelect, selected, ...rest } = attrs;
+	const resolvedDir = dir ?? DirectionContext();
+	return /* @__PURE__ */ jsx(CalendarRoot, {
+		allowNonContiguous,
+		captionLabelClass,
+		captionLayout,
+		classNames,
+		dayButtonClass,
+		dayClassName,
+		defaultMonth,
+		defaultSelected,
+		defaultView,
+		disabled,
+		dir: resolvedDir,
+		endMonth,
+		fixedWeeks,
+		formatters,
+		fromYear,
+		hiddenDayClass,
+		locale,
+		minView,
+		mode,
+		month,
+		monthDropdown,
+		monthLabelClass,
+		monthSelectLabel,
+		nextMonthLabel,
+		previousMonthLabel,
+		yearSelectLabel,
+		modifiers,
+		navButtonClass,
+		navSpacerClass,
+		nextIcon,
+		nextIconClass,
+		numberOfMonths,
+		onMonthChange,
+		onSelect,
+		onViewChange,
+		previousIcon,
+		previousIconClass,
+		renderDay,
+		required,
+		selected,
+		showOutsideDays,
+		showWeekNumber,
+		startMonth,
+		timeZone,
+		toYear,
+		unavailable,
+		view,
+		weekStartsOn,
+		yearDropdown,
+		yearLabelClass,
+		...statefulRootAttrs(rest),
+		"attr:class": classes,
+		"attr:data-slot": "calendar",
+		"attr:dir": resolvedDir
+	});
+};
+/** Unstyled day button used by Calendar. */
+var CalendarDayButton = ({ class: classes, date, day, modifiers, timeZone, type = "button", ...attrs }) => {
+	const value = dateToPlain(date, timeZone);
+	const single = modifiers.selected && !modifiers.range_start && !modifiers.range_end && !modifiers.range_middle;
+	return /* @__PURE__ */ jsx("button", {
+		...attrs,
+		"aria-disabled": modifiers.unavailable ? "true" : attrs["aria-disabled"],
+		class: classes,
+		"data-day": iso(value),
+		"data-disabled": modifiers.disabled ? "true" : void 0,
+		"data-outside": modifiers.outside ? "true" : void 0,
+		"data-range-end": modifiers.range_end ? "true" : void 0,
+		"data-range-middle": modifiers.range_middle ? "true" : void 0,
+		"data-range-start": modifiers.range_start ? "true" : void 0,
+		"data-selected-single": single ? "true" : void 0,
+		"data-slot": "calendar-day-button",
+		"data-state": modifiers.selected ? "selected" : "unselected",
+		"data-today": modifiers.today ? "true" : void 0,
+		"data-unavailable": modifiers.unavailable ? "true" : void 0,
+		type,
+		children: day
+	});
+};
+//#endregion
+export { field as a, isReversed as c, defaultMessage as i, timeRun as l, CalendarDayButton as n, formatValue as o, compile as r, fromISO as s, Calendar as t, unitLabel as u };