@nepdatejs/core 0.0.0-bootstrap → 0.1.0

package/dist/index.js

@@ -0,0 +1,1241 @@
+import { t as BS_DATA } from "./years-CabTFbN9.js";
+//#region src/errors.ts
+/** Thrown for any invalid date or argument. Check `code`, not the message. */
+var NepDateRangeError = class extends RangeError {
+	constructor(code, message) {
+		super(message);
+		this.name = "NepDateRangeError";
+		this.code = code;
+	}
+};
+/** Thrown when a BS table passed to `setBsData` or `patchBsYear` is not valid. */
+var NepDateDataError = class extends Error {
+	constructor(code, message, year, month) {
+		super(message);
+		this.name = "NepDateDataError";
+		this.code = code;
+		this.year = year;
+		this.month = month;
+	}
+};
+//#endregion
+//#region src/epoch.ts
+/** Brand a whole number of days since 1970-01-01 as an `EpochDay`. */
+function toEpochDay(value) {
+	if (!Number.isSafeInteger(value)) throw new NepDateRangeError("INVALID_ARGUMENT", `${String(value)} is not a whole number of days.`);
+	return value;
+}
+/** The weekday of a day count. 1970-01-01 was a Thursday. */
+function weekdayOf(epoch) {
+	return ((epoch + 4) % 7 + 7) % 7;
+}
+//#endregion
+//#region src/locale/en.ts
+const bsMonths$1 = [
+	"Baisakh",
+	"Jestha",
+	"Asar",
+	"Shrawan",
+	"Bhadra",
+	"Ashwin",
+	"Kartik",
+	"Mangsir",
+	"Poush",
+	"Magh",
+	"Falgun",
+	"Chaitra"
+];
+const adMonths$1 = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+const en = {
+	digits: [
+		"0",
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9"
+	],
+	weekdays: {
+		long: [
+			"Sunday",
+			"Monday",
+			"Tuesday",
+			"Wednesday",
+			"Thursday",
+			"Friday",
+			"Saturday"
+		],
+		short: [
+			"Sun",
+			"Mon",
+			"Tue",
+			"Wed",
+			"Thu",
+			"Fri",
+			"Sat"
+		],
+		narrow: [
+			"Su",
+			"Mo",
+			"Tu",
+			"We",
+			"Th",
+			"Fr",
+			"Sa"
+		]
+	},
+	months: {
+		AD: {
+			long: adMonths$1,
+			short: adMonths$1.map((name) => name.slice(0, 3))
+		},
+		BS: {
+			long: bsMonths$1,
+			short: bsMonths$1.map((name) => name.slice(0, 3))
+		}
+	},
+	calendarNames: {
+		AD: "AD",
+		BS: "BS"
+	},
+	labels: {
+		today: "Today",
+		clear: "Clear date",
+		previousMonth: "Previous month",
+		nextMonth: "Next month",
+		previousYear: "Previous year",
+		nextYear: "Next year",
+		month: "Month",
+		year: "Year",
+		openCalendar: "Open calendar",
+		chooseDate: "Choose a date",
+		calendar: "Calendar",
+		presets: "Shortcuts",
+		fiscalYear: "Fiscal year",
+		time: "Time",
+		hour: "Hour",
+		minute: "Minute",
+		now: "Now",
+		done: "Done"
+	},
+	time: {
+		am: "AM",
+		pm: "PM"
+	},
+	presets: {
+		today: "Today",
+		yesterday: "Yesterday",
+		tomorrow: "Tomorrow",
+		thisWeek: "This week",
+		lastWeek: "Last week",
+		last7Days: "Last 7 days",
+		last30Days: "Last 30 days",
+		thisMonth: "This month",
+		lastMonth: "Last month",
+		thisYear: "This year",
+		thisFiscalYear: "This fiscal year",
+		lastFiscalYear: "Last fiscal year"
+	},
+	messages: {
+		invalidFormat: {
+			AD: "Enter an AD date as YYYY-MM-DD.",
+			BS: "Enter a BS date as YYYY-MM-DD."
+		},
+		outOfRange: "Choose a date from {min} to {max}.",
+		onOrAfter: "Choose {min} or later.",
+		onOrBefore: "Choose {max} or earlier.",
+		unavailable: "This date is not available.",
+		rangeTooShort: "Choose at least {min} days.",
+		rangeTooLong: "Choose at most {max} days.",
+		tooManyDates: "Choose at most {max} dates.",
+		invalidTime: "Enter a time as HH:MM."
+	}
+};
+//#endregion
+//#region src/locale/ne.ts
+const bsMonths = [
+	"बैशाख",
+	"जेठ",
+	"असार",
+	"साउन",
+	"भदौ",
+	"असोज",
+	"कार्तिक",
+	"मङ्सिर",
+	"पुस",
+	"माघ",
+	"फाल्गुण",
+	"चैत"
+];
+const adMonths = [
+	"जनवरी",
+	"फेब्रुअरी",
+	"मार्च",
+	"अप्रिल",
+	"मे",
+	"जुन",
+	"जुलाई",
+	"अगस्ट",
+	"सेप्टेम्बर",
+	"अक्टोबर",
+	"नोभेम्बर",
+	"डिसेम्बर"
+];
+//#endregion
+//#region src/locale/registry.ts
+const locales = /* @__PURE__ */ new Map([["en", en], ["ne", {
+	digits: [
+		"०",
+		"१",
+		"२",
+		"३",
+		"४",
+		"५",
+		"६",
+		"७",
+		"८",
+		"९"
+	],
+	weekdays: {
+		long: [
+			"आइतबार",
+			"सोमबार",
+			"मङ्गलबार",
+			"बुधबार",
+			"बिहिबार",
+			"शुक्रबार",
+			"शनिबार"
+		],
+		short: [
+			"आइत",
+			"सोम",
+			"मङ्गल",
+			"बुध",
+			"बिही",
+			"शुक्र",
+			"शनि"
+		],
+		narrow: [
+			"आ",
+			"सो",
+			"मं",
+			"बु",
+			"बि",
+			"शु",
+			"श"
+		]
+	},
+	months: {
+		AD: {
+			long: adMonths,
+			short: adMonths
+		},
+		BS: {
+			long: bsMonths,
+			short: bsMonths
+		}
+	},
+	calendarNames: {
+		AD: "ई.सं.",
+		BS: "वि.सं."
+	},
+	labels: {
+		today: "आज",
+		clear: "मिति हटाउनुहोस्",
+		previousMonth: "अघिल्लो महिना",
+		nextMonth: "अर्को महिना",
+		previousYear: "अघिल्लो वर्ष",
+		nextYear: "अर्को वर्ष",
+		month: "महिना",
+		year: "वर्ष",
+		openCalendar: "पात्रो खोल्नुहोस्",
+		chooseDate: "मिति छान्नुहोस्",
+		calendar: "पात्रो",
+		presets: "छिटो छनोट",
+		fiscalYear: "आर्थिक वर्ष",
+		time: "समय",
+		hour: "घण्टा",
+		minute: "मिनेट",
+		now: "अहिले",
+		done: "भयो"
+	},
+	time: {
+		am: "पूर्वाह्न",
+		pm: "अपराह्न"
+	},
+	presets: {
+		today: "आज",
+		yesterday: "हिजो",
+		tomorrow: "भोलि",
+		thisWeek: "यो हप्ता",
+		lastWeek: "गत हप्ता",
+		last7Days: "पछिल्लो ७ दिन",
+		last30Days: "पछिल्लो ३० दिन",
+		thisMonth: "यो महिना",
+		lastMonth: "गत महिना",
+		thisYear: "यो वर्ष",
+		thisFiscalYear: "यो आर्थिक वर्ष",
+		lastFiscalYear: "गत आर्थिक वर्ष"
+	},
+	messages: {
+		invalidFormat: {
+			AD: "ई.सं. मिति YYYY-MM-DD ढाँचामा लेख्नुहोस्।",
+			BS: "वि.सं. मिति YYYY-MM-DD ढाँचामा लेख्नुहोस्।"
+		},
+		outOfRange: "{min} देखि {max} सम्मको मिति छान्नुहोस्।",
+		onOrAfter: "{min} वा त्यसपछिको मिति छान्नुहोस्।",
+		onOrBefore: "{max} वा त्यसअघिको मिति छान्नुहोस्।",
+		unavailable: "यो मिति उपलब्ध छैन।",
+		rangeTooShort: "कम्तीमा {min} दिन छान्नुहोस्।",
+		rangeTooLong: "बढीमा {max} दिन छान्नुहोस्।",
+		tooManyDates: "बढीमा {max} मिति छान्नुहोस्।",
+		invalidTime: "समय HH:MM ढाँचामा लेख्नुहोस्।"
+	}
+}]]);
+/** Add or replace a language. Lists must have the right lengths (10 digits, 7 weekdays, 12 months). */
+function registerLocale(code, data) {
+	const checks = [
+		[
+			"digits",
+			data.digits,
+			10
+		],
+		[
+			"weekdays.long",
+			data.weekdays.long,
+			7
+		],
+		[
+			"weekdays.short",
+			data.weekdays.short,
+			7
+		],
+		[
+			"weekdays.narrow",
+			data.weekdays.narrow,
+			7
+		],
+		[
+			"months.AD.long",
+			data.months.AD.long,
+			12
+		],
+		[
+			"months.AD.short",
+			data.months.AD.short,
+			12
+		],
+		[
+			"months.BS.long",
+			data.months.BS.long,
+			12
+		],
+		[
+			"months.BS.short",
+			data.months.BS.short,
+			12
+		]
+	];
+	for (const [name, list, length] of checks) if (list.length !== length) throw new NepDateRangeError("INVALID_ARGUMENT", `Locale "${code}": ${name} must have ${length} entries, not ${list.length}.`);
+	locales.set(code, data);
+}
+function hasLocale(code) {
+	return locales.has(code);
+}
+/** The data for a locale, or English when the locale is not registered. */
+function localeData(code) {
+	return locales.get(code) ?? en;
+}
+//#endregion
+//#region src/config.ts
+const DEFAULTS = Object.freeze({
+	timeZone: "Asia/Kathmandu",
+	weekStartsOn: 0,
+	weekendDays: Object.freeze([6]),
+	defaultLocale: "en"
+});
+let current = DEFAULTS;
+/** Change one or more settings. Every value is checked before any is applied. */
+function configure(changes) {
+	const next = {
+		...current,
+		...changes
+	};
+	if (!isTimeZone(next.timeZone)) throw new NepDateRangeError("INVALID_ARGUMENT", `"${next.timeZone}" is not a time zone.`);
+	if (!isWeekday(next.weekStartsOn)) throw new NepDateRangeError("INVALID_ARGUMENT", `weekStartsOn must be 0–6, not ${String(next.weekStartsOn)}.`);
+	if (!next.weekendDays.every(isWeekday) || new Set(next.weekendDays).size !== next.weekendDays.length) throw new NepDateRangeError("INVALID_ARGUMENT", "weekendDays must be different weekdays, each 0–6.");
+	if (!hasLocale(next.defaultLocale)) throw new NepDateRangeError("INVALID_ARGUMENT", `Locale "${next.defaultLocale}" is not registered.`);
+	current = Object.freeze({
+		...next,
+		weekendDays: Object.freeze([...next.weekendDays])
+	});
+}
+function getConfig() {
+	return current;
+}
+/** Back to the defaults (Kathmandu, Sunday first, Saturday weekend, English). */
+function resetConfig() {
+	current = DEFAULTS;
+}
+function isWeekday(value) {
+	return Number.isInteger(value) && value >= 0 && value <= 6;
+}
+function isTimeZone(value) {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: value });
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/ad/calendar.ts
+/**
+* The Gregorian (AD) calendar, by arithmetic only: no table, no BS knowledge,
+* no `Date`. Works for any year in ±MAX_AD_YEAR (docs/plan D-001).
+*
+* The day-count algorithms are Howard Hinnant's days_from_civil and
+* civil_from_days (proleptic Gregorian, March-based years).
+*/
+/** AD years must lie within ±this value. */
+const MAX_AD_YEAR = 999999;
+const DAYS_BEFORE_EPOCH = 719468;
+const DAYS_PER_ERA = 146097;
+const MONTH_DAYS = [
+	31,
+	28,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
+function isAdLeapYear(year) {
+	return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+/** Days in an AD month. The month must be 1–12. */
+function adMonthLength(year, month) {
+	return month === 2 && isAdLeapYear(year) ? 29 : MONTH_DAYS[month - 1] ?? 0;
+}
+function isValidAdDate(year, month, day) {
+	return Number.isInteger(year) && Number.isInteger(month) && Number.isInteger(day) && Math.abs(year) <= 999999 && month >= 1 && month <= 12 && day >= 1 && day <= adMonthLength(year, month);
+}
+/** Days since 1970-01-01 of a valid AD date. */
+function adToEpoch(year, month, day) {
+	const y = month <= 2 ? year - 1 : year;
+	const era = Math.floor(y / 400);
+	const yearOfEra = y - era * 400;
+	const dayOfYear = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;
+	const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;
+	return era * DAYS_PER_ERA + dayOfEra - DAYS_BEFORE_EPOCH;
+}
+/** The AD year, month and day of a day count. */
+function epochToAd(epoch) {
+	const z = epoch + DAYS_BEFORE_EPOCH;
+	const era = Math.floor(z / DAYS_PER_ERA);
+	const dayOfEra = z - era * DAYS_PER_ERA;
+	const yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36524) - Math.floor(dayOfEra / 146096)) / 365);
+	const dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));
+	const shiftedMonth = Math.floor((5 * dayOfYear + 2) / 153);
+	const day = dayOfYear - Math.floor((153 * shiftedMonth + 2) / 5) + 1;
+	const month = shiftedMonth < 10 ? shiftedMonth + 3 : shiftedMonth - 9;
+	return {
+		year: yearOfEra + era * 400 + (month <= 2 ? 1 : 0),
+		month,
+		day
+	};
+}
+//#endregion
+//#region src/bs/table.ts
+/**
+* The Bikram Sambat calendar, from its table only. Nothing here reads or
+* produces an AD year: BS dates map to and from day counts (EpochDay) through
+* `epochStart` and the month lengths (docs/plan D-001).
+*/
+let data = freezeData(BS_DATA);
+let table = null;
+/** Replace the data the table is built from. Callers validate first (data-api.ts). */
+function useBsData(next) {
+	data = freezeData(next);
+	table = null;
+}
+function freezeData(source) {
+	return Object.freeze({
+		firstYear: source.firstYear,
+		epochStart: source.epochStart,
+		verifiedThrough: source.verifiedThrough,
+		years: Object.freeze(source.years.map((months) => Object.freeze([...months])))
+	});
+}
+function currentBsData() {
+	return data;
+}
+function buildTable() {
+	const count = data.years.length;
+	const yearStart = new Float64Array(count + 1);
+	const monthOffset = new Uint16Array(count * 12);
+	let start = data.epochStart;
+	for (let i = 0; i < count; i++) {
+		yearStart[i] = start;
+		const months = data.years[i] ?? [];
+		let offset = 0;
+		for (let m = 0; m < 12; m++) {
+			monthOffset[i * 12 + m] = offset;
+			offset += months[m] ?? 0;
+		}
+		start += offset;
+	}
+	yearStart[count] = start;
+	return {
+		data,
+		lastYear: data.firstYear + count - 1,
+		yearStart,
+		monthOffset
+	};
+}
+function bsTable() {
+	return table ?? (table = buildTable());
+}
+function bsFirstYear() {
+	return data.firstYear;
+}
+function bsLastYear() {
+	return bsTable().lastYear;
+}
+/** The first and last day counts the table covers. */
+function bsEpochRange() {
+	const { yearStart } = bsTable();
+	return {
+		first: yearStart[0] ?? 0,
+		last: (yearStart[yearStart.length - 1] ?? 0) - 1
+	};
+}
+/** Days in a BS month. Throws when the year is outside the table or the month is not 1–12. */
+function bsMonthLength(year, month) {
+	const { lastYear } = bsTable();
+	if (!Number.isInteger(year) || year < data.firstYear || year > lastYear) throw new NepDateRangeError("OUT_OF_TABLE", `BS year ${String(year)} is outside the supported range (BS ${data.firstYear}–${lastYear}).`);
+	if (!Number.isInteger(month) || month < 1 || month > 12) throw new NepDateRangeError("INVALID_DATE", `BS month ${String(month)} does not exist.`);
+	return data.years[year - data.firstYear]?.[month - 1] ?? 0;
+}
+function isValidBsDate(year, month, day) {
+	try {
+		return Number.isInteger(day) && day >= 1 && day <= bsMonthLength(year, month);
+	} catch {
+		return false;
+	}
+}
+/** Day count of a valid BS date. */
+function bsToEpoch(year, month, day) {
+	const { yearStart, monthOffset } = bsTable();
+	const index = year - data.firstYear;
+	return (yearStart[index] ?? 0) + (monthOffset[index * 12 + month - 1] ?? 0) + day - 1;
+}
+/** The BS year, month and day of a day count. Throws when it is outside the table. */
+function epochToBs(epoch) {
+	const { yearStart, monthOffset } = bsTable();
+	const { first, last } = bsEpochRange();
+	if (epoch < first || epoch > last) throw new NepDateRangeError("OUT_OF_TABLE", `Day ${epoch} is outside the BS table (BS ${data.firstYear}–${bsLastYear()}).`);
+	let low = 0;
+	let high = yearStart.length - 2;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if ((yearStart[middle] ?? 0) <= epoch) low = middle;
+		else high = middle - 1;
+	}
+	const dayOfYear = epoch - (yearStart[low] ?? 0);
+	let month = 11;
+	while (month > 0 && (monthOffset[low * 12 + month] ?? 0) > dayOfYear) month--;
+	return {
+		year: data.firstYear + low,
+		month: month + 1,
+		day: dayOfYear - (monthOffset[low * 12 + month] ?? 0) + 1
+	};
+}
+/** Whether a BS year is after the last year checked against a published calendar. */
+function isProjectedBsYear(year) {
+	return year > data.verifiedThrough;
+}
+//#endregion
+//#region src/bs/data-api.ts
+/** The first BS month of Nepal's fiscal year: Shrawan. */
+const BS_FISCAL_YEAR_START_MONTH = 4;
+/** Days a verified year may have. Projected years may be off by one (the bundled BS 2096 lists 364). */
+const VERIFIED_YEAR_DAYS = [365, 366];
+const PROJECTED_YEAR_DAYS = [
+	364,
+	365,
+	366,
+	367
+];
+/** Throws NepDateDataError when the table is not usable. Same rules as scripts/gen-data.ts. */
+function validateBsData(table) {
+	if (!Number.isSafeInteger(table.epochStart) || !Number.isInteger(table.firstYear)) throw new NepDateDataError("BAD_ANCHOR", "firstYear and epochStart must be whole numbers.");
+	if (!Number.isInteger(table.verifiedThrough)) throw new NepDateDataError("BAD_ANCHOR", "verifiedThrough must be a whole number.");
+	if (table.years.length === 0) throw new NepDateDataError("EMPTY", "The BS table has no years.");
+	table.years.forEach((months, index) => {
+		const year = table.firstYear + index;
+		if (months.length !== 12) throw new NepDateDataError("BAD_MONTH_COUNT", `BS ${year} lists ${months.length} months, not 12.`, year);
+		let total = 0;
+		months.forEach((days, m) => {
+			if (!Number.isInteger(days) || days < 29 || days > 32) throw new NepDateDataError("BAD_MONTH", `BS ${year} month ${m + 1} has ${String(days)} days; expected 29–32.`, year, m + 1);
+			total += days;
+		});
+		const allowed = year <= table.verifiedThrough ? VERIFIED_YEAR_DAYS : PROJECTED_YEAR_DAYS;
+		if (!allowed.includes(total)) throw new NepDateDataError("BAD_YEAR_TOTAL", `BS ${year} has ${total} days; expected ${allowed.join(" or ")}.`, year);
+	});
+}
+/** The BS table in use (frozen). */
+function getBsData() {
+	return currentBsData();
+}
+/** Replace the whole BS table. Only BS results change; AD functions are unaffected. */
+function setBsData(table) {
+	validateBsData(table);
+	useBsData(table);
+}
+/**
+* Correct one year's month lengths, or add the year just before the first or
+* just after the last. Years after a corrected year move with it; earlier years
+* never move (adding a year before the first keeps every existing year in place).
+*/
+function patchBsYear(year, months) {
+	const table = currentBsData();
+	const lastYear = table.firstYear + table.years.length - 1;
+	let next;
+	if (year >= table.firstYear && year <= lastYear) next = {
+		...table,
+		years: table.years.map((row, index) => index === year - table.firstYear ? months : row)
+	};
+	else if (year === lastYear + 1) next = {
+		...table,
+		years: [...table.years, months]
+	};
+	else if (year === table.firstYear - 1) {
+		const length = months.reduce((total, days) => total + days, 0);
+		next = {
+			...table,
+			firstYear: year,
+			epochStart: table.epochStart - length,
+			years: [months, ...table.years]
+		};
+	} else throw new NepDateRangeError("OUT_OF_TABLE", `BS ${String(year)} is not in the table and does not extend it (BS ${table.firstYear}–${lastYear}).`);
+	setBsData(next);
+}
+/** Back to the table bundled with the package. */
+function resetBsData() {
+	useBsData(BS_DATA);
+}
+//#endregion
+//#region src/create.ts
+/** An AD date. Any year within ±999,999 is allowed; only conversion to BS is limited. */
+function adDate(year, month, day) {
+	if (!isValidAdDate(year, month, day)) throw new NepDateRangeError(Number.isInteger(year) && Number.isInteger(month) && Number.isInteger(day) ? "INVALID_DATE" : "INVALID_ARGUMENT", Math.abs(year) > 999999 ? `AD year ${String(year)} is outside ±${MAX_AD_YEAR}.` : `AD ${String(year)}-${String(month)}-${String(day)} is not a valid date.`);
+	return Object.freeze({
+		calendar: "AD",
+		year,
+		month,
+		day
+	});
+}
+/** A BS date. The year must be in the BS table. */
+function bsDate(year, month, day) {
+	const length = bsMonthLength(year, month);
+	if (!Number.isInteger(day) || day < 1 || day > length) throw new NepDateRangeError(Number.isInteger(day) ? "INVALID_DATE" : "INVALID_ARGUMENT", `BS ${year}-${month} has ${length} days, not ${String(day)}.`);
+	return Object.freeze({
+		calendar: "BS",
+		year,
+		month,
+		day
+	});
+}
+function createDate(calendar, year, month, day) {
+	return calendar === "AD" ? adDate(year, month, day) : bsDate(year, month, day);
+}
+function isValidDate(calendar, year, month, day) {
+	return calendar === "AD" ? isValidAdDate(year, month, day) : isValidBsDate(year, month, day);
+}
+/** Days in a month of either calendar. */
+function daysInMonth(calendar, year, month) {
+	if (calendar === "BS") return bsMonthLength(year, month);
+	if (!isValidAdDate(year, month, 1)) throw new NepDateRangeError("INVALID_DATE", `AD ${String(year)}-${String(month)} is not a month.`);
+	return adMonthLength(year, month);
+}
+/** True for a valid, frozen-or-not AD date object (e.g. from JSON). */
+function isAdDate(value) {
+	return isDateLike(value, "AD") && isValidAdDate(value.year, value.month, value.day);
+}
+/** True for a valid BS date object (e.g. from JSON). */
+function isBsDate(value) {
+	return isDateLike(value, "BS") && isValidBsDate(value.year, value.month, value.day);
+}
+function isCalendarDate(value) {
+	return isAdDate(value) || isBsDate(value);
+}
+function isDateLike(value, calendar) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return record["calendar"] === calendar && typeof record["year"] === "number" && typeof record["month"] === "number" && typeof record["day"] === "number";
+}
+//#endregion
+//#region src/convert.ts
+/**
+* The only place the AD and BS calendars meet, and only through EpochDay
+* (docs/plan D-001). Nothing here looks up a year number across calendars.
+*/
+/** The day count of a date in either calendar. */
+function toEpoch(date) {
+	return toEpochDay(date.calendar === "AD" ? adToEpoch(date.year, date.month, date.day) : bsToEpoch(date.year, date.month, date.day));
+}
+/** The date of a day count in a calendar. BS throws OUT_OF_TABLE outside the table. */
+function fromEpoch(epoch, calendar) {
+	if (calendar === "AD") {
+		const { year, month, day } = epochToAd(epoch);
+		return adDate(year, month, day);
+	}
+	assertConvertible(epoch);
+	const { year, month, day } = epochToBs(epoch);
+	return bsDate(year, month, day);
+}
+function adToBs(date) {
+	return fromEpoch(toEpoch(date), "BS");
+}
+function bsToAd(date) {
+	return fromEpoch(toEpoch(date), "AD");
+}
+/** The same day in the given calendar (the date itself when it is already in it). */
+function toCalendar(date, calendar) {
+	if (date.calendar === calendar) return date;
+	return fromEpoch(toEpoch(date), calendar);
+}
+/** The first day that can be converted, in either calendar (the start of the BS table). */
+function minDate(calendar) {
+	return fromEpoch(toEpochDay(bsEpochRange().first), calendar);
+}
+/** The last day that can be converted, in either calendar (the end of the BS table). */
+function maxDate(calendar) {
+	return fromEpoch(toEpochDay(bsEpochRange().last), calendar);
+}
+/** Whether a date can be converted to the other calendar. */
+function isConvertible(date) {
+	const epoch = toEpoch(date);
+	const { first, last } = bsEpochRange();
+	return epoch >= first && epoch <= last;
+}
+/** The AD day as "YYYY-MM-DD", the form to store and send (docs/plan D-003). */
+function toIsoDate(date) {
+	const { year, month, day } = toCalendar(date, "AD");
+	if (year < 0 || year > 9999) throw new NepDateRangeError("INVALID_ARGUMENT", `AD year ${year} cannot be written as YYYY-MM-DD.`);
+	return `${pad(year, 4)}-${pad(month, 2)}-${pad(day, 2)}`;
+}
+/**
+* An AD date from "YYYY-MM-DD", or from a longer ISO timestamp by its date part
+* ("2026-10-18T09:30:00Z" → 2026-10-18). Null for anything else.
+*/
+function fromIsoDate(value) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})(?:$|[T ])/.exec(value ?? "");
+	if (!match) return null;
+	try {
+		return adDate(Number(match[1]), Number(match[2]), Number(match[3]));
+	} catch {
+		return null;
+	}
+}
+/** The AD calendar day an instant falls on in a time zone (Nepal by default). */
+function fromJsDate(instant, timeZone = getConfig().timeZone) {
+	if (Number.isNaN(instant.getTime())) throw new NepDateRangeError("INVALID_ARGUMENT", "The Date is invalid.");
+	let parts;
+	try {
+		parts = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			era: "short"
+		}).formatToParts(instant);
+	} catch {
+		throw new NepDateRangeError("INVALID_ARGUMENT", `"${timeZone}" is not a time zone.`);
+	}
+	const part = (type) => parts.find((item) => item.type === type)?.value ?? "";
+	const year = Number(part("year"));
+	return adDate(part("era") === "BC" ? 1 - year : year, Number(part("month")), Number(part("day")));
+}
+/**
+* The calendar day and time of an ISO timestamp *with a zone* ("…Z",
+* "…+05:45"), read in `timeZone` (Nepal by default). Null for anything else,
+* including plain dates, which have no instant.
+*/
+function fromIsoTimestamp(value, timeZone = getConfig().timeZone) {
+	if (!value || !/T.*(?:Z|[+-]\d{2}:?\d{2})$/.test(value)) return null;
+	const instant = new Date(value);
+	if (Number.isNaN(instant.getTime())) return null;
+	const time = new Intl.DateTimeFormat("en-GB", {
+		timeZone,
+		hour: "2-digit",
+		minute: "2-digit",
+		hourCycle: "h23"
+	}).format(instant);
+	return {
+		date: fromJsDate(instant, timeZone),
+		time
+	};
+}
+function assertConvertible(epoch) {
+	const { first, last } = bsEpochRange();
+	if (epoch < first || epoch > last) {
+		const { year, month, day } = epochToAd(epoch);
+		const from = epochToAd(first);
+		const to = epochToAd(last);
+		throw new NepDateRangeError("OUT_OF_TABLE", `AD ${isoParts(year, month, day)} is outside the BS table (AD ${isoParts(from.year, from.month, from.day)} to ${isoParts(to.year, to.month, to.day)}).`);
+	}
+}
+function isoParts(year, month, day) {
+	return `${year}-${pad(month, 2)}-${pad(day, 2)}`;
+}
+function pad(value, length) {
+	return String(value).padStart(length, "0");
+}
+//#endregion
+//#region src/projected.ts
+/** Whether the date's BS year is after the last year checked against a published calendar. */
+function isProjected(date) {
+	return isProjectedBsYear(toCalendar(date, "BS").year);
+}
+//#endregion
+//#region src/clock.ts
+function today(calendar = "AD", timeZone = getConfig().timeZone) {
+	return toCalendar(fromJsDate(/* @__PURE__ */ new Date(), timeZone), calendar);
+}
+/** The current calendar day and time (HH:MM) in `timeZone` (Nepal by default). */
+function now(timeZone = getConfig().timeZone) {
+	const current = fromIsoTimestamp((/* @__PURE__ */ new Date()).toISOString(), timeZone);
+	const [hour = 0, minute = 0] = (current?.time ?? "00:00").split(":").map(Number);
+	return {
+		date: current?.date ?? fromJsDate(/* @__PURE__ */ new Date(), timeZone),
+		time: Object.freeze({
+			hour,
+			minute
+		})
+	};
+}
+//#endregion
+//#region src/arithmetic.ts
+function addDays(date, days) {
+	assertInteger(days, "days");
+	return fromEpoch(toEpochDay(toEpoch(date) + days), date.calendar);
+}
+/** Move by whole months in the date's own calendar; the day is capped to the new month's length. */
+function addMonths(date, months) {
+	assertInteger(months, "months");
+	const index = date.year * 12 + (date.month - 1) + months;
+	const year = Math.floor(index / 12);
+	const month = index - year * 12 + 1;
+	const day = Math.min(date.day, daysInMonth(date.calendar, year, month));
+	return createDate(date.calendar, year, month, day);
+}
+/** Move by whole years in the date's own calendar; the day is capped (29 Feb, short BS months). */
+function addYears(date, years) {
+	assertInteger(years, "years");
+	return addMonths(date, years * 12);
+}
+function startOfMonth(date) {
+	return createDate(date.calendar, date.year, date.month, 1);
+}
+function endOfMonth(date) {
+	return createDate(date.calendar, date.year, date.month, daysInMonth(date.calendar, date.year, date.month));
+}
+function startOfYear(date) {
+	return createDate(date.calendar, date.year, 1, 1);
+}
+function endOfYear(date) {
+	return createDate(date.calendar, date.year, 12, daysInMonth(date.calendar, date.year, 12));
+}
+function startOfWeek(date, weekStartsOn = getConfig().weekStartsOn) {
+	assertWeekday(weekStartsOn);
+	return addDays(date, -((weekdayOf(toEpoch(date)) - weekStartsOn + 7) % 7));
+}
+function endOfWeek(date, weekStartsOn = getConfig().weekStartsOn) {
+	return addDays(startOfWeek(date, weekStartsOn), 6);
+}
+/** Whole days from `b` to `a` (positive when `a` is later). The calendars may differ. */
+function differenceInDays(a, b) {
+	return toEpoch(a) - toEpoch(b);
+}
+/** Every day from `start` to `end` inclusive, in `start`'s calendar. Nothing when end < start. */
+function* eachDayOfInterval(start, end) {
+	const last = toEpoch(end);
+	for (let epoch = toEpoch(start); epoch <= last; epoch++) yield fromEpoch(toEpochDay(epoch), start.calendar);
+}
+/** Every day of the month the date is in. */
+function eachDayOfMonth(date) {
+	return [...eachDayOfInterval(startOfMonth(date), endOfMonth(date))];
+}
+/** The date converted to `target`'s calendar; a small helper used by compare and fiscal code. */
+function inCalendarOf(target, date) {
+	return toCalendar(date, target.calendar);
+}
+function assertInteger(value, name) {
+	if (!Number.isSafeInteger(value)) throw new NepDateRangeError("INVALID_ARGUMENT", `${name} must be a whole number, not ${String(value)}.`);
+}
+function assertWeekday(value) {
+	if (!isWeekday(value)) throw new NepDateRangeError("INVALID_ARGUMENT", `${String(value)} is not a weekday (0–6).`);
+}
+//#endregion
+//#region src/compare.ts
+/** -1, 0 or 1. Dates in different calendars compare by the day they fall on. */
+function compareDates(a, b) {
+	return Math.sign(toEpoch(a) - toEpoch(b));
+}
+/** Same day, in any calendars. False when either is missing. */
+function isSameDay(a, b) {
+	return a != null && b != null && toEpoch(a) === toEpoch(b);
+}
+/** Whether `b` falls in the same month as `a`, judged in `a`'s calendar. */
+function isSameMonth(a, b) {
+	const other = inCalendarOf(a, b);
+	return other.year === a.year && other.month === a.month;
+}
+/** Whether `b` falls in the same year as `a`, judged in `a`'s calendar. */
+function isSameYear(a, b) {
+	return inCalendarOf(a, b).year === a.year;
+}
+function isBefore(a, b) {
+	return toEpoch(a) < toEpoch(b);
+}
+function isAfter(a, b) {
+	return toEpoch(a) > toEpoch(b);
+}
+/** On or after `min` and on or before `max`; a missing bound is open. */
+function isWithin(date, min, max) {
+	const day = toEpoch(date);
+	return (min == null || day >= toEpoch(min)) && (max == null || day <= toEpoch(max));
+}
+/** The date, or the nearest bound when it is outside, in the date's calendar. */
+function clampDate(date, min, max) {
+	if (min != null && isBefore(date, min)) return toCalendar(min, date.calendar);
+	if (max != null && isAfter(date, max)) return toCalendar(max, date.calendar);
+	return date;
+}
+/** 0 = Sunday … 6 = Saturday. The same in both calendars. */
+function dayOfWeek(date) {
+	return weekdayOf(toEpoch(date));
+}
+/** Saturday by default (Nepal); set `weekendDays` in configure() or pass them here. */
+function isWeekend(date, weekendDays = getConfig().weekendDays) {
+	return weekendDays.includes(dayOfWeek(date));
+}
+//#endregion
+//#region src/locale/index.ts
+const DEVANAGARI = [
+	"०",
+	"१",
+	"२",
+	"३",
+	"४",
+	"५",
+	"६",
+	"७",
+	"८",
+	"९"
+];
+/** The data for a locale (the configured default when omitted; English when unknown). */
+function getLocale(locale = getConfig().defaultLocale) {
+	return localeData(locale);
+}
+function monthNames(calendar, locale, width = "long") {
+	return getLocale(locale).months[calendar][width];
+}
+function weekdayNames(locale, width = "long") {
+	return getLocale(locale).weekdays[width];
+}
+/** Replace Devanagari digits with ASCII digits. */
+function toAsciiDigits(value) {
+	return value.replace(/[०-९]/g, (digit) => String(DEVANAGARI.indexOf(digit)));
+}
+/** Replace ASCII digits with Devanagari digits. */
+function toDevanagariDigits(value) {
+	return String(value).replace(/[0-9]/g, (digit) => DEVANAGARI[Number(digit)] ?? digit);
+}
+/** Write a number (or digit string) with the locale's digits. */
+function formatNumber(value, locale) {
+	const { digits } = getLocale(locale);
+	return String(value).replace(/[0-9]/g, (digit) => digits[Number(digit)] ?? digit);
+}
+/** Fill {name} placeholders in a locale message. */
+function formatMessage(template, values) {
+	return template.replace(/\{(\w+)\}/g, (whole, name) => values[name] ?? whole);
+}
+//#endregion
+//#region src/format.ts
+/** Named formats. `cbms` is the dotted form Nepal's tax system uses. */
+const DATE_FORMATS = Object.freeze({
+	iso: "Y-m-d",
+	cbms: "Y.m.d",
+	short: "j M Y",
+	long: "j F Y",
+	full: "l, j F Y"
+});
+/**
+* Format a date in its own calendar. Tokens: Y 2083, y 83, m 06, n 6, d 09,
+* j 9, F month name, M short month name, l weekday, D short weekday. Put a
+* backslash before a letter to print it as is. Digits follow the locale.
+*
+*   formatDate(bsDate(2082, 4, 1), 'full')        → "Thursday, 1 Shrawan 2082"
+*   formatDate(bsDate(2082, 4, 1), 'long', 'ne')  → "१ साउन २०८२"
+*/
+function formatDate(date, pattern = "iso", locale) {
+	const tokens = pattern in DATE_FORMATS ? DATE_FORMATS[pattern] : pattern;
+	const data = getLocale(locale);
+	const months = data.months[date.calendar];
+	const digits = (value) => formatNumber(value, locale);
+	const pad = (value) => String(value).padStart(2, "0");
+	let output = "";
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens.charAt(index);
+		switch (token) {
+			case "\\":
+				index++;
+				output += tokens.charAt(index);
+				break;
+			case "Y":
+				output += digits(date.year);
+				break;
+			case "y":
+				output += digits(pad((date.year % 100 + 100) % 100));
+				break;
+			case "m":
+				output += digits(pad(date.month));
+				break;
+			case "n":
+				output += digits(date.month);
+				break;
+			case "d":
+				output += digits(pad(date.day));
+				break;
+			case "j":
+				output += digits(date.day);
+				break;
+			case "F":
+				output += months.long[date.month - 1] ?? "";
+				break;
+			case "M":
+				output += months.short[date.month - 1] ?? "";
+				break;
+			case "l":
+				output += data.weekdays.long[dayOfWeek(date)] ?? "";
+				break;
+			case "D":
+				output += data.weekdays.short[dayOfWeek(date)] ?? "";
+				break;
+			default: output += token;
+		}
+	}
+	return output;
+}
+//#endregion
+//#region src/fiscal.ts
+/** The fiscal year a date falls in: 1 Shrawan to the end of Asar. */
+function fiscalYear(date) {
+	const bs = toCalendar(date, "BS");
+	return fiscalYearRange(bs.month >= 4 ? bs.year : bs.year - 1);
+}
+/** The fiscal year that starts in BS `startYear` (2083 → FY 2083/84). */
+function fiscalYearRange(startYear) {
+	const endYear = startYear + 1;
+	const lastMonth = 3;
+	return Object.freeze({
+		startYear,
+		label: `${startYear}/${String(endYear % 100).padStart(2, "0")}`,
+		firstDay: bsDate(startYear, 4, 1),
+		lastDay: bsDate(endYear, lastMonth, daysInMonth("BS", endYear, lastMonth))
+	});
+}
+/**
+* label "2083/84" · full "2083/2084" · cbms "2083.084" (the form Nepal's tax
+* system uses). Digits follow the locale.
+*/
+function formatFiscalYear(fy, style = "label", locale) {
+	const end = fy.startYear + 1;
+	return formatNumber(style === "full" ? `${fy.startYear}/${end}` : style === "cbms" ? `${fy.startYear}.${String(end % 1e3).padStart(3, "0")}` : fy.label, locale);
+}
+function isInFiscalYear(date, fy) {
+	return compareDates(date, fy.firstDay) >= 0 && compareDates(date, fy.lastDay) <= 0;
+}
+//#endregion
+//#region src/parse.ts
+const YEAR_FIRST = /^(\d{4})[-./](\d{1,2})[-./](\d{1,2})$/;
+const COMPACT = /^(\d{4})(\d{2})(\d{2})$/;
+/**
+* A date written year first ("2083-06-24", "2083/6/24", "2083.06.24", or
+* compact "20830624") in ASCII or Devanagari digits, in the calendar the caller names. Other orders are
+* rejected, not guessed. Returns null when the text is not a valid date.
+*/
+function parseDate(text, calendar) {
+	try {
+		return parseDateStrict(text ?? "", calendar);
+	} catch {
+		return null;
+	}
+}
+/** Like parseDate, but throws a NepDateRangeError that says what is wrong. */
+function parseDateStrict(text, calendar) {
+	const ascii = toAsciiDigits(text).trim();
+	const match = YEAR_FIRST.exec(ascii) ?? COMPACT.exec(ascii);
+	if (!match) throw new NepDateRangeError("INVALID_ARGUMENT", `"${text}" is not a date written as YYYY-MM-DD.`);
+	return createDate(calendar, Number(match[1]), Number(match[2]), Number(match[3]));
+}
+/**
+* A fiscal year from its label: "2083/84", "2083/2084", "2083-84" or the
+* tax form "2083.084", in ASCII or Devanagari digits. Null when not valid.
+*/
+function parseFiscalYear(text) {
+	const match = /^(\d{4})\s*[-/.]\s*(\d{2,4})$/.exec(toAsciiDigits(text ?? "").trim());
+	if (!match) return null;
+	const start = Number(match[1]);
+	const end = match[2] ?? "";
+	const next = start + 1;
+	if (end !== (end.length === 4 ? String(next) : String(next % 10 ** end.length).padStart(end.length, "0"))) return null;
+	try {
+		return fiscalYearRange(start);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/time.ts
+function timeOfDay(hour, minute = 0) {
+	if (!isValidTime(hour, minute)) throw new NepDateRangeError("INVALID_ARGUMENT", `${String(hour)}:${String(minute)} is not a time of day.`);
+	return Object.freeze({
+		hour,
+		minute
+	});
+}
+function isValidTime(hour, minute) {
+	return Number.isInteger(hour) && Number.isInteger(minute) && hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+}
+/** -1, 0 or 1. */
+function compareTimes(a, b) {
+	return Math.sign(a.hour * 60 + a.minute - (b.hour * 60 + b.minute));
+}
+/**
+* "14:30", "2:30 pm", "2 PM", "1430", "१४:३०", "२:३० अपराह्न" → TimeOfDay.
+* Null when the text is not a time.
+*/
+function parseTime(text) {
+	let value = toAsciiDigits(text ?? "").trim().toLowerCase();
+	let meridiem = null;
+	for (const code of ["en", "ne"]) {
+		const { am, pm } = getLocale(code).time;
+		for (const [word, kind] of [
+			[am.toLowerCase(), "am"],
+			[pm.toLowerCase(), "pm"],
+			[am.toLowerCase().replace(/(.)/g, "$1."), "am"],
+			[pm.toLowerCase().replace(/(.)/g, "$1."), "pm"]
+		]) if (value.endsWith(word)) {
+			meridiem = kind;
+			value = value.slice(0, -word.length).trim();
+			break;
+		}
+		if (meridiem) break;
+	}
+	const match = /^(\d{1,2})(?:[:.](\d{2}))?$/.exec(value) ?? /^(\d{2})(\d{2})$/.exec(value);
+	if (!match) return null;
+	let hour = Number(match[1]);
+	const minute = Number(match[2] ?? 0);
+	if (meridiem) {
+		if (hour < 1 || hour > 12) return null;
+		hour = hour % 12 + (meridiem === "pm" ? 12 : 0);
+	}
+	return isValidTime(hour, minute) ? timeOfDay(hour, minute) : null;
+}
+/** "14:30" (24-hour) or "2:30 PM" (hour12), in the locale's digits and words. */
+function formatTime(time, options = {}) {
+	const minute = String(time.minute).padStart(2, "0");
+	if (!options.hour12) return formatNumber(`${String(time.hour).padStart(2, "0")}:${minute}`, options.locale);
+	const { am, pm } = getLocale(options.locale).time;
+	return `${formatNumber(`${time.hour % 12 === 0 ? 12 : time.hour % 12}:${minute}`, options.locale)} ${time.hour < 12 ? am : pm}`;
+}
+/**
+* The instant of a calendar day and time in a zone (Nepal by default), as an
+* ISO timestamp with that zone's offset: "2026-10-18T14:30:00+05:45".
+*/
+function toIsoDateTime(date, time, timeZone = getConfig().timeZone) {
+	const { year, month, day } = toCalendar(date, "AD");
+	if (year < 0 || year > 9999) throw new NepDateRangeError("INVALID_ARGUMENT", `AD year ${year} cannot be written in ISO form.`);
+	const wall = Date.UTC(year, month - 1, day, time.hour, time.minute);
+	const offset = offsetMinutes(wall - offsetMinutes(wall, timeZone) * 6e4, timeZone);
+	const sign = offset < 0 ? "-" : "+";
+	const abs = Math.abs(offset);
+	const pad = (value, length = 2) => String(value).padStart(length, "0");
+	return `${pad(year, 4)}-${pad(month)}-${pad(day)}T${pad(time.hour)}:${pad(time.minute)}:00${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+/**
+* The day and time of an ISO timestamp in a zone (Nepal by default). A value
+* without an offset ("2026-10-18T14:30", as from <input type="datetime-local">)
+* is read as a wall time already in that zone. Null for anything else.
+*/
+function fromIsoDateTime(value, timeZone = getConfig().timeZone) {
+	const zoned = fromIsoTimestamp(value, timeZone);
+	if (zoned) {
+		const time = parseTime(zoned.time);
+		return time ? {
+			date: zoned.date,
+			time
+		} : null;
+	}
+	const local = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::\d{2}(?:\.\d+)?)?$/.exec(value ?? "");
+	if (!local) return null;
+	try {
+		return {
+			date: adDate(Number(local[1]), Number(local[2]), Number(local[3])),
+			time: timeOfDay(Number(local[4]), Number(local[5]))
+		};
+	} catch {
+		return null;
+	}
+}
+/** Minutes the zone is ahead of UTC at an instant. */
+function offsetMinutes(instant, timeZone) {
+	let parts;
+	try {
+		parts = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			hour: "numeric",
+			minute: "numeric"
+		}).formatToParts(new Date(instant));
+	} catch {
+		throw new NepDateRangeError("INVALID_ARGUMENT", `"${timeZone}" is not a time zone.`);
+	}
+	const part = (type) => Number(parts.find((item) => item.type === type)?.value ?? 0);
+	const wall = Date.UTC(part("year"), part("month") - 1, part("day"), part("hour"), part("minute"));
+	return Math.round((wall - Math.floor(instant / 6e4) * 6e4) / 6e4);
+}
+//#endregion
+export { BS_FISCAL_YEAR_START_MONTH, DATE_FORMATS, MAX_AD_YEAR, NepDateDataError, NepDateRangeError, adDate, adToBs, addDays, addMonths, addYears, bsDate, bsFirstYear, bsLastYear, bsToAd, clampDate, compareDates, compareTimes, configure, createDate, dayOfWeek, daysInMonth, differenceInDays, eachDayOfInterval, eachDayOfMonth, endOfMonth, endOfWeek, endOfYear, fiscalYear, fiscalYearRange, formatDate, formatFiscalYear, formatMessage, formatNumber, formatTime, fromEpoch, fromIsoDate, fromIsoDateTime, fromIsoTimestamp, fromJsDate, getBsData, getConfig, getLocale, hasLocale, isAdDate, isAdLeapYear, isAfter, isBefore, isBsDate, isCalendarDate, isConvertible, isInFiscalYear, isProjected, isSameDay, isSameMonth, isSameYear, isValidDate, isValidTime, isWeekend, isWithin, maxDate, minDate, monthNames, now, parseDate, parseDateStrict, parseFiscalYear, parseTime, patchBsYear, registerLocale, resetBsData, resetConfig, setBsData, startOfMonth, startOfWeek, startOfYear, timeOfDay, toAsciiDigits, toCalendar, toDevanagariDigits, toEpoch, toEpochDay, toIsoDate, toIsoDateTime, today, validateBsData, weekdayNames, weekdayOf };
+
+//# sourceMappingURL=index.js.map