@dereekb/date 10.1.30 → 11.0.0

package/index.cjs.js

@@ -1903,8 +1903,8 @@ function toISODateString(input) {
  * @returns
  */
 function guessCurrentTimezone() {
-  var _a, _b;
-  return (_b = (_a = Intl.DateTimeFormat()) === null || _a === void 0 ? void 0 : _a.resolvedOptions()) === null || _b === void 0 ? void 0 : _b.timeZone;
+  var _Intl$DateTimeFormat;
+  return (_Intl$DateTimeFormat = Intl.DateTimeFormat()) == null || (_Intl$DateTimeFormat = _Intl$DateTimeFormat.resolvedOptions()) == null ? void 0 : _Intl$DateTimeFormat.timeZone;
 }
 /**
  * Convenience function for getCurrentTimezone() that asserts a timezone is returned.
@@ -1928,8 +1928,8 @@ function safeToJsDate(input) {
  * @returns
  */
 function toJsDate(input) {
-  var _a;
-  return isDate(input) ? input : (_a = parseJsDateString(input)) !== null && _a !== void 0 ? _a : new Date(input);
+  var _parseJsDateString;
+  return isDate(input) ? input : (_parseJsDateString = parseJsDateString(input)) != null ? _parseJsDateString : new Date(input);
 }
 function parseJsDateString(input) {
   const date = typeof input === 'string' && util.isISO8601DateString(input) ? dateFns.parseISO(input) : new Date(input);
@@ -1973,6 +1973,8 @@ function utcDayForDate(date) {
  * For example, if it is currently 9PM:
  * - if 10PM on any day is passed then 9PM the next day will be returned.
  * - if 11PM on any day is passed, 11PM today will be returned.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function takeNextUpcomingTime(date, roundDownToMinute) {
   date = copyHoursAndMinutesFromDateToToday(date, roundDownToMinute);
@@ -1983,18 +1985,24 @@ function takeNextUpcomingTime(date, roundDownToMinute) {
 }
 /**
  * Creates a new date and copies the hours/minutes from the previous date and applies them to a date for today.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function copyHoursAndMinutesFromDateToToday(fromDate, roundDownToMinute) {
   return copyHoursAndMinutesFromDate(new Date(), fromDate, roundDownToMinute);
 }
 /**
  * Copies the hours/minutes from now to the target date.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function copyHoursAndMinutesFromNow(target, roundDownToMinute) {
   return copyHoursAndMinutesFromDate(target, new Date(), roundDownToMinute);
 }
 /**
  * Creates a new date and copies the hours/minutes from the input date to the target date.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function copyHoursAndMinutesFromDate(target, fromDate, roundDownToMinute) {
   return copyHoursAndMinutesToDate({
@@ -2020,11 +2028,11 @@ function copyHoursAndMinutesToDate({
   removeSeconds,
   roundDownToMinute = true
 }, target) {
-  return dateFns.set(target !== null && target !== void 0 ? target : new Date(), Object.assign(Object.assign({
+  return dateFns.set(target != null ? target : new Date(), Object.assign({
     hours
   }, minutes != null ? {
     minutes
-  } : undefined), roundDownToMinute || removeSeconds ? {
+  } : undefined, roundDownToMinute || removeSeconds ? {
     seconds: 0,
     milliseconds: 0
   } : undefined));
@@ -2034,22 +2042,56 @@ const copyHoursAndMinutesToToday = copyHoursAndMinutesToDate;
  * Removes the seconds and milliseconds from the input date, or returns the current date with no seconds or milliseconds.
  */
 function roundDownToMinute(date = new Date()) {
-  return dateFns.set(date, {
-    seconds: 0,
-    milliseconds: 0
-  });
+  return roundDateDownTo(date, 'minute');
+}
+/**
+ * Removes the minutes, seconds and milliseconds from the input date, or returns the current date with no mkinutes, seconds or milliseconds.
+ */
+function roundDownToHour(date = new Date()) {
+  return roundDateDownTo(date, 'hour');
+}
+function roundDateDownTo(date, roundToUnit) {
+  return roundDateToDate(date, roundToUnit, 'floor');
+}
+function roundDateTo(date, roundToUnit, roundType = 'floor') {
+  return typeof date === 'number' ? roundDateToUnixDateTimeNumber(date, roundToUnit, roundType) : roundDateTo(date, roundToUnit, roundType);
+}
+function roundDateToDate(date, roundToUnit, roundType = 'floor') {
+  return new Date(roundDateToUnixDateTimeNumber(date, roundToUnit, roundType));
 }
 /**
- * Removes all minutes,
+ * Rounds the input Date value down to the nearest hour, minute, or second.
+ *
  * @param date
+ * @param roundToUnit
+ * @param roundType
  * @returns
  */
-function roundDownToHour(date) {
-  return dateFns.set(date, {
-    minutes: 0,
-    seconds: 0,
-    milliseconds: 0
-  });
+function roundDateToUnixDateTimeNumber(date, roundToUnit, roundType = 'floor') {
+  const inputTimeUnrounded = typeof date === 'number' ? date : date.getTime();
+  let roundAmount = 0;
+  switch (roundToUnit) {
+    case 'hour':
+      roundAmount = util.MS_IN_HOUR;
+      break;
+    case 'second':
+      roundAmount = util.MS_IN_SECOND;
+      break;
+    default:
+    case 'minute':
+      roundAmount = util.MS_IN_MINUTE;
+      break;
+  }
+  const secondsAndMs = inputTimeUnrounded % roundAmount; // determine the number of seconds and milliseconds (prepare to round to nearest minute)
+  let roundedTime = inputTimeUnrounded;
+  if (secondsAndMs !== 0) {
+    roundedTime = inputTimeUnrounded - secondsAndMs; // remove seconds and ms as it will throw off the final tzOffset
+    if (roundType === 'ceil') {
+      roundedTime += roundAmount; // round up by adding the units
+    }
+  }
+
+  return roundedTime;
 }
 function reduceDatesFunction(reduceDates) {
   return inputDates => {
@@ -2208,6 +2250,8 @@ function isDateRangeStart(value) {
 const sortDateRangeStartAscendingCompareFunction = sortByDateFunction(x => x.start);
 class DateRange {
   constructor(template) {
+    this.start = void 0;
+    this.end = void 0;
     if (template != null) {
       this.start = template.start;
       this.end = template.end;
@@ -2256,11 +2300,10 @@ function isFullDateRange(input) {
   return input.start != null && input.end != null;
 }
 function dateOrDateRangeToDateRange(startOrDateRange, end) {
-  var _a;
   if (isDate(startOrDateRange)) {
     return {
       start: startOrDateRange,
-      end: (_a = end) !== null && _a !== void 0 ? _a : startOrDateRange
+      end: end != null ? end : startOrDateRange
     };
   } else {
     return startOrDateRange;
@@ -2342,6 +2385,7 @@ class DateRangeParams {
      * Date to filter on. If not provided, assumes now.
      */
     this.date = new Date();
+    this.distance = void 0;
     if (template) {
       this.type = template.type;
       this.date = template.date;
@@ -2369,10 +2413,10 @@ function dateRange(input, inputRoundToMinute) {
     distance: inputDistance,
     roundToMinute: inputConfigRoundToMinute = false
   } = config;
-  const rawDistance = inputDistance !== null && inputDistance !== void 0 ? inputDistance : undefined;
-  const roundToMinute = inputRoundToMinute !== null && inputRoundToMinute !== void 0 ? inputRoundToMinute : inputConfigRoundToMinute;
-  let date = inputDate !== null && inputDate !== void 0 ? inputDate : new Date();
-  let distance = inputDistance !== null && inputDistance !== void 0 ? inputDistance : 1;
+  const rawDistance = inputDistance != null ? inputDistance : undefined;
+  const roundToMinute = inputRoundToMinute != null ? inputRoundToMinute : inputConfigRoundToMinute;
+  let date = inputDate != null ? inputDate : new Date();
+  let distance = inputDistance != null ? inputDistance : 1;
   let start = date;
   let end = date;
   if (roundToMinute) {
@@ -2696,25 +2740,25 @@ function fitUTCDateRangeToDayPeriod(dateRange) {
     newDistance = util.MS_IN_DAY;
   }
   const end = dateFns.addMilliseconds(dateRange.start, newDistance);
-  return Object.assign(Object.assign({}, dateRange), {
+  return Object.assign({}, dateRange, {
     start: dateRange.start,
     end
   });
 }
 function clampDateFunction(dateRange) {
-  var _a, _b;
   let fn;
   const hasStartDate = dateRange.start != null;
   const hasEndDate = dateRange.end != null;
   if (hasStartDate || hasEndDate) {
+    var _dateRange$start, _dateRange$end;
     // Start Clamp
-    const startTime = ((_a = dateRange.start) === null || _a === void 0 ? void 0 : _a.getTime()) || 0;
+    const startTime = ((_dateRange$start = dateRange.start) == null ? void 0 : _dateRange$start.getTime()) || 0;
     const clampStart = input => {
       const time = input.getTime();
       return time >= startTime ? input : dateRange.start;
     };
     // End Clamp
-    const endTime = ((_b = dateRange.end) === null || _b === void 0 ? void 0 : _b.getTime()) || 0;
+    const endTime = ((_dateRange$end = dateRange.end) == null ? void 0 : _dateRange$end.getTime()) || 0;
     const clampEnd = input => {
       const time = input.getTime();
       return time <= endTime ? input : dateRange.end;
@@ -2806,6 +2850,8 @@ function getDaysOfWeekInDateRange(dateRange) {
 
 class DateDurationSpan {
   constructor(template) {
+    this.startsAt = void 0;
+    this.duration = void 0;
     if (template != null) {
       this.startsAt = template.startsAt;
       this.duration = template.duration;
@@ -2840,6 +2886,58 @@ function isSameDurationSpan(a, b) {
   return util.safeCompareEquality(a, b, (a, b) => a.duration === b.duration && isSameDate(a.startsAt, b.startsAt));
 }
 
+const DATE_TODAY_START_VALUE = 'today_start';
+const DATE_TODAY_END_VALUE = 'today_end';
+const DATE_WEEK_START_VALUE = 'this_week_start';
+const DATE_WEEK_END_VALUE = 'this_week_end';
+function logicalDateStringCodeDateFactory(logicalDateStringCode) {
+  let mapFn;
+  switch (logicalDateStringCode.toLocaleLowerCase()) {
+    case util.DATE_NOW_VALUE:
+      mapFn = util.mapIdentityFunction();
+      break;
+    case DATE_TODAY_START_VALUE:
+      mapFn = dateFns.startOfDay;
+      break;
+    case DATE_TODAY_END_VALUE:
+      mapFn = dateFns.endOfDay;
+      break;
+    case DATE_WEEK_START_VALUE:
+      mapFn = dateFns.startOfWeek;
+      break;
+    case DATE_WEEK_END_VALUE:
+      mapFn = dateFns.endOfWeek;
+      break;
+    default:
+      throw new Error(`Unknown logical date string "${logicalDateStringCode}"`);
+  }
+  return (now = new Date()) => mapFn(now);
+}
+function dateFromLogicalDate(logicalDate, now = new Date()) {
+  let result;
+  if (typeof logicalDate === 'string') {
+    result = logicalDateStringCodeDateFactory(logicalDate)(now);
+  } else {
+    result = logicalDate;
+  }
+  return result;
+}
+function isLogicalDateStringCode(logicalDate) {
+  let isLogicalDateStringCode = false;
+  if (typeof logicalDate === 'string') {
+    switch (logicalDate.toLocaleLowerCase()) {
+      case util.DATE_NOW_VALUE:
+      case DATE_TODAY_START_VALUE:
+      case DATE_TODAY_END_VALUE:
+      case DATE_WEEK_START_VALUE:
+      case DATE_WEEK_END_VALUE:
+        isLogicalDateStringCode = true;
+        break;
+    }
+  }
+  return isLogicalDateStringCode;
+}
+
 /**
  * Returns true if any DateTimezoneConversionConfig configuration value is provided.
  *
@@ -2874,7 +2972,8 @@ function isSameDateTimezoneConversionConfig(a, b) {
  * @returns
  */
 function getCurrentSystemOffsetInMs(date) {
-  return minutesToMs(getCurrentSystemOffsetInMinutes(date));
+  const systemTimezone = requireCurrentTimezone();
+  return calculateTimezoneOffset(systemTimezone, date);
 }
 /**
  * Returns the current system time offset in hours.
@@ -2883,20 +2982,25 @@ function getCurrentSystemOffsetInMs(date) {
  * @returns
  */
 function getCurrentSystemOffsetInHours(date) {
-  return dateFns.minutesToHours(getCurrentSystemOffsetInMinutes(date));
+  return dateFns.millisecondsToHours(getCurrentSystemOffsetInMs(date));
 }
 /**
- * Equivalent to -date.getTimezoneOffset().
+ * Returns the system offset for the input date, in minutes.
+ *
+ * The offset corresponds positively with the UTC offset, so UTC-6 is negative 6 hours, in milliseconds.
  *
  * @param date
  * @returns
  */
 function getCurrentSystemOffsetInMinutes(date) {
-  return -date.getTimezoneOffset();
+  return dateFns.millisecondsToMinutes(getCurrentSystemOffsetInMs(date));
 }
 /**
  * Returns the timezone offset in milliseconds.
  *
+ * This is preferential to Date.getTimezoneOffset() or date-fns's getTimezoneOffset() as those are currently wrong for the first
+ * two hours when daylight savings changes.
+ *
  * I.E. GMT-5 = -5 hours (in milliseconds)
  *
  * @param timezone
@@ -2910,14 +3014,17 @@ function calculateTimezoneOffset(timezone, date) {
   
   const tzOffset = getTimezoneOffset(timezone, date);
   */
-  // WORKAROUND: This is the current workaround. Performance hit seems negligible for all UI use cases.
-  const zoneDate = dateFnsTz.utcToZonedTime(date, timezone);
+  /*
+   * WORKAROUND: This is the current workaround. Performance hit seems negligible for all UI use cases.
+   */
+  // inputTimeDate.setSeconds(0);         // NOTE: setting seconds/milliseconds during the daylight savings epoch will also remove an hour
+  // inputTimeDate.setMilliseconds(0);    // do not clear seconds in this way.
+  const inputTimeUnrounded = date.getTime();
+  const secondsAndMs = inputTimeUnrounded % util.MS_IN_MINUTE; // determine the number of seconds and milliseconds (prepare to round to nearest minute)
+  const inputTime = inputTimeUnrounded - secondsAndMs; // remove seconds and ms as it will throw off the final tzOffset
+  const zoneDate = dateFnsTz.utcToZonedTime(inputTime, timezone);
   const zoneDateStr = dateFnsTz.format(zoneDate, 'yyyy-MM-dd HH:mm'); // ignore seconds, etc.
   const zoneDateTime = new Date(zoneDateStr + 'Z').getTime();
-  const inputTime = dateFns.set(date, {
-    seconds: 0,
-    milliseconds: 0
-  }).getTime();
   const tzOffset = zoneDateTime - inputTime;
   return tzOffset;
 }
@@ -2973,15 +3080,20 @@ class DateTimezoneUtcNormalInstance {
     const {
       timezone
     } = this.config;
-    return timezone !== null && timezone !== void 0 ? timezone : this.config.useSystemTimezone ? guessCurrentTimezone() : undefined;
+    return timezone != null ? timezone : this.config.useSystemTimezone ? guessCurrentTimezone() : undefined;
   }
   constructor(config) {
+    this.config = void 0;
+    this.hasConversion = void 0;
+    this._getOffset = void 0;
+    this._setOnDate = util.cachedGetter(() => setOnDateWithTimezoneNormalFunction(this));
     let getOffsetInMsFn;
     function useTimezone(timezone) {
       getOffsetInMsFn = date => calculateTimezoneOffset(timezone, date);
     }
     if (config == null || typeof config === 'string') {
-      const timezone = config !== null && config !== void 0 ? config : util.UTC_TIMEZONE_STRING;
+      var _config;
+      const timezone = (_config = config) != null ? _config : util.UTC_TIMEZONE_STRING;
       config = {
         timezone
       };
@@ -3045,10 +3157,44 @@ class DateTimezoneUtcNormalInstance {
     }
     this.hasConversion = hasConversion;
   }
-  _computeOffsetDate(date, from, to) {
+  convertDate(date, from, to) {
     return dateFns.addMilliseconds(date, this._getOffset(date, from, to));
   }
+  /**
+   * A "safer" conversion that will return a "mirrored" offset. Only functional with a "to" UTC value.
+   *
+   * This is required in cases where "reverse" offset will be used and must be consistent so they reverse in both directions the same amount compared to the base.
+   *
+   * 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
+   */
+  safeMirroredConvertDate(baseDate, originalContextDate, contextType, safeConvert = true) {
+    if (contextType === 'base') {
+      return {
+        date: baseDate,
+        daylightSavingsOffset: 0
+      };
+    } else {
+      const reverseConversion = this.convertDate(baseDate, contextType, 'base');
+      // in some cases where daylight savings ends (november 3rd),
+      // the input startsAt time will not be properly recovered due to loss of timezone information
+      // (cannot determine whether or not to apply the -5 or -6 offset after daylight savings ends)
+      const daylightSavingsOffset = safeConvert ? dateFns.differenceInHours(originalContextDate, reverseConversion) : 0;
+      const date = daylightSavingsOffset ? dateFns.addHours(reverseConversion, daylightSavingsOffset) : reverseConversion;
+      return {
+        date,
+        daylightSavingsOffset
+      };
+    }
+  }
   // MARK: DateTimezoneBaseDateConverter
+  get setOnDate() {
+    return this._setOnDate();
+  }
   getCurrentOffset(date, from, to) {
     return this._getOffset(date, from, to);
   }
@@ -3062,22 +3208,22 @@ class DateTimezoneUtcNormalInstance {
     return transformDateRangeToTimezoneFunction(this, transformType);
   }
   targetDateToBaseDate(date) {
-    return this._computeOffsetDate(date, 'target', 'base');
+    return this.convertDate(date, 'target', 'base');
   }
   baseDateToTargetDate(date) {
-    return this._computeOffsetDate(date, 'base', 'target');
+    return this.convertDate(date, 'base', 'target');
   }
   baseDateToSystemDate(date) {
-    return this._computeOffsetDate(date, 'base', 'system');
+    return this.convertDate(date, 'base', 'system');
   }
   systemDateToBaseDate(date) {
-    return this._computeOffsetDate(date, 'system', 'base');
+    return this.convertDate(date, 'system', 'base');
   }
   targetDateToSystemDate(date) {
-    return this._computeOffsetDate(date, 'target', 'system');
+    return this.convertDate(date, 'target', 'system');
   }
   systemDateToTargetDate(date) {
-    return this._computeOffsetDate(date, 'system', 'target');
+    return this.convertDate(date, 'system', 'target');
   }
   getOffset(date, transform) {
     return this[`${transform}Offset`](date);
@@ -3106,6 +3252,9 @@ class DateTimezoneUtcNormalInstance {
   systemDateToTargetDateOffset(date) {
     return this._getOffset(date, 'system', 'target');
   }
+  conversionOffset(date, from, to) {
+    return this._getOffset(date, from, to);
+  }
   calculateAllOffsets(date, map) {
     return calculateAllConversions(date, this, map);
   }
@@ -3136,7 +3285,7 @@ class DateTimezoneUtcNormalInstance {
     if (typeof date === 'string') {
       return util.parseISO8601DayStringToUTCDate(date);
     } else {
-      const startOfDayForSystem = dateFns.startOfDay(date !== null && date !== void 0 ? date : new Date());
+      const startOfDayForSystem = dateFns.startOfDay(date != null ? date : new Date());
       return this.baseDateToSystemDate(startOfDayForSystem);
     }
   }
@@ -3162,7 +3311,7 @@ class DateTimezoneUtcNormalInstance {
       const utcDate = util.parseISO8601DayStringToUTCDate(date);
       return this.systemDateToBaseDate(utcDate);
     } else {
-      return dateFns.startOfDay(date !== null && date !== void 0 ? date : new Date());
+      return dateFns.startOfDay(date != null ? date : new Date());
     }
   }
   /**
@@ -3317,6 +3466,78 @@ function startOfDayInTimezoneDayStringFactory(timezone) {
 function startOfDayInTimezoneFromISO8601DayString(day, timezone) {
   return startOfDayInTimezoneDayStringFactory(timezone)(day);
 }
+/**
+ * Creates a new SetONDateFunction using the input
+ */
+function setOnDateWithTimezoneNormalFunction(timezone) {
+  const timezoneInstance = dateTimezoneUtcNormal(timezone);
+  const fn = input => {
+    var _copyFrom, _copyFrom2;
+    const {
+      date: inputDate,
+      copyFrom: copyFromInput,
+      copyHours,
+      copyMinutes,
+      inputType: inputInputType,
+      outputType,
+      hours: inputHours,
+      minutes: inputMinutes,
+      roundDownToMinute
+    } = input;
+    const DEFAULT_TYPE = 'target';
+    const inputType = inputInputType != null ? inputInputType : DEFAULT_TYPE;
+    let baseDate;
+    let copyFrom;
+    // set copyFrom
+    if (copyFromInput != null) {
+      copyFrom = dateFromLogicalDate(copyFromInput); // read the logical date and set initial value
+      // if the input matches the copyFrom values, then skip conversion
+      // this step is also crucial for returning the correct value for daylight savings ending changes
+      if (inputDate != null && isSameDate(copyFrom, inputDate) && copyHours !== false && copyMinutes !== false) {
+        return roundDownToMinute ? roundDateDownTo(inputDate, 'minute') : inputDate;
+      }
+      if (inputType !== 'base') {
+        copyFrom = copyFrom != null ? timezoneInstance.convertDate(copyFrom, 'base', inputType) : undefined;
+      }
+    }
+    // set baseDate
+    if (inputDate != null) {
+      if (inputType === 'base') {
+        // use dates directly as UTC
+        baseDate = inputDate;
+      } else {
+        baseDate = timezoneInstance.convertDate(inputDate, 'base', inputType);
+      }
+    } else {
+      baseDate = new Date();
+    }
+    const hours = inputHours != null ? inputHours : copyHours !== false ? (_copyFrom = copyFrom) == null ? void 0 : _copyFrom.getUTCHours() : undefined;
+    const minutes = inputMinutes != null ? inputMinutes : copyMinutes !== false ? (_copyFrom2 = copyFrom) == null ? void 0 : _copyFrom2.getUTCMinutes() : undefined;
+    // NOTE: We do the math this way to avoid issues surrounding daylight savings
+    const time = baseDate.getTime();
+    const currentDayMillseconds = time % util.MS_IN_DAY;
+    const minutesSecondsAndMillseconds = currentDayMillseconds % util.MS_IN_HOUR;
+    const hoursInTimeInMs = currentDayMillseconds - minutesSecondsAndMillseconds;
+    const secondsAndMilliseconds = minutesSecondsAndMillseconds % util.MS_IN_MINUTE;
+    const minutesInTime = minutesSecondsAndMillseconds - secondsAndMilliseconds;
+    const nextDay = time - currentDayMillseconds;
+    const nextMinutes = minutes != null ? minutes * util.MS_IN_MINUTE : minutesInTime;
+    const nextHours = hours != null ? hours * util.MS_IN_HOUR : hoursInTimeInMs;
+    const nextTime = nextDay + nextHours + nextMinutes + (roundDownToMinute ? 0 : secondsAndMilliseconds);
+    const nextBaseDate = new Date(nextTime);
+    let result = timezoneInstance.convertDate(nextBaseDate, outputType != null ? outputType : inputType, 'base');
+    // one more test to limit the "range" of the change
+    // if it is over 1 day, then we can infer there is a timezone mismatch issue. It only occurs in one direction here, so we can safely
+    // infer that the real valid result can be derived by subtracting one day
+    const inputToResultDifferenceInHours = inputDate != null ? dateFns.differenceInHours(result, inputDate) : 0;
+    if (inputToResultDifferenceInHours >= 24) {
+      result = dateFns.addHours(result, -24);
+    }
+    return result;
+  };
+  fn._timezoneInstance = timezoneInstance;
+  return fn;
+}
 // MARK: Timezone Utilities
 /**
  * Convenience function for calling copyHoursAndMinutesFromDatesWithTimezoneNormal() with now.
@@ -3326,10 +3547,10 @@ function startOfDayInTimezoneFromISO8601DayString(day, timezone) {
  * @returns
  */
 function copyHoursAndMinutesFromNowWithTimezoneNormal(input, timezone) {
-  return copyHoursAndMinutesFromDateWithTimezoneNormal(input, new Date(), timezone);
+  return copyHoursAndMinutesFromDateWithTimezoneNormal(input, 'now', timezone);
 }
 /**
- * Converts the two input dates, which are dates in the same timezone/normal but than the current system, using the input DateTimezoneUtcNormalFunctionInput.
+ * Converts the two input dates, which are dates in the same timezone/normal instead of the current system, using the input DateTimezoneUtcNormalFunctionInput.
  *
  * This converts the dates to the system timezone normal, copies the values, then back to the original timezone normal.
  *
@@ -3339,15 +3560,13 @@ function copyHoursAndMinutesFromNowWithTimezoneNormal(input, timezone) {
  */
 function copyHoursAndMinutesFromDateWithTimezoneNormal(input, copyFrom, timezone) {
   const timezoneInstance = dateTimezoneUtcNormal(timezone);
-  const inputInSystemTimezone = timezoneInstance.systemDateToTargetDate(input);
-  const copyFromInSystemTimezone = timezoneInstance.systemDateToTargetDate(copyFrom);
-  // handle the potential system date time offset when the system's timezone offset changes between dates...
-  const inputInSystemTimezoneOffset = inputInSystemTimezone.getTimezoneOffset();
-  const copyFromInSystemTimezoneOffset = copyFromInSystemTimezone.getTimezoneOffset();
-  const offsetDifference = inputInSystemTimezoneOffset - copyFromInSystemTimezoneOffset;
-  // copy the minutes then add the offset difference to get the appropriate time.
-  const copiedInSystemTimezone = dateFns.addMinutes(copyHoursAndMinutesFromDate(inputInSystemTimezone, copyFromInSystemTimezone), offsetDifference);
-  const result = timezoneInstance.targetDateToSystemDate(copiedInSystemTimezone);
+  const result = timezoneInstance.setOnDate({
+    date: input,
+    copyFrom,
+    inputType: 'target',
+    copyHours: true,
+    copyMinutes: true
+  });
   return result;
 }
 
@@ -3826,8 +4045,8 @@ const allTimezoneInfos = util.cachedGetter(() => {
   return allTimezoneStrings().map(x => timezoneStringToTimezoneInfo(x, now));
 });
 function timezoneInfoForSystem() {
-  var _a;
-  return timezoneStringToTimezoneInfo((_a = guessCurrentTimezone()) !== null && _a !== void 0 ? _a : util.UTC_TIMEZONE_STRING);
+  var _guessCurrentTimezone;
+  return timezoneStringToTimezoneInfo((_guessCurrentTimezone = guessCurrentTimezone()) != null ? _guessCurrentTimezone : util.UTC_TIMEZONE_STRING);
 }
 function getTimezoneAbbreviation(timezone, date = new Date()) {
   return timezone === util.UTC_TIMEZONE_STRING ? util.UTC_TIMEZONE_STRING : timezone ? dateFnsTz.formatInTimeZone(date, timezone, 'zzz') : 'UKNOWN';
@@ -3878,7 +4097,7 @@ function IsKnownTimezone(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isKnownTimezone,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args === null || args === void 0 ? void 0 : args.value}" is not a known timezone.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args == null ? void 0 : args.value}" is not a known timezone.`, validationOptions)
       }
     });
   };
@@ -3892,7 +4111,7 @@ function IsKnownTimezone(validationOptions) {
  */
 function fitDateRangeToDayPeriodFunction(timezone) {
   const transformFn = transformDateRangeInTimezoneNormalFunction(timezone, 'baseDateToTargetDate');
-  const fn = input => Object.assign(Object.assign({}, input), transformFn(input, fitUTCDateRangeToDayPeriod));
+  const fn = input => Object.assign({}, input, transformFn(input, fitUTCDateRangeToDayPeriod));
   fn._timezoneInstance = transformFn._timezoneInstance;
   return fn;
 }
@@ -4065,7 +4284,7 @@ function formatDateRangeDistanceFunction(inputConfig) {
     timeRangeTimezone,
     strict = false
   } = inputConfig;
-  const transform = inputTransform !== null && inputTransform !== void 0 ? inputTransform : onlyTimeRange ? timeRangeTimezone ? fitDateRangeToDayPeriodFunction(timeRangeTimezone) : fitUTCDateRangeToDayPeriod : util.mapIdentityFunction();
+  const transform = inputTransform != null ? inputTransform : onlyTimeRange ? timeRangeTimezone ? fitDateRangeToDayPeriodFunction(timeRangeTimezone) : fitUTCDateRangeToDayPeriod : util.mapIdentityFunction();
   return (startOrDateRange, inputEnd) => {
     const dateRange = transform(dateOrDateRangeToDateRange(startOrDateRange, inputEnd));
     const {
@@ -4128,6 +4347,7 @@ function formatToDayTimeRangeString(startOrDateRange, end) {
   });
 }
 function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
+  var _inputFormat;
   let end;
   if (endOrFormat != null) {
     if (typeof endOrFormat === 'function') {
@@ -4136,7 +4356,7 @@ function formatToDayRangeString(startOrDateRange, endOrFormat, inputFormat) {
       end = endOrFormat;
     }
   }
-  const format = inputFormat !== null && inputFormat !== void 0 ? inputFormat : formatToShortDateString;
+  const format = (_inputFormat = inputFormat) != null ? _inputFormat : formatToShortDateString;
   return formatDateRange(dateOrDateRangeToDateRange(startOrDateRange, end), {
     format,
     simplifySameDate: true
@@ -4278,6 +4498,7 @@ function isValidDateCellIndex(input) {
 }
 class DateCell {
   constructor(template) {
+    this.i = void 0;
     if (template) {
       this.i = template.i;
     }
@@ -4302,8 +4523,8 @@ function dateCell(dateCellOrIndex) {
  * @returns
  */
 function dateCellTimingStartsAtForStartOfDay(input = {}) {
-  var _a;
-  const timezone = (_a = input.timezone) !== null && _a !== void 0 ? _a : requireCurrentTimezone();
+  var _input$timezone;
+  const timezone = (_input$timezone = input.timezone) != null ? _input$timezone : requireCurrentTimezone();
   let startsAt = dateFns.startOfDay(new Date());
   if (input.timezone != null) {
     startsAt = dateTimezoneUtcNormal(timezone).targetDateToSystemDate(startsAt);
@@ -4316,6 +4537,8 @@ function dateCellTimingStartsAtForStartOfDay(input = {}) {
 class DateCellTiming extends DateDurationSpan {
   constructor(template) {
     super(template);
+    this.end = void 0;
+    this.timezone = void 0;
     if (template) {
       this.end = template.end;
       this.timezone = template.timezone;
@@ -4414,7 +4637,8 @@ function dateCellTiming(durationInput, rangeInput, timezoneInput) {
     startsAt: inputStartsAt
   } = durationInput;
   // it is important that startsAt is evaluated the base time normal so we can avoid daylight savings issues
-  let startsAtInUtc = normalInstance.baseDateToTargetDate(inputStartsAt);
+  const startsAtInUtcInitial = normalInstance.baseDateToTargetDate(inputStartsAt);
+  let startsAtInUtc = startsAtInUtcInitial;
   let numberOfDayBlocks;
   let hasRangeFromInput = false;
   let rangeInUtc;
@@ -4456,12 +4680,18 @@ function dateCellTiming(durationInput, rangeInput, timezoneInput) {
     startsAtInUtc = roundDownToMinute(startsAtInUtc); // clear seconds and milliseconds from startsAt
   }
 
-  const lastStartsAtInBaseTimezone = dateFns.addHours(startsAtInUtc, numberOfDayBlocks * 24); // use addDays so the system (if it experiences daylight savings) can account for change for daylight savings
-  // calculate end to be the ending date/time of the final duration span
-  const end = dateFns.addMinutes(normalInstance.targetDateToBaseDate(lastStartsAtInBaseTimezone), duration);
   const utcDay = formatToISO8601DayStringForUTC(startsAtInUtc);
   const start = normalInstance.startOfDayInTargetTimezone(utcDay);
-  const startsAt = normalInstance.targetDateToBaseDate(startsAtInUtc);
+  const safeMirror = util.isEqualDate(startsAtInUtc, startsAtInUtcInitial);
+  const {
+    date: startsAt,
+    daylightSavingsOffset
+  } = normalInstance.safeMirroredConvertDate(startsAtInUtc, inputStartsAt, 'target', safeMirror);
+  // calculate end to be the ending date/time of the final duration span
+  const lastStartsAtInBaseTimezone = dateFns.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
+  const lastStartInTarget = normalInstance.targetDateToBaseDate(lastStartsAtInBaseTimezone);
+  const end = dateFns.addMinutes(lastStartInTarget, duration);
+  // console.log({ lastStartsAtInBaseTimezone, inputStartsAt, startsAtInUtcInitial, startsAtInUtc, startsAt, daylightSavingsOffset, start, lastStartInTarget, end });
   return {
     start,
     end,
@@ -4613,7 +4843,7 @@ function updateDateCellTimingToTimezoneFunction(timezone) {
     const {
       startsAt
     } = timing;
-    const newTiming = Object.assign(Object.assign({}, timing), {
+    const newTiming = Object.assign({}, timing, {
       start: dateCellTimingStart({
         startsAt,
         timezone
@@ -4668,7 +4898,7 @@ function shiftDateCellTimingToTimezoneFunction(timezoneInput) {
     const endNormal = inputTimingNormalInstance.baseDateToTargetDate(timing.end);
     const startsAt = normalInstance.targetDateToBaseDate(startsAtNormal);
     const end = normalInstance.targetDateToBaseDate(endNormal);
-    const newTiming = Object.assign(Object.assign({}, timing), {
+    const newTiming = Object.assign({}, timing, {
       start: dateCellTimingStart({
         startsAt,
         timezone
@@ -4723,11 +4953,24 @@ function calculateExpectedDateCellTimingDurationPair(timing) {
     timezone
   } = timing;
   const normalInstance = dateTimezoneUtcNormal(timezone);
-  const startsAtInUtcNormal = normalInstance.baseDateToTargetDate(startsAt); // convert to UTC normal
-  const endInUtcNormal = normalInstance.baseDateToTargetDate(end);
+  let startsAtInUtcNormal = normalInstance.baseDateToTargetDate(startsAt); // convert to UTC normal
+  let endInUtcNormal = normalInstance.baseDateToTargetDate(end);
+  const {
+    daylightSavingsOffset: startDaylightSavingsOffset
+  } = normalInstance.safeMirroredConvertDate(startsAtInUtcNormal, startsAt, 'target');
+  const {
+    daylightSavingsOffset: endDaylightSavingsOffset
+  } = normalInstance.safeMirroredConvertDate(endInUtcNormal, end, 'target');
+  if (startDaylightSavingsOffset) {
+    startsAtInUtcNormal = dateFns.addHours(startsAtInUtcNormal, startDaylightSavingsOffset);
+  }
+  if (endDaylightSavingsOffset) {
+    endInUtcNormal = dateFns.addHours(endInUtcNormal, endDaylightSavingsOffset);
+  }
   const finalMsDifferenceBetweenStartAndEnd = dateFns.differenceInMilliseconds(endInUtcNormal, startsAtInUtcNormal);
   const duration = finalMsDifferenceBetweenStartAndEnd / util.MS_IN_MINUTE % util.MINUTES_IN_DAY || util.MINUTES_IN_DAY;
-  const expectedFinalStartsAt = normalInstance.targetDateToBaseDate(dateFns.addMinutes(endInUtcNormal, -duration));
+  const expectedFinalStartsAtUtc = dateFns.addMinutes(endInUtcNormal, -duration);
+  const expectedFinalStartsAt = normalInstance.targetDateToBaseDate(expectedFinalStartsAtUtc); // 2024-11-03T03:00:00.000Z
   return {
     duration,
     expectedFinalStartsAt
@@ -4855,6 +5098,7 @@ function isValidFullDateCellTiming(timing) {
 class DateCellRange extends DateCell {
   constructor(template) {
     super(template);
+    this.to = void 0;
     if (template) {
       this.to = template.to;
     }
@@ -4922,8 +5166,8 @@ function isValidDateCellRangeSeries(input) {
  * The input range is not expected to be sorted.
  */
 function getLeastDateCellIndexInDateCellRanges(input) {
-  var _a, _b;
-  return (_b = (_a = getLeastAndGreatestDateCellIndexInDateCellRanges(input)) === null || _a === void 0 ? void 0 : _a.leastIndex) !== null && _b !== void 0 ? _b : 0;
+  var _getLeastAndGreatestD, _getLeastAndGreatestD2;
+  return (_getLeastAndGreatestD = (_getLeastAndGreatestD2 = getLeastAndGreatestDateCellIndexInDateCellRanges(input)) == null ? void 0 : _getLeastAndGreatestD2.leastIndex) != null ? _getLeastAndGreatestD : 0;
 }
 /**
  * Returns the largest index between all the input date block ranges. Returns 0 by default.
@@ -4931,8 +5175,8 @@ function getLeastDateCellIndexInDateCellRanges(input) {
  * The input range is not expected to be sorted.
  */
 function getGreatestDateCellIndexInDateCellRanges(input) {
-  var _a, _b;
-  return (_b = (_a = getLeastAndGreatestDateCellIndexInDateCellRanges(input)) === null || _a === void 0 ? void 0 : _a.greatestIndex) !== null && _b !== void 0 ? _b : 0;
+  var _getLeastAndGreatestD3, _getLeastAndGreatestD4;
+  return (_getLeastAndGreatestD3 = (_getLeastAndGreatestD4 = getLeastAndGreatestDateCellIndexInDateCellRanges(input)) == null ? void 0 : _getLeastAndGreatestD4.greatestIndex) != null ? _getLeastAndGreatestD3 : 0;
 }
 /**
  * Returns the largest index between all the input date block ranges. Returns null if the input is empty.
@@ -4977,7 +5221,7 @@ function getLeastAndGreatestDateCellIndexInDateCellRanges(input) {
 function dateCellRange(i, to) {
   return {
     i,
-    to: to !== null && to !== void 0 ? to : i
+    to: to != null ? to : i
   };
 }
 /**
@@ -5014,9 +5258,9 @@ function dateCellRangeIncludedByRangeFunction(inputRange) {
     to
   } = dateCellRangeWithRange(inputRange);
   return input => {
-    var _a;
+    var _range$to;
     const range = dateCellRangeWithRange(input);
-    return range.i <= i && ((_a = range === null || range === void 0 ? void 0 : range.to) !== null && _a !== void 0 ? _a : range.i) >= to;
+    return range.i <= i && ((_range$to = range == null ? void 0 : range.to) != null ? _range$to : range.i) >= to;
   };
 }
 /**
@@ -5031,9 +5275,9 @@ function dateCellRangeOverlapsRangeFunction(inputRange) {
     to
   } = dateCellRangeWithRange(inputRange);
   return input => {
-    var _a;
+    var _range$to2;
     const range = dateCellRangeWithRange(input);
-    return range.i <= to && ((_a = range === null || range === void 0 ? void 0 : range.to) !== null && _a !== void 0 ? _a : range.i) >= i;
+    return range.i <= to && ((_range$to2 = range == null ? void 0 : range.to) != null ? _range$to2 : range.i) >= i;
   };
 }
 /**
@@ -5055,8 +5299,8 @@ function dateCellRangeOverlapsRange(rangeA, rangeB) {
  */
 function sortDateCellRangeAndSizeFunction() {
   return (a, b) => {
-    var _a, _b;
-    return a.i - b.i || ((_a = a.to) !== null && _a !== void 0 ? _a : a.i) - ((_b = b.to) !== null && _b !== void 0 ? _b : b.i);
+    var _a$to, _b$to;
+    return a.i - b.i || ((_a$to = a.to) != null ? _a$to : a.i) - ((_b$to = b.to) != null ? _b$to : b.i);
   };
 }
 /**
@@ -5074,7 +5318,6 @@ function sortDateCellRanges(input) {
  * @param input
  */
 function groupToDateCellRanges(input) {
-  var _a;
   if (input.length === 0) {
     return [];
   }
@@ -5087,7 +5330,7 @@ function groupToDateCellRanges(input) {
     } = blocks[blocksArrayIndex];
     return {
       i,
-      to: to !== null && to !== void 0 ? to : i
+      to: to != null ? to : i
     };
   }
   // start at the first block
@@ -5097,8 +5340,9 @@ function groupToDateCellRanges(input) {
     const block = blocks[i];
     const isContinuous = block.i <= current.to + 1;
     if (isContinuous) {
+      var _blocks$i$to;
       // extend the current block.
-      current.to = (_a = blocks[i].to) !== null && _a !== void 0 ? _a : blocks[i].i;
+      current.to = (_blocks$i$to = blocks[i].to) != null ? _blocks$i$to : blocks[i].i;
     } else {
       // complete/create new block.
       results.push(current);
@@ -5155,14 +5399,14 @@ function filterDateCellsInDateCellRange(blocks, range) {
 function isDateCellWithinDateCellRangeFunction(inputRange) {
   const range = dateCellRangeWithRange(inputRange);
   return input => {
-    var _a;
     if (typeof input === 'number') {
       input = {
         i: input
       };
     }
     if (input.i >= range.i) {
-      const to = (_a = input.to) !== null && _a !== void 0 ? _a : input.i;
+      var _input$to;
+      const to = (_input$to = input.to) != null ? _input$to : input.i;
       return to <= range.to;
     }
     return false;
@@ -5228,7 +5472,7 @@ function dateCellRangesFullyCoverDateCellRangeFunction(ranges) {
  * @param input
  */
 function getNextDateCellTimingIndex(input) {
-  var _a, _b, _c;
+  var _relativeStateGroups$, _relativeStateGroups$2, _relativeStateGroups$3;
   const {
     ranges,
     currentIndex
@@ -5236,9 +5480,9 @@ function getNextDateCellTimingIndex(input) {
   const relativeStateGroups = util.makeValuesGroupMap(util.asArray(ranges), range => {
     return dateRelativeStateForDateCellRangeComparedToIndex(range, currentIndex);
   });
-  const pastResults = (_a = relativeStateGroups.get('past')) !== null && _a !== void 0 ? _a : [];
-  const presentResults = (_b = relativeStateGroups.get('present')) !== null && _b !== void 0 ? _b : [];
-  const futureResults = (_c = relativeStateGroups.get('future')) !== null && _c !== void 0 ? _c : [];
+  const pastResults = (_relativeStateGroups$ = relativeStateGroups.get('past')) != null ? _relativeStateGroups$ : [];
+  const presentResults = (_relativeStateGroups$2 = relativeStateGroups.get('present')) != null ? _relativeStateGroups$2 : [];
+  const futureResults = (_relativeStateGroups$3 = relativeStateGroups.get('future')) != null ? _relativeStateGroups$3 : [];
   const currentResult = presentResults[0];
   let nextResult;
   let nextIndex = currentIndex + 1;
@@ -5293,7 +5537,7 @@ function dateRelativeStateForDateCellRangeComparedToIndex(range, nowIndex) {
  */
 function expandDateCellRange(block) {
   return util.range(block.i, dateCellEndIndex(block) + 1).map(i => {
-    return Object.assign(Object.assign({}, block), {
+    return Object.assign({}, block, {
       i,
       to: i
     }); // copy block, set to as i
@@ -5314,22 +5558,22 @@ function dateCellRangeHasRange(input) {
  * @returns
  */
 function dateCellEndIndex(input) {
-  var _a;
-  return (_a = input.to) !== null && _a !== void 0 ? _a : input.i;
+  var _input$to2;
+  return (_input$to2 = input.to) != null ? _input$to2 : input.i;
 }
 /**
  * Groups all input DateCellRange or UniqueDateCell values into a UniqueDateCellRangeGroup value amd sorts the input.
  */
 function groupUniqueDateCells(input) {
-  var _a;
   const blocks = sortDateCellRanges([...input]);
   const i = 0;
   let to;
   if (blocks.length === 0) {
     to = i;
   } else {
+    var _lastBlock$to;
     const lastBlock = util.lastValue(blocks);
-    to = (_a = lastBlock.to) !== null && _a !== void 0 ? _a : lastBlock.i;
+    to = (_lastBlock$to = lastBlock.to) != null ? _lastBlock$to : lastBlock.i;
   }
   return {
     i,
@@ -5345,8 +5589,8 @@ function expandUniqueDateCellsFunction(config) {
     fillFactory: inputFillFactory,
     retainOnOverlap: inputRetainOnOverlap
   } = config;
-  const retainOnOverlap = inputRetainOnOverlap !== null && inputRetainOnOverlap !== void 0 ? inputRetainOnOverlap : 'next';
-  const maxAllowedIndex = endAtIndex !== null && endAtIndex !== void 0 ? endAtIndex : Number.MAX_SAFE_INTEGER;
+  const retainOnOverlap = inputRetainOnOverlap != null ? inputRetainOnOverlap : 'next';
+  const maxAllowedIndex = endAtIndex != null ? endAtIndex : Number.MAX_SAFE_INTEGER;
   const fillFactory = inputFillFactory;
   if (!fillFactory && fill === 'fill') {
     throw new Error('fillFactory is required when fillOption is "fill".');
@@ -5383,7 +5627,7 @@ function expandUniqueDateCellsFunction(config) {
       const to = Math.min(inputTo, maxAllowedIndex) || 0;
       let block = null;
       if (inputBlock != null) {
-        block = Object.assign(Object.assign({}, inputBlock), {
+        block = Object.assign({}, inputBlock, {
           i,
           to
         });
@@ -5406,7 +5650,7 @@ function expandUniqueDateCellsFunction(config) {
           to
         };
         const block = fillFactory(dateCellRange);
-        addBlockWithRange(block, i, to !== null && to !== void 0 ? to : i);
+        addBlockWithRange(block, i, to != null ? to : i);
       } else if (fill === 'empty') ; else if (blocks.length > 0) {
         // only extend if one or more blocks have been pushed
         const blockToExtend = util.lastValue(blocks);
@@ -5489,7 +5733,7 @@ function expandUniqueDateCellsFunction(config) {
             // add current
             addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
             // change next to start at the next range
-            continueToNext(Object.assign(Object.assign({}, next.block), {
+            continueToNext(Object.assign({}, next.block, {
               i: currentEndIndex + 1,
               to: nextEndIndex
             }), next.priority);
@@ -5509,7 +5753,7 @@ function expandUniqueDateCellsFunction(config) {
             // add the next item first since it overwrites the current
             addBlockWithRange(next.block, nextStartIndex, nextEndIndex);
             // continue with the current item as next.
-            continueToNext(Object.assign(Object.assign({}, current.block), {
+            continueToNext(Object.assign({}, current.block, {
               i: nextEndIndex + 1,
               to: currentEndIndex
             }), current.priority);
@@ -5524,7 +5768,7 @@ function expandUniqueDateCellsFunction(config) {
             addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
             if (nextEndIndex > currentEndIndex) {
               // change next to start at the next range
-              continueToNext(Object.assign(Object.assign({}, next.block), {
+              continueToNext(Object.assign({}, next.block, {
                 i: currentEndIndex + 1,
                 to: nextEndIndex
               }), next.priority);
@@ -5540,7 +5784,7 @@ function expandUniqueDateCellsFunction(config) {
               // add the next
               addBlockWithRange(next.block, nextStartIndex, nextEndIndex);
               // continue with the current
-              continueToNext(Object.assign(Object.assign({}, current.block), {
+              continueToNext(Object.assign({}, current.block, {
                 i: nextEndIndex + 1,
                 to: currentEndIndex
               }), next.priority);
@@ -5594,7 +5838,7 @@ function dateCellRangeOfTimingFactory(config) {
     limitToCompletedIndexes: onlyIncludeIfComplete = false,
     now: inputNowGetter
   } = config;
-  const nowGetter = util.asGetter(inputNowGetter !== null && inputNowGetter !== void 0 ? inputNowGetter : () => new Date());
+  const nowGetter = util.asGetter(inputNowGetter != null ? inputNowGetter : () => new Date());
   const indexFactory = dateCellTimingRelativeIndexFactory(timing);
   const minIndex = fitToTimingRange ? 0 : Number.MIN_SAFE_INTEGER;
   const maxIndex = fitToTimingRange ? indexFactory(indexFactory._timing.end) : Number.MAX_SAFE_INTEGER;
@@ -5637,9 +5881,9 @@ function dateCellRangeOfTimingFactory(config) {
     const {
       i: start,
       to: end
-    } = input !== null && input !== void 0 ? input : {};
-    const startIndex = indexFactory(start !== null && start !== void 0 ? start : 0);
-    const endIndex = indexFactory(end !== null && end !== void 0 ? end : nowGetter());
+    } = input != null ? input : {};
+    const startIndex = indexFactory(start != null ? start : 0);
+    const endIndex = indexFactory(end != null ? end : nowGetter());
     const maxIndex = getCurrentMaxIndex();
     const to = Math.min(maxIndex, endIndex); // calculate to first to get the max value
     const i = Math.min(Math.max(minIndex, startIndex), to); // i should never be greater than to
@@ -5669,11 +5913,11 @@ function dateCellRangeOfTiming(config, input) {
  * By default fitToTimingRange is true.
  */
 function dateCellTimingCompletedTimeRange(timing, config) {
-  var _a;
+  var _config$fitToTimingRa;
   return dateCellRangeOfTiming({
     timing,
-    now: config === null || config === void 0 ? void 0 : config.now,
-    fitToTimingRange: (_a = config === null || config === void 0 ? void 0 : config.fitToTimingRange) !== null && _a !== void 0 ? _a : true,
+    now: config == null ? void 0 : config.now,
+    fitToTimingRange: (_config$fitToTimingRa = config == null ? void 0 : config.fitToTimingRange) != null ? _config$fitToTimingRa : true,
     limitToCompletedIndexes: true
   });
 }
@@ -5691,10 +5935,10 @@ function dateCellTimingLatestCompletedIndex(timing, now) {
   }).to;
 }
 function dateCellRangeToDateCellIndexRange(range) {
-  var _a;
+  var _range$to;
   return {
     minIndex: range.i,
-    maxIndex: ((_a = range.to) !== null && _a !== void 0 ? _a : range.i) + 1
+    maxIndex: ((_range$to = range.to) != null ? _range$to : range.i) + 1
   };
 }
 function dateCellIndexRangeToDateCellRange(range) {
@@ -5788,7 +6032,7 @@ function dateCellTimingExpansionFactory(config) {
   });
   const filter = util.mergeFilterFunctions(x => isInRange(x.i), inputFilter);
   const startsAtFactory = dateCellTimingStartsAtDateFactory(timing);
-  const durationSpanFilter = inputDurationSpanFilter !== null && inputDurationSpanFilter !== void 0 ? inputDurationSpanFilter : () => true;
+  const durationSpanFilter = inputDurationSpanFilter != null ? inputDurationSpanFilter : () => true;
   return input => {
     const blocks = Array.isArray(input) ? input : input.blocks;
     const spans = [];
@@ -5798,7 +6042,7 @@ function dateCellTimingExpansionFactory(config) {
       blocksEvaluated += 1;
       if (filter(block, blockIndex)) {
         const startsAt = startsAtFactory(block.i);
-        const durationSpan = Object.assign(Object.assign({}, block), {
+        const durationSpan = Object.assign({}, block, {
           startsAt,
           duration
         });
@@ -5816,7 +6060,7 @@ function dateCellTimingExpansionFactory(config) {
       if (dateCellRangeHasRange(block)) {
         // Expands the block's range as if it is at a single index
         util.range(block.i, block.to + 1).findIndex(i => {
-          const blockAtIndex = Object.assign(Object.assign({}, block), {
+          const blockAtIndex = Object.assign({}, block, {
             i,
             to: i
           }); // copy block, set to as i
@@ -5856,7 +6100,7 @@ function dateCellDayTimingInfoFactory(config) {
     const date = typeof input === 'number' ? dayFactory(input) : input;
     const dayIndex = indexFactory(input);
     const isInRange = checkIsInRange(dayIndex);
-    const now = inputNow !== null && inputNow !== void 0 ? inputNow : date;
+    const now = inputNow != null ? inputNow : date;
     const startsAtOnDay = startsAtFactory(dayIndex); // convert back to the proper date
     const endsAtOnDay = dateFns.addMinutes(startsAtOnDay, duration);
     const potentiallyInProgress = !dateFns.isAfter(startsAtOnDay, now); // is potentially in progress if the now is equal-to or after the start time.
@@ -5961,13 +6205,13 @@ function dateCellTimingRelativeIndexArrayFactory(indexFactory) {
     const inputAsArray = util.asArray(input);
     const result = [];
     inputAsArray.forEach(value => {
-      var _a;
       let resultIndexes;
       if (typeof value === 'object' && !util.isDate(value)) {
         if (isDateRange(value)) {
           resultIndexes = util.range(indexFactory(value.start), indexFactory(value.end) + 1);
         } else {
-          resultIndexes = util.range(value.i, ((_a = value.to) !== null && _a !== void 0 ? _a : value.i) + 1);
+          var _value$to;
+          resultIndexes = util.range(value.i, ((_value$to = value.to) != null ? _value$to : value.i) + 1);
         }
       } else {
         resultIndexes = [indexFactory(value)];
@@ -6005,7 +6249,7 @@ function dateCellTimingDateFactory(timing) {
     if (util.isDate(input)) {
       return input;
     } else {
-      const now = inputNow !== null && inputNow !== void 0 ? inputNow : new Date();
+      const now = inputNow != null ? inputNow : new Date();
       const nowHours = now.getUTCHours();
       const utcStartDateWithNowTime = new Date(Date.UTC(utcStartDate.getUTCFullYear(), utcStartDate.getUTCMonth(), utcStartDate.getUTCDate(), nowHours, now.getUTCMinutes(), now.getUTCSeconds(), now.getUTCMilliseconds()));
       // if the current hours are less than the UTC offset hours, then bump one extra day forward to be sure we're in the correct day.
@@ -6304,7 +6548,7 @@ function modifyDateCellsToFitRangeFunction(range) {
       const asRange = dateCellRangeWithRange(x);
       const rangesOverlap = overlapsRange(asRange);
       if (rangesOverlap) {
-        result = Object.assign(Object.assign({}, x), {
+        result = Object.assign({}, x, {
           i: Math.max(i, asRange.i),
           to: Math.min(to, asRange.to) // should be no larger than to
         });
@@ -6419,7 +6663,7 @@ function yearWeekCode(dateOrYear, inputWeek) {
  * @returns
  */
 function yearWeekCodeFactory(config) {
-  const normal = yearWeekCodeDateTimezoneInstance(config === null || config === void 0 ? void 0 : config.timezone);
+  const normal = yearWeekCodeDateTimezoneInstance(config == null ? void 0 : config.timezone);
   const result = (dateOrYear, inputWeek) => {
     let pair;
     if (isDate(dateOrYear)) {
@@ -6522,7 +6766,7 @@ function yearWeekCodeForCalendarMonthFactory(factory = yearWeekCodeFactory()) {
  * @returns
  */
 function yearWeekCodeDateFactory(config) {
-  const normal = yearWeekCodeDateTimezoneInstance(config === null || config === void 0 ? void 0 : config.timezone);
+  const normal = yearWeekCodeDateTimezoneInstance(config == null ? void 0 : config.timezone);
   return yearWeekCode => {
     const pair = yearWeekCodePair(yearWeekCode);
     const utcYearDate = new Date(Date.UTC(pair.year, 0, 1, 0, 0, 0, 0));
@@ -6831,7 +7075,7 @@ function rawDateCellScheduleDayCodes(input) {
  * @returns
  */
 function dateCellScheduleDayCodeFactory(config) {
-  const normal = yearWeekCodeDateTimezoneInstance(config === null || config === void 0 ? void 0 : config.timezone);
+  const normal = yearWeekCodeDateTimezoneInstance(config == null ? void 0 : config.timezone);
   return date => {
     const target = normal.systemDateToTargetDate(date);
     const day = dateFns.getDay(target);
@@ -6864,15 +7108,18 @@ function isDateCellSchedule(input) {
   return false;
 }
 function isSameDateCellSchedule(a, b) {
-  var _a, _b, _c, _d;
   if (a && b) {
-    return a.w === b.w && util.iterablesAreSetEquivalent((_a = a.ex) !== null && _a !== void 0 ? _a : [], (_b = b.ex) !== null && _b !== void 0 ? _b : []) && util.iterablesAreSetEquivalent((_c = a.d) !== null && _c !== void 0 ? _c : [], (_d = b.d) !== null && _d !== void 0 ? _d : []);
+    var _a$ex, _b$ex, _a$d, _b$d;
+    return a.w === b.w && util.iterablesAreSetEquivalent((_a$ex = a.ex) != null ? _a$ex : [], (_b$ex = b.ex) != null ? _b$ex : []) && util.iterablesAreSetEquivalent((_a$d = a.d) != null ? _a$d : [], (_b$d = b.d) != null ? _b$d : []);
   } else {
     return a == b;
   }
 }
 class DateCellSchedule {
   constructor(template) {
+    this.w = void 0;
+    this.d = void 0;
+    this.ex = void 0;
     if (template) {
       this.w = template.w;
       this.d = template.d;
@@ -6950,7 +7197,7 @@ function dateCellScheduleDateRange(input) {
     end: inputEnd,
     timezone: inputTimezone
   } = input;
-  const timezone = inputTimezone !== null && inputTimezone !== void 0 ? inputTimezone : requireCurrentTimezone(); // treat input as the current timezone
+  const timezone = inputTimezone != null ? inputTimezone : requireCurrentTimezone(); // treat input as the current timezone
   const normalInstance = dateTimezoneUtcNormal(timezone);
   let start;
   let end;
@@ -6968,7 +7215,7 @@ function dateCellScheduleDateRange(input) {
     }
   }
   // set the end value
-  end = inputEnd !== null && inputEnd !== void 0 ? inputEnd : dateFns.addMinutes(start, 1); // default the end to one minute after the start
+  end = inputEnd != null ? inputEnd : dateFns.addMinutes(start, 1); // default the end to one minute after the start
   return {
     w,
     ex,
@@ -7083,8 +7330,8 @@ function fullDateCellScheduleRange(input) {
   } else {
     // fill in the blanks for the date range
     const initialDateRange = dateCellScheduleDateRange(dateCellScheduleRange);
-    initialDateRange.startsAt = inputStartsAt !== null && inputStartsAt !== void 0 ? inputStartsAt : initialDateRange.start;
-    initialDateRange.duration = inputDuration !== null && inputDuration !== void 0 ? inputDuration : DEFAULT_FULL_DATE_SCHEDULE_RANGE_DURATION; // copy duration and startsAt
+    initialDateRange.startsAt = inputStartsAt != null ? inputStartsAt : initialDateRange.start;
+    initialDateRange.duration = inputDuration != null ? inputDuration : DEFAULT_FULL_DATE_SCHEDULE_RANGE_DURATION; // copy duration and startsAt
     initialFullDateRange = initialDateRange;
     if (isDateCellScheduleStartOfDayDateRange(dateCellScheduleRange)) {
       const startOfLastDay = initialFullDateRange.end;
@@ -7098,8 +7345,8 @@ function fullDateCellScheduleRange(input) {
     fullDateCellTiming = updateDateCellTimingWithDateCellTimingEvent({
       timing: initialFullDateRange,
       event: {
-        startsAt: inputDefaultStartsAtTime !== null && inputDefaultStartsAtTime !== void 0 ? inputDefaultStartsAtTime : initialFullDateRange.startsAt,
-        duration: inputDefaultDuration !== null && inputDefaultDuration !== void 0 ? inputDefaultDuration : initialFullDateRange.duration
+        startsAt: inputDefaultStartsAtTime != null ? inputDefaultStartsAtTime : initialFullDateRange.startsAt,
+        duration: inputDefaultDuration != null ? inputDefaultDuration : initialFullDateRange.duration
       },
       // flag to replace the necessary items
       replaceStartsAt: needsStartsAtAdjustment,
@@ -7148,10 +7395,10 @@ function dateCellScheduleDateFilter(config) {
     setStartAsMinDate = true,
     minMaxDateRange
   } = config;
-  const timezone = inputTimezone !== null && inputTimezone !== void 0 ? inputTimezone : requireCurrentTimezone(); // if the timezone is not provided, assume the startsAt is a system timezone normal.
+  const timezone = inputTimezone != null ? inputTimezone : requireCurrentTimezone(); // if the timezone is not provided, assume the startsAt is a system timezone normal.
   const normalInstance = dateTimezoneUtcNormal(timezone);
   // derive the startsAt time for the range. If not provided, defaults to inputStart, or midnight today in the target timezone.
-  const startsAt = inputStartsAt != null ? inputStartsAt : inputStart !== null && inputStart !== void 0 ? inputStart : normalInstance.startOfDayInTargetTimezone();
+  const startsAt = inputStartsAt != null ? inputStartsAt : inputStart != null ? inputStart : normalInstance.startOfDayInTargetTimezone();
   const allowedDays = expandDateCellScheduleDayCodesToDayOfWeekSet(w);
   const startsAtInSystem = normalInstance.systemDateToTargetDate(startsAt); // convert to the system date
   const firstDateDay = dateFns.getDay(startsAtInSystem);
@@ -7173,8 +7420,8 @@ function dateCellScheduleDateFilter(config) {
     end = expectedFinalStartsAt;
   }
   const indexFloor = setStartAsMinDate ? 0 : Number.MIN_SAFE_INTEGER;
-  const minAllowedIndex = (minMaxDateRange === null || minMaxDateRange === void 0 ? void 0 : minMaxDateRange.start) != null ? Math.max(indexFloor, _dateCellTimingRelativeIndexFactory(minMaxDateRange.start)) : indexFloor; // start date should be the min inde
-  const maxAllowedIndex = end != null ? _dateCellTimingRelativeIndexFactory(end) : (minMaxDateRange === null || minMaxDateRange === void 0 ? void 0 : minMaxDateRange.end) != null ? _dateCellTimingRelativeIndexFactory(minMaxDateRange.end) : Number.MAX_SAFE_INTEGER; // max "to" value
+  const minAllowedIndex = (minMaxDateRange == null ? void 0 : minMaxDateRange.start) != null ? Math.max(indexFloor, _dateCellTimingRelativeIndexFactory(minMaxDateRange.start)) : indexFloor; // start date should be the min inde
+  const maxAllowedIndex = end != null ? _dateCellTimingRelativeIndexFactory(end) : (minMaxDateRange == null ? void 0 : minMaxDateRange.end) != null ? _dateCellTimingRelativeIndexFactory(minMaxDateRange.end) : Number.MAX_SAFE_INTEGER; // max "to" value
   const includedIndexes = new Set(config.d);
   const excludedIndexes = new Set(config.ex);
   const fn = input => {
@@ -7337,7 +7584,7 @@ function expandDateCellScheduleRange(input) {
     startsAtTime,
     updateWithDefaults: true
   });
-  return expandDateCellSchedule(Object.assign(Object.assign({}, input), {
+  return expandDateCellSchedule(Object.assign({}, input, {
     schedule: fullDateRange,
     timing: fullDateRange
   }));
@@ -7369,7 +7616,7 @@ function IsValidDateCellTiming(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isValidDateCellTiming,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args === null || args === void 0 ? void 0 : args.value)}" is not a valid DateCellTiming.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args == null ? void 0 : args.value)}" is not a valid DateCellTiming.`, validationOptions)
       }
     });
   };
@@ -7386,7 +7633,7 @@ function IsValidDateCellRange(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isValidDateCellRange,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args === null || args === void 0 ? void 0 : args.value)}" is not a valid DateCellRange.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args == null ? void 0 : args.value)}" is not a valid DateCellRange.`, validationOptions)
       }
     });
   };
@@ -7403,7 +7650,7 @@ function IsValidDateCellRangeSeries(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isValidDateCellRangeSeries,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args === null || args === void 0 ? void 0 : args.value)}" is not a valid DateCellRange series. Items must be sorted in ascending order and have no repeat indexes.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args == null ? void 0 : args.value)}" is not a valid DateCellRange series. Items must be sorted in ascending order and have no repeat indexes.`, validationOptions)
       }
     });
   };
@@ -7437,7 +7684,7 @@ class CalendarDate extends DateDurationSpan {
 }
 __decorate([classTransformer.Expose(), classValidator.IsEnum(exports.CalendarDateType), __metadata("design:type", String)], CalendarDate.prototype, "type", void 0);
 function calendarDateFactory(config) {
-  const normalConfig = (config === null || config === void 0 ? void 0 : config.timezone) === undefined ? {
+  const normalConfig = (config == null ? void 0 : config.timezone) === undefined ? {
     useSystemTimezone: true
   } : {
     timezone: config.timezone ? config.timezone : undefined
@@ -7472,58 +7719,6 @@ class DateSet extends util.HashSet {
   }
 }
 
-const DATE_TODAY_START_VALUE = 'today_start';
-const DATE_TODAY_END_VALUE = 'today_end';
-const DATE_WEEK_START_VALUE = 'this_week_start';
-const DATE_WEEK_END_VALUE = 'this_week_end';
-function logicalDateStringCodeDateFactory(logicalDateStringCode) {
-  let mapFn;
-  switch (logicalDateStringCode.toLocaleLowerCase()) {
-    case util.DATE_NOW_VALUE:
-      mapFn = util.mapIdentityFunction();
-      break;
-    case DATE_TODAY_START_VALUE:
-      mapFn = dateFns.startOfDay;
-      break;
-    case DATE_TODAY_END_VALUE:
-      mapFn = dateFns.endOfDay;
-      break;
-    case DATE_WEEK_START_VALUE:
-      mapFn = dateFns.startOfWeek;
-      break;
-    case DATE_WEEK_END_VALUE:
-      mapFn = dateFns.endOfWeek;
-      break;
-    default:
-      throw new Error(`Unknown logical date string "${logicalDateStringCode}"`);
-  }
-  return (now = new Date()) => mapFn(now);
-}
-function dateFromLogicalDate(logicalDate, now = new Date()) {
-  let result;
-  if (typeof logicalDate === 'string') {
-    result = logicalDateStringCodeDateFactory(logicalDate)(now);
-  } else {
-    result = logicalDate;
-  }
-  return result;
-}
-function isLogicalDateStringCode(logicalDate) {
-  let isLogicalDateStringCode = false;
-  if (typeof logicalDate === 'string') {
-    switch (logicalDate.toLocaleLowerCase()) {
-      case util.DATE_NOW_VALUE:
-      case DATE_TODAY_START_VALUE:
-      case DATE_TODAY_END_VALUE:
-      case DATE_WEEK_START_VALUE:
-      case DATE_WEEK_END_VALUE:
-        isLogicalDateStringCode = true;
-        break;
-    }
-  }
-  return isLogicalDateStringCode;
-}
-
 function dateOrDayStringRangeToDateRange(range) {
   return {
     start: toJsDayDate(range.start),
@@ -7544,7 +7739,7 @@ function roundDateTimeDownToSteps(date, round) {
     roundToSteps = true
   } = round;
   if (roundToSteps) {
-    date = roundToMinuteSteps(date, step !== null && step !== void 0 ? step : 1);
+    date = roundToMinuteSteps(date, step != null ? step : 1);
   }
   return roundDateTimeDown(date, round);
 }
@@ -7555,13 +7750,13 @@ function roundDateTimeDown(date, round) {
   } = round;
   let rounding = {};
   if (roundDownToMinute) {
-    rounding = Object.assign(Object.assign({}, rounding), {
+    rounding = Object.assign({}, rounding, {
       seconds: 0,
       milliseconds: 0
     });
   }
   if (roundDownToDay) {
-    rounding = Object.assign(Object.assign({}, rounding), {
+    rounding = Object.assign({}, rounding, {
       hours: 0,
       minutes: 0
     });
@@ -7608,7 +7803,7 @@ function dateInterval(config) {
   if (!logicalDate && !inputFactory) {
     logicalDate = 'now';
   }
-  const intervalPeriod = period !== null && period !== void 0 ? period : util.MS_IN_SECOND;
+  const intervalPeriod = period != null ? period : util.MS_IN_SECOND;
   const factory = inputFactory ? inputFactory : util.protectedFactory(logicalDateStringCodeDateFactory(logicalDate));
   let obs = rxjs.interval(intervalPeriod, scheduler).pipe(rxjs.startWith(-1), rxjs.map(factory));
   if (emitAll !== true) {
@@ -7635,13 +7830,13 @@ function nowInterval(period) {
  */
 class LimitDateTimeInstance {
   constructor(config = {}) {
+    this.config = void 0;
     this.config = config;
   }
   get instant() {
     return this.config.instant || 'now';
   }
   get minimumMinutesIntoFuture() {
-    var _a;
     const {
       limits = {}
     } = this.config;
@@ -7650,7 +7845,8 @@ class LimitDateTimeInstance {
     } = limits;
     let minutes;
     if (future) {
-      minutes = (_a = future.minutes) !== null && _a !== void 0 ? _a : 0;
+      var _future$minutes;
+      minutes = (_future$minutes = future.minutes) != null ? _future$minutes : 0;
       if (future.hours) {
         minutes += Math.floor(future.hours * 60);
       }
@@ -7676,7 +7872,7 @@ class LimitDateTimeInstance {
         limit = util.DATE_NOW_VALUE;
       } else if (future) {
         const minimumMinutesIntoFuture = this.minimumMinutesIntoFuture;
-        limit = dateFns.addMinutes(instant, minimumMinutesIntoFuture !== null && minimumMinutesIntoFuture !== void 0 ? minimumMinutesIntoFuture : 0);
+        limit = dateFns.addMinutes(instant, minimumMinutesIntoFuture != null ? minimumMinutesIntoFuture : 0);
       }
     }
     return limit;
@@ -7723,12 +7919,12 @@ class LimitDateTimeInstance {
    * Clamps the input date to the current range.
    */
   clamp(date) {
-    var _a;
     let result = date;
     const dateRange = this.dateRange();
     result = clampDateToDateRange(date, dateRange);
     if (this.config.takeNextUpcomingTime) {
-      result = takeNextUpcomingTime(result, (_a = this.config.roundDownToMinute) !== null && _a !== void 0 ? _a : false);
+      var _this$config$roundDow;
+      result = takeNextUpcomingTime(result, (_this$config$roundDow = this.config.roundDownToMinute) != null ? _this$config$roundDow : false);
     } else if (this.config.roundDownToMinute) {
       result = roundDownToMinute(result);
     }
@@ -7749,10 +7945,15 @@ function limitDateTimeInstance(config) {
  */
 class DateTimeMinuteInstance {
   constructor(config = {}, dateOverride) {
-    var _a;
+    var _config$step;
+    this.config = void 0;
+    this._date = void 0;
+    this._step = void 0;
+    this._limit = void 0;
+    this._dateFilter = void 0;
     this.config = config;
     this._date = (dateOverride == undefined ? config.date : dateOverride) || new Date();
-    this._step = (_a = config.step) !== null && _a !== void 0 ? _a : 1;
+    this._step = (_config$step = config.step) != null ? _config$step : 1;
     this._limit = new LimitDateTimeInstance(config);
     this._dateFilter = config.schedule ? dateCellScheduleDateFilter(config.schedule) : undefined;
   }
@@ -7868,9 +8069,9 @@ class DateTimeMinuteInstance {
   }
 
   round(round) {
-    var _a;
-    let date = roundDateTimeDownToSteps(this.date, Object.assign(Object.assign({}, round), {
-      step: (_a = round.step) !== null && _a !== void 0 ? _a : this.step
+    var _round$step;
+    let date = roundDateTimeDownToSteps(this.date, Object.assign({}, round, {
+      step: (_round$step = round.step) != null ? _round$step : this.step
     }));
     if (round.roundToBound) {
       date = this._takeBoundedDate(date);
@@ -7884,6 +8085,7 @@ class DateTimeMinuteInstance {
     return this._limit.clamp(date);
   }
   clampToSchedule(date = this.date, maxClampDistance = 370) {
+    var _nextAvailableDate;
     let nextAvailableDate;
     if (this._dateFilter != null) {
       const maxLimitedDateRange = this._limit.dateRange();
@@ -7920,7 +8122,7 @@ class DateTimeMinuteInstance {
         }
       }
     }
-    return nextAvailableDate !== null && nextAvailableDate !== void 0 ? nextAvailableDate : date;
+    return (_nextAvailableDate = nextAvailableDate) != null ? _nextAvailableDate : date;
   }
   findNextAvailableDayInSchedule(date, direction, maxDistance = 370) {
     let nextAvailableDate;
@@ -7945,8 +8147,8 @@ class DateTimeMinuteInstance {
     return this._takeMaximumBoundedDate(this._takeMinimumBoundedDate(date));
   }
   _takeMinimumBoundedDate(date = this.date) {
-    var _a;
-    if (((_a = this.config.behavior) === null || _a === void 0 ? void 0 : _a.capToMinLimit) !== false) {
+    var _this$config$behavior;
+    if (((_this$config$behavior = this.config.behavior) == null ? void 0 : _this$config$behavior.capToMinLimit) !== false) {
       const min = dateFromLogicalDate(this._limit.min);
       if (min && dateFns.isBefore(date, min)) {
         date = min;
@@ -7955,8 +8157,8 @@ class DateTimeMinuteInstance {
     return date;
   }
   _takeMaximumBoundedDate(date = this.date) {
-    var _a;
-    if (((_a = this.config.behavior) === null || _a === void 0 ? void 0 : _a.capToMaxLimit) !== false) {
+    var _this$config$behavior2;
+    if (((_this$config$behavior2 = this.config.behavior) == null ? void 0 : _this$config$behavior2.capToMaxLimit) !== false) {
       const max = dateFromLogicalDate(this._limit.max);
       if (max && dateFns.isAfter(date, max)) {
         date = max;
@@ -8311,17 +8513,18 @@ class DateTimeUtilityInstance {
    * If the timezone is not defined, it defaults to UTC.
    */
   constructor(timezone) {
+    this.normalInstance = void 0;
     this.normalInstance = new DateTimezoneUtcNormalInstance(timezone);
   }
   get timezone() {
     return this.normalInstance.configuredTimezoneString;
   }
   getTimeAM(date = new Date(), timezone) {
-    const am = dateFnsTz.formatInTimeZone(date, timezone !== null && timezone !== void 0 ? timezone : this.timezone, 'a');
+    const am = dateFnsTz.formatInTimeZone(date, timezone != null ? timezone : this.timezone, 'a');
     return am;
   }
   toTimeString(date, timezone) {
-    return dateFnsTz.formatInTimeZone(date, timezone !== null && timezone !== void 0 ? timezone : this.timezone, `h:mma`);
+    return dateFnsTz.formatInTimeZone(date, timezone != null ? timezone : this.timezone, `h:mma`);
   }
   parseTimeString(input, config) {
     const timestringResult = this._timeStringToDate(input, config);
@@ -8471,13 +8674,13 @@ class DateTimeUtilityInstance {
     return output;
   }
   _normalizeInstanceForConfig(config) {
-    var _a;
     let instance;
     if (isSameDateTimezoneConversionConfig(this.normalInstance.config, config)) {
       instance = this.normalInstance;
     } else {
-      instance = new DateTimezoneUtcNormalInstance(Object.assign(Object.assign({}, config), {
-        timezone: (_a = config.timezone) !== null && _a !== void 0 ? _a : this.normalInstance.config.timezone
+      var _config$timezone;
+      instance = new DateTimezoneUtcNormalInstance(Object.assign({}, config, {
+        timezone: (_config$timezone = config.timezone) != null ? _config$timezone : this.normalInstance.config.timezone
       }));
     }
     return instance;
@@ -8487,7 +8690,7 @@ function dateTimeInstanceUtc() {
   return dateTimeInstance(util.UTC_TIMEZONE_STRING);
 }
 function dateTimeInstance(timezone) {
-  return new DateTimeUtilityInstance(timezone !== null && timezone !== void 0 ? timezone : util.UTC_TIMEZONE_STRING);
+  return new DateTimeUtilityInstance(timezone != null ? timezone : util.UTC_TIMEZONE_STRING);
 }
 function getTimeAM(date = new Date(), timezone) {
   return dateTimeInstance(timezone).getTimeAM(date);
@@ -8514,10 +8717,10 @@ function toReadableTimeString(date, timezone) {
  * @returns
  */
 function parseReadableTimeString(input, config) {
-  return dateTimeInstance(config === null || config === void 0 ? void 0 : config.timezone).parseTimeString(input, config);
+  return dateTimeInstance(config == null ? void 0 : config.timezone).parseTimeString(input, config);
 }
 function readableTimeStringToDate(input, config) {
-  return dateTimeInstance(config === null || config === void 0 ? void 0 : config.timezone).timeStringToDate(input, config);
+  return dateTimeInstance(config == null ? void 0 : config.timezone).timeStringToDate(input, config);
 }
 // MARK: Limits
 function limitDateTime(config) {
@@ -8618,8 +8821,8 @@ function hasExpired(expires) {
  * Returns the expiration date, or a date 1 minute in the past if not defined.
  */
 function getExpiration(expires) {
-  var _a;
-  return (_a = expires === null || expires === void 0 ? void 0 : expires.expiresAt) !== null && _a !== void 0 ? _a : dateFns.addMinutes(new Date(), -1);
+  var _expires$expiresAt;
+  return (_expires$expiresAt = expires == null ? void 0 : expires.expiresAt) != null ? _expires$expiresAt : dateFns.addMinutes(new Date(), -1);
 }
 
 /**
@@ -8684,7 +8887,7 @@ function makeDateQueryForDateItemRangeFilter(find) {
   const result = {};
   result.timezone = find.timezone;
   // Apply the timezone to the date range if provided.
-  const range = find.timezone ? Object.assign(Object.assign({}, find.range), {
+  const range = find.timezone ? Object.assign({}, find.range, {
     date: dateFnsTz.utcToZonedTime(find.range.date, find.timezone)
   }) : find.range;
   const dates = dateRange(range);
@@ -8709,28 +8912,29 @@ function makeDateQueryForDateItemRangeFilter(find) {
   return result;
 }
 function makeDateQueryForDateStartsEndsFilter(find) {
-  var _a, _b;
   const result = {};
   result.timezone = find.timezone;
   if (find.starts) {
+    var _result$startsGte;
     const {
       before,
       after,
       at: equals
     } = find.starts;
-    result.startsGte = after !== null && after !== void 0 ? after : equals;
-    result.startsLte = before !== null && before !== void 0 ? before : equals;
-    result.rStart = (_a = result.startsGte) !== null && _a !== void 0 ? _a : result.startsLte;
+    result.startsGte = after != null ? after : equals;
+    result.startsLte = before != null ? before : equals;
+    result.rStart = (_result$startsGte = result.startsGte) != null ? _result$startsGte : result.startsLte;
   }
   if (find.ends) {
+    var _result$endsGte;
     const {
       before,
       after,
       at: equals
     } = find.ends;
-    result.endsGte = after !== null && after !== void 0 ? after : equals;
-    result.endsLte = before !== null && before !== void 0 ? before : equals;
-    result.rEnd = (_b = result.endsGte) !== null && _b !== void 0 ? _b : result.endsLte;
+    result.endsGte = after != null ? after : equals;
+    result.endsLte = before != null ? before : equals;
+    result.rEnd = (_result$endsGte = result.endsGte) != null ? _result$endsGte : result.endsLte;
   }
   return result;
 }
@@ -8769,10 +8973,10 @@ function makeDaysAndTimeFiltersFunction(builder) {
 }
 
 function mergeMongoDBLikeRangeFilters(startsAt, endsAt) {
-  var _a, _b;
+  var _startsAt$$lte, _endsAt$$gte;
   return {
-    $lte: (_a = startsAt === null || startsAt === void 0 ? void 0 : startsAt.$lte) !== null && _a !== void 0 ? _a : endsAt === null || endsAt === void 0 ? void 0 : endsAt.$lte,
-    $gte: (_b = endsAt === null || endsAt === void 0 ? void 0 : endsAt.$gte) !== null && _b !== void 0 ? _b : startsAt === null || startsAt === void 0 ? void 0 : startsAt.$gte
+    $lte: (_startsAt$$lte = startsAt == null ? void 0 : startsAt.$lte) != null ? _startsAt$$lte : endsAt == null ? void 0 : endsAt.$lte,
+    $gte: (_endsAt$$gte = endsAt == null ? void 0 : endsAt.$gte) != null ? _endsAt$$gte : startsAt == null ? void 0 : startsAt.$gte
   };
 }
 function makeMongoDBLikeDateQueryBuilder(config) {
@@ -8783,9 +8987,9 @@ function makeMongoDBLikeDateQueryBuilder(config) {
     makeRangeFilter(gte, lte) {
       let result;
       if (gte || lte) {
-        result = Object.assign(Object.assign({}, gte ? {
+        result = Object.assign({}, gte ? {
           $gte: gte
-        } : undefined), lte ? {
+        } : undefined, lte ? {
           $lte: lte
         } : undefined);
       }
@@ -8812,7 +9016,7 @@ function makeMongoDBLikeDateQueryBuilder(config) {
           [fields.end]: endsAt
         } : undefined;
       }
-      const filter = Object.assign(Object.assign({}, startsAtFilter), endsAtFilter);
+      const filter = Object.assign({}, startsAtFilter, endsAtFilter);
       return filter;
     }
   };
@@ -8871,8 +9075,9 @@ class BaseRRuleIter {
 class LastIterResult extends BaseRRuleIter {
   constructor(maxIterationsAllowed = DEFAULT_LAST_ITER_RESULT_MAX_ITERATIONS_ALLOWED) {
     super();
-    this.maxIterationsAllowed = maxIterationsAllowed;
+    this.maxIterationsAllowed = void 0;
     this.maxDate = maxFutureDate();
+    this.maxIterationsAllowed = maxIterationsAllowed;
   }
   accept(date) {
     ++this.total;
@@ -8896,9 +9101,12 @@ class LastIterResult extends BaseRRuleIter {
 class NextIterResult extends BaseRRuleIter {
   constructor(minDate, maxIterationsAllowed = DEFAULT_LAST_ITER_RESULT_MAX_ITERATIONS_ALLOWED) {
     super();
+    this.minDate = void 0;
+    this.maxIterationsAllowed = void 0;
+    this.maxDate = void 0;
     this.minDate = minDate;
     this.maxIterationsAllowed = maxIterationsAllowed;
-    this.maxDate = this.minDate;
+    this.maxDate = minDate;
   }
   accept(date) {
     this.total += 1;
@@ -8921,14 +9129,15 @@ class NextIterResult extends BaseRRuleIter {
 }
 class AnyIterResult extends BaseRRuleIter {
   constructor(filter, maxIterationsAllowed = DEFAULT_LAST_ITER_RESULT_MAX_ITERATIONS_ALLOWED) {
-    var _a, _b;
     super();
-    this.maxIterationsAllowed = maxIterationsAllowed;
+    this.maxIterationsAllowed = void 0;
     this.minDate = null;
     this.maxDate = null;
+    this.maxIterationsAllowed = maxIterationsAllowed;
     if (filter) {
-      this.minDate = (_a = filter.minDate) !== null && _a !== void 0 ? _a : null;
-      this.maxDate = (_b = filter.maxDate) !== null && _b !== void 0 ? _b : null;
+      var _filter$minDate, _filter$maxDate;
+      this.minDate = (_filter$minDate = filter.minDate) != null ? _filter$minDate : null;
+      this.maxDate = (_filter$maxDate = filter.maxDate) != null ? _filter$maxDate : null;
     }
   }
   accept(date) {
@@ -9056,8 +9265,8 @@ class DateRRuleParseUtility {
     return DateRRuleParseUtility.parseExdateAttributeFromProperty(property);
   }
   static parseExdateAttributeFromProperty(property) {
-    var _a;
-    const timezone = (_a = property.params.find(x => x.key === 'TZID')) === null || _a === void 0 ? void 0 : _a.value;
+    var _property$params$find;
+    const timezone = (_property$params$find = property.params.find(x => x.key === 'TZID')) == null ? void 0 : _property$params$find.value;
     const rawDates = property.values.split(',');
     const conversion = new DateTimezoneUtcNormalInstance({
       timezone
@@ -9158,20 +9367,22 @@ class DateRRuleInstance {
    * Creates a new DateRRuleInstance from the input.
    */
   static make(params) {
-    var _a, _b;
+    var _params$rruleStringLi, _params$options$exclu;
     if (!(params.rruleLines || params.rruleStringLineSet)) {
       throw new Error('Missing rruleLines or rruleStringLineSet input.');
     }
-    const rruleStringLineSet = (_a = params.rruleStringLineSet) !== null && _a !== void 0 ? _a : DateRRuleParseUtility.toRRuleStringSet(params.rruleLines);
+    const rruleStringLineSet = (_params$rruleStringLi = params.rruleStringLineSet) != null ? _params$rruleStringLi : DateRRuleParseUtility.toRRuleStringSet(params.rruleLines);
     const rruleOptions = DateRRuleUtility.toRRuleOptions(rruleStringLineSet);
-    const exclude = rruleOptions.exdates.addAll((_b = params.options.exclude) === null || _b === void 0 ? void 0 : _b.valuesArray());
+    const exclude = rruleOptions.exdates.addAll((_params$options$exclu = params.options.exclude) == null ? void 0 : _params$options$exclu.valuesArray());
     const rrule = new DateRRule(rruleOptions.options);
-    return new DateRRuleInstance(rrule, Object.assign(Object.assign({}, params.options), {
+    return new DateRRuleInstance(rrule, Object.assign({}, params.options, {
       exclude
     }));
   }
   constructor(rrule, options) {
-    var _a, _b;
+    this.options = void 0;
+    this.rrule = void 0;
+    this.normalInstance = void 0;
     this.options = options;
     const tzid = rrule.origOptions.tzid;
     let dtstart = rrule.origOptions.dtstart;
@@ -9182,17 +9393,19 @@ class DateRRuleInstance {
      */
     this.normalInstance = new DateTimezoneUtcNormalInstance(timezone);
     if (dtstart && tzid) ; else if (timezone) {
-      const startsAt = (_a = options.date) === null || _a === void 0 ? void 0 : _a.startsAt;
+      var _options$date;
+      const startsAt = (_options$date = options.date) == null ? void 0 : _options$date.startsAt;
       // If startsAt is provided, need to change it to start from the base UTC date, if any timezone is provided.
       if (startsAt) {
         const baseStartDate = this.normalInstance.baseDateToTargetDate(startsAt);
         dtstart = baseStartDate;
       }
     } else {
+      var _dtstart, _options$date2;
       // If start date is provided without a timezone, assume timezone is UTC. Do nothing.
-      dtstart = dtstart !== null && dtstart !== void 0 ? dtstart : (_b = options.date) === null || _b === void 0 ? void 0 : _b.startsAt;
+      dtstart = (_dtstart = dtstart) != null ? _dtstart : (_options$date2 = options.date) == null ? void 0 : _options$date2.startsAt;
     }
-    const rruleOptions = Object.assign(Object.assign({}, rrule.origOptions), {
+    const rruleOptions = Object.assign({}, rrule.origOptions, {
       tzid: undefined,
       dtstart
     });
@@ -9237,13 +9450,13 @@ class DateRRuleInstance {
       startsAtDates = this.rrule.all();
     }
     const referenceDate = this.options.date;
-    const allDates = startsAtDates.map(startsAt => Object.assign(Object.assign({}, referenceDate), {
+    const allDates = startsAtDates.map(startsAt => Object.assign({}, referenceDate, {
       startsAt
     })); // Inherit calendar time, etc.
     let dates = allDates;
     // Fix Dates w/ Timezones
     if (this.normalInstance.hasConversion) {
-      dates = dates.map(x => Object.assign(Object.assign({}, x), {
+      dates = dates.map(x => Object.assign({}, x, {
         startsAt: this.normalInstance.targetDateToBaseDate(x.startsAt)
       }));
     }
@@ -9287,7 +9500,7 @@ class DateRRuleInstance {
         end = this.rrule.last();
       }
       const referenceDate = this.options.date;
-      const finalRecurrenceDateRange = durationSpanToDateRange(Object.assign(Object.assign({}, referenceDate), {
+      const finalRecurrenceDateRange = durationSpanToDateRange(Object.assign({}, referenceDate, {
         startsAt: end
       }));
       finalRecurrenceEndsAt = finalRecurrenceDateRange.end;
@@ -9316,11 +9529,11 @@ class DateRRuleUtility {
    * Creates the expansion item results based on the input.
    */
   static expand(options) {
-    var _a;
+    var _options$instance;
     if (!options.instance && !options.instanceFrom) {
       throw new Error('Rrules be defined for expansion.');
     }
-    const dateRrule = (_a = options.instance) !== null && _a !== void 0 ? _a : DateRRuleInstance.make(options.instanceFrom);
+    const dateRrule = (_options$instance = options.instance) != null ? _options$instance : DateRRuleInstance.make(options.instanceFrom);
     return dateRrule.expand(options);
   }
   static makeInstance(params) {
@@ -9331,7 +9544,7 @@ class DateRRuleUtility {
     const rules = DateRRuleParseUtility.separateRRuleStringSetValues(rruleStringLineSet);
     const lines = DateRRuleParseUtility.toRRuleLines(rules.basic);
     const ruleOptions = rrule.RRule.parseString(lines);
-    return Object.assign(Object.assign({}, rules), {
+    return Object.assign({}, rules, {
       options: ruleOptions
     });
   }
@@ -9342,6 +9555,28 @@ class DateRRuleUtility {
  */
 exports.ModelRecurrenceInfo = class ModelRecurrenceInfo {
   constructor(template) {
+    /**
+     * Timezone the rule is a part of.
+     *
+     * Required for RRules that have timezone-sensitive implementations.
+     */
+    this.timezone = void 0;
+    /**
+     * RRules for this recurrence.
+     */
+    this.rrule = void 0;
+    /**
+     * First instance of the recurrence.
+     */
+    this.start = void 0;
+    /**
+     * Final instance of the recurrence.
+     */
+    this.end = void 0;
+    /**
+     * True if the recurrence has no end.
+     */
+    this.forever = void 0;
     if (template != null) {
       this.timezone = template.timezone;
       this.rrule = template.rrule;
@@ -9365,7 +9600,7 @@ class ModelRecurrenceInfoUtility {
    * Creates a ModelRecurrenceInfo instance from the input ModelRecurrenceStart.
    */
   static expandModelRecurrenceStartToModelRecurrenceInfo(update) {
-    var _a;
+    var _dates$finalRecurrenc;
     const {
       date,
       rrule,
@@ -9383,7 +9618,7 @@ class ModelRecurrenceInfoUtility {
       timezone,
       rrule: rruleSetString,
       start: dates.start,
-      end: (_a = dates.finalRecurrenceEndsAt) !== null && _a !== void 0 ? _a : dates.end,
+      end: (_dates$finalRecurrenc = dates.finalRecurrenceEndsAt) != null ? _dates$finalRecurrenc : dates.end,
       forever: dates.forever
     };
     return new exports.ModelRecurrenceInfo(recurrenceInfo);
@@ -9709,14 +9944,19 @@ exports.readDaysOfWeekNames = readDaysOfWeekNames;
 exports.readableTimeStringToDate = readableTimeStringToDate;
 exports.reduceDatesFunction = reduceDatesFunction;
 exports.requireCurrentTimezone = requireCurrentTimezone;
+exports.roundDateDownTo = roundDateDownTo;
 exports.roundDateTimeDown = roundDateTimeDown;
 exports.roundDateTimeDownToSteps = roundDateTimeDownToSteps;
+exports.roundDateTo = roundDateTo;
+exports.roundDateToDate = roundDateToDate;
+exports.roundDateToUnixDateTimeNumber = roundDateToUnixDateTimeNumber;
 exports.roundDownToHour = roundDownToHour;
 exports.roundDownToMinute = roundDownToMinute;
 exports.roundToMinuteSteps = roundToMinuteSteps;
 exports.safeFormatToISO8601DateString = safeFormatToISO8601DateString;
 exports.safeToJsDate = safeToJsDate;
 exports.searchTimezoneInfos = searchTimezoneInfos;
+exports.setOnDateWithTimezoneNormalFunction = setOnDateWithTimezoneNormalFunction;
 exports.shiftDateCellTimingToSystemTimezone = shiftDateCellTimingToSystemTimezone;
 exports.shiftDateCellTimingToTimezone = shiftDateCellTimingToTimezone;
 exports.shiftDateCellTimingToTimezoneFunction = shiftDateCellTimingToTimezoneFunction;