@dereekb/date 13.4.0 → 13.4.2

package/index.esm.js

@@ -8,6 +8,14 @@ import { ARKTYPE_DATE_DTO_TYPE } from '@dereekb/model';
 import { interval, startWith, map, distinctUntilChanged } from 'rxjs';
 import { RRule } from 'rrule';
 
+function _array_like_to_array$7(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$5(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$7(arr);
+}
 function _define_property$h(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -21,6 +29,12 @@ function _define_property$h(obj, key, value) {
     }
     return obj;
 }
+function _iterable_to_array$5(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$5() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread$e(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -36,6 +50,17 @@ function _object_spread$e(target) {
     }
     return target;
 }
+function _to_consumable_array$5(arr) {
+    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$7(arr) || _non_iterable_spread$5();
+}
+function _unsupported_iterable_to_array$7(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$7(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$7(o, minLen);
+}
 /**
  * Sentinel date representing the maximum future date (January 1, 9999 UTC).
  *
@@ -133,6 +158,8 @@ function _object_spread$e(target) {
  *
  * Useful as a default for "no expiration" comparisons.
  *
+ * @returns the MAX_FUTURE_DATE sentinel
+ *
  * @example
  * ```ts
  * const futureDate = maxFutureDate();
@@ -203,8 +230,7 @@ function _object_spread$e(target) {
  * // tz === 'America/New_York' (or similar)
  * ```
  */ function guessCurrentTimezone() {
-    var _Intl_DateTimeFormat_resolvedOptions, _Intl_DateTimeFormat;
-    return (_Intl_DateTimeFormat = Intl.DateTimeFormat()) === null || _Intl_DateTimeFormat === void 0 ? void 0 : (_Intl_DateTimeFormat_resolvedOptions = _Intl_DateTimeFormat.resolvedOptions()) === null || _Intl_DateTimeFormat_resolvedOptions === void 0 ? void 0 : _Intl_DateTimeFormat_resolvedOptions.timeZone;
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
 /**
  * Returns the current system's timezone, throwing if detection fails.
@@ -294,15 +320,15 @@ function isBefore(a, b) {
 }
 function isSameDate(a, b) {
     var defaultValue = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
-    return a != null && b != null ? isEqual(a, b) : defaultValue != null ? defaultValue : a == b;
+    return a != null && b != null ? isEqual(a, b) : defaultValue !== null && defaultValue !== void 0 ? defaultValue : a == b;
 }
 function isSameDateHoursAndMinutes(a, b) {
     var defaultValue = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
-    return a != null && b != null ? isEqual(roundDownToMinute(a), roundDownToMinute(b)) : defaultValue != null ? defaultValue : a == b;
+    return a != null && b != null ? isEqual(roundDownToMinute(a), roundDownToMinute(b)) : defaultValue !== null && defaultValue !== void 0 ? defaultValue : a == b;
 }
 function isSameDateDay(a, b) {
     var defaultValue = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
-    return a != null && b != null ? isSameDay(a, b) : defaultValue != null ? defaultValue : a == b;
+    return a != null && b != null ? isSameDay(a, b) : defaultValue !== null && defaultValue !== void 0 ? defaultValue : a == b;
 }
 // MARK: Unix Date/Time
 /**
@@ -346,6 +372,10 @@ function isSameDateDay(a, b) {
  * Sets the hours and optionally minutes on a target date (defaults to now), with optional rounding to strip seconds/milliseconds.
  *
  * @param config - hours, optional minutes, and rounding options
+ * @param config.hours - the hours value to set
+ * @param config.minutes - optional minutes value to set
+ * @param config.removeSeconds - whether to zero out seconds
+ * @param config.roundDownToMinute - whether to zero out seconds and milliseconds (defaults to true)
  * @param target - date to modify (defaults to the current date/time)
  * @returns a new Date with the specified time values applied
  *
@@ -575,7 +605,7 @@ function roundDateTo(date, roundToUnit) {
  * // names === ['Mon', 'Tue']
  * ```
  */ function readDaysOfWeekNames(values, readDate, nameFunction) {
-    return Array.from(readDaysOfWeek(values, readDate)).sort(sortNumbersAscendingFunction).map(nameFunction);
+    return _to_consumable_array$5(readDaysOfWeek(values, readDate)).sort(sortNumbersAscendingFunction).map(nameFunction);
 }
 /**
  * Checks whether the given date falls exactly at midnight (00:00:00.000) in UTC.
@@ -844,6 +874,9 @@ function _is_native_reflect_construct$2() {
 /**
  * Type guard to check if a value conforms to the {@link DateRangeStart} interface.
  *
+ * @param value - the value to check
+ * @returns true if the value has a valid Date `start` property
+ *
  * @example
  * ```ts
  * isDateRangeStart({ start: new Date() }); // true
@@ -872,6 +905,9 @@ function _is_native_reflect_construct$2() {
  * Counts the total number of calendar days spanned by the range, inclusive of both endpoints.
  * Always returns at least 1, even for same-day ranges.
  *
+ * @param dateRange - the date range to measure
+ * @returns the number of days in the range, inclusive
+ *
  * @example
  * ```ts
  * const range = { start: new Date('2024-01-01'), end: new Date('2024-01-03') };
@@ -883,6 +919,9 @@ function _is_native_reflect_construct$2() {
 /**
  * Type guard to check if a value is a valid {@link DateRange} with both start and end as Date objects.
  *
+ * @param input - the value to check
+ * @returns true if the value has valid Date `start` and `end` properties
+ *
  * @example
  * ```ts
  * isDateRange({ start: new Date(), end: new Date() }); // true
@@ -896,6 +935,10 @@ function _is_native_reflect_construct$2() {
  * Compares two date ranges for exact millisecond equality on both start and end.
  * Returns true if both are nullish.
  *
+ * @param a - first date range to compare
+ * @param b - second date range to compare
+ * @returns true if both ranges are equal or both are nullish
+ *
  * @example
  * ```ts
  * const a = { start: new Date('2024-01-01'), end: new Date('2024-01-31') };
@@ -910,6 +953,10 @@ function _is_native_reflect_construct$2() {
  * Compares two date ranges for calendar-day equality, ignoring time-of-day differences.
  * Returns true if both are nullish.
  *
+ * @param a - first date range to compare
+ * @param b - second date range to compare
+ * @returns true if both ranges fall on the same calendar days or both are nullish
+ *
  * @example
  * ```ts
  * const a = { start: new Date('2024-01-01T08:00:00'), end: new Date('2024-01-31T10:00:00') };
@@ -922,6 +969,9 @@ function _is_native_reflect_construct$2() {
 /**
  * Checks whether the range is unbounded (neither start nor end is set), meaning it conceptually includes all dates.
  *
+ * @param input - the partial date range to check
+ * @returns true if neither start nor end is set
+ *
  * @example
  * ```ts
  * isInfiniteDateRange({}); // true
@@ -933,6 +983,9 @@ function _is_native_reflect_construct$2() {
 /**
  * Checks whether the range has only one of start or end set, but not both.
  *
+ * @param input - the partial date range to check
+ * @returns true if exactly one of start or end is set
+ *
  * @example
  * ```ts
  * isPartialDateRange({ start: new Date() }); // true
@@ -944,6 +997,9 @@ function _is_native_reflect_construct$2() {
 /**
  * Checks whether the range has both start and end set.
  *
+ * @param input - the partial date range to check
+ * @returns true if both start and end are set
+ *
  * @example
  * ```ts
  * isFullDateRange({ start: new Date(), end: new Date() }); // true
@@ -956,6 +1012,10 @@ function _is_native_reflect_construct$2() {
  * Normalizes a Date or {@link DateRange} into a DateRange. When given a single Date,
  * uses it as start and optionally uses the provided end date (defaults to the same date).
  *
+ * @param startOrDateRange - a Date or existing DateRange
+ * @param end - optional end date when the first argument is a plain Date
+ * @returns a DateRange
+ *
  * @example
  * ```ts
  * const range = dateOrDateRangeToDateRange(new Date('2024-01-01'), new Date('2024-01-31'));
@@ -1028,6 +1088,9 @@ var DateRangeType;
  * Creates a {@link DateRange} from the given type and optional parameters. Supports many range
  * strategies including fixed periods (day, week, month), directional ranges, and radii.
  *
+ * @param input - the range type or full configuration object
+ * @param inputRoundToMinute - optional override to round the date to the start of its minute
+ * @returns a computed DateRange
  * @throws Error if the type is not a recognized {@link DateRangeType}
  *
  * @example
@@ -1061,25 +1124,27 @@ var DateRangeType;
         start = startOfFn(preStart);
         end = endOfFn(preEnd);
     }
-    function calculateStartAndEndForBetween(addFn) {
-        var distance = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, startOfFn = arguments.length > 2 ? arguments[2] : void 0, endOfFn = arguments.length > 3 ? arguments[3] : void 0;
+    function calculateStartAndEndForBetween(config) {
+        var addFn = config.addFn, tmp = config.distance, betweenDistance = tmp === void 0 ? 0 : tmp, startOfFn = config.startOfFn, endOfFn = config.endOfFn;
         var preStart;
         var preEnd;
-        switch(distance){
+        switch(betweenDistance){
             case 0:
                 preStart = date;
                 preEnd = date;
                 break;
             default:
-                var hasNegativeDistance = distance < 0;
-                if (hasNegativeDistance) {
-                    preStart = addFn(date, distance);
-                    preEnd = date;
-                } else {
-                    preStart = date;
-                    preEnd = addFn(date, distance);
+                {
+                    var hasNegativeDistance = betweenDistance < 0;
+                    if (hasNegativeDistance) {
+                        preStart = addFn(date, betweenDistance);
+                        preEnd = date;
+                    } else {
+                        preStart = date;
+                        preEnd = addFn(date, betweenDistance);
+                    }
+                    break;
                 }
-                break;
         }
         start = startOfFn(preStart);
         end = endOfFn(preEnd);
@@ -1101,19 +1166,44 @@ var DateRangeType;
             calculateStartAndEndForDate(startOfMinute, endOfMinute);
             break;
         case DateRangeType.MINUTES_RANGE:
-            calculateStartAndEndForBetween(addMinutes, rawDistance, startOfMinute, endOfMinute);
+            calculateStartAndEndForBetween({
+                addFn: addMinutes,
+                distance: rawDistance,
+                startOfFn: startOfMinute,
+                endOfFn: endOfMinute
+            });
             break;
         case DateRangeType.HOURS_RANGE:
-            calculateStartAndEndForBetween(addHours, rawDistance, startOfHour, endOfHour);
+            calculateStartAndEndForBetween({
+                addFn: addHours,
+                distance: rawDistance,
+                startOfFn: startOfHour,
+                endOfFn: endOfHour
+            });
             break;
         case DateRangeType.DAYS_RANGE:
-            calculateStartAndEndForBetween(addDays, rawDistance, startOfDay, endOfDay);
+            calculateStartAndEndForBetween({
+                addFn: addDays,
+                distance: rawDistance,
+                startOfFn: startOfDay,
+                endOfFn: endOfDay
+            });
             break;
         case DateRangeType.WEEKS_RANGE:
-            calculateStartAndEndForBetween(addWeeks, rawDistance, startOfWeek, endOfWeek);
+            calculateStartAndEndForBetween({
+                addFn: addWeeks,
+                distance: rawDistance,
+                startOfFn: startOfWeek,
+                endOfFn: endOfWeek
+            });
             break;
         case DateRangeType.MONTHS_RANGE:
-            calculateStartAndEndForBetween(addMonths, rawDistance, startOfMonth, endOfMonth);
+            calculateStartAndEndForBetween({
+                addFn: addMonths,
+                distance: rawDistance,
+                startOfFn: startOfMonth,
+                endOfFn: endOfMonth
+            });
             break;
         case DateRangeType.MINUTES_RADIUS:
             distance = Math.abs(distance);
@@ -1136,10 +1226,12 @@ var DateRangeType;
             end = addDays(date, distance * 7);
             break;
         case DateRangeType.CALENDAR_MONTH:
-            var monthStart = startOfMonth(endOfWeek(date));
-            start = startOfWeek(monthStart);
-            end = endOfWeek(endOfMonth(monthStart));
-            break;
+            {
+                var monthStart = startOfMonth(endOfWeek(date));
+                start = startOfWeek(monthStart);
+                end = endOfWeek(endOfMonth(monthStart));
+                break;
+            }
         default:
             throw new Error("Unknown date range type: ".concat(type));
     }
@@ -1152,6 +1244,9 @@ var DateRangeType;
  * Returns a range spanning the full calendar day (first to last millisecond) of the given date.
  * Convenience wrapper around {@link dateRange} with {@link DateRangeType.DAY}.
  *
+ * @param date - the date whose full day range to return
+ * @returns a DateRange from start of day to end of day
+ *
  * @example
  * ```ts
  * const range = dateRangeFromStartAndEndOfDay(new Date('2024-06-15T14:30:00'));
@@ -1190,6 +1285,8 @@ var DEFAULT_ITERATE_DAYS_IN_DATE_RANGE_MAX_ITERATIONS = 4000;
  * Creates a reusable function that iterates over dates within a range using a configurable step function.
  * Supports max iteration limits and early bail-out via {@link endItreateDaysInDateRangeEarly}.
  *
+ * @param input - configuration or a step function for advancing between dates
+ * @returns a reusable iteration function
  * @throws Error if max iterations is exceeded and throwErrorOnMaxIterations is true
  *
  * @example
@@ -1243,6 +1340,8 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Creates a reusable function that expands a {@link DateRange} into an array of individual day dates.
  * Includes a configurable safety limit to prevent accidental memory exhaustion from large ranges.
  *
+ * @param config - optional configuration for the max expansion size
+ * @returns a function that expands a DateRange into an array of Dates
  * @throws Error if the range spans more days than the configured maxExpansionSize
  *
  * @example
@@ -1272,6 +1371,9 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Expands a {@link DateRange} into an array of one Date per day. Uses the default max expansion size.
  * Convenience wrapper around {@link expandDaysForDateRangeFunction}.
  *
+ * @param range - the date range to expand
+ * @returns an array of Dates, one per day in the range
+ *
  * @example
  * ```ts
  * const days = expandDaysForDateRange({ start: new Date('2024-01-01'), end: new Date('2024-01-03') });
@@ -1283,6 +1385,12 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
 /**
  * Determines whether the current moment (or provided `now`) falls before, within, or after the given range.
  *
+ * @param dateRange - the date range to compare against
+ * @param dateRange.start - the start of the range
+ * @param dateRange.end - the end of the range
+ * @param now - the reference date, defaults to the current moment
+ * @returns 'past', 'present', or 'future'
+ *
  * @example
  * ```ts
  * const range = { start: new Date('2024-01-01'), end: new Date('2024-12-31') };
@@ -1305,6 +1413,10 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
 /**
  * Groups an array of date ranges into past, present, and future buckets based on the current moment (or provided `now`).
  *
+ * @param dateRanges - the date ranges to group
+ * @param _now - the reference date, defaults to the current moment
+ * @returns an object with past, present, and future arrays
+ *
  * @example
  * ```ts
  * const ranges = [
@@ -1323,6 +1435,10 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Checks whether a date falls within a (possibly partial) date range.
  * Convenience wrapper around {@link isDateInDateRangeFunction}.
  *
+ * @param date - the date to test
+ * @param dateRange - the range to test against
+ * @returns true if the date falls within the range
+ *
  * @example
  * ```ts
  * const range = { start: new Date('2024-01-01'), end: new Date('2024-12-31') };
@@ -1337,6 +1453,9 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Handles partial ranges: if only start is set, checks >= start; if only end, checks <= end;
  * if neither, all dates are considered in range.
  *
+ * @param dateRange - the boundary range to test against
+ * @returns a function that tests whether a date falls within the range
+ *
  * @example
  * ```ts
  * const isInQ1 = isDateInDateRangeFunction({
@@ -1371,7 +1490,7 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
             return time <= endTime1;
         };
     } else {
-        fn = function fn(input) {
+        fn = function fn(_input) {
             return true;
         };
     }
@@ -1382,6 +1501,10 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Checks whether a date range is fully contained within another (possibly partial) date range.
  * Convenience wrapper around {@link isDateRangeInDateRangeFunction}.
  *
+ * @param compareDateRange - the range to test for containment
+ * @param dateRange - the boundary range
+ * @returns true if compareDateRange is fully within dateRange
+ *
  * @example
  * ```ts
  * const outer = { start: new Date('2024-01-01'), end: new Date('2024-12-31') };
@@ -1395,6 +1518,9 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Creates a reusable function that tests whether a given date range is fully contained within
  * the configured boundary range. Both start and end of the input must be within bounds.
  *
+ * @param dateRange - the boundary range
+ * @returns a function that tests containment of other ranges
+ *
  * @example
  * ```ts
  * const isInYear = isDateRangeInDateRangeFunction({
@@ -1416,6 +1542,10 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Checks whether two date ranges overlap in any way (partial or full).
  * Convenience wrapper around {@link dateRangeOverlapsDateRangeFunction}.
  *
+ * @param compareDateRange - the range to test for overlap
+ * @param dateRange - the reference range
+ * @returns true if the ranges overlap
+ *
  * @example
  * ```ts
  * const a = { start: new Date('2024-01-01'), end: new Date('2024-06-30') };
@@ -1429,6 +1559,9 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Creates a reusable function that tests whether input ranges overlap the configured boundary range.
  * Two ranges overlap if one starts before the other ends, and vice versa.
  *
+ * @param dateRange - the boundary range to test overlap against
+ * @returns a function that tests overlap of other ranges
+ *
  * @example
  * ```ts
  * const overlapsQ1 = dateRangeOverlapsDateRangeFunction({
@@ -1460,6 +1593,9 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  *
  * Operates in UTC, so daylight savings transitions are not considered.
  *
+ * @param dateRange - the date range to fit into a single day period
+ * @returns a new date range with the same start and an end within 24 hours of start
+ *
  * @example
  * ```ts
  * // 10AM to 1PM across 3 days becomes same-day 10AM to 1PM
@@ -1487,6 +1623,9 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Dates before start are clamped to start; dates after end are clamped to end.
  * Partial ranges clamp only on the side that is defined.
  *
+ * @param dateRange - the boundary range for clamping
+ * @returns a function that clamps dates to the range
+ *
  * @example
  * ```ts
  * const clamp = clampDateFunction({
@@ -1502,15 +1641,16 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
     var hasStartDate = dateRange.start != null;
     var hasEndDate = dateRange.end != null;
     if (hasStartDate || hasEndDate) {
+        var _ref, _ref1;
         var _dateRange_start, _dateRange_end;
         // Start Clamp
-        var startTime = ((_dateRange_start = dateRange.start) === null || _dateRange_start === void 0 ? void 0 : _dateRange_start.getTime()) || 0;
+        var startTime = (_ref = (_dateRange_start = dateRange.start) === null || _dateRange_start === void 0 ? void 0 : _dateRange_start.getTime()) !== null && _ref !== void 0 ? _ref : 0;
         var clampStart = function clampStart(input) {
             var time = input.getTime();
             return time >= startTime ? input : dateRange.start;
         };
         // End Clamp
-        var endTime = ((_dateRange_end = dateRange.end) === null || _dateRange_end === void 0 ? void 0 : _dateRange_end.getTime()) || 0;
+        var endTime = (_ref1 = (_dateRange_end = dateRange.end) === null || _dateRange_end === void 0 ? void 0 : _dateRange_end.getTime()) !== null && _ref1 !== void 0 ? _ref1 : 0;
         var clampEnd = function clampEnd(input) {
             var time = input.getTime();
             return time <= endTime ? input : dateRange.end;
@@ -1540,6 +1680,10 @@ var DEFAULT_EXPAND_DAYS_FOR_DATE_RANGE_MAX_EXPANSION_SIZE = 1500;
  * Clamps a single date to fall within the given range boundaries.
  * Convenience wrapper around {@link clampDateFunction}.
  *
+ * @param date - the date to clamp
+ * @param dateRange - the boundary range
+ * @returns the clamped date
+ *
  * @example
  * ```ts
  * const range = { start: new Date('2024-01-01'), end: new Date('2024-12-31') };
@@ -1567,6 +1711,10 @@ function clampDateRangeFunction(dateRange) {
  * Clamps a date range to fit within a boundary range.
  * Convenience wrapper around {@link clampDateRangeFunction}.
  *
+ * @param inputDateRange - the date range to clamp
+ * @param limitToDateRange - the boundary range
+ * @returns the clamped date range
+ *
  * @example
  * ```ts
  * const input = { start: new Date('2023-06-01'), end: new Date('2024-06-30') };
@@ -1580,6 +1728,9 @@ function clampDateRangeFunction(dateRange) {
 /**
  * Creates a function that applies a date transformation to both start and end of a {@link DateRange}.
  *
+ * @param transform - the transformation to apply to both dates
+ * @returns a function that transforms both dates of a DateRange
+ *
  * @example
  * ```ts
  * import { startOfHour } from 'date-fns';
@@ -1603,6 +1754,9 @@ function clampDateRangeFunction(dateRange) {
  * Returns each unique day of the week present in the range, in the order they appear starting from
  * the range's start day. For ranges spanning 7+ days, returns all days of the week.
  *
+ * @param dateRange - the date range to inspect
+ * @returns an array of unique day-of-week values present in the range
+ *
  * @example
  * ```ts
  * // Wednesday through Friday
@@ -1766,8 +1920,11 @@ function _type_of$6(obj) {
  * isValidDateTimezoneConversionConfig({ timezone: 'America/Chicago' }); // true
  * isValidDateTimezoneConversionConfig({}); // false
  * ```
+ *
+ * @param input - the conversion config to validate
+ * @returns true if the config has at least one meaningful conversion property set
  */ function isValidDateTimezoneConversionConfig(input) {
-    return input.useSystemTimezone || input.timezone != null || input.timezoneOffset != null || input.noConversion || false;
+    return input.useSystemTimezone === true || input.timezone != null || input.timezoneOffset != null || input.noConversion === true;
 }
 /**
  * Compares two configs for logical equivalence, accounting for the fact that
@@ -1778,12 +1935,16 @@ function _type_of$6(obj) {
  * isSameDateTimezoneConversionConfig({ timezone: 'UTC' }, { timezone: undefined }); // true
  * isSameDateTimezoneConversionConfig({ useSystemTimezone: true }, { timezone: 'America/Denver' }); // false
  * ```
+ *
+ * @param a - first conversion config to compare
+ * @param b - second conversion config to compare
+ * @returns true if both configs are logically equivalent
  */ function isSameDateTimezoneConversionConfig(a, b) {
     var isSame = false;
     if (a.useSystemTimezone || b.useSystemTimezone || a.timezoneOffset || b.timezoneOffset) {
         isSame = isSameNonNullValue(a.useSystemTimezone, b.useSystemTimezone) || isSameNonNullValue(a.timezoneOffset, b.timezoneOffset);
     } else {
-        isSame = isConsideredUtcTimezoneString(a.timezone) && isConsideredUtcTimezoneString(b.timezone) || a != null && a === b;
+        isSame = isConsideredUtcTimezoneString(a.timezone) && isConsideredUtcTimezoneString(b.timezone) || a === b;
     }
     return isSame;
 }
@@ -1802,6 +1963,7 @@ function _type_of$6(obj) {
  * ```
  *
  * @param date - required to determine the correct offset for that instant (DST-aware)
+ * @returns the system timezone UTC offset in milliseconds
  */ function getCurrentSystemOffsetInMs(date) {
     // Use native getTimezoneOffset() instead of calculateTimezoneOffset() to avoid
     // a DST edge case where toZonedTime() creates an epoch that lands on the system's
@@ -1818,6 +1980,7 @@ function _type_of$6(obj) {
  * ```
  *
  * @param date - required to determine the correct offset for that instant (DST-aware)
+ * @returns the system timezone UTC offset truncated to whole hours
  */ function getCurrentSystemOffsetInHours(date) {
     return millisecondsToHours(getCurrentSystemOffsetInMs(date));
 }
@@ -1834,6 +1997,7 @@ function _type_of$6(obj) {
  * ```
  *
  * @param date - required to determine the correct offset for that instant (DST-aware)
+ * @returns the system timezone UTC offset in minutes
  */ function getCurrentSystemOffsetInMinutes(date) {
     return millisecondsToMinutes(getCurrentSystemOffsetInMs(date));
 }
@@ -1854,6 +2018,7 @@ function _type_of$6(obj) {
  *
  * @param timezone - IANA timezone string (e.g. 'America/New_York')
  * @param date - the instant to evaluate, since DST may shift the offset
+ * @returns the UTC offset for the given timezone at the given instant, in milliseconds
  */ function calculateTimezoneOffset(timezone, date) {
     var tzOffset;
     // UTC always has zero offset; skip toZonedTime which can produce wrong results
@@ -1880,7 +2045,15 @@ function _type_of$6(obj) {
     }
     return tzOffset;
 }
-function calculateAllConversions(date, converter) {
+/**
+ * Calculates offset values for every pair of conversion targets (target, base, system)
+ * and returns them as a keyed map (e.g. `'target-base'`, `'base-system'`).
+ *
+ * @param date - the reference date used to compute offsets
+ * @param converter - the converter instance providing offset calculations
+ * @param map - optional mapping function applied to each raw millisecond offset
+ * @returns a map of conversion-pair keys to their computed offset values
+ */ function calculateAllConversions(date, converter) {
     var map = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : function(x) {
         return x;
     };
@@ -1907,6 +2080,9 @@ function calculateAllConversions(date, converter) {
  * inverseDateTimezoneUtcNormalInstanceTransformType('targetDateToBaseDate'); // 'baseDateToTargetDate'
  * inverseDateTimezoneUtcNormalInstanceTransformType('systemDateToTargetDate'); // 'targetDateToSystemDate'
  * ```
+ *
+ * @param input - the transform type to invert
+ * @returns the inverse transform type for round-trip conversion
  */ function inverseDateTimezoneUtcNormalInstanceTransformType(input) {
     var result;
     switch(input){
@@ -1928,6 +2104,8 @@ function calculateAllConversions(date, converter) {
         case 'targetDateToSystemDate':
             result = 'systemDateToTargetDate';
             break;
+        default:
+            throw new Error("Unexpected transform type: ".concat(input));
     }
     return result;
 }
@@ -1959,8 +2137,7 @@ function calculateAllConversions(date, converter) {
             };
         };
         var calculateOffset = function calculateOffset(date) {
-            var offset = getOffsetInMsFn(date);
-            return offset;
+            return getOffsetInMsFn(date);
         };
         var calculateSystemNormalDifference = function calculateSystemNormalDifference(date) {
             var normalOffset = calculateOffset(date);
@@ -2069,12 +2246,11 @@ function calculateAllConversions(date, converter) {
      * For example, when daylight savings changed on November 3, 2024 the offset returned was 5 but to get back to the original an offset of 6 was required.
      * This is where some contextual data was not being used. This function uses that contextual data to make sure the reverse will be consistent.
      *
-     * @param baseDate The base date. Should have been derived from the originalContextDate using the convertDate() function
-     * @param originalContextDate Original date used to derive the baseDate.
-     * @param fromOrTo the "type" of date the originalContextDate is
+     * @param config - configuration for the safe mirrored conversion
+     * @returns the converted date and the DST offset adjustment applied
      */ key: "safeMirroredConvertDate",
-            value: function safeMirroredConvertDate(baseDate, originalContextDate, contextType) {
-                var safeConvert = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
+            value: function safeMirroredConvertDate(config) {
+                var baseDate = config.baseDate, originalContextDate = config.originalContextDate, contextType = config.contextType, _config_safeConvert = config.safeConvert, safeConvert = _config_safeConvert === void 0 ? true : _config_safeConvert;
                 if (contextType === 'base') {
                     return {
                         date: baseDate,
@@ -2237,7 +2413,8 @@ function calculateAllConversions(date, converter) {
             /**
      * Returns true if the input is midnight in the target timezone.
      *
-     * @param date
+     * @param date - the date to check
+     * @returns true if the date is at the start of the day in the target timezone
      */ key: "isStartOfDayInTargetTimezone",
             value: function isStartOfDayInTargetTimezone(date) {
                 var utcNormal = this.baseDateToTargetDate(date);
@@ -2248,7 +2425,8 @@ function calculateAllConversions(date, converter) {
             /**
      * Start of the given day in the target timezone.
      *
-     * @param date The input is treated as an instant in time.
+     * @param date - the input is treated as an instant in time
+     * @returns the start-of-day date in the target timezone
      */ key: "startOfDayInTargetTimezone",
             value: function startOfDayInTargetTimezone(date) {
                 var baseDay = this.startOfDayInBaseDate(date);
@@ -2259,7 +2437,8 @@ function calculateAllConversions(date, converter) {
             /**
      * Start of the given day in UTC.
      *
-     * @param date
+     * @param date - the date or ISO8601 day string to get the start of day for
+     * @returns the start of the day as a BaseDateAsUTC
      */ key: "startOfDayInBaseDate",
             value: function startOfDayInBaseDate(date) {
                 if (typeof date === 'string') {
@@ -2274,8 +2453,8 @@ function calculateAllConversions(date, converter) {
             /**
      * End of the given day in UTC.
      *
-     * @param date
-     * @returns
+     * @param date - the date or ISO8601 day string to get the end of day for
+     * @returns the end of the day as a BaseDateAsUTC (23:59:59.999)
      */ key: "endOfDayInBaseDate",
             value: function endOfDayInBaseDate(date) {
                 var result = this.startOfDayInBaseDate(date);
@@ -2287,8 +2466,8 @@ function calculateAllConversions(date, converter) {
             /**
      * Start of the given day for the system.
      *
-     * @param date
-     * @returns
+     * @param date - the date or ISO8601 day string to get the start of day for
+     * @returns the start of the day in the system timezone
      */ key: "startOfDayInSystemDate",
             value: function startOfDayInSystemDate(date) {
                 if (typeof date === 'string') {
@@ -2303,8 +2482,8 @@ function calculateAllConversions(date, converter) {
             /**
      * End of the given day for the system.
      *
-     * @param date
-     * @returns
+     * @param date - the date or ISO8601 day string to get the end of day for
+     * @returns the end of the day in the system timezone
      */ key: "endOfDayInSystemDate",
             value: function endOfDayInSystemDate(date) {
                 return endOfDay(this.startOfDayInSystemDate(date));
@@ -2312,9 +2491,10 @@ function calculateAllConversions(date, converter) {
         },
         {
             /**
-     * Whether or not the system experiences daylight savings for the given year.
+     * Whether or not the target timezone experiences daylight savings for the given year.
      *
-     * @param year
+     * @param year - the year to check, as a Date or number; defaults to the current year
+     * @returns true if the target timezone has different offsets in January and July
      */ key: "targetTimezoneExperiencesDaylightSavings",
             value: function targetTimezoneExperiencesDaylightSavings() {
                 var year = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : new Date();
@@ -2371,6 +2551,8 @@ function calculateAllConversions(date, converter) {
  * const same = dateTimezoneUtcNormal(denver); // same reference
  * ```
  *
+ * @param config - timezone input: an existing instance, timezone string, millisecond offset, or config object
+ * @returns a DateTimezoneUtcNormalInstance for the given input
  * @throws Error if the input type is not recognized
  */ function dateTimezoneUtcNormal(config) {
     var instance;
@@ -2393,7 +2575,7 @@ function calculateAllConversions(date, converter) {
                 });
                 break;
             default:
-                throw new Error('Invalid input passed to dateTimezoneUtcNormal()');
+                throw new Error('Invalid input type "'.concat(type, '" passed to dateTimezoneUtcNormal()'));
         }
     }
     return instance;
@@ -2416,6 +2598,8 @@ function calculateAllConversions(date, converter) {
  *
  * Prefer this over constructing a new instance when you need system-timezone conversions,
  * as the singleton avoids unnecessary allocations.
+ *
+ * @returns the shared system-timezone DateTimezoneUtcNormalInstance singleton
  */ function systemDateTimezoneUtcNormal() {
     return SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE;
 }
@@ -2432,10 +2616,13 @@ function calculateAllConversions(date, converter) {
  * const target = baseDateToTargetDate(base, 'America/Denver');
  * // target is 2024-06-15T14:00:00.000-06:00 (2PM MDT)
  * ```
+ *
+ * @param date - the BaseDateAsUTC to convert
+ * @param timezone - the target IANA timezone string
+ * @returns a real instant in the specified timezone
  */ function baseDateToTargetDate(date, timezone) {
     var instance = new DateTimezoneUtcNormalInstance(timezone);
-    var result = instance.baseDateToTargetDate(date);
-    return result;
+    return instance.baseDateToTargetDate(date);
 }
 /**
  * Convenience function that strips the timezone offset from a target-timezone date,
@@ -2450,30 +2637,46 @@ function calculateAllConversions(date, converter) {
  * const base = targetDateToBaseDate(target, 'America/Denver');
  * // base is 2024-06-15T14:00:00.000Z — wall-clock 2PM preserved as UTC
  * ```
+ *
+ * @param date - the target-timezone date to convert
+ * @param timezone - the IANA timezone the date is expressed in
+ * @returns a BaseDateAsUTC with wall-clock time preserved as UTC
  */ function targetDateToBaseDate(date, timezone) {
     return new DateTimezoneUtcNormalInstance(timezone).targetDateToBaseDate(date);
 }
 /**
  * Converts a {@link BaseDateAsUTC} to a target date in the system's local timezone
  * using the shared system-timezone instance.
+ *
+ * @param date - the BaseDateAsUTC to convert
+ * @returns the date converted to the system's local timezone
  */ function systemBaseDateToNormalDate(date) {
     return SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.baseDateToTargetDate(date);
 }
 /**
  * Converts a target date in the system's local timezone back to a {@link BaseDateAsUTC}
  * using the shared system-timezone instance.
+ *
+ * @param date - the system-timezone target date to convert back to base
+ * @returns the corresponding BaseDateAsUTC
  */ function systemNormalDateToBaseDate(date) {
     return SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.targetDateToBaseDate(date);
 }
 /**
  * Returns the millisecond offset needed to convert a {@link BaseDateAsUTC} to a target date
  * in the system's local timezone.
+ *
+ * @param date - the date to compute the offset for
+ * @returns the offset in milliseconds
  */ function systemBaseDateToNormalDateOffset(date) {
     return SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.baseDateToTargetDateOffset(date);
 }
 /**
  * Returns the millisecond offset needed to convert a target date in the system's
  * local timezone back to a {@link BaseDateAsUTC}.
+ *
+ * @param date - the date to compute the offset for
+ * @returns the offset in milliseconds
  */ function systemNormalDateToBaseDateOffset(date) {
     return SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.targetDateToBaseDateOffset(date);
 }
@@ -2481,6 +2684,9 @@ function calculateAllConversions(date, converter) {
  * Returns whether the system's local timezone observes daylight saving time in the given year.
  *
  * Compares the offset on January 1 and July 1; if they differ, DST is in effect for part of the year.
+ *
+ * @param year - the year to check, as a Date
+ * @returns true if the system timezone observes DST in the given year
  */ function systemExperiencesDaylightSavings(year) {
     return SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.targetTimezoneExperiencesDaylightSavings(year);
 }
@@ -2496,7 +2702,9 @@ function calculateAllConversions(date, converter) {
  * const result = fn(someDate, (d) => startOfDay(d));
  * ```
  *
+ * @param timezoneInput - timezone configuration for the conversion
  * @param transformType - defaults to `'systemDateToTargetDate'`
+ * @returns a function that transforms dates within the specified timezone normalization
  */ function transformDateInTimezoneNormalFunction(timezoneInput) {
     var transformType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'systemDateToTargetDate';
     var timezoneInstance = dateTimezoneUtcNormal(timezoneInput);
@@ -2515,7 +2723,9 @@ function calculateAllConversions(date, converter) {
  * Creates a {@link TransformDateRangeToTimezoneFunction} that converts both dates in
  * a {@link DateRange} using the specified transform type.
  *
+ * @param timezoneInput - timezone configuration for the conversion
  * @param transformType - defaults to `'systemDateToTargetDate'`
+ * @returns a function that converts DateRange dates using the specified transform
  */ function transformDateRangeToTimezoneFunction(timezoneInput) {
     var transformType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'systemDateToTargetDate';
     var timezoneInstance = dateTimezoneUtcNormal(timezoneInput);
@@ -2528,7 +2738,9 @@ function calculateAllConversions(date, converter) {
  * Creates a {@link TransformDateRangeInTimezoneNormalFunction} that converts a date range
  * into the specified date space, applies a user-provided range transformation, then converts back.
  *
+ * @param timezoneInput - timezone configuration for the conversion
  * @param transformType - defaults to `'systemDateToTargetDate'`
+ * @returns a function that transforms date ranges within the specified timezone normalization
  */ function transformDateRangeInTimezoneNormalFunction(timezoneInput) {
     var transformType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'systemDateToTargetDate';
     var timezoneInstance = dateTimezoneUtcNormal(timezoneInput);
@@ -2552,6 +2764,9 @@ function calculateAllConversions(date, converter) {
  * const midnight = startOfDayInDenver('2024-06-15');
  * // midnight is 2024-06-15T06:00:00.000Z (midnight MDT = 6AM UTC)
  * ```
+ *
+ * @param timezone - timezone configuration to bind the factory to
+ * @returns a factory that converts ISO8601 day strings to start-of-day dates
  */ function startOfDayInTimezoneDayStringFactory(timezone) {
     var timezoneInstance = dateTimezoneUtcNormal(timezone);
     return function(day) {
@@ -2567,6 +2782,10 @@ function calculateAllConversions(date, converter) {
  * ```ts
  * const midnight = startOfDayInTimezoneFromISO8601DayString('2024-06-15', 'America/Denver');
  * ```
+ *
+ * @param day - the ISO8601 day string to parse
+ * @param timezone - timezone configuration for the start-of-day calculation
+ * @returns the start-of-day instant in the given timezone
  */ function startOfDayInTimezoneFromISO8601DayString(day, timezone) {
     return startOfDayInTimezoneDayStringFactory(timezone)(day);
 }
@@ -2583,6 +2802,9 @@ function calculateAllConversions(date, converter) {
  * const result = setOnDate({ date: someDate, hours: 14, minutes: 30, inputType: 'target' });
  * // result is someDate with hours set to 14:30 in Denver time
  * ```
+ *
+ * @param timezone - the timezone configuration to bind to
+ * @returns a function that sets hours/minutes on dates in the given timezone
  */ function setOnDateWithTimezoneNormalFunction(timezone) {
     var timezoneInstance = dateTimezoneUtcNormal(timezone);
     var fn = function fn(input) {
@@ -2600,7 +2822,7 @@ function calculateAllConversions(date, converter) {
                 return roundDownToMinute ? roundDateDownTo(inputDate, 'minute') : inputDate;
             }
             if (inputType !== 'base') {
-                copyFrom = copyFrom != null ? timezoneInstance.convertDate(copyFrom, 'base', inputType) : undefined;
+                copyFrom = timezoneInstance.convertDate(copyFrom, 'base', inputType);
             }
         }
         // set baseDate
@@ -2649,6 +2871,7 @@ function calculateAllConversions(date, converter) {
  *
  * @param input - the date whose day is preserved
  * @param timezone - the timezone context for the hour/minute interpretation
+ * @returns the input date with hours and minutes set to the current time in the given timezone
  */ function copyHoursAndMinutesFromNowWithTimezoneNormal(input, timezone) {
     return copyHoursAndMinutesFromDateWithTimezoneNormal(input, 'now', timezone);
 }
@@ -2669,16 +2892,16 @@ function calculateAllConversions(date, converter) {
  * @param input - the date whose day is preserved
  * @param copyFrom - the date (or `'now'`) whose hours/minutes are copied
  * @param timezone - the timezone context for interpreting both dates
+ * @returns the input date with hours and minutes copied from the source
  */ function copyHoursAndMinutesFromDateWithTimezoneNormal(input, copyFrom, timezone) {
     var timezoneInstance = dateTimezoneUtcNormal(timezone);
-    var result = timezoneInstance.setOnDate({
+    return timezoneInstance.setOnDate({
         date: input,
         copyFrom: copyFrom,
         inputType: 'target',
         copyHours: true,
         copyMinutes: true
     });
-    return result;
 }
 
 function _define_property$e(obj, key, value) {
@@ -2739,6 +2962,7 @@ function _object_spread$c(target) {
  *
  * @param dateRange - the range to fit
  * @param timezone - the timezone for day boundary calculation
+ * @returns the date range fitted to a single day period
  */ function fitDateRangeToDayPeriod(dateRange, timezone) {
     return fitDateRangeToDayPeriodFunction(timezone)(dateRange);
 }
@@ -2749,6 +2973,7 @@ function _object_spread$c(target) {
  * Useful when the same range formatting logic needs to be applied repeatedly with consistent settings.
  *
  * @param inputConfig - format function or full configuration
+ * @returns a reusable function that formats date ranges into strings
  *
  * @example
  * ```ts
@@ -2785,6 +3010,7 @@ function _object_spread$c(target) {
  * @param range - date range to format
  * @param inputConfig - format function or full configuration
  * @param separator - optional separator override when inputConfig is a function
+ * @returns the formatted date range string
  *
  * @example
  * ```ts
@@ -2808,6 +3034,7 @@ function _object_spread$c(target) {
  * (e.g., "3 hours", "about 2 days"). Delegates to date-fns `formatDistance` or `formatDistanceStrict`.
  *
  * @param inputConfig - controls distance formatting, optional transforms, and same-day handling
+ * @returns a reusable function that computes and formats date range distances
  *
  * @example
  * ```ts
@@ -2861,6 +3088,7 @@ function _object_spread$c(target) {
  *
  * @param range - date range to compute distance for
  * @param inputConfig - optional distance formatting configuration
+ * @returns the human-readable distance string
  *
  * @example
  * ```ts
@@ -2901,7 +3129,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
             end = endOrFormat;
         }
     }
-    var format = inputFormat !== null && inputFormat !== void 0 ? inputFormat : formatToShortDateString;
+    var format = inputFormat !== null && inputFormat !== void 0 ? inputFormat : formatToMonthDaySlashDate;
     return formatDateRange(dateOrDateRangeToDateRange(startOrDateRange, end), {
         format: format,
         simplifySameDate: true
@@ -2912,6 +3140,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * instead of throwing.
  *
  * @param input - date, date string, or nullish value
+ * @returns the ISO 8601 date string, or `undefined` if the input is invalid or nullish
  *
  * @example
  * ```ts
@@ -2934,6 +3163,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Formats a Date to a full ISO 8601 date-time string via `Date.toISOString()`. Defaults to the current date/time.
  *
  * @param date - date to format; defaults to `new Date()`
+ * @returns the full ISO 8601 date-time string
  *
  * @example
  * ```ts
@@ -2953,6 +3183,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Use {@link toISO8601DayStringForUTC} when the UTC date is needed instead.
  *
  * @param dateOrString - date or existing day string
+ * @returns the ISO 8601 day string in system timezone
  *
  * @example
  * ```ts
@@ -2972,6 +3203,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Defaults to the current date.
  *
  * @param date - date to format; defaults to `new Date()`
+ * @returns the ISO 8601 day string in system timezone
  *
  * @example
  * ```ts
@@ -2991,6 +3223,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Use {@link toISO8601DayStringForSystem} when the system-local date is needed instead.
  *
  * @param dateOrString - date or existing day string
+ * @returns the ISO 8601 day string in UTC
  *
  * @example
  * ```ts
@@ -3011,6 +3244,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Defaults to the current date.
  *
  * @param date - date to format; defaults to `new Date()`
+ * @returns the ISO 8601 day string using UTC date components
  *
  * @example
  * ```ts
@@ -3023,12 +3257,18 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
     var date = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : new Date();
     return "".concat(date.getUTCFullYear(), "-").concat((date.getUTCMonth() + 1).toString().padStart(2, '0'), "-").concat(date.getUTCDate().toString().padStart(2, '0'));
 }
-/** date-fns format string for `MM/dd/yyyy` (e.g., `"01/15/2024"`). */ var MONTH_DAY_SLASH_DATE_STRING_FORMAT = 'MM/dd/yyyy';
-/** @deprecated use MONTH_DAY_SLASH_DATE_STRING_FORMAT instead. */ var monthDaySlashDateStringFormat = MONTH_DAY_SLASH_DATE_STRING_FORMAT;
+/**
+ * date-fns format string for `MM/dd/yyyy` (e.g., `"01/15/2024"`).
+ */ var MONTH_DAY_SLASH_DATE_STRING_FORMAT = 'MM/dd/yyyy';
+/**
+ * @deprecated Use MONTH_DAY_SLASH_DATE_STRING_FORMAT instead.
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+var monthDaySlashDateStringFormat = MONTH_DAY_SLASH_DATE_STRING_FORMAT;
 /**
  * Formats a Date as a month/day/year slash-separated string (`MM/dd/yyyy`). Defaults to the current date.
  *
  * @param date - date to format; defaults to `new Date()`
+ * @returns the formatted `MM/dd/yyyy` string
  *
  * @example
  * ```ts
@@ -3044,12 +3284,18 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
 /**
  * @deprecated use formatToMonthDaySlashDate instead.
  */ var formatToShortDateString = formatToMonthDaySlashDate;
-/** date-fns format string for `MM/dd` (e.g., `"01/15"`). */ var DATE_MONTH_DAY_STRING_FORMAT = 'MM/dd';
-/** @deprecated use DATE_MONTH_DAY_STRING_FORMAT instead. */ var dateMonthDayStringFormat = DATE_MONTH_DAY_STRING_FORMAT;
+/**
+ * date-fns format string for `MM/dd` (e.g., `"01/15"`).
+ */ var DATE_MONTH_DAY_STRING_FORMAT = 'MM/dd';
+/**
+ * @deprecated Use DATE_MONTH_DAY_STRING_FORMAT instead.
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+var dateMonthDayStringFormat = DATE_MONTH_DAY_STRING_FORMAT;
 /**
  * Formats a Date as a month/day string (`MM/dd`) without the year. Defaults to the current date.
  *
  * @param date - date to format; defaults to `new Date()`
+ * @returns the formatted `MM/dd` string
  *
  * @example
  * ```ts
@@ -3066,6 +3312,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Formats a Date as a human-friendly weekday and month/day string (e.g., `"Mon, Jan 15th"`).
  *
  * @param date - date to format
+ * @returns the formatted weekday and month/day string
  *
  * @example
  * ```ts
@@ -3077,12 +3324,18 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  */ function formatToDateString(date) {
     return format$1(date, 'EEE, MMM do');
 }
-/** date-fns format string for 12-hour time with AM/PM (e.g., `"9:00 AM"`). */ var DATE_TIME_STRING_FORMAT = 'h:mm a';
-/** @deprecated use DATE_TIME_STRING_FORMAT instead. */ var dateTimeStringFormat = DATE_TIME_STRING_FORMAT;
+/**
+ * date-fns format string for 12-hour time with AM/PM (e.g., `"9:00 AM"`).
+ */ var DATE_TIME_STRING_FORMAT = 'h:mm a';
+/**
+ * @deprecated Use DATE_TIME_STRING_FORMAT instead.
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+var dateTimeStringFormat = DATE_TIME_STRING_FORMAT;
 /**
  * Formats a Date as a 12-hour time string with AM/PM (e.g., `"9:00 AM"`).
  *
  * @param date - date to format
+ * @returns the formatted 12-hour time string with AM/PM
  *
  * @example
  * ```ts
@@ -3094,12 +3347,18 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  */ function formatToTimeString(date) {
     return format$1(date, DATE_TIME_STRING_FORMAT);
 }
-/** Combined date-fns format string for `MM/dd/yyyy h:mm a` (e.g., `"01/15/2024 9:00 AM"`). */ var DATE_SHORT_DATE_AND_TIME_STRING_FORMAT = "".concat(MONTH_DAY_SLASH_DATE_STRING_FORMAT, " ").concat(DATE_TIME_STRING_FORMAT);
-/** @deprecated use DATE_SHORT_DATE_AND_TIME_STRING_FORMAT instead. */ var dateShortDateAndTimeStringFormat = DATE_SHORT_DATE_AND_TIME_STRING_FORMAT;
+/**
+ * Combined date-fns format string for `MM/dd/yyyy h:mm a` (e.g., `"01/15/2024 9:00 AM"`).
+ */ var DATE_SHORT_DATE_AND_TIME_STRING_FORMAT = "".concat(MONTH_DAY_SLASH_DATE_STRING_FORMAT, " ").concat(DATE_TIME_STRING_FORMAT);
+/**
+ * @deprecated Use DATE_SHORT_DATE_AND_TIME_STRING_FORMAT instead.
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+var dateShortDateAndTimeStringFormat = DATE_SHORT_DATE_AND_TIME_STRING_FORMAT;
 /**
  * Formats a Date as a short date and time string (e.g., `"01/15/2024 9:00 AM"`).
  *
  * @param date - date to format
+ * @returns the formatted short date and time string
  *
  * @example
  * ```ts
@@ -3117,6 +3376,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  *
  * @param start - start date/time
  * @param end - end date/time
+ * @returns the formatted time string with an appended duration indicator
  *
  * @example
  * ```ts
@@ -3138,7 +3398,8 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
             includeSeconds: false
         }), ")");
     } else {
-        subtitle = "".concat(minutes ? "(".concat(minutes, " Minutes)") : '');
+        var minutesLabel = minutes ? "(".concat(minutes, " Minutes)") : '';
+        subtitle = minutesLabel;
     }
     return "".concat(formatToTimeString(start), " ").concat(subtitle);
 }
@@ -3161,6 +3422,11 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * formatStartedEndedDistanceString(activeRange);
  * // "started about 1 hour ago"
  * ```
+ *
+ * @param dateRange - date range with start and end dates
+ * @param dateRange.start - the start date of the range
+ * @param dateRange.end - the end date of the range
+ * @returns the relative-time label describing the date range state
  */ function formatStartedEndedDistanceString(param) {
     var start = param.start, end = param.end;
     var state = dateRangeRelativeState({
@@ -3192,6 +3458,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * Useful for converting heterogeneous date inputs into a consistent midnight-aligned Date.
  *
  * @param input - date or day string to normalize
+ * @returns a Date set to midnight of the corresponding day in the system timezone
  *
  * @example
  * ```ts
@@ -3211,6 +3478,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
  * in the system timezone. Supports year formats with more than 4 digits but does not support negative years.
  *
  * @param dayString - ISO 8601 day or date string to parse
+ * @returns a Date at the start of the parsed day in the system timezone
  *
  * @example
  * ```ts
@@ -3427,6 +3695,11 @@ function _type_of$5(obj) {
  * The end date is used just to determine the number of days, but a minimum of 1 day is always enforced as a DateCellTiming must contain atleast 1 day.
  *
  * The start date from the inputDate is considered to to have the offset noted in DateCell, and will be retained.
+ *
+ * @param durationInput - the duration span containing the startsAt time and event duration in minutes
+ * @param rangeInput - specifies the date range: a number of days, a DateRange, or a DateRangeDayDistanceInput
+ * @param timezoneInput - optional timezone configuration; defaults to the system timezone if omitted
+ * @returns a fully computed FullDateCellTiming with start, startsAt, end, duration, and timezone
  */ function dateCellTiming(durationInput, rangeInput, timezoneInput) {
     var duration = durationInput.duration;
     if (duration > MINUTES_IN_DAY) {
@@ -3481,7 +3754,12 @@ function _type_of$5(obj) {
     var utcDay = formatToISO8601DayStringForUTC(startsAtInUtc);
     var start = normalInstance.startOfDayInTargetTimezone(utcDay);
     var safeMirror = isEqualDate(startsAtInUtc, startsAtInUtcInitial);
-    var _normalInstance_safeMirroredConvertDate = normalInstance.safeMirroredConvertDate(startsAtInUtc, inputStartsAt, 'target', safeMirror), startsAt = _normalInstance_safeMirroredConvertDate.date, daylightSavingsOffset = _normalInstance_safeMirroredConvertDate.daylightSavingsOffset;
+    var _normalInstance_safeMirroredConvertDate = normalInstance.safeMirroredConvertDate({
+        baseDate: startsAtInUtc,
+        originalContextDate: inputStartsAt,
+        contextType: 'target',
+        safeConvert: safeMirror
+    }), startsAt = _normalInstance_safeMirroredConvertDate.date, daylightSavingsOffset = _normalInstance_safeMirroredConvertDate.daylightSavingsOffset;
     // calculate end to be the ending date/time of the final duration span
     var lastStartsAtInBaseTimezone = addHours(startsAtInUtc, numberOfDayBlocks * 24 + daylightSavingsOffset); // use addHours instead of addDays, since addDays will take into account a daylight savings change if the system time changes
     var lastStartInTarget = normalInstance.targetDateToBaseDate(lastStartsAtInBaseTimezone);
@@ -3741,8 +4019,16 @@ function _calculateExpectedDateCellTimingDurationPair(timing) {
     var normalInstance = dateTimezoneUtcNormal(timezone);
     var startsAtInUtcNormal = normalInstance.baseDateToTargetDate(startsAt); // convert to UTC normal
     var endInUtcNormal = normalInstance.baseDateToTargetDate(end);
-    var _normalInstance_safeMirroredConvertDate = normalInstance.safeMirroredConvertDate(startsAtInUtcNormal, startsAt, 'target'), startDaylightSavingsOffset = _normalInstance_safeMirroredConvertDate.daylightSavingsOffset;
-    var _normalInstance_safeMirroredConvertDate1 = normalInstance.safeMirroredConvertDate(endInUtcNormal, end, 'target'), endDaylightSavingsOffset = _normalInstance_safeMirroredConvertDate1.daylightSavingsOffset;
+    var _normalInstance_safeMirroredConvertDate = normalInstance.safeMirroredConvertDate({
+        baseDate: startsAtInUtcNormal,
+        originalContextDate: startsAt,
+        contextType: 'target'
+    }), startDaylightSavingsOffset = _normalInstance_safeMirroredConvertDate.daylightSavingsOffset;
+    var _normalInstance_safeMirroredConvertDate1 = normalInstance.safeMirroredConvertDate({
+        baseDate: endInUtcNormal,
+        originalContextDate: end,
+        contextType: 'target'
+    }), endDaylightSavingsOffset = _normalInstance_safeMirroredConvertDate1.daylightSavingsOffset;
     if (startDaylightSavingsOffset) {
         startsAtInUtcNormal = addHours(startsAtInUtcNormal, startDaylightSavingsOffset);
     }
@@ -3828,7 +4114,7 @@ function _calculateExpectedDateCellTimingDurationPair(timing) {
         isExpectedValidEnd = expectedDuration === duration; // should be the expected duration
         isValid = isExpectedValidEnd;
     }
-    var result = {
+    return {
         isValid: isValid,
         endIsAfterTheStartsAtTime: endIsAfterTheStartsAtTime,
         durationGreaterThanZero: durationGreaterThanZero,
@@ -3837,7 +4123,6 @@ function _calculateExpectedDateCellTimingDurationPair(timing) {
         isExpectedValidEnd: isExpectedValidEnd,
         normalInstance: normalInstance
     };
-    return result;
 }
 /**
  * Returns true if the {@link DateCellTiming} passes all validation checks.
@@ -3902,13 +4187,13 @@ function _calculateExpectedDateCellTimingDurationPair(timing) {
     return isValid;
 }
 
-function _array_like_to_array$5(arr, len) {
+function _array_like_to_array$6(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes$2(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
+function _array_without_holes$4(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$6(arr);
 }
 function _define_property$c(obj, key, value) {
     if (key in obj) {
@@ -3923,10 +4208,10 @@ function _define_property$c(obj, key, value) {
     }
     return obj;
 }
-function _iterable_to_array$2(iter) {
+function _iterable_to_array$4(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread$2() {
+function _non_iterable_spread$4() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 function _object_spread$a(target) {
@@ -3963,20 +4248,20 @@ function _object_spread_props$8(target, source) {
     }
     return target;
 }
-function _to_consumable_array$2(arr) {
-    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$2();
+function _to_consumable_array$4(arr) {
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$6(arr) || _non_iterable_spread$4();
 }
 function _type_of$4(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$5(o, minLen) {
+function _unsupported_iterable_to_array$6(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$6(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$6(o, minLen);
 }
 /**
  * Returns true if the input is a DateCellRange.
@@ -3984,6 +4269,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Does not check validity. Use {@link isValidDateCellRange} for that.
  *
  * @param input - value to check
+ * @returns true if the input is a DateCellRange
  */ function isDateCellRange(input) {
     return (typeof input === "undefined" ? "undefined" : _type_of$4(input)) === 'object' ? Number.isInteger(input.i) && input.to === undefined || Number.isInteger(input.to) : false;
 }
@@ -3994,6 +4280,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * that is greater than or equal to `i`.
  *
  * @param input - range to validate
+ * @returns true if the range has valid non-negative indexes and `to` (when defined) is greater than or equal to `i`
  */ function isValidDateCellRange(input) {
     var i = input.i, to = input.to;
     if (!isValidDateCellIndex(i)) {
@@ -4009,6 +4296,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Validates that each range is individually valid and that no ranges overlap or appear out of order.
  *
  * @param input - array of ranges to validate as a non-overlapping ascending series
+ * @returns true if the array is sorted in ascending order with no overlapping or duplicate indexes
  */ function isValidDateCellRangeSeries(input) {
     if (!Array.isArray(input)) {
         return false;
@@ -4020,13 +4308,30 @@ function _unsupported_iterable_to_array$5(o, minLen) {
         return false;
     }
     var greatestIndex = -1;
-    for(var i = 0; i < input.length; i += 1){
-        var range = input[i];
-        if (range.i <= greatestIndex) {
-            return false;
-        } else {
-            var nextGreatestIndex = range.to || range.i; // to is greater than or equal to i in a valid date block range.
-            greatestIndex = nextGreatestIndex;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var range = _step.value;
+            if (range.i <= greatestIndex) {
+                return false;
+            } else {
+                var _range_to;
+                var nextGreatestIndex = (_range_to = range.to) !== null && _range_to !== void 0 ? _range_to : range.i; // to is greater than or equal to i in a valid date block range.
+                greatestIndex = nextGreatestIndex;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
     }
     return true;
@@ -4037,6 +4342,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * The input range is not expected to be sorted.
  *
  * @param input - unsorted array of date cell ranges to scan
+ * @returns the smallest starting index found, or 0 if the input is empty
  */ function getLeastDateCellIndexInDateCellRanges(input) {
     var _ref;
     var _getLeastAndGreatestDateCellIndexInDateCellRanges;
@@ -4048,6 +4354,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * The input range is not expected to be sorted.
  *
  * @param input - unsorted array of date cell ranges to scan
+ * @returns the largest ending index found, or 0 if the input is empty
  */ function getGreatestDateCellIndexInDateCellRanges(input) {
     var _ref;
     var _getLeastAndGreatestDateCellIndexInDateCellRanges;
@@ -4059,6 +4366,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * The input range is not expected to be sorted.
  *
  * @param input - unsorted array of date cell ranges to scan
+ * @returns an object with the least and greatest indexes and their source items, or null if the input is empty
  */ function getLeastAndGreatestDateCellIndexInDateCellRanges(input) {
     if (!input.length) {
         return null;
@@ -4067,17 +4375,34 @@ function _unsupported_iterable_to_array$5(o, minLen) {
     var greatestIndex = 0;
     var leastIndexItem = input[0];
     var greatestIndexItem = input[0];
-    for(var i = 0; i < input.length; i += 1){
-        var range = input[i];
-        var leastRangeIndex = range.i;
-        var greatestRangeIndex = range.to || range.i;
-        if (leastRangeIndex < leastIndex) {
-            leastIndex = leastRangeIndex;
-            leastIndexItem = range;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var range = _step.value;
+            var _range_to;
+            var leastRangeIndex = range.i;
+            var greatestRangeIndex = (_range_to = range.to) !== null && _range_to !== void 0 ? _range_to : range.i;
+            if (leastRangeIndex < leastIndex) {
+                leastIndex = leastRangeIndex;
+                leastIndexItem = range;
+            }
+            if (greatestRangeIndex > greatestIndex) {
+                greatestIndex = greatestRangeIndex;
+                greatestIndexItem = range;
+            }
         }
-        if (greatestRangeIndex > greatestIndex) {
-            greatestIndex = greatestRangeIndex;
-            greatestIndexItem = range;
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
     }
     return {
@@ -4093,6 +4418,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  *
  * @param i - starting cell index
  * @param to - ending cell index (inclusive); defaults to `i`
+ * @returns a DateCellRangeWithRange spanning from `i` to `to`
  */ function dateCellRange(i, to) {
     return {
         i: i,
@@ -4103,6 +4429,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Creates a single-cell {@link DateCellRangeWithRange} where both `i` and `to` equal the given index.
  *
  * @param dateCellIndex - the index for both start and end of the range
+ * @returns a DateCellRangeWithRange where `i` and `to` both equal the given index
  */ function dateCellRangeWithRangeFromIndex(dateCellIndex) {
     return dateCellRange(dateCellIndex, dateCellIndex);
 }
@@ -4111,6 +4438,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * ensuring the result always has an explicit `to` value.
  *
  * @param input - index, cell, or range to normalize
+ * @returns a DateCellRangeWithRange with an explicit `to` value
  */ function dateCellRangeWithRange(input) {
     if (typeof input === 'number') {
         return dateCellRangeWithRangeFromIndex(input);
@@ -4123,12 +4451,12 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * fully contains the configured `inputRange`.
  *
  * @param inputRange - the range that must be fully included
+ * @returns a function that returns true when its argument fully contains `inputRange`
  */ function dateCellRangeIncludedByRangeFunction(inputRange) {
     var _dateCellRangeWithRange = dateCellRangeWithRange(inputRange), i = _dateCellRangeWithRange.i, to = _dateCellRangeWithRange.to;
     return function(input) {
-        var _ref;
         var range = dateCellRangeWithRange(input);
-        return range.i <= i && ((_ref = range === null || range === void 0 ? void 0 : range.to) !== null && _ref !== void 0 ? _ref : range.i) >= to;
+        return range.i <= i && range.to >= to;
     };
 }
 /**
@@ -4136,12 +4464,12 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * has any overlap with the configured `inputRange`.
  *
  * @param inputRange - the range to test for overlap against
+ * @returns a function that returns true when its argument overlaps with `inputRange`
  */ function dateCellRangeOverlapsRangeFunction(inputRange) {
     var _dateCellRangeWithRange = dateCellRangeWithRange(inputRange), i = _dateCellRangeWithRange.i, to = _dateCellRangeWithRange.to;
     return function(input) {
-        var _ref;
         var range = dateCellRangeWithRange(input);
-        return range.i <= to && ((_ref = range === null || range === void 0 ? void 0 : range.to) !== null && _ref !== void 0 ? _ref : range.i) >= i;
+        return range.i <= to && range.to >= i;
     };
 }
 /**
@@ -4149,6 +4477,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  *
  * @param rangeA - first range to compare
  * @param rangeB - second range to compare
+ * @returns true if the two ranges share at least one common index
  */ function dateCellRangeOverlapsRange(rangeA, rangeB) {
     return dateCellRangeOverlapsRangeFunction(rangeA)(rangeB);
 }
@@ -4156,6 +4485,8 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Returns a sort comparator that orders ranges first by starting index (`i`), then by ending index (`to`).
  *
  * In many cases {@link sortAscendingIndexNumberRefFunction} may be preferential when `to` ordering is not needed.
+ *
+ * @returns a comparator function that sorts ranges by `i` then by `to`
  */ function sortDateCellRangeAndSizeFunction() {
     return function(a, b) {
         var _a_to, _b_to;
@@ -4166,6 +4497,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Sorts the input date ranges in-place by ascending index using {@link sortAscendingIndexNumberRefFunction}.
  *
  * @param input - array of ranges to sort (mutated in place)
+ * @returns the same array, sorted in ascending index order
  */ function sortDateCellRanges(input) {
     return input.sort(sortAscendingIndexNumberRefFunction());
 }
@@ -4176,6 +4508,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * The input is sorted internally before grouping.
  *
  * @param input - cells or ranges to merge into contiguous groups
+ * @returns an array of non-overlapping contiguous DateCellRangeWithRange values
  *
  * @example
  * ```ts
@@ -4223,6 +4556,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Returns an array containing every individual index in the given date cell range (inclusive of both `i` and `to`).
  *
  * @param input - range to expand into individual indexes
+ * @returns an array of every DateCellIndex from `i` to `to` inclusive
  */ function allIndexesInDateCellRange(input) {
     return input.to != null ? range(input.i, input.to + 1) : [
         input.i
@@ -4232,6 +4566,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Flattens an array of indexes and/or ranges into a single array of individual {@link DateCellIndex} values.
  *
  * @param input - mix of raw indexes and ranges to flatten
+ * @returns a flat array of all individual DateCellIndex values
  */ function allIndexesInDateCellRangesToArray(input) {
     var result = [];
     input.forEach(function(x) {
@@ -4248,6 +4583,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Returns a deduplicated {@link Set} of all indexes within the input ranges.
  *
  * @param input - mix of raw indexes and ranges to collect
+ * @returns a Set containing every unique DateCellIndex from the input
  */ function allIndexesInDateCellRanges(input) {
     return new Set(allIndexesInDateCellRangesToArray(input));
 }
@@ -4256,6 +4592,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  *
  * @param blocks - cells or ranges to filter
  * @param range - bounding range that blocks must fall within
+ * @returns only the blocks that fall entirely within the given range
  */ function filterDateCellsInDateCellRange(blocks, range) {
     var dateCellIsWithinDateCellRange = isDateCellWithinDateCellRangeFunction(range);
     return blocks.filter(dateCellIsWithinDateCellRange);
@@ -4265,6 +4602,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * is fully contained within `inputRange`.
  *
  * @param inputRange - the bounding range to test containment against
+ * @returns a function that returns true when its argument is fully contained within `inputRange`
  */ function isDateCellWithinDateCellRangeFunction(inputRange) {
     var range = dateCellRangeWithRange(inputRange);
     return function(input) {
@@ -4286,6 +4624,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  *
  * @param range - the outer bounding range
  * @param contains - the cell or range to test for containment
+ * @returns true if `contains` is fully within `range`
  */ function isDateCellWithinDateCellRange(range, contains) {
     return isDateCellWithinDateCellRangeFunction(range)(dateCellRangeWithRange(contains));
 }
@@ -4295,6 +4634,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Internally groups overlapping ranges before counting so each index is counted only once.
  *
  * @param inputDateCellRange - one or more cells/ranges to analyze
+ * @returns count, total, and average statistics for the given ranges
  */ function dateCellRangeBlocksCountInfo(inputDateCellRange) {
     var group = groupToDateCellRanges(asArray(inputDateCellRange));
     var count = 0;
@@ -4317,6 +4657,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Shorthand for `dateCellRangeBlocksCountInfo(input).count`.
  *
  * @param inputDateCellRange - one or more cells/ranges to count
+ * @returns the total number of individual cell indexes
  *
  * @example
  * ```ts
@@ -4331,13 +4672,14 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * grouped range from `ranges` fully covers a given input range.
  *
  * @param ranges - the covering ranges to test against
+ * @returns a function that returns true when any single grouped range fully covers the input range
  */ function dateCellRangesFullyCoverDateCellRangeFunction(ranges) {
     var groupedRanges = Array.isArray(ranges) ? groupToDateCellRanges(ranges) : [
         dateCellRangeWithRange(ranges)
     ];
     return function(inputRange) {
         var fn = dateCellRangeIncludedByRangeFunction(inputRange);
-        return groupedRanges.findIndex(fn) !== -1;
+        return groupedRanges.some(fn);
     };
 }
 /**
@@ -4348,6 +4690,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * nearest future range's starting index is used.
  *
  * @param input - the current index and ranges to evaluate
+ * @returns classification of ranges as past/present/future and the next upcoming index
  *
  * @example
  * ```ts
@@ -4404,6 +4747,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  *
  * @param range - the date cell range to classify
  * @param nowIndex - the reference index representing "now"
+ * @returns 'past', 'present', or 'future' depending on the range's position relative to `nowIndex`
  */ function dateRelativeStateForDateCellRangeComparedToIndex(range, nowIndex) {
     var _dateCellRange = dateCellRange(range.i, range.to), i = _dateCellRange.i, to = _dateCellRange.to;
     var state;
@@ -4421,6 +4765,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * from `i` to `to` (inclusive). Each copy retains all properties of the original block.
  *
  * @param block - the range to expand
+ * @returns an array of single-cell copies, one per index from `i` to `to`
  *
  * @example
  * ```ts
@@ -4439,6 +4784,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Returns true if the input spans more than one cell (i.e., has a `to` value strictly greater than `i`).
  *
  * @param input - range or cell to check
+ * @returns true if `to` is defined and strictly greater than `i`
  */ function dateCellRangeHasRange(input) {
     return input.to != null && input.to > input.i;
 }
@@ -4446,6 +4792,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * Returns the effective ending index of a range: `to` if defined, otherwise `i`.
  *
  * @param input - range or cell to read
+ * @returns the `to` index if defined, otherwise `i`
  */ function dateCellEndIndex(input) {
     var _input_to;
     return (_input_to = input.to) !== null && _input_to !== void 0 ? _input_to : input.i;
@@ -4456,8 +4803,9 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * and `to` is the maximum ending index across all blocks.
  *
  * @param input - cells or ranges to group
+ * @returns a UniqueDateCellRangeGroup containing the sorted blocks with `i` at 0
  */ function groupUniqueDateCells(input) {
-    var blocks = sortDateCellRanges(_to_consumable_array$2(input));
+    var blocks = sortDateCellRanges(_to_consumable_array$4(input));
     var i = 0;
     var to;
     if (blocks.length === 0) {
@@ -4478,6 +4826,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  * according to the provided configuration. Handles overlap resolution, gap filling, and boundary clamping.
  *
  * @param config - controls start/end bounds, fill strategy, and overlap retention behavior
+ * @returns a function that merges, fills, and resolves overlaps in date cell range arrays
  *
  * @example
  * ```ts
@@ -4495,9 +4844,10 @@ function _unsupported_iterable_to_array$5(o, minLen) {
     var retainOnOverlap = inputRetainOnOverlap !== null && inputRetainOnOverlap !== void 0 ? inputRetainOnOverlap : 'next';
     var maxAllowedIndex = endAtIndex !== null && endAtIndex !== void 0 ? endAtIndex : Number.MAX_SAFE_INTEGER;
     var fillFactory = inputFillFactory;
-    if (!fillFactory && fill === 'fill') {
+    if (!inputFillFactory && fill === 'fill') {
         throw new Error('fillFactory is required when fillOption is "fill".');
     }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
     return function(input, newBlocks) {
         var addBlockWithRange = function addBlockWithRange(inputBlock, i) {
             var inputTo = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : i;
@@ -4535,7 +4885,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
                     to: to
                 };
                 var block = fillFactory(dateCellRange);
-                addBlockWithRange(block, i, to !== null && to !== void 0 ? to : i);
+                addBlockWithRange(block, i, to);
             } else if (fill === 'empty') ; else if (blocks.length > 0) {
                 // only extend if one or more blocks have been pushed
                 var blockToExtend = lastValue(blocks);
@@ -4556,6 +4906,8 @@ function _unsupported_iterable_to_array$5(o, minLen) {
         };
         var shouldRetainCurrentOverNext = /**
          * Used to determine how to handle two neighboring objects.
+         *
+         * @returns true if the current block should be retained over the next block
          */ function shouldRetainCurrentOverNext() {
             if (current.priority === next.priority) {
                 return retainOnOverlap === 'current';
@@ -4726,12 +5078,11 @@ function _unsupported_iterable_to_array$5(o, minLen) {
         } else if (fill === 'fill') {
             completeBlocks();
         }
-        var result = {
+        return {
             i: 0,
             blocks: blocks,
             discarded: discarded
         };
-        return result;
     };
 }
 
@@ -4794,6 +5145,9 @@ function _type_of$3(obj) {
  * When `limitToCompletedIndexes` is true, only indexes whose timing duration has fully elapsed are included,
  * with the max boundary lazily refreshed as time passes.
  *
+ * @param config - Configuration specifying the timing, range fit, and completion constraints.
+ * @returns A factory function that produces a clamped {@link DateCellRangeWithRange} from optional start/end input.
+ *
  * @example
  * ```ts
  * const timing = dateCellTiming({ startsAt, duration: 60 }, 5);
@@ -4869,6 +5223,10 @@ function _type_of$3(obj) {
  * Computes a {@link DateCellRangeWithRange} from a timing and optional start/end input.
  *
  * Shorthand for creating a {@link dateCellRangeOfTimingFactory} and immediately invoking it.
+ *
+ * @param config - A {@link DateCellTiming} or full factory configuration.
+ * @param input - Optional start/end boundaries for the range.
+ * @returns A clamped {@link DateCellRangeWithRange} derived from the timing and input.
  */ function dateCellRangeOfTiming(config, input) {
     return dateCellRangeOfTimingFactory(isDateCellTiming(config) ? {
         timing: config
@@ -4879,6 +5237,10 @@ function _type_of$3(obj) {
  * of the timing schedule. Useful for determining which days have already finished.
  *
  * By default fitToTimingRange is true.
+ *
+ * @param timing - The timing schedule to evaluate.
+ * @param config - Optional configuration for the current time reference and range fitting.
+ * @returns A {@link DateCellRangeWithRange} covering only the completed day indexes.
  */ function dateCellTimingCompletedTimeRange(timing, config) {
     var _ref;
     return dateCellRangeOfTiming({
@@ -4892,6 +5254,10 @@ function _type_of$3(obj) {
  * Returns the latest completed day index for a {@link DateCellTiming}.
  *
  * Returns -1 if no days have been completed yet.
+ *
+ * @param timing - The timing schedule to evaluate.
+ * @param now - Optional reference time; defaults to the current time.
+ * @returns The zero-based index of the last fully completed day, or -1 if none.
  */ function dateCellTimingLatestCompletedIndex(timing, now) {
     return dateCellTimingCompletedTimeRange(timing, {
         now: now
@@ -4899,6 +5265,9 @@ function _type_of$3(obj) {
 }
 /**
  * Converts a {@link DateCellRange} (inclusive `to`) to a {@link DateCellIndexRange} (exclusive `maxIndex`).
+ *
+ * @param range - The inclusive date cell range to convert.
+ * @returns A {@link DateCellIndexRange} with exclusive `maxIndex`.
  */ function dateCellRangeToDateCellIndexRange(range) {
     var _range_to;
     return {
@@ -4908,6 +5277,9 @@ function _type_of$3(obj) {
 }
 /**
  * Converts a {@link DateCellIndexRange} (exclusive `maxIndex`) back to a {@link DateCellRangeWithRange} (inclusive `to`).
+ *
+ * @param range - The exclusive date cell index range to convert.
+ * @returns A {@link DateCellRangeWithRange} with inclusive `to`.
  */ function dateCellIndexRangeToDateCellRange(range) {
     return {
         i: range.minIndex,
@@ -4919,6 +5291,11 @@ function _type_of$3(obj) {
  *
  * An arbitrary limit can also be applied. When `fitToTimingRange` is true (default),
  * the limit is intersected with the timing's own range; otherwise the limit is used as-is.
+ *
+ * @param timing - The timing schedule to derive the range from.
+ * @param limit - Optional range input to constrain the output.
+ * @param fitToTimingRange - Whether to intersect the limit with the timing's own range. Defaults to true.
+ * @returns A {@link DateCellIndexRange} representing the computed index bounds.
  */ function dateCellIndexRange(timing, limit) {
     var fitToTimingRange = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
     var indexFactory = dateCellTimingRelativeIndexFactory(timing);
@@ -4947,6 +5324,9 @@ function _type_of$3(obj) {
  * by combining its timing and blocks.
  *
  * Shorthand for calling {@link expandDateCellTiming} with `collection.timing` and `collection.blocks`.
+ *
+ * @param collection - The date cell collection containing timing and blocks to expand.
+ * @returns An array of {@link DateCellDurationSpan} values with concrete start times and durations.
  */ function expandDateCellCollection(collection) {
     return expandDateCellTiming(collection.timing, collection.blocks);
 }
@@ -4954,6 +5334,10 @@ function _type_of$3(obj) {
  * Expands the given blocks into {@link DateCellDurationSpan} values using the provided timing.
  *
  * Shorthand for creating a {@link dateCellTimingExpansionFactory} and immediately invoking it.
+ *
+ * @param timing - The timing schedule providing start times and duration.
+ * @param blocks - The date cell blocks to expand into duration spans.
+ * @returns An array of {@link DateCellDurationSpan} values with concrete start times.
  */ function expandDateCellTiming(timing, blocks) {
     return dateCellTimingExpansionFactory({
         timing: timing
@@ -4967,6 +5351,9 @@ function _type_of$3(obj) {
  * Filtering is applied both at the block level and at the computed duration span level,
  * and evaluation can be capped for performance with large datasets.
  *
+ * @param config - Configuration specifying the timing, range limits, filters, and output caps.
+ * @returns A factory function that expands date cell blocks into {@link DateCellDurationSpan} arrays.
+ *
  * @example
  * ```ts
  * const timing = dateCellTiming({ startsAt, duration: 60 }, 5);
@@ -5064,6 +5451,9 @@ function _type_of$3(obj) {
  * const dateInfo = infoFactory(someDate);
  * console.log(dateInfo.dayIndex);    // which day index this date falls on
  * ```
+ *
+ * @param config - Configuration providing the timing and optional range limit.
+ * @returns A factory that computes {@link DateCellDayTimingInfo} for any date or day index.
  */ function dateCellDayTimingInfoFactory(config) {
     var timing = config.timing, rangeLimit = config.rangeLimit;
     var duration = timing.duration;
@@ -5128,8 +5518,11 @@ function _type_of$3(obj) {
  * Type guard that returns true if the input is a {@link DateCellTimingRelativeIndexFactory}.
  *
  * Checks for the presence of `_timing` and `_normalInstance` properties on a function.
+ *
+ * @param input - The value to check.
+ * @returns True if the input is a {@link DateCellTimingRelativeIndexFactory}.
  */ function isDateCellTimingRelativeIndexFactory(input) {
-    return typeof input === 'function' && input._timing != null && input._normalInstance != null;
+    return typeof input === 'function' && '_timing' in input && '_normalInstance' in input;
 }
 /**
  * Creates a {@link DateCellTimingRelativeIndexFactory} that converts dates, ISO8601 day strings,
@@ -5157,6 +5550,9 @@ function _type_of$3(obj) {
  * indexFactory._timing;         // the original timing
  * indexFactory._normalInstance;  // timezone normalizer
  * ```
+ *
+ * @param input - A timing configuration or an existing factory (returned as-is).
+ * @returns A factory that converts dates, ISO8601 day strings, or indexes to zero-based day offsets.
  */ function dateCellTimingRelativeIndexFactory(input) {
     if (isDateCellTimingRelativeIndexFactory(input)) {
         return input;
@@ -5195,6 +5591,9 @@ function _type_of$3(obj) {
  * dates, date ranges, and cell ranges into a flat array of day indexes.
  *
  * Date ranges and cell ranges are expanded to include every index within the range.
+ *
+ * @param indexFactory - The relative index factory used for date-to-index conversion.
+ * @returns A factory that flattens mixed date/range arrays into day index arrays.
  */ function dateCellTimingRelativeIndexArrayFactory(indexFactory) {
     var factory = function factory(input) {
         var inputAsArray = asArray(input);
@@ -5236,6 +5635,10 @@ function _type_of$3(obj) {
  * // Get the index for a specific date
  * const index = getRelativeIndexForDateCellTiming(timing, someDate);
  * ```
+ *
+ * @param timing - The timing providing the start date and timezone context.
+ * @param date - A date or index to convert; defaults to the current date/time.
+ * @returns The zero-based day index relative to the timing's start.
  */ function getRelativeIndexForDateCellTiming(timing) {
     var date = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : new Date();
     return dateCellTimingRelativeIndexFactory(timing)(date);
@@ -5262,6 +5665,9 @@ function _type_of$3(obj) {
  * // Convert index 3 to a date with a specific reference time
  * const dateForDay3AtNoon = dateFactory(3, noonDate);
  * ```
+ *
+ * @param timing - The timing providing the start date and timezone context.
+ * @returns A factory that maps day indexes to calendar dates preserving the current time-of-day.
  */ function dateCellTimingDateFactory(timing) {
     var _dateCellTimingStartPair = dateCellTimingStartPair(timing), start = _dateCellTimingStartPair.start, normalInstance = _dateCellTimingStartPair.normalInstance;
     var utcStartDate = normalInstance.baseDateToTargetDate(start);
@@ -5277,8 +5683,8 @@ function _type_of$3(obj) {
             if (startUtcHours > nowHours) {
                 input += 1;
             }
-            var nowWithDateForIndex = addHours(utcStartDateWithNowTime, input * HOURS_IN_DAY); // add days to apply the correct offset to the target index
-            return nowWithDateForIndex;
+            // add days to apply the correct offset to the target index
+            return addHours(utcStartDateWithNowTime, input * HOURS_IN_DAY);
         }
     };
     factory._timing = timing;
@@ -5295,6 +5701,9 @@ function _type_of$3(obj) {
  * const timing = dateCellTiming({ startsAt, duration: 60 }, 5);
  * const lastIndex = dateCellTimingEndIndex(timing); // 4 (zero-based, 5 days)
  * ```
+ *
+ * @param input - A timing or an existing relative index factory.
+ * @returns The zero-based index of the last day in the schedule.
  */ function dateCellTimingEndIndex(input) {
     var factory = dateCellTimingRelativeIndexFactory(input);
     return factory(factory._timing.end);
@@ -5304,6 +5713,9 @@ function _type_of$3(obj) {
  * for any day index relative to the timing's start.
  *
  * The returned date represents the beginning of the day in the timing's timezone context.
+ *
+ * @param input - A timing or an existing relative index factory.
+ * @returns A factory that maps day indexes to the start-of-day date in the timing's timezone.
  */ function dateCellTimingStartDateFactory(input) {
     var indexFactory = dateCellTimingRelativeIndexFactory(input);
     var _dateCellTimingStartPair = dateCellTimingStartPair(indexFactory._timing), start = _dateCellTimingStartPair.start, normalInstance = _dateCellTimingStartPair.normalInstance;
@@ -5341,6 +5753,10 @@ function dateCellTimingEndDateFactory(input) {
 /**
  * Convenience function that returns the calendar date for a given day index or date
  * relative to the timing. Shorthand for creating a {@link dateCellTimingDateFactory} and invoking it.
+ *
+ * @param timing - The timing providing the start date and timezone context.
+ * @param input - A date or day index to convert.
+ * @returns The calendar date corresponding to the input, preserving current time-of-day.
  */ function getRelativeDateForDateCellTiming(timing, input) {
     return dateCellTimingDateFactory(timing)(input);
 }
@@ -5366,6 +5782,9 @@ function dateCellTimingEndDateFactory(input) {
  * });
  * // result has the same start day and end day, but new time-of-day and 90-minute duration
  * ```
+ *
+ * @param input - Configuration specifying the timing to update, the event source, and which aspects to replace.
+ * @returns A new {@link FullDateCellTiming} with the requested aspects replaced.
  */ function updateDateCellTimingWithDateCellTimingEvent(input) {
     var timing = input.timing, event = input.event, replaceStartDay = input.replaceStartDay, replaceStartsAt = input.replaceStartsAt, startDateDay = input.startDayDate, endOnEvent = input.endOnEvent, replaceDuration = input.replaceDuration;
     var timezone = timing.timezone;
@@ -5382,7 +5801,8 @@ function dateCellTimingEndDateFactory(input) {
             var _dateCellTimingStartPair = dateCellTimingStartPair({
                 startsAt: event.startsAt,
                 timezone: timezone
-            }), eventStartDate = _dateCellTimingStartPair.start, normalInstance = _dateCellTimingStartPair.normalInstance;
+            }), initialEventStartDate = _dateCellTimingStartPair.start, normalInstance = _dateCellTimingStartPair.normalInstance;
+            var eventStartDate = initialEventStartDate;
             if (startDateDay != null) {
                 var startDateFactory = dateCellTimingStartDateFactory(timing);
                 eventStartDate = startDateFactory(startDateDay);
@@ -5446,6 +5866,9 @@ function dateCellTimingEndDateFactory(input) {
  * isInRange(6);        // false - index 6 is outside [2, 5]
  * isInRange(someDate); // converts date to index, then checks containment
  * ```
+ *
+ * @param config - Configuration specifying the reference range and optional timezone context.
+ * @returns A predicate function that checks containment within the configured range.
  */ function isDateWithinDateCellRangeFunction(config) {
     var inputStartsAt = config.startsAt, inputRange = config.range;
     var startsAt = inputStartsAt;
@@ -5466,13 +5889,11 @@ function dateCellTimingEndDateFactory(input) {
     } else {
         rangeInput = inputRange;
     }
-    if (!inputStartsAt) {
-        if (dateRange && isDateInput) {
-            startsAt = {
-                startsAt: inputRange,
-                timezone: guessCurrentTimezone()
-            };
-        }
+    if (!inputStartsAt && dateRange && isDateInput) {
+        startsAt = {
+            startsAt: inputRange,
+            timezone: guessCurrentTimezone()
+        };
     }
     if (!startsAt) {
         throw new Error('Invalid isDateWithinDateCellRangeFunction() config. StartsAt date info could not be determined from input.');
@@ -5625,6 +6046,7 @@ function _object_spread_props$6(target, source) {
  * Useful for identifying events or blocks that have already begun relative to a point in time.
  *
  * @param now - Reference time to compare against. Defaults to the current time.
+ * @returns a filter function that returns true for spans whose start time is at or before the reference time
  *
  * @example
  * ```ts
@@ -5643,6 +6065,7 @@ function _object_spread_props$6(target, source) {
  * The inverse of {@link dateCellDurationSpanHasStartedFilterFunction}. Useful for finding upcoming or future events.
  *
  * @param now - Reference time to compare against. Defaults to the current time.
+ * @returns a filter function that returns true for spans whose start time is strictly after the reference time
  *
  * @example
  * ```ts
@@ -5662,6 +6085,7 @@ function _object_spread_props$6(target, source) {
  * Useful for identifying completed events.
  *
  * @param now - Reference time to compare against. Defaults to the current time.
+ * @returns a filter function that returns true for spans whose computed end time is at or before the reference time
  *
  * @example
  * ```ts
@@ -5682,6 +6106,7 @@ function _object_spread_props$6(target, source) {
  * still in progress or have not yet occurred.
  *
  * @param now - Reference time to compare against. Defaults to the current time.
+ * @returns a filter function that returns true for spans whose computed end time is strictly after the reference time
  *
  * @example
  * ```ts
@@ -5703,6 +6128,7 @@ function _object_spread_props$6(target, source) {
  * indices clamped to the range boundaries. Non-overlapping cells are excluded entirely.
  *
  * @param range - The target range to fit cells into.
+ * @returns a reusable function that clamps or filters date cells to the configured range
  *
  * @example
  * ```ts
@@ -5743,6 +6169,7 @@ function _object_spread_props$6(target, source) {
  *
  * @param range - The target range to fit cells into.
  * @param input - The date cells to clamp or filter.
+ * @returns an array of date cells clamped to the range, with non-overlapping cells removed
  *
  * @example
  * ```ts
@@ -5757,6 +6184,7 @@ function _object_spread_props$6(target, source) {
  *
  * @param range - The target range to fit the cell into.
  * @param input - The single date cell to clamp or exclude.
+ * @returns the clamped date cell, or `undefined` if it does not overlap the range
  *
  * @example
  * ```ts
@@ -5771,7 +6199,7 @@ function _object_spread_props$6(target, source) {
     ])[0];
 }
 
-function _array_like_to_array$4(arr, len) {
+function _array_like_to_array$5(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
@@ -5779,6 +6207,9 @@ function _array_like_to_array$4(arr, len) {
 function _array_with_holes$2(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
+}
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -5786,6 +6217,9 @@ function _instanceof(left, right) {
         return left instanceof right;
     }
 }
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit$2(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -5813,16 +6247,22 @@ function _iterable_to_array_limit$2(arr, i) {
 function _non_iterable_rest$2() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread$3() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _sliced_to_array$2(arr, i) {
-    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$4(arr, i) || _non_iterable_rest$2();
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$5(arr, i) || _non_iterable_rest$2();
 }
-function _unsupported_iterable_to_array$4(o, minLen) {
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$3();
+}
+function _unsupported_iterable_to_array$5(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
 }
 /**
  * Used for default YearWeekCode values
@@ -5928,8 +6368,7 @@ function _unsupported_iterable_to_array$4(o, minLen) {
  * @param input - timezone string, config, or instance
  * @returns the resolved normal instance
  */ function yearWeekCodeDateTimezoneInstance(input) {
-    var normal = input ? _instanceof(input, DateTimezoneUtcNormalInstance) ? input : dateTimezoneUtcNormal(input) : SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE;
-    return normal;
+    return input ? _instanceof(input, DateTimezoneUtcNormalInstance) ? input : dateTimezoneUtcNormal(input) : SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE;
 }
 function yearWeekCode(dateOrYear, inputWeek) {
     return yearWeekCodeFactory({
@@ -5981,6 +6420,7 @@ function yearWeekCode(dateOrYear, inputWeek) {
  *
  * @param dateRange - the range to compute week codes for
  * @param dateRangeTimezone - the timezone context for accurate week boundary calculation
+ * @returns an array of YearWeekCode values covering the range
  */ function yearWeekCodeForDateRangeInTimezone(dateRange, dateRangeTimezone) {
     return yearWeekCodeForDateRangeFactory(yearWeekCodeFactory({
         timezone: dateRangeTimezone
@@ -6013,6 +6453,7 @@ function yearWeekCode(dateOrYear, inputWeek) {
  * Returns all {@link YearWeekCode} values for the calendar month containing the given date, using the system timezone.
  *
  * @param date - a date within the target month
+ * @returns an array of YearWeekCode values for the month
  */ function yearWeekCodeForCalendarMonth(date) {
     return yearWeekCodeForCalendarMonthFactory(yearWeekCodeFactory({
         timezone: SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE
@@ -6056,8 +6497,8 @@ function yearWeekCode(dateOrYear, inputWeek) {
         var utcYearDate = new Date(Date.UTC(pair.year, 0, 1, 0, 0, 0, 0));
         var systemYearDate = normal.systemDateToBaseDate(utcYearDate); // convert to system before using system date functions
         var date = startOfWeek(setWeek(systemYearDate, pair.week));
-        var fixed = normal.targetDateToSystemDate(date); // back to timezone
-        return fixed;
+        // back to timezone
+        return normal.targetDateToSystemDate(date);
     };
 }
 /**
@@ -6111,10 +6552,10 @@ function yearWeekCode(dateOrYear, inputWeek) {
             }
             return yearWeekCode;
         });
-        var groups = Array.from(map.entries()).map(function(param) {
+        var groups = _to_consumable_array$3(map.entries()).map(function(param) {
             var _param = _sliced_to_array$2(param, 2), week = _param[0], _$items = _param[1];
             return {
-                week: week || 0,
+                week: week !== null && week !== void 0 ? week : 0,
                 items: _$items
             };
         });
@@ -6153,8 +6594,7 @@ function yearWeekCode(dateOrYear, inputWeek) {
     var normalInstance = startDateFactory._indexFactory._normalInstance;
     return function(indexOrDate) {
         var dateInSystemTimezone = normalInstance.systemDateToTargetDate(startDateFactory(indexOrDate));
-        var yearWeekCode = yearWeekCodeFromDate(dateInSystemTimezone);
-        return yearWeekCode;
+        return yearWeekCodeFromDate(dateInSystemTimezone);
     };
 }
 /**
@@ -6165,21 +6605,20 @@ function yearWeekCode(dateOrYear, inputWeek) {
  */ function dateCellIndexYearWeekCodeGroupFactory(config) {
     var dateCellIndexReader = config.dateCellIndexReader, inputDateCellIndexYearWeekCodeFactory = config.dateCellIndexYearWeekCodeFactory;
     var dateCellIndexYearWeekCode = typeof inputDateCellIndexYearWeekCodeFactory === 'function' ? inputDateCellIndexYearWeekCodeFactory : dateCellIndexYearWeekCodeFactory(inputDateCellIndexYearWeekCodeFactory);
-    var factory = yearWeekCodeGroupFactory({
+    return yearWeekCodeGroupFactory({
         yearWeekCodeFactory: dateCellIndexYearWeekCode,
         yearWeekCodeReader: dateCellIndexYearWeekCode,
         dateReader: dateCellIndexReader
     });
-    return factory;
 }
 
-function _array_like_to_array$3(arr, len) {
+function _array_like_to_array$4(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes$1(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
 }
 function _define_property$9(obj, key, value) {
     if (key in obj) {
@@ -6194,10 +6633,10 @@ function _define_property$9(obj, key, value) {
     }
     return obj;
 }
-function _iterable_to_array$1(iter) {
+function _iterable_to_array$2(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread$1() {
+function _non_iterable_spread$2() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 function _object_spread$7(target) {
@@ -6234,20 +6673,20 @@ function _object_spread_props$5(target, source) {
     }
     return target;
 }
-function _to_consumable_array$1(arr) {
-    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$1();
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$2();
 }
 function _type_of$2(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$3(o, minLen) {
+function _unsupported_iterable_to_array$4(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
 }
 /**
  * Encodes days of the week as numeric codes for use in schedule filtering.
@@ -6312,7 +6751,7 @@ function _unsupported_iterable_to_array$3(o, minLen) {
  * @param input - schedule day codes to convert (WEEKDAY/WEEKEND shorthand codes are expanded)
  * @returns an EnabledDays object with boolean flags for each day
  */ function enabledDaysFromDateCellScheduleDayCodes(input) {
-    var days = expandDateCellScheduleDayCodesToDayOfWeekSet(Array.from(new Set(input)));
+    var days = expandDateCellScheduleDayCodesToDayOfWeekSet(_to_consumable_array$2(new Set(input)));
     return enabledDaysFromDaysOfWeek(days);
 }
 /**
@@ -6460,7 +6899,7 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  * @param input - day codes to expand
  * @returns sorted array of individual day codes (1-7 only, no shorthand)
  */ function expandDateCellScheduleDayCodes(input) {
-    return Array.from(expandDateCellScheduleDayCodesToDayCodesSet(input)).sort(sortNumbersAscendingFunction);
+    return _to_consumable_array$2(expandDateCellScheduleDayCodesToDayCodesSet(input)).sort(sortNumbersAscendingFunction);
 }
 /**
  * Expands the input DateCellScheduleDayCodesInput to a Set of individual DateCellScheduleDayCode values (1-7), expanding shorthand codes like WEEKDAY and WEEKEND.
@@ -6498,7 +6937,7 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
     var dayCodes;
     switch(typeof input === "undefined" ? "undefined" : _type_of$2(input)){
         case 'string':
-            dayCodes = Array.from(new Set(input)).map(function(x) {
+            dayCodes = _to_consumable_array$2(new Set(input)).map(function(x) {
                 return Number(x);
             });
             break;
@@ -6508,7 +6947,7 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
             ];
             break;
         default:
-            dayCodes = Array.from(input);
+            dayCodes = _to_consumable_array$2(input);
             break;
     }
     return dayCodes.filter(function(x) {
@@ -6617,7 +7056,6 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
     var timezone = inputTimezone !== null && inputTimezone !== void 0 ? inputTimezone : requireCurrentTimezone(); // treat input as the current timezone
     var normalInstance = dateTimezoneUtcNormal(timezone);
     var start;
-    var end;
     // either start or startsAt is provided
     if (inputStart != null) {
         var startInSystemTimezone = normalInstance.systemDateToTargetDate(inputStart); // start needs to be in the system timezone normal before processing.
@@ -6634,7 +7072,7 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
         }
     }
     // set the end value
-    end = inputEnd !== null && inputEnd !== void 0 ? inputEnd : addMinutes(start, 1); // default the end to one minute after the start
+    var end = inputEnd !== null && inputEnd !== void 0 ? inputEnd : addMinutes(start, 1); // default the end to one minute after the start
     return {
         w: w,
         ex: ex,
@@ -6836,11 +7274,12 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  * filter(5);  // false (Saturday Jan 11)
  * ```
  */ function dateCellScheduleDateFilter(config) {
+    var _ref;
     var w = config.w, inputStart = config.start, inputStartsAt = config.startsAt, inputEnd = config.end, inputTimezone = config.timezone, _config_setStartAsMinDate = config.setStartAsMinDate, setStartAsMinDate = _config_setStartAsMinDate === void 0 ? true : _config_setStartAsMinDate, minMaxDateRange = config.minMaxDateRange;
     var timezone = inputTimezone !== null && inputTimezone !== void 0 ? inputTimezone : requireCurrentTimezone(); // if the timezone is not provided, assume the startsAt is a system timezone normal.
     var normalInstance = dateTimezoneUtcNormal(timezone);
     // derive the startsAt time for the range. If not provided, defaults to inputStart, or midnight today in the target timezone.
-    var startsAt = inputStartsAt != null ? inputStartsAt : inputStart !== null && inputStart !== void 0 ? inputStart : normalInstance.startOfDayInTargetTimezone();
+    var startsAt = (_ref = inputStartsAt !== null && inputStartsAt !== void 0 ? inputStartsAt : inputStart) !== null && _ref !== void 0 ? _ref : normalInstance.startOfDayInTargetTimezone();
     var allowedDays = expandDateCellScheduleDayCodesToDayOfWeekSet(w);
     var startsAtInSystem = normalInstance.systemDateToTargetDate(startsAt); // convert to the system date
     var firstDateDay = getDay(startsAtInSystem);
@@ -6866,15 +7305,13 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
     var excludedIndexes = new Set(config.ex);
     var fn = function fn(input) {
         var i;
-        var day;
         if (typeof input === 'number') {
             i = input;
         } else {
             i = _dateCellTimingRelativeIndexFactory(input);
         }
-        day = dayForIndex(i);
-        var result = i >= minAllowedIndex && i <= maxAllowedIndex && allowedDays.has(day) && !excludedIndexes.has(i) || includedIndexes.has(i);
-        return result;
+        var day = dayForIndex(i);
+        return i >= minAllowedIndex && i <= maxAllowedIndex && allowedDays.has(day) && !excludedIndexes.has(i) || includedIndexes.has(i);
     };
     fn._dateCellTimingRelativeIndexFactory = _dateCellTimingRelativeIndexFactory;
     return fn;
@@ -6928,6 +7365,8 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  * Creates a DateCellScheduleDateCellTimingFilter that tests whether a DateCell block's index is allowed by the schedule within the given timing.
  *
  * @param config - timing and schedule to build the filter from
+ * @param config.timing - the DateCellTiming that defines the date range and event times for the filter
+ * @param config.schedule - the DateCellSchedule that controls which day codes and indices are included or excluded
  * @returns a decision function returning true for allowed blocks
  */ function dateCellScheduleDateCellTimingFilter(param) {
     var timing = param.timing, schedule = param.schedule;
@@ -6951,7 +7390,6 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  * @returns an expansion factory that converts DateCellRange arrays into filtered DateCellDurationSpan arrays
  */ function expandDateCellScheduleFactory(config) {
     var _config_invertSchedule = config.invertSchedule, invertSchedule = _config_invertSchedule === void 0 ? false : _config_invertSchedule, now = config.now, onlyBlocksThatHaveEnded = config.onlyBlocksThatHaveEnded, onlyBlocksThatHaveStarted = config.onlyBlocksThatHaveStarted, onlyBlocksNotYetEnded = config.onlyBlocksNotYetEnded, onlyBlocksNotYetStarted = config.onlyBlocksNotYetStarted, maxDateCellsToReturn = config.maxDateCellsToReturn, inputDurationSpanFilter = config.durationSpanFilter;
-    var durationSpanFilter;
     var durationSpanFilters = [];
     if (inputDurationSpanFilter) {
         durationSpanFilters.push(inputDurationSpanFilter);
@@ -6968,14 +7406,13 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
             durationSpanFilters.push(dateCellDurationSpanHasNotEndedFilterFunction(now));
         }
     }
-    durationSpanFilter = mergeFilterFunctions.apply(void 0, _to_consumable_array$1(durationSpanFilters));
-    var expansionFactory = dateCellTimingExpansionFactory({
+    var durationSpanFilter = mergeFilterFunctions.apply(void 0, _to_consumable_array$2(durationSpanFilters));
+    return dateCellTimingExpansionFactory({
         timing: config.timing,
         filter: invertFilter(dateCellScheduleDateCellTimingFilter(config), invertSchedule),
         durationSpanFilter: durationSpanFilter,
         maxDateCellsToReturn: maxDateCellsToReturn
     });
-    return expansionFactory;
 }
 /**
  * Expands a DateCellTiming and DateCellSchedule into concrete DateCellDurationSpan values representing each active block in the event.
@@ -7061,16 +7498,155 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
     });
 }
 
+function _define_property$8(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$6(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$8(target, key, source[key]);
+        });
+    }
+    return target;
+}
+/**
+ * Distinguishes between time-based calendar events and all-day/multi-day events.
+ */ var CalendarDateType;
+(function(CalendarDateType) {
+    /**
+     * Event starts at a specific time and lasts for a certain duration.
+     */ CalendarDateType["TIME"] = "time";
+    /**
+     * Event is specifically for a number of days. Duration is still tracked in minutes.
+     */ CalendarDateType["DAYS"] = "days";
+})(CalendarDateType || (CalendarDateType = {}));
+/**
+ * Creates a {@link CalendarDateFactory} that produces all-day calendar events with timezone-aware start times.
+ *
+ * The factory converts an ISO 8601 day string to a UTC date, then applies timezone normalization
+ * so the resulting `startsAt` represents the correct moment for the target timezone.
+ *
+ * @param config - optional timezone configuration
+ * @returns a factory function that creates CalendarDate objects
+ *
+ * @example
+ * ```ts
+ * const factory = calendarDateFactory({ timezone: 'America/Denver' });
+ * const event = factory('2024-01-15', 3);
+ * // event.type === CalendarDateType.DAYS
+ * // event.duration === daysToMinutes(3)
+ * ```
+ */ function calendarDateFactory(config) {
+    var normalConfig = (config === null || config === void 0 ? void 0 : config.timezone) === undefined ? {
+        useSystemTimezone: true
+    } : {
+        timezone: config.timezone ? config.timezone : undefined
+    };
+    var normal = dateTimezoneUtcNormal(normalConfig);
+    return function(day, days) {
+        var date = parseISO8601DayStringToUTCDate(day);
+        var startsAt = normal.targetDateToBaseDate(date);
+        return {
+            type: CalendarDateType.DAYS,
+            startsAt: startsAt,
+            duration: daysToMinutes(days)
+        };
+    };
+}
+/**
+ * Convenience function that creates a single all-day {@link CalendarDate} with optional timezone.
+ *
+ * Shorthand for creating a factory and immediately invoking it.
+ *
+ * @param day - ISO 8601 day string (e.g. '2024-01-15')
+ * @param days - number of days the event spans
+ * @param timezone - IANA timezone string, false for UTC, or undefined for system timezone
+ * @returns a CalendarDate with type DAYS
+ *
+ * @example
+ * ```ts
+ * const event = calendarDate('2024-01-15', 1, 'America/Denver');
+ * // event.type === CalendarDateType.DAYS
+ * ```
+ */ function calendarDate(day, days, timezone) {
+    return calendarDateFactory({
+        timezone: timezone
+    })(day, days);
+}
+/**
+ * Wraps an existing {@link DateDurationSpan} as a time-based {@link CalendarDate}.
+ *
+ * @param dateDurationSpan - the duration span to wrap
+ * @returns a CalendarDate with type TIME
+ *
+ * @example
+ * ```ts
+ * const span: DateDurationSpan = { startsAt: new Date(), duration: 60 };
+ * const event = calendarDateForDateDurationSpan(span);
+ * // event.type === CalendarDateType.TIME
+ * ```
+ */ function calendarDateForDateDurationSpan(dateDurationSpan) {
+    return _object_spread$6({
+        type: CalendarDateType.TIME
+    }, dateDurationSpan);
+}
+
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
 /**
  * Returns all recognized IANA timezone strings, including the explicit UTC entry.
  *
+ * @returns all known IANA timezone strings plus UTC
+ *
  * @example
  * ```ts
  * const zones = allTimezoneStrings();
  * // ['Africa/Abidjan', ..., 'UTC']
  * ```
  */ function allTimezoneStrings() {
-    return timeZonesNames.concat(UTC_TIMEZONE_STRING);
+    return _to_consumable_array$1(timeZonesNames).concat([
+        UTC_TIMEZONE_STRING
+    ]);
 }
 /**
  * Lazily-computed set of all known timezone strings for O(1) membership checks.
@@ -7096,6 +7672,8 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
 /**
  * Returns the {@link TimezoneInfo} for the current system timezone, falling back to UTC.
  *
+ * @returns timezone info for the current system timezone
+ *
  * @example
  * ```ts
  * const info = timezoneInfoForSystem();
@@ -7111,6 +7689,10 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  * The date matters because abbreviations change with DST transitions.
  * Returns `"UKNOWN"` if no timezone is provided.
  *
+ * @param timezone - the IANA timezone string (or UTC abbreviation) to get the abbreviation for
+ * @param date - the date at which to evaluate the abbreviation (defaults to now)
+ * @returns the short timezone abbreviation
+ *
  * @example
  * ```ts
  * getTimezoneAbbreviation('America/New_York'); // 'EST' or 'EDT'
@@ -7124,6 +7706,10 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  *
  * Returns `"Unknown Timezone"` if no timezone is provided.
  *
+ * @param timezone - the IANA timezone string to get the long name for
+ * @param date - the date at which to evaluate the name (defaults to now)
+ * @returns the full timezone display name
+ *
  * @example
  * ```ts
  * getTimezoneLongName('America/New_York'); // 'Eastern Standard Time'
@@ -7135,6 +7721,10 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
 /**
  * Builds a {@link TimezoneInfo} for the given timezone, computing abbreviation and search variants.
  *
+ * @param timezone - the IANA timezone string to build info for
+ * @param date - the date at which to evaluate the abbreviation (defaults to now)
+ * @returns the computed TimezoneInfo
+ *
  * @example
  * ```ts
  * const info = timezoneStringToTimezoneInfo('America/Chicago');
@@ -7144,14 +7734,13 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  */ function timezoneStringToTimezoneInfo(timezone) {
     var date = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : new Date();
     var abbreviation = getTimezoneAbbreviation(timezone, date);
-    var result = {
+    return {
         timezone: timezone,
         search: timezoneStringToSearchableString(timezone),
         lowercase: timezone.toLowerCase(),
         abbreviation: abbreviation,
         lowercaseAbbreviation: abbreviation.toLowerCase()
     };
-    return result;
 }
 /**
  * Filters timezone infos by a search string, matching against the searchable name,
@@ -7159,6 +7748,10 @@ var DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
  *
  * For queries longer than 2 characters, substring matching on the searchable name is also used.
  *
+ * @param search - the search query string
+ * @param infos - the array of TimezoneInfo objects to filter
+ * @returns the matching TimezoneInfo entries
+ *
  * @example
  * ```ts
  * const results = searchTimezoneInfos('eastern', allTimezoneInfos());
@@ -7181,6 +7774,9 @@ var timezoneStringToSearchableStringReplace = replaceStringsFunction({
  *
  * Replaces `/` and `_` with spaces (e.g., `"America/New_York"` becomes `"america new york"`).
  *
+ * @param timezone - the IANA timezone string to convert
+ * @returns the searchable lowercase string
+ *
  * @example
  * ```ts
  * timezoneStringToSearchableString('America/New_York'); // 'america new york'
@@ -7193,6 +7789,9 @@ var timezoneStringToSearchableStringReplace = replaceStringsFunction({
  *
  * Uses the cached set from {@link allKnownTimezoneStrings} for O(1) lookup.
  *
+ * @param input - the string to check
+ * @returns whether the input is a known timezone
+ *
  * @example
  * ```ts
  * isKnownTimezone('America/New_York'); // true
@@ -7202,116 +7801,6 @@ var timezoneStringToSearchableStringReplace = replaceStringsFunction({
     return allKnownTimezoneStrings().has(input);
 }
 
-function _define_property$8(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread$6(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property$8(target, key, source[key]);
-        });
-    }
-    return target;
-}
-/**
- * Distinguishes between time-based calendar events and all-day/multi-day events.
- */ var CalendarDateType;
-(function(CalendarDateType) {
-    /**
-     * Event starts at a specific time and lasts for a certain duration.
-     */ CalendarDateType["TIME"] = "time";
-    /**
-     * Event is specifically for a number of days. Duration is still tracked in minutes.
-     */ CalendarDateType["DAYS"] = "days";
-})(CalendarDateType || (CalendarDateType = {}));
-/**
- * Creates a {@link CalendarDateFactory} that produces all-day calendar events with timezone-aware start times.
- *
- * The factory converts an ISO 8601 day string to a UTC date, then applies timezone normalization
- * so the resulting `startsAt` represents the correct moment for the target timezone.
- *
- * @param config - optional timezone configuration
- * @returns a factory function that creates CalendarDate objects
- *
- * @example
- * ```ts
- * const factory = calendarDateFactory({ timezone: 'America/Denver' });
- * const event = factory('2024-01-15', 3);
- * // event.type === CalendarDateType.DAYS
- * // event.duration === daysToMinutes(3)
- * ```
- */ function calendarDateFactory(config) {
-    var normalConfig = (config === null || config === void 0 ? void 0 : config.timezone) === undefined ? {
-        useSystemTimezone: true
-    } : {
-        timezone: config.timezone ? config.timezone : undefined
-    };
-    var normal = dateTimezoneUtcNormal(normalConfig);
-    return function(day, days) {
-        var date = parseISO8601DayStringToUTCDate(day);
-        var startsAt = normal.targetDateToBaseDate(date);
-        return {
-            type: CalendarDateType.DAYS,
-            startsAt: startsAt,
-            duration: daysToMinutes(days)
-        };
-    };
-}
-/**
- * Convenience function that creates a single all-day {@link CalendarDate} with optional timezone.
- *
- * Shorthand for creating a factory and immediately invoking it.
- *
- * @param day - ISO 8601 day string (e.g. '2024-01-15')
- * @param days - number of days the event spans
- * @param timezone - IANA timezone string, false for UTC, or undefined for system timezone
- * @returns a CalendarDate with type DAYS
- *
- * @example
- * ```ts
- * const event = calendarDate('2024-01-15', 1, 'America/Denver');
- * // event.type === CalendarDateType.DAYS
- * ```
- */ function calendarDate(day, days, timezone) {
-    return calendarDateFactory({
-        timezone: timezone
-    })(day, days);
-}
-/**
- * Wraps an existing {@link DateDurationSpan} as a time-based {@link CalendarDate}.
- *
- * @param dateDurationSpan - the duration span to wrap
- * @returns a CalendarDate with type TIME
- *
- * @example
- * ```ts
- * const span: DateDurationSpan = { startsAt: new Date(), duration: 60 };
- * const event = calendarDateForDateDurationSpan(span);
- * // event.type === CalendarDateType.TIME
- * ```
- */ function calendarDateForDateDurationSpan(dateDurationSpan) {
-    return _object_spread$6({
-        type: CalendarDateType.TIME
-    }, dateDurationSpan);
-}
-
 function _array_like_to_array$2(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -7351,7 +7840,7 @@ var _type, _type1;
  * const result = knownTimezoneType('America/Denver');
  * ```
  */ var knownTimezoneType = type('string > 0').narrow(function(val, ctx) {
-    return val != null && isKnownTimezone(val) || ctx.mustBe('a known timezone');
+    return isKnownTimezone(val) || ctx.mustBe('a known timezone');
 });
 // MARK: DateDurationSpan
 /**
@@ -7465,21 +7954,21 @@ var _type, _type1;
  * Accepts both Date objects and date strings (parsed via `string.date.parse`), then validates the resulting timing
  * using {@link isValidDateCellTiming}.
  */ var validDateCellTimingType = dateCellTimingType.narrow(function(val, ctx) {
-    return val != null && isValidDateCellTiming(val) || ctx.mustBe('a valid DateCellTiming');
+    return isValidDateCellTiming(val) || ctx.mustBe('a valid DateCellTiming');
 });
 /**
  * ArkType DTO schema that validates a value is a valid {@link DateCellRange} (non-negative indexes, `to >= i`).
  *
  * Validates cell range data from JSON/DTO input.
  */ var validDateCellRangeType = dateCellRangeType.narrow(function(val, ctx) {
-    return val != null && isValidDateCellRange(val) || ctx.mustBe('a valid DateCellRange');
+    return isValidDateCellRange(val) || ctx.mustBe('a valid DateCellRange');
 });
 /**
  * ArkType DTO schema that validates a value is a sorted array of non-overlapping {@link DateCellRange} values.
  *
  * Validates cell range series data from JSON/DTO input.
  */ var validDateCellRangeSeriesType = type(dateCellRangeType.array()).narrow(function(val, ctx) {
-    return val != null && isValidDateCellRangeSeries(val) || ctx.mustBe('a valid DateCellRange series with items sorted in ascending order and no repeat indexes');
+    return isValidDateCellRangeSeries(val) || ctx.mustBe('a valid DateCellRange series with items sorted in ascending order and no repeat indexes');
 });
 
 function _assert_this_initialized$1(self) {
@@ -7759,7 +8248,7 @@ function _object_spread_props$4(target, source) {
         logicalDate = 'now';
     }
     var intervalPeriod = period !== null && period !== void 0 ? period : MS_IN_SECOND;
-    var factory = inputFactory ? inputFactory : protectedFactory(logicalDateStringCodeDateFactory(logicalDate));
+    var factory = inputFactory !== null && inputFactory !== void 0 ? inputFactory : protectedFactory(logicalDateStringCodeDateFactory(logicalDate));
     var obs = interval(intervalPeriod, scheduler).pipe(startWith(-1), map(factory));
     if (emitAll !== true) {
         obs = obs.pipe(distinctUntilChanged(isSameDate));
@@ -7851,7 +8340,8 @@ function _define_property$6(obj, key, value) {
         {
             key: "instant",
             get: function get() {
-                return this._config.instant || 'now';
+                var _this__config_instant;
+                return (_this__config_instant = this._config.instant) !== null && _this__config_instant !== void 0 ? _this__config_instant : 'now';
             }
         },
         {
@@ -7896,10 +8386,8 @@ function _define_property$6(obj, key, value) {
                 var _this__config = this._config, _this__config_instant = _this__config.instant, instant = _this__config_instant === void 0 ? new Date() : _this__config_instant, _this__config_limits = _this__config.limits, limits = _this__config_limits === void 0 ? {} : _this__config_limits;
                 var isPast = limits.isPast, max = limits.max;
                 var limit = max;
-                if (typeof max !== 'string' && isPast) {
-                    if (!max || isBefore$1(max, instant)) {
-                        limit = DATE_NOW_VALUE;
-                    }
+                if (typeof max !== 'string' && isPast && (!max || isBefore$1(max, instant))) {
+                    limit = DATE_NOW_VALUE;
                 }
                 return limit;
             }
@@ -7914,6 +8402,8 @@ function _define_property$6(obj, key, value) {
      * const limiter = new LimitDateTimeInstance({ limits: { isFuture: true } });
      * const range = limiter.dateRange(); // { start: <now>, end: undefined }
      * ```
+     *
+     * @returns A partial {@link DateRange} with `start` and/or `end` derived from the limits.
      */ key: "dateRange",
             value: function dateRange() {
                 var _this__config = this._config, _this__config_instant = _this__config.instant, instant = _this__config_instant === void 0 ? new Date() : _this__config_instant;
@@ -7926,6 +8416,7 @@ function _define_property$6(obj, key, value) {
      * like "now" or relative future offsets to resolve against the given moment.
      *
      * @param instant - The reference point in time for resolving dynamic limits.
+     * @returns A partial {@link DateRange} resolved against the given instant.
      */ key: "dateRangeForInstant",
             value: function dateRangeForInstant(instant) {
                 var _this = this, min = _this.min, max = _this.max;
@@ -7949,6 +8440,8 @@ function _define_property$6(obj, key, value) {
      * });
      * const safe = limiter.clamp(new Date()); // at least 30 minutes from now
      * ```
+     *
+     * @returns The clamped date within the allowed range.
      */ key: "clamp",
             value: function clamp(date) {
                 var result = date;
@@ -7986,6 +8479,8 @@ function _define_property$6(obj, key, value) {
      * const clamped = limiter.clampDateRange({ start: pastDate, end: futureDate });
      * // clamped.start will be at least now
      * ```
+     *
+     * @returns The date range clamped to the allowed limits.
      */ key: "clampDateRange",
             value: function clampDateRange(dateRange) {
                 return clampDateRangeToDateRange(dateRange, this.dateRange());
@@ -8007,6 +8502,8 @@ function _define_property$6(obj, key, value) {
  * });
  * const clamped = limiter.clamp(someDate);
  * ```
+ *
+ * @returns A new {@link LimitDateTimeInstance}.
  */ function limitDateTimeInstance(config) {
     return new LimitDateTimeInstance(config);
 }
@@ -8098,14 +8595,14 @@ function _object_spread_props$3(target, source) {
     function DateTimeMinuteInstance() {
         var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, dateOverride = arguments.length > 1 ? arguments[1] : void 0;
         _class_call_check$5(this, DateTimeMinuteInstance);
-        var _config_step;
+        var _ref, _config_step;
         _define_property$5(this, "_config", void 0);
         _define_property$5(this, "_date", void 0);
         _define_property$5(this, "_step", void 0);
         _define_property$5(this, "_limit", void 0);
         _define_property$5(this, "_dateFilter", void 0);
         this._config = config;
-        this._date = (dateOverride == undefined ? config.date : dateOverride) || new Date();
+        this._date = (_ref = dateOverride !== null && dateOverride !== void 0 ? dateOverride : config.date) !== null && _ref !== void 0 ? _ref : new Date();
         this._step = (_config_step = config.step) !== null && _config_step !== void 0 ? _config_step : 1;
         this._limit = new LimitDateTimeInstance(config);
         this._dateFilter = config.schedule ? dateCellScheduleDateFilter(config.schedule) : undefined;
@@ -8139,6 +8636,8 @@ function _object_spread_props$3(target, source) {
             key: "limitInstance",
             get: /**
      * Returns the LimitDateTimeInstance. This does not take the schedule into consideration.
+     *
+     * @returns The underlying {@link LimitDateTimeInstance}.
      */ function get() {
                 return this._limit;
             }
@@ -8161,6 +8660,8 @@ function _object_spread_props$3(target, source) {
      * // true if June 15 is a weekday and overlaps the limit range
      * instance.dateDayContainsValidDateValue(new Date('2024-06-15'));
      * ```
+     *
+     * @returns `true` if the day contains at least one valid date/time value.
      */ key: "dateDayContainsValidDateValue",
             value: function dateDayContainsValidDateValue(date) {
                 var isInSchedule = this.dateIsInSchedule(date);
@@ -8199,6 +8700,8 @@ function _object_spread_props$3(target, source) {
      *
      * instance.isInValidRange(new Date('2024-06-15T10:00:00')); // true if a weekday
      * ```
+     *
+     * @returns `true` if the date is within the min/max limits and on a scheduled day.
      */ key: "isInValidRange",
             value: function isInValidRange(date) {
                 var result = this.getStatus(date);
@@ -8221,6 +8724,8 @@ function _object_spread_props$3(target, source) {
      *
      * instance.isValid(new Date('2099-03-15T10:00:00')); // true if all constraints pass
      * ```
+     *
+     * @returns `true` if the date passes all configured constraints.
      */ key: "isValid",
             value: function isValid(date) {
                 var result = this.getStatus(date);
@@ -8244,6 +8749,8 @@ function _object_spread_props$3(target, source) {
      * // status.isAfterMinimum === false (before min)
      * // status.inFuture === false (if date is in the past)
      * ```
+     *
+     * @returns A {@link DateTimeMinuteDateStatus} snapshot for the given date.
      */ key: "getStatus",
             value: function getStatus() {
                 var date = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.date;
@@ -8302,6 +8809,8 @@ function _object_spread_props$3(target, source) {
      *
      * instance.dateIsInSchedule(new Date('2024-06-15')); // true (Saturday = false)
      * ```
+     *
+     * @returns `true` if the date is on a scheduled day or no schedule is configured.
      */ key: "dateIsInSchedule",
             value: function dateIsInSchedule() {
                 var date = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.date;
@@ -8326,6 +8835,8 @@ function _object_spread_props$3(target, source) {
      * instance.round({ roundToSteps: true }); // 2024-06-15T09:00:00
      * instance.round({ roundToSteps: true, roundToBound: true }); // clamped to min if below
      * ```
+     *
+     * @returns The rounded (and optionally clamped) date.
      */ key: "round",
             value: function round(round) {
                 var _round_step;
@@ -8355,6 +8866,8 @@ function _object_spread_props$3(target, source) {
      *
      * instance.clamp(new Date('2024-05-25')); // clamped to min, then nearest weekday
      * ```
+     *
+     * @returns The date clamped to both the limits and the schedule.
      */ key: "clamp",
             value: function clamp() {
                 var date = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.date, maxClampDistance = arguments.length > 1 ? arguments[1] : void 0;
@@ -8375,6 +8888,8 @@ function _object_spread_props$3(target, source) {
      *
      * instance.clampToLimit(new Date('2025-03-01')); // returns max (2024-12-31)
      * ```
+     *
+     * @returns The date clamped to the configured min/max limits.
      */ key: "clampToLimit",
             value: function clampToLimit() {
                 var date = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.date;
@@ -8399,6 +8914,8 @@ function _object_spread_props$3(target, source) {
      * // If June 15, 2024 is a Saturday, returns the next Monday
      * instance.clampToSchedule(new Date('2024-06-15'));
      * ```
+     *
+     * @returns The nearest valid scheduled date, or the input date if already valid or no schedule is configured.
      */ key: "clampToSchedule",
             value: function clampToSchedule() {
                 var date = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.date, maxClampDistance = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 370;
@@ -8433,9 +8950,7 @@ function _object_spread_props$3(target, source) {
                             }
                         }
                         // set a default from the given input if applicable
-                        if (nextAvailableDate == null) {
-                            nextAvailableDate = this.clampToLimit(date);
-                        }
+                        nextAvailableDate !== null && nextAvailableDate !== void 0 ? nextAvailableDate : nextAvailableDate = this.clampToLimit(date);
                     }
                 }
                 return nextAvailableDate !== null && nextAvailableDate !== void 0 ? nextAvailableDate : date;
@@ -8460,6 +8975,8 @@ function _object_spread_props$3(target, source) {
      * // Find the next weekday after a Saturday
      * instance.findNextAvailableDayInSchedule(new Date('2024-06-15'), 'future');
      * ```
+     *
+     * @returns The next valid schedule date, or `undefined` if none found within the max distance.
      */ key: "findNextAvailableDayInSchedule",
             value: function findNextAvailableDayInSchedule(date, direction) {
                 var maxDistance = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 370;
@@ -8495,6 +9012,8 @@ function _object_spread_props$3(target, source) {
      * instance.isInSchedule(new Date('2024-06-17')); // true (Monday)
      * instance.isInSchedule(new Date('2024-06-16')); // false (Sunday)
      * ```
+     *
+     * @returns `true` if the date is on a scheduled day or no schedule is configured.
      */ key: "isInSchedule",
             value: function isInSchedule(date) {
                 return this._dateFilter ? this._dateFilter(date) : true;
@@ -8554,6 +9073,8 @@ function _object_spread_props$3(target, source) {
  *
  * isValid(new Date('2024-06-17T10:00:00')); // true if future weekday after min
  * ```
+ *
+ * @returns A decision function that returns `true` for valid dates.
  */ function dateTimeMinuteDecisionFunction(config) {
     var instance = new DateTimeMinuteInstance(config, null);
     return function(date) {
@@ -8586,6 +9107,8 @@ function _object_spread_props$3(target, source) {
  * // true only if both 00:00 and 23:59 on June 15 pass all constraints
  * isFullDayValid(new Date('2024-06-15'));
  * ```
+ *
+ * @returns A decision function that returns `true` for valid days.
  */ function dateTimeMinuteWholeDayDecisionFunction(config) {
     var startAndEndOfDayMustBeValid = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     var instance = new DateTimeMinuteInstance(config, null);
@@ -8670,6 +9193,7 @@ function _object_spread_props$2(target, source) {
  * guaranteeing that `raw` and `result` are defined.
  *
  * @param result - The parse result to check.
+ * @returns `true` if the result is valid, narrowing the type to {@link ValidDateFromTimestringResult}.
  *
  * @example
  * ```ts
@@ -8713,6 +9237,7 @@ function _object_spread_props$2(target, source) {
      *
      * @param date - The date to check. Defaults to now.
      * @param timezone - Overrides the instance's configured timezone for this call.
+     * @returns {@link TimeAM.AM} or {@link TimeAM.PM} depending on the time of day.
      *
      * @example
      * ```ts
@@ -8732,6 +9257,7 @@ function _object_spread_props$2(target, source) {
      *
      * @param date - The date to format.
      * @param timezone - Overrides the instance's configured timezone for this call.
+     * @returns The formatted time string (e.g., "1:30PM").
      *
      * @example
      * ```ts
@@ -8826,18 +9352,35 @@ function _object_spread_props$2(target, source) {
                         'h:mm',
                         'HH:mm' // 01:20
                     ];
-                    // tslint:disable-next-line: prefer-for-of
-                    for(var i = 0; i < formats.length; i += 1){
-                        systemParsedDateTime = parse(input, formats[i], relativeDate);
-                        if (isValid(systemParsedDateTime)) {
-                            valid = true;
-                            break; // Use time.
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        // tslint:disable-next-line: prefer-for-of
+                        for(var _iterator = formats[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var format = _step.value;
+                            systemParsedDateTime = parse(input, format, relativeDate);
+                            if (isValid(systemParsedDateTime)) {
+                                valid = true;
+                                break; // Use time.
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
                         }
                     }
                     var removedPm = false;
                     function removeAmPm(inputString) {
                         inputString = inputString.toLowerCase();
-                        removedPm = inputString.indexOf('pm') !== -1;
+                        removedPm = inputString.includes('pm');
                         inputString = inputString.replace(/am|pm/g, '');
                         return inputString;
                     }
@@ -8937,6 +9480,8 @@ function _object_spread_props$2(target, source) {
 /**
  * Creates a {@link DateTimeUtilityInstance} configured for UTC.
  *
+ * @returns A new {@link DateTimeUtilityInstance} using the UTC timezone.
+ *
  * @example
  * ```ts
  * const utcInstance = dateTimeInstanceUtc();
@@ -8950,6 +9495,7 @@ function _object_spread_props$2(target, source) {
  * Defaults to UTC when no timezone is provided.
  *
  * @param timezone - The IANA timezone identifier (e.g., 'America/New_York').
+ * @returns A new {@link DateTimeUtilityInstance} for the specified timezone.
  *
  * @example
  * ```ts
@@ -8964,6 +9510,7 @@ function _object_spread_props$2(target, source) {
  *
  * @param date - The date to check. Defaults to now.
  * @param timezone - The IANA timezone to evaluate in. Defaults to UTC.
+ * @returns {@link TimeAM.AM} or {@link TimeAM.PM} depending on the time of day.
  *
  * @example
  * ```ts
@@ -8981,6 +9528,7 @@ function _object_spread_props$2(target, source) {
  * unlike {@link toReadableTimeString} which defaults to UTC.
  *
  * @param date - The date to format.
+ * @returns The formatted time string in the system's local timezone.
  *
  * @example
  * ```ts
@@ -8994,6 +9542,7 @@ function _object_spread_props$2(target, source) {
  *
  * @param date - The date to format.
  * @param timezone - The IANA timezone to format in. Defaults to UTC.
+ * @returns The formatted time string (e.g., "10:30AM").
  *
  * @example
  * ```ts
@@ -9009,6 +9558,7 @@ function _object_spread_props$2(target, source) {
  *
  * @param input - A time string such as "1:30PM", "13:30", or "1PM".
  * @param config - Optional configuration specifying the timezone and reference date.
+ * @returns The parsed time string result, or `undefined` if parsing failed.
  *
  * @example
  * ```ts
@@ -9027,6 +9577,7 @@ function _object_spread_props$2(target, source) {
  *
  * @param input - A time string such as "1:30PM" or "13:30".
  * @param config - Optional configuration specifying the timezone and reference date.
+ * @returns The resolved date, or `undefined` if the input could not be parsed.
  *
  * @example
  * ```ts
@@ -9040,6 +9591,7 @@ function _object_spread_props$2(target, source) {
  * Creates a {@link LimitDateTimeInstance} for clamping and constraining dates to a configured range.
  *
  * @param config - The limit configuration specifying min/max bounds, future requirements, etc.
+ * @returns A new {@link LimitDateTimeInstance} configured with the given bounds.
  *
  * @example
  * ```ts
@@ -9149,6 +9701,7 @@ function _object_spread_props$1(target, source) {
         date: toZonedTime(find.range.date, find.timezone)
     }) : find.range;
     var dates = dateRange(range);
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch(range.type){
         case DateRangeType.DAY:
         case DateRangeType.WEEK:
@@ -9344,13 +9897,12 @@ function _object_spread$1(target) {
                 // A single field that manages start/end will start and end at the same instant (end = start)
                 // so we merge the gte/lte values.
                 var merged = mergeMongoDBLikeRangeFilters(startsAt, endsAt);
-                startsAtFilter = merged ? _define_property$2({}, fields.start, merged) : undefined;
+                startsAtFilter = _define_property$2({}, fields.start, merged);
             } else {
                 startsAtFilter = startsAt ? _define_property$2({}, fields.start, startsAt) : undefined;
                 endsAtFilter = endsAt && fields.end ? _define_property$2({}, fields.end, endsAt) : undefined;
             }
-            var filter = _object_spread$1({}, startsAtFilter, endsAtFilter);
-            return filter;
+            return _object_spread$1({}, startsAtFilter, endsAtFilter);
         }
     };
 }
@@ -9473,6 +10025,8 @@ function _is_native_reflect_construct() {
      * const rule = new DateRRule({ freq: RRule.DAILY, count: 5, dtstart: startDate });
      * const lastDate = rule.last(); // fifth occurrence
      * ```
+     *
+     * @returns The last occurrence date, or `undefined` if there are none.
      */ key: "last",
             value: function last() {
                 return this._iter(new LastIterResult());
@@ -9487,6 +10041,9 @@ function _is_native_reflect_construct() {
      * const rule = new DateRRule({ freq: RRule.WEEKLY, dtstart: startDate });
      * const nextDate = rule.next(new Date());
      * ```
+     *
+     * @param minDate - The earliest date to consider.
+     * @returns The first occurrence on or after `minDate`, or `undefined` if none.
      */ key: "next",
             value: function next(minDate) {
                 return this._iter(new NextIterResult(minDate));
@@ -9501,6 +10058,11 @@ function _is_native_reflect_construct() {
      * const rule = new DateRRule({ freq: RRule.DAILY, dtstart: startDate });
      * const exists = rule.any({ minDate: rangeStart, maxDate: rangeEnd });
      * ```
+     *
+     * @param filter - Optional date bounds with `minDate` and `maxDate`.
+     * @param filter.minDate - Optional minimum date bound.
+     * @param filter.maxDate - Optional maximum date bound.
+     * @returns `true` if at least one recurrence falls within the bounds.
      */ key: "any",
             value: function any() {
                 var filter = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
@@ -9761,7 +10323,10 @@ function _unsupported_iterable_to_array$1(o, minLen) {
 /**
  * Delimiter separating the property name/params from values in an RRule line.
  */ var RRULE_STRING_SPLITTER = ':';
-/** @deprecated use RRULE_STRING_SPLITTER instead. */ var RRuleStringSplitter = RRULE_STRING_SPLITTER;
+/**
+ * @deprecated use RRULE_STRING_SPLITTER instead.
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+var RRuleStringSplitter = RRULE_STRING_SPLITTER;
 /**
  * Utility class for parsing and manipulating RFC 5545 RRule strings.
  *
@@ -9792,6 +10357,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
      * // result.basic = ['RRULE:FREQ=DAILY']
      * // result.exdates contains the parsed exclusion dates
      * ```
+     *
+     * @param input - The RRule string line set to separate.
+     * @returns The separated basic rules and parsed EXDATE exclusion dates.
      */ function separateRRuleStringSetValues(input) {
                 var basic = [];
                 var exdateRules = [];
@@ -9821,6 +10389,8 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             /**
      * Parses an EXDATE line into its timezone and date components.
      *
+     * @param line - The raw EXDATE line string to parse.
+     * @returns The parsed EXDATE attribute with timezone and dates.
      * @throws Error if the line is not an EXDATE property.
      */ function parseExdateAttributeFromLine(line) {
                 var property = this.parseProperty(line);
@@ -9832,6 +10402,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             key: "parseExdateAttributeFromProperty",
             value: /**
      * Extracts timezone and UTC-normalized dates from an already-parsed EXDATE property.
+     *
+     * @param property - The parsed EXDATE property to extract from.
+     * @returns The EXDATE attribute containing timezone and UTC-normalized dates.
      */ function parseExdateAttributeFromProperty(property) {
                 var _property_params_find;
                 var timezone = (_property_params_find = property.params.find(function(x) {
@@ -9855,6 +10428,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             value: /**
      * Convenience wrapper that creates a timezone converter and delegates to {@link parseDateTimeString}.
      *
+     * @param rfcDateString - The RFC 5545 date or date-time string to parse.
+     * @param timezone - Optional timezone for non-UTC date strings.
+     * @returns The parsed JavaScript Date.
      * @throws Error if the date string is not UTC and no timezone is provided.
      */ function parseDateTimeStringWithTimezone(rfcDateString, timezone) {
                 return DateRRuleParseUtility.parseDateTimeString(rfcDateString, timezone ? new DateTimezoneUtcNormalInstance({
@@ -9870,6 +10446,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
      * If the string does not end in `Z` (indicating UTC), the converter is used to normalize
      * the local date representation to its true UTC equivalent.
      *
+     * @param rfcDateString - The RFC 5545 date or date-time string to parse.
+     * @param converter - Optional timezone converter for non-UTC date strings.
+     * @returns The parsed JavaScript Date.
      * @throws Error if the string cannot be parsed or a non-UTC string lacks a converter.
      */ function parseDateTimeString(rfcDateString, converter) {
                 var RFC5545_DATE_TIME_FORMAT = /^((\d{4})(\d{2})(\d{2}))(T(\d{2})(\d{2})(\d{2})Z?)?$/;
@@ -9913,6 +10492,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
      * DateRRuleParseUtility.formatDateTimeString(new Date('2021-06-11T11:00:00Z'));
      * // => '20210611T110000Z'
      * ```
+     *
+     * @param date - The date to format.
+     * @returns The RFC 5545 UTC date-time string representation.
      */ function formatDateTimeString(date) {
                 return format(date, "yyyyMMdd'T'HHmmss'Z'");
             }
@@ -9921,6 +10503,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             key: "parseProperty",
             value: /**
      * Parses a full RRule line string into a structured {@link RRuleProperty}.
+     *
+     * @param line - The raw RRule line string to parse.
+     * @returns The structured property with type, params, and values.
      */ function parseProperty(line) {
                 var rawLine = DateRRuleParseUtility.parseRawLine(line);
                 return DateRRuleParseUtility.propertyFromRawLine(rawLine);
@@ -9930,6 +10515,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             key: "propertyFromRawLine",
             value: /**
      * Converts an {@link RRuleRawLine} into a structured {@link RRuleProperty} by splitting the type and params.
+     *
+     * @param rawLine - The raw line to convert.
+     * @returns The structured property with separated type, params, and values.
      */ function propertyFromRawLine(rawLine) {
                 var typeAndParams = rawLine.params.split(';');
                 var type = typeAndParams[0].toUpperCase();
@@ -9945,6 +10533,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             key: "parseRawParam",
             value: /**
      * Splits a raw param string (e.g., `"TZID=America/New_York"`) into key-value form.
+     *
+     * @param param - The raw param string to split.
+     * @returns The parsed key-value param.
      */ function parseRawParam(param) {
                 var _splitJoinRemainder = _sliced_to_array$1(splitJoinRemainder(param, '=', 2), 2), key = _splitJoinRemainder[0], value = _splitJoinRemainder[1];
                 return {
@@ -9958,6 +10549,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             value: /**
      * Splits a raw line at the colon delimiter into params and values portions.
      * Falls back to treating a single-segment line as an RRULE value.
+     *
+     * @param line - The raw RRule line string to split.
+     * @returns The raw line with separated params and values.
      */ function parseRawLine(line) {
                 var _splitJoinRemainder = _sliced_to_array$1(splitJoinRemainder(line, RRULE_STRING_SPLITTER, 2), 2), params = _splitJoinRemainder[0], values = _splitJoinRemainder[1];
                 var result;
@@ -9980,6 +10574,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             value: // MARK: String
             /**
      * Splits a newline-delimited RRule string into individual line strings.
+     *
+     * @param lines - The newline-delimited RRule string to split.
+     * @returns An array of individual RRule line strings.
      */ function toRRuleStringSet(lines) {
                 return lines.split('\n');
             }
@@ -9988,6 +10585,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             key: "toRRuleLines",
             value: /**
      * Joins an array of RRule line strings into a single newline-delimited string.
+     *
+     * @param rruleStringSet - The array of RRule line strings to join.
+     * @returns A single newline-delimited RRule string.
      */ function toRRuleLines(rruleStringSet) {
                 return rruleStringSet.join('\n');
             }
@@ -9998,6 +10598,8 @@ function _unsupported_iterable_to_array$1(o, minLen) {
             /**
      * Asserts that the property has the expected type, throwing if it does not match.
      *
+     * @param type - The expected property type.
+     * @param property - The property to check.
      * @throws Error if the property type does not match the expected type.
      */ function assertPropertyType(type, property) {
                 if (property.type !== type) {
@@ -10138,7 +10740,7 @@ function _unsupported_iterable_to_array(o, minLen) {
         this.options = options;
         var tzid = rrule.origOptions.tzid;
         var dtstart = rrule.origOptions.dtstart;
-        var timezone = tzid || options.timezone;
+        var timezone = tzid !== null && tzid !== void 0 ? tzid : options.timezone;
         /**
          * The normal instance for DateRRuleInstance is used backwards in most cases because DateRRule always
          * parses dates as UTC, so we handle all input dates as base dates, an
@@ -10189,8 +10791,7 @@ function _unsupported_iterable_to_array(o, minLen) {
                 var from = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : new Date();
                 var baseFrom = this.normalInstance.baseDateToTargetDate(from);
                 var rawNext = this.rrule.next(baseFrom);
-                var next = rawNext ? this.normalInstance.targetDateToBaseDate(rawNext) : undefined;
-                return next;
+                return rawNext ? this.normalInstance.targetDateToBaseDate(rawNext) : undefined;
             }
         },
         {
@@ -10331,11 +10932,12 @@ function _unsupported_iterable_to_array(o, minLen) {
             /**
      * Returns `true` when the underlying RRule has neither a `count` nor an
      * `until` constraint, meaning it recurs indefinitely.
+     *
+     * @returns `true` if the rule recurs indefinitely.
      */ key: "hasForeverRange",
             value: function hasForeverRange() {
                 var options = this.rrule.options;
-                var forever = !options.count && !options.until;
-                return forever;
+                return !options.count && !options.until;
             }
         }
     ], [