@craftguild/jscalendar 0.5.2 → 0.5.4

package/dist/index.cjs

@@ -0,0 +1,3923 @@
+let date_fns = require("date-fns");
+let date_fns_tz = require("date-fns-tz");
+
+//#region src/utils.ts
+const TYPEOF_FUNCTION$1 = "function";
+const TYPEOF_STRING = "string";
+const TYPEOF_NUMBER = "number";
+const TYPEOF_BOOLEAN = "boolean";
+const TYPEOF_OBJECT = "object";
+/**
+* Check whether a value is a string.
+* @param value Value to check.
+* @return True if the value is a string.
+*/
+function isStringValue(value) {
+	return typeof value === TYPEOF_STRING;
+}
+/**
+* Check whether a value is a number.
+* @param value Value to check.
+* @return True if the value is a number.
+*/
+function isNumberValue(value) {
+	return typeof value === TYPEOF_NUMBER;
+}
+/**
+* Check whether a value is a boolean.
+* @param value Value to check.
+* @return True if the value is a boolean.
+*/
+function isBooleanValue(value) {
+	return typeof value === TYPEOF_BOOLEAN;
+}
+/**
+* Check whether a value is a non-null object.
+* @param value Value to check.
+* @return True if the value is a non-null object.
+*/
+function isObjectValue(value) {
+	return value !== null && typeof value === TYPEOF_OBJECT;
+}
+/**
+* Get the current UTC date-time string.
+* @return Current time as UTCDateTime.
+*/
+function nowUtc() {
+	return normalizeUtcDateTime((/* @__PURE__ */ new Date()).toISOString());
+}
+/**
+* Deep-clone a value using structuredClone.
+* @param value Value to clone.
+* @return Deep clone of the input value.
+*/
+function deepClone(value) {
+	if (typeof structuredClone === TYPEOF_FUNCTION$1) return structuredClone(value);
+	throw new Error("structuredClone is not available in this environment");
+}
+/**
+* Check if a string is a UTCDateTime with Z suffix.
+* @param value Date-time string.
+* @return True if the value ends with Z.
+*/
+function isUtcDateTime(value) {
+	return /Z$/.test(value);
+}
+/**
+* Compare two date-time strings, returning null when incomparable.
+* @param a Date-time string A.
+* @param b Date-time string B.
+* @return -1, 0, 1, or null when formats are incompatible.
+*/
+function compareDateTime(a, b) {
+	const aUtc = isUtcDateTime(a);
+	const bUtc = isUtcDateTime(b);
+	if (aUtc && bUtc) {
+		const aMs = Date.parse(a);
+		const bMs = Date.parse(b);
+		if (Number.isNaN(aMs) || Number.isNaN(bMs)) return null;
+		return aMs === bMs ? 0 : aMs < bMs ? -1 : 1;
+	}
+	if (!aUtc && !bUtc) {
+		if (a === b) return 0;
+		return a < b ? -1 : 1;
+	}
+	return null;
+}
+/**
+* Convert a duration string to milliseconds.
+* @param duration Duration string.
+* @return Milliseconds or null when invalid.
+*/
+function durationToMilliseconds(duration) {
+	const match = /^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(duration);
+	if (!match) return null;
+	const weeks = Number(match[1] || 0);
+	const days = Number(match[2] || 0);
+	const hours = Number(match[3] || 0);
+	const minutes = Number(match[4] || 0);
+	const seconds = Number(match[5] || 0);
+	return (weeks * 7 * 24 * 60 * 60 + days * 24 * 60 * 60 + hours * 60 * 60 + minutes * 60 + seconds) * 1e3;
+}
+/**
+* Normalize a UTCDateTime by trimming trailing fractional zeros.
+* @param value UTCDateTime string.
+* @return Normalized UTCDateTime string.
+*/
+function normalizeUtcDateTime(value) {
+	var _match$, _match$2;
+	const match = value.match(/^(.*)\.(\d+)Z$/);
+	if (!match) return value;
+	const prefix = (_match$ = match[1]) !== null && _match$ !== void 0 ? _match$ : value;
+	const trimmed = ((_match$2 = match[2]) !== null && _match$2 !== void 0 ? _match$2 : "").replace(/0+$/, "");
+	if (trimmed.length === 0) return `${prefix}Z`;
+	return `${prefix}.${trimmed}Z`;
+}
+/**
+* Format a Date as LocalDateTime string.
+* @param value Date to format.
+* @return LocalDateTime string.
+*/
+function localDateTimeFromDate(value) {
+	return (0, date_fns.format)(value, "yyyy-MM-dd'T'HH:mm:ss");
+}
+/**
+* Format a Date as a LocalDateTime in a target time zone.
+* @param value Date to format.
+* @param timeZone IANA time zone.
+* @return LocalDateTime string in the time zone.
+*/
+function dateTimeInTimeZone(value, timeZone) {
+	return (0, date_fns_tz.formatInTimeZone)(value, timeZone, "yyyy-MM-dd'T'HH:mm:ss");
+}
+/**
+* Convert LocalDateTime string to a UTC Date using a time zone.
+* @param value LocalDateTime string.
+* @param timeZone IANA time zone.
+* @return Date in UTC.
+*/
+function localDateTimeToUtcDate(value, timeZone) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(value);
+	if (!match) throw new Error(`Invalid LocalDateTime: ${value}`);
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	const hour = Number(match[4]);
+	const minute = Number(match[5]);
+	const second = Number(match[6]);
+	return (0, date_fns_tz.fromZonedTime)(new Date(year, month - 1, day, hour, minute, second), timeZone);
+}
+
+//#endregion
+//#region src/ical.ts
+const TYPE_EVENT$4 = "Event";
+const TYPE_GROUP$3 = "Group";
+const TYPE_TASK$4 = "Task";
+const DEFAULT_PRODID = "-//craftguild//EN";
+/**
+* Convert JSCalendar objects into an iCalendar string.
+* @param objects JSCalendar objects to export.
+* @param options Export options.
+* @return iCalendar text.
+*/
+function toICal(objects, options = {}) {
+	var _options$prodId, _options$method;
+	const lines = [];
+	const includeX = options.includeXJSCalendar !== false;
+	lines.push("BEGIN:VCALENDAR");
+	lines.push("VERSION:2.0");
+	lines.push(`PRODID:${(_options$prodId = options.prodId) !== null && _options$prodId !== void 0 ? _options$prodId : DEFAULT_PRODID}`);
+	const method = (_options$method = options.method) !== null && _options$method !== void 0 ? _options$method : findMethod(objects);
+	if (method) lines.push(`METHOD:${method.toUpperCase()}`);
+	for (const object of objects) if (object["@type"] === TYPE_GROUP$3) {
+		const group = object;
+		if (includeX) lines.push(`X-JSCALENDAR-GROUP:${escapeText(JSON.stringify(stripEntries(group)))}`);
+		for (const entry of group.entries) lines.push(...buildComponent(entry, includeX));
+	} else lines.push(...buildComponent(object, includeX));
+	lines.push("END:VCALENDAR");
+	return foldLines(lines).join("\r\n");
+}
+/**
+* Find the first METHOD value from objects.
+* @param objects JSCalendar objects.
+* @return METHOD value or undefined.
+*/
+function findMethod(objects) {
+	for (const object of objects) if (object.method) return object.method;
+}
+/**
+* Build an iCalendar component from a JSCalendar object.
+* @param object JSCalendar object.
+* @param includeX Whether to include X-JSCALENDAR.
+* @return iCalendar lines for the component.
+*/
+function buildComponent(object, includeX) {
+	if (object["@type"] === TYPE_EVENT$4) return buildEvent(object, includeX);
+	if (object["@type"] === TYPE_TASK$4) return buildTask(object, includeX);
+	return [];
+}
+/**
+* Build a VEVENT component.
+* @param event Event object.
+* @param includeX Whether to include X-JSCALENDAR.
+* @return VEVENT lines.
+*/
+function buildEvent(event, includeX) {
+	const lines = [];
+	lines.push("BEGIN:VEVENT");
+	lines.push(`UID:${escapeText(event.uid)}`);
+	lines.push(`DTSTAMP:${formatUtcDateTime(event.updated)}`);
+	if (event.sequence !== void 0) lines.push(`SEQUENCE:${event.sequence}`);
+	if (event.title) lines.push(`SUMMARY:${escapeText(event.title)}`);
+	if (event.description) lines.push(`DESCRIPTION:${escapeText(event.description)}`);
+	const dtStart = formatLocalDateTime$1(event.start);
+	if (event.timeZone) lines.push(`DTSTART;TZID=${event.timeZone}:${dtStart}`);
+	else lines.push(`DTSTART:${dtStart}`);
+	if (event.duration) lines.push(`DURATION:${event.duration}`);
+	if (event.status) lines.push(`STATUS:${event.status.toUpperCase()}`);
+	appendRecurrence(lines, event.recurrenceRules);
+	if (includeX) lines.push(`X-JSCALENDAR:${escapeText(JSON.stringify(event))}`);
+	lines.push("END:VEVENT");
+	return lines;
+}
+/**
+* Build a VTODO component.
+* @param task Task object.
+* @param includeX Whether to include X-JSCALENDAR.
+* @return VTODO lines.
+*/
+function buildTask(task, includeX) {
+	const lines = [];
+	lines.push("BEGIN:VTODO");
+	lines.push(`UID:${escapeText(task.uid)}`);
+	lines.push(`DTSTAMP:${formatUtcDateTime(task.updated)}`);
+	if (task.sequence !== void 0) lines.push(`SEQUENCE:${task.sequence}`);
+	if (task.title) lines.push(`SUMMARY:${escapeText(task.title)}`);
+	if (task.description) lines.push(`DESCRIPTION:${escapeText(task.description)}`);
+	if (task.start) {
+		const dtStart = formatLocalDateTime$1(task.start);
+		if (task.timeZone) lines.push(`DTSTART;TZID=${task.timeZone}:${dtStart}`);
+		else lines.push(`DTSTART:${dtStart}`);
+	}
+	if (task.due) {
+		const due = formatLocalDateTime$1(task.due);
+		if (task.timeZone) lines.push(`DUE;TZID=${task.timeZone}:${due}`);
+		else lines.push(`DUE:${due}`);
+	}
+	if (task.percentComplete !== void 0) lines.push(`PERCENT-COMPLETE:${task.percentComplete}`);
+	if (task.progress) lines.push(`STATUS:${task.progress.toUpperCase()}`);
+	appendRecurrence(lines, task.recurrenceRules);
+	if (includeX) lines.push(`X-JSCALENDAR:${escapeText(JSON.stringify(task))}`);
+	lines.push("END:VTODO");
+	return lines;
+}
+/**
+* Append RRULE lines for recurrence rules.
+* @param lines Lines to append to.
+* @param rules Recurrence rules.
+* @return Nothing.
+*/
+function appendRecurrence(lines, rules) {
+	if (!rules) return;
+	for (const rule of rules) {
+		const rrule = recurrenceRuleToRRule(rule);
+		if (rrule) lines.push(`RRULE:${rrule}`);
+	}
+}
+/**
+* Convert a RecurrenceRule to an RRULE string.
+* @param rule Recurrence rule.
+* @return RRULE value or null.
+*/
+function recurrenceRuleToRRule(rule) {
+	var _rule$byDay, _rule$byMonthDay, _rule$byMonth, _rule$byYearDay, _rule$byWeekNo, _rule$byHour, _rule$byMinute, _rule$bySecond, _rule$bySetPosition;
+	const parts = [];
+	parts.push(`FREQ=${rule.frequency.toUpperCase()}`);
+	if (rule.interval) parts.push(`INTERVAL=${rule.interval}`);
+	if (rule.count) parts.push(`COUNT=${rule.count}`);
+	if (rule.until) parts.push(`UNTIL=${formatLocalDateTime$1(rule.until)}`);
+	if ((_rule$byDay = rule.byDay) === null || _rule$byDay === void 0 ? void 0 : _rule$byDay.length) {
+		const days = rule.byDay.map((day) => {
+			var _day$nthOfPeriod;
+			return `${(_day$nthOfPeriod = day.nthOfPeriod) !== null && _day$nthOfPeriod !== void 0 ? _day$nthOfPeriod : ""}${day.day.toUpperCase()}`;
+		}).join(",");
+		parts.push(`BYDAY=${days}`);
+	}
+	if ((_rule$byMonthDay = rule.byMonthDay) === null || _rule$byMonthDay === void 0 ? void 0 : _rule$byMonthDay.length) parts.push(`BYMONTHDAY=${rule.byMonthDay.join(",")}`);
+	if ((_rule$byMonth = rule.byMonth) === null || _rule$byMonth === void 0 ? void 0 : _rule$byMonth.length) parts.push(`BYMONTH=${rule.byMonth.join(",")}`);
+	if ((_rule$byYearDay = rule.byYearDay) === null || _rule$byYearDay === void 0 ? void 0 : _rule$byYearDay.length) parts.push(`BYYEARDAY=${rule.byYearDay.join(",")}`);
+	if ((_rule$byWeekNo = rule.byWeekNo) === null || _rule$byWeekNo === void 0 ? void 0 : _rule$byWeekNo.length) parts.push(`BYWEEKNO=${rule.byWeekNo.join(",")}`);
+	if ((_rule$byHour = rule.byHour) === null || _rule$byHour === void 0 ? void 0 : _rule$byHour.length) parts.push(`BYHOUR=${rule.byHour.join(",")}`);
+	if ((_rule$byMinute = rule.byMinute) === null || _rule$byMinute === void 0 ? void 0 : _rule$byMinute.length) parts.push(`BYMINUTE=${rule.byMinute.join(",")}`);
+	if ((_rule$bySecond = rule.bySecond) === null || _rule$bySecond === void 0 ? void 0 : _rule$bySecond.length) parts.push(`BYSECOND=${rule.bySecond.join(",")}`);
+	if ((_rule$bySetPosition = rule.bySetPosition) === null || _rule$bySetPosition === void 0 ? void 0 : _rule$bySetPosition.length) parts.push(`BYSETPOS=${rule.bySetPosition.join(",")}`);
+	if (rule.firstDayOfWeek) parts.push(`WKST=${rule.firstDayOfWeek.toUpperCase()}`);
+	if (rule.rscale) parts.push(`RSCALE=${rule.rscale.toUpperCase()}`);
+	if (rule.skip) parts.push(`SKIP=${rule.skip.toUpperCase()}`);
+	return parts.join(";");
+}
+/**
+* Format a UTCDateTime for iCalendar.
+* @param value UTCDateTime string.
+* @return iCalendar-formatted UTCDateTime.
+*/
+function formatUtcDateTime(value) {
+	return normalizeUtcDateTime(value).replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z").replace(/Z$/, "Z");
+}
+/**
+* Format a LocalDateTime for iCalendar.
+* @param value LocalDateTime string.
+* @return iCalendar-formatted LocalDateTime.
+*/
+function formatLocalDateTime$1(value) {
+	return value.replace(/[-:]/g, "").replace(/\.\d+$/, "").replace(/Z$/, "");
+}
+/**
+* Escape text for iCalendar content lines.
+* @param value Raw text.
+* @return Escaped text.
+*/
+function escapeText(value) {
+	return value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/;/g, "\\;").replace(/,/g, "\\,");
+}
+/**
+* Fold iCalendar lines to 75 octets per RFC.
+* @param lines Lines to fold.
+* @return Folded lines.
+*/
+function foldLines(lines) {
+	const result = [];
+	for (const line of lines) {
+		if (line.length <= 75) {
+			result.push(line);
+			continue;
+		}
+		let remaining = line;
+		result.push(remaining.slice(0, 75));
+		remaining = remaining.slice(75);
+		while (remaining.length > 0) {
+			result.push(` ${remaining.slice(0, 74)}`);
+			remaining = remaining.slice(74);
+		}
+	}
+	return result;
+}
+/**
+* Strip group entries for X-JSCALENDAR-GROUP payload.
+* @param group Group object.
+* @return Group without entries.
+*/
+function stripEntries(group) {
+	const { entries: _entries, ...rest } = group;
+	return rest;
+}
+
+//#endregion
+//#region src/patch.ts
+const POINTER_SEPARATOR = "/";
+const TYPE_OBJECT = "object";
+const PATCH_ERROR_NAME = "PatchError";
+/**
+* Error thrown when a patch operation is invalid.
+*/
+var PatchError = class extends Error {
+	/**
+	* Create a new PatchError.
+	* @param message Error message.
+	*/
+	constructor(message) {
+		super(message);
+		this.name = PATCH_ERROR_NAME;
+	}
+};
+/**
+* Unescape a JSON Pointer segment.
+* @param segment Escaped pointer segment.
+* @return Unescaped pointer segment.
+*/
+function unescapePointer(segment) {
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/**
+* Normalize a JSON Pointer string to ensure it is absolute.
+* @param pointer Pointer to normalize.
+* @return Normalized pointer.
+*/
+function normalizePointer(pointer) {
+	return pointer.startsWith(POINTER_SEPARATOR) ? pointer : `${POINTER_SEPARATOR}${pointer}`;
+}
+/**
+* Split a JSON Pointer into unescaped segments.
+* @param pointer Pointer to split.
+* @return Unescaped pointer segments.
+*/
+function splitPointer(pointer) {
+	const normalized = normalizePointer(pointer);
+	if (normalized === POINTER_SEPARATOR) return [];
+	return normalized.split(POINTER_SEPARATOR).slice(1).map(unescapePointer);
+}
+/**
+* Validate that no pointer is a prefix of another pointer.
+* @param pointers Patch pointers to validate.
+* @return Nothing.
+*/
+function validatePrefixConflicts(pointers) {
+	const normalized = pointers.map(normalizePointer).sort();
+	for (let i = 0; i < normalized.length; i += 1) {
+		const current = normalized[i];
+		for (let j = i + 1; j < normalized.length; j += 1) {
+			const other = normalized[j];
+			const prefix = `${current}${POINTER_SEPARATOR}`;
+			if (other && other.startsWith(prefix)) throw new PatchError(`Patch pointer conflict: ${current} is prefix of ${other}`);
+		}
+	}
+}
+/**
+* Ensure the value is not an array when traversing pointers.
+* @param value Value to check.
+* @param pointer Pointer for error context.
+* @return Nothing.
+*/
+function assertNotArray(value, pointer) {
+	if (Array.isArray(value)) throw new PatchError(`Patch pointer references into array: ${pointer}`);
+}
+/**
+* Ensure a value is an object record for traversal.
+* @param value Value to check.
+* @param pointer Pointer for error context.
+* @return Nothing.
+*/
+function assertObject(value, pointer) {
+	if (value === null || typeof value !== TYPE_OBJECT || Array.isArray(value)) throw new PatchError(`Patch pointer references missing or non-object path: ${pointer}`);
+}
+/**
+* Ensure a value is a record at the current traversal position.
+* @param value Value to check.
+* @param pointer Pointer for error context.
+* @return Nothing.
+*/
+function assertRecord(value, pointer) {
+	if (value === null || Array.isArray(value)) throw new PatchError(`Patch pointer references missing or non-object path: ${pointer}`);
+}
+/**
+* Apply a PatchObject to a target record.
+* @param target Target record to mutate.
+* @param patch Patch entries to apply.
+* @return Nothing.
+*/
+function applyPatchEntries(target, patch) {
+	for (const [rawPointer, value] of Object.entries(patch)) {
+		const pointer = normalizePointer(rawPointer);
+		applyPointerSegments(target, pointer, splitPointer(pointer), value);
+	}
+}
+/**
+* Apply patch segments to the target by walking each segment.
+* @param target Target record to mutate.
+* @param pointer Normalized pointer.
+* @param segments Pointer segments.
+* @param value Patch value for the pointer.
+* @return Nothing.
+*/
+function applyPointerSegments(target, pointer, segments, value) {
+	let current = target;
+	for (let i = 0; i < segments.length; i += 1) {
+		const segment = ensureSegment(segments[i], pointer);
+		const isLast = isLastSegment(i, segments.length);
+		current = applySegment(current, segment, isLast, value, pointer);
+	}
+}
+/**
+* Ensure the current segment is present.
+* @param segment Segment to validate.
+* @param pointer Pointer for error context.
+* @return Validated segment.
+*/
+function ensureSegment(segment, pointer) {
+	if (segment === void 0) throw new PatchError(`Patch pointer missing segment: ${pointer}`);
+	return segment;
+}
+/**
+* Determine if the index is the last segment.
+* @param index Current index.
+* @param length Total number of segments.
+* @return True if this is the last segment.
+*/
+function isLastSegment(index, length) {
+	return index === length - 1;
+}
+/**
+* Apply a single patch segment and return the next traversal record.
+* @param current Current record.
+* @param segment Current segment.
+* @param isLast Whether this is the last segment.
+* @param value Patch value.
+* @param pointer Pointer for error context.
+* @return Next record to traverse.
+*/
+function applySegment(current, segment, isLast, value, pointer) {
+	assertNotArray(current, pointer);
+	assertRecord(current, pointer);
+	if (isLast) {
+		applyValueAtSegment(current, segment, value);
+		return current;
+	}
+	return getNextRecord(current, segment, pointer);
+}
+/**
+* Apply a value update or delete at the given segment.
+* @param current Current record.
+* @param segment Segment to update.
+* @param value Patch value.
+* @return Nothing.
+*/
+function applyValueAtSegment(current, segment, value) {
+	if (value === null) {
+		if (Object.prototype.hasOwnProperty.call(current, segment)) delete current[segment];
+		return;
+	}
+	current[segment] = value;
+}
+/**
+* Resolve the next record in the traversal, validating it exists and is an object.
+* @param current Current record.
+* @param segment Segment to traverse.
+* @param pointer Pointer for error context.
+* @return Next record to traverse.
+*/
+function getNextRecord(current, segment, pointer) {
+	if (!Object.prototype.hasOwnProperty.call(current, segment)) throw new PatchError(`Patch pointer missing path: ${pointer}`);
+	const next = current[segment];
+	if (next === void 0) throw new PatchError(`Patch pointer missing path: ${pointer}`);
+	assertObject(next, pointer);
+	return next;
+}
+/**
+* Apply a JSCalendar PatchObject to an input object.
+* @param input Input object.
+* @param patch Patch object to apply.
+* @return Patched clone of the input object.
+*/
+function applyPatch(input, patch) {
+	validatePrefixConflicts(Object.keys(patch));
+	const target = deepClone(input);
+	assertRecord(target, POINTER_SEPARATOR);
+	applyPatchEntries(target, patch);
+	return target;
+}
+
+//#endregion
+//#region src/recurrence/constants.ts
+const TYPE_EVENT$3 = "Event";
+const TYPE_TASK$3 = "Task";
+const RSCALE_GREGORIAN$1 = "gregorian";
+const SKIP_OMIT = "omit";
+const SKIP_FORWARD = "forward";
+const SKIP_BACKWARD = "backward";
+const FREQ_YEARLY = "yearly";
+const FREQ_MONTHLY = "monthly";
+const FREQ_WEEKLY = "weekly";
+const FREQ_DAILY = "daily";
+const FREQ_HOURLY = "hourly";
+const FREQ_MINUTELY = "minutely";
+const FREQ_SECONDLY = "secondly";
+
+//#endregion
+//#region src/recurrence/date-utils.ts
+/**
+* Advance a date-time by a recurrence interval.
+* @param start Anchor date-time.
+* @param frequency Recurrence frequency.
+* @param amount Number of intervals to add.
+* @param firstDay First day of week for weekly intervals.
+* @return Date-time moved to the next interval boundary.
+*/
+function addInterval(start, frequency, amount, firstDay) {
+	if (frequency === FREQ_YEARLY) return {
+		year: start.year + amount,
+		month: 1,
+		day: 1,
+		hour: 0,
+		minute: 0,
+		second: 0
+	};
+	if (frequency === FREQ_MONTHLY) {
+		const next = addMonths(start, amount);
+		return {
+			year: next.year,
+			month: next.month,
+			day: 1,
+			hour: 0,
+			minute: 0,
+			second: 0
+		};
+	}
+	if (frequency === FREQ_WEEKLY) return addDays(startOfWeek(start, firstDay), amount * 7);
+	if (frequency === FREQ_DAILY) return addDays(start, amount);
+	if (frequency === FREQ_HOURLY) return addHours(start, amount);
+	if (frequency === FREQ_MINUTELY) return addMinutes(start, amount);
+	return addSeconds(start, amount);
+}
+/**
+* Parse local date time into structured data.
+* @param value LocalDateTime string.
+* @return Parsed date-time parts.
+*/
+function parseLocalDateTime(value) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(value);
+	if (!match) throw new Error(`Invalid LocalDateTime: ${value}`);
+	return {
+		year: Number(match[1]),
+		month: Number(match[2]),
+		day: Number(match[3]),
+		hour: Number(match[4]),
+		minute: Number(match[5]),
+		second: Number(match[6])
+	};
+}
+/**
+* Format local date time as string.
+* @param dt Date-time parts.
+* @return LocalDateTime string.
+*/
+function formatLocalDateTime(dt) {
+	return `${pad(dt.year, 4)}-${pad(dt.month, 2)}-${pad(dt.day, 2)}T${pad(dt.hour, 2)}:${pad(dt.minute, 2)}:${pad(dt.second, 2)}`;
+}
+/**
+* Pad a numeric value with leading zeros.
+* @param value Number to pad.
+* @param length Total length.
+* @return Zero-padded string.
+*/
+function pad(value, length) {
+	return value.toString().padStart(length, "0");
+}
+/**
+* Add days to the target.
+* @param dt Date-time parts.
+* @param days Days to add.
+* @return New date-time with days added.
+*/
+function addDays(dt, days) {
+	const ms = Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second) + days * 86400 * 1e3;
+	const d = new Date(ms);
+	return {
+		year: d.getUTCFullYear(),
+		month: d.getUTCMonth() + 1,
+		day: d.getUTCDate(),
+		hour: dt.hour,
+		minute: dt.minute,
+		second: dt.second
+	};
+}
+/**
+* Add hours to the target.
+* @param dt Date-time parts.
+* @param hours Hours to add.
+* @return New date-time with hours added.
+*/
+function addHours(dt, hours) {
+	const ms = Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second) + hours * 3600 * 1e3;
+	const d = new Date(ms);
+	return {
+		year: d.getUTCFullYear(),
+		month: d.getUTCMonth() + 1,
+		day: d.getUTCDate(),
+		hour: d.getUTCHours(),
+		minute: d.getUTCMinutes(),
+		second: d.getUTCSeconds()
+	};
+}
+/**
+* Add minutes to the target.
+* @param dt Date-time parts.
+* @param minutes Minutes to add.
+* @return New date-time with minutes added.
+*/
+function addMinutes(dt, minutes) {
+	return addSeconds(dt, minutes * 60);
+}
+/**
+* Add seconds to the target.
+* @param dt Date-time parts.
+* @param seconds Seconds to add.
+* @return New date-time with seconds added.
+*/
+function addSeconds(dt, seconds) {
+	const ms = Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second) + seconds * 1e3;
+	const d = new Date(ms);
+	return {
+		year: d.getUTCFullYear(),
+		month: d.getUTCMonth() + 1,
+		day: d.getUTCDate(),
+		hour: d.getUTCHours(),
+		minute: d.getUTCMinutes(),
+		second: d.getUTCSeconds()
+	};
+}
+/**
+* Add months to the target.
+* @param dt Date-time parts.
+* @param months Months to add.
+* @return New date-time with months added.
+*/
+function addMonths(dt, months) {
+	const total = dt.year * 12 + (dt.month - 1) + months;
+	const year = Math.floor(total / 12);
+	const month = total % 12 + 1;
+	return {
+		year,
+		month,
+		day: Math.min(dt.day, daysInMonth(year, month)),
+		hour: dt.hour,
+		minute: dt.minute,
+		second: dt.second
+	};
+}
+/**
+* Get day of week for a date-time.
+* @param dt Date-time parts.
+* @return Two-letter weekday code.
+*/
+function dayOfWeek(dt) {
+	const idx = new Date(Date.UTC(dt.year, dt.month - 1, dt.day)).getUTCDay();
+	if (idx === 0) return "su";
+	if (idx === 1) return "mo";
+	if (idx === 2) return "tu";
+	if (idx === 3) return "we";
+	if (idx === 4) return "th";
+	if (idx === 5) return "fr";
+	return "sa";
+}
+/**
+* Get day of year for a date-time.
+* @param dt Date-time parts.
+* @return Day of year (1-366).
+*/
+function dayOfYear(dt) {
+	const start = Date.UTC(dt.year, 0, 1);
+	const current = Date.UTC(dt.year, dt.month - 1, dt.day);
+	return Math.floor((current - start) / (24 * 3600 * 1e3)) + 1;
+}
+/**
+* Get number of days in a month.
+* @param year Year number.
+* @param month Month number (1-12).
+* @return Days in the month.
+*/
+function daysInMonth(year, month) {
+	return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+/**
+* Get number of days in a year.
+* @param year Year number.
+* @return Days in the year.
+*/
+function daysInYear(year) {
+	return new Date(Date.UTC(year + 1, 0, 0)).getUTCDate();
+}
+/**
+* Get the start of week for a date-time.
+* @param dt Date-time parts.
+* @param firstDay Weekday that starts the week.
+* @return Date-time at the start of the week.
+*/
+function startOfWeek(dt, firstDay) {
+	const order = [
+		"mo",
+		"tu",
+		"we",
+		"th",
+		"fr",
+		"sa",
+		"su"
+	];
+	const dow = dayOfWeek(dt);
+	return addDays(dt, -((order.indexOf(dow) - order.indexOf(firstDay) + 7) % 7));
+}
+/**
+* Get ISO-like week number for a date-time.
+* @param dt Date-time parts.
+* @param firstDay Weekday that starts the week.
+* @return Week number for the given date.
+*/
+function weekNumber(dt, firstDay) {
+	const yearStart = {
+		year: dt.year,
+		month: 1,
+		day: 1,
+		hour: 0,
+		minute: 0,
+		second: 0
+	};
+	const weekStart = startOfWeek(yearStart, firstDay);
+	const week1Start = 7 - daysBetween(weekStart, yearStart) >= 4 ? weekStart : addDays(weekStart, 7);
+	if (compareDate(dt, week1Start) < 0) return totalWeeksInYear(dt.year - 1, firstDay);
+	const diff = daysBetween(week1Start, dt);
+	return Math.floor(diff / 7) + 1;
+}
+/**
+* Get total weeks in a year.
+* @param year Year number.
+* @param firstDay Weekday that starts the week.
+* @return Total number of weeks in the year.
+*/
+function totalWeeksInYear(year, firstDay) {
+	return weekNumber({
+		year,
+		month: 12,
+		day: 31,
+		hour: 0,
+		minute: 0,
+		second: 0
+	}, firstDay);
+}
+/**
+* Get whole-day difference between two dates.
+* @param a Start date.
+* @param b End date.
+* @return Whole-day difference (b - a).
+*/
+function daysBetween(a, b) {
+	const msA = Date.UTC(a.year, a.month - 1, a.day);
+	const msB = Date.UTC(b.year, b.month - 1, b.day);
+	return Math.floor((msB - msA) / (24 * 3600 * 1e3));
+}
+/**
+* Compare two dates without time.
+* @param a First date.
+* @param b Second date.
+* @return Negative/zero/positive comparison result.
+*/
+function compareDate(a, b) {
+	if (a.year !== b.year) return a.year - b.year;
+	if (a.month !== b.month) return a.month - b.month;
+	if (a.day !== b.day) return a.day - b.day;
+	return 0;
+}
+
+//#endregion
+//#region src/recurrence/rule-matchers.ts
+/**
+* Check whether a candidate date matches BYMONTHDAY values.
+* @param date Candidate date.
+* @param byMonthDay BYMONTHDAY values (positive or negative).
+* @return True when the candidate date matches any BYMONTHDAY value.
+*/
+function matchesByMonthDay(date, byMonthDay) {
+	const dim = daysInMonth(date.year, date.month);
+	for (const v of byMonthDay) {
+		if (v > 0 && date.day === v) return true;
+		if (v < 0 && date.day === dim + v + 1) return true;
+	}
+	return false;
+}
+/**
+* Check whether a candidate date matches BYYEARDAY values.
+* @param date Candidate date.
+* @param byYearDay BYYEARDAY values (positive or negative).
+* @return True when the candidate date matches any BYYEARDAY value.
+*/
+function matchesByYearDay(date, byYearDay) {
+	const diy = daysInYear(date.year);
+	const doy = dayOfYear({
+		year: date.year,
+		month: date.month,
+		day: date.day,
+		hour: 0,
+		minute: 0,
+		second: 0
+	});
+	for (const v of byYearDay) {
+		if (v > 0 && doy === v) return true;
+		if (v < 0 && doy === diy + v + 1) return true;
+	}
+	return false;
+}
+/**
+* Check whether a candidate date matches BYWEEKNO values.
+* @param date Candidate date.
+* @param byWeekNo BYWEEKNO values (positive or negative).
+* @param firstDay First day of the week for week number calculations.
+* @return True when the candidate date matches any BYWEEKNO value.
+*/
+function matchesByWeekNo(date, byWeekNo, firstDay) {
+	const week = weekNumber({
+		year: date.year,
+		month: date.month,
+		day: date.day,
+		hour: 0,
+		minute: 0,
+		second: 0
+	}, firstDay);
+	const total = totalWeeksInYear(date.year, firstDay);
+	for (const v of byWeekNo) {
+		if (v > 0 && week === v) return true;
+		if (v < 0 && week === total + v + 1) return true;
+	}
+	return false;
+}
+/**
+* Check whether a candidate date matches BYDAY rules.
+* @param date Candidate date.
+* @param byDay BYDAY rules (with optional nth-of-period entries).
+* @param frequency Rule frequency.
+* @param periodStart Start of the current recurrence period.
+* @param firstDay First day of the week for weekly calculations.
+* @return True when the candidate date matches any BYDAY rule.
+*/
+function matchesByDay(date, byDay, frequency, periodStart, firstDay) {
+	const weekday = dayOfWeek({
+		year: date.year,
+		month: date.month,
+		day: date.day,
+		hour: 0,
+		minute: 0,
+		second: 0
+	});
+	for (const entry of byDay) {
+		if (entry.nthOfPeriod === void 0) {
+			if (entry.day === weekday) return true;
+			continue;
+		}
+		if (frequency !== FREQ_MONTHLY && frequency !== FREQ_YEARLY) continue;
+		const matches = listNthPeriodDates(date, frequency, periodStart, firstDay).filter((d) => dayOfWeek(d) === entry.day);
+		const index = entry.nthOfPeriod > 0 ? entry.nthOfPeriod - 1 : matches.length + entry.nthOfPeriod;
+		if (index >= 0 && index < matches.length) {
+			const target = matches[index];
+			if (target && target.year === date.year && target.month === date.month && target.day === date.day) return true;
+		}
+	}
+	return false;
+}
+/**
+* List dates in the current period for nth-of-period matching.
+* @param date Candidate date (year/month used for period selection).
+* @param frequency Rule frequency.
+* @param periodStart Start of the current recurrence period.
+* @param firstDay First day of the week for weekly calculations.
+* @return Date list used to resolve nth-of-period BYDAY entries.
+*/
+function listNthPeriodDates(date, frequency, periodStart, firstDay) {
+	if (frequency === FREQ_YEARLY) {
+		const result = [];
+		for (let month = 1; month <= 12; month += 1) {
+			const days = daysInMonth(date.year, month);
+			for (let day = 1; day <= days; day += 1) result.push({
+				year: date.year,
+				month,
+				day,
+				hour: 0,
+				minute: 0,
+				second: 0
+			});
+		}
+		return result;
+	}
+	if (frequency === FREQ_MONTHLY) {
+		const result = [];
+		const days = daysInMonth(date.year, date.month);
+		for (let day = 1; day <= days; day += 1) result.push({
+			year: date.year,
+			month: date.month,
+			day,
+			hour: 0,
+			minute: 0,
+			second: 0
+		});
+		return result;
+	}
+	const result = [];
+	let cursor = periodStart;
+	for (let i = 0; i < 7; i += 1) {
+		result.push({
+			year: cursor.year,
+			month: cursor.month,
+			day: cursor.day,
+			hour: 0,
+			minute: 0,
+			second: 0
+		});
+		cursor = addDays(cursor, 1);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/recurrence/rule-candidates.ts
+/**
+* Build candidate dates for the current recurrence period.
+* @param periodStart Start of the current recurrence period.
+* @param rule Normalized recurrence rule.
+* @param firstDay First day of the week for weekly calculations.
+* @param skip Skip policy for invalid month days.
+* @return Candidate dates for further filtering.
+*/
+function generateDateCandidates(periodStart, rule, firstDay, skip) {
+	const result = [];
+	const wantsInvalid = skip !== SKIP_OMIT && rule.byMonthDay && rule.byMonthDay.length > 0;
+	if (rule.frequency === FREQ_YEARLY) {
+		for (let month = 1; month <= 12; month += 1) {
+			const maxDays = wantsInvalid ? 31 : daysInMonth(periodStart.year, month);
+			for (let day = 1; day <= maxDays; day += 1) {
+				const valid = day <= daysInMonth(periodStart.year, month);
+				result.push({
+					year: periodStart.year,
+					month,
+					day,
+					valid
+				});
+			}
+		}
+		return result;
+	}
+	if (rule.frequency === FREQ_MONTHLY) {
+		const maxDays = wantsInvalid ? 31 : daysInMonth(periodStart.year, periodStart.month);
+		for (let day = 1; day <= maxDays; day += 1) {
+			const valid = day <= daysInMonth(periodStart.year, periodStart.month);
+			result.push({
+				year: periodStart.year,
+				month: periodStart.month,
+				day,
+				valid
+			});
+		}
+		return result;
+	}
+	if (rule.frequency === FREQ_WEEKLY) {
+		let cursor = periodStart;
+		for (let i = 0; i < 7; i += 1) {
+			result.push({
+				year: cursor.year,
+				month: cursor.month,
+				day: cursor.day,
+				valid: true
+			});
+			cursor = addDays(cursor, 1);
+		}
+		return result;
+	}
+	if (rule.frequency === FREQ_DAILY) {
+		result.push({
+			year: periodStart.year,
+			month: periodStart.month,
+			day: periodStart.day,
+			valid: true
+		});
+		return result;
+	}
+	if (rule.frequency === FREQ_HOURLY || rule.frequency === FREQ_MINUTELY || rule.frequency === FREQ_SECONDLY) {
+		result.push({
+			year: periodStart.year,
+			month: periodStart.month,
+			day: periodStart.day,
+			valid: true
+		});
+		return result;
+	}
+	return result;
+}
+/**
+* Apply BY* filters and skip behavior to candidate dates.
+* @param candidates Candidate dates for the period.
+* @param rule Normalized recurrence rule.
+* @param periodStart Start of the current recurrence period.
+* @param firstDay First day of the week for weekly calculations.
+* @param skip Skip policy for invalid month days.
+* @return Filtered candidate dates.
+*/
+function filterDateCandidates(candidates, rule, periodStart, firstDay, skip) {
+	let result = candidates;
+	if (rule.byMonth && rule.byMonth.length > 0) {
+		const months = rule.byMonth.map((m) => parseInt(m, 10)).filter((m) => !Number.isNaN(m));
+		result = result.filter((d) => months.includes(d.month));
+	}
+	if (rule.byWeekNo && rule.byWeekNo.length > 0) {
+		const byWeekNo = rule.byWeekNo.filter((d) => d !== 0);
+		result = result.filter((d) => d.valid && matchesByWeekNo(d, byWeekNo, firstDay));
+	}
+	if (rule.byYearDay && rule.byYearDay.length > 0) {
+		const byYearDay = rule.byYearDay.filter((d) => d !== 0);
+		result = result.filter((d) => d.valid && matchesByYearDay(d, byYearDay));
+	}
+	if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+		const byMonthDay = rule.byMonthDay.filter((d) => d !== 0);
+		result = result.filter((d) => matchesByMonthDay(d, byMonthDay));
+	}
+	const byDay = rule.byDay;
+	if (byDay && byDay.length > 0) result = result.filter((d) => matchesByDay(d, byDay, rule.frequency, periodStart, firstDay));
+	if (skip !== SKIP_OMIT && rule.byMonthDay && rule.byMonthDay.length > 0) result = adjustInvalidMonthDays(result, skip);
+	else result = result.filter((d) => d.valid);
+	return result;
+}
+/**
+* Shift invalid month-day candidates using the skip policy.
+* @param candidates Candidate dates that may include invalid month days.
+* @param skip Skip policy for invalid month days.
+* @return Candidates with invalid days adjusted or removed.
+*/
+function adjustInvalidMonthDays(candidates, skip) {
+	const adjusted = [];
+	for (const candidate of candidates) {
+		if (candidate.valid) {
+			adjusted.push(candidate);
+			continue;
+		}
+		if (skip === SKIP_FORWARD) {
+			const next = addMonths({
+				year: candidate.year,
+				month: candidate.month,
+				day: 1,
+				hour: 0,
+				minute: 0,
+				second: 0
+			}, 1);
+			adjusted.push({
+				year: next.year,
+				month: next.month,
+				day: 1,
+				valid: true
+			});
+		} else if (skip === SKIP_BACKWARD) {
+			const day = daysInMonth(candidate.year, candidate.month);
+			adjusted.push({
+				year: candidate.year,
+				month: candidate.month,
+				day,
+				valid: true
+			});
+		}
+	}
+	const deduped = /* @__PURE__ */ new Map();
+	for (const candidate of adjusted) {
+		const key = `${pad(candidate.year, 4)}-${pad(candidate.month, 2)}-${pad(candidate.day, 2)}`;
+		if (!deduped.has(key)) deduped.set(key, candidate);
+	}
+	return Array.from(deduped.values());
+}
+
+//#endregion
+//#region src/recurrence/rule-generate.ts
+/**
+* Generate date-time strings for the current period using rule filters.
+* @param periodStart Start of the current recurrence period.
+* @param rule Normalized recurrence rule.
+* @param firstDay First day of the week for weekly calculations.
+* @param skip Skip policy for invalid month days.
+* @return Date-time strings for this period.
+*/
+function generateDateTimes(periodStart, rule, firstDay, skip) {
+	const filteredDates = filterDateCandidates(generateDateCandidates(periodStart, rule, firstDay, skip), rule, periodStart, firstDay, skip);
+	const hours = rule.byHour && rule.byHour.length > 0 ? rule.byHour : [periodStart.hour];
+	const minutes = rule.byMinute && rule.byMinute.length > 0 ? rule.byMinute : [periodStart.minute];
+	const seconds = rule.bySecond && rule.bySecond.length > 0 ? rule.bySecond : [periodStart.second];
+	const result = [];
+	for (const date of filteredDates) for (const hour of hours) for (const minute of minutes) for (const second of seconds) {
+		const dt = formatLocalDateTime({
+			year: date.year,
+			month: date.month,
+			day: date.day,
+			hour,
+			minute,
+			second
+		});
+		result.push(dt);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/recurrence/rule-normalize.ts
+/**
+* Normalize rule fields by copying arrays and filling defaults from the start date-time.
+* @param rule Recurrence rule to normalize.
+* @param start Anchor date-time that supplies default by* values.
+* @return Normalized recurrence rule with default by* fields filled.
+*/
+function normalizeRule(rule, start) {
+	const normalized = {
+		...rule,
+		bySecond: rule.bySecond ? [...rule.bySecond] : void 0,
+		byMinute: rule.byMinute ? [...rule.byMinute] : void 0,
+		byHour: rule.byHour ? [...rule.byHour] : void 0,
+		byDay: rule.byDay ? [...rule.byDay] : void 0,
+		byMonthDay: rule.byMonthDay ? [...rule.byMonthDay] : void 0,
+		byMonth: rule.byMonth ? [...rule.byMonth] : void 0,
+		byYearDay: rule.byYearDay ? [...rule.byYearDay] : void 0,
+		byWeekNo: rule.byWeekNo ? [...rule.byWeekNo] : void 0,
+		bySetPosition: rule.bySetPosition ? [...rule.bySetPosition] : void 0
+	};
+	if (normalized.frequency !== FREQ_SECONDLY && (!normalized.bySecond || normalized.bySecond.length === 0)) normalized.bySecond = [start.second];
+	if (normalized.frequency !== FREQ_SECONDLY && normalized.frequency !== FREQ_MINUTELY && (!normalized.byMinute || normalized.byMinute.length === 0)) normalized.byMinute = [start.minute];
+	if (normalized.frequency !== FREQ_SECONDLY && normalized.frequency !== FREQ_MINUTELY && normalized.frequency !== FREQ_HOURLY && (!normalized.byHour || normalized.byHour.length === 0)) normalized.byHour = [start.hour];
+	if (normalized.frequency === FREQ_WEEKLY && (!normalized.byDay || normalized.byDay.length === 0)) normalized.byDay = [{
+		"@type": "NDay",
+		day: dayOfWeek(start)
+	}];
+	if (normalized.frequency === FREQ_MONTHLY && (!normalized.byDay || normalized.byDay.length === 0) && (!normalized.byMonthDay || normalized.byMonthDay.length === 0)) normalized.byMonthDay = [start.day];
+	if (normalized.frequency === FREQ_YEARLY && (!normalized.byYearDay || normalized.byYearDay.length === 0)) {
+		const hasByMonth = normalized.byMonth && normalized.byMonth.length > 0;
+		const hasByWeekNo = normalized.byWeekNo && normalized.byWeekNo.length > 0;
+		const hasByMonthDay = normalized.byMonthDay && normalized.byMonthDay.length > 0;
+		const hasByDay = normalized.byDay && normalized.byDay.length > 0;
+		if (!hasByMonth && !hasByWeekNo && (hasByMonthDay || !hasByDay)) normalized.byMonth = [start.month.toString()];
+		if (!hasByMonthDay && !hasByWeekNo && !hasByDay) normalized.byMonthDay = [start.day];
+		if (hasByWeekNo && !hasByMonthDay && !hasByDay) normalized.byDay = [{
+			"@type": "NDay",
+			day: dayOfWeek(start)
+		}];
+	}
+	return normalized;
+}
+
+//#endregion
+//#region src/recurrence/rule-selectors.ts
+/**
+* Select candidate positions based on BYSETPOS rules.
+* @param candidates Candidate date-time strings.
+* @param setPos BYSETPOS indices (1-based, negative from end).
+* @return Selected date-time strings in the order of set positions.
+*/
+function applyBySetPos(candidates, setPos) {
+	const sorted = [...candidates].sort();
+	const result = [];
+	const total = sorted.length;
+	for (const pos of setPos) {
+		const index = pos > 0 ? pos - 1 : total + pos;
+		if (index >= 0 && index < total) {
+			const value = sorted[index];
+			if (value !== void 0) result.push(value);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/recurrence/rules.ts
+/**
+* Expand a recurrence rule into local date-time strings within a range.
+* @param anchor Anchor LocalDateTime for the rule.
+* @param rule Recurrence rule to expand.
+* @param fromLocal Local date-time lower bound (inclusive).
+* @param toLocal Local date-time upper bound (inclusive).
+* @param includeAnchor Whether to include the anchor occurrence.
+* @param timeZone Optional time zone for range comparisons.
+* @param fromDate Optional Date lower bound (time zone-aware).
+* @param toDate Optional Date upper bound (time zone-aware).
+* @return Local date-time strings that match the rule in range order.
+*/
+function expandRule(anchor, rule, fromLocal, toLocal, includeAnchor, timeZone, fromDate, toDate) {
+	var _normalized$interval, _normalized$count, _normalized$skip, _normalized$firstDayO;
+	if (rule.rscale && rule.rscale !== RSCALE_GREGORIAN$1) throw new Error(`Unsupported rscale: ${rule.rscale}`);
+	const start = parseLocalDateTime(anchor);
+	const normalized = normalizeRule(rule, start);
+	const interval = (_normalized$interval = normalized.interval) !== null && _normalized$interval !== void 0 ? _normalized$interval : 1;
+	const until = normalized.until;
+	const count = (_normalized$count = normalized.count) !== null && _normalized$count !== void 0 ? _normalized$count : Infinity;
+	const skip = (_normalized$skip = normalized.skip) !== null && _normalized$skip !== void 0 ? _normalized$skip : SKIP_OMIT;
+	const firstDay = (_normalized$firstDayO = normalized.firstDayOfWeek) !== null && _normalized$firstDayO !== void 0 ? _normalized$firstDayO : "mo";
+	const results = [];
+	let generated = 0;
+	let cursor = start;
+	while (generated < count) {
+		let filtered = generateDateTimes(cursor, normalized, firstDay, skip).sort();
+		if (normalized.bySetPosition && normalized.bySetPosition.length > 0) filtered = applyBySetPos(filtered, normalized.bySetPosition);
+		for (const dt of filtered) {
+			generated += 1;
+			if (generated > count) break;
+			if (until && dt > until) return results;
+			if (dt >= fromLocal && dt <= toLocal) results.push(dt);
+		}
+		if (until && cursor && formatLocalDateTime(cursor) > until) break;
+		if (generated >= count) break;
+		if (cursor && compareDate(cursor, parseLocalDateTime(toLocal)) > 0) break;
+		cursor = addInterval(cursor, normalized.frequency, interval, firstDay);
+	}
+	return results;
+}
+
+//#endregion
+//#region src/recurrence/expand.ts
+/**
+* Expand recurrence into occurrences sorted by recurrenceId/start.
+* @param items JSCalendar objects to expand.
+* @param range Date range bounds.
+* @return Generator of expanded occurrences.
+*/
+function* expandRecurrence(items, range) {
+	const occurrences = [];
+	let index = 0;
+	for (const item of items) {
+		if (item["@type"] === TYPE_EVENT$3) {
+			for (const occurrence of expandEvent(item, range)) {
+				occurrences.push({
+					value: occurrence,
+					key: occurrenceKey(occurrence),
+					index
+				});
+				index += 1;
+			}
+			continue;
+		}
+		if (item["@type"] === TYPE_TASK$3) {
+			for (const occurrence of expandTask(item, range)) {
+				occurrences.push({
+					value: occurrence,
+					key: occurrenceKey(occurrence),
+					index
+				});
+				index += 1;
+			}
+			continue;
+		}
+		occurrences.push({
+			value: item,
+			key: occurrenceKey(item),
+			index
+		});
+		index += 1;
+	}
+	occurrences.sort((a, b) => {
+		if (a.key && b.key) return a.key.localeCompare(b.key);
+		if (a.key) return -1;
+		if (b.key) return 1;
+		return a.index - b.index;
+	});
+	for (const occurrence of occurrences) yield occurrence.value;
+}
+/**
+* Expand recurrence paged into occurrences.
+* @param items JSCalendar objects to expand.
+* @param range Date range bounds.
+* @param options Pagination options.
+* @return Page of expanded items plus an optional next cursor.
+*/
+function expandRecurrencePaged(items, range, options) {
+	const result = [];
+	let nextCursor;
+	for (const occurrence of expandRecurrence(items, range)) {
+		const key = occurrenceKey(occurrence);
+		if (options.cursor && key) {
+			if (key <= options.cursor) continue;
+		} else if (options.cursor && !key) continue;
+		result.push(occurrence);
+		if (key) nextCursor = key;
+		if (result.length >= options.limit) break;
+	}
+	return {
+		items: result,
+		nextCursor
+	};
+}
+/**
+* Expand event into occurrences.
+* @param event Event to expand.
+* @param range Date range bounds.
+* @return Generator of expanded occurrences.
+*/
+function expandEvent(event, range) {
+	var _event$timeZone;
+	return expandObject(event, range, event.start, event.recurrenceRules, event.excludedRecurrenceRules, event.recurrenceOverrides, (_event$timeZone = event.timeZone) !== null && _event$timeZone !== void 0 ? _event$timeZone : null);
+}
+/**
+* Expand task into occurrences.
+* @param task Task to expand.
+* @param range Date range bounds.
+* @return Generator of expanded occurrences.
+*/
+function expandTask(task, range) {
+	var _task$start, _task$timeZone;
+	const anchor = (_task$start = task.start) !== null && _task$start !== void 0 ? _task$start : task.due;
+	if (!anchor) return (function* empty() {})();
+	return expandObject(task, range, anchor, task.recurrenceRules, task.excludedRecurrenceRules, task.recurrenceOverrides, (_task$timeZone = task.timeZone) !== null && _task$timeZone !== void 0 ? _task$timeZone : null);
+}
+/**
+* Build a stable ordering key for an occurrence.
+* @param value Occurrence object.
+* @return Sort key or undefined when not available.
+*/
+function occurrenceKey(value) {
+	var _value$start;
+	if (value.recurrenceId) return value.recurrenceId;
+	if (value["@type"] === TYPE_EVENT$3) return value.start;
+	if (value["@type"] === TYPE_TASK$3) return (_value$start = value.start) !== null && _value$start !== void 0 ? _value$start : value.due;
+}
+/**
+* Expand object into occurrences.
+* @param base Base JSCalendar object.
+* @param range Date range bounds.
+* @param anchor Anchor LocalDateTime for the series.
+* @param rules Inclusion recurrence rules.
+* @param excludedRules Exclusion recurrence rules.
+* @param overrides Recurrence overrides keyed by LocalDateTime.
+* @param recurrenceIdTimeZone Optional time zone for recurrence IDs.
+* @return Generator of expanded occurrences.
+*/
+function* expandObject(base, range, anchor, rules, excludedRules, overrides, recurrenceIdTimeZone) {
+	var _rules$;
+	const hasZone = Boolean(recurrenceIdTimeZone);
+	const fromLocal = hasZone && recurrenceIdTimeZone ? dateTimeInTimeZone(range.from, recurrenceIdTimeZone) : localDateTimeFromDate(range.from);
+	const toLocal = hasZone && recurrenceIdTimeZone ? dateTimeInTimeZone(range.to, recurrenceIdTimeZone) : localDateTimeFromDate(range.to);
+	const fromDate = range.from;
+	const toDate = range.to;
+	const overrideKeys = overrides ? Object.keys(overrides) : [];
+	if (!rules || rules.length === 0) {
+		if (hasZone && recurrenceIdTimeZone) {
+			if (isInRangeWithZone(anchor, fromDate, toDate, recurrenceIdTimeZone)) yield base;
+		} else if (isInRange(anchor, fromLocal, toLocal)) yield base;
+		for (const key of overrideKeys) {
+			const instance = buildInstance(base, key, recurrenceIdTimeZone, overrides ? overrides[key] : void 0);
+			if (!instance) continue;
+			if (hasZone && recurrenceIdTimeZone) {
+				if (isInRangeWithZone(key, fromDate, toDate, recurrenceIdTimeZone)) yield instance;
+			} else if (isInRange(key, fromLocal, toLocal)) yield instance;
+		}
+		return;
+	}
+	const occurrences = [];
+	for (const rule of rules) {
+		const expanded = expandRule(anchor, rule, fromLocal, toLocal, true, recurrenceIdTimeZone !== null && recurrenceIdTimeZone !== void 0 ? recurrenceIdTimeZone : void 0, fromDate, toDate);
+		occurrences.push(...expanded);
+	}
+	const excluded = /* @__PURE__ */ new Set();
+	if (excludedRules && excludedRules.length > 0) for (const rule of excludedRules) {
+		const expanded = expandRule(anchor, rule, fromLocal, toLocal, true, recurrenceIdTimeZone !== null && recurrenceIdTimeZone !== void 0 ? recurrenceIdTimeZone : void 0, fromDate, toDate);
+		for (const value of expanded) excluded.add(value);
+	}
+	if (!occurrences.includes(anchor)) occurrences.push(anchor);
+	for (const key of overrideKeys) if (!occurrences.includes(key)) occurrences.push(key);
+	let sorted = Array.from(new Set(occurrences)).sort((a, b) => compareLocal(a, b, recurrenceIdTimeZone !== null && recurrenceIdTimeZone !== void 0 ? recurrenceIdTimeZone : void 0));
+	if (((_rules$ = rules[0]) === null || _rules$ === void 0 ? void 0 : _rules$.count) && sorted.length > rules[0].count) sorted = sorted.slice(0, rules[0].count);
+	for (const dt of sorted) {
+		if (excluded.has(dt)) continue;
+		const instance = buildInstance(base, dt, recurrenceIdTimeZone, overrides ? overrides[dt] : void 0);
+		if (!instance) continue;
+		if (hasZone && recurrenceIdTimeZone) {
+			if (isInRangeWithZone(dt, fromDate, toDate, recurrenceIdTimeZone)) yield instance;
+		} else if (isInRange(dt, fromLocal, toLocal)) yield instance;
+	}
+}
+/**
+* Build an occurrence instance from a base object plus override patch.
+* @param base Base JSCalendar object.
+* @param recurrenceId LocalDateTime recurrence id.
+* @param recurrenceIdTimeZone Optional time zone for recurrence id.
+* @param patch Override patch for the occurrence.
+* @return Occurrence instance or null if excluded.
+*/
+function buildInstance(base, recurrenceId, recurrenceIdTimeZone, patch) {
+	const patched = patch ? applyPatch(base, patch) : base;
+	if (isExcludedInstance(patched)) return null;
+	const overridesStart = patchHasKey(patch, "start");
+	const overridesDue = patchHasKey(patch, "due");
+	let shifted;
+	if (patched["@type"] === TYPE_EVENT$3) shifted = overridesStart ? patched : {
+		...patched,
+		start: recurrenceId
+	};
+	else if (patched["@type"] === TYPE_TASK$3) if (patched.start) shifted = overridesStart ? patched : {
+		...patched,
+		start: recurrenceId
+	};
+	else if (patched.due) shifted = overridesDue ? patched : {
+		...patched,
+		due: recurrenceId
+	};
+	else shifted = patched;
+	else shifted = patched;
+	const instance = {
+		...stripRecurrenceProperties(shifted),
+		recurrenceId
+	};
+	if (recurrenceIdTimeZone) instance.recurrenceIdTimeZone = recurrenceIdTimeZone;
+	return instance;
+}
+/**
+* Check if a patch contains a key or pointer.
+* @param patch Patch object to inspect.
+* @param key Field name to look up.
+* @return True when the patch modifies the field.
+*/
+function patchHasKey(patch, key) {
+	if (!patch) return false;
+	if (Object.prototype.hasOwnProperty.call(patch, key)) return true;
+	if (Object.prototype.hasOwnProperty.call(patch, `/${key}`)) return true;
+	return false;
+}
+/**
+* Strip recurrence properties from value.
+* @param object JSCalendar object to clean.
+* @return Object without recurrence rule fields.
+*/
+function stripRecurrenceProperties(object) {
+	const { recurrenceRules: _recurrenceRules, excludedRecurrenceRules: _excludedRecurrenceRules, recurrenceOverrides: _recurrenceOverrides, ...rest } = object;
+	return rest;
+}
+/**
+* Check whether value is excluded instance.
+* @param object JSCalendar object.
+* @return True when the occurrence is excluded.
+*/
+function isExcludedInstance(object) {
+	return object.excluded === true;
+}
+/**
+* Check whether value is in range.
+* @param value LocalDateTime string.
+* @param from LocalDateTime lower bound.
+* @param to LocalDateTime upper bound.
+* @return True when value is within the range.
+*/
+function isInRange(value, from, to) {
+	return value >= from && value <= to;
+}
+/**
+* Check whether value is in range with zone.
+* @param value LocalDateTime string.
+* @param from Date lower bound.
+* @param to Date upper bound.
+* @param timeZone Time zone for LocalDateTime conversion.
+* @return True when value is within the range.
+*/
+function isInRangeWithZone(value, from, to, timeZone) {
+	const utc = localDateTimeToUtcDate(value, timeZone);
+	return utc >= from && utc <= to;
+}
+/**
+* Compare local date-time strings, optionally using a time zone.
+* @param a LocalDateTime string A.
+* @param b LocalDateTime string B.
+* @param timeZone Optional time zone for comparison.
+* @return Negative/zero/positive comparison result.
+*/
+function compareLocal(a, b, timeZone) {
+	if (!timeZone) {
+		if (a === b) return 0;
+		return a < b ? -1 : 1;
+	}
+	const aUtc = localDateTimeToUtcDate(a, timeZone).getTime();
+	const bUtc = localDateTimeToUtcDate(b, timeZone).getTime();
+	if (aUtc === bUtc) return 0;
+	return aUtc < bUtc ? -1 : 1;
+}
+
+//#endregion
+//#region src/search.ts
+const TYPE_EVENT$2 = "Event";
+const TYPE_GROUP$2 = "Group";
+const TYPE_TASK$2 = "Task";
+/**
+* Find a JSCalendar object by UID.
+* @param items Items to search.
+* @param uid UID to match.
+* @return The matching item or undefined.
+*/
+function findByUid(items, uid) {
+	return items.find((item) => item.uid === uid);
+}
+/**
+* Filter items by JSCalendar @type.
+* @param items Items to filter.
+* @param type Type to match.
+* @return Filtered items.
+*/
+function filterByType(items, type) {
+	return items.filter((item) => item["@type"] === type);
+}
+/**
+* Group JSCalendar objects by @type.
+* @param items Items to group.
+* @return Record keyed by type.
+*/
+function groupByType(items) {
+	return items.reduce((acc, item) => {
+		const type = item["@type"];
+		if (!acc[type]) acc[type] = [];
+		acc[type].push(item);
+		return acc;
+	}, {});
+}
+/**
+* Filter items by free-text match.
+* @param items Items to search.
+* @param query Text query.
+* @return Filtered items.
+*/
+function filterByText(items, query) {
+	const needle = query.trim().toLowerCase();
+	if (!needle) return items;
+	return items.filter((item) => collectText(item).includes(needle));
+}
+/**
+* Filter items that intersect a date range.
+* @param items Items to filter.
+* @param range Range with optional start and end.
+* @param options Filtering options.
+* @return Filtered items.
+*/
+function filterByDateRange(items, range, options = {}) {
+	var _options$includeIncom;
+	const includeIncomparable = (_options$includeIncom = options.includeIncomparable) !== null && _options$includeIncom !== void 0 ? _options$includeIncom : false;
+	return items.filter((item) => {
+		var _item$timeZone;
+		const objectRange = getObjectRange(item);
+		if (!objectRange) return includeIncomparable;
+		if (range.start instanceof Date || range.end instanceof Date) {
+			var _objectRangeDate$end;
+			const objectRangeDate = getObjectRangeAsDates(item);
+			if (!objectRangeDate) return includeIncomparable;
+			const startDate = objectRangeDate.start;
+			const endDate = (_objectRangeDate$end = objectRangeDate.end) !== null && _objectRangeDate$end !== void 0 ? _objectRangeDate$end : objectRangeDate.start;
+			if (range.start instanceof Date) {
+				if (endDate < range.start) return false;
+			}
+			if (range.end instanceof Date) {
+				if (startDate > range.end) return false;
+			}
+			return true;
+		}
+		const timeZone = "timeZone" in item ? (_item$timeZone = item.timeZone) !== null && _item$timeZone !== void 0 ? _item$timeZone : void 0 : void 0;
+		const rangeStart = normalizeRangeValue(range.start, timeZone);
+		const rangeEnd = normalizeRangeValue(range.end, timeZone);
+		if (range.start) {
+			var _objectRange$end;
+			const cmpStart = compareDateTime((_objectRange$end = objectRange.end) !== null && _objectRange$end !== void 0 ? _objectRange$end : objectRange.start, rangeStart);
+			if (cmpStart === null) return includeIncomparable;
+			if (cmpStart < 0) return false;
+		}
+		if (range.end) {
+			const cmpEnd = compareDateTime(objectRange.start, rangeEnd);
+			if (cmpEnd === null) return includeIncomparable;
+			if (cmpEnd > 0) return false;
+		}
+		return true;
+	});
+}
+/**
+* Normalize a range value into a LocalDateTime or UTCDateTime string.
+* @param value Range value.
+* @param timeZone Optional time zone.
+* @return Normalized date-time string.
+*/
+function normalizeRangeValue(value, timeZone) {
+	if (!value) return "";
+	if (isStringValue(value)) return value;
+	if (timeZone) return dateTimeInTimeZone(value, timeZone);
+	return localDateTimeFromDate(value);
+}
+/**
+* Collect searchable text from a JSCalendar object.
+* @param item Item to inspect.
+* @return Lowercased text blob.
+*/
+function collectText(item) {
+	const parts = [];
+	if (item.title) parts.push(item.title);
+	if (item.description) parts.push(item.description);
+	if (item.locations) for (const location of Object.values(item.locations)) {
+		if (location.name) parts.push(location.name);
+		if (location.description) parts.push(location.description);
+	}
+	if (item.virtualLocations) for (const vloc of Object.values(item.virtualLocations)) {
+		if (vloc.name) parts.push(vloc.name);
+		if (vloc.description) parts.push(vloc.description);
+		if (vloc.uri) parts.push(vloc.uri);
+	}
+	if (item.participants) for (const participant of Object.values(item.participants)) {
+		if (participant.name) parts.push(participant.name);
+		if (participant.email) parts.push(participant.email);
+		if (participant.description) parts.push(participant.description);
+	}
+	return parts.join(" ").toLowerCase();
+}
+/**
+* Get the string-based time range for an object.
+* @param item JSCalendar object.
+* @return Range or null if unavailable.
+*/
+function getObjectRange(item) {
+	if (item["@type"] === TYPE_EVENT$2) return getEventRange(item);
+	if (item["@type"] === TYPE_TASK$2) return getTaskRange(item);
+	if (item["@type"] === TYPE_GROUP$2) return getGroupRange(item);
+	return null;
+}
+/**
+* Get the Date-based time range for an object.
+* @param item JSCalendar object.
+* @return Range or null if unavailable.
+*/
+function getObjectRangeAsDates(item) {
+	if (item["@type"] === TYPE_EVENT$2) return getEventRangeAsDates(item);
+	if (item["@type"] === TYPE_TASK$2) return getTaskRangeAsDates(item);
+	if (item["@type"] === TYPE_GROUP$2) return getGroupRangeAsDates(item);
+	return null;
+}
+/**
+* Get the string-based range for an event.
+* @param event Event instance.
+* @return Event range.
+*/
+function getEventRange(event) {
+	if (!event.duration) return { start: event.start };
+	if (isUtcDateTime(event.start)) {
+		const ms = durationToMilliseconds(event.duration);
+		if (ms !== null) {
+			const end = new Date(Date.parse(event.start) + ms).toISOString().replace(/\.000Z$/, "Z");
+			return {
+				start: event.start,
+				end
+			};
+		}
+	}
+	return { start: event.start };
+}
+/**
+* Get the Date-based range for an event.
+* @param event Event instance.
+* @return Event range or null if incomparable.
+*/
+function getEventRangeAsDates(event) {
+	const start = event.timeZone ? localDateTimeToUtcDate(event.start, event.timeZone) : isUtcDateTime(event.start) ? new Date(event.start) : null;
+	if (!start) return null;
+	if (!event.duration) return { start };
+	const ms = durationToMilliseconds(event.duration);
+	if (ms === null) return { start };
+	return {
+		start,
+		end: new Date(start.getTime() + ms)
+	};
+}
+/**
+* Get the string-based range for a task.
+* @param task Task instance.
+* @return Task range or null if missing.
+*/
+function getTaskRange(task) {
+	var _task$start;
+	const start = (_task$start = task.start) !== null && _task$start !== void 0 ? _task$start : task.due;
+	if (!start) return null;
+	return { start };
+}
+/**
+* Get the Date-based range for a task.
+* @param task Task instance.
+* @return Task range or null if incomparable.
+*/
+function getTaskRangeAsDates(task) {
+	var _task$start2;
+	const start = (_task$start2 = task.start) !== null && _task$start2 !== void 0 ? _task$start2 : task.due;
+	if (!start) return null;
+	if (task.timeZone) return { start: localDateTimeToUtcDate(start, task.timeZone) };
+	if (isUtcDateTime(start)) return { start: new Date(start) };
+	return null;
+}
+/**
+* Get the string-based range for a group.
+* @param group Group instance.
+* @return Group range or null if empty.
+*/
+function getGroupRange(group) {
+	const ranges = group.entries.map((entry) => getObjectRange(entry)).filter((range) => Boolean(range));
+	if (ranges.length === 0) return null;
+	const starts = ranges.map((range) => range.start).sort();
+	const ends = ranges.map((range) => {
+		var _range$end;
+		return (_range$end = range.end) !== null && _range$end !== void 0 ? _range$end : range.start;
+	}).sort();
+	const start = starts[0];
+	const end = ends[ends.length - 1];
+	if (!start || !end) return null;
+	return {
+		start,
+		end
+	};
+}
+/**
+* Get the Date-based range for a group.
+* @param group Group instance.
+* @return Group range or null if empty.
+*/
+function getGroupRangeAsDates(group) {
+	const ranges = group.entries.map((entry) => getObjectRangeAsDates(entry)).filter((range) => Boolean(range));
+	if (ranges.length === 0) return null;
+	const starts = ranges.map((range) => range.start.getTime()).sort((a, b) => a - b);
+	const ends = ranges.map((range) => {
+		var _range$end2;
+		return ((_range$end2 = range.end) !== null && _range$end2 !== void 0 ? _range$end2 : range.start).getTime();
+	}).sort((a, b) => a - b);
+	const start = starts[0];
+	const end = ends[ends.length - 1];
+	if (start === void 0 || end === void 0) return null;
+	return {
+		start: new Date(start),
+		end: new Date(end)
+	};
+}
+
+//#endregion
+//#region src/timezones.ts
+const TimeZones = [
+	"Africa/Abidjan",
+	"Africa/Accra",
+	"Africa/Addis_Ababa",
+	"Africa/Algiers",
+	"Africa/Asmara",
+	"Africa/Bamako",
+	"Africa/Bangui",
+	"Africa/Banjul",
+	"Africa/Bissau",
+	"Africa/Blantyre",
+	"Africa/Brazzaville",
+	"Africa/Bujumbura",
+	"Africa/Cairo",
+	"Africa/Casablanca",
+	"Africa/Ceuta",
+	"Africa/Conakry",
+	"Africa/Dakar",
+	"Africa/Dar_es_Salaam",
+	"Africa/Djibouti",
+	"Africa/Douala",
+	"Africa/El_Aaiun",
+	"Africa/Freetown",
+	"Africa/Gaborone",
+	"Africa/Harare",
+	"Africa/Johannesburg",
+	"Africa/Juba",
+	"Africa/Kampala",
+	"Africa/Khartoum",
+	"Africa/Kigali",
+	"Africa/Kinshasa",
+	"Africa/Lagos",
+	"Africa/Libreville",
+	"Africa/Lome",
+	"Africa/Luanda",
+	"Africa/Lubumbashi",
+	"Africa/Lusaka",
+	"Africa/Malabo",
+	"Africa/Maputo",
+	"Africa/Maseru",
+	"Africa/Mbabane",
+	"Africa/Mogadishu",
+	"Africa/Monrovia",
+	"Africa/Nairobi",
+	"Africa/Ndjamena",
+	"Africa/Niamey",
+	"Africa/Nouakchott",
+	"Africa/Ouagadougou",
+	"Africa/Porto-Novo",
+	"Africa/Sao_Tome",
+	"Africa/Tripoli",
+	"Africa/Tunis",
+	"Africa/Windhoek",
+	"America/Adak",
+	"America/Anchorage",
+	"America/Anguilla",
+	"America/Antigua",
+	"America/Araguaina",
+	"America/Argentina/Buenos_Aires",
+	"America/Argentina/Catamarca",
+	"America/Argentina/Cordoba",
+	"America/Argentina/Jujuy",
+	"America/Argentina/La_Rioja",
+	"America/Argentina/Mendoza",
+	"America/Argentina/Rio_Gallegos",
+	"America/Argentina/Salta",
+	"America/Argentina/San_Juan",
+	"America/Argentina/San_Luis",
+	"America/Argentina/Tucuman",
+	"America/Argentina/Ushuaia",
+	"America/Aruba",
+	"America/Asuncion",
+	"America/Atikokan",
+	"America/Bahia",
+	"America/Bahia_Banderas",
+	"America/Barbados",
+	"America/Belem",
+	"America/Belize",
+	"America/Blanc-Sablon",
+	"America/Boa_Vista",
+	"America/Bogota",
+	"America/Boise",
+	"America/Cambridge_Bay",
+	"America/Campo_Grande",
+	"America/Cancun",
+	"America/Caracas",
+	"America/Cayenne",
+	"America/Cayman",
+	"America/Chicago",
+	"America/Chihuahua",
+	"America/Costa_Rica",
+	"America/Creston",
+	"America/Cuiaba",
+	"America/Curacao",
+	"America/Danmarkshavn",
+	"America/Dawson",
+	"America/Dawson_Creek",
+	"America/Denver",
+	"America/Detroit",
+	"America/Dominica",
+	"America/Edmonton",
+	"America/Eirunepe",
+	"America/El_Salvador",
+	"America/Fort_Nelson",
+	"America/Fortaleza",
+	"America/Glace_Bay",
+	"America/Godthab",
+	"America/Goose_Bay",
+	"America/Grand_Turk",
+	"America/Grenada",
+	"America/Guadeloupe",
+	"America/Guatemala",
+	"America/Guayaquil",
+	"America/Guyana",
+	"America/Halifax",
+	"America/Havana",
+	"America/Hermosillo",
+	"America/Indiana/Indianapolis",
+	"America/Indiana/Knox",
+	"America/Indiana/Marengo",
+	"America/Indiana/Petersburg",
+	"America/Indiana/Tell_City",
+	"America/Indiana/Vevay",
+	"America/Indiana/Vincennes",
+	"America/Indiana/Winamac",
+	"America/Inuvik",
+	"America/Iqaluit",
+	"America/Jamaica",
+	"America/Juneau",
+	"America/Kentucky/Louisville",
+	"America/Kentucky/Monticello",
+	"America/Kralendijk",
+	"America/La_Paz",
+	"America/Lima",
+	"America/Los_Angeles",
+	"America/Lower_Princes",
+	"America/Maceio",
+	"America/Managua",
+	"America/Manaus",
+	"America/Marigot",
+	"America/Martinique",
+	"America/Matamoros",
+	"America/Mazatlan",
+	"America/Menominee",
+	"America/Merida",
+	"America/Metlakatla",
+	"America/Mexico_City",
+	"America/Miquelon",
+	"America/Moncton",
+	"America/Monterrey",
+	"America/Montevideo",
+	"America/Montserrat",
+	"America/Nassau",
+	"America/New_York",
+	"America/Nipigon",
+	"America/Nome",
+	"America/Noronha",
+	"America/North_Dakota/Beulah",
+	"America/North_Dakota/Center",
+	"America/North_Dakota/New_Salem",
+	"America/Ojinaga",
+	"America/Panama",
+	"America/Pangnirtung",
+	"America/Paramaribo",
+	"America/Phoenix",
+	"America/Port-au-Prince",
+	"America/Port_of_Spain",
+	"America/Porto_Velho",
+	"America/Puerto_Rico",
+	"America/Punta_Arenas",
+	"America/Rainy_River",
+	"America/Rankin_Inlet",
+	"America/Recife",
+	"America/Regina",
+	"America/Resolute",
+	"America/Rio_Branco",
+	"America/Santarem",
+	"America/Santiago",
+	"America/Santo_Domingo",
+	"America/Sao_Paulo",
+	"America/Scoresbysund",
+	"America/Sitka",
+	"America/St_Barthelemy",
+	"America/St_Johns",
+	"America/St_Kitts",
+	"America/St_Lucia",
+	"America/St_Thomas",
+	"America/St_Vincent",
+	"America/Swift_Current",
+	"America/Tegucigalpa",
+	"America/Thule",
+	"America/Thunder_Bay",
+	"America/Tijuana",
+	"America/Toronto",
+	"America/Tortola",
+	"America/Vancouver",
+	"America/Whitehorse",
+	"America/Winnipeg",
+	"America/Yakutat",
+	"America/Yellowknife",
+	"Antarctica/Casey",
+	"Antarctica/Davis",
+	"Antarctica/DumontDUrville",
+	"Antarctica/Macquarie",
+	"Antarctica/Mawson",
+	"Antarctica/McMurdo",
+	"Antarctica/Palmer",
+	"Antarctica/Rothera",
+	"Antarctica/Syowa",
+	"Antarctica/Troll",
+	"Antarctica/Vostok",
+	"Arctic/Longyearbyen",
+	"Asia/Aden",
+	"Asia/Almaty",
+	"Asia/Amman",
+	"Asia/Anadyr",
+	"Asia/Aqtau",
+	"Asia/Aqtobe",
+	"Asia/Ashgabat",
+	"Asia/Atyrau",
+	"Asia/Baghdad",
+	"Asia/Bahrain",
+	"Asia/Baku",
+	"Asia/Bangkok",
+	"Asia/Barnaul",
+	"Asia/Beirut",
+	"Asia/Bishkek",
+	"Asia/Brunei",
+	"Asia/Chita",
+	"Asia/Choibalsan",
+	"Asia/Colombo",
+	"Asia/Damascus",
+	"Asia/Dhaka",
+	"Asia/Dili",
+	"Asia/Dubai",
+	"Asia/Dushanbe",
+	"Asia/Famagusta",
+	"Asia/Gaza",
+	"Asia/Hebron",
+	"Asia/Ho_Chi_Minh",
+	"Asia/Hong_Kong",
+	"Asia/Hovd",
+	"Asia/Irkutsk",
+	"Asia/Jakarta",
+	"Asia/Jayapura",
+	"Asia/Jerusalem",
+	"Asia/Kabul",
+	"Asia/Kamchatka",
+	"Asia/Karachi",
+	"Asia/Kathmandu",
+	"Asia/Khandyga",
+	"Asia/Kolkata",
+	"Asia/Krasnoyarsk",
+	"Asia/Kuala_Lumpur",
+	"Asia/Kuching",
+	"Asia/Kuwait",
+	"Asia/Macau",
+	"Asia/Magadan",
+	"Asia/Makassar",
+	"Asia/Manila",
+	"Asia/Muscat",
+	"Asia/Nicosia",
+	"Asia/Novokuznetsk",
+	"Asia/Novosibirsk",
+	"Asia/Omsk",
+	"Asia/Oral",
+	"Asia/Phnom_Penh",
+	"Asia/Pontianak",
+	"Asia/Pyongyang",
+	"Asia/Qatar",
+	"Asia/Qyzylorda",
+	"Asia/Riyadh",
+	"Asia/Sakhalin",
+	"Asia/Samarkand",
+	"Asia/Seoul",
+	"Asia/Shanghai",
+	"Asia/Singapore",
+	"Asia/Srednekolymsk",
+	"Asia/Taipei",
+	"Asia/Tashkent",
+	"Asia/Tbilisi",
+	"Asia/Tehran",
+	"Asia/Thimphu",
+	"Asia/Tokyo",
+	"Asia/Tomsk",
+	"Asia/Ulaanbaatar",
+	"Asia/Urumqi",
+	"Asia/Ust-Nera",
+	"Asia/Vientiane",
+	"Asia/Vladivostok",
+	"Asia/Yakutsk",
+	"Asia/Yangon",
+	"Asia/Yekaterinburg",
+	"Asia/Yerevan",
+	"Atlantic/Azores",
+	"Atlantic/Bermuda",
+	"Atlantic/Canary",
+	"Atlantic/Cape_Verde",
+	"Atlantic/Faroe",
+	"Atlantic/Madeira",
+	"Atlantic/Reykjavik",
+	"Atlantic/South_Georgia",
+	"Atlantic/St_Helena",
+	"Atlantic/Stanley",
+	"Australia/Adelaide",
+	"Australia/Brisbane",
+	"Australia/Broken_Hill",
+	"Australia/Currie",
+	"Australia/Darwin",
+	"Australia/Eucla",
+	"Australia/Hobart",
+	"Australia/Lindeman",
+	"Australia/Lord_Howe",
+	"Australia/Melbourne",
+	"Australia/Perth",
+	"Australia/Sydney",
+	"Europe/Amsterdam",
+	"Europe/Andorra",
+	"Europe/Astrakhan",
+	"Europe/Athens",
+	"Europe/Belgrade",
+	"Europe/Berlin",
+	"Europe/Bratislava",
+	"Europe/Brussels",
+	"Europe/Bucharest",
+	"Europe/Budapest",
+	"Europe/Busingen",
+	"Europe/Chisinau",
+	"Europe/Copenhagen",
+	"Europe/Dublin",
+	"Europe/Gibraltar",
+	"Europe/Guernsey",
+	"Europe/Helsinki",
+	"Europe/Isle_of_Man",
+	"Europe/Istanbul",
+	"Europe/Jersey",
+	"Europe/Kaliningrad",
+	"Europe/Kiev",
+	"Europe/Kirov",
+	"Europe/Lisbon",
+	"Europe/Ljubljana",
+	"Europe/London",
+	"Europe/Luxembourg",
+	"Europe/Madrid",
+	"Europe/Malta",
+	"Europe/Mariehamn",
+	"Europe/Minsk",
+	"Europe/Monaco",
+	"Europe/Moscow",
+	"Europe/Oslo",
+	"Europe/Paris",
+	"Europe/Podgorica",
+	"Europe/Prague",
+	"Europe/Riga",
+	"Europe/Rome",
+	"Europe/Samara",
+	"Europe/San_Marino",
+	"Europe/Sarajevo",
+	"Europe/Saratov",
+	"Europe/Simferopol",
+	"Europe/Skopje",
+	"Europe/Sofia",
+	"Europe/Stockholm",
+	"Europe/Tallinn",
+	"Europe/Tirane",
+	"Europe/Ulyanovsk",
+	"Europe/Uzhgorod",
+	"Europe/Vaduz",
+	"Europe/Vatican",
+	"Europe/Vienna",
+	"Europe/Vilnius",
+	"Europe/Volgograd",
+	"Europe/Warsaw",
+	"Europe/Zagreb",
+	"Europe/Zaporozhye",
+	"Europe/Zurich",
+	"Indian/Antananarivo",
+	"Indian/Chagos",
+	"Indian/Christmas",
+	"Indian/Cocos",
+	"Indian/Comoro",
+	"Indian/Kerguelen",
+	"Indian/Mahe",
+	"Indian/Maldives",
+	"Indian/Mauritius",
+	"Indian/Mayotte",
+	"Indian/Reunion",
+	"Pacific/Apia",
+	"Pacific/Auckland",
+	"Pacific/Bougainville",
+	"Pacific/Chatham",
+	"Pacific/Chuuk",
+	"Pacific/Easter",
+	"Pacific/Efate",
+	"Pacific/Enderbury",
+	"Pacific/Fakaofo",
+	"Pacific/Fiji",
+	"Pacific/Funafuti",
+	"Pacific/Galapagos",
+	"Pacific/Gambier",
+	"Pacific/Guadalcanal",
+	"Pacific/Guam",
+	"Pacific/Honolulu",
+	"Pacific/Kiritimati",
+	"Pacific/Kosrae",
+	"Pacific/Kwajalein",
+	"Pacific/Majuro",
+	"Pacific/Marquesas",
+	"Pacific/Midway",
+	"Pacific/Nauru",
+	"Pacific/Niue",
+	"Pacific/Norfolk",
+	"Pacific/Noumea",
+	"Pacific/Pago_Pago",
+	"Pacific/Palau",
+	"Pacific/Pitcairn",
+	"Pacific/Pohnpei",
+	"Pacific/Port_Moresby",
+	"Pacific/Rarotonga",
+	"Pacific/Saipan",
+	"Pacific/Tahiti",
+	"Pacific/Tarawa",
+	"Pacific/Tongatapu",
+	"Pacific/Wake",
+	"Pacific/Wallis"
+];
+/**
+* Build a lowercase lookup map for time zones.
+* @param zones List of time zone IDs.
+* @return Map keyed by lowercase ID.
+*/
+function createTimeZoneMap(zones) {
+	const map = {};
+	for (const tz of zones) map[tz.toLowerCase()] = tz;
+	return map;
+}
+const TimeZoneMap = createTimeZoneMap(TimeZones);
+/**
+* Resolve a time zone input to its canonical ID.
+* @param input Time zone input.
+* @return Canonical TimeZoneId.
+*/
+function resolveTimeZone(input) {
+	const value = TimeZoneMap[input.toLowerCase()];
+	if (!value) throw new Error(`Unknown time zone: ${input}`);
+	return value;
+}
+
+//#endregion
+//#region src/validate/error.ts
+/**
+* Error thrown when validation fails.
+*/
+var ValidationError = class extends Error {
+	path;
+	/**
+	* Create a new ValidationError.
+	* @param path Validation path.
+	* @param message Error message.
+	*/
+	constructor(path, message) {
+		super(`${path}: ${message}`);
+		this.name = "ValidationError";
+		this.path = path;
+	}
+};
+/**
+* Throw a ValidationError.
+* @param path Validation path.
+* @param message Error message.
+* @return Never returns.
+*/
+function fail(path, message) {
+	throw new ValidationError(path, message);
+}
+
+//#endregion
+//#region src/validate/constants.ts
+const Z_SUFFIX = "Z";
+const CHARSET_KEY = "charset";
+const UTF8 = "utf-8";
+const RSCALE_GREGORIAN = "gregorian";
+const TYPE_NDAY$1 = "NDay";
+const TYPE_RECURRENCE_RULE$1 = "RecurrenceRule";
+const TYPE_ALERT$1 = "Alert";
+const TYPE_OFFSET_TRIGGER$1 = "OffsetTrigger";
+const TYPE_ABSOLUTE_TRIGGER$1 = "AbsoluteTrigger";
+const TYPE_RELATION$1 = "Relation";
+const TYPE_LINK$1 = "Link";
+const TYPE_LOCATION$1 = "Location";
+const TYPE_VIRTUAL_LOCATION$1 = "VirtualLocation";
+const TYPE_TIME_ZONE_RULE$1 = "TimeZoneRule";
+const TYPE_TIME_ZONE$1 = "TimeZone";
+const TYPE_PARTICIPANT$1 = "Participant";
+const TYPE_EVENT$1 = "Event";
+const TYPE_TASK$1 = "Task";
+const TYPE_GROUP$1 = "Group";
+const DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z)?$/;
+const DURATION = /^-?P(?:(\d+)W(?:(\d+)D)?|(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)(?:\.(\d+))?S)?)?$/;
+const DAY_OF_WEEK = new Set([
+	"mo",
+	"tu",
+	"we",
+	"th",
+	"fr",
+	"sa",
+	"su"
+]);
+const RECURRENCE_FREQUENCY = new Set([
+	"yearly",
+	"monthly",
+	"weekly",
+	"daily",
+	"hourly",
+	"minutely",
+	"secondly"
+]);
+const SKIP = new Set([
+	"omit",
+	"backward",
+	"forward"
+]);
+const ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+//#endregion
+//#region src/validate/asserts.ts
+const TYPEOF_UNDEFINED = "undefined";
+/**
+* Get the UTF-8 byte length of a string.
+* @param value Input string.
+* @return Byte length.
+*/
+function utf8Length(value) {
+	if (typeof TextEncoder !== TYPEOF_UNDEFINED) return new TextEncoder().encode(value).length;
+	return value.length;
+}
+/**
+* Check whether a value is a plain record.
+* @param value Input value.
+* @return True if the value is a record.
+*/
+function isRecord(value) {
+	return !!value && isObjectValue(value) && !Array.isArray(value);
+}
+/**
+* Assert a value is a string when defined.
+* @param value Value to check.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertString(value, path) {
+	if (value === void 0 || value === null) return;
+	if (!isStringValue(value)) fail(path, "must be a string");
+}
+/**
+* Assert a value is a non-empty string when defined.
+* @param value Value to check.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertNonEmptyString(value, path) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be a string");
+	if (value.length === 0) fail(path, "must not be empty");
+}
+/**
+* Assert a value is a valid Id when defined.
+* @param value Value to check.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertId(value, path) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be an Id");
+	const length = utf8Length(value);
+	if (length < 1 || length > 255) fail(path, "must be between 1 and 255 octets");
+	if (!ID_PATTERN.test(value)) fail(path, "must use base64url characters");
+}
+/**
+* Assert a value is boolean when defined.
+* @param value Value to check.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertBoolean(value, path) {
+	if (value === void 0 || value === null) return;
+	if (!isBooleanValue(value)) fail(path, "must be a boolean");
+}
+/**
+* Assert a value is an integer when defined.
+* @param value Value to check.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertInteger(value, path) {
+	if (value === void 0 || value === null) return;
+	if (!isNumberValue(value) || !Number.isInteger(value)) fail(path, "must be an integer");
+}
+/**
+* Assert a value is a non-negative integer when defined.
+* @param value Value to check.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertUnsignedInt(value, path) {
+	if (value === void 0 || value === null) return;
+	if (!isNumberValue(value) || !Number.isInteger(value) || value < 0) fail(path, "must be a non-negative integer");
+}
+/**
+* Assert a date-time string matches the expected format.
+* @param value Date-time string.
+* @param path Validation path.
+* @param requireZ Whether a Z suffix is required.
+* @return Nothing.
+*/
+function assertDateTime(value, path, requireZ) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be a date-time string");
+	const match = value.match(DATE_TIME);
+	if (!match) fail(path, requireZ ? "must be a UTCDateTime (YYYY-MM-DDTHH:mm:ssZ)" : "must be a LocalDateTime (YYYY-MM-DDTHH:mm:ss)");
+	const [, year, month, day, hour, minute, second, fraction, zFlag] = match;
+	if (requireZ && zFlag !== Z_SUFFIX) fail(path, "must use Z suffix");
+	if (!requireZ && zFlag) fail(path, "must not include time zone offset");
+	const monthNum = Number.parseInt(month !== null && month !== void 0 ? month : "0", 10);
+	const dayNum = Number.parseInt(day !== null && day !== void 0 ? day : "0", 10);
+	const hourNum = Number.parseInt(hour !== null && hour !== void 0 ? hour : "0", 10);
+	const minuteNum = Number.parseInt(minute !== null && minute !== void 0 ? minute : "0", 10);
+	const secondNum = Number.parseInt(second !== null && second !== void 0 ? second : "0", 10);
+	if (monthNum < 1 || monthNum > 12) fail(path, "month must be 01-12");
+	if (dayNum < 1 || dayNum > 31) fail(path, "day must be 01-31");
+	if (hourNum < 0 || hourNum > 23) fail(path, "hour must be 00-23");
+	if (minuteNum < 0 || minuteNum > 59) fail(path, "minute must be 00-59");
+	if (secondNum < 0 || secondNum > 59) fail(path, "second must be 00-59");
+	if (fraction !== void 0) {
+		if (fraction.length > 9) fail(path, "fractional seconds must be 1-9 digits");
+		if (/^0+$/.test(fraction)) fail(path, "fractional seconds must be non-zero");
+		if (fraction.endsWith("0")) fail(path, "fractional seconds must not have trailing zeros");
+	}
+}
+/**
+* Assert local date time when provided.
+* @param value LocalDateTime string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertLocalDateTime(value, path) {
+	return assertDateTime(value, path, false);
+}
+/**
+* Assert utc date time when provided.
+* @param value UTCDateTime string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertUtcDateTime(value, path) {
+	return assertDateTime(value, path, true);
+}
+/**
+* Assert duration like when provided.
+* @param value Duration string.
+* @param path Validation path.
+* @param signed Whether negative values are allowed.
+* @return Nothing.
+*/
+function assertDurationLike(value, path, signed) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be a duration string");
+	if (!signed && value.startsWith("-")) fail(path, "must not be negative");
+	const match = value.match(DURATION);
+	if (!match) fail(path, "must be an ISO 8601 duration");
+	const week = match[1];
+	const dayFromWeek = match[2];
+	const day = match[3];
+	const hour = match[4];
+	const minute = match[5];
+	const second = match[6];
+	const fraction = match[7];
+	if (!(!!week || !!dayFromWeek || !!day) && !(!!hour || !!minute || !!second)) fail(path, "must include at least one duration component");
+	if (fraction !== void 0) {
+		if (fraction.length > 9) fail(path, "fractional seconds must be 1-9 digits");
+		if (/^0+$/.test(fraction)) fail(path, "fractional seconds must be non-zero");
+		if (fraction.endsWith("0")) fail(path, "fractional seconds must not have trailing zeros");
+	}
+}
+/**
+* Assert duration when provided.
+* @param value Duration string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertDuration(value, path) {
+	return assertDurationLike(value, path, false);
+}
+/**
+* Assert signed duration when provided.
+* @param value Duration string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertSignedDuration(value, path) {
+	return assertDurationLike(value, path, true);
+}
+/**
+* Assert boolean map when provided.
+* @param value Boolean map object.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertBooleanMap(value, path) {
+	if (value === void 0) return;
+	if (!isRecord(value)) fail(path, "must be a boolean map object");
+	for (const [key, entry] of Object.entries(value)) if (entry !== true) fail(`${path}.${key}`, "must be true");
+}
+/**
+* Assert ID boolean map when provided.
+* @param value Boolean map object keyed by Ids.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertIdBooleanMap(value, path) {
+	if (value === void 0) return;
+	if (!isRecord(value)) fail(path, "must be a boolean map object");
+	for (const [key, entry] of Object.entries(value)) {
+		assertId(key, `${path}.${key}`);
+		if (entry !== true) fail(`${path}.${key}`, "must be true");
+	}
+}
+/**
+* Assert media type when provided.
+* @param value Media type string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertMediaType(value, path) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be a media type string");
+	const [typePart, ...params] = value.split(";");
+	const mediaType = (typePart !== null && typePart !== void 0 ? typePart : "").trim();
+	if (!/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/.test(mediaType)) fail(path, "must be a valid media type");
+	for (const param of params) {
+		const [rawKey, rawValue] = param.split("=");
+		if (!rawKey || !rawValue) continue;
+		const key = rawKey.trim().toLowerCase();
+		const valuePart = rawValue.trim().toLowerCase();
+		if (key === CHARSET_KEY && valuePart !== UTF8) fail(path, "charset parameter must be utf-8");
+	}
+}
+/**
+* Assert text content type when provided.
+* @param value Media type string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertTextContentType(value, path) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be a media type string");
+	const [typePart] = value.split(";");
+	if (!(typePart !== null && typePart !== void 0 ? typePart : "").trim().startsWith("text/")) fail(path, "must be a text/* media type");
+	assertMediaType(value, path);
+}
+/**
+* Assert content ID when provided.
+* @param value Content-ID string.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertContentId(value, path) {
+	if (value === void 0) return;
+	if (!isStringValue(value)) fail(path, "must be a content-id");
+	const trimmed = value.trim();
+	const hasBrackets = trimmed.startsWith("<") || trimmed.endsWith(">");
+	if (hasBrackets && !(trimmed.startsWith("<") && trimmed.endsWith(">"))) fail(path, "must use matching angle brackets");
+	const raw = hasBrackets ? trimmed.slice(1, -1) : trimmed;
+	if (!/^[^\s<>@]+@[^\s<>@]+$/.test(raw)) fail(path, "must be a content-id");
+}
+/**
+* Assert time zone when provided.
+* @param value Time zone ID.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertTimeZone(value, path) {
+	if (value === void 0 || value === null) return;
+	if (!isStringValue(value)) fail(path, "must be a time zone ID");
+	for (const tz of TimeZones) if (tz === value) return;
+	fail(path, "must be a supported time zone ID");
+}
+/**
+* Assert json value when provided.
+* @param value JSON value.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertJsonValue(value, path) {
+	if (value === void 0) fail(path, "must be a JSON value");
+	if (value === null) return;
+	if (isStringValue(value) || isNumberValue(value) || isBooleanValue(value)) return;
+	if (Array.isArray(value)) {
+		value.forEach((entry, index) => assertJsonValue(entry, `${path}[${index}]`));
+		return;
+	}
+	if (isObjectValue(value)) {
+		if (!isRecord(value)) fail(path, "must be a JSON object");
+		for (const [key, entry] of Object.entries(value)) assertJsonValue(entry, `${path}.${key}`);
+		return;
+	}
+	fail(path, "must be a JSON value");
+}
+/**
+* Assert patch object when provided.
+* @param value PatchObject.
+* @param path Validation path.
+* @return Nothing.
+*/
+function assertPatchObject(value, path) {
+	if (value === void 0) return;
+	if (!isRecord(value)) fail(path, "must be a PatchObject");
+	for (const [key, entry] of Object.entries(value)) {
+		if (entry === null) continue;
+		assertJsonValue(entry, `${path}.${key}`);
+	}
+}
+
+//#endregion
+//#region src/validate/validators-recurrence.ts
+/**
+* Validate n day structure.
+* @param value NDay object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateNDay(value, path) {
+	if (value["@type"] !== TYPE_NDAY$1) fail(path, "must have @type NDay");
+	if (!DAY_OF_WEEK.has(value.day)) fail(`${path}.day`, "must be a valid day of week");
+	assertInteger(value.nthOfPeriod, `${path}.nthOfPeriod`);
+}
+/**
+* Validate recurrence rule structure.
+* @param value RecurrenceRule object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateRecurrenceRule(value, path) {
+	if (value["@type"] !== TYPE_RECURRENCE_RULE$1) fail(path, "must have @type RecurrenceRule");
+	if (!RECURRENCE_FREQUENCY.has(value.frequency)) fail(`${path}.frequency`, "must be a valid frequency");
+	assertUnsignedInt(value.interval, `${path}.interval`);
+	assertUnsignedInt(value.count, `${path}.count`);
+	if (value.rscale !== void 0 && value.rscale !== RSCALE_GREGORIAN) fail(`${path}.rscale`, "only gregorian is supported");
+	if (value.skip !== void 0 && !SKIP.has(value.skip)) fail(`${path}.skip`, "must be omit, backward, or forward");
+	if (value.firstDayOfWeek !== void 0 && !DAY_OF_WEEK.has(value.firstDayOfWeek)) fail(`${path}.firstDayOfWeek`, "must be a valid day of week");
+	if (value.byDay) for (let i = 0; i < value.byDay.length; i += 1) {
+		const entry = value.byDay[i];
+		if (!entry) continue;
+		validateNDay(entry, `${path}.byDay[${i}]`);
+	}
+	if (value.byMonthDay) for (let i = 0; i < value.byMonthDay.length; i += 1) {
+		const entry = value.byMonthDay[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry === 0 || entry < -31 || entry > 31) fail(`${path}.byMonthDay[${i}]`, "must be an integer between -31 and 31, excluding 0");
+	}
+	if (value.byMonth) for (let i = 0; i < value.byMonth.length; i += 1) {
+		const entry = value.byMonth[i];
+		if (!isStringValue(entry)) fail(`${path}.byMonth[${i}]`, "must be a string month");
+		const numeric = Number.parseInt(entry, 10);
+		if (!Number.isInteger(numeric) || numeric < 1 || numeric > 12) fail(`${path}.byMonth[${i}]`, "must be a month number between 1 and 12");
+	}
+	if (value.byYearDay) for (let i = 0; i < value.byYearDay.length; i += 1) {
+		const entry = value.byYearDay[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry === 0 || entry < -366 || entry > 366) fail(`${path}.byYearDay[${i}]`, "must be an integer between -366 and 366, excluding 0");
+	}
+	if (value.byWeekNo) for (let i = 0; i < value.byWeekNo.length; i += 1) {
+		const entry = value.byWeekNo[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry === 0 || entry < -53 || entry > 53) fail(`${path}.byWeekNo[${i}]`, "must be an integer between -53 and 53, excluding 0");
+	}
+	if (value.byHour) for (let i = 0; i < value.byHour.length; i += 1) {
+		const entry = value.byHour[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry < 0 || entry > 23) fail(`${path}.byHour[${i}]`, "must be an integer between 0 and 23");
+	}
+	if (value.byMinute) for (let i = 0; i < value.byMinute.length; i += 1) {
+		const entry = value.byMinute[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry < 0 || entry > 59) fail(`${path}.byMinute[${i}]`, "must be an integer between 0 and 59");
+	}
+	if (value.bySecond) for (let i = 0; i < value.bySecond.length; i += 1) {
+		const entry = value.bySecond[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry < 0 || entry > 59) fail(`${path}.bySecond[${i}]`, "must be an integer between 0 and 59");
+	}
+	if (value.bySetPosition) for (let i = 0; i < value.bySetPosition.length; i += 1) {
+		const entry = value.bySetPosition[i];
+		if (!isNumberValue(entry) || !Number.isInteger(entry) || entry === 0) fail(`${path}.bySetPosition[${i}]`, "must be a non-zero integer");
+	}
+	assertLocalDateTime(value.until, `${path}.until`);
+}
+
+//#endregion
+//#region src/validate/validators-common.ts
+/**
+* Validate alert structure.
+* @param value Alert object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateAlert(value, path) {
+	if (value["@type"] !== TYPE_ALERT$1) fail(path, "must have @type Alert");
+	if (!value.trigger) fail(`${path}.trigger`, "is required");
+	if (value.trigger["@type"] === TYPE_OFFSET_TRIGGER$1) {
+		const offset = value.trigger.offset;
+		if (!isStringValue(offset)) fail(`${path}.trigger.offset`, "must be a duration string");
+		assertSignedDuration(offset, `${path}.trigger.offset`);
+	} else if (value.trigger["@type"] === TYPE_ABSOLUTE_TRIGGER$1) {
+		const when = value.trigger.when;
+		if (!isStringValue(when)) fail(`${path}.trigger.when`, "must be a UTCDateTime string");
+		assertUtcDateTime(when, `${path}.trigger.when`);
+	}
+	assertUtcDateTime(value.acknowledged, `${path}.acknowledged`);
+	assertString(value.action, `${path}.action`);
+	if (value.relatedTo) {
+		if (!isObjectValue(value.relatedTo) || value.relatedTo === null || Array.isArray(value.relatedTo)) fail(`${path}.relatedTo`, "must be an object");
+		for (const [key, entry] of Object.entries(value.relatedTo)) {
+			if (!entry || !isObjectValue(entry)) fail(`${path}.relatedTo.${key}`, "must be a relation object");
+			validateRelation(entry, `${path}.relatedTo.${key}`);
+		}
+	}
+}
+/**
+* Validate relation structure.
+* @param value Relation object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateRelation(value, path) {
+	if (value["@type"] !== TYPE_RELATION$1) fail(path, "must have @type Relation");
+	if (value.relation) assertBooleanMap(value.relation, `${path}.relation`);
+}
+/**
+* Validate link structure.
+* @param value Link object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateLink(value, path) {
+	if (value["@type"] !== TYPE_LINK$1) fail(path, "must have @type Link");
+	assertString(value.href, `${path}.href`);
+	if (!value.href) fail(`${path}.href`, "is required");
+	assertContentId(value.cid, `${path}.cid`);
+	assertMediaType(value.contentType, `${path}.contentType`);
+	assertUnsignedInt(value.size, `${path}.size`);
+	assertString(value.rel, `${path}.rel`);
+	assertString(value.display, `${path}.display`);
+	assertString(value.title, `${path}.title`);
+}
+/**
+* Validate location structure.
+* @param value Location object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateLocation(value, path) {
+	if (value["@type"] !== TYPE_LOCATION$1) fail(path, "must have @type Location");
+	assertId(value.relativeTo, `${path}.relativeTo`);
+	assertString(value.name, `${path}.name`);
+	assertString(value.description, `${path}.description`);
+	if (value.locationTypes) assertBooleanMap(value.locationTypes, `${path}.locationTypes`);
+	assertString(value.relativeTo, `${path}.relativeTo`);
+	assertTimeZone(value.timeZone, `${path}.timeZone`);
+	assertString(value.coordinates, `${path}.coordinates`);
+	if (value.links) {
+		if (!isObjectValue(value.links) || value.links === null || Array.isArray(value.links)) fail(`${path}.links`, "must be an object");
+		for (const [key, entry] of Object.entries(value.links)) {
+			assertId(key, `${path}.links.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.links.${key}`, "must be a link object");
+			validateLink(entry, `${path}.links.${key}`);
+		}
+	}
+}
+/**
+* Validate virtual location structure.
+* @param value VirtualLocation object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateVirtualLocation(value, path) {
+	if (value["@type"] !== TYPE_VIRTUAL_LOCATION$1) fail(path, "must have @type VirtualLocation");
+	assertString(value.name, `${path}.name`);
+	assertString(value.description, `${path}.description`);
+	assertString(value.uri, `${path}.uri`);
+	if (!value.uri) fail(`${path}.uri`, "is required");
+	if (value.features) assertBooleanMap(value.features, `${path}.features`);
+}
+/**
+* Validate time zone rule structure.
+* @param value TimeZoneRule object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateTimeZoneRule(value, path) {
+	if (value["@type"] !== TYPE_TIME_ZONE_RULE$1) fail(path, "must have @type TimeZoneRule");
+	assertLocalDateTime(value.start, `${path}.start`);
+	if (!value.start) fail(`${path}.start`, "is required");
+	assertString(value.offsetFrom, `${path}.offsetFrom`);
+	if (!value.offsetFrom) fail(`${path}.offsetFrom`, "is required");
+	assertString(value.offsetTo, `${path}.offsetTo`);
+	if (!value.offsetTo) fail(`${path}.offsetTo`, "is required");
+	if (value.recurrenceRules) value.recurrenceRules.forEach((rule, index) => validateRecurrenceRule(rule, `${path}.recurrenceRules[${index}]`));
+	if (value.comments) value.comments.forEach((entry, index) => assertString(entry, `${path}.comments[${index}]`));
+}
+/**
+* Validate time zone object structure.
+* @param value TimeZone object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateTimeZoneObject(value, path) {
+	if (value["@type"] !== TYPE_TIME_ZONE$1) fail(path, "must have @type TimeZone");
+	assertTimeZone(value.tzId, `${path}.tzId`);
+	if (!value.tzId) fail(`${path}.tzId`, "is required");
+	assertUtcDateTime(value.updated, `${path}.updated`);
+	assertString(value.url, `${path}.url`);
+	assertUtcDateTime(value.validUntil, `${path}.validUntil`);
+	if (value.aliases) assertBooleanMap(value.aliases, `${path}.aliases`);
+	if (value.standard) value.standard.forEach((rule, index) => validateTimeZoneRule(rule, `${path}.standard[${index}]`));
+	if (value.daylight) value.daylight.forEach((rule, index) => validateTimeZoneRule(rule, `${path}.daylight[${index}]`));
+}
+/**
+* Validate participant structure.
+* @param value Participant object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateParticipant(value, path) {
+	if (value["@type"] !== TYPE_PARTICIPANT$1) fail(path, "must have @type Participant");
+	assertString(value.name, `${path}.name`);
+	assertString(value.email, `${path}.email`);
+	assertString(value.description, `${path}.description`);
+	if (value.sendTo) {
+		if (!isObjectValue(value.sendTo) || value.sendTo === null || Array.isArray(value.sendTo)) fail(`${path}.sendTo`, "must be an object");
+		for (const [key, entry] of Object.entries(value.sendTo)) {
+			assertString(key, `${path}.sendTo.${key}`);
+			assertString(entry, `${path}.sendTo.${key}`);
+		}
+	}
+	assertString(value.kind, `${path}.kind`);
+	if (!value.roles) fail(`${path}.roles`, "is required");
+	assertBooleanMap(value.roles, `${path}.roles`);
+	if (Object.keys(value.roles).length === 0) fail(`${path}.roles`, "must include at least one role");
+	assertId(value.locationId, `${path}.locationId`);
+	assertString(value.language, `${path}.language`);
+	assertString(value.participationStatus, `${path}.participationStatus`);
+	assertString(value.participationComment, `${path}.participationComment`);
+	assertBoolean(value.expectReply, `${path}.expectReply`);
+	assertString(value.scheduleAgent, `${path}.scheduleAgent`);
+	assertBoolean(value.scheduleForceSend, `${path}.scheduleForceSend`);
+	assertUnsignedInt(value.scheduleSequence, `${path}.scheduleSequence`);
+	if (value.scheduleStatus) value.scheduleStatus.forEach((entry, index) => assertString(entry, `${path}.scheduleStatus[${index}]`));
+	assertUtcDateTime(value.scheduleUpdated, `${path}.scheduleUpdated`);
+	assertString(value.sentBy, `${path}.sentBy`);
+	assertId(value.invitedBy, `${path}.invitedBy`);
+	if (value.delegatedTo) assertIdBooleanMap(value.delegatedTo, `${path}.delegatedTo`);
+	if (value.delegatedFrom) assertIdBooleanMap(value.delegatedFrom, `${path}.delegatedFrom`);
+	if (value.memberOf) assertIdBooleanMap(value.memberOf, `${path}.memberOf`);
+	if (value.links) {
+		if (!isObjectValue(value.links) || value.links === null || Array.isArray(value.links)) fail(`${path}.links`, "must be an object");
+		for (const [key, entry] of Object.entries(value.links)) {
+			assertId(key, `${path}.links.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.links.${key}`, "must be a link object");
+			validateLink(entry, `${path}.links.${key}`);
+		}
+	}
+	assertString(value.progress, `${path}.progress`);
+	assertUtcDateTime(value.progressUpdated, `${path}.progressUpdated`);
+	assertUnsignedInt(value.percentComplete, `${path}.percentComplete`);
+}
+/**
+* Validate common structure.
+* @param value JSCalendar object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateCommon(value, path) {
+	assertNonEmptyString(value.uid, `${path}.uid`);
+	if (!value.uid) fail(`${path}.uid`, "is required");
+	assertUtcDateTime(value.updated, `${path}.updated`);
+	assertUtcDateTime(value.created, `${path}.created`);
+	assertUnsignedInt(value.sequence, `${path}.sequence`);
+	assertString(value.method, `${path}.method`);
+	if (value.method && value.method !== value.method.toLowerCase()) fail(`${path}.method`, "must be lowercase");
+	assertString(value.title, `${path}.title`);
+	assertString(value.description, `${path}.description`);
+	assertTextContentType(value.descriptionContentType, `${path}.descriptionContentType`);
+	assertBoolean(value.showWithoutTime, `${path}.showWithoutTime`);
+	if (value.relatedTo) {
+		if (!isObjectValue(value.relatedTo) || value.relatedTo === null || Array.isArray(value.relatedTo)) fail(`${path}.relatedTo`, "must be an object");
+		for (const [key, entry] of Object.entries(value.relatedTo)) {
+			assertNonEmptyString(key, `${path}.relatedTo.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.relatedTo.${key}`, "must be a relation object");
+			validateRelation(entry, `${path}.relatedTo.${key}`);
+		}
+	}
+	if (value.keywords) assertBooleanMap(value.keywords, `${path}.keywords`);
+	if (value.categories) assertBooleanMap(value.categories, `${path}.categories`);
+	assertString(value.color, `${path}.color`);
+	assertLocalDateTime(value.recurrenceId, `${path}.recurrenceId`);
+	assertTimeZone(value.recurrenceIdTimeZone, `${path}.recurrenceIdTimeZone`);
+	if (value.recurrenceRules) value.recurrenceRules.forEach((rule, index) => validateRecurrenceRule(rule, `${path}.recurrenceRules[${index}]`));
+	if (value.excludedRecurrenceRules) value.excludedRecurrenceRules.forEach((rule, index) => validateRecurrenceRule(rule, `${path}.excludedRecurrenceRules[${index}]`));
+	if (value.recurrenceOverrides) {
+		if (!isObjectValue(value.recurrenceOverrides) || value.recurrenceOverrides === null || Array.isArray(value.recurrenceOverrides)) fail(`${path}.recurrenceOverrides`, "must be an object");
+		for (const [key, entry] of Object.entries(value.recurrenceOverrides)) {
+			assertLocalDateTime(key, `${path}.recurrenceOverrides.${key}`);
+			assertPatchObject(entry, `${path}.recurrenceOverrides.${key}`);
+		}
+	}
+	assertBoolean(value.excluded, `${path}.excluded`);
+	assertInteger(value.priority, `${path}.priority`);
+	assertString(value.freeBusyStatus, `${path}.freeBusyStatus`);
+	assertString(value.privacy, `${path}.privacy`);
+	if (value.replyTo) {
+		if (!isObjectValue(value.replyTo) || value.replyTo === null || Array.isArray(value.replyTo)) fail(`${path}.replyTo`, "must be an object");
+		for (const [key, entry] of Object.entries(value.replyTo)) assertString(entry, `${path}.replyTo.${key}`);
+	}
+	assertString(value.sentBy, `${path}.sentBy`);
+	if (value.locations) {
+		if (!isObjectValue(value.locations) || value.locations === null || Array.isArray(value.locations)) fail(`${path}.locations`, "must be an object");
+		for (const [key, entry] of Object.entries(value.locations)) {
+			assertId(key, `${path}.locations.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.locations.${key}`, "must be a location object");
+			validateLocation(entry, `${path}.locations.${key}`);
+		}
+	}
+	if (value.virtualLocations) {
+		if (!isObjectValue(value.virtualLocations) || value.virtualLocations === null || Array.isArray(value.virtualLocations)) fail(`${path}.virtualLocations`, "must be an object");
+		for (const [key, entry] of Object.entries(value.virtualLocations)) {
+			assertId(key, `${path}.virtualLocations.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.virtualLocations.${key}`, "must be a virtual location object");
+			validateVirtualLocation(entry, `${path}.virtualLocations.${key}`);
+		}
+	}
+	if (value.links) {
+		if (!isObjectValue(value.links) || value.links === null || Array.isArray(value.links)) fail(`${path}.links`, "must be an object");
+		for (const [key, entry] of Object.entries(value.links)) {
+			assertId(key, `${path}.links.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.links.${key}`, "must be a link object");
+			validateLink(entry, `${path}.links.${key}`);
+		}
+	}
+	if (value.participants) {
+		if (!isObjectValue(value.participants) || value.participants === null || Array.isArray(value.participants)) fail(`${path}.participants`, "must be an object");
+		for (const [key, entry] of Object.entries(value.participants)) {
+			assertId(key, `${path}.participants.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.participants.${key}`, "must be a participant object");
+			validateParticipant(entry, `${path}.participants.${key}`);
+		}
+	}
+	assertString(value.requestStatus, `${path}.requestStatus`);
+	assertBoolean(value.useDefaultAlerts, `${path}.useDefaultAlerts`);
+	if (value.alerts) {
+		if (!isObjectValue(value.alerts) || value.alerts === null || Array.isArray(value.alerts)) fail(`${path}.alerts`, "must be an object");
+		for (const [key, entry] of Object.entries(value.alerts)) {
+			assertId(key, `${path}.alerts.${key}`);
+			if (!entry || !isObjectValue(entry)) fail(`${path}.alerts.${key}`, "must be an alert object");
+			validateAlert(entry, `${path}.alerts.${key}`);
+		}
+	}
+	if (value.localizations) {
+		if (!isRecord(value.localizations)) fail(`${path}.localizations`, "must be an object");
+		for (const [key, entry] of Object.entries(value.localizations)) assertPatchObject(entry, `${path}.localizations.${key}`);
+	}
+	assertTimeZone(value.timeZone, `${path}.timeZone`);
+	if (value.timeZones) {
+		const timeZones = value.timeZones;
+		if (!isObjectValue(timeZones) || timeZones === null || Array.isArray(timeZones)) fail(`${path}.timeZones`, "must be an object");
+		for (const [key] of Object.entries(timeZones)) assertTimeZone(key, `${path}.timeZones.${key}`);
+		for (const [key, entry] of Object.entries(timeZones)) {
+			if (!entry || !isObjectValue(entry)) fail(`${path}.timeZones.${key}`, "must be a time zone object");
+			validateTimeZoneObject(entry, `${path}.timeZones.${key}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/validate/validators-objects.ts
+/**
+* Validate event structure.
+* @param value Event object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateEvent(value, path) {
+	if (value["@type"] !== TYPE_EVENT$1) fail(path, "must have @type Event");
+	validateCommon(value, path);
+	assertLocalDateTime(value.start, `${path}.start`);
+	if (!value.start) fail(`${path}.start`, "is required");
+	assertDuration(value.duration, `${path}.duration`);
+	assertString(value.status, `${path}.status`);
+}
+/**
+* Validate task structure.
+* @param value Task object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateTask(value, path) {
+	if (value["@type"] !== TYPE_TASK$1) fail(path, "must have @type Task");
+	validateCommon(value, path);
+	assertLocalDateTime(value.start, `${path}.start`);
+	assertLocalDateTime(value.due, `${path}.due`);
+	assertDuration(value.estimatedDuration, `${path}.estimatedDuration`);
+	assertUnsignedInt(value.percentComplete, `${path}.percentComplete`);
+	assertString(value.progress, `${path}.progress`);
+	assertUtcDateTime(value.progressUpdated, `${path}.progressUpdated`);
+}
+/**
+* Validate group structure.
+* @param value Group object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateGroup(value, path) {
+	if (value["@type"] !== TYPE_GROUP$1) fail(path, "must have @type Group");
+	validateCommon(value, path);
+	if (!Array.isArray(value.entries)) fail(`${path}.entries`, "must be an array");
+	value.entries.forEach((entry, index) => validateJsCalendarObject(entry, `${path}.entries[${index}]`));
+	assertString(value.source, `${path}.source`);
+}
+/**
+* Validate js calendar object structure.
+* @param value JSCalendar object to validate.
+* @param path JSON pointer path for error messages.
+* @return Nothing.
+*/
+function validateJsCalendarObject(value, path = "object") {
+	if (!value || !isObjectValue(value)) fail(path, "must be an object");
+	if (value["@type"] === TYPE_EVENT$1) return validateEvent(value, path);
+	if (value["@type"] === TYPE_TASK$1) return validateTask(value, path);
+	if (value["@type"] === TYPE_GROUP$1) return validateGroup(value, path);
+	fail(`${path}["@type"]`, "must be Event, Task, or Group");
+}
+
+//#endregion
+//#region src/jscal/constants.ts
+const TYPEOF_FUNCTION = "function";
+const EMPTY_STRING = "";
+const TYPE_EVENT = "Event";
+const TYPE_TASK = "Task";
+const TYPE_GROUP = "Group";
+const STATUS_COMPLETED = "completed";
+const STATUS_FAILED = "failed";
+const STATUS_IN_PROCESS = "in-process";
+const STATUS_NEEDS_ACTION = "needs-action";
+
+//#endregion
+//#region src/jscal/defaults.ts
+/**
+* Apply common defaults to the target.
+* @param data JSCalendar object to mutate.
+* @return The same object with defaults applied.
+*/
+function applyCommonDefaults(data) {
+	if (data.sequence === void 0) data.sequence = 0;
+	if (data.title === void 0) data.title = "";
+	if (data.description === void 0) data.description = "";
+	if (data.descriptionContentType === void 0) data.descriptionContentType = "text/plain";
+	if (data.showWithoutTime === void 0) data.showWithoutTime = false;
+	if (data.recurrenceIdTimeZone === void 0) data.recurrenceIdTimeZone = null;
+	if (data.excluded === void 0) data.excluded = false;
+	if (data.priority === void 0) data.priority = 0;
+	if (data.freeBusyStatus === void 0) data.freeBusyStatus = "busy";
+	if (data.privacy === void 0) data.privacy = "public";
+	if (data.useDefaultAlerts === void 0) data.useDefaultAlerts = false;
+	return data;
+}
+/**
+* Apply event defaults to the target.
+* @param data Event to mutate.
+* @return The same event with defaults applied.
+*/
+function applyEventDefaults(data) {
+	if (data.duration === void 0) data.duration = "PT0S";
+	if (data.status === void 0) data.status = "confirmed";
+	return data;
+}
+/**
+* Apply task defaults to the target.
+* @param data Task to mutate.
+* @return The same task with defaults applied.
+*/
+function applyTaskDefaults(data) {
+	if (data.progress === void 0) {
+		const participants = data.participants ? Object.values(data.participants) : [];
+		if (participants.length === 0) data.progress = STATUS_NEEDS_ACTION;
+		else if (participants.every((p) => p.progress === STATUS_COMPLETED)) data.progress = STATUS_COMPLETED;
+		else if (participants.some((p) => p.progress === STATUS_FAILED)) data.progress = STATUS_FAILED;
+		else if (participants.some((p) => p.progress === STATUS_IN_PROCESS)) data.progress = STATUS_IN_PROCESS;
+		else data.progress = STATUS_NEEDS_ACTION;
+	}
+	return data;
+}
+
+//#endregion
+//#region src/jscal/duration.ts
+/**
+* Convert seconds to an ISO 8601 duration string.
+* @param totalSeconds Total seconds to encode.
+* @return ISO 8601 duration string.
+*/
+function durationFromSeconds(totalSeconds) {
+	const negative = totalSeconds < 0;
+	const absSeconds = Math.abs(totalSeconds);
+	const clamped = Math.floor(absSeconds);
+	const days = Math.floor(clamped / 86400);
+	let remaining = clamped % 86400;
+	const hours = Math.floor(remaining / 3600);
+	remaining %= 3600;
+	const minutes = Math.floor(remaining / 60);
+	const seconds = remaining % 60;
+	const datePart = days > 0 ? `${days}D` : "";
+	const timeParts = [];
+	if (hours > 0) timeParts.push(`${hours}H`);
+	if (minutes > 0) timeParts.push(`${minutes}M`);
+	if (seconds > 0 || datePart === EMPTY_STRING && timeParts.length === 0) timeParts.push(`${seconds}S`);
+	const timePart = timeParts.length > 0 ? `T${timeParts.join("")}` : "";
+	return `${negative && clamped > 0 ? "-" : ""}P${datePart}${timePart}`;
+}
+const Duration = {
+	seconds(value) {
+		return durationFromSeconds(value);
+	},
+	minutes(value) {
+		return durationFromSeconds(value * 60);
+	},
+	hours(value) {
+		return durationFromSeconds(value * 3600);
+	},
+	days(value) {
+		return durationFromSeconds(value * 86400);
+	},
+	from(parts) {
+		var _parts$days, _parts$hours, _parts$minutes, _parts$seconds;
+		return durationFromSeconds(((_parts$days = parts.days) !== null && _parts$days !== void 0 ? _parts$days : 0) * 86400 + ((_parts$hours = parts.hours) !== null && _parts$hours !== void 0 ? _parts$hours : 0) * 3600 + ((_parts$minutes = parts.minutes) !== null && _parts$minutes !== void 0 ? _parts$minutes : 0) * 60 + ((_parts$seconds = parts.seconds) !== null && _parts$seconds !== void 0 ? _parts$seconds : 0));
+	}
+};
+
+//#endregion
+//#region src/jscal/ids.ts
+/**
+* Get a Crypto instance if available.
+* @return Crypto instance when available, otherwise undefined.
+*/
+function getCrypto() {
+	const cryptoObj = globalThis.crypto;
+	if (cryptoObj && typeof cryptoObj.getRandomValues === TYPEOF_FUNCTION) return cryptoObj;
+}
+/**
+* Generate random bytes using Crypto or Math.random.
+* @param length Number of bytes to generate.
+* @return Random byte array.
+*/
+function getRandomBytes(length) {
+	const bytes = new Uint8Array(length);
+	const cryptoObj = getCrypto();
+	if (cryptoObj) {
+		cryptoObj.getRandomValues(bytes);
+		return bytes;
+	}
+	for (let i = 0; i < length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+	return bytes;
+}
+/**
+* Encode bytes as base64url.
+* @param bytes Byte array to encode.
+* @return Base64url string without padding.
+*/
+function base64UrlEncode(bytes) {
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	let output = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		var _bytes$i, _bytes, _bytes2, _alphabet, _alphabet2, _alphabet3, _alphabet4;
+		const b0 = (_bytes$i = bytes[i]) !== null && _bytes$i !== void 0 ? _bytes$i : 0;
+		const b1 = (_bytes = bytes[i + 1]) !== null && _bytes !== void 0 ? _bytes : 0;
+		const b2 = (_bytes2 = bytes[i + 2]) !== null && _bytes2 !== void 0 ? _bytes2 : 0;
+		const triplet = (b0 !== null && b0 !== void 0 ? b0 : 0) << 16 | (b1 !== null && b1 !== void 0 ? b1 : 0) << 8 | (b2 !== null && b2 !== void 0 ? b2 : 0);
+		output += (_alphabet = alphabet[triplet >> 18 & 63]) !== null && _alphabet !== void 0 ? _alphabet : "";
+		output += (_alphabet2 = alphabet[triplet >> 12 & 63]) !== null && _alphabet2 !== void 0 ? _alphabet2 : "";
+		output += i + 1 < bytes.length ? (_alphabet3 = alphabet[triplet >> 6 & 63]) !== null && _alphabet3 !== void 0 ? _alphabet3 : "" : "=";
+		output += i + 2 < bytes.length ? (_alphabet4 = alphabet[triplet & 63]) !== null && _alphabet4 !== void 0 ? _alphabet4 : "" : "=";
+	}
+	return output.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/**
+* Create a UUID-like identifier.
+* @return UUID string.
+*/
+function createUid() {
+	const cryptoObj = getCrypto();
+	if (cryptoObj === null || cryptoObj === void 0 ? void 0 : cryptoObj.randomUUID) return cryptoObj.randomUUID();
+	const bytes = getRandomBytes(16);
+	if (bytes.length > 6) {
+		var _bytes$;
+		bytes[6] = ((_bytes$ = bytes[6]) !== null && _bytes$ !== void 0 ? _bytes$ : 0) & 15 | 64;
+	}
+	if (bytes.length > 8) {
+		var _bytes$2;
+		bytes[8] = ((_bytes$2 = bytes[8]) !== null && _bytes$2 !== void 0 ? _bytes$2 : 0) & 63 | 128;
+	}
+	const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/**
+* Create a compact base64url identifier.
+* @return Base64url ID string.
+*/
+function createId() {
+	return base64UrlEncode(getRandomBytes(16));
+}
+
+//#endregion
+//#region src/jscal/datetime.ts
+/**
+* Pad a number to two digits.
+* @param value Number to pad.
+* @return Zero-padded string.
+*/
+function pad2(value) {
+	return value.toString().padStart(2, "0");
+}
+/**
+* Convert a Date input to a LocalDateTime string.
+* @param value Date or LocalDateTime string.
+* @return LocalDateTime string.
+*/
+function toLocalDateTime(value) {
+	if (isStringValue(value)) return value;
+	return [
+		value.getFullYear().toString().padStart(4, "0"),
+		"-",
+		pad2(value.getMonth() + 1),
+		"-",
+		pad2(value.getDate()),
+		"T",
+		pad2(value.getHours()),
+		":",
+		pad2(value.getMinutes()),
+		":",
+		pad2(value.getSeconds())
+	].join("");
+}
+/**
+* Convert a Date input to a UTCDateTime string.
+* @param value Date or UTCDateTime string.
+* @return UTCDateTime string.
+*/
+function toUtcDateTime(value) {
+	if (isStringValue(value)) return value;
+	return normalizeUtcDateTime(value.toISOString());
+}
+
+//#endregion
+//#region src/jscal/base.ts
+var Base = class {
+	data;
+	/**
+	* Create a new base instance that wraps a JSCalendar object.
+	* @param data Underlying JSCalendar data.
+	* @return Result.
+	*/
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Return a deep-cloned plain object for safe serialization.
+	* @return Cloned JSCalendar data.
+	*/
+	eject() {
+		return deepClone(this.data);
+	}
+	/**
+	* Clone the current instance with a deep-cloned payload.
+	* @return New instance with cloned data.
+	*/
+	clone() {
+		return this.wrap(deepClone(this.data));
+	}
+	/**
+	* Read a field value from the underlying data.
+	* @param key Field key.
+	* @return Field value.
+	*/
+	get(key) {
+		return this.data[key];
+	}
+	/**
+	* Set a field value and update metadata as needed.
+	* @param key Field key.
+	* @param value Field value.
+	* @return New instance with the updated field.
+	*/
+	set(key, value) {
+		const next = deepClone(this.data);
+		next[key] = value;
+		const touched = this.touchKeys(next, [String(key)]);
+		return this.wrap(touched);
+	}
+	/**
+	* Apply a PatchObject and touch updated/sequence metadata.
+	* @param patch Patch to apply.
+	* @param options Update options.
+	* @return New instance with applied patch.
+	*/
+	patch(patch, options = {}) {
+		const next = applyPatch(this.data, patch);
+		if (options.validate !== false) validateJsCalendarObject(next);
+		const touched = this.touchFromPatch(next, patch, options);
+		return this.wrap(touched);
+	}
+	/**
+	* Update updated/sequence metadata for modified keys.
+	* @param keys Modified keys.
+	* @param options Update options.
+	* @return Updated instance.
+	*/
+	touchKeys(data, keys, options = {}) {
+		var _options$now;
+		if (options.touch === false) return data;
+		data.updated = ((_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : nowUtc)();
+		if (options.sequence === false) return data;
+		data.sequence = (isNumberValue(data.sequence) ? data.sequence : 0) + 1;
+		return data;
+	}
+	/**
+	* Update updated/sequence metadata for PatchObject changes.
+	* @param patch Patch applied to the object.
+	* @param options Update options.
+	* @return Updated instance.
+	*/
+	touchFromPatch(data, patch, options = {}) {
+		var _options$now2;
+		if (options.touch === false) return data;
+		data.updated = ((_options$now2 = options.now) !== null && _options$now2 !== void 0 ? _options$now2 : nowUtc)();
+		if (options.sequence === false) return data;
+		data.sequence = (isNumberValue(data.sequence) ? data.sequence : 0) + 1;
+		return data;
+	}
+};
+
+//#endregion
+//#region src/jscal/event.ts
+var EventObject = class EventObject extends Base {
+	/**
+	* Wrap updated data in a new EventObject.
+	* @param data Updated event data.
+	* @return New EventObject instance.
+	*/
+	wrap(data) {
+		const { "@type": _type, ...rest } = data;
+		return new EventObject(rest, { validate: false });
+	}
+	/**
+	* Create an event with normalized dates, duration, and RFC defaults.
+	* @param input Event input values to normalize.
+	* @param options Creation options (validation, clock).
+	* @return EventObject instance.
+	*/
+	constructor(input, options = {}) {
+		var _options$now, _input$uid;
+		if (!isStringValue(input.start) && !(input.start instanceof Date)) throw new Error("Event.start is required");
+		if (isStringValue(input.start) && input.start.length === 0) throw new Error("Event.start is required");
+		const now = (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : nowUtc;
+		const { start: rawStart, duration: rawDuration, updated: rawUpdated, created: rawCreated, timeZone: rawTimeZone, ...rest } = input;
+		const start = toLocalDateTime(rawStart);
+		const updated = rawUpdated ? toUtcDateTime(rawUpdated) : now();
+		let timeZone;
+		if (rawTimeZone === null) timeZone = null;
+		else if (rawTimeZone) timeZone = resolveTimeZone(rawTimeZone);
+		const data = {
+			...rest,
+			"@type": "Event",
+			start,
+			uid: (_input$uid = input.uid) !== null && _input$uid !== void 0 ? _input$uid : createUid(),
+			updated
+		};
+		if (timeZone !== void 0) data.timeZone = timeZone;
+		if (rawDuration !== void 0) data.duration = isNumberValue(rawDuration) ? durationFromSeconds(Math.max(0, rawDuration)) : rawDuration;
+		if (rawCreated) data.created = toUtcDateTime(rawCreated);
+		else data.created = updated;
+		applyCommonDefaults(data);
+		applyEventDefaults(data);
+		if (options.validate !== false) validateJsCalendarObject(data);
+		super(data);
+	}
+	/**
+	* Clone the event as a new EventObject instance.
+	* @return Cloned EventObject.
+	*/
+	clone() {
+		return this.wrap(deepClone(this.data));
+	}
+};
+
+//#endregion
+//#region src/jscal/task.ts
+var TaskObject = class TaskObject extends Base {
+	/**
+	* Wrap updated data in a new TaskObject.
+	* @param data Updated task data.
+	* @return New TaskObject instance.
+	*/
+	wrap(data) {
+		const { "@type": _type, ...rest } = data;
+		return new TaskObject(rest, { validate: false });
+	}
+	/**
+	* Create a task with normalized date fields and RFC defaults applied.
+	* @param input Task input values to normalize.
+	* @param options Creation options (validation, clock).
+	* @return TaskObject instance.
+	*/
+	constructor(input = {}, options = {}) {
+		var _options$now, _input$uid;
+		const now = (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : nowUtc;
+		const { start: rawStart, due: rawDue, updated: rawUpdated, created: rawCreated, timeZone: rawTimeZone, ...rest } = input;
+		const updated = rawUpdated ? toUtcDateTime(rawUpdated) : now();
+		let timeZone;
+		if (rawTimeZone === null) timeZone = null;
+		else if (rawTimeZone) timeZone = resolveTimeZone(rawTimeZone);
+		const data = {
+			...rest,
+			"@type": "Task",
+			uid: (_input$uid = input.uid) !== null && _input$uid !== void 0 ? _input$uid : createUid(),
+			updated
+		};
+		if (rawStart) data.start = toLocalDateTime(rawStart);
+		if (rawDue) data.due = toLocalDateTime(rawDue);
+		if (timeZone !== void 0) data.timeZone = timeZone;
+		if (rawCreated) data.created = toUtcDateTime(rawCreated);
+		else data.created = updated;
+		applyCommonDefaults(data);
+		applyTaskDefaults(data);
+		if (options.validate !== false) validateJsCalendarObject(data);
+		super(data);
+	}
+	/**
+	* Clone the task as a new TaskObject instance.
+	* @return Cloned TaskObject.
+	*/
+	clone() {
+		return this.wrap(deepClone(this.data));
+	}
+};
+
+//#endregion
+//#region src/jscal/normalize.ts
+/**
+* Type guard for wrapper instances that expose a data field.
+* @param value Value to check.
+* @return True when value looks like a JsCal instance.
+*/
+function isJsCalInstance(value) {
+	return "data" in value;
+}
+/**
+* Normalize a list of mixed JSCalendar objects and JsCal instances.
+* @param items Items to normalize.
+* @return Plain JSCalendar objects.
+*/
+function normalizeItems(items) {
+	const mapped = [];
+	for (const entry of items) if (isObjectValue(entry) && isJsCalInstance(entry)) mapped.push(entry.data);
+	else mapped.push(entry);
+	return mapped;
+}
+/**
+* Normalize a group entry into a plain Event or Task.
+* @param entry Group entry input.
+* @return Plain Event or Task object.
+*/
+function normalizeEntry(entry) {
+	if (isObjectValue(entry) && isJsCalInstance(entry)) return entry.data;
+	return entry;
+}
+/**
+* Normalize a list to plain JSCalendar objects.
+* @param value List of JSCalendar objects or JsCal instances.
+* @return Plain JSCalendar objects.
+*/
+function normalizeToObjects(value) {
+	return normalizeItems(value);
+}
+
+//#endregion
+//#region src/jscal/group.ts
+var GroupObject = class GroupObject extends Base {
+	/**
+	* Wrap updated data in a new GroupObject.
+	* @param data Updated group data.
+	* @return New GroupObject instance.
+	*/
+	wrap(data) {
+		const { "@type": _type, ...rest } = data;
+		return new GroupObject(rest, { validate: false });
+	}
+	/**
+	* Create a group with normalized entries and RFC defaults.
+	* @param input Group input values to normalize.
+	* @param options Creation options (validation, clock).
+	* @return GroupObject instance.
+	*/
+	constructor(input, options = {}) {
+		var _options$now, _input$uid;
+		if (!Array.isArray(input.entries)) throw new Error("Group.entries is required");
+		const now = (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : nowUtc;
+		const { updated: rawUpdated, created: rawCreated, ...rest } = input;
+		const entries = input.entries.map((entry) => normalizeEntry(entry));
+		const updated = rawUpdated ? toUtcDateTime(rawUpdated) : now();
+		const data = {
+			...rest,
+			"@type": "Group",
+			entries,
+			uid: (_input$uid = input.uid) !== null && _input$uid !== void 0 ? _input$uid : createUid(),
+			updated
+		};
+		if (rawCreated) data.created = toUtcDateTime(rawCreated);
+		else data.created = updated;
+		applyCommonDefaults(data);
+		if (options.validate !== false) validateJsCalendarObject(data);
+		super(data);
+	}
+	/**
+	* Clone the group as a new GroupObject instance.
+	* @return Cloned GroupObject.
+	*/
+	clone() {
+		return this.wrap(deepClone(this.data));
+	}
+};
+
+//#endregion
+//#region src/jscal/guards.ts
+/**
+* Type guard for JSCalendar Event objects.
+* @param obj JSCalendar object to check.
+* @return True when the object is an Event.
+*/
+function isEvent(obj) {
+	return obj["@type"] === TYPE_EVENT;
+}
+/**
+* Type guard for JSCalendar Task objects.
+* @param obj JSCalendar object to check.
+* @return True when the object is a Task.
+*/
+function isTask(obj) {
+	return obj["@type"] === TYPE_TASK;
+}
+/**
+* Type guard for JSCalendar Group objects.
+* @param obj JSCalendar object to check.
+* @return True when the object is a Group.
+*/
+function isGroup(obj) {
+	return obj["@type"] === TYPE_GROUP;
+}
+
+//#endregion
+//#region src/jscal/builders.ts
+const TYPE_PARTICIPANT = "Participant";
+const TYPE_LOCATION = "Location";
+const TYPE_VIRTUAL_LOCATION = "VirtualLocation";
+const TYPE_ALERT = "Alert";
+const TYPE_OFFSET_TRIGGER = "OffsetTrigger";
+const TYPE_ABSOLUTE_TRIGGER = "AbsoluteTrigger";
+const TYPE_RELATION = "Relation";
+const TYPE_LINK = "Link";
+const TYPE_TIME_ZONE = "TimeZone";
+const TYPE_TIME_ZONE_RULE = "TimeZoneRule";
+const TYPE_RECURRENCE_RULE = "RecurrenceRule";
+const TYPE_NDAY = "NDay";
+/**
+* Build a Participant object with @type set and validated.
+* @param input Participant fields without @type.
+* @return Validated Participant object.
+*/
+function buildParticipant(input) {
+	if (input["@type"] && input["@type"] !== TYPE_PARTICIPANT) fail("participant", `must have @type ${TYPE_PARTICIPANT}`);
+	const participant = {
+		...input,
+		"@type": TYPE_PARTICIPANT
+	};
+	validateParticipant(participant, "participant");
+	return participant;
+}
+/**
+* Build a Location object with @type set and validated.
+* @param input Location fields without @type.
+* @return Validated Location object.
+*/
+function buildLocation(input) {
+	if (input["@type"] && input["@type"] !== TYPE_LOCATION) fail("location", `must have @type ${TYPE_LOCATION}`);
+	const location = {
+		...input,
+		"@type": TYPE_LOCATION
+	};
+	validateLocation(location, "location");
+	return location;
+}
+/**
+* Build a VirtualLocation object with @type set and validated.
+* @param input VirtualLocation fields without @type.
+* @return Validated VirtualLocation object.
+*/
+function buildVirtualLocation(input) {
+	if (input["@type"] && input["@type"] !== TYPE_VIRTUAL_LOCATION) fail("virtualLocation", `must have @type ${TYPE_VIRTUAL_LOCATION}`);
+	const virtualLocation = {
+		...input,
+		"@type": TYPE_VIRTUAL_LOCATION
+	};
+	validateVirtualLocation(virtualLocation, "virtualLocation");
+	return virtualLocation;
+}
+/**
+* Build an Alert object with @type set and validated.
+* @param input Alert fields without @type.
+* @return Validated Alert object.
+*/
+function buildAlert(input) {
+	if (input["@type"] && input["@type"] !== TYPE_ALERT) fail("alert", `must have @type ${TYPE_ALERT}`);
+	const alert = {
+		...input,
+		"@type": TYPE_ALERT
+	};
+	validateAlert(alert, "alert");
+	return alert;
+}
+/**
+* Build an OffsetTrigger object with @type set and validated.
+* @param input OffsetTrigger fields without @type.
+* @return Validated OffsetTrigger object.
+*/
+function buildOffsetTrigger(input) {
+	if (input["@type"] && input["@type"] !== TYPE_OFFSET_TRIGGER) fail("offsetTrigger", `must have @type ${TYPE_OFFSET_TRIGGER}`);
+	const trigger = {
+		...input,
+		"@type": TYPE_OFFSET_TRIGGER
+	};
+	assertSignedDuration(trigger.offset, "offsetTrigger.offset");
+	assertString(trigger.relativeTo, "offsetTrigger.relativeTo");
+	return trigger;
+}
+/**
+* Build an AbsoluteTrigger object with @type set and validated.
+* @param input AbsoluteTrigger fields without @type.
+* @return Validated AbsoluteTrigger object.
+*/
+function buildAbsoluteTrigger(input) {
+	if (input["@type"] && input["@type"] !== TYPE_ABSOLUTE_TRIGGER) fail("absoluteTrigger", `must have @type ${TYPE_ABSOLUTE_TRIGGER}`);
+	const trigger = {
+		...input,
+		"@type": TYPE_ABSOLUTE_TRIGGER
+	};
+	assertUtcDateTime(trigger.when, "absoluteTrigger.when");
+	return trigger;
+}
+/**
+* Build a Relation object with @type set and validated.
+* @param input Relation fields without @type.
+* @return Validated Relation object.
+*/
+function buildRelation(input) {
+	if (input["@type"] && input["@type"] !== TYPE_RELATION) fail("relation", `must have @type ${TYPE_RELATION}`);
+	const relation = {
+		...input,
+		"@type": TYPE_RELATION
+	};
+	validateRelation(relation, "relation");
+	return relation;
+}
+/**
+* Build a Link object with @type set and validated.
+* @param input Link fields without @type.
+* @return Validated Link object.
+*/
+function buildLink(input) {
+	if (input["@type"] && input["@type"] !== TYPE_LINK) fail("link", `must have @type ${TYPE_LINK}`);
+	const link = {
+		...input,
+		"@type": TYPE_LINK
+	};
+	validateLink(link, "link");
+	return link;
+}
+/**
+* Build a TimeZone object with @type set and validated.
+* @param input TimeZone fields without @type.
+* @return Validated TimeZone object.
+*/
+function buildTimeZone(input) {
+	if (input["@type"] && input["@type"] !== TYPE_TIME_ZONE) fail("timeZone", `must have @type ${TYPE_TIME_ZONE}`);
+	const timeZone = {
+		...input,
+		"@type": TYPE_TIME_ZONE
+	};
+	validateTimeZoneObject(timeZone, "timeZone");
+	return timeZone;
+}
+/**
+* Build a TimeZoneRule object with @type set and validated.
+* @param input TimeZoneRule fields without @type.
+* @return Validated TimeZoneRule object.
+*/
+function buildTimeZoneRule(input) {
+	if (input["@type"] && input["@type"] !== TYPE_TIME_ZONE_RULE) fail("timeZoneRule", `must have @type ${TYPE_TIME_ZONE_RULE}`);
+	const rule = {
+		...input,
+		"@type": TYPE_TIME_ZONE_RULE
+	};
+	validateTimeZoneRule(rule, "timeZoneRule");
+	return rule;
+}
+/**
+* Build a RecurrenceRule object with @type set and validated.
+* @param input RecurrenceRule fields without @type.
+* @return Validated RecurrenceRule object.
+*/
+function buildRecurrenceRule(input) {
+	if (input["@type"] && input["@type"] !== TYPE_RECURRENCE_RULE) fail("recurrenceRule", `must have @type ${TYPE_RECURRENCE_RULE}`);
+	const rule = {
+		...input,
+		"@type": TYPE_RECURRENCE_RULE
+	};
+	validateRecurrenceRule(rule, "recurrenceRule");
+	return rule;
+}
+/**
+* Build an NDay object with @type set and validated.
+* @param input NDay fields without @type.
+* @return Validated NDay object.
+*/
+function buildNDay(input) {
+	if (input["@type"] && input["@type"] !== TYPE_NDAY) fail("nday", `must have @type ${TYPE_NDAY}`);
+	const nday = {
+		...input,
+		"@type": TYPE_NDAY
+	};
+	validateNDay(nday, "nday");
+	return nday;
+}
+/**
+* Build a patch object for Event-like updates with JSON value validation.
+* @param input Patch fields for an event.
+* @return Validated PatchObject.
+*/
+function buildEventPatch(input) {
+	const patch = { ...input };
+	assertPatchObject(patch, "eventPatch");
+	return patch;
+}
+/**
+* Build a patch object for Task-like updates with JSON value validation.
+* @param input Patch fields for a task.
+* @return Validated PatchObject.
+*/
+function buildTaskPatch(input) {
+	const patch = { ...input };
+	assertPatchObject(patch, "taskPatch");
+	return patch;
+}
+/**
+* Build a patch object for Group-like updates with JSON value validation.
+* @param input Patch fields for a group.
+* @return Validated PatchObject.
+*/
+function buildGroupPatch(input) {
+	const patch = { ...input };
+	assertPatchObject(patch, "groupPatch");
+	return patch;
+}
+/**
+* Build a record keyed by Ids, optionally merging into an existing record.
+* @param items Items to store with optional explicit ids.
+* @param builder Builder function to validate each item.
+* @param idFn Optional ID generator for items without explicit ids.
+* @param existing Existing record to merge into.
+* @return Record keyed by ids with merged values.
+*/
+function buildIdMap(items, builder, idFn = () => createId(), existing) {
+	const result = existing ? { ...existing } : {};
+	items.forEach((item, index) => {
+		var _item$id;
+		const id = (_item$id = item.id) !== null && _item$id !== void 0 ? _item$id : idFn(item.value, index);
+		result[id] = builder(item.value);
+	});
+	return result;
+}
+/**
+* Build a record of Participant objects keyed by Ids.
+* @param items Participant inputs with optional explicit ids.
+* @param existing Existing participant record to merge into.
+* @return Participant record keyed by Id.
+*/
+function buildParticipants(items, existing) {
+	return buildIdMap(items, buildParticipant, () => createId(), existing);
+}
+/**
+* Build a record of Location objects keyed by Ids.
+* @param items Location inputs with optional explicit ids.
+* @param existing Existing location record to merge into.
+* @return Location record keyed by Id.
+*/
+function buildLocations(items, existing) {
+	return buildIdMap(items, buildLocation, () => createId(), existing);
+}
+/**
+* Build a record of VirtualLocation objects keyed by Ids.
+* @param items VirtualLocation inputs with optional explicit ids.
+* @param existing Existing virtual location record to merge into.
+* @return VirtualLocation record keyed by Id.
+*/
+function buildVirtualLocations(items, existing) {
+	return buildIdMap(items, buildVirtualLocation, () => createId(), existing);
+}
+/**
+* Build a record of Alert objects keyed by Ids.
+* @param items Alert inputs with optional explicit ids.
+* @param existing Existing alert record to merge into.
+* @return Alert record keyed by Id.
+*/
+function buildAlerts(items, existing) {
+	return buildIdMap(items, buildAlert, () => createId(), existing);
+}
+/**
+* Build a record of Link objects keyed by Ids.
+* @param items Link inputs with optional explicit ids.
+* @param existing Existing link record to merge into.
+* @return Link record keyed by Id.
+*/
+function buildLinks(items, existing) {
+	return buildIdMap(items, buildLink, () => createId(), existing);
+}
+/**
+* Build a record of Relation objects keyed by Ids.
+* @param items Relation inputs with optional explicit ids.
+* @param existing Existing relation record to merge into.
+* @return Relation record keyed by Id.
+*/
+function buildRelatedTo(items, existing) {
+	return buildIdMap(items, buildRelation, () => createId(), existing);
+}
+/**
+* Build a record of TimeZone objects keyed by tzId.
+* @param items TimeZone inputs.
+* @return TimeZone record keyed by tzId.
+*/
+function buildTimeZoneMap(items) {
+	const result = {};
+	items.forEach((item) => {
+		const timeZone = buildTimeZone(item);
+		result[timeZone.tzId] = timeZone;
+	});
+	return result;
+}
+
+//#endregion
+//#region src/jscal.ts
+const JsCal = {
+	Event: EventObject,
+	Task: TaskObject,
+	Group: GroupObject,
+	createUid,
+	createId,
+	isEvent,
+	isGroup,
+	isTask,
+	duration: Duration,
+	timeZone: resolveTimeZone,
+	timeZones: TimeZones,
+	applyPatch,
+	Participant: buildParticipant,
+	Location: buildLocation,
+	VirtualLocation: buildVirtualLocation,
+	Alert: buildAlert,
+	OffsetTrigger: buildOffsetTrigger,
+	AbsoluteTrigger: buildAbsoluteTrigger,
+	Relation: buildRelation,
+	Link: buildLink,
+	TimeZone: buildTimeZone,
+	TimeZoneRule: buildTimeZoneRule,
+	RecurrenceRule: buildRecurrenceRule,
+	NDay: buildNDay,
+	ByDay: buildNDay,
+	EventPatch: buildEventPatch,
+	TaskPatch: buildTaskPatch,
+	GroupPatch: buildGroupPatch,
+	participants: buildParticipants,
+	locations: buildLocations,
+	virtualLocations: buildVirtualLocations,
+	alerts: buildAlerts,
+	links: buildLinks,
+	relatedTo: buildRelatedTo,
+	timeZonesMap: buildTimeZoneMap,
+	findByUid(items, uid) {
+		return findByUid(normalizeItems(items), uid);
+	},
+	filterByType(items, type) {
+		return filterByType(normalizeItems(items), type);
+	},
+	groupByType(items) {
+		return groupByType(normalizeItems(items));
+	},
+	filterByText(items, query) {
+		return filterByText(normalizeItems(items), query);
+	},
+	filterByDateRange(items, range, options) {
+		return filterByDateRange(normalizeItems(items), range, options);
+	},
+	expandRecurrence(items, range) {
+		return expandRecurrence(normalizeItems(items), range);
+	},
+	expandRecurrencePaged(items, range, options) {
+		return expandRecurrencePaged(normalizeItems(items), range, options);
+	},
+	toICal(value, options) {
+		return toICal(normalizeToObjects(value), options);
+	}
+};
+
+//#endregion
+exports.JsCal = JsCal;
+exports.ValidationError = ValidationError;