@fullcalendar/timeline 7.0.0-beta.4 → 7.0.0-beta.5

package/internal.cjs

@@ -1,1258 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var internal_cjs = require('@fullcalendar/core/internal.cjs');
-var preact_cjs = require('@fullcalendar/core/preact.cjs');
-var internal_cjs$1 = require('@fullcalendar/scrollgrid/internal.cjs');
-
-const MIN_AUTO_LABELS = 18; // more than `12` months but less that `24` hours
-const MAX_AUTO_SLOTS_PER_LABEL = 6; // allows 6 10-min slots in an hour
-const MAX_AUTO_CELLS = 200; // allows 4-days to have a :30 slot duration
-internal_cjs.config.MAX_TIMELINE_SLOTS = 1000;
-// potential nice values for slot-duration and interval-duration
-const STOCK_SUB_DURATIONS = [
-    { years: 1 },
-    { months: 1 },
-    { days: 1 },
-    { hours: 1 },
-    { minutes: 30 },
-    { minutes: 15 },
-    { minutes: 10 },
-    { minutes: 5 },
-    { minutes: 1 },
-    { seconds: 30 },
-    { seconds: 15 },
-    { seconds: 10 },
-    { seconds: 5 },
-    { seconds: 1 },
-    { milliseconds: 500 },
-    { milliseconds: 100 },
-    { milliseconds: 10 },
-    { milliseconds: 1 },
-];
-function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileGenerator) {
-    let tDateProfile = {
-        labelInterval: allOptions.slotLabelInterval,
-        slotDuration: allOptions.slotDuration,
-    };
-    validateLabelAndSlot(tDateProfile, dateProfile, dateEnv); // validate after computed grid duration
-    ensureLabelInterval(tDateProfile, dateProfile, dateEnv);
-    ensureSlotDuration(tDateProfile, dateProfile, dateEnv);
-    let input = allOptions.slotLabelFormat;
-    let rawFormats = Array.isArray(input) ? input :
-        (input != null) ? [input] :
-            computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions);
-    tDateProfile.headerFormats = rawFormats.map((rawFormat) => internal_cjs.createFormatter(rawFormat));
-    tDateProfile.isTimeScale = Boolean(tDateProfile.slotDuration.milliseconds);
-    let largeUnit = null;
-    if (!tDateProfile.isTimeScale) {
-        const slotUnit = internal_cjs.greatestDurationDenominator(tDateProfile.slotDuration).unit;
-        if (/year|month|week/.test(slotUnit)) {
-            largeUnit = slotUnit;
-        }
-    }
-    tDateProfile.largeUnit = largeUnit;
-    tDateProfile.emphasizeWeeks =
-        internal_cjs.asCleanDays(tDateProfile.slotDuration) === 1 &&
-            currentRangeAs('weeks', dateProfile, dateEnv) >= 2 &&
-            !allOptions.businessHours;
-    /*
-    console.log('label interval =', timelineView.labelInterval.humanize())
-    console.log('slot duration =', timelineView.slotDuration.humanize())
-    console.log('header formats =', timelineView.headerFormats)
-    console.log('isTimeScale', timelineView.isTimeScale)
-    console.log('largeUnit', timelineView.largeUnit)
-    */
-    let rawSnapDuration = allOptions.snapDuration;
-    let snapDuration;
-    let snapsPerSlot;
-    if (rawSnapDuration) {
-        snapDuration = internal_cjs.createDuration(rawSnapDuration);
-        snapsPerSlot = internal_cjs.wholeDivideDurations(tDateProfile.slotDuration, snapDuration);
-        // ^ TODO: warning if not whole?
-    }
-    if (snapsPerSlot == null) {
-        snapDuration = tDateProfile.slotDuration;
-        snapsPerSlot = 1;
-    }
-    tDateProfile.snapDuration = snapDuration;
-    tDateProfile.snapsPerSlot = snapsPerSlot;
-    // more...
-    let timeWindowMs = internal_cjs.asRoughMs(dateProfile.slotMaxTime) - internal_cjs.asRoughMs(dateProfile.slotMinTime);
-    // TODO: why not use normalizeRange!?
-    let normalizedStart = normalizeDate(dateProfile.renderRange.start, tDateProfile, dateEnv);
-    let normalizedEnd = normalizeDate(dateProfile.renderRange.end, tDateProfile, dateEnv);
-    // apply slotMinTime/slotMaxTime
-    // TODO: View should be responsible.
-    if (tDateProfile.isTimeScale) {
-        normalizedStart = dateEnv.add(normalizedStart, dateProfile.slotMinTime);
-        normalizedEnd = dateEnv.add(internal_cjs.addDays(normalizedEnd, -1), dateProfile.slotMaxTime);
-    }
-    tDateProfile.timeWindowMs = timeWindowMs;
-    tDateProfile.normalizedRange = { start: normalizedStart, end: normalizedEnd };
-    let slotDates = [];
-    let date = normalizedStart;
-    while (date < normalizedEnd) {
-        if (isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator)) {
-            slotDates.push(date);
-        }
-        date = dateEnv.add(date, tDateProfile.slotDuration);
-    }
-    tDateProfile.slotDates = slotDates;
-    // more...
-    let snapIndex = -1;
-    let snapDiff = 0; // index of the diff :(
-    const snapDiffToIndex = [];
-    const snapIndexToDiff = [];
-    date = normalizedStart;
-    while (date < normalizedEnd) {
-        if (isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator)) {
-            snapIndex += 1;
-            snapDiffToIndex.push(snapIndex);
-            snapIndexToDiff.push(snapDiff);
-        }
-        else {
-            snapDiffToIndex.push(snapIndex + 0.5);
-        }
-        date = dateEnv.add(date, tDateProfile.snapDuration);
-        snapDiff += 1;
-    }
-    tDateProfile.snapDiffToIndex = snapDiffToIndex;
-    tDateProfile.snapIndexToDiff = snapIndexToDiff;
-    tDateProfile.snapCnt = snapIndex + 1; // is always one behind
-    tDateProfile.slotCnt = tDateProfile.snapCnt / tDateProfile.snapsPerSlot;
-    // more...
-    tDateProfile.isWeekStarts = buildIsWeekStarts(tDateProfile, dateEnv);
-    tDateProfile.cellRows = buildCellRows(tDateProfile, dateEnv);
-    tDateProfile.slotsPerLabel = internal_cjs.wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
-    return tDateProfile;
-}
-/*
-snaps to appropriate unit
-*/
-function normalizeDate(date, tDateProfile, dateEnv) {
-    let normalDate = date;
-    if (!tDateProfile.isTimeScale) {
-        normalDate = internal_cjs.startOfDay(normalDate);
-        if (tDateProfile.largeUnit) {
-            normalDate = dateEnv.startOf(normalDate, tDateProfile.largeUnit);
-        }
-    }
-    return normalDate;
-}
-/*
-snaps to appropriate unit
-*/
-function normalizeRange(range, tDateProfile, dateEnv) {
-    if (!tDateProfile.isTimeScale) {
-        range = internal_cjs.computeVisibleDayRange(range);
-        if (tDateProfile.largeUnit) {
-            let dayRange = range; // preserve original result
-            range = {
-                start: dateEnv.startOf(range.start, tDateProfile.largeUnit),
-                end: dateEnv.startOf(range.end, tDateProfile.largeUnit),
-            };
-            // if date is partially through the interval, or is in the same interval as the start,
-            // make the exclusive end be the *next* interval
-            if (range.end.valueOf() !== dayRange.end.valueOf() || range.end <= range.start) {
-                range = {
-                    start: range.start,
-                    end: dateEnv.add(range.end, tDateProfile.slotDuration),
-                };
-            }
-        }
-    }
-    return range;
-}
-function isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator) {
-    if (dateProfileGenerator.isHiddenDay(date)) {
-        return false;
-    }
-    if (tDateProfile.isTimeScale) {
-        // determine if the time is within slotMinTime/slotMaxTime, which may have wacky values
-        let day = internal_cjs.startOfDay(date);
-        let timeMs = date.valueOf() - day.valueOf();
-        let ms = timeMs - internal_cjs.asRoughMs(dateProfile.slotMinTime); // milliseconds since slotMinTime
-        ms = ((ms % 86400000) + 86400000) % 86400000; // make negative values wrap to 24hr clock
-        return ms < tDateProfile.timeWindowMs; // before the slotMaxTime?
-    }
-    return true;
-}
-function validateLabelAndSlot(tDateProfile, dateProfile, dateEnv) {
-    const { currentRange } = dateProfile;
-    // make sure labelInterval doesn't exceed the max number of cells
-    if (tDateProfile.labelInterval) {
-        const labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.labelInterval);
-        if (labelCnt > internal_cjs.config.MAX_TIMELINE_SLOTS) {
-            console.warn('slotLabelInterval results in too many cells');
-            tDateProfile.labelInterval = null;
-        }
-    }
-    // make sure slotDuration doesn't exceed the maximum number of cells
-    if (tDateProfile.slotDuration) {
-        const slotCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.slotDuration);
-        if (slotCnt > internal_cjs.config.MAX_TIMELINE_SLOTS) {
-            console.warn('slotDuration results in too many cells');
-            tDateProfile.slotDuration = null;
-        }
-    }
-    // make sure labelInterval is a multiple of slotDuration
-    if (tDateProfile.labelInterval && tDateProfile.slotDuration) {
-        const slotsPerLabel = internal_cjs.wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
-        if (slotsPerLabel === null || slotsPerLabel < 1) {
-            console.warn('slotLabelInterval must be a multiple of slotDuration');
-            tDateProfile.slotDuration = null;
-        }
-    }
-}
-function ensureLabelInterval(tDateProfile, dateProfile, dateEnv) {
-    const { currentRange } = dateProfile;
-    let { labelInterval } = tDateProfile;
-    if (!labelInterval) {
-        // compute based off the slot duration
-        // find the largest label interval with an acceptable slots-per-label
-        let input;
-        if (tDateProfile.slotDuration) {
-            for (input of STOCK_SUB_DURATIONS) {
-                const tryLabelInterval = internal_cjs.createDuration(input);
-                const slotsPerLabel = internal_cjs.wholeDivideDurations(tryLabelInterval, tDateProfile.slotDuration);
-                if (slotsPerLabel !== null && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) {
-                    labelInterval = tryLabelInterval;
-                    break;
-                }
-            }
-            // use the slot duration as a last resort
-            if (!labelInterval) {
-                labelInterval = tDateProfile.slotDuration;
-            }
-            // compute based off the view's duration
-            // find the largest label interval that yields the minimum number of labels
-        }
-        else {
-            for (input of STOCK_SUB_DURATIONS) {
-                labelInterval = internal_cjs.createDuration(input);
-                const labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, labelInterval);
-                if (labelCnt >= MIN_AUTO_LABELS) {
-                    break;
-                }
-            }
-        }
-        tDateProfile.labelInterval = labelInterval;
-    }
-    return labelInterval;
-}
-function ensureSlotDuration(tDateProfile, dateProfile, dateEnv) {
-    const { currentRange } = dateProfile;
-    let { slotDuration } = tDateProfile;
-    if (!slotDuration) {
-        const labelInterval = ensureLabelInterval(tDateProfile, dateProfile, dateEnv); // will compute if necessary
-        // compute based off the label interval
-        // find the largest slot duration that is different from labelInterval, but still acceptable
-        for (let input of STOCK_SUB_DURATIONS) {
-            const trySlotDuration = internal_cjs.createDuration(input);
-            const slotsPerLabel = internal_cjs.wholeDivideDurations(labelInterval, trySlotDuration);
-            if (slotsPerLabel !== null && slotsPerLabel > 1 && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) {
-                slotDuration = trySlotDuration;
-                break;
-            }
-        }
-        // only allow the value if it won't exceed the view's # of slots limit
-        if (slotDuration) {
-            const slotCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, slotDuration);
-            if (slotCnt > MAX_AUTO_CELLS) {
-                slotDuration = null;
-            }
-        }
-        // use the label interval as a last resort
-        if (!slotDuration) {
-            slotDuration = labelInterval;
-        }
-        tDateProfile.slotDuration = slotDuration;
-    }
-    return slotDuration;
-}
-function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
-    let format1;
-    let format2;
-    const { labelInterval } = tDateProfile;
-    let unit = internal_cjs.greatestDurationDenominator(labelInterval).unit;
-    const weekNumbersVisible = allOptions.weekNumbers;
-    let format0 = (format1 = (format2 = null));
-    // NOTE: weekNumber computation function wont work
-    if ((unit === 'week') && !weekNumbersVisible) {
-        unit = 'day';
-    }
-    switch (unit) {
-        case 'year':
-            format0 = { year: 'numeric' }; // '2015'
-            break;
-        case 'month':
-            if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
-                format0 = { year: 'numeric' }; // '2015'
-            }
-            format1 = { month: 'short' }; // 'Jan'
-            break;
-        case 'week':
-            if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
-                format0 = { year: 'numeric' }; // '2015'
-            }
-            format1 = { week: 'narrow' }; // 'Wk4'
-            break;
-        case 'day':
-            if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
-                format0 = { year: 'numeric', month: 'long' }; // 'January 2014'
-            }
-            else if (currentRangeAs('months', dateProfile, dateEnv) > 1) {
-                format0 = { month: 'long' }; // 'January'
-            }
-            if (weekNumbersVisible) {
-                format1 = { week: 'short' }; // 'Wk 4'
-            }
-            format2 = { weekday: 'narrow', day: 'numeric' }; // 'Su 9'
-            break;
-        case 'hour':
-            if (weekNumbersVisible) {
-                format0 = { week: 'short' }; // 'Wk 4'
-            }
-            if (currentRangeAs('days', dateProfile, dateEnv) > 1) {
-                format1 = { weekday: 'short', day: 'numeric', month: 'numeric', omitCommas: true }; // Sat 4/7
-            }
-            format2 = {
-                hour: 'numeric',
-                minute: '2-digit',
-                omitZeroMinute: true,
-                meridiem: 'short',
-            };
-            break;
-        case 'minute':
-            // sufficiently large number of different minute cells?
-            if ((internal_cjs.asRoughMinutes(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
-                format0 = {
-                    hour: 'numeric',
-                    meridiem: 'short',
-                };
-                format1 = (params) => (':' + internal_cjs.padStart(params.date.minute, 2) // ':30'
-                );
-            }
-            else {
-                format0 = {
-                    hour: 'numeric',
-                    minute: 'numeric',
-                    meridiem: 'short',
-                };
-            }
-            break;
-        case 'second':
-            // sufficiently large number of different second cells?
-            if ((internal_cjs.asRoughSeconds(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
-                format0 = { hour: 'numeric', minute: '2-digit', meridiem: 'lowercase' }; // '8:30 PM'
-                format1 = (params) => (':' + internal_cjs.padStart(params.date.second, 2) // ':30'
-                );
-            }
-            else {
-                format0 = { hour: 'numeric', minute: '2-digit', second: '2-digit', meridiem: 'lowercase' }; // '8:30:45 PM'
-            }
-            break;
-        case 'millisecond':
-            format0 = { hour: 'numeric', minute: '2-digit', second: '2-digit', meridiem: 'lowercase' }; // '8:30:45 PM'
-            format1 = (params) => ('.' + internal_cjs.padStart(params.millisecond, 3));
-            break;
-    }
-    return [].concat(format0 || [], format1 || [], format2 || []);
-}
-// Compute the number of the give units in the "current" range.
-// Won't go more precise than days.
-// Will return `0` if there's not a clean whole interval.
-function currentRangeAs(unit, dateProfile, dateEnv) {
-    let range = dateProfile.currentRange;
-    let res = null;
-    if (unit === 'years') {
-        res = dateEnv.diffWholeYears(range.start, range.end);
-    }
-    else if (unit === 'months') {
-        res = dateEnv.diffWholeMonths(range.start, range.end);
-    }
-    else if (unit === 'weeks') {
-        res = dateEnv.diffWholeMonths(range.start, range.end);
-    }
-    else if (unit === 'days') {
-        res = internal_cjs.diffWholeDays(range.start, range.end);
-    }
-    return res || 0;
-}
-function buildIsWeekStarts(tDateProfile, dateEnv) {
-    let { slotDates, emphasizeWeeks } = tDateProfile;
-    let prevWeekNumber = null;
-    let isWeekStarts = [];
-    for (let slotDate of slotDates) {
-        let weekNumber = dateEnv.computeWeekNumber(slotDate);
-        let isWeekStart = emphasizeWeeks && (prevWeekNumber !== null) && (prevWeekNumber !== weekNumber);
-        prevWeekNumber = weekNumber;
-        isWeekStarts.push(isWeekStart);
-    }
-    return isWeekStarts;
-}
-function buildCellRows(tDateProfile, dateEnv) {
-    let slotDates = tDateProfile.slotDates;
-    let formats = tDateProfile.headerFormats;
-    let cellRows = formats.map(() => []); // indexed by row,col
-    let slotAsDays = internal_cjs.asCleanDays(tDateProfile.slotDuration);
-    let guessedSlotUnit = slotAsDays === 7 ? 'week' :
-        slotAsDays === 1 ? 'day' :
-            null;
-    // specifically for navclicks
-    let rowUnitsFromFormats = formats.map((format) => (format.getLargestUnit ? format.getLargestUnit() : null));
-    // builds cellRows and slotCells
-    for (let i = 0; i < slotDates.length; i += 1) {
-        let date = slotDates[i];
-        let isWeekStart = tDateProfile.isWeekStarts[i];
-        for (let row = 0; row < formats.length; row += 1) {
-            let format = formats[row];
-            let rowCells = cellRows[row];
-            let leadingCell = rowCells[rowCells.length - 1];
-            let isLastRow = row === formats.length - 1;
-            let isSuperRow = formats.length > 1 && !isLastRow; // more than one row and not the last
-            let newCell = null;
-            let rowUnit = rowUnitsFromFormats[row] || (isLastRow ? guessedSlotUnit : null);
-            if (isSuperRow) {
-                let text = dateEnv.format(date, format);
-                if (!leadingCell || (leadingCell.text !== text)) {
-                    newCell = buildCellObject(date, text, rowUnit);
-                }
-                else {
-                    leadingCell.colspan += 1;
-                }
-            }
-            else if (!leadingCell ||
-                internal_cjs.isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.labelInterval))) {
-                let text = dateEnv.format(date, format);
-                newCell = buildCellObject(date, text, rowUnit);
-            }
-            else {
-                leadingCell.colspan += 1;
-            }
-            if (newCell) {
-                newCell.weekStart = isWeekStart;
-                rowCells.push(newCell);
-            }
-        }
-    }
-    return cellRows;
-}
-function buildCellObject(date, text, rowUnit) {
-    return { date, text, rowUnit, colspan: 1, isWeekStart: false };
-}
-
-class TimelineSlatCell extends internal_cjs.BaseComponent {
-    constructor() {
-        super(...arguments);
-        // ref
-        this.innerElRef = preact_cjs.createRef();
-    }
-    render() {
-        let { props, context } = this;
-        let { dateEnv, options } = context;
-        let { date, tDateProfile, isEm } = props;
-        let dateMeta = internal_cjs.getDateMeta(props.date, props.todayRange, props.nowDate, props.dateProfile);
-        let renderProps = Object.assign(Object.assign({ date: dateEnv.toDate(props.date) }, dateMeta), { view: context.viewApi });
-        return (preact_cjs.createElement(internal_cjs.ContentContainer, { tag: "div", 
-            // fc-align-start shrinks width of InnerContent
-            // TODO: document this semantic className fc-timeline-slot-em
-            className: internal_cjs.joinClassNames('fc-timeline-slot', isEm && 'fc-timeline-slot-em', tDateProfile.isTimeScale && (internal_cjs.isInt(dateEnv.countDurationsBetween(// best to do this here?
-            tDateProfile.normalizedRange.start, props.date, tDateProfile.labelInterval)) ?
-                'fc-timeline-slot-major' :
-                'fc-timeline-slot-minor'), 'fc-timeline-slot-lane fc-cell fc-flex-col fc-align-start', props.borderStart && 'fc-border-s', props.isDay ?
-                internal_cjs.getDayClassName(dateMeta) :
-                internal_cjs.getSlotClassName(dateMeta)), attrs: Object.assign({ 'data-date': dateEnv.formatIso(date, {
-                    omitTimeZoneOffset: true,
-                    omitTime: !tDateProfile.isTimeScale,
-                }) }, (dateMeta.isToday ? { 'aria-current': 'date' } : {})), style: {
-                width: props.width,
-            }, renderProps: renderProps, generatorName: "slotLaneContent", customGenerator: options.slotLaneContent, classNameGenerator: options.slotLaneClassNames, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount }, (InnerContent) => (preact_cjs.createElement(InnerContent, { tag: "div", className: 'fc-cell-inner', elRef: this.innerElRef }))));
-    }
-    componentDidMount() {
-        const innerEl = this.innerElRef.current;
-        this.disconnectInnerWidth = internal_cjs.watchWidth(innerEl, (width) => {
-            internal_cjs.setRef(this.props.innerWidthRef, width);
-        });
-    }
-    componentWillUnmount() {
-        this.disconnectInnerWidth();
-        internal_cjs.setRef(this.props.innerWidthRef, null);
-    }
-}
-
-class TimelineSlats extends internal_cjs.BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.innerWidthRefMap = new internal_cjs.RefMap(() => {
-            internal_cjs.afterSize(this.handleInnerWidths);
-        });
-        this.handleInnerWidths = () => {
-            const innerWidthMap = this.innerWidthRefMap.current;
-            let max = 0;
-            for (const innerWidth of innerWidthMap.values()) {
-                max = Math.max(max, innerWidth);
-            }
-            // TODO: check to see if changed before firing ref!? YES. do in other places too
-            internal_cjs.setRef(this.props.innerWidthRef, max);
-        };
-    }
-    render() {
-        let { props, innerWidthRefMap } = this;
-        let { tDateProfile, slotWidth } = props;
-        let { slotDates, isWeekStarts } = tDateProfile;
-        let isDay = !tDateProfile.isTimeScale && !tDateProfile.largeUnit;
-        return (preact_cjs.createElement("div", { "aria-hidden": true, className: "fc-timeline-slots fc-fill fc-flex-row", style: { height: props.height } }, slotDates.map((slotDate, i) => {
-            let key = slotDate.toISOString();
-            return (preact_cjs.createElement(TimelineSlatCell, { key: key, date: slotDate, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isEm: isWeekStarts[i], isDay: isDay, borderStart: Boolean(i), 
-                // ref
-                innerWidthRef: innerWidthRefMap.createRef(key), 
-                // dimensions
-                width: slotWidth }));
-        })));
-    }
-}
-
-/*
-TODO: rename this file!
-*/
-// returned value is between 0 and the number of snaps
-function computeDateSnapCoverage$1(date, tDateProfile, dateEnv) {
-    let snapDiff = dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.snapDuration);
-    if (snapDiff < 0) {
-        return 0;
-    }
-    if (snapDiff >= tDateProfile.snapDiffToIndex.length) {
-        return tDateProfile.snapCnt;
-    }
-    let snapDiffInt = Math.floor(snapDiff);
-    let snapCoverage = tDateProfile.snapDiffToIndex[snapDiffInt];
-    if (internal_cjs.isInt(snapCoverage)) { // not an in-between value
-        snapCoverage += snapDiff - snapDiffInt; // add the remainder
-    }
-    else {
-        // a fractional value, meaning the date is not visible
-        // always round up in this case. works for start AND end dates in a range.
-        snapCoverage = Math.ceil(snapCoverage);
-    }
-    return snapCoverage;
-}
-/*
-TODO: DRY up with elsewhere?
-*/
-function horizontalsToCss(hcoord, isRtl) {
-    if (!hcoord) {
-        return {};
-    }
-    if (isRtl) {
-        return { right: hcoord.start, width: hcoord.size };
-    }
-    else {
-        return { left: hcoord.start, width: hcoord.size };
-    }
-}
-function horizontalCoordToCss(start, isRtl) {
-    if (isRtl) {
-        return { right: start };
-    }
-    else {
-        return { left: start };
-    }
-}
-
-function createVerticalStyle(props) {
-    if (props) {
-        return {
-            top: props.start,
-            height: props.size,
-        };
-    }
-}
-function createHorizontalStyle(// TODO: DRY up?
-props, isRtl) {
-    if (props) {
-        return {
-            [isRtl ? 'right' : 'left']: props.start,
-            width: props.size,
-        };
-    }
-}
-// Timeline-specific
-// -------------------------------------------------------------------------------------------------
-const MIN_SLOT_WIDTH = 30; // for real
-/*
-TODO: DRY with computeSlatHeight?
-*/
-function computeSlotWidth(slatCnt, slatsPerLabel, slatMinWidth, labelInnerWidth, viewportWidth) {
-    if (labelInnerWidth == null || viewportWidth == null) {
-        return [undefined, undefined, false];
-    }
-    slatMinWidth = Math.max(slatMinWidth || 0, (labelInnerWidth + 1) / slatsPerLabel, MIN_SLOT_WIDTH);
-    const slatTryWidth = viewportWidth / slatCnt;
-    let slatLiquid;
-    let slatWidth;
-    if (slatTryWidth >= slatMinWidth) {
-        slatLiquid = true;
-        slatWidth = slatTryWidth;
-    }
-    else {
-        slatLiquid = false;
-        slatWidth = Math.max(slatMinWidth, slatTryWidth);
-    }
-    return [slatWidth * slatCnt, slatWidth, slatLiquid];
-}
-function timeToCoord(// pixels
-time, dateEnv, dateProfile, tDateProfile, slowWidth) {
-    let date = dateEnv.add(dateProfile.activeRange.start, time);
-    if (!tDateProfile.isTimeScale) {
-        date = internal_cjs.startOfDay(date);
-    }
-    return dateToCoord(date, dateEnv, tDateProfile, slowWidth);
-}
-function dateToCoord(// pixels
-date, dateEnv, tDateProfile, slotWidth) {
-    let snapCoverage = computeDateSnapCoverage(date, tDateProfile, dateEnv);
-    let slotCoverage = snapCoverage / tDateProfile.snapsPerSlot;
-    return slotCoverage * slotWidth;
-}
-/*
-returned value is between 0 and the number of snaps
-*/
-function computeDateSnapCoverage(date, tDateProfile, dateEnv) {
-    let snapDiff = dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.snapDuration);
-    if (snapDiff < 0) {
-        return 0;
-    }
-    if (snapDiff >= tDateProfile.snapDiffToIndex.length) {
-        return tDateProfile.snapCnt;
-    }
-    let snapDiffInt = Math.floor(snapDiff);
-    let snapCoverage = tDateProfile.snapDiffToIndex[snapDiffInt];
-    if (internal_cjs.isInt(snapCoverage)) { // not an in-between value
-        snapCoverage += snapDiff - snapDiffInt; // add the remainder
-    }
-    else {
-        // a fractional value, meaning the date is not visible
-        // always round up in this case. works for start AND end dates in a range.
-        snapCoverage = Math.ceil(snapCoverage);
-    }
-    return snapCoverage;
-}
-
-function computeManySegHorizontals(segs, segMinWidth, dateEnv, tDateProfile, slotWidth) {
-    const res = {};
-    for (const seg of segs) {
-        res[internal_cjs.getEventKey(seg)] = computeSegHorizontals(seg, segMinWidth, dateEnv, tDateProfile, slotWidth);
-    }
-    return res;
-}
-function computeSegHorizontals(seg, segMinWidth, dateEnv, tDateProfile, slotWidth) {
-    const startCoord = dateToCoord(seg.startDate, dateEnv, tDateProfile, slotWidth);
-    const endCoord = dateToCoord(seg.endDate, dateEnv, tDateProfile, slotWidth);
-    let size = endCoord - startCoord;
-    if (segMinWidth) {
-        size = Math.max(size, segMinWidth);
-    }
-    return { start: startCoord, size };
-}
-function computeFgSegPlacements(// mostly horizontals
-segs, segHorizontals, // TODO: use Map
-segHeights, // keyed by instanceId
-hiddenGroupHeights, strictOrder, maxDepth) {
-    const segRanges = [];
-    // isn't it true that there will either be ALL hcoords or NONE? can optimize
-    for (const seg of segs) {
-        const hcoords = segHorizontals[internal_cjs.getEventKey(seg)];
-        if (hcoords) {
-            segRanges.push(Object.assign(Object.assign({}, seg), { start: hcoords.start, end: hcoords.start + hcoords.size }));
-        }
-    }
-    const hierarchy = new internal_cjs.SegHierarchy(segRanges, (seg) => segHeights.get(internal_cjs.getEventKey(seg)), strictOrder, undefined, // maxCoord
-    maxDepth);
-    const segTops = new Map();
-    hierarchy.traverseSegs((seg, segTop) => {
-        segTops.set(internal_cjs.getEventKey(seg), segTop);
-    });
-    const { hiddenSegs } = hierarchy;
-    let totalHeight = 0;
-    for (const segRange of segRanges) {
-        const segKey = internal_cjs.getEventKey(segRange);
-        const segHeight = segHeights.get(segKey);
-        const segTop = segTops.get(segKey);
-        if (segHeight != null) {
-            if (segTop != null) {
-                totalHeight = Math.max(totalHeight, segTop + segHeight);
-            }
-        }
-    }
-    const hiddenGroups = internal_cjs.groupIntersectingSegs(hiddenSegs);
-    const hiddenGroupTops = new Map();
-    // HACK for hiddenGroup findInsertion() call
-    hierarchy.strictOrder = true;
-    for (const hiddenGroup of hiddenGroups) {
-        const { levelCoord: top } = hierarchy.findInsertion(hiddenGroup, 0);
-        const hiddenGroupHeight = hiddenGroupHeights.get(hiddenGroup.key) || 0;
-        hiddenGroupTops.set(hiddenGroup.key, top);
-        totalHeight = Math.max(totalHeight, top + hiddenGroupHeight);
-    }
-    return [
-        segTops,
-        hiddenGroups,
-        hiddenGroupTops,
-        totalHeight,
-    ];
-}
-
-class TimelineLaneBg extends internal_cjs.BaseComponent {
-    render() {
-        let { props } = this;
-        let highlightSeg = [].concat(props.eventResizeSegs, props.dateSelectionSegs);
-        return (preact_cjs.createElement(preact_cjs.Fragment, null,
-            this.renderSegs(props.businessHourSegs || [], 'non-business'),
-            this.renderSegs(props.bgEventSegs || [], 'bg-event'),
-            this.renderSegs(highlightSeg, 'highlight')));
-    }
-    renderSegs(segs, fillType) {
-        let { tDateProfile, todayRange, nowDate, slotWidth } = this.props;
-        let { dateEnv, isRtl } = this.context;
-        return (preact_cjs.createElement(preact_cjs.Fragment, null, segs.map((seg) => {
-            let hStyle; // TODO
-            if (slotWidth != null) {
-                let segHorizontal = computeSegHorizontals(seg, undefined, dateEnv, tDateProfile, slotWidth);
-                hStyle = horizontalsToCss(segHorizontal, isRtl);
-            }
-            return (preact_cjs.createElement("div", { key: internal_cjs.buildEventRangeKey(seg.eventRange), className: "fc-fill-y", style: hStyle }, fillType === 'bg-event' ?
-                preact_cjs.createElement(internal_cjs.BgEvent, Object.assign({ eventRange: seg.eventRange, isStart: seg.isStart, isEnd: seg.isEnd }, internal_cjs.getEventRangeMeta(seg.eventRange, todayRange, nowDate))) : (internal_cjs.renderFill(fillType))));
-        })));
-    }
-}
-
-class TimelineLaneSlicer extends internal_cjs.Slicer {
-    sliceRange(origRange, dateProfile, dateProfileGenerator, tDateProfile, dateEnv) {
-        let normalRange = normalizeRange(origRange, tDateProfile, dateEnv);
-        let segs = [];
-        // protect against when the span is entirely in an invalid date region
-        if (computeDateSnapCoverage$1(normalRange.start, tDateProfile, dateEnv)
-            < computeDateSnapCoverage$1(normalRange.end, tDateProfile, dateEnv)) {
-            // intersect the footprint's range with the grid's range
-            let slicedRange = internal_cjs.intersectRanges(normalRange, tDateProfile.normalizedRange);
-            if (slicedRange) {
-                segs.push({
-                    startDate: slicedRange.start,
-                    endDate: slicedRange.end,
-                    isStart: slicedRange.start.valueOf() === normalRange.start.valueOf()
-                        && isValidDate(slicedRange.start, tDateProfile, dateProfile, dateProfileGenerator),
-                    isEnd: slicedRange.end.valueOf() === normalRange.end.valueOf()
-                        && isValidDate(internal_cjs.addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
-                });
-            }
-        }
-        return segs;
-    }
-}
-
-const DEFAULT_TIME_FORMAT = internal_cjs.createFormatter({
-    hour: 'numeric',
-    minute: '2-digit',
-    omitZeroMinute: true,
-    meridiem: 'narrow',
-});
-class TimelineEvent extends internal_cjs.BaseComponent {
-    render() {
-        let { props, context } = this;
-        let { options } = context;
-        return (preact_cjs.createElement(internal_cjs.StandardEvent, Object.assign({}, props, { className: internal_cjs.joinClassNames('fc-timeline-event', options.eventOverlap === false // TODO: fix bad default
-                && 'fc-timeline-event-spacious', 'fc-h-event'), defaultTimeFormat: DEFAULT_TIME_FORMAT, defaultDisplayEventTime: !props.isTimeScale })));
-    }
-}
-
-class TimelineLaneMoreLink extends internal_cjs.BaseComponent {
-    render() {
-        let { props } = this;
-        let { hiddenSegs, resourceId, forcedInvisibleMap } = props;
-        let dateSpanProps = resourceId ? { resourceId } : {};
-        return (preact_cjs.createElement(internal_cjs.MoreLinkContainer, { className: 'fc-timeline-more-link', allDayDate: null, segs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, dateSpanProps: dateSpanProps, popoverContent: () => (preact_cjs.createElement(preact_cjs.Fragment, null, hiddenSegs.map((seg) => {
-                let { eventRange } = seg;
-                let instanceId = eventRange.instance.instanceId;
-                return (preact_cjs.createElement("div", { key: instanceId, style: { visibility: forcedInvisibleMap[instanceId] ? 'hidden' : '' } },
-                    preact_cjs.createElement(TimelineEvent, Object.assign({ isTimeScale: props.isTimeScale, eventRange: eventRange, isStart: seg.isStart, isEnd: seg.isEnd, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === props.eventSelection }, internal_cjs.getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
-            }))) }, (InnerContent) => (preact_cjs.createElement(InnerContent, { tag: "div", className: 'fc-timeline-more-link-inner fc-sticky-s' }))));
-    }
-}
-
-/*
-TODO: make DRY with other Event Harnesses
-*/
-class TimelineEventHarness extends preact_cjs.Component {
-    constructor() {
-        super(...arguments);
-        // ref
-        this.rootElRef = preact_cjs.createRef();
-    }
-    render() {
-        const { props } = this;
-        return (preact_cjs.createElement("div", { className: "fc-abs", style: props.style, ref: this.rootElRef }, props.children));
-    }
-    componentDidMount() {
-        const rootEl = this.rootElRef.current; // TODO: make dynamic with useEffect
-        this.disconnectHeight = internal_cjs.watchHeight(rootEl, (height) => {
-            internal_cjs.setRef(this.props.heightRef, height);
-        });
-    }
-    componentWillUnmount() {
-        this.disconnectHeight();
-        internal_cjs.setRef(this.props.heightRef, null);
-    }
-}
-
-/*
-TODO: split TimelineLaneBg and TimelineLaneFg?
-*/
-class TimelineLane extends internal_cjs.BaseComponent {
-    constructor() {
-        super(...arguments);
-        // memo
-        this.sortEventSegs = internal_cjs.memoize(internal_cjs.sortEventSegs);
-        // refs
-        this.segHeightRefMap = new internal_cjs.RefMap(() => {
-            internal_cjs.afterSize(this.handleSegHeights);
-        });
-        this.moreLinkHeightRefMap = new internal_cjs.RefMap(() => {
-            internal_cjs.afterSize(this.handleMoreLinkHeights);
-        });
-        // internal
-        this.slicer = new TimelineLaneSlicer();
-        this.handleMoreLinkHeights = () => {
-            this.setState({ moreLinkHeightRev: this.moreLinkHeightRefMap.rev }); // will trigger rerender
-        };
-        this.handleSegHeights = () => {
-            this.setState({ segHeightRev: this.segHeightRefMap.rev }); // will trigger rerender
-        };
-    }
-    /*
-    TODO: lots of memoization needed here!
-    */
-    render() {
-        let { props, context, segHeightRefMap, moreLinkHeightRefMap } = this;
-        let { options } = context;
-        let { dateProfile, tDateProfile } = props;
-        let slicedProps = this.slicer.sliceProps(props, dateProfile, tDateProfile.isTimeScale ? null : props.nextDayThreshold, context, // wish we didn't have to pass in the rest of the args...
-        dateProfile, context.dateProfileGenerator, tDateProfile, context.dateEnv);
-        let mirrorSegs = (slicedProps.eventDrag ? slicedProps.eventDrag.segs : null) ||
-            (slicedProps.eventResize ? slicedProps.eventResize.segs : null) ||
-            [];
-        let fgSegs = this.sortEventSegs(slicedProps.fgEventSegs, options.eventOrder);
-        let fgSegHorizontals = props.slotWidth != null
-            ? computeManySegHorizontals(fgSegs, options.eventMinWidth, context.dateEnv, tDateProfile, props.slotWidth)
-            : {};
-        let [fgSegTops, hiddenGroups, hiddenGroupTops, totalHeight] = computeFgSegPlacements(fgSegs, fgSegHorizontals, segHeightRefMap.current, moreLinkHeightRefMap.current, options.eventOrderStrict, options.eventMaxStack);
-        let forcedInvisibleMap = // TODO: more convenient/DRY
-         (slicedProps.eventDrag ? slicedProps.eventDrag.affectedInstances : null) ||
-            (slicedProps.eventResize ? slicedProps.eventResize.affectedInstances : null) ||
-            {};
-        return (preact_cjs.createElement(preact_cjs.Fragment, null,
-            preact_cjs.createElement(TimelineLaneBg, { tDateProfile: tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, 
-                // content
-                bgEventSegs: slicedProps.bgEventSegs, businessHourSegs: slicedProps.businessHourSegs, dateSelectionSegs: slicedProps.dateSelectionSegs, eventResizeSegs: slicedProps.eventResize ? slicedProps.eventResize.segs : [] /* bad new empty array? */, 
-                // dimensions
-                slotWidth: props.slotWidth }),
-            preact_cjs.createElement("div", { className: internal_cjs.joinClassNames('fc-timeline-events', options.eventOverlap === false // TODO: fix bad default
-                    ? 'fc-timeline-events-overlap-disabled'
-                    : 'fc-timeline-events-overlap-enabled', 'fc-content-box'), style: { height: totalHeight } },
-                this.renderFgSegs(fgSegs, fgSegHorizontals, fgSegTops, forcedInvisibleMap, hiddenGroups, hiddenGroupTops, false, // isDragging
-                false, // isResizing
-                false),
-                this.renderFgSegs(mirrorSegs, props.slotWidth // TODO: memoize
-                    ? computeManySegHorizontals(mirrorSegs, options.eventMinWidth, context.dateEnv, tDateProfile, props.slotWidth)
-                    : {}, fgSegTops, {}, // forcedInvisibleMap
-                [], // hiddenGroups
-                new Map(), // hiddenGroupTops
-                Boolean(slicedProps.eventDrag), Boolean(slicedProps.eventResize), false))));
-    }
-    renderFgSegs(segs, segHorizontals, segTops, forcedInvisibleMap, hiddenGroups, hiddenGroupTops, isDragging, isResizing, isDateSelecting) {
-        let { props, context, segHeightRefMap, moreLinkHeightRefMap } = this;
-        let isMirror = isDragging || isResizing || isDateSelecting;
-        return (preact_cjs.createElement(preact_cjs.Fragment, null,
-            segs.map((seg) => {
-                const { eventRange } = seg;
-                const { instanceId } = eventRange.instance;
-                const segTop = segTops.get(instanceId);
-                const segHorizontal = segHorizontals[instanceId];
-                const isVisible = isMirror ||
-                    (segHorizontal && segTop != null && !forcedInvisibleMap[instanceId]);
-                return (preact_cjs.createElement(TimelineEventHarness, { key: instanceId, style: Object.assign({ visibility: isVisible ? '' : 'hidden', top: segTop || 0 }, horizontalsToCss(segHorizontal, context.isRtl)), heightRef: isMirror ? undefined : segHeightRefMap.createRef(instanceId) },
-                    preact_cjs.createElement(TimelineEvent, Object.assign({ isTimeScale: props.tDateProfile.isTimeScale, eventRange: eventRange, isStart: seg.isStart, isEnd: seg.isEnd, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === props.eventSelection /* TODO: bad for mirror? */ }, internal_cjs.getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
-            }),
-            hiddenGroups.map((hiddenGroup) => (preact_cjs.createElement(TimelineEventHarness, { key: hiddenGroup.key, style: Object.assign({ top: hiddenGroupTops.get(hiddenGroup.key) || 0 }, horizontalsToCss({
-                    start: hiddenGroup.start,
-                    size: hiddenGroup.end - hiddenGroup.start
-                }, context.isRtl)), heightRef: moreLinkHeightRefMap.createRef(hiddenGroup.key) },
-                preact_cjs.createElement(TimelineLaneMoreLink, { hiddenSegs: hiddenGroup.segs, dateProfile: props.dateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isTimeScale: props.tDateProfile.isTimeScale, eventSelection: props.eventSelection, resourceId: props.resourceId, forcedInvisibleMap: forcedInvisibleMap }))))));
-    }
-}
-
-class TimelineHeaderCell extends internal_cjs.BaseComponent {
-    constructor() {
-        super(...arguments);
-        // memo
-        this.refineRenderProps = internal_cjs.memoizeObjArg(refineRenderProps);
-        // ref
-        this.innerElRef = preact_cjs.createRef();
-    }
-    render() {
-        let { props, context } = this;
-        let { dateEnv, options } = context;
-        let { cell, dateProfile, tDateProfile } = props;
-        // the cell.rowUnit is f'd
-        // giving 'month' for a 3-day view
-        // workaround: to infer day, do NOT time
-        let dateMeta = internal_cjs.getDateMeta(cell.date, props.todayRange, props.nowDate, dateProfile);
-        let renderProps = this.refineRenderProps({
-            level: props.rowLevel,
-            dateMarker: cell.date,
-            text: cell.text,
-            dateEnv: context.dateEnv,
-            viewApi: context.viewApi,
-        });
-        let isNavLink = !dateMeta.isDisabled && (cell.rowUnit && cell.rowUnit !== 'time');
-        return (preact_cjs.createElement(internal_cjs.ContentContainer, { tag: "div", className: internal_cjs.joinClassNames('fc-timeline-slot-label fc-timeline-slot', cell.isWeekStart && 'fc-timeline-slot-em', // TODO: document this semantic className
-            'fc-header-cell fc-cell fc-flex-col fc-justify-center', props.borderStart && 'fc-border-s', props.isCentered ? 'fc-align-center' : 'fc-align-start', 
-            // TODO: so slot classnames for week/month/bigger. see note above about rowUnit
-            cell.rowUnit === 'time' ?
-                internal_cjs.getSlotClassName(dateMeta) :
-                internal_cjs.getDayClassName(dateMeta)), attrs: Object.assign({ 'data-date': dateEnv.formatIso(cell.date, {
-                    omitTime: !tDateProfile.isTimeScale,
-                    omitTimeZoneOffset: true,
-                }) }, (dateMeta.isToday ? { 'aria-current': 'date' } : {})), style: {
-                width: props.slotWidth != null
-                    ? props.slotWidth * cell.colspan
-                    : undefined,
-            }, renderProps: renderProps, generatorName: "slotLabelContent", customGenerator: options.slotLabelContent, defaultGenerator: renderInnerContent, classNameGenerator: options.slotLabelClassNames, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, (InnerContent) => (preact_cjs.createElement(InnerContent, { tag: 'div', attrs: isNavLink
-                // not tabbable because parent is aria-hidden
-                ? internal_cjs.buildNavLinkAttrs(context, cell.date, cell.rowUnit, undefined, /* isTabbable = */ false)
-                : {} // don't bother with aria-hidden because parent already hidden
-            , className: internal_cjs.joinClassNames('fc-cell-inner fc-padding-md', props.isSticky && 'fc-sticky-s'), elRef: this.innerElRef }))));
-    }
-    componentDidMount() {
-        const { props } = this;
-        const innerEl = this.innerElRef.current; // TODO: make dynamic with useEffect
-        this.detachSize = internal_cjs.watchSize(innerEl, (width, height) => {
-            internal_cjs.setRef(props.innerWidthRef, width);
-            internal_cjs.setRef(props.innerHeightRef, height);
-            // HACK for sticky-centering
-            innerEl.style.left = innerEl.style.right =
-                (props.isCentered && props.isSticky)
-                    ? `calc(50% - ${width / 2}px)`
-                    : '';
-        });
-    }
-    componentWillUnmount() {
-        const { props } = this;
-        this.detachSize();
-        internal_cjs.setRef(props.innerWidthRef, null);
-        internal_cjs.setRef(props.innerHeightRef, null);
-    }
-}
-// Utils
-// -------------------------------------------------------------------------------------------------
-function renderInnerContent(renderProps) {
-    return renderProps.text;
-}
-function refineRenderProps(input) {
-    return {
-        level: input.level,
-        date: input.dateEnv.toDate(input.dateMarker),
-        view: input.viewApi,
-        text: input.text,
-    };
-}
-
-class TimelineHeaderRow extends internal_cjs.BaseComponent {
-    constructor() {
-        super(...arguments);
-        // refs
-        this.innerWidthRefMap = new internal_cjs.RefMap(() => {
-            internal_cjs.afterSize(this.handleInnerWidths);
-        });
-        this.innerHeightRefMap = new internal_cjs.RefMap(() => {
-            internal_cjs.afterSize(this.handleInnerHeights);
-        });
-        this.handleInnerWidths = () => {
-            const innerWidthMap = this.innerWidthRefMap.current;
-            let max = 0;
-            for (const innerWidth of innerWidthMap.values()) {
-                max = Math.max(max, innerWidth);
-            }
-            // TODO: ensure not equal?
-            internal_cjs.setRef(this.props.innerWidthRef, max);
-        };
-        this.handleInnerHeights = () => {
-            const innerHeightMap = this.innerHeightRefMap.current;
-            let max = 0;
-            for (const innerHeight of innerHeightMap.values()) {
-                max = Math.max(max, innerHeight);
-            }
-            // TODO: ensure not equal?
-            internal_cjs.setRef(this.props.innerHeighRef, max);
-        };
-    }
-    render() {
-        const { props, innerWidthRefMap, innerHeightRefMap } = this;
-        const isCentered = !(props.tDateProfile.isTimeScale && props.isLastRow);
-        const isSticky = !props.isLastRow;
-        return (preact_cjs.createElement("div", { className: internal_cjs.joinClassNames('fc-flex-row fc-grow', // TODO: move fc-grow to parent?
-            !props.isLastRow && 'fc-border-b') }, props.cells.map((cell, cellI) => {
-            // TODO: make this part of the cell obj?
-            // TODO: rowUnit seems wrong sometimes. says 'month' when it should be day
-            // TODO: rowUnit is relevant to whole row. put it on a row object, not the cells
-            // TODO: use rowUnit to key the Row itself?
-            const key = cell.rowUnit + ':' + cell.date.toISOString();
-            return (preact_cjs.createElement(TimelineHeaderCell, { key: key, cell: cell, rowLevel: props.rowLevel, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, todayRange: props.todayRange, nowDate: props.nowDate, isCentered: isCentered, isSticky: isSticky, borderStart: Boolean(cellI), 
-                // refs
-                innerWidthRef: innerWidthRefMap.createRef(key), innerHeightRef: innerHeightRefMap.createRef(key), 
-                // dimensions
-                slotWidth: props.slotWidth }));
-        })));
-    }
-    componentWillUnmount() {
-        internal_cjs.setRef(this.props.innerWidthRef, null);
-        internal_cjs.setRef(this.props.innerHeighRef, null);
-    }
-}
-
-class TimelineNowIndicatorLine extends internal_cjs.BaseComponent {
-    render() {
-        const { props, context } = this;
-        return (preact_cjs.createElement("div", { className: "fc-timeline-now-indicator-container" },
-            preact_cjs.createElement(internal_cjs.NowIndicatorContainer // TODO: make separate component?
-            , { className: 'fc-timeline-now-indicator-line', style: props.slotWidth != null
-                    ? horizontalCoordToCss(dateToCoord(props.nowDate, context.dateEnv, props.tDateProfile, props.slotWidth), context.isRtl)
-                    : {}, isAxis: false, date: props.nowDate })));
-    }
-}
-
-class TimelineNowIndicatorArrow extends internal_cjs.BaseComponent {
-    render() {
-        const { props, context } = this;
-        return (preact_cjs.createElement("div", { className: "fc-timeline-now-indicator-container" },
-            preact_cjs.createElement(internal_cjs.NowIndicatorContainer, { className: 'fc-timeline-now-indicator-arrow', style: props.slotWidth != null
-                    ? horizontalCoordToCss(dateToCoord(props.nowDate, context.dateEnv, props.tDateProfile, props.slotWidth), context.isRtl)
-                    : {}, isAxis: true, date: props.nowDate })));
-    }
-}
-
-class TimelineView extends internal_cjs.DateComponent {
-    constructor() {
-        super(...arguments);
-        // memoized
-        this.buildTimelineDateProfile = internal_cjs.memoize(buildTimelineDateProfile);
-        this.computeSlotWidth = internal_cjs.memoize(computeSlotWidth);
-        // refs
-        this.headerScrollerRef = preact_cjs.createRef();
-        this.bodyScrollerRef = preact_cjs.createRef();
-        this.footerScrollerRef = preact_cjs.createRef();
-        this.headerRowInnerWidthMap = new internal_cjs.RefMap(() => {
-            internal_cjs.afterSize(this.handleSlotInnerWidths);
-        });
-        this.scrollTime = null;
-        // Sizing
-        // -----------------------------------------------------------------------------------------------
-        this.handleBodySlotInnerWidth = (innerWidth) => {
-            this.bodySlotInnerWidth = innerWidth;
-            internal_cjs.afterSize(this.handleSlotInnerWidths);
-        };
-        this.handleSlotInnerWidths = () => {
-            const { state } = this;
-            const slotInnerWidth = Math.max(this.headerRowInnerWidthMap.current.get(this.tDateProfile.cellRows.length - 1) || 0, this.bodySlotInnerWidth);
-            if (state.slotInnerWidth !== slotInnerWidth) {
-                this.setState({ slotInnerWidth });
-            }
-        };
-        this.handleClientWidth = (clientWidth) => {
-            this.setState({
-                clientWidth,
-            });
-        };
-        this.handleEndScrollbarWidth = (endScrollbarWidth) => {
-            this.setState({
-                endScrollbarWidth
-            });
-        };
-        this.handleTimeScrollRequest = (scrollTime) => {
-            this.scrollTime = scrollTime;
-            this.applyTimeScroll();
-        };
-        this.handleTimeScrollEnd = ({ isUser }) => {
-            if (isUser) {
-                this.scrollTime = null;
-            }
-        };
-        // Hit System
-        // -----------------------------------------------------------------------------------------------
-        this.handeBodyEl = (el) => {
-            this.bodyEl = el;
-            if (el) {
-                this.context.registerInteractiveComponent(this, { el });
-            }
-            else {
-                this.context.unregisterInteractiveComponent(this);
-            }
-        };
-    }
-    render() {
-        const { props, state, context } = this;
-        const { options } = context;
-        /* date */
-        const tDateProfile = this.tDateProfile = this.buildTimelineDateProfile(props.dateProfile, context.dateEnv, options, context.dateProfileGenerator);
-        const { cellRows } = tDateProfile;
-        const timerUnit = internal_cjs.greatestDurationDenominator(tDateProfile.slotDuration).unit;
-        /* table settings */
-        const verticalScrolling = !props.forPrint && !internal_cjs.getIsHeightAuto(options);
-        const stickyHeaderDates = !props.forPrint && internal_cjs.getStickyHeaderDates(options);
-        const stickyFooterScrollbar = !props.forPrint && internal_cjs.getStickyFooterScrollbar(options);
-        /* table positions */
-        const [canvasWidth, slotWidth] = this.computeSlotWidth(tDateProfile.slotCnt, tDateProfile.slotsPerLabel, options.slotMinWidth, state.slotInnerWidth, // is ACTUALLY the label width. rename?
-        state.clientWidth);
-        this.slotWidth = slotWidth;
-        return (preact_cjs.createElement(internal_cjs.NowTimer, { unit: timerUnit }, (nowDate, todayRange) => {
-            const enableNowIndicator = // TODO: DRY
-             options.nowIndicator &&
-                slotWidth != null &&
-                internal_cjs.rangeContainsMarker(props.dateProfile.currentRange, nowDate);
-            return (preact_cjs.createElement(internal_cjs.ViewContainer, { viewSpec: context.viewSpec, className: internal_cjs.joinClassNames('fc-timeline fc-border', 
-                // HACK for Safari print-mode, where fc-scroller-no-bars won't take effect for
-                // the below Scrollers if they have liquid flex height
-                !props.forPrint && 'fc-flex-col') },
-                preact_cjs.createElement(internal_cjs.Scroller, { horizontal: true, hideScrollbars: true, className: internal_cjs.joinClassNames('fc-timeline-header fc-flex-row fc-border-b', stickyHeaderDates && 'fc-table-header-sticky'), ref: this.headerScrollerRef },
-                    preact_cjs.createElement("div", { 
-                        // TODO: DRY
-                        className: internal_cjs.joinClassNames('fc-rel', // origin for now-indicator
-                        canvasWidth == null && 'fc-liquid'), style: { width: canvasWidth } },
-                        cellRows.map((cells, rowLevel) => {
-                            const isLast = rowLevel === cellRows.length - 1;
-                            return (preact_cjs.createElement(TimelineHeaderRow, { key: rowLevel, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, rowLevel: rowLevel, isLastRow: isLast, cells: cells, slotWidth: slotWidth, innerWidthRef: this.headerRowInnerWidthMap.createRef(rowLevel) }));
-                        }),
-                        enableNowIndicator && (preact_cjs.createElement(TimelineNowIndicatorArrow, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth }))),
-                    Boolean(state.endScrollbarWidth) && (preact_cjs.createElement("div", { className: 'fc-border-s fc-filler', style: { minWidth: state.endScrollbarWidth } }))),
-                preact_cjs.createElement(internal_cjs.Scroller, { vertical: verticalScrolling, horizontal: true, hideScrollbars: props.forPrint, className: internal_cjs.joinClassNames('fc-timeline-body fc-flex-col', verticalScrolling && 'fc-liquid'), ref: this.bodyScrollerRef, clientWidthRef: this.handleClientWidth, endScrollbarWidthRef: this.handleEndScrollbarWidth },
-                    preact_cjs.createElement("div", { "aria-label": options.eventsHint, className: "fc-rel fc-grow", style: { width: canvasWidth }, ref: this.handeBodyEl },
-                        preact_cjs.createElement(TimelineSlats, { dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, 
-                            // ref
-                            innerWidthRef: this.handleBodySlotInnerWidth, 
-                            // dimensions
-                            slotWidth: slotWidth }),
-                        preact_cjs.createElement(TimelineLane, { dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, nextDayThreshold: options.nextDayThreshold, eventStore: props.eventStore, eventUiBases: props.eventUiBases, businessHours: props.businessHours, dateSelection: props.dateSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, eventSelection: props.eventSelection, slotWidth: slotWidth }),
-                        enableNowIndicator && (preact_cjs.createElement(TimelineNowIndicatorLine, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth })))),
-                stickyFooterScrollbar && (preact_cjs.createElement(internal_cjs.Scroller, { ref: this.footerScrollerRef, horizontal: true },
-                    preact_cjs.createElement("div", { style: { width: canvasWidth } })))));
-        }));
-    }
-    // Lifecycle
-    // -----------------------------------------------------------------------------------------------
-    componentDidMount() {
-        this.syncedScroller = new internal_cjs$1.ScrollerSyncer(true); // horizontal=true
-        this.updateSyncedScroller();
-        this.resetScroll();
-        this.context.emitter.on('_timeScrollRequest', this.handleTimeScrollRequest);
-        this.syncedScroller.addScrollEndListener(this.handleTimeScrollEnd);
-    }
-    componentDidUpdate(prevProps) {
-        this.updateSyncedScroller();
-        if (prevProps.dateProfile !== this.props.dateProfile && this.context.options.scrollTimeReset) {
-            this.resetScroll();
-        }
-        else {
-            // TODO: inefficient to update so often
-            this.applyTimeScroll();
-        }
-    }
-    componentWillUnmount() {
-        this.syncedScroller.destroy();
-        this.context.emitter.off('_timeScrollRequest', this.handleTimeScrollRequest);
-        this.syncedScroller.removeScrollEndListener(this.handleTimeScrollEnd);
-    }
-    // Scrolling
-    // -----------------------------------------------------------------------------------------------
-    updateSyncedScroller() {
-        this.syncedScroller.handleChildren([
-            this.headerScrollerRef.current,
-            this.bodyScrollerRef.current,
-            this.footerScrollerRef.current
-        ]);
-    }
-    resetScroll() {
-        this.handleTimeScrollRequest(this.context.options.scrollTime);
-    }
-    applyTimeScroll() {
-        const { props, context, tDateProfile, scrollTime, slotWidth } = this;
-        if (scrollTime != null && slotWidth != null) {
-            let x = timeToCoord(scrollTime, context.dateEnv, props.dateProfile, tDateProfile, slotWidth);
-            if (x) {
-                x += 1; // overcome border. TODO: DRY this up
-            }
-            this.syncedScroller.scrollTo({ x });
-        }
-    }
-    queryHit(positionLeft, positionTop, elWidth, elHeight) {
-        const { props, context, tDateProfile, slotWidth } = this;
-        const { dateEnv } = context;
-        if (slotWidth) {
-            const x = context.isRtl ? elWidth - positionLeft : positionLeft;
-            const slatIndex = Math.floor(x / slotWidth);
-            const slatX = slatIndex * slotWidth;
-            const partial = (x - slatX) / slotWidth; // floating point number between 0 and 1
-            const localSnapIndex = Math.floor(partial * tDateProfile.snapsPerSlot); // the snap # relative to start of slat
-            let startDate = dateEnv.add(tDateProfile.slotDates[slatIndex], internal_cjs.multiplyDuration(tDateProfile.snapDuration, localSnapIndex));
-            let endDate = dateEnv.add(startDate, tDateProfile.snapDuration);
-            // TODO: generalize this coord stuff to TimeGrid?
-            let snapWidth = slotWidth / tDateProfile.snapsPerSlot;
-            let startCoord = slatIndex * slotWidth + (snapWidth * localSnapIndex);
-            let endCoord = startCoord + snapWidth;
-            let left, right;
-            if (context.isRtl) {
-                left = elWidth - endCoord;
-                right = elWidth - startCoord;
-            }
-            else {
-                left = startCoord;
-                right = endCoord;
-            }
-            return {
-                dateProfile: props.dateProfile,
-                dateSpan: {
-                    range: { start: startDate, end: endDate },
-                    allDay: !tDateProfile.isTimeScale,
-                },
-                rect: {
-                    left,
-                    right,
-                    top: 0,
-                    bottom: elHeight,
-                },
-                // HACK. TODO: This is expensive to do every hit-query
-                dayEl: this.bodyEl.querySelectorAll('.fc-timeline-slot')[slatIndex],
-                layer: 0,
-            };
-        }
-        return null;
-    }
-}
-
-var css_248z = ".fc-timeline-slots{z-index:1}.fc-timeline-events{position:relative;z-index:2}.fc-timeline-slot-minor{border-style:dotted}.fc-timeline-events-overlap-enabled{padding-bottom:10px}.fc-timeline-event{border-radius:0;font-size:var(--fc-small-font-size);margin-bottom:1px}.fc-direction-ltr .fc-timeline-event.fc-event-end{margin-right:1px}.fc-direction-rtl .fc-timeline-event.fc-event-end{margin-left:1px}.fc-timeline-event .fc-event-inner{align-items:center;display:flex;flex-direction:row;padding:2px 1px}.fc-timeline-event-spacious .fc-event-inner{padding-bottom:5px;padding-top:5px}.fc-timeline-event .fc-event-time{font-weight:700}.fc-timeline-event .fc-event-time,.fc-timeline-event .fc-event-title{padding:0 2px}.fc-timeline-event:not(.fc-event-end) .fc-event-inner:after,.fc-timeline-event:not(.fc-event-start) .fc-event-inner:before{border-color:transparent #000;border-style:solid;border-width:5px;content:\"\";flex-grow:0;flex-shrink:0;height:0;margin:0 1px;opacity:.5;width:0}.fc-direction-ltr .fc-timeline-event:not(.fc-event-start) .fc-event-inner:before,.fc-direction-rtl .fc-timeline-event:not(.fc-event-end) .fc-event-inner:after{border-left:0}.fc-direction-ltr .fc-timeline-event:not(.fc-event-end) .fc-event-inner:after,.fc-direction-rtl .fc-timeline-event:not(.fc-event-start) .fc-event-inner:before{border-right:0}.fc-timeline-more-link{align-items:flex-start;background:var(--fc-more-link-bg-color);color:var(--fc-more-link-text-color);cursor:pointer;display:flex;flex-direction:column;font-size:var(--fc-small-font-size);padding:1px}.fc-direction-ltr .fc-timeline-more-link{margin-right:1px}.fc-direction-rtl .fc-timeline-more-link{margin-left:1px}.fc-timeline-more-link-inner{padding:2px}.fc-timeline-now-indicator-container{bottom:0;left:0;overflow:hidden;pointer-events:none;position:absolute;right:0;top:0;z-index:4}.fc-timeline-now-indicator-arrow{border-bottom-style:solid;border-bottom-width:0;border-color:var(--fc-now-indicator-color);border-left:5px solid transparent;border-right:5px solid transparent;border-top-style:solid;border-top-width:6px;height:0;margin:0 -5px;position:absolute;top:0;width:0}.fc-timeline-now-indicator-line{border-left:1px solid var(--fc-now-indicator-color);bottom:0;position:absolute;top:0}";
-internal_cjs.injectStyles(css_248z);
-
-exports.TimelineHeaderRow = TimelineHeaderRow;
-exports.TimelineLane = TimelineLane;
-exports.TimelineLaneBg = TimelineLaneBg;
-exports.TimelineLaneSlicer = TimelineLaneSlicer;
-exports.TimelineNowIndicatorArrow = TimelineNowIndicatorArrow;
-exports.TimelineNowIndicatorLine = TimelineNowIndicatorLine;
-exports.TimelineSlats = TimelineSlats;
-exports.TimelineView = TimelineView;
-exports.buildTimelineDateProfile = buildTimelineDateProfile;
-exports.computeSlotWidth = computeSlotWidth;
-exports.createHorizontalStyle = createHorizontalStyle;
-exports.createVerticalStyle = createVerticalStyle;
-exports.timeToCoord = timeToCoord;