@bereasoftware/time-guard 2.6.0 → 2.7.0

package/dist/core-CafqOI7W.cjs

@@ -0,0 +1,1892 @@
+/*! time-guard v2.7.0 | (c) 2026 Berea-Soft | MIT License | https://github.com/Berea-Soft/time-guard */
+//#region src/locales/locale.manager.ts
+/**
+* English locale data
+*/
+var EN_LOCALE = {
+	name: "en",
+	months: [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	monthsShort: [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	],
+	weekdays: [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	weekdaysShort: [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	],
+	weekdaysMin: [
+		"Su",
+		"Mo",
+		"Tu",
+		"We",
+		"Th",
+		"Fr",
+		"Sa"
+	],
+	meridiem: {
+		am: "AM",
+		pm: "PM"
+	},
+	formats: {
+		iso: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+		date: "YYYY-MM-DD",
+		time: "HH:mm:ss",
+		datetime: "YYYY-MM-DD HH:mm:ss",
+		rfc2822: "ddd, DD MMM YYYY HH:mm:ss Z"
+	}
+};
+/**
+* Spanish locale data (sample for i18n support)
+*/
+var ES_LOCALE = {
+	name: "es",
+	months: [
+		"Enero",
+		"Febrero",
+		"Marzo",
+		"Abril",
+		"Mayo",
+		"Junio",
+		"Julio",
+		"Agosto",
+		"Septiembre",
+		"Octubre",
+		"Noviembre",
+		"Diciembre"
+	],
+	monthsShort: [
+		"Ene",
+		"Feb",
+		"Mar",
+		"Abr",
+		"May",
+		"Jun",
+		"Jul",
+		"Ago",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dic"
+	],
+	weekdays: [
+		"Domingo",
+		"Lunes",
+		"Martes",
+		"Miércoles",
+		"Jueves",
+		"Viernes",
+		"Sábado"
+	],
+	weekdaysShort: [
+		"Dom",
+		"Lun",
+		"Mar",
+		"Mié",
+		"Jue",
+		"Vie",
+		"Sáb"
+	],
+	weekdaysMin: [
+		"Do",
+		"Lu",
+		"Ma",
+		"Mi",
+		"Ju",
+		"Vi",
+		"Sa"
+	],
+	meridiem: {
+		am: "AM",
+		pm: "PM"
+	},
+	formats: {
+		iso: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+		date: "DD/MM/YYYY",
+		time: "HH:mm:ss",
+		datetime: "DD/MM/YYYY HH:mm:ss",
+		rfc2822: "ddd, DD MMM YYYY HH:mm:ss Z"
+	}
+};
+/**
+* Locale Manager - implements ILocaleManager
+*/
+var LocaleManager = class LocaleManager {
+	static instance;
+	locales = /* @__PURE__ */ new Map();
+	currentLocale = "en";
+	/**
+	* Singleton pattern
+	*/
+	static getInstance() {
+		if (!LocaleManager.instance) LocaleManager.instance = new LocaleManager();
+		return LocaleManager.instance;
+	}
+	constructor() {
+		this.locales.set("en", EN_LOCALE);
+		this.locales.set("es", ES_LOCALE);
+	}
+	/**
+	* Set or register a locale
+	*/
+	setLocale(locale, data) {
+		if (data) this.locales.set(locale.toLowerCase(), data);
+		this.currentLocale = locale.toLowerCase();
+	}
+	/**
+	* Get locale information
+	*/
+	getLocale(locale) {
+		const target = (locale || this.currentLocale).toLowerCase();
+		const result = this.locales.get(target);
+		if (!result) return this.locales.get("en") || EN_LOCALE;
+		return result;
+	}
+	/**
+	* List all registered locales
+	*/
+	listLocales() {
+		return Array.from(this.locales.keys());
+	}
+	/**
+	* Get current locale
+	*/
+	getCurrentLocale() {
+		return this.currentLocale;
+	}
+	/**
+	* Load multiple locales
+	*/
+	loadLocales(locales) {
+		Object.entries(locales).forEach(([name, data]) => {
+			this.locales.set(name.toLowerCase(), data);
+		});
+	}
+};
+//#endregion
+//#region src/adapters/temporal.adapter.ts
+var temporalCache = null;
+/**
+* Get Temporal from globalThis or imported module
+*/
+function useTemporal() {
+	if (temporalCache) return temporalCache;
+	const TemporalLoaded = globalThis.Temporal;
+	if (!TemporalLoaded) throw new Error("Temporal API not loaded. Make sure @js-temporal/polyfill is imported in your app.");
+	temporalCache = TemporalLoaded;
+	return TemporalLoaded;
+}
+/**
+* Adapter for Temporal date/time operations
+*/
+var TemporalAdapter = class {
+	/**
+	* Parse various input formats to Temporal.PlainDateTime
+	*/
+	static parseToPlainDateTime(input) {
+		const Temporal = useTemporal();
+		if (this.isPlainDateTime(input)) return input;
+		if (this.isZonedDateTime(input)) return input.toPlainDateTime();
+		if (this.isPlainDate(input)) return input.toPlainDateTime({
+			hour: 0,
+			minute: 0,
+			second: 0,
+			millisecond: 0
+		});
+		if (this.isPlainTime(input)) return Temporal.Now.plainDateTimeISO().with(input);
+		if (input !== null && typeof input === "object" && "getTime" in input && typeof input.getTime === "function") return this.fromDate(input);
+		if (typeof input === "number") return this.fromUnix(input);
+		if (typeof input === "string") return this.parseISOString(input);
+		if (typeof input === "object" && input !== null) return this.fromObject(input);
+		return Temporal.Now.plainDateTimeISO();
+	}
+	/**
+	* Convert JavaScript Date to Temporal.PlainDateTime
+	*/
+	static fromDate(date) {
+		const Temporal = useTemporal();
+		const [datePart, timePart] = date.toISOString().split("T");
+		return Temporal.PlainDateTime.from(datePart + "T" + timePart.slice(0, -1));
+	}
+	/**
+	* Convert Unix timestamp (milliseconds) to Temporal.PlainDateTime
+	*/
+	static fromUnix(timestamp) {
+		return this.fromDate(new Date(timestamp));
+	}
+	/**
+	* Parse ISO string to Temporal.PlainDateTime
+	*/
+	static parseISOString(iso) {
+		const Temporal = useTemporal();
+		try {
+			if (iso.includes("T") || / \d{2}:\d{2}/.test(iso)) {
+				const normalized = iso.replace(" ", "T");
+				return Temporal.PlainDateTime.from(normalized);
+			}
+			return Temporal.PlainDate.from(iso).toPlainDateTime({ hour: 0 });
+		} catch {
+			return Temporal.Now.plainDateTimeISO();
+		}
+	}
+	/**
+	* Create from object with date components
+	*/
+	static fromObject(obj) {
+		const Temporal = useTemporal();
+		const year = obj.year || Temporal.Now.plainDateISO().year;
+		const month = obj.month || 1;
+		const day = obj.day || 1;
+		const hour = obj.hour || 0;
+		const minute = obj.minute || 0;
+		const second = obj.second || 0;
+		const millisecond = obj.millisecond || 0;
+		return Temporal.PlainDateTime.from({
+			year: this.toFiniteInteger(year),
+			month: this.toFiniteInteger(month),
+			day: this.toFiniteInteger(day),
+			hour: this.toFiniteInteger(hour),
+			minute: this.toFiniteInteger(minute),
+			second: this.toFiniteInteger(second),
+			millisecond: this.toFiniteInteger(millisecond)
+		});
+	}
+	/**
+	* Convert Temporal.PlainDateTime to JavaScript Date
+	*/
+	static toDate(temporal) {
+		const plainDT = this.toPlainDateTime(temporal);
+		return new Date(plainDT.toString());
+	}
+	/**
+	* Convert to Unix timestamp (milliseconds)
+	*/
+	static toUnix(temporal) {
+		const plainDT = this.toPlainDateTime(temporal);
+		return Date.UTC(plainDT.year, plainDT.month - 1, plainDT.day, plainDT.hour, plainDT.minute, plainDT.second, plainDT.millisecond);
+	}
+	/**
+	* Convert to ISO string
+	*/
+	static toISOString(temporal) {
+		return this.toPlainDateTime(temporal).toString() + "Z";
+	}
+	/**
+	* Ensure we have a PlainDateTime
+	*/
+	static toPlainDateTime(temporal) {
+		if (this.isPlainDateTime(temporal)) return temporal;
+		return temporal.toPlainDateTime();
+	}
+	/**
+	* Type guards
+	*/
+	static isPlainDateTime(obj) {
+		return obj !== null && typeof obj === "object" && "year" in obj && "month" in obj && "day" in obj && "hour" in obj;
+	}
+	static isZonedDateTime(obj) {
+		return obj !== null && typeof obj === "object" && "timeZone" in obj;
+	}
+	static isPlainDate(obj) {
+		return obj !== null && typeof obj === "object" && "year" in obj && "month" in obj && "day" in obj && !("hour" in obj) && "toPlainDateTime" in obj;
+	}
+	static isPlainTime(obj) {
+		return obj !== null && typeof obj === "object" && "hour" in obj && !("year" in obj);
+	}
+	static toFiniteInteger(value) {
+		const num = Number(value);
+		if (!Number.isFinite(num)) throw new Error(`Temporal error: Expected finite integer, got ${value}`);
+		return Math.trunc(num);
+	}
+	/**
+	* Validate that a PlainDateTime has finite integer components
+	*/
+	static validatePlainDateTime(dt) {
+		for (const field of [
+			"year",
+			"month",
+			"day",
+			"hour",
+			"minute",
+			"second",
+			"millisecond"
+		]) {
+			const value = dt[field];
+			if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+				if (typeof console !== "undefined" && typeof console.error === "function") console.error("TemporalAdapter.validatePlainDateTime: campo inválido", field, value, dt);
+				throw new Error(`Temporal error: Expected finite integer for ${field}, got ${value}`);
+			}
+		}
+	}
+	/**
+	* Get current time as PlainDateTime
+	*/
+	static now() {
+		return useTemporal().Now.plainDateTimeISO();
+	}
+	/**
+	* Get current time as ZonedDateTime with timezone
+	*/
+	static nowInTimezone(timezone) {
+		return useTemporal().Now.zonedDateTimeISO(timezone);
+	}
+	/**
+	* Compare two Temporal.PlainDateTime objects
+	* Returns: -1 if dt1 < dt2, 0 if equal, 1 if dt1 > dt2
+	* Uses ISO string comparison as fallback for polyfills that don't have Temporal.PlainDateTime.compare
+	*/
+	static compare(dt1, dt2) {
+		const Temporal = useTemporal();
+		this.validatePlainDateTime(dt1);
+		this.validatePlainDateTime(dt2);
+		if (Temporal.PlainDateTime && typeof Temporal.PlainDateTime.compare === "function") return Temporal.PlainDateTime.compare(dt1, dt2);
+		const iso1 = dt1.toString();
+		const iso2 = dt2.toString();
+		if (iso1 < iso2) return -1;
+		if (iso1 > iso2) return 1;
+		return 0;
+	}
+};
+//#endregion
+//#region src/formatters/date.formatter.ts
+/**
+* Date Formatter implementation
+*/
+var DateFormatter = class {
+	localeManager;
+	constructor() {
+		this.localeManager = LocaleManager.getInstance();
+	}
+	/**
+	* Format date with pattern and locale
+	*/
+	format(date, pattern, locale) {
+		const localeData = this.localeManager.getLocale(locale);
+		const escapedParts = [];
+		let escapedPattern = pattern.replace(/\[([^\]]+)\]/g, (_match, content) => {
+			escapedParts.push(content);
+			return `~${escapedParts.length - 1}~`;
+		});
+		escapedPattern = escapedPattern.replace(/"([^"]*)"/g, (_match, content) => {
+			escapedParts.push(content);
+			return `~${escapedParts.length - 1}~`;
+		});
+		let result = escapedPattern.replace(/Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|SSS/g, (match) => {
+			switch (match) {
+				case "YYYY": return String(date.year).padStart(4, "0");
+				case "YY": return String(date.year).slice(-2);
+				case "Y": return String(date.year);
+				case "MMMM": return localeData.months[date.month - 1];
+				case "MMM": return localeData.monthsShort[date.month - 1];
+				case "MM": return String(date.month).padStart(2, "0");
+				case "M": return String(date.month);
+				case "DD": return String(date.day).padStart(2, "0");
+				case "D": return String(date.day);
+				case "dddd": return localeData.weekdays[date.dayOfWeek % 7];
+				case "ddd": return localeData.weekdaysShort[date.dayOfWeek % 7];
+				case "dd": return localeData.weekdaysMin[date.dayOfWeek % 7];
+				case "d": return String(date.dayOfWeek);
+				case "HH": return String(date.hour).padStart(2, "0");
+				case "H": return String(date.hour);
+				case "hh": return String(date.hour % 12 || 12).padStart(2, "0");
+				case "h": return String(date.hour % 12 || 12);
+				case "mm": return String(date.minute).padStart(2, "0");
+				case "m": return String(date.minute);
+				case "ss": return String(date.second).padStart(2, "0");
+				case "s": return String(date.second);
+				case "SSS": return String(date.millisecond).padStart(3, "0");
+				case "a":
+				case "A":
+					const meridiem = localeData.meridiem || {
+						am: "am",
+						pm: "pm"
+					};
+					const value = date.hour >= 12 ? meridiem.pm : meridiem.am;
+					return match === "a" ? value.toLowerCase() : value.toUpperCase();
+				default: return match;
+			}
+		});
+		escapedParts.forEach((content, index) => {
+			result = result.replace(`~${index}~`, content);
+		});
+		return result;
+	}
+	/**
+	* Get format pattern for preset
+	*/
+	getPreset(preset) {
+		const presets = {
+			iso: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+			date: "YYYY-MM-DD",
+			time: "HH:mm:ss",
+			datetime: "YYYY-MM-DD HH:mm:ss",
+			rfc2822: "ddd, DD MMM YYYY HH:mm:ss Z",
+			rfc3339: "YYYY-MM-DDTHH:mm:ssZ",
+			utc: "YYYY-MM-DDTHH:mm:ss[Z]"
+		};
+		return presets[preset] || presets.iso;
+	}
+	/**
+	* Format with preset
+	*/
+	formatPreset(date, preset, locale) {
+		const pattern = this.getPreset(preset);
+		return this.format(date, pattern, locale);
+	}
+};
+//#endregion
+//#region src/utils/duration-locale.ts
+/**
+* Shared locale utilities for duration formatting
+* Extracted from DiffResult and DurationResult to avoid duplication
+*/
+/**
+* Duration unit labels for different locales
+* Format: [singular, plural]
+*/
+var DURATION_UNIT_LABELS = {
+	en: {
+		year: ["year", "years"],
+		month: ["month", "months"],
+		week: ["week", "weeks"],
+		day: ["day", "days"],
+		hour: ["hour", "hours"],
+		minute: ["minute", "minutes"],
+		second: ["second", "seconds"],
+		millisecond: ["millisecond", "milliseconds"]
+	},
+	es: {
+		year: ["año", "años"],
+		month: ["mes", "meses"],
+		week: ["semana", "semanas"],
+		day: ["día", "días"],
+		hour: ["hora", "horas"],
+		minute: ["minuto", "minutos"],
+		second: ["segundo", "segundos"],
+		millisecond: ["milisegundo", "milisegundos"]
+	},
+	fr: {
+		year: ["année", "années"],
+		month: ["mois", "mois"],
+		week: ["semaine", "semaines"],
+		day: ["jour", "jours"],
+		hour: ["heure", "heures"],
+		minute: ["minute", "minutes"],
+		second: ["seconde", "secondes"],
+		millisecond: ["milliseconde", "millisecondes"]
+	}
+};
+/**
+* Conjunction words for joining duration parts
+*/
+var CONJUNCTION_LABELS = {
+	en: "and",
+	es: "y",
+	fr: "et",
+	de: "und",
+	it: "e",
+	pt: "e"
+};
+/**
+* Get duration unit label for a specific locale
+*/
+function getDurationUnitLabel(unit, locale, value) {
+	return ((DURATION_UNIT_LABELS[locale] || DURATION_UNIT_LABELS.en)[unit] || [unit, unit + "s"])[value === 1 ? 0 : 1];
+}
+/**
+* Get conjunction word for a specific locale
+*/
+function getConjunctionLabel(locale) {
+	return CONJUNCTION_LABELS[locale] || "and";
+}
+/**
+* Join formatted duration parts with locale-appropriate conjunctions
+*/
+function joinDurationParts(parts, locale) {
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	const conjunction = getConjunctionLabel(locale);
+	if (parts.length === 2) return `${parts[0]} ${conjunction} ${parts[1]}`;
+	return parts.slice(0, -1).join(", ") + ` ${conjunction} ${parts[parts.length - 1]}`;
+}
+/**
+* Format a zero duration for display
+*/
+function formatZeroDuration(locale) {
+	return {
+		en: "0 seconds",
+		es: "0 segundos",
+		fr: "0 secondes"
+	}[locale] || "0 seconds";
+}
+//#endregion
+//#region src/calendars/calendar.manager.ts
+/**
+* Gregorian Calendar System (ISO 8601 default)
+*/
+var GregorianCalendar = class {
+	id = "gregory";
+	name = "Gregorian Calendar";
+	locale = "en";
+	monthNames = [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	];
+	monthNamesShort = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	weekdayNames = [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	];
+	weekdayNamesShort = [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	];
+	getMonthName(month, short = false) {
+		return (short ? this.monthNamesShort : this.monthNames)[Math.max(0, Math.min(11, month - 1))];
+	}
+	getWeekdayName(day, short = false) {
+		return (short ? this.weekdayNamesShort : this.weekdayNames)[Math.max(0, Math.min(6, day - 1))];
+	}
+	isLeapYear(year) {
+		return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+	}
+	daysInMonth(year, month) {
+		const daysPerMonth = [
+			31,
+			28,
+			31,
+			30,
+			31,
+			30,
+			31,
+			31,
+			30,
+			31,
+			30,
+			31
+		];
+		if (month === 2 && this.isLeapYear(year)) return 29;
+		return daysPerMonth[Math.max(0, Math.min(11, month - 1))];
+	}
+	daysInYear(year) {
+		return this.isLeapYear(year) ? 366 : 365;
+	}
+};
+/**
+* Calendar Manager - Singleton for managing calendar systems
+*/
+var CalendarManager = class CalendarManager {
+	static instance;
+	calendars = /* @__PURE__ */ new Map();
+	defaultCalendar = "gregory";
+	constructor() {
+		this.register(new GregorianCalendar());
+	}
+	/**
+	* Get singleton instance
+	*/
+	static getInstance() {
+		if (!CalendarManager.instance) CalendarManager.instance = new CalendarManager();
+		return CalendarManager.instance;
+	}
+	/**
+	* Register a new calendar system
+	*/
+	register(calendar) {
+		this.calendars.set(calendar.id, calendar);
+	}
+	/**
+	* Get calendar by ID
+	*/
+	get(id) {
+		return this.calendars.get(id);
+	}
+	/**
+	* List all available calendars
+	*/
+	list() {
+		return Array.from(this.calendars.keys());
+	}
+	/**
+	* Set default calendar
+	*/
+	setDefault(id) {
+		if (this.calendars.has(id)) this.defaultCalendar = id;
+	}
+	/**
+	* Get default calendar
+	*/
+	getDefault() {
+		const calendar = this.calendars.get(this.defaultCalendar);
+		if (!calendar) throw new Error(`Default calendar '${this.defaultCalendar}' not found`);
+		return calendar;
+	}
+};
+var calendarManager = CalendarManager.getInstance();
+//#endregion
+//#region src/plugins/manager.ts
+/**
+* Plugin Manager - handles plugin registration and initialization
+* Uses Singleton pattern to ensure single instance across application
+*/
+var PluginManager = class PluginManager {
+	static instance;
+	plugins = /* @__PURE__ */ new Map();
+	/**
+	* Get singleton instance
+	*/
+	static getInstance() {
+		if (!PluginManager.instance) PluginManager.instance = new PluginManager();
+		return PluginManager.instance;
+	}
+	/**
+	* Register a plugin
+	* @param plugin - The plugin to register
+	* @param timeGuardClass - Reference to TimeGuard class
+	* @param config - Optional plugin configuration
+	*/
+	static use(plugin, timeGuardClass, config) {
+		PluginManager.getInstance().register(plugin, timeGuardClass, config);
+	}
+	/**
+	* Register multiple plugins at once
+	* @param plugins - Array of plugins to register
+	* @param timeGuardClass - Reference to TimeGuard class
+	* @param config - Optional plugin configuration
+	*/
+	static useMultiple(plugins, timeGuardClass, config) {
+		const manager = PluginManager.getInstance();
+		plugins.forEach((plugin) => manager.register(plugin, timeGuardClass, config));
+	}
+	/**
+	* Get registered plugin by name
+	* @param name - Plugin name
+	* @returns Plugin instance or undefined
+	*/
+	static getPlugin(name) {
+		return PluginManager.getInstance().plugins.get(name);
+	}
+	/**
+	* Check if plugin is registered
+	* @param name - Plugin name
+	* @returns True if plugin is registered
+	*/
+	static hasPlugin(name) {
+		return PluginManager.getInstance().plugins.has(name);
+	}
+	/**
+	* Get all registered plugins
+	* @returns Array of registered plugin names
+	*/
+	static listPlugins() {
+		const manager = PluginManager.getInstance();
+		return Array.from(manager.plugins.keys());
+	}
+	/**
+	* Unregister a plugin
+	* @param name - Plugin name
+	*/
+	static unuse(name) {
+		return PluginManager.getInstance().plugins.delete(name);
+	}
+	/**
+	* Clear all plugins
+	*/
+	static clear() {
+		PluginManager.getInstance().plugins.clear();
+	}
+	/**
+	* Internal register method
+	*/
+	register(plugin, timeGuardClass, config) {
+		if (this.plugins.has(plugin.name)) {
+			console.warn(`Plugin "${plugin.name}" is already registered. Skipping...`);
+			return;
+		}
+		try {
+			plugin.install(timeGuardClass, config);
+			this.plugins.set(plugin.name, plugin);
+			if (process.env.NODE_ENV !== "production") console.warn(`Plugin "${plugin.name}" v${plugin.version} registered successfully`);
+		} catch (error) {
+			console.error(`Failed to register plugin "${plugin.name}":`, error);
+			throw new Error(`Failed to register plugin "${plugin.name}": ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+};
+//#endregion
+//#region src/core.ts
+/**
+* TimeGuard - Modern date/time library using Temporal API
+* Core Implementation (zero-dependency, polyfill-erased type-space)
+*
+* @author Berea-Soft
+* @license MIT
+*/
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = MS_PER_SECOND * 60;
+var MS_PER_HOUR = MS_PER_MINUTE * 60;
+var MS_PER_DAY = MS_PER_HOUR * 24;
+var MS_PER_WEEK = MS_PER_DAY * 7;
+var DAYS_PER_YEAR = 365.25;
+var MS_PER_MONTH = DAYS_PER_YEAR / 12 * MS_PER_DAY;
+var MS_PER_YEAR = DAYS_PER_YEAR * MS_PER_DAY;
+var ZERO_DIFF_DAYS = " days";
+/**
+* Calculate total milliseconds from duration parts using hoisted constants
+*/
+function calculateTotalMs(duration) {
+	return (duration.years || 0) * MS_PER_YEAR + (duration.months || 0) * MS_PER_MONTH + (duration.weeks || 0) * MS_PER_WEEK + (duration.days || 0) * MS_PER_DAY + (duration.hours || 0) * MS_PER_HOUR + (duration.minutes || 0) * MS_PER_MINUTE + (duration.seconds || 0) * MS_PER_SECOND + (duration.milliseconds || 0);
+}
+/**
+* Diff result object that allows chaining with .as()
+*
+* Supports two modes:
+* - 'exact': Returns precise time differences
+* - 'calendar': Returns calendar-aware breakdown
+*/
+var DiffResult = class {
+	_value;
+	_tg1;
+	_tg2;
+	_mode;
+	_breakdownData;
+	_locale;
+	constructor(value, tg1, tg2, mode = "exact", breakdownData, locale) {
+		this._value = value;
+		this._tg1 = tg1;
+		this._tg2 = tg2;
+		this._mode = mode;
+		this._breakdownData = breakdownData || null;
+		this._locale = locale || "en";
+	}
+	as(unit) {
+		return this._tg1.diff(this._tg2, unit);
+	}
+	breakdown() {
+		return this._breakdownData;
+	}
+	format(locale) {
+		const l = locale || this._locale;
+		if (!this._breakdownData) return `${Math.abs(this._tg1.diff(this._tg2, "day"))}${ZERO_DIFF_DAYS}`;
+		const parts = [];
+		const bd = this._breakdownData;
+		if (bd.years !== 0) parts.push(`${bd.years} ${getDurationUnitLabel("year", l, bd.years)}`);
+		if (bd.months !== 0) parts.push(`${bd.months} ${getDurationUnitLabel("month", l, bd.months)}`);
+		if (bd.weeks !== 0) parts.push(`${bd.weeks} ${getDurationUnitLabel("week", l, bd.weeks)}`);
+		if (bd.days !== 0) parts.push(`${bd.days} ${getDurationUnitLabel("day", l, bd.days)}`);
+		if (bd.hours !== 0) parts.push(`${bd.hours} ${getDurationUnitLabel("hour", l, bd.hours)}`);
+		if (bd.minutes !== 0) parts.push(`${bd.minutes} ${getDurationUnitLabel("minute", l, bd.minutes)}`);
+		if (bd.seconds !== 0) parts.push(`${bd.seconds} ${getDurationUnitLabel("second", l, bd.seconds)}`);
+		if (parts.length === 0) return formatZeroDuration(l);
+		return joinDurationParts(parts, l);
+	}
+	getMode() {
+		return this._mode;
+	}
+	valueOf() {
+		return this._value;
+	}
+	toString() {
+		if (this._mode === "calendar" && this._breakdownData) return this.format();
+		return this._value.toString();
+	}
+	toJSON() {
+		return this._value;
+	}
+};
+/**
+* DurationResult class - Represents a duration breakdown with humanize support
+* Returned by until(), since(), and between() methods
+*/
+var DurationResult = class {
+	years;
+	months;
+	weeks;
+	days;
+	hours;
+	minutes;
+	seconds;
+	milliseconds;
+	_locale;
+	_startDate;
+	_endDate;
+	_steps = [];
+	_mode = "exact";
+	_leapYearFlags = [];
+	_calculationTimeMs = 0;
+	constructor(parts, locale = "en", metadata) {
+		this.years = parts.years;
+		this.months = parts.months;
+		this.weeks = parts.weeks;
+		this.days = parts.days;
+		this.hours = parts.hours;
+		this.minutes = parts.minutes;
+		this.seconds = parts.seconds;
+		this.milliseconds = parts.milliseconds;
+		this._locale = locale;
+		if (metadata) {
+			this._startDate = metadata.startDate;
+			this._endDate = metadata.endDate;
+			this._steps = metadata.steps || [];
+			this._mode = metadata.mode || "exact";
+			this._leapYearFlags = metadata.leapYearFlags || [];
+			this._calculationTimeMs = metadata.calculationTimeMs || 0;
+		}
+	}
+	humanize(options) {
+		const locale = options?.locale || this._locale;
+		const fullBreakdown = options?.fullBreakdown ?? false;
+		const numeric = options?.numeric ?? "always";
+		const nonZeroParts = [
+			{
+				unit: "year",
+				value: this.years
+			},
+			{
+				unit: "month",
+				value: this.months
+			},
+			{
+				unit: "week",
+				value: this.weeks
+			},
+			{
+				unit: "day",
+				value: this.days
+			},
+			{
+				unit: "hour",
+				value: this.hours
+			},
+			{
+				unit: "minute",
+				value: this.minutes
+			},
+			{
+				unit: "second",
+				value: this.seconds
+			},
+			{
+				unit: "millisecond",
+				value: this.milliseconds
+			}
+		].filter((p) => p.value > 0);
+		if (nonZeroParts.length === 0) return "0 seconds";
+		if (!fullBreakdown || nonZeroParts.length === 1) {
+			const largest = nonZeroParts[0];
+			try {
+				return new Intl.RelativeTimeFormat(locale, {
+					numeric,
+					style: "long"
+				}).format(largest.value, largest.unit);
+			} catch {
+				return `${largest.value} ${this.pluralizeUnit(largest.unit, largest.value, locale)}`;
+			}
+		}
+		return joinDurationParts(nonZeroParts.map((p) => {
+			const label = getDurationUnitLabel(p.unit, locale, p.value);
+			return `${p.value} ${label}`;
+		}), locale);
+	}
+	total(unit) {
+		let totalMs = 0;
+		totalMs += this.years * MS_PER_YEAR;
+		totalMs += this.months * MS_PER_MONTH;
+		totalMs += this.weeks * MS_PER_WEEK;
+		totalMs += this.days * MS_PER_DAY;
+		totalMs += this.hours * MS_PER_HOUR;
+		totalMs += this.minutes * MS_PER_MINUTE;
+		totalMs += this.seconds * MS_PER_SECOND;
+		totalMs += this.milliseconds;
+		switch (unit) {
+			case "millisecond": return totalMs;
+			case "second": return totalMs / MS_PER_SECOND;
+			case "minute": return totalMs / MS_PER_MINUTE;
+			case "hour": return totalMs / MS_PER_HOUR;
+			case "day": return totalMs / MS_PER_DAY;
+			case "week": return totalMs / MS_PER_WEEK;
+			case "month": return totalMs / MS_PER_MONTH;
+			case "year": return totalMs / MS_PER_YEAR;
+			case "microsecond": return totalMs * 1e3;
+			case "nanosecond": return totalMs * 1e6;
+			default: throw new Error(`Unsupported unit: ${unit}`);
+		}
+	}
+	toString() {
+		return this.humanize({ fullBreakdown: true });
+	}
+	toJSON() {
+		return {
+			years: this.years,
+			months: this.months,
+			weeks: this.weeks,
+			days: this.days,
+			hours: this.hours,
+			minutes: this.minutes,
+			seconds: this.seconds,
+			milliseconds: this.milliseconds
+		};
+	}
+	explain() {
+		let steps = [...this._steps];
+		if (steps.length === 0) steps = this.generateExplanationSteps();
+		const explanationParts = [];
+		if (this._startDate && this._endDate) explanationParts.push(`Calculated duration from ${this._startDate} to ${this._endDate}`);
+		if (this._leapYearFlags && this._leapYearFlags.length > 0) {
+			const leapYears = this._leapYearFlags.filter((f) => f.isLeap).map((f) => f.year);
+			if (leapYears.length > 0) explanationParts.push(`Leap year(s) detected: ${leapYears.join(", ")}`);
+		}
+		explanationParts.push(`Breakdown: ${this.years} year(s), ${this.months} month(s), ${this.days} day(s)`);
+		explanationParts.push(`Mode: ${this._mode} calculation`);
+		return {
+			input: this._startDate && this._endDate ? [this._startDate, this._endDate] : [],
+			steps,
+			breakdown: {
+				years: this.years,
+				months: this.months,
+				weeks: this.weeks,
+				days: this.days,
+				hours: this.hours,
+				minutes: this.minutes,
+				seconds: this.seconds,
+				milliseconds: this.milliseconds
+			},
+			mode: this._mode,
+			explanation: explanationParts.join(". "),
+			locale: this._locale,
+			leapYearFlags: this._leapYearFlags.length > 0 ? this._leapYearFlags : void 0,
+			metadata: {
+				calculationTimeMs: this._calculationTimeMs,
+				precision: "day"
+			}
+		};
+	}
+	generateExplanationSteps() {
+		const steps = [];
+		if (this._startDate && this._endDate) steps.push(`Input: ${this._startDate} to ${this._endDate}`);
+		else steps.push("Duration calculation started");
+		if (this.years > 0) steps.push(`Years: ${this.years}`);
+		if (this.months > 0) steps.push(`Months: ${this.months}`);
+		if (this.weeks > 0) steps.push(`Weeks: ${this.weeks}`);
+		if (this.days > 0) steps.push(`Days: ${this.days}`);
+		if (this.hours > 0) steps.push(`Hours: ${this.hours}`);
+		if (this.minutes > 0) steps.push(`Minutes: ${this.minutes}`);
+		if (this.seconds > 0) steps.push(`Seconds: ${this.seconds}`);
+		if (this.milliseconds > 0) steps.push(`Milliseconds: ${this.milliseconds}`);
+		if (this._leapYearFlags && this._leapYearFlags.length > 0) {
+			for (const flag of this._leapYearFlags) if (flag.isLeap) steps.push(`${flag.year} is a leap year (February has ${flag.daysInFebruary} days)`);
+		}
+		const totalParts = [
+			this.years > 0 ? `${this.years}y` : "",
+			this.months > 0 ? `${this.months}m` : "",
+			this.days > 0 ? `${this.days}d` : "",
+			this.hours > 0 ? `${this.hours}h` : "",
+			this.minutes > 0 ? `${this.minutes}min` : "",
+			this.seconds > 0 ? `${this.seconds}s` : ""
+		].filter((p) => p.length > 0).join(" ");
+		steps.push(`Total: ${totalParts || "0"}`);
+		return steps;
+	}
+	pluralizeUnit(unit, count, locale) {
+		return getDurationUnitLabel(unit, locale, count);
+	}
+};
+/**
+* TimeRange - Fluent API for date range operations
+*
+* @example
+* TimeGuard.range('2024-01-15', '2024-03-20')
+*   .toDuration().humanize()        // "2 months and 5 days"
+*   .inMonths()                     // 2.1355 (precise decimal)
+*/
+var TimeRange = class TimeRange {
+	_start;
+	_end;
+	constructor(start, end) {
+		this._start = start;
+		this._end = end;
+	}
+	get start() {
+		return this._start;
+	}
+	get end() {
+		return this._end;
+	}
+	getOrdered() {
+		const t1 = TemporalAdapter.toPlainDateTime(this._start.toTemporal());
+		const t2 = TemporalAdapter.toPlainDateTime(this._end.toTemporal());
+		return TemporalAdapter.compare(t1, t2) <= 0 ? [t1, t2] : [t2, t1];
+	}
+	toDuration() {
+		return TimeGuard.between(this._start, this._end);
+	}
+	inMonths() {
+		return this.toDuration().total("month");
+	}
+	humanize(options) {
+		return this.toDuration().humanize(options);
+	}
+	in(unit) {
+		return this.toDuration().total(unit);
+	}
+	contains(date) {
+		const tg = date instanceof TimeGuard ? date : new TimeGuard(date);
+		const t = TemporalAdapter.toPlainDateTime(tg.toTemporal());
+		const [startT, endT] = this.getOrdered();
+		return TemporalAdapter.compare(t, startT) >= 0 && TemporalAdapter.compare(t, endT) <= 0;
+	}
+	overlaps(other) {
+		const [s1, e1] = this.getOrdered();
+		const [s2, e2] = other.getOrdered();
+		return TemporalAdapter.compare(s1, e2) <= 0 && TemporalAdapter.compare(s2, e1) <= 0;
+	}
+	intersect(other) {
+		if (!this.overlaps(other)) return null;
+		const [s1, e1] = this.getOrdered();
+		const [s2, e2] = other.getOrdered();
+		const startT = TemporalAdapter.compare(s1, s2) >= 0 ? s1 : s2;
+		const endT = TemporalAdapter.compare(e1, e2) <= 0 ? e1 : e2;
+		return new TimeRange(TimeGuard.fromTemporal(startT, { locale: this._start.locale() }), TimeGuard.fromTemporal(endT, { locale: this._end.locale() }));
+	}
+	union(other) {
+		const [s1, e1] = this.getOrdered();
+		const [s2, e2] = other.getOrdered();
+		const startT = TemporalAdapter.compare(s1, s2) <= 0 ? s1 : s2;
+		const endT = TemporalAdapter.compare(e1, e2) >= 0 ? e1 : e2;
+		return new TimeRange(TimeGuard.fromTemporal(startT, { locale: this._start.locale() }), TimeGuard.fromTemporal(endT, { locale: this._end.locale() }));
+	}
+};
+/**
+* TimeGuard implementation - Main facade class
+*/
+var TimeGuard = class TimeGuard {
+	temporal;
+	config;
+	formatterInstance;
+	static holidays = /* @__PURE__ */ new Set();
+	static registerHolidays(dates) {
+		dates.forEach((d) => {
+			try {
+				const tg = new TimeGuard(d);
+				this.holidays.add(tg.format("YYYY-MM-DD"));
+			} catch {}
+		});
+	}
+	static clearHolidays() {
+		this.holidays.clear();
+	}
+	static getRegisteredHolidays() {
+		return Array.from(this.holidays).sort();
+	}
+	static ZERO_DURATION = {
+		years: 0,
+		months: 0,
+		weeks: 0,
+		days: 0,
+		hours: 0,
+		minutes: 0,
+		seconds: 0,
+		milliseconds: 0
+	};
+	static isLeapYearValue(year) {
+		return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+	}
+	static toDurationParts(duration) {
+		return {
+			years: Math.floor(duration.years || 0),
+			months: Math.floor(duration.months || 0),
+			weeks: Math.floor(duration.weeks || 0),
+			days: Math.floor(duration.days || 0),
+			hours: Math.floor(duration.hours || 0),
+			minutes: Math.floor(duration.minutes || 0),
+			seconds: Math.floor(duration.seconds || 0),
+			milliseconds: Math.floor(duration.milliseconds || 0)
+		};
+	}
+	constructor(input, config) {
+		this.formatterInstance = new DateFormatter();
+		this.config = {
+			locale: config?.locale || "en",
+			timezone: config?.timezone || "UTC",
+			strict: config?.strict ?? false
+		};
+		this.temporal = TemporalAdapter.parseToPlainDateTime(input);
+		if (this.config.timezone && this.config.timezone !== "UTC") try {
+			const zoned = this.temporal.toZonedDateTime(this.config.timezone);
+			this.temporal = zoned;
+		} catch {}
+	}
+	static now(config) {
+		return new TimeGuard(void 0, config);
+	}
+	static from(input, config) {
+		return new TimeGuard(input, config);
+	}
+	static fromTemporal(temporal, config) {
+		const instance = new TimeGuard(void 0, config);
+		instance.temporal = temporal;
+		return instance;
+	}
+	/**
+	* Calculate duration between two dates - always returns positive duration
+	*
+	* @example
+	* TimeGuard.between(start, end).humanize() // "2 months and 5 days"
+	* TimeGuard.between(end, start).humanize() // "2 months and 5 days" (still positive)
+	*/
+	static between(date1, date2) {
+		const t1 = TemporalAdapter.toPlainDateTime(date1.temporal);
+		const t2 = TemporalAdapter.toPlainDateTime(date2.temporal);
+		const [earlier, later] = TemporalAdapter.compare(t1, t2) <= 0 ? [date1, date2] : [date2, date1];
+		return earlier.until(later);
+	}
+	/**
+	* Create a TimeRange for fluent duration calculations
+	*
+	* @example
+	* TimeGuard.range("2024-01-15", "2024-03-20").humanize() // "2 months and 5 days"
+	*/
+	static range(start, end) {
+		return new TimeRange(start instanceof TimeGuard ? start : new TimeGuard(start), end instanceof TimeGuard ? end : new TimeGuard(end));
+	}
+	toTemporal() {
+		return this.temporal;
+	}
+	toDate() {
+		return TemporalAdapter.toDate(this.temporal);
+	}
+	toISOString() {
+		return TemporalAdapter.toISOString(this.temporal);
+	}
+	valueOf() {
+		return TemporalAdapter.toUnix(this.temporal);
+	}
+	unix() {
+		return Math.floor(this.valueOf() / 1e3);
+	}
+	toJSON() {
+		return this.toISOString();
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return this.valueOf();
+		if (hint === "string") return this.toISOString();
+		return this.toISOString();
+	}
+	toString() {
+		return this.format("YYYY-MM-DD HH:mm:ss");
+	}
+	locale(locale) {
+		if (locale === void 0) return this.config.locale;
+		const cloned = this.clone();
+		cloned.config.locale = locale;
+		return cloned;
+	}
+	timezone(timezone) {
+		if (timezone === void 0) return this.config.timezone;
+		const cloned = this.clone();
+		cloned.config.timezone = timezone;
+		try {
+			cloned.temporal = TemporalAdapter.toPlainDateTime(cloned.temporal).toZonedDateTime(timezone);
+		} catch {}
+		return cloned;
+	}
+	format(pattern) {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		const formatPattern = [
+			"iso",
+			"date",
+			"time",
+			"datetime",
+			"rfc2822",
+			"rfc3339",
+			"utc"
+		].includes(pattern) ? this.formatterInstance.getPreset(pattern) : pattern;
+		return this.formatterInstance.format(plainDT, formatPattern, this.config.locale);
+	}
+	get(component) {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		const unitMap = {
+			year: "year",
+			month: "month",
+			week: "year",
+			day: "day",
+			hour: "hour",
+			minute: "minute",
+			second: "second",
+			millisecond: "millisecond",
+			microsecond: "microsecond",
+			nanosecond: "nanosecond"
+		};
+		if (component === "week") return plainDT.weekOfYear;
+		return plainDT[unitMap[component]];
+	}
+	/** Map from singular Unit to plural Temporal polyfill key */
+	static UNIT_TO_PLURAL = {
+		year: "years",
+		month: "months",
+		week: "weeks",
+		day: "days",
+		hour: "hours",
+		minute: "minutes",
+		second: "seconds",
+		millisecond: "milliseconds",
+		microsecond: "microseconds",
+		nanosecond: "nanoseconds",
+		years: "years",
+		months: "months",
+		weeks: "weeks",
+		days: "days",
+		hours: "hours",
+		minutes: "minutes",
+		seconds: "seconds",
+		milliseconds: "milliseconds",
+		microseconds: "microseconds",
+		nanoseconds: "nanoseconds"
+	};
+	add(units) {
+		let plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		const duration = {
+			years: 0,
+			months: 0,
+			weeks: 0,
+			days: 0,
+			hours: 0,
+			minutes: 0,
+			seconds: 0,
+			milliseconds: 0,
+			microseconds: 0,
+			nanoseconds: 0
+		};
+		let hasValidFields = false;
+		Object.entries(units).forEach(([unit, value]) => {
+			if (value !== void 0 && value !== 0) {
+				const num = Number(value);
+				if (Number.isFinite(num)) {
+					const targetKey = TimeGuard.UNIT_TO_PLURAL[unit] || unit;
+					duration[targetKey] = Math.trunc(num);
+					hasValidFields = true;
+				}
+			}
+		});
+		if (!hasValidFields) return this;
+		plainDT = plainDT.add(duration);
+		return TimeGuard.fromTemporal(plainDT, this.config);
+	}
+	subtract(units) {
+		const negated = {};
+		Object.entries(units).forEach(([unit, value]) => {
+			negated[unit] = value ? -value : 0;
+		});
+		return this.add(negated);
+	}
+	diff(other, unitOrOptions) {
+		const plainDT1 = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainDT2 = TemporalAdapter.toPlainDateTime(other.temporal);
+		const unitMap = {
+			year: "years",
+			month: "months",
+			week: "weeks",
+			day: "days",
+			hour: "hours",
+			minute: "minutes",
+			second: "seconds",
+			millisecond: "milliseconds",
+			microsecond: "microseconds",
+			nanosecond: "nanoseconds"
+		};
+		if (typeof unitOrOptions === "string") {
+			const unit = unitOrOptions;
+			const mappedUnit = unitMap[unit];
+			const durationObj = plainDT1.since(plainDT2, { smallestUnit: unit });
+			return Math.round(durationObj[mappedUnit] || 0);
+		}
+		const options = unitOrOptions || {};
+		const mode = options.mode || "exact";
+		const unit = options.unit || "millisecond";
+		const locale = options.locale || this.config.locale;
+		if (mode === "exact") {
+			const mappedUnit = unitMap[unit];
+			const duration = plainDT1.since(plainDT2, { smallestUnit: unit });
+			const result = Math.round(duration[mappedUnit] || 0);
+			if (unitOrOptions === void 0 || typeof unitOrOptions === "object") {
+				const totalMs = calculateTotalMs(duration);
+				return new DiffResult(Math.round(totalMs), this, other, mode, void 0, locale);
+			}
+			return result;
+		}
+		if (mode === "calendar") {
+			const duration = plainDT1.since(plainDT2, {
+				largestUnit: "month",
+				smallestUnit: "millisecond"
+			});
+			const breakdownData = {
+				years: Math.floor(duration.years || 0),
+				months: Math.floor(duration.months || 0),
+				weeks: Math.floor(duration.weeks || 0),
+				days: Math.floor(duration.days || 0),
+				hours: Math.floor(duration.hours || 0),
+				minutes: Math.floor(duration.minutes || 0),
+				seconds: Math.floor(duration.seconds || 0),
+				milliseconds: Math.floor(duration.milliseconds || 0)
+			};
+			const totalMs = calculateTotalMs(duration);
+			return new DiffResult(Math.round(totalMs), this, other, mode, breakdownData, locale);
+		}
+		const totalMs = calculateTotalMs(plainDT1.since(plainDT2, { smallestUnit: "millisecond" }));
+		return new DiffResult(Math.round(totalMs), this, other, mode, void 0, locale);
+	}
+	isBefore(other) {
+		const plainDT1 = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainDT2 = TemporalAdapter.toPlainDateTime(other.temporal);
+		return TemporalAdapter.compare(plainDT1, plainDT2) < 0;
+	}
+	isAfter(other) {
+		const plainDT1 = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainDT2 = TemporalAdapter.toPlainDateTime(other.temporal);
+		return TemporalAdapter.compare(plainDT1, plainDT2) > 0;
+	}
+	isSame(other, unit) {
+		if (!unit) return TemporalAdapter.compare(TemporalAdapter.toPlainDateTime(this.temporal), TemporalAdapter.toPlainDateTime(other.temporal)) === 0;
+		const plainDT1 = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainDT2 = TemporalAdapter.toPlainDateTime(other.temporal);
+		switch (unit) {
+			case "year": return plainDT1.year === plainDT2.year;
+			case "month": return plainDT1.year === plainDT2.year && plainDT1.month === plainDT2.month;
+			case "day": return plainDT1.year === plainDT2.year && plainDT1.month === plainDT2.month && plainDT1.day === plainDT2.day;
+			case "hour": return plainDT1.year === plainDT2.year && plainDT1.month === plainDT2.month && plainDT1.day === plainDT2.day && plainDT1.hour === plainDT2.hour;
+			case "minute": return plainDT1.year === plainDT2.year && plainDT1.month === plainDT2.month && plainDT1.day === plainDT2.day && plainDT1.hour === plainDT2.hour && plainDT1.minute === plainDT2.minute;
+			case "second": return plainDT1.year === plainDT2.year && plainDT1.month === plainDT2.month && plainDT1.day === plainDT2.day && plainDT1.hour === plainDT2.hour && plainDT1.minute === plainDT2.minute && plainDT1.second === plainDT2.second;
+			default: return false;
+		}
+	}
+	isBetween(start, end, unit, inclusivity = "[]") {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainStart = TemporalAdapter.toPlainDateTime(start.temporal);
+		const plainEnd = TemporalAdapter.toPlainDateTime(end.temporal);
+		let afterStart = true;
+		let beforeEnd = true;
+		if (unit) {
+			const startCopy = this.clone().startOf(unit);
+			const endCopy = this.clone().endOf(unit);
+			const plainCopy = TemporalAdapter.toPlainDateTime(startCopy.temporal);
+			const plainEndCopy = TemporalAdapter.toPlainDateTime(endCopy.temporal);
+			afterStart = TemporalAdapter.compare(plainCopy, plainStart) >= 0;
+			beforeEnd = TemporalAdapter.compare(plainEndCopy, plainEnd) <= 0;
+		} else {
+			afterStart = TemporalAdapter.compare(plainDT, plainStart) >= 0;
+			beforeEnd = TemporalAdapter.compare(plainDT, plainEnd) <= 0;
+		}
+		const hasStartBracket = inclusivity[0] === "[";
+		const hasEndBracket = inclusivity[1] === "]";
+		return (hasStartBracket ? afterStart : TemporalAdapter.compare(plainDT, plainStart) > 0) && (hasEndBracket ? beforeEnd : TemporalAdapter.compare(plainDT, plainEnd) < 0);
+	}
+	clone() {
+		return new TimeGuard(this.toDate(), this.config);
+	}
+	startOf(unit) {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		const values = {};
+		switch (unit) {
+			case "year":
+				values.month = 1;
+				values.day = 1;
+				values.hour = 0;
+				values.minute = 0;
+				values.second = 0;
+				values.millisecond = 0;
+				break;
+			case "month":
+				values.day = 1;
+				values.hour = 0;
+				values.minute = 0;
+				values.second = 0;
+				values.millisecond = 0;
+				break;
+			case "week":
+			case "day":
+				values.hour = 0;
+				values.minute = 0;
+				values.second = 0;
+				values.millisecond = 0;
+				break;
+			case "hour":
+				values.minute = 0;
+				values.second = 0;
+				values.millisecond = 0;
+				break;
+			case "minute":
+				values.second = 0;
+				values.millisecond = 0;
+				break;
+			case "second":
+				values.millisecond = 0;
+				break;
+		}
+		const updated = plainDT.with(values);
+		return TimeGuard.fromTemporal(updated, this.config);
+	}
+	endOf(unit) {
+		return this.startOf(unit).add({ [unit]: 1 }).subtract({ millisecond: 1 });
+	}
+	set(values) {
+		const updated = TemporalAdapter.toPlainDateTime(this.temporal).with(values);
+		return TimeGuard.fromTemporal(updated, this.config);
+	}
+	year() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).year;
+	}
+	month() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).month;
+	}
+	day() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).day;
+	}
+	hour() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).hour;
+	}
+	minute() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).minute;
+	}
+	second() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).second;
+	}
+	millisecond() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).millisecond;
+	}
+	dayOfWeek() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).dayOfWeek;
+	}
+	dayOfYear() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).dayOfYear;
+	}
+	weekOfYear() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).weekOfYear;
+	}
+	daysInMonth() {
+		return TemporalAdapter.toPlainDateTime(this.temporal).add({ months: 1 }).with({ day: 1 }).subtract({ days: 1 }).day;
+	}
+	daysInYear() {
+		const year = this.year();
+		return TimeGuard.isLeapYearValue(year) ? 366 : 365;
+	}
+	inLeapYear() {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		return TimeGuard.isLeapYearValue(plainDT.year);
+	}
+	until(other, options) {
+		const plainDT1 = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainDT2 = TemporalAdapter.toPlainDateTime(other.temporal);
+		const startTime = performance.now();
+		try {
+			const temporalOptions = {};
+			if (options?.largestUnit) temporalOptions.largestUnit = options.largestUnit;
+			if (options?.smallestUnit) temporalOptions.smallestUnit = options.smallestUnit;
+			const duration = plainDT2.since(plainDT1, Object.keys(temporalOptions).length > 0 ? temporalOptions : void 0);
+			const parts = TimeGuard.toDurationParts(duration);
+			const startYear = plainDT1.year;
+			const endYear = plainDT2.year;
+			const leapYearFlags = [];
+			for (let year = startYear; year <= endYear; year++) {
+				const isLeap = TimeGuard.isLeapYearValue(year);
+				leapYearFlags.push({
+					year,
+					isLeap,
+					daysInFebruary: isLeap ? 29 : 28
+				});
+			}
+			const steps = this.generateUntilSteps(plainDT1, plainDT2, parts, leapYearFlags);
+			const calculationTimeMs = performance.now() - startTime;
+			return new DurationResult(parts, this.config.locale, {
+				startDate: plainDT1.toString(),
+				endDate: plainDT2.toString(),
+				steps,
+				mode: "exact",
+				leapYearFlags: leapYearFlags.filter((f) => f.isLeap),
+				calculationTimeMs
+			});
+		} catch {
+			return new DurationResult(TimeGuard.ZERO_DURATION, this.config.locale, {
+				startDate: plainDT1.toString(),
+				endDate: plainDT2.toString(),
+				steps: ["Calculation failed, returning zero duration"],
+				mode: "estimated"
+			});
+		}
+	}
+	generateUntilSteps(start, end, parts, leapYearFlags) {
+		const steps = [];
+		steps.push(`Parsed dates: ${start.year}-${String(start.month).padStart(2, "0")}-${String(start.day).padStart(2, "0")} (day ${start.dayOfYear} of ${TimeGuard.isLeapYearValue(start.year) ? 366 : 365})`);
+		steps.push(`to ${end.year}-${String(end.month).padStart(2, "0")}-${String(end.day).padStart(2, "0")} (day ${end.dayOfYear} of ${TimeGuard.isLeapYearValue(end.year) ? 366 : 365})`);
+		const leapYearsInRange = leapYearFlags.filter((f) => f.isLeap);
+		if (leapYearsInRange.length > 0) for (const flag of leapYearsInRange) steps.push(`${flag.year} is a leap year (February has ${flag.daysInFebruary} days)`);
+		if (parts.years > 0) steps.push(`Years: ${parts.years}`);
+		if (parts.months > 0) steps.push(`Months: ${parts.months}`);
+		if (parts.days > 0) steps.push(`Days: ${parts.days}`);
+		if (parts.hours > 0 || parts.minutes > 0 || parts.seconds > 0) {
+			const timeComponents = [];
+			if (parts.hours > 0) timeComponents.push(`${parts.hours}h`);
+			if (parts.minutes > 0) timeComponents.push(`${parts.minutes}m`);
+			if (parts.seconds > 0) timeComponents.push(`${parts.seconds}s`);
+			steps.push(`Time: ${timeComponents.join(" ")}`);
+		}
+		const totalDays = parts.years * 365.25 + parts.months * 30.4375 + parts.days + parts.hours / 24;
+		steps.push(`Total: approximately ${totalDays.toFixed(2)} days`);
+		return steps;
+	}
+	round(options = {}) {
+		const { smallestUnit = "millisecond", roundingMode = "halfExpand" } = options;
+		const polyfillDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		const unitValues = {
+			year: polyfillDT.year,
+			month: polyfillDT.month,
+			day: polyfillDT.day,
+			hour: polyfillDT.hour,
+			minute: polyfillDT.minute,
+			second: polyfillDT.second,
+			millisecond: polyfillDT.millisecond,
+			microsecond: polyfillDT.microsecond || 0,
+			nanosecond: polyfillDT.nanosecond || 0,
+			week: 0
+		};
+		const unitOrder = [
+			"year",
+			"month",
+			"day",
+			"hour",
+			"minute",
+			"second",
+			"millisecond",
+			"microsecond",
+			"nanosecond"
+		];
+		const smallestIndex = unitOrder.indexOf(smallestUnit);
+		if (smallestIndex === -1) return this.clone();
+		const roundedValues = {};
+		for (let i = 0; i < smallestIndex; i++) {
+			const unit = unitOrder[i];
+			roundedValues[unit] = unitValues[unit];
+		}
+		const unit = unitOrder[smallestIndex];
+		let value = unitValues[unit];
+		if (smallestIndex + 1 < unitOrder.length) {
+			const nextUnitValue = unitValues[unitOrder[smallestIndex + 1]];
+			const shouldRoundUp = (mode, nextVal) => {
+				switch (mode) {
+					case "ceil": return nextVal > 0;
+					case "floor":
+					case "trunc": return false;
+					case "halfExpand":
+					case "halfFloor":
+					case "halfCeil": return nextVal >= 5;
+					case "expand": return nextVal > 0;
+					default: return nextVal >= 5;
+				}
+			};
+			if (shouldRoundUp(roundingMode, nextUnitValue)) value += 1;
+		}
+		roundedValues[unit] = value;
+		for (let i = smallestIndex + 1; i < unitOrder.length; i++) roundedValues[unitOrder[i]] = 0;
+		return this.set(roundedValues);
+	}
+	toPlainDate() {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		return {
+			year: plainDT.year,
+			month: plainDT.month,
+			day: plainDT.day,
+			dayOfWeek: plainDT.dayOfWeek
+		};
+	}
+	toPlainTime() {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		return {
+			hour: plainDT.hour,
+			minute: plainDT.minute,
+			second: plainDT.second,
+			millisecond: plainDT.millisecond
+		};
+	}
+	withDate(year, month, day) {
+		return this.set({
+			year,
+			month,
+			day
+		});
+	}
+	withTime(hour, minute = 0, second = 0, millisecond = 0) {
+		return this.set({
+			hour,
+			minute,
+			second,
+			millisecond
+		});
+	}
+	getOffset() {
+		return this.temporal?.offset || "Z";
+	}
+	getOffsetNanoseconds() {
+		return this.temporal?.offsetNanoseconds || 0;
+	}
+	getTimeZoneId() {
+		return this.temporal?.timeZoneId || null;
+	}
+	startOfDay() {
+		return this.startOf("day");
+	}
+	endOfDay() {
+		return this.endOf("day");
+	}
+	since(other, options) {
+		const plainDT1 = TemporalAdapter.toPlainDateTime(this.temporal);
+		const plainDT2 = TemporalAdapter.toPlainDateTime(other.temporal);
+		const startTime = performance.now();
+		try {
+			const temporalOptions = {};
+			if (options?.largestUnit) temporalOptions.largestUnit = options.largestUnit;
+			if (options?.smallestUnit) temporalOptions.smallestUnit = options.smallestUnit;
+			const duration = plainDT1.since(plainDT2, Object.keys(temporalOptions).length > 0 ? temporalOptions : void 0);
+			const parts = TimeGuard.toDurationParts(duration);
+			const startYear = plainDT2.year;
+			const endYear = plainDT1.year;
+			const leapYearFlags = [];
+			for (let year = startYear; year <= endYear; year++) {
+				const isLeap = TimeGuard.isLeapYearValue(year);
+				leapYearFlags.push({
+					year,
+					isLeap,
+					daysInFebruary: isLeap ? 29 : 28
+				});
+			}
+			const steps = this.generateUntilSteps(plainDT2, plainDT1, parts, leapYearFlags);
+			const calculationTimeMs = performance.now() - startTime;
+			return new DurationResult(parts, this.config.locale, {
+				startDate: plainDT2.toString(),
+				endDate: plainDT1.toString(),
+				steps,
+				mode: "exact",
+				leapYearFlags: leapYearFlags.filter((f) => f.isLeap),
+				calculationTimeMs
+			});
+		} catch {
+			return new DurationResult(TimeGuard.ZERO_DURATION, this.config.locale, {
+				startDate: plainDT2.toString(),
+				endDate: plainDT1.toString(),
+				steps: ["Calculation failed, returning zero duration"],
+				mode: "estimated"
+			});
+		}
+	}
+	toDurationString(other) {
+		const duration = other ? this.until(other) : this.until(TimeGuard.now());
+		const parts = [];
+		if (duration.years) parts.push(`${duration.years}Y`);
+		if (duration.months) parts.push(`${duration.months}M`);
+		if (duration.days) parts.push(`${duration.days}D`);
+		const timeParts = [];
+		if (duration.hours) timeParts.push(`${duration.hours}H`);
+		if (duration.minutes) timeParts.push(`${duration.minutes}M`);
+		if (duration.seconds) timeParts.push(`${duration.seconds}S`);
+		const result = `P${parts.join("")}${timeParts.length > 0 ? "T" + timeParts.join("") : ""}`;
+		return result === "P" ? "PT0S" : result;
+	}
+	isPast() {
+		return this.isBefore(TimeGuard.now());
+	}
+	isFuture() {
+		return this.isAfter(TimeGuard.now());
+	}
+	isToday() {
+		return this.isSame(TimeGuard.now(), "day");
+	}
+	isTomorrow() {
+		return this.isSame(TimeGuard.now().add({ day: 1 }), "day");
+	}
+	isYesterday() {
+		return this.isSame(TimeGuard.now().subtract({ day: 1 }), "day");
+	}
+	isWeekend() {
+		const plainDT = TemporalAdapter.toPlainDateTime(this.temporal);
+		return plainDT.dayOfWeek === 6 || plainDT.dayOfWeek === 7;
+	}
+	isHoliday() {
+		const dateStr = this.format("YYYY-MM-DD");
+		return TimeGuard.holidays.has(dateStr);
+	}
+	isBusinessDay() {
+		return !this.isWeekend() && !this.isHoliday();
+	}
+	addBusinessDays(days) {
+		const num = Math.trunc(days);
+		if (!Number.isFinite(num) || num === 0) return this;
+		let cloned = this.clone();
+		let remaining = Math.abs(num);
+		const step = num > 0 ? 1 : -1;
+		while (remaining > 0) {
+			cloned = cloned.add({ day: step });
+			if (cloned.isBusinessDay()) remaining--;
+		}
+		return cloned;
+	}
+	subtractBusinessDays(days) {
+		return this.addBusinessDays(-days);
+	}
+};
+function timeGuard(input, config) {
+	return new TimeGuard(input, config);
+}
+/** The current version of TimeGuard */
+var version = "2.7.0";
+//#endregion
+Object.defineProperty(exports, "CalendarManager", {
+	enumerable: true,
+	get: function() {
+		return CalendarManager;
+	}
+});
+Object.defineProperty(exports, "DateFormatter", {
+	enumerable: true,
+	get: function() {
+		return DateFormatter;
+	}
+});
+Object.defineProperty(exports, "DurationResult", {
+	enumerable: true,
+	get: function() {
+		return DurationResult;
+	}
+});
+Object.defineProperty(exports, "EN_LOCALE", {
+	enumerable: true,
+	get: function() {
+		return EN_LOCALE;
+	}
+});
+Object.defineProperty(exports, "ES_LOCALE", {
+	enumerable: true,
+	get: function() {
+		return ES_LOCALE;
+	}
+});
+Object.defineProperty(exports, "GregorianCalendar", {
+	enumerable: true,
+	get: function() {
+		return GregorianCalendar;
+	}
+});
+Object.defineProperty(exports, "LocaleManager", {
+	enumerable: true,
+	get: function() {
+		return LocaleManager;
+	}
+});
+Object.defineProperty(exports, "PluginManager", {
+	enumerable: true,
+	get: function() {
+		return PluginManager;
+	}
+});
+Object.defineProperty(exports, "TemporalAdapter", {
+	enumerable: true,
+	get: function() {
+		return TemporalAdapter;
+	}
+});
+Object.defineProperty(exports, "TimeGuard", {
+	enumerable: true,
+	get: function() {
+		return TimeGuard;
+	}
+});
+Object.defineProperty(exports, "TimeRange", {
+	enumerable: true,
+	get: function() {
+		return TimeRange;
+	}
+});
+Object.defineProperty(exports, "calendarManager", {
+	enumerable: true,
+	get: function() {
+		return calendarManager;
+	}
+});
+Object.defineProperty(exports, "timeGuard", {
+	enumerable: true,
+	get: function() {
+		return timeGuard;
+	}
+});
+Object.defineProperty(exports, "version", {
+	enumerable: true,
+	get: function() {
+		return version;
+	}
+});