@nepdatejs/datepicker 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1320 @@
+import { addDays, addMonths, compareDates, differenceInDays, endOfMonth, endOfWeek, endOfYear, fiscalYear, fiscalYearRange, formatDate, formatMessage, formatNumber, formatTime, fromIsoDate, fromIsoDateTime, getConfig, getLocale, isWithin, now, parseDate, parseTime, startOfMonth, startOfWeek, startOfYear, toCalendar, toIsoDate, toIsoDateTime, today } from "@nepdatejs/core";
+import { createCalendar, isDayList } from "@nepdatejs/calendar";
+//#region src/mask.ts
+const DIGIT = "[0-9०-९]";
+const DIGITS_ONLY = new RegExp(`^${DIGIT}{1,8}$`);
+const YEAR_MONTH = new RegExp(`^(${DIGIT}{4}-${DIGIT}{2})(${DIGIT}?)$`);
+/**
+* Add the dashes of YYYY-MM-DD while the user types digits: "2083" becomes
+* "2083-", "208306" becomes "2083-06-" and a pasted "20830624" becomes
+* "2083-06-24". ASCII and Devanagari digits keep their script, and a
+* separator typed straight after a dash is dropped, so typing the dashes
+* yourself works too. Only text that grew at the end (typing, or a paste into
+* an empty field) is touched: deleting, editing in the middle and other
+* separators ("2083/6/4") are left as the user wrote them. Pure.
+*/
+function maskDateText(next, previous = "") {
+	if (next.length <= previous.length || !next.startsWith(previous)) return next;
+	if (previous.endsWith("-") && /^[-./]$/.test(next.slice(previous.length))) return previous;
+	if (DIGITS_ONLY.test(next)) {
+		let out = next.slice(0, 4);
+		if (next.length >= 4) out += "-";
+		out += next.slice(4, 6);
+		if (next.length >= 6) out += "-";
+		return out + next.slice(6);
+	}
+	const yearMonth = YEAR_MONTH.exec(next);
+	if (yearMonth) return `${yearMonth[1] ?? ""}-${yearMonth[2] ?? ""}`;
+	return next;
+}
+//#endregion
+//#region src/input.ts
+/**
+* Read what the user typed: year first, ASCII or Devanagari digits, in the
+* calendar on screen. All date work is done by core (docs/plan D-005).
+*/
+function parseInput(text, calendar, limits, locale, format = "iso") {
+	if (text.trim() === "") return { kind: "empty" };
+	const messages = getLocale(locale).messages;
+	const date = parseDate(text, calendar);
+	if (!date) return {
+		kind: "error",
+		error: {
+			code: "format",
+			message: messages.invalidFormat[calendar]
+		}
+	};
+	const error = checkDate(date, calendar, limits, locale, format);
+	return error ? {
+		kind: "error",
+		error
+	} : {
+		kind: "date",
+		date: toCalendar(date, "AD")
+	};
+}
+/** Null when the day is allowed; otherwise a translated error. */
+function checkDate(date, calendar, limits, locale, format = "iso") {
+	const messages = getLocale(locale).messages;
+	if (!isWithin(date, limits.min, limits.max)) {
+		const values = {
+			min: formatInput(limits.min, calendar, format, locale),
+			max: formatInput(limits.max, calendar, format, locale)
+		};
+		const template = limits.hasMin === limits.hasMax ? messages.outOfRange : limits.hasMin ? messages.onOrAfter : messages.onOrBefore;
+		return {
+			code: "range",
+			message: formatMessage(template, values)
+		};
+	}
+	if (limits.isDateDisabled?.(date)) return {
+		code: "disabled",
+		message: messages.unavailable
+	};
+	return null;
+}
+/** How the input shows a date: in the calendar on screen, with the locale's digits. */
+function formatInput(date, calendar, format, locale) {
+	return date ? formatDate(toCalendar(date, calendar), format, locale) : "";
+}
+/** "10 October 2026 AD": the same day in the other calendar. */
+function equivalentText(date, calendar, locale) {
+	if (!date) return null;
+	const other = calendar === "BS" ? "AD" : "BS";
+	return `${formatDate(toCalendar(date, other), "long", locale)} ${getLocale(locale).calendarNames[other]}`;
+}
+function placeholderText(calendar, locale) {
+	return `YYYY-MM-DD (${getLocale(locale).calendarNames[calendar]})`;
+}
+/** An AD "YYYY-MM-DD" string as a date; anything else is null. */
+function readIso(value) {
+	return value ? fromIsoDate(value) : null;
+}
+function detailOf(date) {
+	return date ? Object.freeze({
+		ad: toCalendar(date, "AD"),
+		bs: toCalendar(date, "BS")
+	}) : null;
+}
+//#endregion
+//#region src/base.ts
+/** The panel calendar's options that come straight from the picker's options. */
+function panelOptions(options, calendar) {
+	return {
+		calendar,
+		locale: options.locale,
+		min: readIso(options.min),
+		max: readIso(options.max),
+		isDateDisabled: options.isDateDisabled,
+		holidays: options.holidays,
+		events: options.events,
+		showOtherCalendar: options.showOtherCalendar,
+		weekStartsOn: options.weekStartsOn,
+		weekendDays: options.weekendDays,
+		today: options.today
+	};
+}
+/** What may be typed: the panel's effective range, so typing and clicking agree. */
+function inputLimits(options, panel) {
+	const { minDate, maxDate } = panel.getState();
+	return {
+		min: minDate,
+		max: maxDate,
+		hasMin: readIso(options.min) !== null,
+		hasMax: readIso(options.max) !== null,
+		isDateDisabled: options.isDateDisabled
+	};
+}
+function localeOf(options) {
+	return options.locale ?? getConfig().defaultLocale;
+}
+function formatOf(options) {
+	return options.displayFormat ?? "iso";
+}
+function todayOf(options) {
+	return options.today ?? today("AD");
+}
+function isRange(selection) {
+	return !isDayList(selection) && !("calendar" in selection);
+}
+function isSingleDay(selection) {
+	return !isDayList(selection) && "calendar" in selection;
+}
+/**
+* Listener set plus batching: changes made inside `act` notify once at the end,
+* and callbacks queued with `after` run after listeners have seen the new state.
+*/
+function createEmitter(rebuild) {
+	const listeners = /* @__PURE__ */ new Set();
+	const queued = [];
+	let depth = 0;
+	function notify() {
+		rebuild();
+		for (const listener of [...listeners]) listener();
+	}
+	return {
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		act(change) {
+			depth++;
+			try {
+				change();
+			} finally {
+				depth--;
+				if (depth === 0) {
+					const callbacks = queued.splice(0);
+					try {
+						notify();
+					} finally {
+						for (const callback of callbacks) callback();
+					}
+				}
+			}
+		},
+		after(callback) {
+			queued.push(callback);
+		},
+		notify() {
+			if (depth === 0) notify();
+		},
+		clear() {
+			listeners.clear();
+		}
+	};
+}
+//#endregion
+//#region src/presets.ts
+/** The date a built-in single preset stands for. */
+function resolveSinglePreset(id, context) {
+	const today = toCalendar(context.today, context.calendar);
+	switch (id) {
+		case "today": return today;
+		case "yesterday": return addDays(today, -1);
+		case "tomorrow": return addDays(today, 1);
+	}
+}
+/** The range a built-in range preset stands for, in the calendar on screen. */
+function resolveRangePreset(id, context) {
+	const today = toCalendar(context.today, context.calendar);
+	const week = context.weekStartsOn;
+	switch (id) {
+		case "today": return {
+			start: today,
+			end: today
+		};
+		case "yesterday": {
+			const day = addDays(today, -1);
+			return {
+				start: day,
+				end: day
+			};
+		}
+		case "thisWeek": return {
+			start: startOfWeek(today, week),
+			end: endOfWeek(today, week)
+		};
+		case "lastWeek": {
+			const day = addDays(today, -7);
+			return {
+				start: startOfWeek(day, week),
+				end: endOfWeek(day, week)
+			};
+		}
+		case "last7Days": return {
+			start: addDays(today, -6),
+			end: today
+		};
+		case "last30Days": return {
+			start: addDays(today, -29),
+			end: today
+		};
+		case "thisMonth": return {
+			start: startOfMonth(today),
+			end: endOfMonth(today)
+		};
+		case "lastMonth": {
+			const month = addMonths(startOfMonth(today), -1);
+			return {
+				start: month,
+				end: endOfMonth(month)
+			};
+		}
+		case "thisYear": return {
+			start: startOfYear(today),
+			end: endOfYear(today)
+		};
+		case "thisFiscalYear": {
+			const fy = fiscalYear(today);
+			return {
+				start: fy.firstDay,
+				end: fy.lastDay
+			};
+		}
+		case "lastFiscalYear": {
+			const fy = fiscalYearRange(fiscalYear(today).startYear - 1);
+			return {
+				start: fy.firstDay,
+				end: fy.lastDay
+			};
+		}
+	}
+}
+/** Shared by both pickers: label + resolver for a preset entry. */
+function describePreset(preset, locale, resolveBuiltIn) {
+	if (typeof preset === "string") {
+		const labels = getLocale(locale).presets;
+		return {
+			id: preset,
+			label: Object.prototype.hasOwnProperty.call(labels, preset) ? labels[preset] ?? preset : preset,
+			resolve: (context) => resolveBuiltIn(preset, context)
+		};
+	}
+	return preset;
+}
+//#endregion
+//#region src/picker.ts
+/**
+* A BS/AD date picker without UI: typed text ⇄ value, validation, the BS/AD
+* switch and open/close, plus the panel's calendar store. The value is always
+* an AD "YYYY-MM-DD" string (docs/plan D-003); all date work goes through core.
+*
+* Like the calendar, the picker keeps its own value; passing `value` through
+* setOptions replaces it (controlled use). Passing back the value the user just
+* typed leaves their text alone, so the cursor does not jump.
+*/
+function createDatePicker(initial = {}) {
+	let options = { ...initial };
+	let calendar = options.calendar ?? options.defaultCalendar ?? "BS";
+	let date = readIso(options.value ?? options.defaultValue);
+	let value = date ? toIsoDate(date) : "";
+	let text = formatInput(date, calendar, formatOf(options), localeOf(options));
+	let error = null;
+	let open = false;
+	let destroyed = false;
+	const panel = createCalendar({
+		...panelOptions(options, calendar),
+		selectionMode: "single",
+		selected: date,
+		onSelect: (selection) => {
+			if (isSingleDay(selection)) pick(selection);
+		}
+	});
+	let snapshot = build();
+	const emitter = createEmitter(() => {
+		snapshot = build();
+	});
+	panel.subscribe(() => {
+		emitter.notify();
+	});
+	function build() {
+		const locale = localeOf(options);
+		return Object.freeze({
+			value,
+			date: detailOf(date),
+			text,
+			calendar,
+			canSwitchCalendar: options.calendar === void 0,
+			open: open || options.inline === true,
+			inline: options.inline === true,
+			error,
+			equivalentText: error ? null : equivalentText(date, calendar, locale),
+			placeholder: placeholderText(calendar, locale),
+			presets: presetStates(),
+			calendarState: panel.getState()
+		});
+	}
+	function presetContext() {
+		return {
+			today: toCalendar(todayOf(options), "AD"),
+			calendar,
+			weekStartsOn: options.weekStartsOn ?? getConfig().weekStartsOn
+		};
+	}
+	/** Each shortcut's date, or null when it cannot be used now. */
+	function resolvedPresets() {
+		const context = presetContext();
+		const limits = inputLimits(options, panel);
+		return (options.presets ?? []).map((preset) => {
+			const entry = describePreset(preset, options.locale, resolveSinglePreset);
+			const date = (() => {
+				try {
+					const candidate = entry.resolve(context);
+					return checkDate(candidate, calendar, limits, localeOf(options)) ? null : candidate;
+				} catch {
+					return null;
+				}
+			})();
+			return {
+				id: entry.id,
+				label: entry.label,
+				date
+			};
+		});
+	}
+	function presetStates() {
+		return resolvedPresets().map(({ id, label, date }) => Object.freeze({
+			id,
+			label,
+			isActive: date !== null && toIsoDate(date) === value,
+			isDisabled: date === null
+		}));
+	}
+	function syncPanel(showDate) {
+		panel.setOptions({
+			...panelOptions(options, calendar),
+			selected: date,
+			...showDate && date ? { visibleMonth: date } : {}
+		});
+	}
+	/** Change the value; queue onChange when it differs and the user caused it. */
+	function setDate(next, byUser) {
+		const nextValue = next ? toIsoDate(next) : "";
+		const changed = nextValue !== value;
+		date = next;
+		value = nextValue;
+		syncPanel(next !== null);
+		if (changed && byUser) {
+			const detail = detailOf(next);
+			emitter.after(() => options.onChange?.(nextValue, detail));
+		}
+	}
+	function format(next) {
+		return formatInput(next, calendar, formatOf(options), localeOf(options));
+	}
+	function pick(selection) {
+		emitter.act(() => {
+			const next = toCalendar(selection, "AD");
+			error = null;
+			text = format(next);
+			setDate(next, true);
+			if (options.closeOnSelect ?? true) open = false;
+		});
+	}
+	const actions = {
+		type(next) {
+			if (destroyed) return;
+			emitter.act(() => {
+				text = options.mask === false ? next : maskDateText(next, text);
+				const result = parseInput(text, calendar, inputLimits(options, panel), localeOf(options), formatOf(options));
+				error = result.kind === "error" ? result.error : null;
+				setDate(result.kind === "date" ? result.date : null, true);
+			});
+		},
+		blur() {
+			emitter.act(() => {
+				if (!error) text = format(date);
+			});
+		},
+		clear() {
+			emitter.act(() => {
+				text = "";
+				error = null;
+				setDate(null, true);
+			});
+		},
+		setValue(next) {
+			emitter.act(() => {
+				applyValue(next);
+			});
+		},
+		open() {
+			emitter.act(() => {
+				open = true;
+				panel.actions.goTo(date ?? todayOf(options));
+			});
+		},
+		close() {
+			emitter.act(() => {
+				open = false;
+			});
+		},
+		toggle() {
+			if (open) actions.close();
+			else actions.open();
+		},
+		switchCalendar(next) {
+			if (options.calendar !== void 0 || next === calendar || destroyed) return;
+			emitter.act(() => {
+				calendar = next;
+				if (!error) text = format(date);
+				syncPanel(date !== null);
+				emitter.after(() => options.onCalendarChange?.(next));
+			});
+		},
+		select(day) {
+			let picked = false;
+			if (!destroyed) emitter.act(() => {
+				picked = panel.actions.select(day);
+			});
+			return picked;
+		},
+		selectToday() {
+			return actions.select(todayOf(options));
+		},
+		reset() {
+			emitter.act(() => {
+				const next = readIso(options.defaultValue);
+				error = null;
+				text = format(next);
+				setDate(next, true);
+			});
+		},
+		applyPreset(id) {
+			const preset = resolvedPresets().find((entry) => entry.id === id);
+			if (destroyed || !preset?.date) return false;
+			pick(preset.date);
+			return true;
+		}
+	};
+	/** An outside value: replaces the text only when it is a different value (echo guard). */
+	function applyValue(next) {
+		const nextDate = readIso(next);
+		if ((nextDate ? toIsoDate(nextDate) : "") === value) return;
+		error = null;
+		text = format(nextDate);
+		setDate(nextDate, false);
+	}
+	return {
+		getState: () => snapshot,
+		subscribe: (listener) => emitter.subscribe(listener),
+		setOptions(changes) {
+			if (destroyed) return;
+			emitter.act(() => {
+				const before = {
+					calendar,
+					locale: localeOf(options),
+					format: formatOf(options)
+				};
+				options = {
+					...options,
+					...changes
+				};
+				if (options.calendar !== void 0) calendar = options.calendar;
+				if ("value" in changes) applyValue(changes.value);
+				if ((before.calendar !== calendar || before.locale !== localeOf(options) || before.format !== formatOf(options)) && !error) text = format(date);
+				syncPanel(false);
+			});
+		},
+		actions,
+		calendar: panel,
+		destroy() {
+			destroyed = true;
+			panel.destroy();
+			emitter.clear();
+		}
+	};
+}
+//#endregion
+//#region src/range.ts
+/**
+* A BS/AD date range picker without UI: two typed fields (start, end), a panel
+* calendar in range mode, minDays/maxDays checks and the BS/AD switch. Values
+* are AD "YYYY-MM-DD" strings; an unfinished or invalid end is "".
+*/
+function createDateRangePicker(initial = {}) {
+	let options = { ...initial };
+	let calendar = options.calendar ?? options.defaultCalendar ?? "BS";
+	let start = readIso(options.value?.start ?? options.defaultValue?.start);
+	let end = readIso(options.value?.end ?? options.defaultValue?.end);
+	[start, end] = ordered(start, end);
+	let value = valueOf(start, end);
+	let startText = format(start);
+	let endText = format(end);
+	let error = null;
+	let open = false;
+	let destroyed = false;
+	const panel = createCalendar({
+		...panelOptions(options, calendar),
+		selectionMode: "range",
+		selected: {
+			start,
+			end
+		},
+		onSelect: (selection) => {
+			if (isRange(selection)) pick(selection.start, selection.end);
+		}
+	});
+	let snapshot = build();
+	const emitter = createEmitter(() => {
+		snapshot = build();
+	});
+	panel.subscribe(() => {
+		emitter.notify();
+	});
+	function format(date) {
+		return formatInput(date, calendar, formatOf(options), localeOf(options));
+	}
+	function build() {
+		const locale = localeOf(options);
+		return Object.freeze({
+			value,
+			date: Object.freeze({
+				start: detailOf(start),
+				end: detailOf(end)
+			}),
+			startText,
+			endText,
+			calendar,
+			canSwitchCalendar: options.calendar === void 0,
+			open: open || options.inline === true,
+			inline: options.inline === true,
+			error,
+			equivalentText: Object.freeze({
+				start: error?.field === "start" ? null : equivalentText(start, calendar, locale),
+				end: error?.field === "end" ? null : equivalentText(end, calendar, locale)
+			}),
+			placeholder: placeholderText(calendar, locale),
+			presets: presetStates(),
+			calendarState: panel.getState()
+		});
+	}
+	function presetContext() {
+		return {
+			today: toCalendar(todayOf(options), "AD"),
+			calendar,
+			weekStartsOn: options.weekStartsOn ?? getConfig().weekStartsOn
+		};
+	}
+	/** Each shortcut's range, or null when it cannot be used now. */
+	function resolvedPresets() {
+		const context = presetContext();
+		const limits = inputLimits(options, panel);
+		const locale = localeOf(options);
+		return (options.presets ?? []).map((preset) => {
+			const entry = describePreset(preset, options.locale, resolveRangePreset);
+			const range = (() => {
+				try {
+					const candidate = entry.resolve(context);
+					const from = toCalendar(candidate.start, "AD");
+					const to = toCalendar(candidate.end, "AD");
+					return compareDates(from, to) <= 0 && !checkDate(from, calendar, limits, locale) && !checkDate(to, calendar, limits, locale) && lengthError(from, to) === null ? candidate : null;
+				} catch {
+					return null;
+				}
+			})();
+			return {
+				id: entry.id,
+				label: entry.label,
+				range
+			};
+		});
+	}
+	function presetStates() {
+		return resolvedPresets().map(({ id, label, range }) => Object.freeze({
+			id,
+			label,
+			isActive: range !== null && toIsoDate(range.start) === value.start && toIsoDate(range.end) === value.end,
+			isDisabled: range === null
+		}));
+	}
+	function syncPanel() {
+		panel.setOptions({
+			...panelOptions(options, calendar),
+			selected: {
+				start,
+				end
+			},
+			...start ? { visibleMonth: start } : {}
+		});
+	}
+	/** Too short or too long, or null. Counts both ends. */
+	function lengthError(from, to) {
+		const days = differenceInDays(to, from) + 1;
+		const messages = getLocale(localeOf(options)).messages;
+		if (options.minDays !== void 0 && days < options.minDays) return {
+			field: "range",
+			code: "tooShort",
+			message: formatMessage(messages.rangeTooShort, { min: String(options.minDays) })
+		};
+		if (options.maxDays !== void 0 && days > options.maxDays) return {
+			field: "range",
+			code: "tooLong",
+			message: formatMessage(messages.rangeTooLong, { max: String(options.maxDays) })
+		};
+		return null;
+	}
+	/** Store the dates, keep the panel in step, and queue onChange when the value moved. */
+	function commit(nextStart, nextEnd, byUser) {
+		start = nextStart;
+		end = nextEnd;
+		const next = valueOf(start, end);
+		const changed = next.start !== value.start || next.end !== value.end;
+		value = next;
+		syncPanel();
+		if (changed && byUser) {
+			const detail = Object.freeze({
+				start: detailOf(start),
+				end: detailOf(end)
+			});
+			emitter.after(() => options.onChange?.(next, detail));
+		}
+	}
+	/** Put the ends in order, check the length, then commit. False when the length is not allowed. */
+	function settle(nextStart, nextEnd) {
+		const [a, b] = ordered(nextStart, nextEnd);
+		if (a !== nextStart) [startText, endText] = [endText, startText];
+		const tooFar = a && b ? lengthError(a, b) : null;
+		error = tooFar ?? error;
+		commit(a, tooFar ? null : b, true);
+		return tooFar === null;
+	}
+	function pick(from, to) {
+		emitter.act(() => {
+			const a = from ? toCalendar(from, "AD") : null;
+			const b = to ? toCalendar(to, "AD") : null;
+			error = null;
+			startText = format(a);
+			endText = format(b);
+			const allowed = settle(a, b);
+			if (b && allowed && (options.closeOnSelect ?? true)) open = false;
+		});
+	}
+	const actions = {
+		type(field, text) {
+			if (destroyed) return;
+			emitter.act(() => {
+				if (options.mask !== false) text = maskDateText(text, field === "start" ? startText : endText);
+				if (field === "start") startText = text;
+				else endText = text;
+				const result = parseInput(text, calendar, inputLimits(options, panel), localeOf(options), formatOf(options));
+				const date = result.kind === "date" ? result.date : null;
+				error = result.kind === "error" ? {
+					...result.error,
+					field
+				} : null;
+				const other = field === "start" ? end : start;
+				const otherError = other ? checkDate(other, calendar, inputLimits(options, panel), localeOf(options)) : null;
+				if (!error && otherError) error = {
+					...otherError,
+					field: field === "start" ? "end" : "start"
+				};
+				if (field === "start") settle(date, end);
+				else settle(start, date);
+			});
+		},
+		blur(field) {
+			emitter.act(() => {
+				if (error?.field === field) return;
+				if (field === "start") startText = format(start);
+				else if (end || error?.field !== "range") endText = format(end);
+			});
+		},
+		clear() {
+			emitter.act(() => {
+				startText = "";
+				endText = "";
+				error = null;
+				commit(null, null, true);
+			});
+		},
+		setValue(next) {
+			emitter.act(() => {
+				applyValue(next);
+			});
+		},
+		open() {
+			emitter.act(() => {
+				open = true;
+				panel.actions.goTo(start ?? todayOf(options));
+			});
+		},
+		close() {
+			emitter.act(() => {
+				open = false;
+			});
+		},
+		toggle() {
+			if (open) actions.close();
+			else actions.open();
+		},
+		switchCalendar(next) {
+			if (options.calendar !== void 0 || next === calendar || destroyed) return;
+			emitter.act(() => {
+				calendar = next;
+				if (!error) {
+					startText = format(start);
+					endText = format(end);
+				}
+				syncPanel();
+				emitter.after(() => options.onCalendarChange?.(next));
+			});
+		},
+		select(day) {
+			let picked = false;
+			if (!destroyed) emitter.act(() => {
+				picked = panel.actions.select(day);
+			});
+			return picked;
+		},
+		applyPreset(id) {
+			const preset = resolvedPresets().find((entry) => entry.id === id);
+			if (destroyed || !preset?.range) return false;
+			pick(preset.range.start, preset.range.end);
+			return true;
+		},
+		reset() {
+			emitter.act(() => {
+				const [a, b] = ordered(readIso(options.defaultValue?.start), readIso(options.defaultValue?.end));
+				error = null;
+				startText = format(a);
+				endText = format(b);
+				commit(a, b, true);
+			});
+		}
+	};
+	/** An outside value: replaces the texts only when the value differs (echo guard). */
+	function applyValue(next) {
+		const [a, b] = ordered(readIso(next?.start), readIso(next?.end));
+		const incoming = valueOf(a, b);
+		if (incoming.start === value.start && incoming.end === value.end) return;
+		error = null;
+		startText = format(a);
+		endText = format(b);
+		commit(a, b, false);
+	}
+	return {
+		getState: () => snapshot,
+		subscribe: (listener) => emitter.subscribe(listener),
+		setOptions(changes) {
+			if (destroyed) return;
+			emitter.act(() => {
+				const before = {
+					calendar,
+					locale: localeOf(options),
+					format: formatOf(options)
+				};
+				options = {
+					...options,
+					...changes
+				};
+				if (options.calendar !== void 0) calendar = options.calendar;
+				if ("value" in changes) applyValue(changes.value);
+				if ((before.calendar !== calendar || before.locale !== localeOf(options) || before.format !== formatOf(options)) && !error) {
+					startText = format(start);
+					endText = format(end);
+				}
+				syncPanel();
+			});
+		},
+		actions,
+		calendar: panel,
+		destroy() {
+			destroyed = true;
+			panel.destroy();
+			emitter.clear();
+		}
+	};
+}
+function ordered(a, b) {
+	return a && b && compareDates(b, a) < 0 ? [b, a] : [a, b];
+}
+function valueOf(start, end) {
+	return Object.freeze({
+		start: start ? toIsoDate(start) : "",
+		end: end ? toIsoDate(end) : ""
+	});
+}
+//#endregion
+//#region src/multi.ts
+const SEPARATOR = /[,\s\u060c]+/;
+/**
+* A picker for several separate days (PICK-001). The value is a sorted list of
+* AD "YYYY-MM-DD" strings; the input lists the days in the calendar on screen,
+* separated by ", ", and clicking a day in the panel adds or removes it. The
+* list is always written as YYYY-MM-DD so it can be typed back.
+*/
+function createMultiDatePicker(initial = {}) {
+	let options = { ...initial };
+	let calendar = options.calendar ?? options.defaultCalendar ?? "BS";
+	let dates = readAll(options.value ?? options.defaultValue);
+	let value = valuesOf(dates);
+	let text = format(dates);
+	let error = null;
+	/** False while the typed text has a problem: then it is left as typed. */
+	let textOk = true;
+	let open = false;
+	let destroyed = false;
+	const panel = createCalendar({
+		...panelOptions(options, calendar),
+		selectionMode: "multiple",
+		selected: dates,
+		onSelect: (selection) => {
+			if (isDayList(selection)) pick(selection.map((day) => toCalendar(day, "AD")));
+		}
+	});
+	let snapshot = build();
+	const emitter = createEmitter(() => {
+		snapshot = build();
+	});
+	panel.subscribe(() => {
+		emitter.notify();
+	});
+	function build() {
+		return Object.freeze({
+			value,
+			dates: detailsOf(dates),
+			text,
+			calendar,
+			canSwitchCalendar: options.calendar === void 0,
+			open: open || options.inline === true,
+			inline: options.inline === true,
+			error,
+			placeholder: placeholderText(calendar, localeOf(options)),
+			calendarState: panel.getState()
+		});
+	}
+	function format(list) {
+		return list.map((day) => formatInput(day, calendar, "iso", localeOf(options))).join(", ");
+	}
+	function tooMany(count) {
+		const max = options.maxDates;
+		return max !== void 0 && count > max ? {
+			code: "tooMany",
+			message: formatMessage(getLocale(localeOf(options)).messages.tooManyDates, { max: String(max) })
+		} : null;
+	}
+	function syncPanel() {
+		panel.setOptions({
+			...panelOptions(options, calendar),
+			selected: dates
+		});
+	}
+	/** Change the value; queue onChange when it differs and the user caused it. */
+	function setDates(next, byUser) {
+		const sorted = unique(next);
+		const nextValue = valuesOf(sorted);
+		const changed = nextValue.join() !== value.join();
+		dates = sorted;
+		value = nextValue;
+		syncPanel();
+		if (changed && byUser) {
+			const details = detailsOf(sorted);
+			emitter.after(() => options.onChange?.(nextValue, details));
+		}
+	}
+	function pick(next) {
+		emitter.act(() => {
+			error = tooMany(next.length);
+			if (error) {
+				syncPanel();
+				return;
+			}
+			text = format(unique(next));
+			textOk = true;
+			setDates(next, true);
+			if (options.closeOnSelect === true) open = false;
+		});
+	}
+	const actions = {
+		type(next) {
+			if (destroyed) return;
+			emitter.act(() => {
+				text = options.mask === false ? next : maskLast(next, text);
+				const limits = inputLimits(options, panel);
+				const parsed = [];
+				let firstError = null;
+				for (const token of text.split(SEPARATOR)) {
+					const result = parseInput(token, calendar, limits, localeOf(options));
+					if (result.kind === "date") parsed.push(result.date);
+					else if (result.kind === "error") firstError ?? (firstError = result.error);
+				}
+				error = firstError ?? tooMany(unique(parsed).length);
+				textOk = error === null;
+				setDates(parsed, true);
+			});
+		},
+		blur() {
+			emitter.act(() => {
+				if (textOk) text = format(dates);
+			});
+		},
+		clear() {
+			emitter.act(() => {
+				text = "";
+				error = null;
+				textOk = true;
+				setDates([], true);
+			});
+		},
+		setValue(next) {
+			emitter.act(() => {
+				applyValue(next);
+			});
+		},
+		open() {
+			emitter.act(() => {
+				open = true;
+				const first = dates[0];
+				if (first) panel.actions.goTo(first);
+			});
+		},
+		close() {
+			emitter.act(() => {
+				open = false;
+			});
+		},
+		toggle() {
+			if (open) actions.close();
+			else actions.open();
+		},
+		switchCalendar(next) {
+			if (options.calendar !== void 0 || next === calendar || destroyed) return;
+			emitter.act(() => {
+				calendar = next;
+				if (textOk) text = format(dates);
+				syncPanel();
+				emitter.after(() => options.onCalendarChange?.(next));
+			});
+		},
+		select(day) {
+			if (destroyed) return false;
+			const before = value;
+			emitter.act(() => {
+				panel.actions.select(day);
+			});
+			return value !== before;
+		},
+		remove(iso) {
+			emitter.act(() => {
+				error = null;
+				const next = dates.filter((day) => toIsoDate(day) !== iso);
+				text = format(next);
+				textOk = true;
+				setDates(next, true);
+			});
+		},
+		reset() {
+			emitter.act(() => {
+				const next = readAll(options.defaultValue);
+				error = null;
+				text = format(next);
+				textOk = true;
+				setDates(next, true);
+			});
+		}
+	};
+	/** An outside value: replaces the text only when it is a different value (echo guard). */
+	function applyValue(next) {
+		const nextDates = readAll(next);
+		if (valuesOf(nextDates).join() === value.join()) return;
+		error = null;
+		text = format(nextDates);
+		textOk = true;
+		setDates(nextDates, false);
+	}
+	return {
+		getState: () => snapshot,
+		subscribe: (listener) => emitter.subscribe(listener),
+		setOptions(changes) {
+			if (destroyed) return;
+			emitter.act(() => {
+				const before = {
+					calendar,
+					locale: localeOf(options)
+				};
+				options = {
+					...options,
+					...changes
+				};
+				if (options.calendar !== void 0) calendar = options.calendar;
+				if ("value" in changes) applyValue(changes.value);
+				if ((before.calendar !== calendar || before.locale !== localeOf(options)) && textOk) text = format(dates);
+				syncPanel();
+			});
+		},
+		actions,
+		calendar: panel,
+		destroy() {
+			destroyed = true;
+			panel.destroy();
+			emitter.clear();
+		}
+	};
+}
+function readAll(values) {
+	return unique((values ?? []).map(readIso).filter((day) => day !== null));
+}
+function unique(list) {
+	return [...new Map(list.map((day) => [toIsoDate(day), day])).entries()].sort(([a], [b]) => a < b ? -1 : 1).map(([, day]) => day);
+}
+function valuesOf(list) {
+	return Object.freeze(list.map((day) => toIsoDate(day)));
+}
+function detailsOf(list) {
+	return Object.freeze(list.map((day) => Object.freeze({
+		ad: day,
+		bs: toCalendar(day, "BS")
+	})));
+}
+/** Mask only the day being typed: the text after the last separator. */
+function maskLast(next, previous) {
+	if (!next.startsWith(previous)) return next;
+	const match = /^(.*[,\s\u060c])?([^,\s\u060c]*)$/.exec(next);
+	const head = match?.[1] ?? "";
+	return head + maskDateText(match?.[2] ?? next, previous.length > head.length ? previous.slice(head.length) : "");
+}
+//#endregion
+//#region src/datetime.ts
+/**
+* A BS/AD date and time picker without UI. The date half is a regular date
+* picker; the value is the instant as an ISO timestamp carrying the zone's
+* offset, so servers store one unambiguous moment.
+*/
+function createDateTimePicker(initial = {}) {
+	let options = { ...initial };
+	const start = fromIsoDateTime(options.value ?? options.defaultValue, zone());
+	let time = start?.time ?? null;
+	let timeText = time ? fmt(time) : "";
+	let timeError = null;
+	let value = "";
+	let destroyed = false;
+	const datePicker = createDatePicker({
+		...dateOptions(),
+		defaultValue: start ? toIsoDay(start.date) : "",
+		closeOnSelect: false,
+		onChange: () => {
+			emitter.act(() => {
+				if (datePicker.getState().date && !time) {
+					time = parseTime(options.defaultTime) ?? Object.freeze({
+						hour: 0,
+						minute: 0
+					});
+					timeText = fmt(time);
+					timeError = null;
+				}
+				commit(true);
+			});
+		}
+	});
+	value = compose();
+	let snapshot = build();
+	const emitter = createEmitter(() => {
+		snapshot = build();
+	});
+	datePicker.subscribe(() => {
+		emitter.notify();
+	});
+	function zone() {
+		return options.timeZone ?? getConfig().timeZone;
+	}
+	function fmt(t) {
+		return formatTime(t, {
+			hour12: options.hour12 ?? false,
+			locale: localeOf(options)
+		});
+	}
+	function dateOptions() {
+		const { value: _value, defaultValue: _default, onChange: _onChange, timeZone: _zone, hour12: _hour12, minuteStep: _step, defaultTime: _defaultTime, ...rest } = options;
+		return rest;
+	}
+	function compose() {
+		const day = datePicker.getState().date;
+		return day && time ? toIsoDateTime(day.ad, time, zone()) : "";
+	}
+	function detail() {
+		const day = datePicker.getState().date;
+		return day && time && value ? Object.freeze({
+			ad: day.ad,
+			bs: day.bs,
+			time,
+			iso: value
+		}) : null;
+	}
+	/** Recompute the value; queue onChange when it changed and the user caused it. */
+	function commit(byUser) {
+		const next = compose();
+		if (next === value) return;
+		value = next;
+		if (byUser) {
+			const info = detail();
+			emitter.after(() => options.onChange?.(next, info));
+		}
+	}
+	function build() {
+		const inner = datePicker.getState();
+		const locale = localeOf(options);
+		const step = Math.min(30, Math.max(1, Math.floor(options.minuteStep ?? 5)));
+		const { am, pm } = getLocale(locale).time;
+		const hour12 = options.hour12 ?? false;
+		return Object.freeze({
+			value,
+			detail: detail(),
+			dateText: inner.text,
+			timeText,
+			time,
+			calendar: inner.calendar,
+			canSwitchCalendar: inner.canSwitchCalendar,
+			open: inner.open,
+			inline: inner.inline,
+			error: inner.error ? {
+				...inner.error,
+				field: "date"
+			} : timeError ? {
+				...timeError,
+				field: "time"
+			} : null,
+			equivalentText: inner.equivalentText,
+			placeholder: inner.placeholder,
+			timePlaceholder: hour12 ? `h:mm ${am}` : "HH:MM",
+			hours: Array.from({ length: 24 }, (_, hour) => Object.freeze({
+				value: hour,
+				label: hour12 ? `${formatNumber(hour % 12 === 0 ? 12 : hour % 12, locale)} ${hour < 12 ? am : pm}` : formatNumber(String(hour).padStart(2, "0"), locale),
+				isSelected: time?.hour === hour
+			})),
+			minutes: Array.from({ length: Math.ceil(60 / step) }, (_, index) => Object.freeze({
+				value: index * step,
+				label: formatNumber(String(index * step).padStart(2, "0"), locale),
+				isSelected: time?.minute === index * step
+			})),
+			presets: inner.presets,
+			calendarState: inner.calendarState
+		});
+	}
+	function setTime(next, text, byUser) {
+		time = next;
+		timeText = text;
+		timeError = null;
+		commit(byUser);
+	}
+	const actions = {
+		typeDate(text) {
+			datePicker.actions.type(text);
+		},
+		blurDate() {
+			datePicker.actions.blur();
+		},
+		typeTime(text) {
+			if (destroyed) return;
+			emitter.act(() => {
+				const parsed = parseTime(text);
+				if (text.trim() === "" || parsed) setTime(parsed, text, true);
+				else {
+					time = null;
+					timeText = text;
+					timeError = {
+						code: "format",
+						message: getLocale(localeOf(options)).messages.invalidTime
+					};
+					commit(true);
+				}
+			});
+		},
+		blurTime() {
+			emitter.act(() => {
+				if (!timeError && time) timeText = fmt(time);
+			});
+		},
+		selectDate(date) {
+			return !destroyed && datePicker.actions.select(date);
+		},
+		selectHour(hour) {
+			emitter.act(() => {
+				const next = Object.freeze({
+					hour,
+					minute: time?.minute ?? 0
+				});
+				setTime(next, fmt(next), true);
+			});
+		},
+		selectMinute(minute) {
+			emitter.act(() => {
+				const next = Object.freeze({
+					hour: time?.hour ?? 0,
+					minute
+				});
+				setTime(next, fmt(next), true);
+			});
+		},
+		selectNow() {
+			if (destroyed) return false;
+			const current = now(zone());
+			let picked = false;
+			emitter.act(() => {
+				time = current.time;
+				timeText = fmt(current.time);
+				timeError = null;
+				picked = datePicker.actions.select(current.date);
+				commit(true);
+			});
+			return picked;
+		},
+		applyPreset(id) {
+			return !destroyed && datePicker.actions.applyPreset(id);
+		},
+		open() {
+			datePicker.actions.open();
+		},
+		close() {
+			datePicker.actions.close();
+		},
+		toggle() {
+			datePicker.actions.toggle();
+		},
+		clear() {
+			emitter.act(() => {
+				datePicker.actions.setValue("");
+				setTime(null, "", true);
+			});
+		},
+		setValue(next) {
+			emitter.act(() => {
+				applyValue(next);
+			});
+		},
+		switchCalendar(calendar) {
+			datePicker.actions.switchCalendar(calendar);
+		},
+		reset() {
+			emitter.act(() => {
+				const start = fromIsoDateTime(options.defaultValue, zone());
+				datePicker.actions.setValue(start ? toIsoDay(start.date) : "");
+				setTime(start?.time ?? null, start ? fmt(start.time) : "", true);
+			});
+		}
+	};
+	/** An outside value; ignored when it is the instant already shown (echo guard). */
+	function applyValue(next) {
+		const parsed = fromIsoDateTime(next, zone());
+		if ((parsed ? toIsoDateTime(parsed.date, parsed.time, zone()) : "") === value) return;
+		datePicker.actions.setValue(parsed ? toIsoDay(parsed.date) : "");
+		time = parsed?.time ?? null;
+		timeText = time ? fmt(time) : "";
+		timeError = null;
+		commit(false);
+	}
+	return {
+		getState: () => snapshot,
+		subscribe: (listener) => emitter.subscribe(listener),
+		setOptions(changes) {
+			if (destroyed) return;
+			emitter.act(() => {
+				options = {
+					...options,
+					...changes
+				};
+				datePicker.setOptions(dateOptions());
+				if ("value" in changes) applyValue(changes.value);
+				if (time && !timeError) timeText = fmt(time);
+				commit(false);
+			});
+		},
+		actions,
+		calendar: datePicker.calendar,
+		destroy() {
+			destroyed = true;
+			datePicker.destroy();
+			emitter.clear();
+		}
+	};
+}
+function toIsoDay(date) {
+	return toIsoDate(date);
+}
+//#endregion
+export { checkDate, createDatePicker, createDateRangePicker, createDateTimePicker, createMultiDatePicker, equivalentText, formatInput, maskDateText, parseInput, placeholderText, resolveRangePreset, resolveSinglePreset };
+
+//# sourceMappingURL=index.js.map