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

package/{internal.js → esm/internal.js}

@@ -1,6 +1,8 @@
-import { config, createFormatter, greatestDurationDenominator, asCleanDays, createDuration, wholeDivideDurations, asRoughMs, addDays, startOfDay, asRoughSeconds, asRoughMinutes, diffWholeDays, isInt, computeVisibleDayRange, padStart, BaseComponent, getDateMeta, ContentContainer, joinClassNames, getDayClassName, getSlotClassName, watchWidth, setRef, RefMap, afterSize, getEventKey, SegHierarchy, groupIntersectingSegs, buildEventRangeKey, BgEvent, getEventRangeMeta, renderFill, Slicer, intersectRanges, addMs, StandardEvent, MoreLinkContainer, watchHeight, memoize, sortEventSegs, memoizeObjArg, buildNavLinkAttrs, watchSize, NowIndicatorContainer, DateComponent, getIsHeightAuto, getStickyHeaderDates, getStickyFooterScrollbar, NowTimer, rangeContainsMarker, ViewContainer, Scroller, multiplyDuration, injectStyles } from '@fullcalendar/core/internal.js';
-import { createRef, createElement, Fragment, Component } from '@fullcalendar/core/preact.js';
-import { ScrollerSyncer } from '@fullcalendar/scrollgrid/internal.js';
+import { joinClassNames } from '@fullcalendar/core';
+import { config, createFormatter, greatestDurationDenominator, createDuration, wholeDivideDurations, asRoughMs, addDays, computeMajorUnit, isMajorUnit, startOfDay, asRoughSeconds, asRoughMinutes, diffWholeDays, asCleanDays, isInt, computeVisibleDayRange, padStart, BaseComponent, memoize, getDateMeta, ContentContainer, joinArrayishClassNames, buildNavLinkAttrs, generateClassName, watchSize, setRef, RefMap, afterSize, NowIndicatorLineContainer, NowIndicatorDot, NowIndicatorHeaderContainer, Slicer, intersectRanges, addMs, StandardEvent, MoreLinkContainer, getEventRangeMeta, getEventKey, SegHierarchy, groupIntersectingSegs, watchHeight, sortEventSegs, buildEventRangeKey, BgEvent, renderFill, DateComponent, getIsHeightAuto, getStickyHeaderDates, getStickyFooterScrollbar, NowTimer, rangeContainsMarker, ViewContainer, Scroller, FooterScrollbar, Ruler, multiplyDuration } from '@fullcalendar/core/internal';
+import classNames from '@fullcalendar/core/internal-classnames';
+import { createElement, createRef, Fragment, Component } from '@fullcalendar/core/preact';
+import { ScrollerSyncer } from '@fullcalendar/scrollgrid/internal';
 
 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
@@ -29,13 +31,13 @@ const STOCK_SUB_DURATIONS = [
 ];
 function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileGenerator) {
     let tDateProfile = {
-        labelInterval: allOptions.slotLabelInterval,
+        labelInterval: allOptions.slotHeaderInterval,
         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 input = allOptions.slotHeaderFormat;
     let rawFormats = Array.isArray(input) ? input :
         (input != null) ? [input] :
             computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions);
@@ -49,10 +51,6 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
         }
     }
     tDateProfile.largeUnit = largeUnit;
-    tDateProfile.emphasizeWeeks =
-        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())
@@ -88,14 +86,18 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     tDateProfile.timeWindowMs = timeWindowMs;
     tDateProfile.normalizedRange = { start: normalizedStart, end: normalizedEnd };
     let slotDates = [];
+    let slotDatesMajor = [];
     let date = normalizedStart;
+    let majorUnit = computeMajorUnit(dateProfile, dateEnv);
     while (date < normalizedEnd) {
         if (isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator)) {
             slotDates.push(date);
+            slotDatesMajor.push(isMajorUnit(date, majorUnit, dateEnv));
         }
         date = dateEnv.add(date, tDateProfile.slotDuration);
     }
     tDateProfile.slotDates = slotDates;
+    tDateProfile.slotDatesMajor = slotDatesMajor;
     // more...
     let snapIndex = -1;
     let snapDiff = 0; // index of the diff :(
@@ -119,8 +121,7 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     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.cellRows = buildCellRows(tDateProfile, dateEnv, majorUnit);
     tDateProfile.slotsPerLabel = wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
     return tDateProfile;
 }
@@ -181,7 +182,7 @@ function validateLabelAndSlot(tDateProfile, dateProfile, dateEnv) {
     if (tDateProfile.labelInterval) {
         const labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.labelInterval);
         if (labelCnt > config.MAX_TIMELINE_SLOTS) {
-            console.warn('slotLabelInterval results in too many cells');
+            console.warn('slotHeaderInterval results in too many cells');
             tDateProfile.labelInterval = null;
         }
     }
@@ -197,7 +198,7 @@ function validateLabelAndSlot(tDateProfile, dateProfile, dateEnv) {
     if (tDateProfile.labelInterval && tDateProfile.slotDuration) {
         const slotsPerLabel = wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
         if (slotsPerLabel === null || slotsPerLabel < 1) {
-            console.warn('slotLabelInterval must be a multiple of slotDuration');
+            console.warn('slotHeaderInterval must be a multiple of slotDuration');
             tDateProfile.slotDuration = null;
         }
     }
@@ -272,6 +273,7 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
     let format1;
     let format2;
     const { labelInterval } = tDateProfile;
+    const { currentRange } = dateProfile;
     let unit = greatestDurationDenominator(labelInterval).unit;
     const weekNumbersVisible = allOptions.weekNumbers;
     let format0 = (format1 = (format2 = null));
@@ -284,22 +286,22 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
             format0 = { year: 'numeric' }; // '2015'
             break;
         case 'month':
-            if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
+            if (dateEnv.diffWholeYears(currentRange.start, currentRange.end) > 1) {
                 format0 = { year: 'numeric' }; // '2015'
             }
             format1 = { month: 'short' }; // 'Jan'
             break;
         case 'week':
-            if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
+            if (dateEnv.diffWholeYears(currentRange.start, currentRange.end) > 1) {
                 format0 = { year: 'numeric' }; // '2015'
             }
             format1 = { week: 'narrow' }; // 'Wk4'
             break;
         case 'day':
-            if (currentRangeAs('years', dateProfile, dateEnv) > 1) {
+            if (dateEnv.diffWholeYears(currentRange.start, currentRange.end) > 1) {
                 format0 = { year: 'numeric', month: 'long' }; // 'January 2014'
             }
-            else if (currentRangeAs('months', dateProfile, dateEnv) > 1) {
+            else if (dateEnv.diffWholeMonths(currentRange.start, currentRange.end) > 1) {
                 format0 = { month: 'long' }; // 'January'
             }
             if (weekNumbersVisible) {
@@ -311,7 +313,7 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
             if (weekNumbersVisible) {
                 format0 = { week: 'short' }; // 'Wk 4'
             }
-            if (currentRangeAs('days', dateProfile, dateEnv) > 1) {
+            if (diffWholeDays(currentRange.start, currentRange.end) > 1) {
                 format1 = { weekday: 'short', day: 'numeric', month: 'numeric', omitCommas: true }; // Sat 4/7
             }
             format2 = {
@@ -357,39 +359,7 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
     }
     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 = 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) {
+function buildCellRows(tDateProfile, dateEnv, majorUnit) {
     let slotDates = tDateProfile.slotDates;
     let formats = tDateProfile.headerFormats;
     let cellRows = formats.map(() => []); // indexed by row,col
@@ -398,23 +368,23 @@ function buildCellRows(tDateProfile, dateEnv) {
         slotAsDays === 1 ? 'day' :
             null;
     // specifically for navclicks
-    let rowUnitsFromFormats = formats.map((format) => (format.getLargestUnit ? format.getLargestUnit() : null));
+    let rowUnitsFromFormats = formats.map((format) => (format.getSmallestUnit ? format.getSmallestUnit() : 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 isMajor = isMajorUnit(date, majorUnit, dateEnv);
             let newCell = null;
             let rowUnit = rowUnitsFromFormats[row] || (isLastRow ? guessedSlotUnit : null);
             if (isSuperRow) {
-                let text = dateEnv.format(date, format);
+                let [text] = dateEnv.format(date, format);
                 if (!leadingCell || (leadingCell.text !== text)) {
-                    newCell = buildCellObject(date, text, rowUnit);
+                    newCell = buildCellObject(date, isMajor, text, rowUnit);
                 }
                 else {
                     leadingCell.colspan += 1;
@@ -422,159 +392,202 @@ function buildCellRows(tDateProfile, dateEnv) {
             }
             else if (!leadingCell ||
                 isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.labelInterval))) {
-                let text = dateEnv.format(date, format);
-                newCell = buildCellObject(date, text, rowUnit);
+                let [text] = dateEnv.format(date, format);
+                newCell = buildCellObject(date, isMajor, 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 };
+function buildCellObject(date, isMajor, text, rowUnit) {
+    return { date, isMajor, text, rowUnit, colspan: 1 }; // colspan mutated later
 }
 
 class TimelineSlatCell extends BaseComponent {
     constructor() {
         super(...arguments);
-        // ref
-        this.innerElRef = createRef();
+        // memo
+        this.getDateMeta = memoize(getDateMeta);
     }
     render() {
         let { props, context } = this;
         let { dateEnv, options } = context;
-        let { date, tDateProfile, isEm } = props;
-        let dateMeta = 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 (createElement(ContentContainer, { tag: "div", 
-            // fc-align-start shrinks width of InnerContent
-            // TODO: document this semantic className fc-timeline-slot-em
-            className: joinClassNames('fc-timeline-slot', isEm && 'fc-timeline-slot-em', tDateProfile.isTimeScale && (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 ?
-                getDayClassName(dateMeta) :
-                getSlotClassName(dateMeta)), attrs: Object.assign({ 'data-date': dateEnv.formatIso(date, {
+        let { date, tDateProfile, isMajor } = props;
+        let dateMeta = this.getDateMeta(props.date, dateEnv, props.dateProfile, props.todayRange, props.nowDate);
+        let isMinor = tDateProfile.isTimeScale &&
+            !isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, props.date, tDateProfile.labelInterval));
+        let renderProps = Object.assign(Object.assign({}, dateMeta), { isMajor,
+            isMinor, view: context.viewApi });
+        return (createElement(ContentContainer, { tag: "div", className: joinClassNames(classNames.tight, classNames.alignStart, // shrinks width of InnerContent
+            props.borderStart ? classNames.borderOnlyS : classNames.borderNone, classNames.internalTimelineSlot), 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) => (createElement(InnerContent, { tag: "div", className: 'fc-cell-inner', elRef: this.innerElRef }))));
+            }, renderProps: renderProps, generatorName: undefined, classNameGenerator: options.slotLaneClass, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount }));
+    }
+}
+
+class TimelineSlats extends BaseComponent {
+    render() {
+        let { props } = this;
+        let { tDateProfile, slotWidth } = props;
+        let { slotDates, slotDatesMajor } = tDateProfile;
+        return (createElement("div", { "aria-hidden": true, className: joinClassNames(classNames.flexRow, classNames.fill), style: { height: props.height } }, slotDates.map((slotDate, i) => {
+            let key = slotDate.toISOString();
+            return (createElement(TimelineSlatCell, { key: key, date: slotDate, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isMajor: slotDatesMajor[i], borderStart: Boolean(i), 
+                // dimensions
+                width: slotWidth }));
+        })));
+    }
+}
+
+class TimelineHeaderCell extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        // memo
+        this.getDateMeta = memoize(getDateMeta);
+        // ref
+        this.innerWrapperElRef = createRef();
+    }
+    render() {
+        let { props, state, 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 = this.getDateMeta(cell.date, dateEnv, dateProfile, props.todayRange, props.nowDate);
+        let hasNavLink = options.navLinks && !dateMeta.isDisabled && (cell.rowUnit && cell.rowUnit !== 'time');
+        let isTime = tDateProfile.isTimeScale && !props.rowLevel; // HACK: faulty way of determining this
+        let renderProps = Object.assign(Object.assign({}, dateMeta), { level: props.rowLevel, isMajor: cell.isMajor, isMinor: false, isNarrow: false, isTime,
+            hasNavLink, text: cell.text, isFirst: props.isFirst, view: context.viewApi });
+        const { slotHeaderAlign } = options;
+        const align = this.align =
+            typeof slotHeaderAlign === 'function'
+                ? slotHeaderAlign({ level: props.rowLevel, isTime })
+                : slotHeaderAlign;
+        const isSticky = this.isSticky =
+            props.rowLevel && options.slotHeaderSticky !== false;
+        let edgeCoord;
+        if (isSticky) {
+            if (align === 'center') {
+                if (state.innerWidth != null) {
+                    edgeCoord = `calc(50% - ${state.innerWidth / 2}px)`;
+                }
+            }
+            else {
+                edgeCoord = (typeof options.slotHeaderSticky === 'number' ||
+                    typeof options.slotHeaderSticky === 'string') ? options.slotHeaderSticky : 0;
+            }
+        }
+        return (createElement(ContentContainer, { tag: "div", className: joinArrayishClassNames(classNames.tight, classNames.flexCol, props.isFirst ? classNames.borderNone : classNames.borderOnlyS, align === 'center' ? classNames.alignCenter :
+                align === 'end' ? classNames.alignEnd :
+                    classNames.alignStart, classNames.internalTimelineSlot), 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: "slotHeaderContent", customGenerator: options.slotHeaderContent, defaultGenerator: renderInnerContent, classNameGenerator: options.slotHeaderClass, didMount: options.slotHeaderDidMount, willUnmount: options.slotHeaderWillUnmount }, (InnerContent) => (createElement("div", { ref: this.innerWrapperElRef, className: joinClassNames(classNames.flexCol, classNames.rigid, isSticky && classNames.sticky), style: {
+                left: edgeCoord,
+                right: edgeCoord,
+            } },
+            createElement(InnerContent, { tag: 'div', attrs: hasNavLink
+                    // not tabbable because parent is aria-hidden
+                    ? buildNavLinkAttrs(context, cell.date, cell.rowUnit, undefined, /* isTabbable = */ false)
+                    : {} // don't bother with aria-hidden because parent already hidden
+                , className: generateClassName(options.slotHeaderInnerClass, renderProps) })))));
     }
     componentDidMount() {
-        const innerEl = this.innerElRef.current;
-        this.disconnectInnerWidth = watchWidth(innerEl, (width) => {
-            setRef(this.props.innerWidthRef, width);
+        const { props } = this;
+        const innerWrapperEl = this.innerWrapperElRef.current; // TODO: make dynamic with useEffect
+        this.disconnectSize = watchSize(innerWrapperEl, (width, height) => {
+            setRef(props.innerWidthRef, width);
+            setRef(props.innerHeightRef, height);
+            if (this.align === 'center' && this.isSticky) {
+                this.setState({ innerWidth: width });
+            }
         });
     }
     componentWillUnmount() {
-        this.disconnectInnerWidth();
-        setRef(this.props.innerWidthRef, null);
+        const { props } = this;
+        this.disconnectSize();
+        setRef(props.innerWidthRef, null);
+        setRef(props.innerHeightRef, null);
     }
 }
+// Utils
+// -------------------------------------------------------------------------------------------------
+function renderInnerContent(renderProps) {
+    return renderProps.text;
+}
 
-class TimelineSlats extends BaseComponent {
+class TimelineHeaderRow extends BaseComponent {
     constructor() {
         super(...arguments);
+        // refs
         this.innerWidthRefMap = new RefMap(() => {
             afterSize(this.handleInnerWidths);
         });
+        this.innerHeightRefMap = new RefMap(() => {
+            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: check to see if changed before firing ref!? YES. do in other places too
+            // TODO: ensure not equal?
             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?
+            setRef(this.props.innerHeighRef, max);
+            this.setState({ innerHeight: max });
+        };
     }
     render() {
-        let { props, innerWidthRefMap } = this;
-        let { tDateProfile, slotWidth } = props;
-        let { slotDates, isWeekStarts } = tDateProfile;
-        let isDay = !tDateProfile.isTimeScale && !tDateProfile.largeUnit;
-        return (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 (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), 
+        const { props, innerWidthRefMap, innerHeightRefMap, state, context } = this;
+        const { options } = context;
+        return (createElement("div", { className: joinArrayishClassNames(options.slotHeaderRowClass, classNames.flexRow, classNames.grow, props.rowLevel // not the last row?
+                ? classNames.borderOnlyB
+                : classNames.borderNone), style: {
+                // we assign height because we allow cells to have distorted heights for visual effect
+                // but we still want to keep the overall extrenal mass
+                height: state.innerHeight,
+            } }, 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 (createElement(TimelineHeaderCell, { key: key, cell: cell, rowLevel: props.rowLevel, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, todayRange: props.todayRange, nowDate: props.nowDate, isFirst: cellI === 0, 
+                // refs
+                innerWidthRef: innerWidthRefMap.createRef(key), innerHeightRef: innerHeightRefMap.createRef(key), 
                 // dimensions
-                width: slotWidth }));
+                slotWidth: props.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 (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 };
+    componentWillUnmount() {
+        setRef(this.props.innerWidthRef, null);
+        setRef(this.props.innerHeighRef, null);
     }
 }
 
-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
@@ -587,17 +600,17 @@ function computeSlotWidth(slatCnt, slatsPerLabel, slatMinWidth, labelInnerWidth,
     }
     slatMinWidth = Math.max(slatMinWidth || 0, (labelInnerWidth + 1) / slatsPerLabel, MIN_SLOT_WIDTH);
     const slatTryWidth = viewportWidth / slatCnt;
-    let slatLiquid;
+    let slotLiquid;
     let slatWidth;
     if (slatTryWidth >= slatMinWidth) {
-        slatLiquid = true;
+        slotLiquid = true;
         slatWidth = slatTryWidth;
     }
     else {
-        slatLiquid = false;
+        slotLiquid = false;
         slatWidth = Math.max(slatMinWidth, slatTryWidth);
     }
-    return [slatWidth * slatCnt, slatWidth, slatLiquid];
+    return [slatWidth * slatCnt, slatWidth, slotLiquid];
 }
 function timeToCoord(// pixels
 time, dateEnv, dateProfile, tDateProfile, slowWidth) {
@@ -609,13 +622,86 @@ time, dateEnv, dateProfile, tDateProfile, slowWidth) {
 }
 function dateToCoord(// pixels
 date, dateEnv, tDateProfile, slotWidth) {
-    let snapCoverage = computeDateSnapCoverage(date, tDateProfile, dateEnv);
+    let snapCoverage = computeDateSnapCoverage$1(date, tDateProfile, dateEnv);
     let slotCoverage = snapCoverage / tDateProfile.snapsPerSlot;
     return slotCoverage * slotWidth;
 }
 /*
 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 (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;
+}
+
+class TimelineNowIndicatorLine extends BaseComponent {
+    render() {
+        const { props, context } = this;
+        const xStyle = props.slotWidth == null
+            ? {}
+            : {
+                insetInlineStart: dateToCoord(props.nowDate, context.dateEnv, props.tDateProfile, props.slotWidth)
+            };
+        return (createElement("div", { className: classNames.fill, style: {
+                zIndex: 2,
+                pointerEvents: 'none', // TODO: className
+            } },
+            createElement(NowIndicatorLineContainer, { className: joinClassNames(classNames.fillY, classNames.noMarginY, classNames.borderlessY), style: xStyle, date: props.nowDate }),
+            createElement("div", { className: joinClassNames(classNames.flexCol, // better for negative margins
+                classNames.fillY), style: xStyle },
+                createElement("div", { 
+                    // stickiness on NowIndicatorDot misbehaves b/c of negative marginss
+                    className: classNames.stickyT },
+                    createElement(NowIndicatorDot, null)))));
+    }
+}
+
+/*
+TODO: DRY with other NowIndicator components
+*/
+class TimelineNowIndicatorArrow extends BaseComponent {
+    render() {
+        const { props, context } = this;
+        const xStyle = props.slotWidth == null
+            ? {}
+            : {
+                insetInlineStart: dateToCoord(props.nowDate, context.dateEnv, props.tDateProfile, props.slotWidth)
+            };
+        return (createElement("div", { 
+            // crop any overflow that the arrow/line might cause
+            // TODO: just do this on the entire canvas within the scroller
+            className: joinClassNames(classNames.fill, classNames.crop), style: {
+                zIndex: 2,
+                pointerEvents: 'none', // TODO: className
+            } },
+            createElement(NowIndicatorHeaderContainer, { className: classNames.abs, style: xStyle, date: props.nowDate })));
+    }
+}
+
+function getTimelineSlotEl(parentEl, index) {
+    return parentEl.querySelectorAll(`.${classNames.internalTimelineSlot}`)[index];
+}
+
+/*
+TODO: rename this file!
+*/
+// 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) {
@@ -637,6 +723,60 @@ function computeDateSnapCoverage(date, tDateProfile, dateEnv) {
     return snapCoverage;
 }
 
+class TimelineLaneSlicer extends 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(normalRange.start, tDateProfile, dateEnv)
+            < computeDateSnapCoverage(normalRange.end, tDateProfile, dateEnv)) {
+            // intersect the footprint's range with the grid's range
+            let slicedRange = 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(addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
+                });
+            }
+        }
+        return segs;
+    }
+}
+
+const DEFAULT_TIME_FORMAT = createFormatter({
+    hour: 'numeric',
+    minute: '2-digit',
+    omitZeroMinute: true,
+    meridiem: 'narrow',
+});
+class TimelineEvent extends BaseComponent {
+    render() {
+        let { props } = this;
+        return (createElement(StandardEvent, Object.assign({}, props, { display: 'row', defaultTimeFormat: DEFAULT_TIME_FORMAT, defaultDisplayEventTime: !props.isTimeScale })));
+    }
+}
+
+class TimelineLaneMoreLink extends BaseComponent {
+    render() {
+        let { props } = this;
+        let { hiddenSegs, resourceId } = props;
+        let dateSpanProps = resourceId ? { resourceId } : {};
+        return (createElement(MoreLinkContainer, { display: 'row', allDayDate: null, segs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, dateSpanProps: dateSpanProps, isNarrow: false, isMicro: false, popoverContent: () => (createElement(Fragment, null, hiddenSegs.map((seg) => {
+                let { eventRange } = seg;
+                let { instanceId } = eventRange.instance;
+                let isDragging = Boolean(props.eventDrag && props.eventDrag.affectedInstances[instanceId]);
+                let isResizing = Boolean(props.eventResize && props.eventResize.affectedInstances[instanceId]);
+                let isInvisible = isDragging || isResizing;
+                return (createElement("div", { key: instanceId, style: { visibility: isInvisible ? 'hidden' : undefined } },
+                    createElement(TimelineEvent, Object.assign({ isTimeScale: props.isTimeScale, eventRange: eventRange, isStart: seg.isStart, isEnd: seg.isEnd, isDragging: isDragging, isResizing: isResizing, isMirror: false, isSelected: instanceId === props.eventSelection }, getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
+            }))) }));
+    }
+}
+
 function computeManySegHorizontals(segs, segMinWidth, dateEnv, tDateProfile, slotWidth) {
     const res = {};
     for (const seg of segs) {
@@ -701,83 +841,6 @@ hiddenGroupHeights, strictOrder, maxDepth) {
     ];
 }
 
-class TimelineLaneBg extends BaseComponent {
-    render() {
-        let { props } = this;
-        let highlightSeg = [].concat(props.eventResizeSegs, props.dateSelectionSegs);
-        return (createElement(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 (createElement(Fragment, null, segs.map((seg) => {
-            let hStyle; // TODO
-            if (slotWidth != null) {
-                let segHorizontal = computeSegHorizontals(seg, undefined, dateEnv, tDateProfile, slotWidth);
-                hStyle = horizontalsToCss(segHorizontal, isRtl);
-            }
-            return (createElement("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-fill-y", style: hStyle }, fillType === 'bg-event' ?
-                createElement(BgEvent, Object.assign({ eventRange: seg.eventRange, isStart: seg.isStart, isEnd: seg.isEnd }, getEventRangeMeta(seg.eventRange, todayRange, nowDate))) : (renderFill(fillType))));
-        })));
-    }
-}
-
-class TimelineLaneSlicer extends 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 = 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(addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
-                });
-            }
-        }
-        return segs;
-    }
-}
-
-const DEFAULT_TIME_FORMAT = createFormatter({
-    hour: 'numeric',
-    minute: '2-digit',
-    omitZeroMinute: true,
-    meridiem: 'narrow',
-});
-class TimelineEvent extends BaseComponent {
-    render() {
-        let { props, context } = this;
-        let { options } = context;
-        return (createElement(StandardEvent, Object.assign({}, props, { className: 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 BaseComponent {
-    render() {
-        let { props } = this;
-        let { hiddenSegs, resourceId, forcedInvisibleMap } = props;
-        let dateSpanProps = resourceId ? { resourceId } : {};
-        return (createElement(MoreLinkContainer, { className: 'fc-timeline-more-link', allDayDate: null, segs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, dateSpanProps: dateSpanProps, popoverContent: () => (createElement(Fragment, null, hiddenSegs.map((seg) => {
-                let { eventRange } = seg;
-                let instanceId = eventRange.instance.instanceId;
-                return (createElement("div", { key: instanceId, style: { visibility: forcedInvisibleMap[instanceId] ? 'hidden' : '' } },
-                    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 }, getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
-            }))) }, (InnerContent) => (createElement(InnerContent, { tag: "div", className: 'fc-timeline-more-link-inner fc-sticky-s' }))));
-    }
-}
-
 /*
 TODO: make DRY with other Event Harnesses
 */
@@ -789,7 +852,7 @@ class TimelineEventHarness extends Component {
     }
     render() {
         const { props } = this;
-        return (createElement("div", { className: "fc-abs", style: props.style, ref: this.rootElRef }, props.children));
+        return (createElement("div", { className: classNames.abs, style: props.style, ref: this.rootElRef }, props.children));
     }
     componentDidMount() {
         const rootEl = this.rootElRef.current; // TODO: make dynamic with useEffect
@@ -803,10 +866,7 @@ class TimelineEventHarness extends Component {
     }
 }
 
-/*
-TODO: split TimelineLaneBg and TimelineLaneFg?
-*/
-class TimelineLane extends BaseComponent {
+class TimelineFg extends BaseComponent {
     constructor() {
         super(...arguments);
         // memo
@@ -818,8 +878,6 @@ class TimelineLane extends BaseComponent {
         this.moreLinkHeightRefMap = new RefMap(() => {
             afterSize(this.handleMoreLinkHeights);
         });
-        // internal
-        this.slicer = new TimelineLaneSlicer();
         this.handleMoreLinkHeights = () => {
             this.setState({ moreLinkHeightRev: this.moreLinkHeightRefMap.rev }); // will trigger rerender
         };
@@ -833,209 +891,92 @@ class TimelineLane extends BaseComponent {
     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 { tDateProfile } = props;
+        let mirrorSegs = (props.eventDrag ? props.eventDrag.segs : null) ||
+            (props.eventResize ? props.eventResize.segs : null) ||
             [];
-        let fgSegs = this.sortEventSegs(slicedProps.fgEventSegs, options.eventOrder);
+        let fgSegs = this.sortEventSegs(props.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 (createElement(Fragment, null,
-            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 }),
-            createElement("div", { className: 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;
+        this.totalHeight = totalHeight;
+        return (createElement("div", { className: joinClassNames(classNames.rel, classNames.noShrink), style: {
+                height: totalHeight,
+            } },
+            this.renderFgSegs(fgSegs, fgSegHorizontals, fgSegTops, hiddenGroups, hiddenGroupTops, 
+            /* isMirror = */ false),
+            this.renderFgSegs(mirrorSegs, props.slotWidth // TODO: memoize
+                ? computeManySegHorizontals(mirrorSegs, options.eventMinWidth, context.dateEnv, tDateProfile, props.slotWidth)
+                : {}, fgSegTops, 
+            /* hiddenGroups = */ [], 
+            /* hiddenGroupTops = */ new Map(), 
+            /* isMirror = */ true)));
+    }
+    renderFgSegs(segs, segHorizontals, segTops, hiddenGroups, hiddenGroupTops, isMirror) {
+        let { props, segHeightRefMap, moreLinkHeightRefMap } = this;
         return (createElement(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 (createElement(TimelineEventHarness, { key: instanceId, style: Object.assign({ visibility: isVisible ? '' : 'hidden', top: segTop || 0 }, horizontalsToCss(segHorizontal, context.isRtl)), heightRef: isMirror ? undefined : segHeightRefMap.createRef(instanceId) },
-                    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? */ }, getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
+                const segHorizontalMaybe = segHorizontals[instanceId];
+                const segHorizontal = segHorizontalMaybe || {};
+                const isDragging = Boolean(props.eventDrag && props.eventDrag.affectedInstances[instanceId]);
+                const isResizing = Boolean(props.eventResize && props.eventResize.affectedInstances[instanceId]);
+                const isInvisible = !isMirror && (isDragging || isResizing || !segHorizontalMaybe || segTop == null);
+                return (createElement(TimelineEventHarness, { key: instanceId, style: {
+                        visibility: isInvisible ? 'hidden' : undefined,
+                        zIndex: 1,
+                        top: segTop || 0,
+                        insetInlineStart: segHorizontal.start,
+                        width: segHorizontal.size,
+                    }, heightRef: isMirror ? undefined : segHeightRefMap.createRef(instanceId) },
+                    createElement(TimelineEvent, Object.assign({ isTimeScale: props.tDateProfile.isTimeScale, eventRange: eventRange, isStart: seg.isStart, isEnd: seg.isEnd, isDragging: isDragging, isResizing: isResizing, isMirror: isMirror, isSelected: instanceId === props.eventSelection }, getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
             }),
-            hiddenGroups.map((hiddenGroup) => (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) },
-                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 BaseComponent {
-    constructor() {
-        super(...arguments);
-        // memo
-        this.refineRenderProps = memoizeObjArg(refineRenderProps);
-        // ref
-        this.innerElRef = 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 = 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 (createElement(ContentContainer, { tag: "div", className: 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' ?
-                getSlotClassName(dateMeta) :
-                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) => (createElement(InnerContent, { tag: 'div', attrs: isNavLink
-                // not tabbable because parent is aria-hidden
-                ? buildNavLinkAttrs(context, cell.date, cell.rowUnit, undefined, /* isTabbable = */ false)
-                : {} // don't bother with aria-hidden because parent already hidden
-            , className: joinClassNames('fc-cell-inner fc-padding-md', props.isSticky && 'fc-sticky-s'), elRef: this.innerElRef }))));
+            hiddenGroups.map((hiddenGroup) => (createElement(TimelineEventHarness, { key: hiddenGroup.key, style: {
+                    top: hiddenGroupTops.get(hiddenGroup.key) || 0,
+                    insetInlineStart: hiddenGroup.start,
+                    width: hiddenGroup.end - hiddenGroup.start,
+                }, heightRef: moreLinkHeightRefMap.createRef(hiddenGroup.key) },
+                createElement(TimelineLaneMoreLink, { hiddenSegs: hiddenGroup.segs, dateProfile: props.dateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isTimeScale: props.tDateProfile.isTimeScale, eventDrag: props.eventDrag, eventResize: props.eventResize, eventSelection: props.eventSelection, resourceId: props.resourceId }))))));
     }
-    componentDidMount() {
-        const { props } = this;
-        const innerEl = this.innerElRef.current; // TODO: make dynamic with useEffect
-        this.detachSize = watchSize(innerEl, (width, height) => {
-            setRef(props.innerWidthRef, width);
-            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();
-        setRef(props.innerWidthRef, null);
-        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 BaseComponent {
-    constructor() {
-        super(...arguments);
-        // refs
-        this.innerWidthRefMap = new RefMap(() => {
-            afterSize(this.handleInnerWidths);
-        });
-        this.innerHeightRefMap = new RefMap(() => {
-            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?
-            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?
-            setRef(this.props.innerHeighRef, max);
-        };
+    /*
+    componentDidMount(): void {
+      // might want to do firedTotalHeight, but won't be ready on first render
     }
-    render() {
-        const { props, innerWidthRefMap, innerHeightRefMap } = this;
-        const isCentered = !(props.tDateProfile.isTimeScale && props.isLastRow);
-        const isSticky = !props.isLastRow;
-        return (createElement("div", { className: 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 (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 }));
-        })));
+    */
+    componentDidUpdate() {
+        if (this.totalHeight !== this.firedTotalHeight) {
+            this.firedTotalHeight = this.totalHeight;
+            setRef(this.props.heightRef, this.totalHeight);
+        }
     }
     componentWillUnmount() {
-        setRef(this.props.innerWidthRef, null);
-        setRef(this.props.innerHeighRef, null);
+        setRef(this.props.heightRef, null);
     }
 }
 
-class TimelineNowIndicatorLine extends BaseComponent {
+class TimelineBg extends BaseComponent {
     render() {
-        const { props, context } = this;
-        return (createElement("div", { className: "fc-timeline-now-indicator-container" },
-            createElement(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 })));
+        let { props } = this;
+        let highlightSeg = [].concat(props.eventResizeSegs || [], props.dateSelectionSegs);
+        return (createElement(Fragment, null,
+            this.renderSegs(props.businessHourSegs || [], 'non-business'),
+            this.renderSegs(props.bgEventSegs || [], 'bg-event'),
+            this.renderSegs(highlightSeg, 'highlight')));
     }
-}
-
-class TimelineNowIndicatorArrow extends BaseComponent {
-    render() {
-        const { props, context } = this;
-        return (createElement("div", { className: "fc-timeline-now-indicator-container" },
-            createElement(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 })));
+    renderSegs(segs, fillType) {
+        let { tDateProfile, todayRange, nowDate, slotWidth } = this.props;
+        let { dateEnv, options } = this.context;
+        return (createElement(Fragment, null, segs.map((seg) => {
+            let hStyle = {};
+            if (slotWidth != null) {
+                let segHorizontal = computeSegHorizontals(seg, undefined, dateEnv, tDateProfile, slotWidth);
+                hStyle = { insetInlineStart: segHorizontal.start, width: segHorizontal.size };
+            }
+            return (createElement("div", { key: buildEventRangeKey(seg.eventRange), className: classNames.fillY, style: hStyle }, fillType === 'bg-event' ? (createElement(BgEvent, Object.assign({ eventRange: seg.eventRange, isStart: seg.isStart, isEnd: seg.isEnd, isVertical: false }, getEventRangeMeta(seg.eventRange, todayRange, nowDate)))) : (renderFill(fillType, options))));
+        })));
     }
 }
 
@@ -1053,34 +994,30 @@ class TimelineView extends DateComponent {
             afterSize(this.handleSlotInnerWidths);
         });
         this.scrollTime = null;
+        this.slicer = new TimelineLaneSlicer();
         // Sizing
         // -----------------------------------------------------------------------------------------------
-        this.handleBodySlotInnerWidth = (innerWidth) => {
-            this.bodySlotInnerWidth = innerWidth;
-            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 });
+            const headerSlotInnerWidth = this.headerRowInnerWidthMap.current.get(this.tDateProfile.cellRows.length - 1);
+            if (headerSlotInnerWidth != null && headerSlotInnerWidth !== this.state.slotInnerWidth) {
+                this.setState({ slotInnerWidth: headerSlotInnerWidth });
             }
         };
-        this.handleClientWidth = (clientWidth) => {
+        this.handleTotalWidth = (totalWidth) => {
             this.setState({
-                clientWidth,
+                totalWidth,
             });
         };
-        this.handleEndScrollbarWidth = (endScrollbarWidth) => {
+        this.handleClientWidth = (clientWidth) => {
             this.setState({
-                endScrollbarWidth
+                clientWidth,
             });
         };
         this.handleTimeScrollRequest = (scrollTime) => {
             this.scrollTime = scrollTime;
             this.applyTimeScroll();
         };
-        this.handleTimeScrollEnd = ({ isUser }) => {
+        this.handleTimeScrollEnd = (isUser) => {
             if (isUser) {
                 this.scrollTime = null;
             }
@@ -1100,6 +1037,10 @@ class TimelineView extends DateComponent {
     render() {
         const { props, state, context } = this;
         const { options } = context;
+        const { totalWidth, clientWidth } = state;
+        const endScrollbarWidth = (totalWidth != null && clientWidth != null)
+            ? totalWidth - clientWidth
+            : undefined;
         /* date */
         const tDateProfile = this.tDateProfile = this.buildTimelineDateProfile(props.dateProfile, context.dateEnv, options, context.dateProfileGenerator);
         const { cellRows } = tDateProfile;
@@ -1110,39 +1051,65 @@ class TimelineView extends DateComponent {
         const stickyFooterScrollbar = !props.forPrint && 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);
+        clientWidth);
         this.slotWidth = slotWidth;
+        /* sliced */
+        let slicedProps = this.slicer.sliceProps(props, props.dateProfile, tDateProfile.isTimeScale ? null : options.nextDayThreshold, context, // wish we didn't have to pass in the rest of the args...
+        props.dateProfile, context.dateProfileGenerator, tDateProfile, context.dateEnv);
         return (createElement(NowTimer, { unit: timerUnit }, (nowDate, todayRange) => {
             const enableNowIndicator = // TODO: DRY
              options.nowIndicator &&
                 slotWidth != null &&
                 rangeContainsMarker(props.dateProfile.currentRange, nowDate);
-            return (createElement(ViewContainer, { viewSpec: context.viewSpec, className: joinClassNames('fc-timeline fc-border', 
-                // HACK for Safari print-mode, where fc-scroller-no-bars won't take effect for
+            return (createElement(ViewContainer, { viewSpec: context.viewSpec, className: joinArrayishClassNames(
+                // HACK for Safari print-mode, where noScrollbars won't take effect for
                 // the below Scrollers if they have liquid flex height
-                !props.forPrint && 'fc-flex-col') },
-                createElement(Scroller, { horizontal: true, hideScrollbars: true, className: joinClassNames('fc-timeline-header fc-flex-row fc-border-b', stickyHeaderDates && 'fc-table-header-sticky'), ref: this.headerScrollerRef },
-                    createElement("div", { 
-                        // TODO: DRY
-                        className: 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 (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 && (createElement(TimelineNowIndicatorArrow, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth }))),
-                    Boolean(state.endScrollbarWidth) && (createElement("div", { className: 'fc-border-s fc-filler', style: { minWidth: state.endScrollbarWidth } }))),
-                createElement(Scroller, { vertical: verticalScrolling, horizontal: true, hideScrollbars: props.forPrint, className: joinClassNames('fc-timeline-body fc-flex-col', verticalScrolling && 'fc-liquid'), ref: this.bodyScrollerRef, clientWidthRef: this.handleClientWidth, endScrollbarWidthRef: this.handleEndScrollbarWidth },
-                    createElement("div", { "aria-label": options.eventsHint, className: "fc-rel fc-grow", style: { width: canvasWidth }, ref: this.handeBodyEl },
+                !props.forPrint && classNames.flexCol, props.className, options.tableClass, classNames.isolate), borderlessX: props.borderlessX, borderlessTop: props.borderlessTop, borderlessBottom: props.borderlessBottom, noEdgeEffects: props.noEdgeEffects },
+                createElement("div", { className: joinClassNames(generateClassName(options.tableHeaderClass, {
+                        isSticky: stickyHeaderDates,
+                    }), props.borderlessX && classNames.borderlessX, classNames.flexCol, stickyHeaderDates && classNames.tableHeaderSticky), style: {
+                        zIndex: 1,
+                    } },
+                    createElement(Scroller, { horizontal: true, hideScrollbars: true, className: classNames.flexRow, ref: this.headerScrollerRef },
+                        createElement("div", { 
+                            // TODO: DRY
+                            className: joinClassNames(classNames.rel, // origin for now-indicator
+                            canvasWidth == null && classNames.liquid), style: { width: canvasWidth } },
+                            cellRows.map((cells, rowIndex) => {
+                                const rowLevel = cellRows.length - rowIndex - 1;
+                                return (createElement(TimelineHeaderRow, { key: rowIndex, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, rowLevel: rowLevel, cells: cells, slotWidth: slotWidth, innerWidthRef: this.headerRowInnerWidthMap.createRef(rowIndex) }));
+                            }),
+                            enableNowIndicator && (createElement(TimelineNowIndicatorArrow, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth }))),
+                        Boolean(endScrollbarWidth) && (createElement("div", { className: joinArrayishClassNames(generateClassName(options.fillerClass, { isHeader: true }), classNames.borderOnlyS), style: { minWidth: endScrollbarWidth } }))),
+                    createElement("div", { className: generateClassName(options.slotHeaderDividerClass, {
+                            isHeader: true,
+                            options: { dayMinWidth: options.dayMinWidth },
+                        }) })),
+                createElement(Scroller, { vertical: verticalScrolling, horizontal: true, hideScrollbars: stickyFooterScrollbar ||
+                        props.forPrint // prevents blank space in print-view on Safari
+                    , className: joinArrayishClassNames(options.tableBodyClass, props.borderlessX && classNames.borderlessX, stickyHeaderDates && classNames.borderlessTop, (stickyHeaderDates || props.noEdgeEffects) && classNames.noEdgeEffects, classNames.flexCol, verticalScrolling && classNames.liquid), style: {
+                        zIndex: 0,
+                    }, ref: this.bodyScrollerRef, clientWidthRef: this.handleClientWidth },
+                    createElement("div", { "aria-label": options.eventsHint, className: joinClassNames(classNames.rel, // for canvas origin?
+                        classNames.grow), style: { width: canvasWidth }, ref: this.handeBodyEl },
                         createElement(TimelineSlats, { dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, 
-                            // ref
-                            innerWidthRef: this.handleBodySlotInnerWidth, 
                             // dimensions
                             slotWidth: slotWidth }),
-                        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 }),
+                        createElement(TimelineBg, { tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, 
+                            // content
+                            bgEventSegs: slicedProps.bgEventSegs, businessHourSegs: slicedProps.businessHourSegs, dateSelectionSegs: slicedProps.dateSelectionSegs, eventResizeSegs: slicedProps.eventResize ? slicedProps.eventResize.segs : null, 
+                            // dimensions
+                            slotWidth: slotWidth }),
+                        createElement("div", { className: joinArrayishClassNames(options.timelineTopClass) }),
+                        createElement(TimelineFg, { dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, 
+                            // content
+                            fgEventSegs: slicedProps.fgEventSegs, eventDrag: slicedProps.eventDrag, eventResize: slicedProps.eventResize, eventSelection: slicedProps.eventSelection, 
+                            // dimensions
+                            slotWidth: slotWidth }),
+                        createElement("div", { className: joinArrayishClassNames(options.timelineBottomClass) }),
                         enableNowIndicator && (createElement(TimelineNowIndicatorLine, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth })))),
-                stickyFooterScrollbar && (createElement(Scroller, { ref: this.footerScrollerRef, horizontal: true },
-                    createElement("div", { style: { width: canvasWidth } })))));
+                Boolean(stickyFooterScrollbar) && (createElement(FooterScrollbar, { isSticky: true, canvasWidth: canvasWidth, scrollerRef: this.footerScrollerRef })),
+                createElement(Ruler, { widthRef: this.handleTotalWidth })));
         }));
     }
     // Lifecycle
@@ -1191,11 +1158,11 @@ class TimelineView extends DateComponent {
             this.syncedScroller.scrollTo({ x });
         }
     }
-    queryHit(positionLeft, positionTop, elWidth, elHeight) {
+    queryHit(isRtl, positionLeft, positionTop, elWidth, elHeight) {
         const { props, context, tDateProfile, slotWidth } = this;
         const { dateEnv } = context;
         if (slotWidth) {
-            const x = context.isRtl ? elWidth - positionLeft : positionLeft;
+            const x = 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
@@ -1207,7 +1174,7 @@ class TimelineView extends DateComponent {
             let startCoord = slatIndex * slotWidth + (snapWidth * localSnapIndex);
             let endCoord = startCoord + snapWidth;
             let left, right;
-            if (context.isRtl) {
+            if (isRtl) {
                 left = elWidth - endCoord;
                 right = elWidth - startCoord;
             }
@@ -1227,8 +1194,7 @@ class TimelineView extends DateComponent {
                     top: 0,
                     bottom: elHeight,
                 },
-                // HACK. TODO: This is expensive to do every hit-query
-                dayEl: this.bodyEl.querySelectorAll('.fc-timeline-slot')[slatIndex],
+                getDayEl: () => getTimelineSlotEl(this.bodyEl, slatIndex),
                 layer: 0,
             };
         }
@@ -1236,7 +1202,4 @@ class TimelineView extends DateComponent {
     }
 }
 
-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}";
-injectStyles(css_248z);
-
-export { TimelineHeaderRow, TimelineLane, TimelineLaneBg, TimelineLaneSlicer, TimelineNowIndicatorArrow, TimelineNowIndicatorLine, TimelineSlats, TimelineView, buildTimelineDateProfile, computeSlotWidth, createHorizontalStyle, createVerticalStyle, timeToCoord };
+export { TimelineBg, TimelineFg, TimelineHeaderRow, TimelineLaneSlicer, TimelineNowIndicatorArrow, TimelineNowIndicatorLine, TimelineSlats, TimelineView, buildTimelineDateProfile, computeSlotWidth, getTimelineSlotEl, timeToCoord };