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

package/{index.global.js → global.js}

@@ -1,14 +1,15 @@
 /*!
-FullCalendar Timeline Plugin v7.0.0-beta.3
+FullCalendar Timeline Plugin v7.0.0-beta.5
 Docs & License: https://fullcalendar.io/docs/timeline-view-no-resources
-(c) 2024 Adam Shaw
+(c) 2025 Adam Shaw
 */
-FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$1, preact, internal$2) {
+FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$1, classNames, preact, internal$2) {
     'use strict';
 
     function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
     var premiumCommonPlugin__default = /*#__PURE__*/_interopDefault(premiumCommonPlugin);
+    var classNames__default = /*#__PURE__*/_interopDefault(classNames);
 
     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
@@ -37,13 +38,13 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
     ];
     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);
@@ -57,10 +58,6 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             }
         }
         tDateProfile.largeUnit = largeUnit;
-        tDateProfile.emphasizeWeeks =
-            internal$1.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())
@@ -96,14 +93,18 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         tDateProfile.timeWindowMs = timeWindowMs;
         tDateProfile.normalizedRange = { start: normalizedStart, end: normalizedEnd };
         let slotDates = [];
+        let slotDatesMajor = [];
         let date = normalizedStart;
+        let majorUnit = internal$1.computeMajorUnit(dateProfile, dateEnv);
         while (date < normalizedEnd) {
             if (isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator)) {
                 slotDates.push(date);
+                slotDatesMajor.push(internal$1.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 :(
@@ -127,8 +128,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         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 = internal$1.wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
         return tDateProfile;
     }
@@ -189,7 +189,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         if (tDateProfile.labelInterval) {
             const labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.labelInterval);
             if (labelCnt > internal$1.config.MAX_TIMELINE_SLOTS) {
-                console.warn('slotLabelInterval results in too many cells');
+                console.warn('slotHeaderInterval results in too many cells');
                 tDateProfile.labelInterval = null;
             }
         }
@@ -205,7 +205,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         if (tDateProfile.labelInterval && tDateProfile.slotDuration) {
             const slotsPerLabel = internal$1.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;
             }
         }
@@ -280,6 +280,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         let format1;
         let format2;
         const { labelInterval } = tDateProfile;
+        const { currentRange } = dateProfile;
         let unit = internal$1.greatestDurationDenominator(labelInterval).unit;
         const weekNumbersVisible = allOptions.weekNumbers;
         let format0 = (format1 = (format2 = null));
@@ -292,22 +293,22 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
                 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) {
@@ -319,7 +320,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
                 if (weekNumbersVisible) {
                     format0 = { week: 'short' }; // 'Wk 4'
                 }
-                if (currentRangeAs('days', dateProfile, dateEnv) > 1) {
+                if (internal$1.diffWholeDays(currentRange.start, currentRange.end) > 1) {
                     format1 = { weekday: 'short', day: 'numeric', month: 'numeric', omitCommas: true }; // Sat 4/7
                 }
                 format2 = {
@@ -365,39 +366,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         }
         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$1.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
@@ -406,23 +375,23 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             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 = internal$1.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;
@@ -430,161 +399,202 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
                 }
                 else if (!leadingCell ||
                     internal$1.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 internal$1.BaseComponent {
         constructor() {
             super(...arguments);
-            // ref
-            this.innerElRef = preact.createRef();
+            // memo
+            this.getDateMeta = internal$1.memoize(internal$1.getDateMeta);
         }
         render() {
             let { props, context } = this;
             let { dateEnv, options } = context;
-            let { date, tDateProfile, isEm } = props;
-            let dateMeta = internal$1.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.createElement(internal$1.ContentContainer, { tag: "div", 
-                // fc-align-start shrinks width of InnerContent
-                // TODO: document this semantic className fc-timeline-slot-em
-                className: internal$1.joinClassNames('fc-timeline-slot', isEm && 'fc-timeline-slot-em', tDateProfile.isTimeScale && (internal$1.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$1.getDayClassName(dateMeta) :
-                    internal$1.getSlotClassName(dateMeta)), attrs: {
-                    '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 &&
+                !internal$1.isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, props.date, tDateProfile.labelInterval));
+            let renderProps = Object.assign(Object.assign({}, dateMeta), { isMajor,
+                isMinor, view: context.viewApi });
+            return (preact.createElement(internal$1.ContentContainer, { tag: "div", className: core.joinClassNames(classNames__default["default"].tight, classNames__default["default"].alignStart, // shrinks width of InnerContent
+                props.borderStart ? classNames__default["default"].borderOnlyS : classNames__default["default"].borderNone, classNames__default["default"].internalTimelineSlot), attrs: Object.assign({ 'data-date': dateEnv.formatIso(date, {
                         omitTimeZoneOffset: true,
                         omitTime: !tDateProfile.isTimeScale,
-                    }),
-                }, style: {
+                    }) }, (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.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 internal$1.BaseComponent {
+        render() {
+            let { props } = this;
+            let { tDateProfile, slotWidth } = props;
+            let { slotDates, slotDatesMajor } = tDateProfile;
+            return (preact.createElement("div", { "aria-hidden": true, className: core.joinClassNames(classNames__default["default"].flexRow, classNames__default["default"].fill), style: { height: props.height } }, slotDates.map((slotDate, i) => {
+                let key = slotDate.toISOString();
+                return (preact.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 internal$1.BaseComponent {
+        constructor() {
+            super(...arguments);
+            // memo
+            this.getDateMeta = internal$1.memoize(internal$1.getDateMeta);
+            // ref
+            this.innerWrapperElRef = preact.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 (preact.createElement(internal$1.ContentContainer, { tag: "div", className: internal$1.joinArrayishClassNames(classNames__default["default"].tight, classNames__default["default"].flexCol, props.isFirst ? classNames__default["default"].borderNone : classNames__default["default"].borderOnlyS, align === 'center' ? classNames__default["default"].alignCenter :
+                    align === 'end' ? classNames__default["default"].alignEnd :
+                        classNames__default["default"].alignStart, classNames__default["default"].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) => (preact.createElement("div", { ref: this.innerWrapperElRef, className: core.joinClassNames(classNames__default["default"].flexCol, classNames__default["default"].rigid, isSticky && classNames__default["default"].sticky), style: {
+                    left: edgeCoord,
+                    right: edgeCoord,
+                } },
+                preact.createElement(InnerContent, { tag: 'div', attrs: hasNavLink
+                        // not tabbable because parent is aria-hidden
+                        ? internal$1.buildNavLinkAttrs(context, cell.date, cell.rowUnit, undefined, /* isTabbable = */ false)
+                        : {} // don't bother with aria-hidden because parent already hidden
+                    , className: internal$1.generateClassName(options.slotHeaderInnerClass, renderProps) })))));
         }
         componentDidMount() {
-            const innerEl = this.innerElRef.current;
-            this.disconnectInnerWidth = internal$1.watchWidth(innerEl, (width) => {
-                internal$1.setRef(this.props.innerWidthRef, width);
+            const { props } = this;
+            const innerWrapperEl = this.innerWrapperElRef.current; // TODO: make dynamic with useEffect
+            this.disconnectSize = internal$1.watchSize(innerWrapperEl, (width, height) => {
+                internal$1.setRef(props.innerWidthRef, width);
+                internal$1.setRef(props.innerHeightRef, height);
+                if (this.align === 'center' && this.isSticky) {
+                    this.setState({ innerWidth: width });
+                }
             });
         }
         componentWillUnmount() {
-            this.disconnectInnerWidth();
-            internal$1.setRef(this.props.innerWidthRef, null);
+            const { props } = this;
+            this.disconnectSize();
+            internal$1.setRef(props.innerWidthRef, null);
+            internal$1.setRef(props.innerHeightRef, null);
         }
     }
+    // Utils
+    // -------------------------------------------------------------------------------------------------
+    function renderInnerContent(renderProps) {
+        return renderProps.text;
+    }
 
-    class TimelineSlats extends internal$1.BaseComponent {
+    class TimelineHeaderRow extends internal$1.BaseComponent {
         constructor() {
             super(...arguments);
+            // refs
             this.innerWidthRefMap = new internal$1.RefMap(() => {
                 internal$1.afterSize(this.handleInnerWidths);
             });
+            this.innerHeightRefMap = new internal$1.RefMap(() => {
+                internal$1.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?
                 internal$1.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$1.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 (preact.createElement("div", { className: "fc-timeline-slots fc-fill fc-flex-row", style: { height: props.height } }, slotDates.map((slotDate, i) => {
-                let key = slotDate.toISOString();
-                return (preact.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 (preact.createElement("div", { className: internal$1.joinArrayishClassNames(options.slotHeaderRowClass, classNames__default["default"].flexRow, classNames__default["default"].grow, props.rowLevel // not the last row?
+                    ? classNames__default["default"].borderOnlyB
+                    : classNames__default["default"].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 (preact.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 (internal$1.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() {
+            internal$1.setRef(this.props.innerWidthRef, null);
+            internal$1.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
@@ -597,17 +607,17 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         }
         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) {
@@ -619,13 +629,86 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
     }
     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 (internal$1.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 internal$1.BaseComponent {
+        render() {
+            const { props, context } = this;
+            const xStyle = props.slotWidth == null
+                ? {}
+                : {
+                    insetInlineStart: dateToCoord(props.nowDate, context.dateEnv, props.tDateProfile, props.slotWidth)
+                };
+            return (preact.createElement("div", { className: classNames__default["default"].fill, style: {
+                    zIndex: 2,
+                    pointerEvents: 'none', // TODO: className
+                } },
+                preact.createElement(internal$1.NowIndicatorLineContainer, { className: core.joinClassNames(classNames__default["default"].fillY, classNames__default["default"].noMarginY, classNames__default["default"].borderlessY), style: xStyle, date: props.nowDate }),
+                preact.createElement("div", { className: core.joinClassNames(classNames__default["default"].flexCol, // better for negative margins
+                    classNames__default["default"].fillY), style: xStyle },
+                    preact.createElement("div", { 
+                        // stickiness on NowIndicatorDot misbehaves b/c of negative marginss
+                        className: classNames__default["default"].stickyT },
+                        preact.createElement(internal$1.NowIndicatorDot, null)))));
+        }
+    }
+
+    /*
+    TODO: DRY with other NowIndicator components
+    */
+    class TimelineNowIndicatorArrow extends internal$1.BaseComponent {
+        render() {
+            const { props, context } = this;
+            const xStyle = props.slotWidth == null
+                ? {}
+                : {
+                    insetInlineStart: dateToCoord(props.nowDate, context.dateEnv, props.tDateProfile, props.slotWidth)
+                };
+            return (preact.createElement("div", { 
+                // crop any overflow that the arrow/line might cause
+                // TODO: just do this on the entire canvas within the scroller
+                className: core.joinClassNames(classNames__default["default"].fill, classNames__default["default"].crop), style: {
+                    zIndex: 2,
+                    pointerEvents: 'none', // TODO: className
+                } },
+                preact.createElement(internal$1.NowIndicatorHeaderContainer, { className: classNames__default["default"].abs, style: xStyle, date: props.nowDate })));
+        }
+    }
+
+    function getTimelineSlotEl(parentEl, index) {
+        return parentEl.querySelectorAll(`.${classNames__default["default"].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) {
@@ -647,6 +730,60 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         return snapCoverage;
     }
 
+    class TimelineLaneSlicer extends internal$1.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 = internal$1.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$1.addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
+                    });
+                }
+            }
+            return segs;
+        }
+    }
+
+    const DEFAULT_TIME_FORMAT = internal$1.createFormatter({
+        hour: 'numeric',
+        minute: '2-digit',
+        omitZeroMinute: true,
+        meridiem: 'narrow',
+    });
+    class TimelineEvent extends internal$1.BaseComponent {
+        render() {
+            let { props } = this;
+            return (preact.createElement(internal$1.StandardEvent, Object.assign({}, props, { display: 'row', defaultTimeFormat: DEFAULT_TIME_FORMAT, defaultDisplayEventTime: !props.isTimeScale })));
+        }
+    }
+
+    class TimelineLaneMoreLink extends internal$1.BaseComponent {
+        render() {
+            let { props } = this;
+            let { hiddenSegs, resourceId } = props;
+            let dateSpanProps = resourceId ? { resourceId } : {};
+            return (preact.createElement(internal$1.MoreLinkContainer, { display: 'row', allDayDate: null, segs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, dateSpanProps: dateSpanProps, isNarrow: false, isMicro: false, popoverContent: () => (preact.createElement(preact.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 (preact.createElement("div", { key: instanceId, style: { visibility: isInvisible ? 'hidden' : undefined } },
+                        preact.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 }, internal$1.getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
+                }))) }));
+        }
+    }
+
     function computeManySegHorizontals(segs, segMinWidth, dateEnv, tDateProfile, slotWidth) {
         const res = {};
         for (const seg of segs) {
@@ -711,83 +848,6 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         ];
     }
 
-    class TimelineLaneBg extends internal$1.BaseComponent {
-        render() {
-            let { props } = this;
-            let highlightSeg = [].concat(props.eventResizeSegs, props.dateSelectionSegs);
-            return (preact.createElement(preact.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.createElement(preact.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.createElement("div", { key: internal$1.buildEventRangeKey(seg.eventRange), className: "fc-fill-y", style: hStyle }, fillType === 'bg-event' ?
-                    preact.createElement(internal$1.BgEvent, Object.assign({ eventRange: seg.eventRange, isStart: seg.isStart, isEnd: seg.isEnd }, internal$1.getEventRangeMeta(seg.eventRange, todayRange, nowDate))) : (internal$1.renderFill(fillType))));
-            })));
-        }
-    }
-
-    class TimelineLaneSlicer extends internal$1.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$1.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$1.addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
-                    });
-                }
-            }
-            return segs;
-        }
-    }
-
-    const DEFAULT_TIME_FORMAT = internal$1.createFormatter({
-        hour: 'numeric',
-        minute: '2-digit',
-        omitZeroMinute: true,
-        meridiem: 'narrow',
-    });
-    class TimelineEvent extends internal$1.BaseComponent {
-        render() {
-            let { props, context } = this;
-            let { options } = context;
-            return (preact.createElement(internal$1.StandardEvent, Object.assign({}, props, { className: internal$1.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$1.BaseComponent {
-        render() {
-            let { props } = this;
-            let { hiddenSegs, resourceId, forcedInvisibleMap } = props;
-            let dateSpanProps = resourceId ? { resourceId } : {};
-            return (preact.createElement(internal$1.MoreLinkContainer, { className: 'fc-timeline-more-link', allDayDate: null, segs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, dateSpanProps: dateSpanProps, popoverContent: () => (preact.createElement(preact.Fragment, null, hiddenSegs.map((seg) => {
-                    let { eventRange } = seg;
-                    let instanceId = eventRange.instance.instanceId;
-                    return (preact.createElement("div", { key: instanceId, style: { visibility: forcedInvisibleMap[instanceId] ? 'hidden' : '' } },
-                        preact.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$1.getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
-                }))) }, (InnerContent) => (preact.createElement(InnerContent, { tag: "div", className: 'fc-timeline-more-link-inner fc-sticky-s' }))));
-        }
-    }
-
     /*
     TODO: make DRY with other Event Harnesses
     */
@@ -799,7 +859,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         }
         render() {
             const { props } = this;
-            return (preact.createElement("div", { className: "fc-abs", style: props.style, ref: this.rootElRef }, props.children));
+            return (preact.createElement("div", { className: classNames__default["default"].abs, style: props.style, ref: this.rootElRef }, props.children));
         }
         componentDidMount() {
             const rootEl = this.rootElRef.current; // TODO: make dynamic with useEffect
@@ -813,10 +873,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         }
     }
 
-    /*
-    TODO: split TimelineLaneBg and TimelineLaneFg?
-    */
-    class TimelineLane extends internal$1.BaseComponent {
+    class TimelineFg extends internal$1.BaseComponent {
         constructor() {
             super(...arguments);
             // memo
@@ -828,8 +885,6 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             this.moreLinkHeightRefMap = new internal$1.RefMap(() => {
                 internal$1.afterSize(this.handleMoreLinkHeights);
             });
-            // internal
-            this.slicer = new TimelineLaneSlicer();
             this.handleMoreLinkHeights = () => {
                 this.setState({ moreLinkHeightRev: this.moreLinkHeightRefMap.rev }); // will trigger rerender
             };
@@ -843,212 +898,92 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         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 (preact.createElement(preact.Fragment, null,
-                preact.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.createElement("div", { className: internal$1.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 (preact.createElement("div", { className: core.joinClassNames(classNames__default["default"].rel, classNames__default["default"].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 (preact.createElement(preact.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.createElement(TimelineEventHarness, { key: instanceId, style: Object.assign({ visibility: isVisible ? '' : 'hidden', top: segTop || 0 }, horizontalsToCss(segHorizontal, context.isRtl)), heightRef: isMirror ? undefined : segHeightRefMap.createRef(instanceId) },
-                        preact.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$1.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 (preact.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) },
+                        preact.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 }, internal$1.getEventRangeMeta(eventRange, props.todayRange, props.nowDate)))));
                 }),
-                hiddenGroups.map((hiddenGroup) => (preact.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.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$1.BaseComponent {
-        constructor() {
-            super(...arguments);
-            // memo
-            this.refineRenderProps = internal$1.memoizeObjArg(refineRenderProps);
-            this.buildCellNavLinkAttrs = internal$1.memoize(buildCellNavLinkAttrs);
-            // ref
-            this.innerElRef = preact.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$1.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,
-            });
-            return (preact.createElement(internal$1.ContentContainer, { tag: "div", className: internal$1.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$1.getSlotClassName(dateMeta) :
-                    internal$1.getDayClassName(dateMeta)), attrs: {
-                    'data-date': dateEnv.formatIso(cell.date, {
-                        omitTime: !tDateProfile.isTimeScale,
-                        omitTimeZoneOffset: true,
-                    }),
-                }, 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.createElement(InnerContent, { tag: "a", attrs: this.buildCellNavLinkAttrs(context, cell.date, cell.rowUnit), className: internal$1.joinClassNames('fc-cell-inner fc-padding-md', props.isSticky && 'fc-sticky-s'), elRef: this.innerElRef }))));
+                hiddenGroups.map((hiddenGroup) => (preact.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) },
+                    preact.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 = internal$1.watchSize(innerEl, (width, height) => {
-                internal$1.setRef(props.innerWidthRef, width);
-                internal$1.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$1.setRef(props.innerWidthRef, null);
-            internal$1.setRef(props.innerHeightRef, null);
-        }
-    }
-    // Utils
-    // -------------------------------------------------------------------------------------------------
-    function buildCellNavLinkAttrs(context, cellDate, rowUnit) {
-        return (rowUnit && rowUnit !== 'time')
-            ? internal$1.buildNavLinkAttrs(context, cellDate, rowUnit)
-            : {};
-    }
-    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$1.BaseComponent {
-        constructor() {
-            super(...arguments);
-            // refs
-            this.innerWidthRefMap = new internal$1.RefMap(() => {
-                internal$1.afterSize(this.handleInnerWidths);
-            });
-            this.innerHeightRefMap = new internal$1.RefMap(() => {
-                internal$1.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$1.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$1.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 (preact.createElement("div", { className: internal$1.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.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;
+                internal$1.setRef(this.props.heightRef, this.totalHeight);
+            }
         }
         componentWillUnmount() {
-            internal$1.setRef(this.props.innerWidthRef, null);
-            internal$1.setRef(this.props.innerHeighRef, null);
+            internal$1.setRef(this.props.heightRef, null);
         }
     }
 
-    class TimelineNowIndicatorLine extends internal$1.BaseComponent {
+    class TimelineBg extends internal$1.BaseComponent {
         render() {
-            const { props, context } = this;
-            return (preact.createElement("div", { className: "fc-timeline-now-indicator-container" },
-                preact.createElement(internal$1.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 (preact.createElement(preact.Fragment, null,
+                this.renderSegs(props.businessHourSegs || [], 'non-business'),
+                this.renderSegs(props.bgEventSegs || [], 'bg-event'),
+                this.renderSegs(highlightSeg, 'highlight')));
         }
-    }
-
-    class TimelineNowIndicatorArrow extends internal$1.BaseComponent {
-        render() {
-            const { props, context } = this;
-            return (preact.createElement("div", { className: "fc-timeline-now-indicator-container" },
-                preact.createElement(internal$1.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 (preact.createElement(preact.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 (preact.createElement("div", { key: internal$1.buildEventRangeKey(seg.eventRange), className: classNames__default["default"].fillY, style: hStyle }, fillType === 'bg-event' ? (preact.createElement(internal$1.BgEvent, Object.assign({ eventRange: seg.eventRange, isStart: seg.isStart, isEnd: seg.isEnd, isVertical: false }, internal$1.getEventRangeMeta(seg.eventRange, todayRange, nowDate)))) : (internal$1.renderFill(fillType, options))));
+            })));
         }
     }
 
@@ -1066,46 +1001,34 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
                 internal$1.afterSize(this.handleSlotInnerWidths);
             });
             this.scrollTime = null;
+            this.slicer = new TimelineLaneSlicer();
             // Sizing
             // -----------------------------------------------------------------------------------------------
-            this.handleBodySlotInnerWidth = (innerWidth) => {
-                this.bodySlotInnerWidth = innerWidth;
-                internal$1.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.handleTimeScroll = (scrollTime) => {
+            this.handleTimeScrollRequest = (scrollTime) => {
                 this.scrollTime = scrollTime;
-                this.updateScroll();
+                this.applyTimeScroll();
             };
-            this.updateScroll = () => {
-                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 });
+            this.handleTimeScrollEnd = (isUser) => {
+                if (isUser) {
+                    this.scrollTime = null;
                 }
             };
-            this.clearScroll = () => {
-                this.scrollTime = null;
-            };
             // Hit System
             // -----------------------------------------------------------------------------------------------
             this.handeBodyEl = (el) => {
@@ -1121,6 +1044,10 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         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;
@@ -1131,39 +1058,65 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             const stickyFooterScrollbar = !props.forPrint && internal$1.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 (preact.createElement(internal$1.NowTimer, { unit: timerUnit }, (nowDate, todayRange) => {
                 const enableNowIndicator = // TODO: DRY
                  options.nowIndicator &&
                     slotWidth != null &&
                     internal$1.rangeContainsMarker(props.dateProfile.currentRange, nowDate);
-                return (preact.createElement(internal$1.ViewContainer, { viewSpec: context.viewSpec, className: internal$1.joinClassNames('fc-timeline fc-border', 
-                    // HACK for Safari print-mode, where fc-scroller-no-bars won't take effect for
+                return (preact.createElement(internal$1.ViewContainer, { viewSpec: context.viewSpec, className: internal$1.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') },
-                    preact.createElement(internal$1.Scroller, { horizontal: true, hideScrollbars: true, className: internal$1.joinClassNames('fc-timeline-header fc-flex-row fc-border-b', stickyHeaderDates && 'fc-table-header-sticky'), ref: this.headerScrollerRef },
-                        preact.createElement("div", { 
-                            // TODO: DRY
-                            className: internal$1.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.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.createElement(TimelineNowIndicatorArrow, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth }))),
-                        Boolean(state.endScrollbarWidth) && (preact.createElement("div", { className: 'fc-border-s fc-filler', style: { minWidth: state.endScrollbarWidth } }))),
-                    preact.createElement(internal$1.Scroller, { vertical: verticalScrolling, horizontal: true, hideScrollbars: props.forPrint, className: internal$1.joinClassNames('fc-timeline-body fc-flex-col', verticalScrolling && 'fc-liquid'), ref: this.bodyScrollerRef, clientWidthRef: this.handleClientWidth, endScrollbarWidthRef: this.handleEndScrollbarWidth },
-                        preact.createElement("div", { className: "fc-rel fc-grow", style: { width: canvasWidth }, ref: this.handeBodyEl },
+                    !props.forPrint && classNames__default["default"].flexCol, props.className, options.tableClass, classNames__default["default"].isolate), borderlessX: props.borderlessX, borderlessTop: props.borderlessTop, borderlessBottom: props.borderlessBottom, noEdgeEffects: props.noEdgeEffects },
+                    preact.createElement("div", { className: core.joinClassNames(internal$1.generateClassName(options.tableHeaderClass, {
+                            isSticky: stickyHeaderDates,
+                        }), props.borderlessX && classNames__default["default"].borderlessX, classNames__default["default"].flexCol, stickyHeaderDates && classNames__default["default"].tableHeaderSticky), style: {
+                            zIndex: 1,
+                        } },
+                        preact.createElement(internal$1.Scroller, { horizontal: true, hideScrollbars: true, className: classNames__default["default"].flexRow, ref: this.headerScrollerRef },
+                            preact.createElement("div", { 
+                                // TODO: DRY
+                                className: core.joinClassNames(classNames__default["default"].rel, // origin for now-indicator
+                                canvasWidth == null && classNames__default["default"].liquid), style: { width: canvasWidth } },
+                                cellRows.map((cells, rowIndex) => {
+                                    const rowLevel = cellRows.length - rowIndex - 1;
+                                    return (preact.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 && (preact.createElement(TimelineNowIndicatorArrow, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth }))),
+                            Boolean(endScrollbarWidth) && (preact.createElement("div", { className: internal$1.joinArrayishClassNames(internal$1.generateClassName(options.fillerClass, { isHeader: true }), classNames__default["default"].borderOnlyS), style: { minWidth: endScrollbarWidth } }))),
+                        preact.createElement("div", { className: internal$1.generateClassName(options.slotHeaderDividerClass, {
+                                isHeader: true,
+                                options: { dayMinWidth: options.dayMinWidth },
+                            }) })),
+                    preact.createElement(internal$1.Scroller, { vertical: verticalScrolling, horizontal: true, hideScrollbars: stickyFooterScrollbar ||
+                            props.forPrint // prevents blank space in print-view on Safari
+                        , className: internal$1.joinArrayishClassNames(options.tableBodyClass, props.borderlessX && classNames__default["default"].borderlessX, stickyHeaderDates && classNames__default["default"].borderlessTop, (stickyHeaderDates || props.noEdgeEffects) && classNames__default["default"].noEdgeEffects, classNames__default["default"].flexCol, verticalScrolling && classNames__default["default"].liquid), style: {
+                            zIndex: 0,
+                        }, ref: this.bodyScrollerRef, clientWidthRef: this.handleClientWidth },
+                        preact.createElement("div", { "aria-label": options.eventsHint, className: core.joinClassNames(classNames__default["default"].rel, // for canvas origin?
+                            classNames__default["default"].grow), style: { width: canvasWidth }, ref: this.handeBodyEl },
                             preact.createElement(TimelineSlats, { dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, 
-                                // ref
-                                innerWidthRef: this.handleBodySlotInnerWidth, 
                                 // dimensions
                                 slotWidth: slotWidth }),
-                            preact.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 }),
+                            preact.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 }),
+                            preact.createElement("div", { className: internal$1.joinArrayishClassNames(options.timelineTopClass) }),
+                            preact.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 }),
+                            preact.createElement("div", { className: internal$1.joinArrayishClassNames(options.timelineBottomClass) }),
                             enableNowIndicator && (preact.createElement(TimelineNowIndicatorLine, { tDateProfile: tDateProfile, nowDate: nowDate, slotWidth: slotWidth })))),
-                    stickyFooterScrollbar && (preact.createElement(internal$1.Scroller, { ref: this.footerScrollerRef, horizontal: true },
-                        preact.createElement("div", { style: { width: canvasWidth } })))));
+                    Boolean(stickyFooterScrollbar) && (preact.createElement(internal$1.FooterScrollbar, { isSticky: true, canvasWidth: canvasWidth, scrollerRef: this.footerScrollerRef })),
+                    preact.createElement(internal$1.Ruler, { widthRef: this.handleTotalWidth })));
             }));
         }
         // Lifecycle
@@ -1172,8 +1125,8 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             this.syncedScroller = new internal$2.ScrollerSyncer(true); // horizontal=true
             this.updateSyncedScroller();
             this.resetScroll();
-            this.context.emitter.on('_timeScrollRequest', this.handleTimeScroll);
-            this.syncedScroller.addScrollEndListener(this.clearScroll);
+            this.context.emitter.on('_timeScrollRequest', this.handleTimeScrollRequest);
+            this.syncedScroller.addScrollEndListener(this.handleTimeScrollEnd);
         }
         componentDidUpdate(prevProps) {
             this.updateSyncedScroller();
@@ -1182,13 +1135,13 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             }
             else {
                 // TODO: inefficient to update so often
-                this.updateScroll();
+                this.applyTimeScroll();
             }
         }
         componentWillUnmount() {
             this.syncedScroller.destroy();
-            this.context.emitter.off('_timeScrollRequest', this.handleTimeScroll);
-            this.syncedScroller.removeScrollEndListener(this.clearScroll);
+            this.context.emitter.off('_timeScrollRequest', this.handleTimeScrollRequest);
+            this.syncedScroller.removeScrollEndListener(this.handleTimeScrollEnd);
         }
         // Scrolling
         // -----------------------------------------------------------------------------------------------
@@ -1200,13 +1153,23 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
             ]);
         }
         resetScroll() {
-            this.handleTimeScroll(this.context.options.scrollTime);
+            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) {
+        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
@@ -1218,7 +1181,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
                 let startCoord = slatIndex * slotWidth + (snapWidth * localSnapIndex);
                 let endCoord = startCoord + snapWidth;
                 let left, right;
-                if (context.isRtl) {
+                if (isRtl) {
                     left = elWidth - endCoord;
                     right = elWidth - startCoord;
                 }
@@ -1238,8 +1201,7 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
                         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,
                 };
             }
@@ -1247,14 +1209,17 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
         }
     }
 
-    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$1.injectStyles(css_248z);
+    const OPTION_REFINERS = {
+        timelineTopClass: internal$1.identity,
+        timelineBottomClass: internal$1.identity,
+    };
 
     var plugin = core.createPlugin({
         name: '@fullcalendar/timeline',
-        premiumReleaseDate: '2024-12-19',
+        premiumReleaseDate: '2025-12-20',
         deps: [premiumCommonPlugin__default["default"]],
         initialView: 'timelineDay',
+        optionRefiners: OPTION_REFINERS,
         views: {
             timeline: {
                 component: TimelineView,
@@ -1283,18 +1248,17 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
     var internal = {
         __proto__: null,
         TimelineView: TimelineView,
-        TimelineLane: TimelineLane,
-        TimelineLaneBg: TimelineLaneBg,
+        TimelineFg: TimelineFg,
+        TimelineBg: TimelineBg,
         TimelineSlats: TimelineSlats,
         buildTimelineDateProfile: buildTimelineDateProfile,
-        createVerticalStyle: createVerticalStyle,
-        createHorizontalStyle: createHorizontalStyle,
         computeSlotWidth: computeSlotWidth,
         timeToCoord: timeToCoord,
         TimelineLaneSlicer: TimelineLaneSlicer,
         TimelineHeaderRow: TimelineHeaderRow,
         TimelineNowIndicatorArrow: TimelineNowIndicatorArrow,
-        TimelineNowIndicatorLine: TimelineNowIndicatorLine
+        TimelineNowIndicatorLine: TimelineNowIndicatorLine,
+        getTimelineSlotEl: getTimelineSlotEl
     };
 
     core.globalPlugins.push(plugin);
@@ -1306,4 +1270,4 @@ FullCalendar.Timeline = (function (exports, core, premiumCommonPlugin, internal$
 
     return exports;
 
-})({}, FullCalendar, FullCalendar.PremiumCommon, FullCalendar.Internal, FullCalendar.Preact, FullCalendar.ScrollGrid.Internal);
+})({}, FullCalendar, FullCalendar.PremiumCommon, FullCalendar.Internal, FullCalendar.InternalClassNames, FullCalendar.Preact, FullCalendar.ScrollGrid.Internal);