@dereekb/date 9.25.16 → 10.0.0

package/src/lib/date/date.block.js

@@ -1,1849 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dateBlockIndexRangeToDateBlockRange = exports.dateBlockRangeToDateBlockIndexRange = exports.dateBlockDayTimingInfoFactory = exports.dateBlocksExpansionFactory = exports.expandDateBlocks = exports.expandDateBlockCollection = exports.dateBlockDayOfWeekFactory = exports.isValidDateBlockTiming = exports.isValidDateBlockTimingInfo = exports.dateBlockTimingInTimezone = exports.dateBlockTimingInTimezoneFunction = exports.dateBlockTiming = exports.getRelativeDateForDateBlockTiming = exports.dateBlockTimingStartsAtDateFactory = exports.dateBlockTimingStartDateFactory = exports.dateBlockTimingDateFactory = exports.dateRelativeStateForDateBlockRangeComparedToIndex = exports.getNextDateBlockTimingIndex = exports.getRelativeIndexForDateBlockTiming = exports.dateBlockTimingRelativeIndexArrayFactory = exports.dateBlockTimingRelativeIndexFactory = exports.isDateBlockTimingRelativeIndexFactory = exports.isValidDateBlockTimingStartDate = exports.getCurrentDateBlockTimingStartDate = exports.dateBlockTimingStartForNowInTimezone = exports.dateBlockTimingStartForNowInSystemTimezone = exports.changeTimingToSystemTimezone = exports.changeTimingToTimezone = exports.changeTimingToTimezoneFunction = exports.dateBlockTimingFromDateBlockTimingStartEndDayDateRange = exports.safeDateBlockTimingFromDateRangeAndEvent = exports.dateBlockTimingFromDateRangeAndEvent = exports.assertedTimingDateTimezoneUtcNormal = exports.timingDateTimezoneUtcNormal = exports.getDateBlockTimingHoursInEvent = exports.getDateBlockTimingFirstEventDateRange = exports.timingIsInExpectedTimezone = exports.timingIsInExpectedTimezoneFunction = exports.getCurrentDateBlockTimingOffset = exports.getCurrentDateBlockTimingOffsetData = exports.getCurrentDateBlockTimingUtcData = exports.dateBlockTimingEventRange = exports.dateBlockTimingFullRange = exports.isSameDateBlockTiming = exports.DateBlockTiming = exports.MIN_DATE_BLOCK_TIMING_OFFSET_HOURS = exports.MAX_DATE_BLOCK_TIMING_OFFSET_HOURS = exports.dateBlock = exports.DateBlock = exports.isValidDateBlockIndex = void 0;
-exports.getRelativeIndexForDateTiming = exports.dateTimingRelativeIndexArrayFactory = exports.dateTimingRelativeIndexFactory = exports.isDateTimingRelativeIndexFactory = exports.dateBlocksDayInfoFactory = exports.dateBlockRangeContainsDateBlock = exports.dateBlockIsWithinDateBlockRangeFunction = exports.dateBlocksInDateBlockRange = exports.modifyDateBlockToFitRange = exports.modifyDateBlocksToFitRange = exports.modifyDateBlocksToFitRangeFunction = exports.expandUniqueDateBlocksFunction = exports.groupUniqueDateBlocks = exports.dateBlockEndIndex = exports.dateBlockRangeHasRange = exports.expandDateBlockRange = exports.dateBlockRangesFullyCoverDateBlockRangeFunction = exports.dateBlockRangeBlocksCount = exports.dateBlockRangeBlocksCountInfo = exports.allIndexesInDateBlockRanges = exports.allIndexesInDateBlockRange = exports.groupToDateBlockRanges = exports.sortDateBlockRanges = exports.sortDateBlockRangeAndSizeFunction = exports.dateBlockRangeOverlapsRange = exports.dateBlockRangeOverlapsRangeFunction = exports.dateBlockRangeIncludedByRangeFunction = exports.dateBlockRangeWithRange = exports.dateBlockRangeWithRangeFromIndex = exports.dateBlockRange = exports.getLeastAndGreatestDateBlockIndexInDateBlockRanges = exports.getGreatestDateBlockIndexInDateBlockRanges = exports.getLeastDateBlockIndexInDateBlockRanges = exports.isValidDateBlockRangeSeries = exports.isValidDateBlockRange = exports.DateBlockRange = exports.isDateWithinDateBlockRangeFunction = exports.isDateBlockWithinDateBlockRange = exports.isDateBlockWithinDateBlockRangeFunction = exports.filterDateBlocksInDateBlockRange = exports.dateBlockIndexRange = void 0;
-const tslib_1 = require("tslib");
-const util_1 = require("@dereekb/util");
-const date_range_1 = require("./date.range");
-const date_duration_1 = require("./date.duration");
-const date_fns_1 = require("date-fns");
-const date_1 = require("./date");
-const class_transformer_1 = require("class-transformer");
-const date_timezone_1 = require("./date.timezone");
-const class_validator_1 = require("class-validator");
-const date_format_1 = require("./date.format");
-const date_range_timezone_1 = require("./date.range.timezone");
-/**
- * Returns true if the index is a non-negative integer.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- */
-function isValidDateBlockIndex(input) {
-    return input >= 0 && Number.isInteger(input);
-}
-exports.isValidDateBlockIndex = isValidDateBlockIndex;
-class DateBlock {
-    constructor(template) {
-        if (template) {
-            this.i = template.i;
-        }
-    }
-}
-tslib_1.__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsNumber)(),
-    (0, class_validator_1.Min)(0),
-    tslib_1.__metadata("design:type", Number)
-], DateBlock.prototype, "i", void 0);
-exports.DateBlock = DateBlock;
-/**
- * Converts the input number or DateBlock to a DateBlock.
- *
- * @deprecated use DateCell implementation instead.
- * @param dateBlockOrIndex
- * @returns
- */
-function dateBlock(dateBlockOrIndex) {
-    return typeof dateBlockOrIndex === 'number' ? { i: dateBlockOrIndex } : dateBlockOrIndex;
-}
-exports.dateBlock = dateBlock;
-/**
- * The maximum number of hours that a DateBlockTiming's start can be offset. This means a max timezone of UTC+12.
- *
- * The timezones UTC+13 and UTC+14 are not supported, and will experience undetermined behavior.
- *
- * @deprecated use DateCell implementation instead.
- */
-exports.MAX_DATE_BLOCK_TIMING_OFFSET_HOURS = 12;
-/**
- * The minimum number of hours that a DateBlockTiming's start can be offset. This means a min timezone of UTC-12.
- *
- * @deprecated use DateCell implementation instead.
- */
-exports.MIN_DATE_BLOCK_TIMING_OFFSET_HOURS = -12;
-class DateBlockTiming extends date_duration_1.DateDurationSpan {
-    constructor(template) {
-        super(template);
-        if (template) {
-            this.start = template.start;
-            this.end = template.end;
-        }
-    }
-}
-tslib_1.__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsDate)(),
-    (0, class_transformer_1.Type)(() => Date),
-    tslib_1.__metadata("design:type", Date)
-], DateBlockTiming.prototype, "start", void 0);
-tslib_1.__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsDate)(),
-    (0, class_transformer_1.Type)(() => Date),
-    tslib_1.__metadata("design:type", Date)
-], DateBlockTiming.prototype, "end", void 0);
-tslib_1.__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsOptional)(),
-    tslib_1.__metadata("design:type", String)
-], DateBlockTiming.prototype, "timezone", void 0);
-exports.DateBlockTiming = DateBlockTiming;
-/**
- * Returns true if the two timings are equivalent.
- *
- * @deprecated use DateCell implementation instead.
- * @param a
- * @param b
- */
-function isSameDateBlockTiming(a, b) {
-    return a && b ? a.duration === b.duration && (0, date_1.isSameDate)(a.start, b.start) && (0, date_1.isSameDate)(a.startsAt, b.startsAt) && (0, date_1.isSameDate)(a.end, b.end) : a == b;
-}
-exports.isSameDateBlockTiming = isSameDateBlockTiming;
-/**
- * Returns the date range from the start of the first event to the end time of the last event.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function dateBlockTimingFullRange(timing) {
-    return { start: timing.start, end: timing.end };
-}
-exports.dateBlockTimingFullRange = dateBlockTimingFullRange;
-/**
- * Returns the date range from the start of the first event to the end time of the last event.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function dateBlockTimingEventRange(timing) {
-    return { start: timing.startsAt, end: timing.end };
-}
-exports.dateBlockTimingEventRange = dateBlockTimingEventRange;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function getCurrentDateBlockTimingUtcData(timing) {
-    const start = timing.start;
-    const dateHours = start.getUTCHours();
-    // if it is a positive offset, then the date is in the future so we subtract the offset from 24 hours to get the proper offset.
-    const originalUtcOffsetInHours = dateHours >= exports.MAX_DATE_BLOCK_TIMING_OFFSET_HOURS ? util_1.HOURS_IN_DAY - dateHours : -dateHours;
-    const originalUtcDate = (0, date_fns_1.addHours)(start, originalUtcOffsetInHours); // convert to original UTC
-    return {
-        originalUtcDate,
-        originalUtcOffsetInHours
-    };
-}
-exports.getCurrentDateBlockTimingUtcData = getCurrentDateBlockTimingUtcData;
-/**
- * The offset in milliseconds to the "real start date", the first second in the target day on in the system timezone.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- */
-function getCurrentDateBlockTimingOffsetData(timing) {
-    const { originalUtcOffsetInHours, originalUtcDate } = getCurrentDateBlockTimingUtcData(timing);
-    const currentTimezoneOffsetInHours = (0, date_timezone_1.getCurrentSystemOffsetInHours)(originalUtcDate); // get the offset as it is on that day
-    // calculate the true offset
-    let offset = originalUtcOffsetInHours - currentTimezoneOffsetInHours;
-    if (offset === -util_1.HOURS_IN_DAY) {
-        offset = 0; // auckland can return -24 for itself
-    }
-    return {
-        originalUtcDate,
-        originalUtcOffsetInHours,
-        offset: (0, date_fns_1.hoursToMilliseconds)(offset),
-        currentTimezoneOffsetInHours
-    };
-}
-exports.getCurrentDateBlockTimingOffsetData = getCurrentDateBlockTimingOffsetData;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function getCurrentDateBlockTimingOffset(timing) {
-    return getCurrentDateBlockTimingOffsetData(timing).offset;
-}
-exports.getCurrentDateBlockTimingOffset = getCurrentDateBlockTimingOffset;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timezone
- * @returns
- */
-function timingIsInExpectedTimezoneFunction(timezone) {
-    const normal = (0, date_timezone_1.dateTimezoneUtcNormal)(timezone);
-    return (timing) => {
-        const { start } = timing;
-        const offset = normal.systemDateToTargetDateOffset(start);
-        const expectedTimingOffset = getCurrentDateBlockTimingOffsetData(timing);
-        return offset === expectedTimingOffset.offset;
-    };
-}
-exports.timingIsInExpectedTimezoneFunction = timingIsInExpectedTimezoneFunction;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @param timezone
- * @returns
- */
-function timingIsInExpectedTimezone(timing, timezone) {
-    return timingIsInExpectedTimezoneFunction(timezone)(timing);
-}
-exports.timingIsInExpectedTimezone = timingIsInExpectedTimezone;
-/**
- * Returns the total minutes between the start of the first event and the end of the last event.
- *
- * @param timing
- * @returns
- */
-function getDateBlockTimingFirstEventDateRange(timing) {
-    return (0, date_range_timezone_1.fitDateRangeToDayPeriod)({ start: timing.startsAt, end: timing.end });
-}
-exports.getDateBlockTimingFirstEventDateRange = getDateBlockTimingFirstEventDateRange;
-/**
- * Returns the fractional hours in the event.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function getDateBlockTimingHoursInEvent(timing) {
-    const dateRange = getDateBlockTimingFirstEventDateRange(timing);
-    return (0, util_1.minutesToFractionalHours)((0, date_fns_1.differenceInMinutes)(dateRange.end, dateRange.start));
-}
-exports.getDateBlockTimingHoursInEvent = getDateBlockTimingHoursInEvent;
-/**
- * Creates a DateTimezoneUtcNormalInstance from the input.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function timingDateTimezoneUtcNormal(input) {
-    const timezoneNormalInput = (0, date_range_1.isDateRangeStart)(input) ? (0, date_fns_1.hoursToMilliseconds)(getCurrentDateBlockTimingUtcData(input).originalUtcOffsetInHours) : input;
-    const timezoneInstance = (0, date_timezone_1.dateTimezoneUtcNormal)(timezoneNormalInput);
-    return timezoneInstance;
-}
-exports.timingDateTimezoneUtcNormal = timingDateTimezoneUtcNormal;
-/**
- * Convenience function that extends timingDateTimezoneUtcNormal() but also asserts the that the timing matches it.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @param timing
- * @returns
- */
-function assertedTimingDateTimezoneUtcNormal(input, timing) {
-    const timezoneInstance = timingDateTimezoneUtcNormal(input);
-    if (!timingIsInExpectedTimezone(timing, timezoneInstance)) {
-        throw new Error(`assertedTimingDateTimezoneUtcNormal() failed to expected to match with the timing.`);
-    }
-    return timezoneInstance;
-}
-exports.assertedTimingDateTimezoneUtcNormal = assertedTimingDateTimezoneUtcNormal;
-function dateBlockTimingFromDateRangeAndEvent(dateBlockTimingStartEndRange, event) {
-    const { start, end } = dateBlockTimingStartEndRange;
-    const { startsAt: eventStartsAt, duration } = event;
-    // need the timezone instance to compute against the normal and convert to the system time, before going back.
-    // this is necessary because the start is a timezone normal for UTC, and the minutes need to be converted back properly adjusting for timezones.
-    const timezoneInstance = timingDateTimezoneUtcNormal(dateBlockTimingStartEndRange);
-    // compute startsAt, the start time for the first event
-    const startsAt = (0, date_timezone_1.copyHoursAndMinutesFromDateWithTimezoneNormal)(start, eventStartsAt, timezoneInstance);
-    const timing = {
-        start,
-        end,
-        startsAt,
-        duration
-    };
-    return timing;
-}
-exports.dateBlockTimingFromDateRangeAndEvent = dateBlockTimingFromDateRangeAndEvent;
-function safeDateBlockTimingFromDateRangeAndEvent(dateBlockTimingStartEndRange, event, timezone) {
-    const { start, end } = dateBlockTimingStartEndRange;
-    const timezoneInstance = assertedTimingDateTimezoneUtcNormal(timezone !== null && timezone !== void 0 ? timezone : dateBlockTimingStartEndRange, dateBlockTimingStartEndRange);
-    // const startDayFactory = dateBlockTimingStartDateFactory({ start }, timezoneInstance);
-    const endDay = end; // get midnight of the day the job usually ends at
-    const endDayDateRange = { start, endDay };
-    return _dateBlockTimingFromDateBlockTimingStartEndDayDateRange(endDayDateRange, event, timezoneInstance);
-}
-exports.safeDateBlockTimingFromDateRangeAndEvent = safeDateBlockTimingFromDateRangeAndEvent;
-/**
- * Converts a DateBlockTimingStartEndDayDateRange and DateBlockTimingEvent to a DateBlockTiming. The event is used to derive the startsAt, duration and end time. The timezone offset is retained.
- *
- * @deprecated use DateCell implementation instead.
- * @param dateBlockTimingStartEndDayDateRange
- * @param event
- * @returns
- */
-function dateBlockTimingFromDateBlockTimingStartEndDayDateRange(dateBlockTimingStartEndDayDateRange, event, timezone) {
-    // need the timezone instance to compute against the normal and convert to the system time, before going back.
-    // this is necessary because the start is a timezone normal for UTC, and the minutes need to be converted back properly adjusting for timezones.
-    const timezoneInstance = assertedTimingDateTimezoneUtcNormal(timezone !== null && timezone !== void 0 ? timezone : dateBlockTimingStartEndDayDateRange, dateBlockTimingStartEndDayDateRange);
-    return _dateBlockTimingFromDateBlockTimingStartEndDayDateRange(dateBlockTimingStartEndDayDateRange, event, timezoneInstance);
-}
-exports.dateBlockTimingFromDateBlockTimingStartEndDayDateRange = dateBlockTimingFromDateBlockTimingStartEndDayDateRange;
-/**
- * Internal function that allows safeDateBlockTimingFromDateRangeAndEvent() and dateBlockTimingFromDateBlockTimingStartEndDayDateRange()
- * to pass their timezone instances to this function, without having to create a new instance.
- *
- * See dateBlockTimingFromDateBlockTimingStartEndDayDateRange() for details.
- *
- * @deprecated use DateCell implementation instead.
- * @param dateBlockTimingStartEndDayDateRange
- * @param event
- * @param timezoneInstance
- * @returns
- */
-function _dateBlockTimingFromDateBlockTimingStartEndDayDateRange(dateBlockTimingStartEndDayDateRange, event, timezoneInstance) {
-    const { start, endDay } = dateBlockTimingStartEndDayDateRange;
-    const { startsAt: eventStartsAt, duration } = event;
-    // compute startsAt, the start time for the first event
-    const startsAt = (0, date_timezone_1.copyHoursAndMinutesFromDateWithTimezoneNormal)(start, eventStartsAt, timezoneInstance);
-    // compute end, the end time for the last event using the last day
-    const lastDayStartsAt = dateBlockTimingStartsAtDateFactory({ start, startsAt }, timezoneInstance)(endDay);
-    const end = (0, date_fns_1.addMinutes)(lastDayStartsAt, duration);
-    const timing = {
-        start,
-        end,
-        startsAt,
-        duration
-    };
-    // console.log({ timezoneInstance, startsAt, eventStartsAt, lastDayStartsAt, dateBlockTimingStartEndDayDateRange, event, timing });
-    return timing;
-}
-/**
- * Creates a ChangeTimingToTimezoneFunction from the input.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function changeTimingToTimezoneFunction(input) {
-    const timezoneInstance = timingDateTimezoneUtcNormal(input);
-    const fn = ((timing) => {
-        const baseTimingOffset = getCurrentDateBlockTimingUtcData(timing);
-        const startInUtc = baseTimingOffset.originalUtcDate;
-        const start = timezoneInstance.targetDateToBaseDate(startInUtc);
-        const newTiming = Object.assign(Object.assign({}, timing), { start });
-        return newTiming;
-    });
-    fn._timezoneInstance = timezoneInstance;
-    return fn;
-}
-exports.changeTimingToTimezoneFunction = changeTimingToTimezoneFunction;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @param timezone
- * @returns
- */
-function changeTimingToTimezone(timing, timezone) {
-    return changeTimingToTimezoneFunction(timezone)(timing);
-}
-exports.changeTimingToTimezone = changeTimingToTimezone;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function changeTimingToSystemTimezone(timing) {
-    return changeTimingToTimezoneFunction(date_timezone_1.SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE)(timing);
-}
-exports.changeTimingToSystemTimezone = changeTimingToSystemTimezone;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @returns
- */
-function dateBlockTimingStartForNowInSystemTimezone() {
-    return {
-        start: (0, date_fns_1.startOfDay)(new Date())
-    };
-}
-exports.dateBlockTimingStartForNowInSystemTimezone = dateBlockTimingStartForNowInSystemTimezone;
-/**
- * Creates a DateBlockTimingStart for now in the given timezone.
- *
- * @param timezoneInput
- * @returns
- */
-function dateBlockTimingStartForNowInTimezone(timezoneInput) {
-    const dateBlockTimingStartSystemTimezone = dateBlockTimingStartForNowInSystemTimezone();
-    return changeTimingToTimezone(dateBlockTimingStartSystemTimezone, timezoneInput);
-}
-exports.dateBlockTimingStartForNowInTimezone = dateBlockTimingStartForNowInTimezone;
-/**
- * Returns the start date in the current/system timezone for the given date.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- */
-function getCurrentDateBlockTimingStartDate(timing) {
-    const offset = getCurrentDateBlockTimingOffset(timing);
-    return (0, date_fns_1.addMilliseconds)(timing.start, offset);
-}
-exports.getCurrentDateBlockTimingStartDate = getCurrentDateBlockTimingStartDate;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param date
- * @returns
- */
-function isValidDateBlockTimingStartDate(date) {
-    return (0, date_fns_1.getMinutes)(date) === 0 && (0, date_fns_1.getSeconds)(date) === 0 && (0, date_fns_1.getMilliseconds)(date) === 0;
-}
-exports.isValidDateBlockTimingStartDate = isValidDateBlockTimingStartDate;
-/**
- * Returns true if the input is a DateBlockTimingRelativeIndexFactory.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function isDateBlockTimingRelativeIndexFactory(input) {
-    return typeof input === 'function' && input._timing != null && input._timingOffsetData != null;
-}
-exports.isDateBlockTimingRelativeIndexFactory = isDateBlockTimingRelativeIndexFactory;
-/**
- * Creates a DateBlockTimingRelativeIndexFactory from the input.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function dateBlockTimingRelativeIndexFactory(input) {
-    if (isDateBlockTimingRelativeIndexFactory(input)) {
-        return input;
-    }
-    else {
-        const timing = input;
-        const offsetData = getCurrentDateBlockTimingOffsetData(timing);
-        const { originalUtcOffsetInHours: toUtcOffset, currentTimezoneOffsetInHours, originalUtcDate: originalUtcDateInSystemTimeNormal } = offsetData;
-        const baseOffsetInHours = currentTimezoneOffsetInHours;
-        const factory = ((input) => {
-            const inputType = typeof input;
-            if (inputType === 'number') {
-                return input;
-            }
-            else if (inputType === 'string') {
-                const startOfDayInUtc = (0, date_format_1.parseISO8601DayStringToUTCDate)(input); // convert to system timezone
-                const diff = (0, date_fns_1.differenceInHours)(startOfDayInUtc, originalUtcDateInSystemTimeNormal, { roundingMethod: 'floor' }); // compare the system times. Round down.
-                const daysOffset = Math.floor(diff / util_1.HOURS_IN_DAY); // total number of hours difference from the original UTC date
-                return daysOffset ? daysOffset : 0; // do not return -0
-            }
-            else {
-                const inputDateTimezoneOffset = input.getTimezoneOffset(); // get current system timezone offset
-                const offsetDifferenceHours = baseOffsetInHours + (0, date_fns_1.minutesToHours)(inputDateTimezoneOffset); // handle timezone offset changes
-                const baseDiff = (0, date_fns_1.differenceInHours)(input, originalUtcDateInSystemTimeNormal, { roundingMethod: 'floor' }); // compare the difference in system times. Round down.
-                const diff = baseDiff + toUtcOffset - offsetDifferenceHours; // apply any timezone changes, then back to UTC for comparison
-                const daysOffset = Math.floor(diff / util_1.HOURS_IN_DAY); // total number of hours difference from the original UTC date
-                return daysOffset ? daysOffset : 0; // do not return -0
-            }
-        });
-        factory._timing = timing;
-        factory._timingOffsetData = offsetData;
-        return factory;
-    }
-}
-exports.dateBlockTimingRelativeIndexFactory = dateBlockTimingRelativeIndexFactory;
-/**
- * Creates a DateBlockTimingRelativeIndexArrayFactory from the input DateBlockTimingRelativeIndexFactory.
- *
- * @deprecated use DateCell implementation instead.
- * @param indexFactory
- */
-function dateBlockTimingRelativeIndexArrayFactory(indexFactory) {
-    const factory = ((input) => {
-        const inputAsArray = (0, util_1.asArray)(input);
-        const result = [];
-        inputAsArray.forEach((value) => {
-            var _a;
-            let resultIndexes;
-            if (typeof value === 'object' && !(0, date_1.isDate)(value)) {
-                if ((0, date_range_1.isDateRange)(value)) {
-                    resultIndexes = (0, util_1.range)(indexFactory(value.start), indexFactory(value.end) + 1);
-                }
-                else {
-                    resultIndexes = (0, util_1.range)(value.i, ((_a = value.to) !== null && _a !== void 0 ? _a : value.i) + 1);
-                }
-            }
-            else {
-                resultIndexes = [indexFactory(value)];
-            }
-            (0, util_1.mergeArrayIntoArray)(result, resultIndexes);
-        });
-        return result;
-    });
-    factory._indexFactory = indexFactory;
-    return factory;
-}
-exports.dateBlockTimingRelativeIndexArrayFactory = dateBlockTimingRelativeIndexArrayFactory;
-/**
- * Gets the relative index of the input date compared to the input timing.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @param date
- */
-function getRelativeIndexForDateBlockTiming(timing, date = new Date()) {
-    return dateBlockTimingRelativeIndexFactory(timing)(date);
-}
-exports.getRelativeIndexForDateBlockTiming = getRelativeIndexForDateBlockTiming;
-/**
- * Computes a GetNextDateBlockTimingIndexResult from the input.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- */
-function getNextDateBlockTimingIndex(input) {
-    var _a, _b, _c;
-    const { ranges, currentIndex } = input;
-    const relativeStateGroups = (0, util_1.makeValuesGroupMap)((0, util_1.asArray)(ranges), (range) => {
-        return dateRelativeStateForDateBlockRangeComparedToIndex(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 currentResult = presentResults[0];
-    let nextResult;
-    let nextIndex = currentIndex + 1;
-    const nextResultFromPresent = presentResults.find((x) => dateRelativeStateForDateBlockRangeComparedToIndex(x, nextIndex) === 'present');
-    if (nextResultFromPresent) {
-        nextResult = nextResultFromPresent;
-    }
-    else {
-        // search through the future indexes, looking for the one with the lowest index.
-        const greatestAndLeastIndexResult = getLeastAndGreatestDateBlockIndexInDateBlockRanges(futureResults);
-        if (greatestAndLeastIndexResult) {
-            nextIndex = greatestAndLeastIndexResult.leastIndex;
-            nextResult = greatestAndLeastIndexResult.leastIndexItem;
-        }
-        else {
-            nextIndex = undefined;
-        }
-    }
-    return {
-        currentResult,
-        nextIndex,
-        nextResult,
-        pastResults,
-        presentResults,
-        futureResults
-    };
-}
-exports.getNextDateBlockTimingIndex = getNextDateBlockTimingIndex;
-/**
- * Returns the DateRelativeState for the given index and range.
- *
- * @deprecated use DateCell implementation instead.
- * @param nowIndex
- * @param range
- */
-function dateRelativeStateForDateBlockRangeComparedToIndex(range, nowIndex) {
-    const { i, to } = dateBlockRange(range.i, range.to);
-    let state;
-    if (i > nowIndex) {
-        state = 'future'; // if i greater, then the range is in the future.
-    }
-    else if (to < nowIndex) {
-        state = 'past'; // if i is less than or equal, and to is less than i, then it is in the past
-    }
-    else {
-        state = 'present';
-    }
-    return state;
-}
-exports.dateRelativeStateForDateBlockRangeComparedToIndex = dateRelativeStateForDateBlockRangeComparedToIndex;
-/**
- * Creates a DateBlockTimingDateFactory.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function dateBlockTimingDateFactory(timing) {
-    const offsetData = getCurrentDateBlockTimingOffsetData(timing);
-    const utcStartDate = offsetData.originalUtcDate;
-    const factory = ((input) => {
-        if ((0, date_1.isDate)(input)) {
-            return input;
-        }
-        else {
-            const now = 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.
-            if (timing.start.getUTCHours() > nowHours) {
-                input += 1;
-            }
-            const nowWithDateForIndex = (0, date_fns_1.addHours)(utcStartDateWithNowTime, input * util_1.HOURS_IN_DAY);
-            return nowWithDateForIndex;
-        }
-    });
-    factory._timing = timing;
-    return factory;
-}
-exports.dateBlockTimingDateFactory = dateBlockTimingDateFactory;
-/**
- * Creates a DateBlockTimingDateFactory. The timezone is required to properly compute the accurate startsAt date for locations that experience daylight savings.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function dateBlockTimingStartDateFactory(input, timezone) {
-    const indexFactory = dateBlockTimingRelativeIndexFactory(input);
-    const timezoneInstance = timingDateTimezoneUtcNormal(timezone);
-    if (timezoneInstance.config.assertTimingMatchesTimezone !== false && !timingIsInExpectedTimezone(indexFactory._timing, timezoneInstance)) {
-        throw new Error(`unexpected timezone "${timezone}" for start date "${indexFactory._timing.start}" for dateBlockTimingStartDateFactory(). Is expected to match the timezones.`);
-    }
-    const { start: baseTimingStart } = indexFactory._timing;
-    const baseStart = timezoneInstance.baseDateToTargetDate(baseTimingStart);
-    const factory = ((input) => {
-        const index = indexFactory(input); // get the index
-        const startInUtc = (0, date_fns_1.addHours)(baseStart, index * util_1.HOURS_IN_DAY);
-        return timezoneInstance.targetDateToBaseDate(startInUtc);
-    });
-    factory._indexFactory = indexFactory;
-    return factory;
-}
-exports.dateBlockTimingStartDateFactory = dateBlockTimingStartDateFactory;
-function dateBlockTimingStartsAtDateFactory(input, timezone) {
-    const indexFactory = dateBlockTimingRelativeIndexFactory(input);
-    const { start, startsAt: baseTimingStartsAt } = indexFactory._timing;
-    const timezoneInstance = timingDateTimezoneUtcNormal(timezone !== null && timezone !== void 0 ? timezone : { start });
-    if (timezoneInstance.config.assertTimingMatchesTimezone !== false && !timingIsInExpectedTimezone(indexFactory._timing, timezoneInstance)) {
-        throw new Error(`unexpected timezone "${timezone}" for start date "${indexFactory._timing.start}" for dateBlockTimingStartsAtDateFactory(). Is expected to match the timezones.`);
-    }
-    const baseStartsAtInUtc = timezoneInstance.baseDateToTargetDate(baseTimingStartsAt);
-    const factory = ((input) => {
-        const index = indexFactory(input); // get the index
-        const startAtInUtc = (0, date_fns_1.addHours)(baseStartsAtInUtc, index * util_1.HOURS_IN_DAY);
-        return timezoneInstance.targetDateToBaseDate(startAtInUtc);
-    });
-    factory._indexFactory = indexFactory;
-    return factory;
-}
-exports.dateBlockTimingStartsAtDateFactory = dateBlockTimingStartsAtDateFactory;
-/**
- * Returns the date of the input index.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @param date
- */
-function getRelativeDateForDateBlockTiming(timing, input) {
-    return dateBlockTimingDateFactory(timing)(input);
-}
-exports.getRelativeDateForDateBlockTiming = getRelativeDateForDateBlockTiming;
-/**
- * Creates a valid DateBlock timing from the DateDurationSpan and range input.
- *
- * The duration is first considered, then the date range is applied to it.
- *
- * If a number is passed as the input range, then the duration's startsAt date will be used and the input number used as the distance.
- * The input range's date takes priority over the duration's startsAt start date, meaning the input date range will be adapted
- * to fit the startsAt time.
- *
- * The input range date is used as the start and end date ranges, meaning they will be used as the expected date offset (have only hours, no minutes/seconds/milliseconds) and be validated as such.
- * The end date is used just to determine the number of days, but a minimum of 1 day is always enforced as a DateBlockTiming must contain atleast 1 day.
- *
- * The start date from the inputDate is considered to to have the offset noted in DateBlock, and will be retained.
- *
- * @deprecated use DateCell implementation instead.
- */
-function dateBlockTiming(durationInput, inputRange, options) {
-    const { duration } = durationInput;
-    const { timezone: timezoneInput } = options !== null && options !== void 0 ? options : {};
-    const timezoneInstance = timezoneInput ? (0, date_timezone_1.dateTimezoneUtcNormal)(timezoneInput) : undefined;
-    if (duration > util_1.MINUTES_IN_DAY) {
-        throw new Error('dateBlockTiming() duration cannot be longer than 24 hours.');
-    }
-    let { startsAt: inputStartsAt } = durationInput;
-    // it is important that startsAt is evaluated the system time normal, as addDays/addMinutes and related functionality rely on the system timezone.
-    let startsAt = timezoneInstance ? timezoneInstance.systemDateToTargetDate(inputStartsAt) : inputStartsAt;
-    let numberOfBlockedDays;
-    let inputDate;
-    let range;
-    if (typeof inputRange === 'number') {
-        numberOfBlockedDays = inputRange - 1;
-        range = (0, date_range_1.dateRange)({ type: date_range_1.DateRangeType.DAY, date: startsAt });
-    }
-    else if ((0, date_range_1.isDateRange)(inputRange)) {
-        range = inputRange;
-        inputDate = inputRange.start;
-        if (!isValidDateBlockTimingStartDate(inputRange.start)) {
-            throw new Error('Invalid dateBlockTiming start date passed to dateBlockTiming() via inputRange.');
-        }
-        numberOfBlockedDays = (0, date_fns_1.differenceInDays)(inputRange.end, inputRange.start); // min of 1 day
-    }
-    else {
-        inputDate = startsAt; // TODO: May not be needed?
-        numberOfBlockedDays = inputRange.distance - 1;
-        range = (0, date_range_1.dateRange)({ type: date_range_1.DateRangeType.DAY, date: inputDate }, true);
-    }
-    if (inputDate != null) {
-        // input date takes priority, so move the startsAt's date to be on the same date.
-        startsAt = (0, date_1.copyHoursAndMinutesFromDate)(range.start, startsAt, true);
-        const startedBeforeRange = (0, date_fns_1.isBefore)(startsAt, range.start);
-        if (startedBeforeRange) {
-            startsAt = (0, date_fns_1.addDays)(startsAt, 1); // starts 24 hours later
-            numberOfBlockedDays = Math.max(numberOfBlockedDays - 1, 0); // reduce number of applied days by 1, to a min of 0
-        }
-    }
-    else {
-        startsAt = (0, date_1.roundDownToMinute)(startsAt); // clear seconds and milliseconds from startsAt
-        // numberOfBlockedDays = numberOfBlockedDays - 1; // reduce number of applied days by 1
-    }
-    const start = range.start;
-    let lastStart = (0, date_fns_1.addDays)(startsAt, numberOfBlockedDays); // add days so the system can change for daylight savings
-    if (timezoneInstance) {
-        startsAt = timezoneInstance.targetDateToSystemDate(startsAt);
-        lastStart = timezoneInstance.targetDateToSystemDate(lastStart); // may be affected by daylight savings
-    }
-    // calculate end to be the ending date/time of the final duration span
-    const end = (0, date_fns_1.addMinutes)(lastStart, duration);
-    return {
-        start,
-        end,
-        startsAt,
-        duration
-    };
-}
-exports.dateBlockTiming = dateBlockTiming;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function dateBlockTimingInTimezoneFunction(input) {
-    const changeTimezoneFunction = changeTimingToTimezoneFunction(input);
-    const fn = ((durationInput, inputRange) => {
-        const timing = dateBlockTiming(durationInput, inputRange, { timezone: changeTimezoneFunction._timezoneInstance });
-        return changeTimezoneFunction(timing);
-    });
-    fn._timezoneInstance = changeTimezoneFunction._timezoneInstance;
-    return fn;
-}
-exports.dateBlockTimingInTimezoneFunction = dateBlockTimingInTimezoneFunction;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param durationInput
- * @param inputRange
- * @param timezone
- * @returns
- */
-function dateBlockTimingInTimezone(durationInput, inputRange, timezone) {
-    return dateBlockTimingInTimezoneFunction(timezone)(durationInput, inputRange);
-}
-exports.dateBlockTimingInTimezone = dateBlockTimingInTimezone;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function isValidDateBlockTimingInfo(timing) {
-    const { end, start, startsAt, duration, timezone } = timing;
-    const { currentTimezoneOffsetInHours: startOffsetInHours // offset as computed on the given date.
-     } = getCurrentDateBlockTimingOffsetData(timing);
-    const isStartRoundedToSeconds = start.getMilliseconds() === 0; // should have no milliseconds specified
-    const msDifference = (0, date_fns_1.differenceInMilliseconds)(startsAt, start); // startsAt is a specific instance to compare to the midnight instant of the target timezone
-    const endIsAfterTheStartsAtTime = (0, date_fns_1.isAfter)(end, startsAt);
-    const durationLessThan24Hours = duration <= util_1.MINUTES_IN_DAY;
-    const startHasZeroSeconds = start.getSeconds() === 0;
-    const startsAtIsAfterStart = msDifference >= 0;
-    const startsAtIsLessThan24HoursAfterStart = msDifference < util_1.MS_IN_DAY;
-    let isValid = false;
-    let isExpectedValidEnd = false;
-    let isPlausiblyValidEnd = false;
-    let isTimezoneValidatedEnd = false;
-    if (isStartRoundedToSeconds &&
-        endIsAfterTheStartsAtTime && // end must be after the startsAt time
-        durationLessThan24Hours &&
-        startHasZeroSeconds && // start cannot have seconds
-        startsAtIsAfterStart && // startsAt is after start instance, secondsDifference
-        startsAtIsLessThan24HoursAfterStart // startsAt is not 24 hours or more later. If so, should start at that time instead.
-    ) {
-        const endOffset = (0, date_timezone_1.getCurrentSystemOffsetInHours)(timing.end);
-        const timezoneOffsetDelta = endOffset - startOffsetInHours;
-        const expectedFinalStartTime = (0, date_fns_1.addHours)((0, date_fns_1.addMinutes)(end, -duration), timezoneOffsetDelta);
-        const finalMsDifference = (0, date_fns_1.differenceInMilliseconds)(startsAt, expectedFinalStartTime);
-        const hoursDifference = Math.abs((finalMsDifference % util_1.MS_IN_DAY) / util_1.MS_IN_HOUR);
-        const difference = hoursDifference === 23 ? -1 : hoursDifference; // depending on daylight savings, may be off by 1 hour
-        isExpectedValidEnd = difference === 0;
-        isPlausiblyValidEnd = isExpectedValidEnd || Math.abs(difference) === 1;
-        isValid = isPlausiblyValidEnd;
-        if (isPlausiblyValidEnd && timezone) {
-            // TODO: validate properly for the timezone...
-        }
-    }
-    const result = {
-        isValid,
-        isStartRoundedToSeconds,
-        msDifference,
-        endIsAfterTheStartsAtTime,
-        durationLessThan24Hours,
-        startHasZeroSeconds,
-        startsAtIsAfterStart,
-        startsAtIsLessThan24HoursAfterStart,
-        isExpectedValidEnd,
-        isPlausiblyValidEnd
-    };
-    return result;
-}
-exports.isValidDateBlockTimingInfo = isValidDateBlockTimingInfo;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @returns
- */
-function isValidDateBlockTiming(timing) {
-    const { isValid } = isValidDateBlockTimingInfo(timing);
-    return isValid;
-}
-exports.isValidDateBlockTiming = isValidDateBlockTiming;
-/**
- * Creates a DateBlockDayOfWeekFactory
- *
- * @deprecated use DateCell implementation instead.
- * @param dayForIndexZero
- * @returns
- */
-function dateBlockDayOfWeekFactory(inputDayForIndexZero) {
-    const dayForIndexZero = typeof inputDayForIndexZero === 'number' ? inputDayForIndexZero : inputDayForIndexZero.getUTCDay();
-    return (index) => (0, util_1.getNextDay)(dayForIndexZero, index);
-}
-exports.dateBlockDayOfWeekFactory = dateBlockDayOfWeekFactory;
-/**
- * Convenience function for calling expandDateBlocks() with the input DateBlockCollection.
- *
- * @deprecated use DateCell implementation instead.
- * @param collection
- * @returns
- */
-function expandDateBlockCollection(collection) {
-    return expandDateBlocks(collection.timing, collection.blocks);
-}
-exports.expandDateBlockCollection = expandDateBlockCollection;
-/**
- * Convenience function for calling dateBlocksExpansionFactory() then passing the blocks.
- *
- * @deprecated use DateCell implementation instead.
- * @param blocks
- * @param timing
- * @returns
- */
-function expandDateBlocks(timing, blocks) {
-    return dateBlocksExpansionFactory({ timing })(blocks);
-}
-exports.expandDateBlocks = expandDateBlocks;
-/**
- * Creates a DateBlocksExpansionFactory
- *
- * @deprecated use DateCell implementation instead.
- * @param config
- * @returns
- */
-function dateBlocksExpansionFactory(config) {
-    const { timing, rangeLimit, filter: inputFilter, durationSpanFilter: inputDurationSpanFilter, maxDateBlocksToReturn = Number.MAX_SAFE_INTEGER, blocksEvaluationLimit = Number.MAX_SAFE_INTEGER } = config;
-    const { startsAt: baseStart, duration } = timing;
-    const indexRange = rangeLimit !== false ? dateBlockIndexRange(timing, rangeLimit) : { minIndex: Number.MIN_SAFE_INTEGER, maxIndex: Number.MAX_SAFE_INTEGER };
-    const isInRange = (0, util_1.indexRangeCheckFunction)({ indexRange, inclusiveMaxIndex: false });
-    const filter = (0, util_1.mergeFilterFunctions)((x) => isInRange(x.i), inputFilter);
-    const durationSpanFilter = inputDurationSpanFilter !== null && inputDurationSpanFilter !== void 0 ? inputDurationSpanFilter : (() => true);
-    return (input) => {
-        const blocks = Array.isArray(input) ? input : input.blocks;
-        const spans = [];
-        let blocksEvaluated = 0;
-        function filterAndPush(block, blockIndex) {
-            // increase the evaluation count early in-case we set the blocksEvaluationLimit below.
-            blocksEvaluated += 1;
-            if (filter(block, blockIndex)) {
-                const startsAt = (0, date_fns_1.addDays)(baseStart, block.i);
-                const durationSpan = Object.assign(Object.assign({}, block), { startsAt,
-                    duration });
-                // try the duration span filter
-                if (durationSpanFilter(durationSpan, blockIndex)) {
-                    if (spans.length >= maxDateBlocksToReturn) {
-                        blocksEvaluated = blocksEvaluationLimit; // trigger return below
-                    }
-                    else {
-                        spans.push(durationSpan);
-                    }
-                }
-            }
-        }
-        blocks.findIndex((block) => {
-            if (dateBlockRangeHasRange(block)) {
-                // Expands the block's range as if it is at a single index
-                (0, util_1.range)(block.i, block.to + 1).findIndex((i) => {
-                    const blockAtIndex = Object.assign(Object.assign({}, block), { i, to: i }); // copy block, set to as i
-                    filterAndPush(blockAtIndex, blocksEvaluated);
-                    // continue iterating until we hit the evaluation limit.
-                    return blocksEvaluated >= blocksEvaluationLimit;
-                });
-            }
-            else {
-                filterAndPush(block, blocksEvaluated);
-            }
-            return blocksEvaluated >= blocksEvaluationLimit; // continue iterating until we hit the evaluation limit or run out of items.
-        });
-        return spans;
-    };
-}
-exports.dateBlocksExpansionFactory = dateBlocksExpansionFactory;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param config
- * @returns
- */
-function dateBlockDayTimingInfoFactory(config) {
-    const { timing, rangeLimit } = config;
-    const { duration } = timing;
-    const indexRange = rangeLimit !== false ? dateBlockIndexRange(timing, rangeLimit) : { minIndex: Number.MIN_SAFE_INTEGER, maxIndex: Number.MAX_SAFE_INTEGER };
-    const checkIsInRange = (0, util_1.indexRangeCheckFunction)({ indexRange, inclusiveMaxIndex: false });
-    const dayIndexFactory = dateBlockTimingRelativeIndexFactory(timing);
-    const dayFactory = dateBlockTimingDateFactory(timing);
-    const startsAtFactory = dateBlockTimingStartsAtDateFactory(dayIndexFactory);
-    return (input, inputNow) => {
-        const date = typeof input === 'number' ? dayFactory(input) : input;
-        const dayIndex = dayIndexFactory(input);
-        const isInRange = checkIsInRange(dayIndex);
-        const now = inputNow !== null && inputNow !== void 0 ? inputNow : date;
-        const startsAtOnDay = startsAtFactory(dayIndex); // convert back to the proper date
-        const endsAtOnDay = (0, date_fns_1.addMinutes)(startsAtOnDay, duration);
-        const potentiallyInProgress = !(0, date_fns_1.isAfter)(startsAtOnDay, now); // is potentially in progress if the now is equal-to or after the start time.
-        const isInProgress = potentiallyInProgress && !(0, date_fns_1.isAfter)(now, endsAtOnDay);
-        const hasOccuredToday = potentiallyInProgress && !isInProgress;
-        const currentIndex = isInProgress || hasOccuredToday ? dayIndex : dayIndex - 1; // If not in progress and hasn't occured today, current index is the previous index.
-        const nextIndex = currentIndex + 1;
-        const nextIndexInRange = checkIsInRange(nextIndex) ? nextIndex : undefined;
-        const isComplete = currentIndex >= 0 && !nextIndexInRange && (!isInRange || hasOccuredToday);
-        return {
-            now,
-            date,
-            dayIndex,
-            currentIndex,
-            nextIndex,
-            hasOccuredToday,
-            isInProgress,
-            isInRange,
-            startsAtOnDay,
-            endsAtOnDay,
-            nextIndexInRange,
-            isComplete
-        };
-    };
-}
-exports.dateBlockDayTimingInfoFactory = dateBlockDayTimingInfoFactory;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param range
- * @returns
- */
-function dateBlockRangeToDateBlockIndexRange(range) {
-    var _a;
-    return { minIndex: range.i, maxIndex: ((_a = range.to) !== null && _a !== void 0 ? _a : range.i) + 1 };
-}
-exports.dateBlockRangeToDateBlockIndexRange = dateBlockRangeToDateBlockIndexRange;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param range
- * @returns
- */
-function dateBlockIndexRangeToDateBlockRange(range) {
-    return { i: range.minIndex, to: range.maxIndex - 1 };
-}
-exports.dateBlockIndexRangeToDateBlockRange = dateBlockIndexRangeToDateBlockRange;
-/**
- * Generates a DateBlockIndexRange based on the input timing.
- *
- * An arbitrary limit can also be applied.
- *
- * @deprecated use DateCell implementation instead.
- * @param timing
- * @param limit
- * @param fitToTimingRange
- */
-function dateBlockIndexRange(timing, limit, fitToTimingRange = true) {
-    const { start: zeroDate, end: endDate } = timing;
-    let minIndex = 0;
-    let maxIndex = (0, date_fns_1.differenceInDays)(endDate, zeroDate) + 1;
-    if (limit) {
-        const { start, end } = dateBlockTiming(timing, limit);
-        const limitMin = (0, date_fns_1.differenceInDays)(start, zeroDate);
-        const hoursDiff = (0, date_fns_1.differenceInHours)(end, zeroDate) / util_1.HOURS_IN_DAY;
-        const limitMax = Math.ceil(hoursDiff);
-        if (fitToTimingRange) {
-            minIndex = Math.min(limitMin, maxIndex);
-            maxIndex = Math.min(limitMax, maxIndex);
-        }
-        else {
-            minIndex = limitMin;
-            maxIndex = limitMax;
-        }
-    }
-    return { minIndex, maxIndex };
-}
-exports.dateBlockIndexRange = dateBlockIndexRange;
-/**
- * Returns blocks that are only in the given DateBlockRange.
- *
- * @deprecated use DateCell implementation instead.
- * @param blocks
- * @param range
- * @returns
- */
-function filterDateBlocksInDateBlockRange(blocks, range) {
-    const dateBlockIsWithinDateBlockRange = isDateBlockWithinDateBlockRangeFunction(range);
-    return blocks.filter(dateBlockIsWithinDateBlockRange);
-}
-exports.filterDateBlocksInDateBlockRange = filterDateBlocksInDateBlockRange;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param inputRange
- * @returns
- */
-function isDateBlockWithinDateBlockRangeFunction(inputRange) {
-    const range = dateBlockRangeWithRange(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;
-            return to <= range.to;
-        }
-        return false;
-    };
-}
-exports.isDateBlockWithinDateBlockRangeFunction = isDateBlockWithinDateBlockRangeFunction;
-/**
- * Returns true if the first DateBlock or DateBlockRange contains the second input.
- *
- * @deprecated use DateCell implementation instead.
- * @param range
- * @param isContainedWithin
- * @returns
- */
-function isDateBlockWithinDateBlockRange(range, contains) {
-    return isDateBlockWithinDateBlockRangeFunction(range)(dateBlockRangeWithRange(contains));
-}
-exports.isDateBlockWithinDateBlockRange = isDateBlockWithinDateBlockRange;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param config
- * @returns
- */
-function isDateWithinDateBlockRangeFunction(config) {
-    const { start: inputStart, range: inputRange } = config;
-    let start = inputStart;
-    let dateRange;
-    let rangeInput;
-    if (typeof inputRange === 'number') {
-        rangeInput = { i: inputRange };
-    }
-    else if ((0, date_1.isDate)(inputRange)) {
-        dateRange = { start: inputRange };
-    }
-    else if ((0, date_range_1.isDateRangeStart)(inputRange)) {
-        dateRange = inputRange;
-    }
-    else {
-        rangeInput = inputRange;
-    }
-    if (start == null) {
-        if (dateRange) {
-            start = inputRange;
-        }
-        else {
-            throw new Error('Invalid isDateWithinDateBlockRangeFunction() config. Start date could not be determined from input.');
-        }
-    }
-    const indexFactory = dateBlockTimingRelativeIndexFactory({ start });
-    function convertDateRangeToIndexRange(range) {
-        const i = indexFactory(range.start);
-        const end = range.end;
-        const to = end != null ? indexFactory(end) : undefined;
-        return { i, to };
-    }
-    if (!rangeInput) {
-        if (dateRange) {
-            rangeInput = convertDateRangeToIndexRange(dateRange);
-        }
-        else {
-            throw new Error('Invalid isDateWithinDateBlockRangeFunction() config. Range determined from input.'); // shouldn't occur
-        }
-    }
-    const isDateBlockWithinDateBlockRange = isDateBlockWithinDateBlockRangeFunction(rangeInput);
-    return (input) => {
-        let range;
-        if ((0, date_1.isDate)(input)) {
-            range = indexFactory(input);
-        }
-        else if ((0, date_range_1.isDateRangeStart)(input)) {
-            range = convertDateRangeToIndexRange(input);
-        }
-        else {
-            range = input;
-        }
-        if (typeof input === 'number') {
-            range = { i: input };
-        }
-        return isDateBlockWithinDateBlockRange(range);
-    };
-}
-exports.isDateWithinDateBlockRangeFunction = isDateWithinDateBlockRangeFunction;
-/**
- *
- * @deprecated use DateCell implementation instead.
- */
-class DateBlockRange extends DateBlock {
-    constructor(template) {
-        super(template);
-        if (template) {
-            this.to = template.to;
-        }
-    }
-}
-tslib_1.__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsNumber)(),
-    (0, class_validator_1.IsOptional)(),
-    (0, class_validator_1.Min)(0),
-    tslib_1.__metadata("design:type", Number)
-], DateBlockRange.prototype, "to", void 0);
-exports.DateBlockRange = DateBlockRange;
-/**
- * Returns true if the input is a valid DateBlockRange.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function isValidDateBlockRange(input) {
-    const { i, to } = input;
-    if (!isValidDateBlockIndex(i)) {
-        return false;
-    }
-    else if (to != null && (!isValidDateBlockIndex(to) || to < i)) {
-        return false;
-    }
-    return true;
-}
-exports.isValidDateBlockRange = isValidDateBlockRange;
-/**
- * Returns true if the input is a sorted DateBlockRange array and there are no repeat indexes.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function isValidDateBlockRangeSeries(input) {
-    if (!Array.isArray(input)) {
-        return false;
-    }
-    const invalidRange = input.findIndex((range) => !isValidDateBlockRange(range));
-    if (invalidRange !== -1) {
-        return false;
-    }
-    let greatestIndex = -1;
-    for (let i = 0; i < input.length; i += 1) {
-        const range = input[i];
-        if (range.i <= greatestIndex) {
-            return false;
-        }
-        else {
-            const nextGreatestIndex = range.to || range.i; // to is greater than or equal to i in a valid date block range.
-            greatestIndex = nextGreatestIndex;
-        }
-    }
-    return true;
-}
-exports.isValidDateBlockRangeSeries = isValidDateBlockRangeSeries;
-/**
- * Returns the lowest index between all the input date block ranges. Returns 0 by default if there is no minimum or input blocks.
- *
- * The input range is not expected to be sorted.
- *
- * @deprecated use DateCell implementation instead.
- */
-function getLeastDateBlockIndexInDateBlockRanges(input) {
-    var _a, _b;
-    return (_b = (_a = getLeastAndGreatestDateBlockIndexInDateBlockRanges(input)) === null || _a === void 0 ? void 0 : _a.leastIndex) !== null && _b !== void 0 ? _b : 0;
-}
-exports.getLeastDateBlockIndexInDateBlockRanges = getLeastDateBlockIndexInDateBlockRanges;
-/**
- * Returns the largest index between all the input date block ranges. Returns 0 by default.
- *
- * The input range is not expected to be sorted.
- *
- * @deprecated use DateCell implementation instead.
- */
-function getGreatestDateBlockIndexInDateBlockRanges(input) {
-    var _a, _b;
-    return (_b = (_a = getLeastAndGreatestDateBlockIndexInDateBlockRanges(input)) === null || _a === void 0 ? void 0 : _a.greatestIndex) !== null && _b !== void 0 ? _b : 0;
-}
-exports.getGreatestDateBlockIndexInDateBlockRanges = getGreatestDateBlockIndexInDateBlockRanges;
-/**
- * Returns the largest index between all the input date block ranges. Returns null if the input is empty.
- *
- * The input range is not expected to be sorted.
- *
- * @deprecated use DateCell implementation instead.
- */
-function getLeastAndGreatestDateBlockIndexInDateBlockRanges(input) {
-    if (!input.length) {
-        return null;
-    }
-    let leastIndex = Number.MAX_SAFE_INTEGER;
-    let greatestIndex = 0;
-    let leastIndexItem = input[0];
-    let greatestIndexItem = input[0];
-    for (let i = 0; i < input.length; i += 1) {
-        const range = input[i];
-        const leastRangeIndex = range.i;
-        const greatestRangeIndex = range.to || range.i;
-        if (leastRangeIndex < leastIndex) {
-            leastIndex = leastRangeIndex;
-            leastIndexItem = range;
-        }
-        if (greatestRangeIndex > greatestIndex) {
-            greatestIndex = greatestRangeIndex;
-            greatestIndexItem = range;
-        }
-    }
-    return {
-        leastIndex,
-        leastIndexItem,
-        greatestIndex,
-        greatestIndexItem
-    };
-}
-exports.getLeastAndGreatestDateBlockIndexInDateBlockRanges = getLeastAndGreatestDateBlockIndexInDateBlockRanges;
-/**
- * Creates a DateBlockRange
- *
- * @deprecated use DateCell implementation instead.
- * @param i
- * @param to
- * @returns
- */
-function dateBlockRange(i, to) {
-    return { i, to: to !== null && to !== void 0 ? to : i };
-}
-exports.dateBlockRange = dateBlockRange;
-/**
- * Creates a DateBlockRangeWithRange from the input DateBlockIndex.
- *
- * @deprecated use DateCell implementation instead.
- * @param dateBlockIndex
- * @returns
- */
-function dateBlockRangeWithRangeFromIndex(dateBlockIndex) {
-    return dateBlockRange(dateBlockIndex, dateBlockIndex);
-}
-exports.dateBlockRangeWithRangeFromIndex = dateBlockRangeWithRangeFromIndex;
-/**
- * Creates a DateBlockRangeWithRange from the input DateBlockIndex, DateBlock, or DateBlockRange.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function dateBlockRangeWithRange(input) {
-    if (typeof input === 'number') {
-        return dateBlockRangeWithRangeFromIndex(input);
-    }
-    else {
-        return dateBlockRange(input.i, input.to);
-    }
-}
-exports.dateBlockRangeWithRange = dateBlockRangeWithRange;
-/**
- * Creates a DateBlockRangeIncludedByRangeFunction
- *
- * @deprecated use DateCell implementation instead.
- * @param inputRange
- * @returns
- */
-function dateBlockRangeIncludedByRangeFunction(inputRange) {
-    const { i, to } = dateBlockRangeWithRange(inputRange);
-    return (input) => {
-        var _a;
-        const range = dateBlockRangeWithRange(input);
-        return range.i <= i && ((_a = range === null || range === void 0 ? void 0 : range.to) !== null && _a !== void 0 ? _a : range.i) >= to;
-    };
-}
-exports.dateBlockRangeIncludedByRangeFunction = dateBlockRangeIncludedByRangeFunction;
-/**
- * Creates a DateBlockRangeOverlapsRangeFunction
- *
- * @deprecated use DateCell implementation instead.
- * @param inputRange
- * @returns
- */
-function dateBlockRangeOverlapsRangeFunction(inputRange) {
-    const { i, to } = dateBlockRangeWithRange(inputRange);
-    return (input) => {
-        var _a;
-        const range = dateBlockRangeWithRange(input);
-        return range.i <= to && ((_a = range === null || range === void 0 ? void 0 : range.to) !== null && _a !== void 0 ? _a : range.i) >= i;
-    };
-}
-exports.dateBlockRangeOverlapsRangeFunction = dateBlockRangeOverlapsRangeFunction;
-/**
- * Returns true if either of the ranges overlap eachother.
- *
- * @deprecated use DateCell implementation instead.
- * @param rangeA
- * @param rangeB
- * @returns
- */
-function dateBlockRangeOverlapsRange(rangeA, rangeB) {
-    return dateBlockRangeOverlapsRangeFunction(rangeA)(rangeB);
-}
-exports.dateBlockRangeOverlapsRange = dateBlockRangeOverlapsRange;
-/**
- * Sorts the input ranges by index and distance (to values).
- *
- * In many cases sortAscendingIndexNumberRefFunction may be preferential since
- *
- * @deprecated use DateCell implementation instead.
- * @returns
- */
-function sortDateBlockRangeAndSizeFunction() {
-    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); };
-}
-exports.sortDateBlockRangeAndSizeFunction = sortDateBlockRangeAndSizeFunction;
-/**
- * Sorts the input date ranges. This will retain the before/after order while also sorting items by index.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function sortDateBlockRanges(input) {
-    return input.sort((0, util_1.sortAscendingIndexNumberRefFunction)());
-}
-exports.sortDateBlockRanges = sortDateBlockRanges;
-/**
- * Groups the input values into DateBlockRange values.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- */
-function groupToDateBlockRanges(input) {
-    var _a;
-    if (input.length === 0) {
-        return [];
-    }
-    // sort by index in ascending order
-    const blocks = sortDateBlockRanges(input);
-    function newBlockFromBlocksArrayIndex(blocksArrayIndex) {
-        const { i, to } = blocks[blocksArrayIndex];
-        return {
-            i,
-            to: to !== null && to !== void 0 ? to : i
-        };
-    }
-    // start at the first block
-    let current = newBlockFromBlocksArrayIndex(0);
-    const results = [];
-    for (let i = 1; i < blocks.length; i += 1) {
-        const block = blocks[i];
-        const isContinuous = block.i <= current.to + 1;
-        if (isContinuous) {
-            // extend the current block.
-            current.to = (_a = blocks[i].to) !== null && _a !== void 0 ? _a : blocks[i].i;
-        }
-        else {
-            // complete/create new block.
-            results.push(current);
-            current = newBlockFromBlocksArrayIndex(i);
-        }
-    }
-    results.push(current);
-    return results;
-}
-exports.groupToDateBlockRanges = groupToDateBlockRanges;
-/**
- * Returns an array containing all indexes in the date block range.
- *
- * @deprecated use DateCell implementation instead.
- */
-function allIndexesInDateBlockRange(input) {
-    return input.to != null ? (0, util_1.range)(input.i, input.to + 1) : [input.i];
-}
-exports.allIndexesInDateBlockRange = allIndexesInDateBlockRange;
-/**
- * Returns the set of all indexes within the input.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function allIndexesInDateBlockRanges(input) {
-    const set = new Set();
-    input.forEach((x) => {
-        if (typeof x === 'number') {
-            set.add(x);
-        }
-        else {
-            const allIndexes = allIndexesInDateBlockRange(x);
-            (0, util_1.addToSet)(set, allIndexes);
-        }
-    });
-    return set;
-}
-exports.allIndexesInDateBlockRanges = allIndexesInDateBlockRanges;
-/**
- * Counts the number of blocks in the input range.
- *
- * @deprecated use DateCell implementation instead.
- * @param inputDateBlockRange
- * @returns
- */
-function dateBlockRangeBlocksCountInfo(inputDateBlockRange) {
-    const group = groupToDateBlockRanges((0, util_1.asArray)(inputDateBlockRange));
-    let count = 0;
-    let total = 0;
-    group.forEach((x) => {
-        const blocks = Math.abs(x.to - x.i) + 1; // +1 for inclusivity
-        count += blocks;
-        const size = (0, util_1.sumOfIntegersBetween)(x.i, x.to);
-        total += size;
-    });
-    return {
-        count,
-        total,
-        average: count > 0 ? total / count : 0
-    };
-}
-exports.dateBlockRangeBlocksCountInfo = dateBlockRangeBlocksCountInfo;
-/**
- * Counts the number of blocks in the input range.
- *
- * @deprecated use DateCell implementation instead.
- * @param inputDateBlockRange
- * @returns
- */
-function dateBlockRangeBlocksCount(inputDateBlockRange) {
-    return dateBlockRangeBlocksCountInfo(inputDateBlockRange).count;
-}
-exports.dateBlockRangeBlocksCount = dateBlockRangeBlocksCount;
-/**
- * Creates a dateBlockRangesFullyCoverDateBlockRangeFunction
- *
- * @deprecated use DateCell implementation instead.
- * @param ranges
- * @returns
- */
-function dateBlockRangesFullyCoverDateBlockRangeFunction(ranges) {
-    const groupedRanges = Array.isArray(ranges) ? groupToDateBlockRanges(ranges) : [dateBlockRangeWithRange(ranges)];
-    return (inputRange) => {
-        const fn = dateBlockRangeIncludedByRangeFunction(inputRange);
-        return groupedRanges.findIndex(fn) !== -1;
-    };
-}
-exports.dateBlockRangesFullyCoverDateBlockRangeFunction = dateBlockRangesFullyCoverDateBlockRangeFunction;
-/**
- * Expands a DateBlockRange into an array of DateBlock values.
- *
- * @deprecated use DateCell implementation instead.
- * @param block
- * @returns
- */
-function expandDateBlockRange(block) {
-    return (0, util_1.range)(block.i, dateBlockEndIndex(block) + 1).map((i) => {
-        return Object.assign(Object.assign({}, block), { i, to: i }); // copy block, set to as i
-    });
-}
-exports.expandDateBlockRange = expandDateBlockRange;
-/**
- * Returns true if the input DateBlockRange is longer than 1 block (I.E. has a "to" value greater than it's "i" value).
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- */
-function dateBlockRangeHasRange(input) {
-    return input.to != null && input.to > input.i;
-}
-exports.dateBlockRangeHasRange = dateBlockRangeHasRange;
-/**
- * Reads the to index if it exists, or returns the block's index itself.
- *
- * @deprecated use DateCell implementation instead.
- * @param input
- * @returns
- */
-function dateBlockEndIndex(input) {
-    var _a;
-    return (_a = input.to) !== null && _a !== void 0 ? _a : input.i;
-}
-exports.dateBlockEndIndex = dateBlockEndIndex;
-/**
- * Groups all input DateBlockRange or UniqueDateBlock values into a UniqueDateBlockRangeGroup value amd sorts the input.
- *
- * @deprecated use DateCell implementation instead.
- */
-function groupUniqueDateBlocks(input) {
-    var _a;
-    const blocks = sortDateBlockRanges([...input]);
-    const i = 0;
-    let to;
-    if (blocks.length === 0) {
-        to = i;
-    }
-    else {
-        const lastBlock = (0, util_1.lastValue)(blocks);
-        to = (_a = lastBlock.to) !== null && _a !== void 0 ? _a : lastBlock.i;
-    }
-    return {
-        i,
-        to,
-        blocks
-    };
-}
-exports.groupUniqueDateBlocks = groupUniqueDateBlocks;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param config
- * @returns
- */
-function expandUniqueDateBlocksFunction(config) {
-    const { startAtIndex = 0, endAtIndex, fillOption: fill, 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 fillFactory = inputFillFactory;
-    if (!fillFactory && fill === 'fill') {
-        throw new Error('fillFactory is required when fillOption is "fill".');
-    }
-    return (input, newBlocks) => {
-        const inputGroup = Array.isArray(input) ? groupUniqueDateBlocks(input) : input;
-        const sorted = inputGroup.blocks.map((block) => ({ priority: 'current', block }));
-        if (newBlocks != null) {
-            const inputOverwriteGroup = Array.isArray(newBlocks) ? groupUniqueDateBlocks(newBlocks) : newBlocks;
-            (0, util_1.mergeArrayIntoArray)(sorted, inputOverwriteGroup.blocks.map((block) => ({ priority: 'next', block }))).sort((a, b) => a.block.i - b.block.i);
-        }
-        const blocks = [];
-        const discarded = [];
-        let current = sorted[0];
-        let currentNextIndex;
-        let next = sorted[1];
-        let nextStartIndex;
-        let i = 0;
-        let latestTo = startAtIndex - 1;
-        function addBlockWithRange(inputBlock, i, inputTo = i) {
-            // Add in any necessary gap block first
-            const gapSizeBetweenBlocks = i - (latestTo + 1);
-            if (gapSizeBetweenBlocks > 0) {
-                // start at the startAtIndex at a minimum
-                const gapStartIndex = Math.max(latestTo + 1, startAtIndex);
-                addGapBlock(gapStartIndex, i - 1);
-            }
-            const to = Math.min(inputTo, maxAllowedIndex) || 0;
-            const block = Object.assign(Object.assign({}, inputBlock), { i,
-                to });
-            blocks.push(block);
-            latestTo = to;
-            return block;
-        }
-        function completeBlocks() {
-            // extend or fill if there is an endAtIndex value present
-            if (endAtIndex != null && latestTo < endAtIndex) {
-                addGapBlock(latestTo + 1, endAtIndex);
-            }
-        }
-        function addGapBlock(i, inputTo = i) {
-            const to = Math.min(inputTo, maxAllowedIndex);
-            if (fill === 'fill') {
-                const dateBlockRange = {
-                    i,
-                    to
-                };
-                const block = fillFactory(dateBlockRange);
-                addBlockWithRange(block, i, to !== null && to !== void 0 ? to : i);
-            }
-            else if (blocks.length > 0) {
-                // do not extend if no blocks have been pushed.
-                const blockToExtend = (0, util_1.lastValue)(blocks);
-                blockToExtend.to = inputTo;
-            }
-            latestTo = to;
-        }
-        function continueToNext(use, priority) {
-            i += 1;
-            current = use != null ? { block: use, priority } : sorted[i];
-            next = sorted[i + 1];
-            if (next) {
-                nextStartIndex = next.block.i;
-                // complete loop once past the max allowed index
-                if (nextStartIndex > maxAllowedIndex) {
-                    continueLoop = false;
-                }
-                else {
-                    const nextEndIndex = dateBlockEndIndex(next.block);
-                    if (nextEndIndex <= latestTo) {
-                        discardCurrent(); // skip until next is not less than or equal to the latest to
-                        continueToNext();
-                    }
-                }
-            }
-            else {
-                continueLoop = false;
-            }
-        }
-        function discard(pair) {
-            discarded.push(pair.block);
-        }
-        function discardCurrent() {
-            discard(current);
-        }
-        function discardNext() {
-            discard(next);
-            i += 1;
-            continueToNext();
-        }
-        let continueLoop = Boolean(next); // only loop if next is defined, otherwise we just add the final item.
-        /**
-         * Used to determine how to handle two neighboring objects.
-         */
-        function shouldRetainCurrentOverNext() {
-            if (current.priority === next.priority) {
-                return retainOnOverlap === 'current';
-            }
-            else {
-                return current.priority === retainOnOverlap;
-            }
-        }
-        while (continueLoop) {
-            currentNextIndex = current.block.i;
-            nextStartIndex = next.block.i;
-            const currentEndIndex = dateBlockEndIndex(current.block);
-            const nextEndIndex = dateBlockEndIndex(next.block);
-            if (nextStartIndex < startAtIndex || currentEndIndex < startAtIndex) {
-                // do nothing if the next index is still before the current start index.
-                discardCurrent();
-                continueToNext();
-            }
-            else if (currentNextIndex === nextStartIndex) {
-                // if next has the same range as current, then look at the tie-breaker
-                if (nextEndIndex === currentEndIndex) {
-                    // if they're both on the same index, then take the one based on the overwrite value
-                    if (shouldRetainCurrentOverNext()) {
-                        // add current
-                        addBlockWithRange(current.block, currentNextIndex, nextEndIndex);
-                        // discard and skip the "next" value
-                        discardNext();
-                    }
-                    else {
-                        // discard the current
-                        discardCurrent();
-                        // move on to next
-                        continueToNext();
-                    }
-                }
-                else if (nextEndIndex > currentEndIndex) {
-                    // handle overlap
-                    if (shouldRetainCurrentOverNext()) {
-                        // add current
-                        addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
-                        // change next to start at the next range
-                        continueToNext(Object.assign(Object.assign({}, next.block), { i: currentEndIndex + 1, to: nextEndIndex }), next.priority);
-                    }
-                    else {
-                        //
-                        discardCurrent();
-                        continueToNext();
-                    }
-                }
-                else {
-                    // the next item ends before the current item.
-                    if (shouldRetainCurrentOverNext()) {
-                        // discard the next value.
-                        discard(next);
-                        // continue with the current value
-                        continueToNext(current.block, current.priority);
-                    }
-                    else {
-                        // 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), { i: nextEndIndex + 1, to: currentEndIndex }), current.priority);
-                    }
-                }
-            }
-            else {
-                // Check for any overlap
-                if (currentEndIndex >= nextStartIndex) {
-                    // handle overlap
-                    if (shouldRetainCurrentOverNext()) {
-                        // add current
-                        addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
-                        if (nextEndIndex > currentEndIndex) {
-                            // change next to start at the next range
-                            continueToNext(Object.assign(Object.assign({}, next.block), { i: currentEndIndex + 1, to: nextEndIndex }), next.priority);
-                        }
-                        else {
-                            // continue normally
-                            continueToNext();
-                        }
-                    }
-                    else {
-                        // add current up to the start index of next
-                        addBlockWithRange(current.block, currentNextIndex, nextStartIndex - 1);
-                        // check if the next one is fully contained
-                        if (nextEndIndex < currentEndIndex) {
-                            // add the next
-                            addBlockWithRange(next.block, nextStartIndex, nextEndIndex);
-                            // continue with the current
-                            continueToNext(Object.assign(Object.assign({}, current.block), { i: nextEndIndex + 1, to: currentEndIndex }), next.priority);
-                        }
-                        else {
-                            // continue to next
-                            continueToNext();
-                        }
-                    }
-                }
-                else {
-                    // no overlap
-                    // add the current block
-                    addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
-                    // continue to next
-                    continueToNext();
-                }
-            }
-        }
-        if (current != null) {
-            // if current != null, then atleast one block was input/remaining.
-            const lastStartIndex = current.block.i;
-            const lastEndIndex = dateBlockEndIndex(current.block);
-            if (lastEndIndex < startAtIndex || lastEndIndex <= latestTo || lastStartIndex > maxAllowedIndex) {
-                // if the block ends before the start index, then do nothing.
-                discardCurrent();
-            }
-            else {
-                addBlockWithRange(current.block, Math.max(startAtIndex, lastStartIndex), Math.min(lastEndIndex, maxAllowedIndex));
-            }
-            completeBlocks();
-        }
-        else if (fill === 'fill') {
-            completeBlocks();
-        }
-        const result = {
-            i: 0,
-            blocks,
-            discarded
-        };
-        return result;
-    };
-}
-exports.expandUniqueDateBlocksFunction = expandUniqueDateBlocksFunction;
-/**
- * Creatse a ModifyDateBlocksToFitRangeFunction
- *
- * @deprecated use DateCell implementation instead.
- */
-function modifyDateBlocksToFitRangeFunction(range) {
-    const { i, to } = dateBlockRangeWithRange(range);
-    const dateBlockIsWithinDateBlockRange = isDateBlockWithinDateBlockRangeFunction(range);
-    const overlapsRange = dateBlockRangeOverlapsRangeFunction(range);
-    return (input) => (0, util_1.filterMaybeValues)(input.map((x) => {
-        let result;
-        const inRange = dateBlockIsWithinDateBlockRange(x);
-        if (inRange) {
-            // if contained within the range then return as-is
-            result = x;
-        }
-        else {
-            // fit to the range otherwise
-            const asRange = dateBlockRangeWithRange(x);
-            const rangesOverlap = overlapsRange(asRange);
-            if (rangesOverlap) {
-                result = Object.assign(Object.assign({}, x), { i: Math.max(i, asRange.i), to: Math.min(to, asRange.to) // should be no larger than to
-                 });
-            }
-        }
-        return result;
-    }));
-}
-exports.modifyDateBlocksToFitRangeFunction = modifyDateBlocksToFitRangeFunction;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param range
- * @param input
- * @returns
- */
-function modifyDateBlocksToFitRange(range, input) {
-    return modifyDateBlocksToFitRangeFunction(range)(input);
-}
-exports.modifyDateBlocksToFitRange = modifyDateBlocksToFitRange;
-/**
- *
- * @deprecated use DateCell implementation instead.
- * @param range
- * @param input
- * @returns
- */
-function modifyDateBlockToFitRange(range, input) {
-    return modifyDateBlocksToFitRange(range, [input])[0];
-}
-exports.modifyDateBlockToFitRange = modifyDateBlockToFitRange;
-// MARK: Compat
-/**
- * @deprecated use dateBlocksInDateBlockRange instead.
- */
-exports.dateBlocksInDateBlockRange = filterDateBlocksInDateBlockRange;
-/**
- * @deprecated use isDateBlockWithinDateBlockRangeFunction() instead.
- */
-exports.dateBlockIsWithinDateBlockRangeFunction = isDateBlockWithinDateBlockRangeFunction;
-/**
- * @deprecated use isDateBlockWithinDateBlockRange() instead.
- */
-exports.dateBlockRangeContainsDateBlock = isDateBlockWithinDateBlockRange;
-/**
- * @deprecated use dateBlocksDayTimingInfoFactory instead.
- */
-exports.dateBlocksDayInfoFactory = dateBlockDayTimingInfoFactory;
-/**
- * @deprecated use isDateBlockTimingRelativeIndexFactory instead.
- */
-exports.isDateTimingRelativeIndexFactory = isDateBlockTimingRelativeIndexFactory;
-/**
- * @deprecated use dateBlockTimingRelativeIndexFactory instead.
- */
-exports.dateTimingRelativeIndexFactory = dateBlockTimingRelativeIndexFactory;
-/**
- * @deprecated use dateBlockTimingRelativeIndexArrayFactory instead.
- */
-exports.dateTimingRelativeIndexArrayFactory = dateBlockTimingRelativeIndexArrayFactory;
-/**
- * @deprecated use getRelativeIndexForDateBlockTiming instead.
- */
-exports.getRelativeIndexForDateTiming = getRelativeIndexForDateBlockTiming;
-//# sourceMappingURL=date.block.js.map