@fullcalendar/timeline 6.0.1 → 6.0.3

package/internal.js

@@ -1,11 +1,15 @@
-import { config, createFormatter, greatestDurationDenominator, asCleanDays, createDuration, wholeDivideDurations, asRoughMs, addDays, startOfDay, asRoughSeconds, asRoughMinutes, diffWholeDays, isInt, computeVisibleDayRange, padStart, BaseComponent, memoizeObjArg, memoize, getDateMeta, ContentContainer, getSlotClassNames, getDayClassNames, buildNavLinkAttrs, PositionCache, findDirectChildren, rangeContainsMarker, NowTimer, NowIndicatorContainer, findElements, RefMap, multiplyDuration, SegHierarchy, groupIntersectingEntries, buildIsoString, computeEarliestSegStart, buildEventRangeKey, BgEvent, getSegMeta, renderFill, Slicer, intersectRanges, addMs, StandardEvent, MoreLinkContainer, sortEventSegs, mapHash, isPropsEqual, DateComponent, getStickyHeaderDates, getStickyFooterScrollbar, ViewContainer, renderScrollShim } from '@fullcalendar/core/internal.js';
-import { createElement, Fragment, createRef } from '@fullcalendar/core/preact.js';
-import { ScrollGrid } from '@fullcalendar/scrollgrid/internal.js';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var internal = require('@fullcalendar/core/internal');
+var preact = require('@fullcalendar/core/preact');
+var internal$1 = require('@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
 const MAX_AUTO_CELLS = 200; // allows 4-days to have a :30 slot duration
-config.MAX_TIMELINE_SLOTS = 1000;
+internal.config.MAX_TIMELINE_SLOTS = 1000;
 // potential nice values for slot-duration and interval-duration
 const STOCK_SUB_DURATIONS = [
     { years: 1 },
@@ -39,18 +43,18 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     let rawFormats = Array.isArray(input) ? input :
         (input != null) ? [input] :
             computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions);
-    tDateProfile.headerFormats = rawFormats.map((rawFormat) => createFormatter(rawFormat));
+    tDateProfile.headerFormats = rawFormats.map((rawFormat) => internal.createFormatter(rawFormat));
     tDateProfile.isTimeScale = Boolean(tDateProfile.slotDuration.milliseconds);
     let largeUnit = null;
     if (!tDateProfile.isTimeScale) {
-        const slotUnit = greatestDurationDenominator(tDateProfile.slotDuration).unit;
+        const slotUnit = internal.greatestDurationDenominator(tDateProfile.slotDuration).unit;
         if (/year|month|week/.test(slotUnit)) {
             largeUnit = slotUnit;
         }
     }
     tDateProfile.largeUnit = largeUnit;
     tDateProfile.emphasizeWeeks =
-        asCleanDays(tDateProfile.slotDuration) === 1 &&
+        internal.asCleanDays(tDateProfile.slotDuration) === 1 &&
             currentRangeAs('weeks', dateProfile, dateEnv) >= 2 &&
             !allOptions.businessHours;
     /*
@@ -64,8 +68,8 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     let snapDuration;
     let snapsPerSlot;
     if (rawSnapDuration) {
-        snapDuration = createDuration(rawSnapDuration);
-        snapsPerSlot = wholeDivideDurations(tDateProfile.slotDuration, snapDuration);
+        snapDuration = internal.createDuration(rawSnapDuration);
+        snapsPerSlot = internal.wholeDivideDurations(tDateProfile.slotDuration, snapDuration);
         // ^ TODO: warning if not whole?
     }
     if (snapsPerSlot == null) {
@@ -75,7 +79,7 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     tDateProfile.snapDuration = snapDuration;
     tDateProfile.snapsPerSlot = snapsPerSlot;
     // more...
-    let timeWindowMs = asRoughMs(dateProfile.slotMaxTime) - asRoughMs(dateProfile.slotMinTime);
+    let timeWindowMs = internal.asRoughMs(dateProfile.slotMaxTime) - internal.asRoughMs(dateProfile.slotMinTime);
     // TODO: why not use normalizeRange!?
     let normalizedStart = normalizeDate(dateProfile.renderRange.start, tDateProfile, dateEnv);
     let normalizedEnd = normalizeDate(dateProfile.renderRange.end, tDateProfile, dateEnv);
@@ -83,7 +87,7 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     // TODO: View should be responsible.
     if (tDateProfile.isTimeScale) {
         normalizedStart = dateEnv.add(normalizedStart, dateProfile.slotMinTime);
-        normalizedEnd = dateEnv.add(addDays(normalizedEnd, -1), dateProfile.slotMaxTime);
+        normalizedEnd = dateEnv.add(internal.addDays(normalizedEnd, -1), dateProfile.slotMaxTime);
     }
     tDateProfile.timeWindowMs = timeWindowMs;
     tDateProfile.normalizedRange = { start: normalizedStart, end: normalizedEnd };
@@ -121,7 +125,7 @@ function buildTimelineDateProfile(dateProfile, dateEnv, allOptions, dateProfileG
     // more...
     tDateProfile.isWeekStarts = buildIsWeekStarts(tDateProfile, dateEnv);
     tDateProfile.cellRows = buildCellRows(tDateProfile, dateEnv);
-    tDateProfile.slotsPerLabel = wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
+    tDateProfile.slotsPerLabel = internal.wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
     return tDateProfile;
 }
 /*
@@ -130,7 +134,7 @@ snaps to appropriate unit
 function normalizeDate(date, tDateProfile, dateEnv) {
     let normalDate = date;
     if (!tDateProfile.isTimeScale) {
-        normalDate = startOfDay(normalDate);
+        normalDate = internal.startOfDay(normalDate);
         if (tDateProfile.largeUnit) {
             normalDate = dateEnv.startOf(normalDate, tDateProfile.largeUnit);
         }
@@ -142,7 +146,7 @@ snaps to appropriate unit
 */
 function normalizeRange(range, tDateProfile, dateEnv) {
     if (!tDateProfile.isTimeScale) {
-        range = computeVisibleDayRange(range);
+        range = internal.computeVisibleDayRange(range);
         if (tDateProfile.largeUnit) {
             let dayRange = range; // preserve original result
             range = {
@@ -167,9 +171,9 @@ function isValidDate(date, tDateProfile, dateProfile, dateProfileGenerator) {
     }
     if (tDateProfile.isTimeScale) {
         // determine if the time is within slotMinTime/slotMaxTime, which may have wacky values
-        let day = startOfDay(date);
+        let day = internal.startOfDay(date);
         let timeMs = date.valueOf() - day.valueOf();
-        let ms = timeMs - asRoughMs(dateProfile.slotMinTime); // milliseconds since slotMinTime
+        let ms = timeMs - internal.asRoughMs(dateProfile.slotMinTime); // milliseconds since slotMinTime
         ms = ((ms % 86400000) + 86400000) % 86400000; // make negative values wrap to 24hr clock
         return ms < tDateProfile.timeWindowMs; // before the slotMaxTime?
     }
@@ -180,7 +184,7 @@ function validateLabelAndSlot(tDateProfile, dateProfile, dateEnv) {
     // make sure labelInterval doesn't exceed the max number of cells
     if (tDateProfile.labelInterval) {
         const labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.labelInterval);
-        if (labelCnt > config.MAX_TIMELINE_SLOTS) {
+        if (labelCnt > internal.config.MAX_TIMELINE_SLOTS) {
             console.warn('slotLabelInterval results in too many cells');
             tDateProfile.labelInterval = null;
         }
@@ -188,14 +192,14 @@ function validateLabelAndSlot(tDateProfile, dateProfile, dateEnv) {
     // make sure slotDuration doesn't exceed the maximum number of cells
     if (tDateProfile.slotDuration) {
         const slotCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, tDateProfile.slotDuration);
-        if (slotCnt > config.MAX_TIMELINE_SLOTS) {
+        if (slotCnt > internal.config.MAX_TIMELINE_SLOTS) {
             console.warn('slotDuration results in too many cells');
             tDateProfile.slotDuration = null;
         }
     }
     // make sure labelInterval is a multiple of slotDuration
     if (tDateProfile.labelInterval && tDateProfile.slotDuration) {
-        const slotsPerLabel = wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
+        const slotsPerLabel = internal.wholeDivideDurations(tDateProfile.labelInterval, tDateProfile.slotDuration);
         if (slotsPerLabel === null || slotsPerLabel < 1) {
             console.warn('slotLabelInterval must be a multiple of slotDuration');
             tDateProfile.slotDuration = null;
@@ -211,8 +215,8 @@ function ensureLabelInterval(tDateProfile, dateProfile, dateEnv) {
         let input;
         if (tDateProfile.slotDuration) {
             for (input of STOCK_SUB_DURATIONS) {
-                const tryLabelInterval = createDuration(input);
-                const slotsPerLabel = wholeDivideDurations(tryLabelInterval, tDateProfile.slotDuration);
+                const tryLabelInterval = internal.createDuration(input);
+                const slotsPerLabel = internal.wholeDivideDurations(tryLabelInterval, tDateProfile.slotDuration);
                 if (slotsPerLabel !== null && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) {
                     labelInterval = tryLabelInterval;
                     break;
@@ -227,7 +231,7 @@ function ensureLabelInterval(tDateProfile, dateProfile, dateEnv) {
         }
         else {
             for (input of STOCK_SUB_DURATIONS) {
-                labelInterval = createDuration(input);
+                labelInterval = internal.createDuration(input);
                 const labelCnt = dateEnv.countDurationsBetween(currentRange.start, currentRange.end, labelInterval);
                 if (labelCnt >= MIN_AUTO_LABELS) {
                     break;
@@ -246,8 +250,8 @@ function ensureSlotDuration(tDateProfile, dateProfile, dateEnv) {
         // compute based off the label interval
         // find the largest slot duration that is different from labelInterval, but still acceptable
         for (let input of STOCK_SUB_DURATIONS) {
-            const trySlotDuration = createDuration(input);
-            const slotsPerLabel = wholeDivideDurations(labelInterval, trySlotDuration);
+            const trySlotDuration = internal.createDuration(input);
+            const slotsPerLabel = internal.wholeDivideDurations(labelInterval, trySlotDuration);
             if (slotsPerLabel !== null && slotsPerLabel > 1 && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) {
                 slotDuration = trySlotDuration;
                 break;
@@ -272,7 +276,7 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
     let format1;
     let format2;
     const { labelInterval } = tDateProfile;
-    let unit = greatestDurationDenominator(labelInterval).unit;
+    let unit = internal.greatestDurationDenominator(labelInterval).unit;
     const weekNumbersVisible = allOptions.weekNumbers;
     let format0 = (format1 = (format2 = null));
     // NOTE: weekNumber computation function wont work
@@ -323,12 +327,12 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
             break;
         case 'minute':
             // sufficiently large number of different minute cells?
-            if ((asRoughMinutes(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
+            if ((internal.asRoughMinutes(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
                 format0 = {
                     hour: 'numeric',
                     meridiem: 'short',
                 };
-                format1 = (params) => (':' + padStart(params.date.minute, 2) // ':30'
+                format1 = (params) => (':' + internal.padStart(params.date.minute, 2) // ':30'
                 );
             }
             else {
@@ -341,9 +345,9 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
             break;
         case 'second':
             // sufficiently large number of different second cells?
-            if ((asRoughSeconds(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
+            if ((internal.asRoughSeconds(labelInterval) / 60) >= MAX_AUTO_SLOTS_PER_LABEL) {
                 format0 = { hour: 'numeric', minute: '2-digit', meridiem: 'lowercase' }; // '8:30 PM'
-                format1 = (params) => (':' + padStart(params.date.second, 2) // ':30'
+                format1 = (params) => (':' + internal.padStart(params.date.second, 2) // ':30'
                 );
             }
             else {
@@ -352,7 +356,7 @@ function computeHeaderFormats(tDateProfile, dateProfile, dateEnv, allOptions) {
             break;
         case 'millisecond':
             format0 = { hour: 'numeric', minute: '2-digit', second: '2-digit', meridiem: 'lowercase' }; // '8:30:45 PM'
-            format1 = (params) => ('.' + padStart(params.millisecond, 3));
+            format1 = (params) => ('.' + internal.padStart(params.millisecond, 3));
             break;
     }
     return [].concat(format0 || [], format1 || [], format2 || []);
@@ -373,7 +377,7 @@ function currentRangeAs(unit, dateProfile, dateEnv) {
         res = dateEnv.diffWholeMonths(range.start, range.end);
     }
     else if (unit === 'days') {
-        res = diffWholeDays(range.start, range.end);
+        res = internal.diffWholeDays(range.start, range.end);
     }
     return res || 0;
 }
@@ -393,7 +397,7 @@ function buildCellRows(tDateProfile, dateEnv) {
     let slotDates = tDateProfile.slotDates;
     let formats = tDateProfile.headerFormats;
     let cellRows = formats.map(() => []); // indexed by row,col
-    let slotAsDays = asCleanDays(tDateProfile.slotDuration);
+    let slotAsDays = internal.asCleanDays(tDateProfile.slotDuration);
     let guessedSlotUnit = slotAsDays === 7 ? 'week' :
         slotAsDays === 1 ? 'day' :
             null;
@@ -421,7 +425,7 @@ function buildCellRows(tDateProfile, dateEnv) {
                 }
             }
             else if (!leadingCell ||
-                isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.labelInterval))) {
+                internal.isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, date, tDateProfile.labelInterval))) {
                 let text = dateEnv.format(date, format);
                 newCell = buildCellObject(date, text, rowUnit);
             }
@@ -440,11 +444,11 @@ function buildCellObject(date, text, rowUnit) {
     return { date, text, rowUnit, colspan: 1, isWeekStart: false };
 }
 
-class TimelineHeaderTh extends BaseComponent {
+class TimelineHeaderTh extends internal.BaseComponent {
     constructor() {
         super(...arguments);
-        this.refineRenderProps = memoizeObjArg(refineRenderProps);
-        this.buildCellNavLinkAttrs = memoize(buildCellNavLinkAttrs);
+        this.refineRenderProps = internal.memoizeObjArg(refineRenderProps);
+        this.buildCellNavLinkAttrs = internal.memoize(buildCellNavLinkAttrs);
     }
     render() {
         let { props, context } = this;
@@ -453,7 +457,7 @@ class TimelineHeaderTh extends BaseComponent {
         // 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 dateMeta = internal.getDateMeta(cell.date, props.todayRange, props.nowDate, dateProfile);
         let renderProps = this.refineRenderProps({
             level: props.rowLevel,
             dateMarker: cell.date,
@@ -461,22 +465,22 @@ class TimelineHeaderTh extends BaseComponent {
             dateEnv: context.dateEnv,
             viewApi: context.viewApi,
         });
-        return (createElement(ContentContainer, { elTag: "th", elClasses: [
+        return (preact.createElement(internal.ContentContainer, { elTag: "th", elClasses: [
                 'fc-timeline-slot',
                 'fc-timeline-slot-label',
                 cell.isWeekStart && 'fc-timeline-slot-em',
                 ...( // TODO: so slot classnames for week/month/bigger. see note above about rowUnit
                 cell.rowUnit === 'time' ?
-                    getSlotClassNames(dateMeta, context.theme) :
-                    getDayClassNames(dateMeta, context.theme)),
+                    internal.getSlotClassNames(dateMeta, context.theme) :
+                    internal.getDayClassNames(dateMeta, context.theme)),
             ], elAttrs: {
                 colSpan: cell.colspan,
                 'data-date': dateEnv.formatIso(cell.date, {
                     omitTime: !tDateProfile.isTimeScale,
                     omitTimeZoneOffset: true,
                 }),
-            }, renderProps: renderProps, generatorName: "slotLabelContent", generator: options.slotLabelContent || renderInnerContent, classNameGenerator: options.slotLabelClassNames, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, (InnerContent) => (createElement("div", { className: "fc-timeline-slot-frame", style: { height: props.rowInnerHeight } },
-            createElement(InnerContent, { elTag: "a", elClasses: [
+            }, renderProps: renderProps, generatorName: "slotLabelContent", generator: options.slotLabelContent || renderInnerContent, classNameGenerator: options.slotLabelClassNames, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, (InnerContent) => (preact.createElement("div", { className: "fc-timeline-slot-frame", style: { height: props.rowInnerHeight } },
+            preact.createElement(InnerContent, { elTag: "a", elClasses: [
                     'fc-timeline-slot-cushion',
                     'fc-scrollgrid-sync-inner',
                     props.isSticky && 'fc-sticky',
@@ -485,7 +489,7 @@ class TimelineHeaderTh extends BaseComponent {
 }
 function buildCellNavLinkAttrs(context, cellDate, rowUnit) {
     return (rowUnit && rowUnit !== 'time')
-        ? buildNavLinkAttrs(context, cellDate, rowUnit)
+        ? internal.buildNavLinkAttrs(context, cellDate, rowUnit)
         : {};
 }
 function renderInnerContent(renderProps) {
@@ -500,11 +504,11 @@ function refineRenderProps(input) {
     };
 }
 
-class TimelineHeaderRows extends BaseComponent {
+class TimelineHeaderRows extends internal.BaseComponent {
     render() {
         let { dateProfile, tDateProfile, rowInnerHeights, todayRange, nowDate } = this.props;
         let { cellRows } = tDateProfile;
-        return (createElement(Fragment, null, cellRows.map((rowCells, rowLevel) => {
+        return (preact.createElement(preact.Fragment, null, cellRows.map((rowCells, rowLevel) => {
             let isLast = rowLevel === cellRows.length - 1;
             let isChrono = tDateProfile.isTimeScale && isLast; // the final row, with times?
             let classNames = [
@@ -512,7 +516,7 @@ class TimelineHeaderRows extends BaseComponent {
                 isChrono ? 'fc-timeline-header-row-chrono' : '',
             ];
             return ( // eslint-disable-next-line react/no-array-index-key
-            createElement("tr", { key: rowLevel, className: classNames.join(' ') }, rowCells.map((cell) => (createElement(TimelineHeaderTh, { key: cell.date.toISOString(), cell: cell, rowLevel: rowLevel, dateProfile: dateProfile, tDateProfile: tDateProfile, todayRange: todayRange, nowDate: nowDate, rowInnerHeight: rowInnerHeights && rowInnerHeights[rowLevel], isSticky: !isLast })))));
+            preact.createElement("tr", { key: rowLevel, className: classNames.join(' ') }, rowCells.map((cell) => (preact.createElement(TimelineHeaderTh, { key: cell.date.toISOString(), cell: cell, rowLevel: rowLevel, dateProfile: dateProfile, tDateProfile: tDateProfile, todayRange: todayRange, nowDate: nowDate, rowInnerHeight: rowInnerHeights && rowInnerHeights[rowLevel], isSticky: !isLast })))));
         })));
     }
 }
@@ -525,15 +529,15 @@ class TimelineCoords {
         this.tDateProfile = tDateProfile;
         this.dateEnv = dateEnv;
         this.isRtl = isRtl;
-        this.outerCoordCache = new PositionCache(slatRootEl, slatEls, true, // isHorizontal
+        this.outerCoordCache = new internal.PositionCache(slatRootEl, slatEls, true, // isHorizontal
         false);
         // for the inner divs within the slats
         // used for event rendering and scrollTime, to disregard slat border
-        this.innerCoordCache = new PositionCache(slatRootEl, findDirectChildren(slatEls, 'div'), true, // isHorizontal
+        this.innerCoordCache = new internal.PositionCache(slatRootEl, internal.findDirectChildren(slatEls, 'div'), true, // isHorizontal
         false);
     }
     isDateInRange(date) {
-        return rangeContainsMarker(this.dateProfile.currentRange, date);
+        return internal.rangeContainsMarker(this.dateProfile.currentRange, date);
     }
     // results range from negative width of area to 0
     dateToCoord(date) {
@@ -563,7 +567,7 @@ class TimelineCoords {
         if (dateProfile) {
             let date = dateEnv.add(dateProfile.activeRange.start, duration);
             if (!tDateProfile.isTimeScale) {
-                date = startOfDay(date);
+                date = internal.startOfDay(date);
             }
             coord = this.dateToCoord(date);
             // hack to overcome the left borders of non-first slat
@@ -595,7 +599,7 @@ function computeDateSnapCoverage(date, tDateProfile, dateEnv) {
     }
     let snapDiffInt = Math.floor(snapDiff);
     let snapCoverage = tDateProfile.snapDiffToIndex[snapDiffInt];
-    if (isInt(snapCoverage)) { // not an in-between value
+    if (internal.isInt(snapCoverage)) { // not an in-between value
         snapCoverage += snapDiff - snapDiffInt; // add the remainder
     }
     else {
@@ -624,28 +628,28 @@ function coordsToCss(hcoords, isRtl) {
     return { left: hcoords.start, right: -hcoords.end };
 }
 
-class TimelineHeader extends BaseComponent {
+class TimelineHeader extends internal.BaseComponent {
     constructor() {
         super(...arguments);
-        this.rootElRef = createRef();
+        this.rootElRef = preact.createRef();
     }
     render() {
         let { props, context } = this;
         // TODO: very repetitive
         // TODO: make part of tDateProfile?
-        let timerUnit = greatestDurationDenominator(props.tDateProfile.slotDuration).unit;
+        let timerUnit = internal.greatestDurationDenominator(props.tDateProfile.slotDuration).unit;
         // WORKAROUND: make ignore slatCoords when out of sync with dateProfile
         let slatCoords = props.slatCoords && props.slatCoords.dateProfile === props.dateProfile ? props.slatCoords : null;
-        return (createElement(NowTimer, { unit: timerUnit }, (nowDate, todayRange) => (createElement("div", { className: "fc-timeline-header", ref: this.rootElRef },
-            createElement("table", { "aria-hidden": true, className: "fc-scrollgrid-sync-table", style: { minWidth: props.tableMinWidth, width: props.clientWidth } },
+        return (preact.createElement(internal.NowTimer, { unit: timerUnit }, (nowDate, todayRange) => (preact.createElement("div", { className: "fc-timeline-header", ref: this.rootElRef },
+            preact.createElement("table", { "aria-hidden": true, className: "fc-scrollgrid-sync-table", style: { minWidth: props.tableMinWidth, width: props.clientWidth } },
                 props.tableColGroupNode,
-                createElement("tbody", null,
-                    createElement(TimelineHeaderRows, { dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, rowInnerHeights: props.rowInnerHeights }))),
+                preact.createElement("tbody", null,
+                    preact.createElement(TimelineHeaderRows, { dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, rowInnerHeights: props.rowInnerHeights }))),
             context.options.nowIndicator && (
             // need to have a container regardless of whether the current view has a visible now indicator
             // because apparently removal of the element resets the scroll for some reasons (issue #5351).
             // this issue doesn't happen for the timeline body however (
-            createElement("div", { className: "fc-timeline-now-indicator-container" }, (slatCoords && slatCoords.isDateInRange(nowDate)) && (createElement(NowIndicatorContainer, { elClasses: ['fc-timeline-now-indicator-arrow'], elStyle: coordToCss(slatCoords.dateToCoord(nowDate), context.isRtl), isAxis: true, date: nowDate }))))))));
+            preact.createElement("div", { className: "fc-timeline-now-indicator-container" }, (slatCoords && slatCoords.isDateInRange(nowDate)) && (preact.createElement(internal.NowIndicatorContainer, { elClasses: ['fc-timeline-now-indicator-arrow'], elStyle: coordToCss(slatCoords.dateToCoord(nowDate), context.isRtl), isAxis: true, date: nowDate }))))))));
     }
     componentDidMount() {
         this.updateSize();
@@ -659,55 +663,55 @@ class TimelineHeader extends BaseComponent {
         }
     }
     computeMaxCushionWidth() {
-        return Math.max(...findElements(this.rootElRef.current, '.fc-timeline-header-row:last-child .fc-timeline-slot-cushion').map((el) => el.getBoundingClientRect().width));
+        return Math.max(...internal.findElements(this.rootElRef.current, '.fc-timeline-header-row:last-child .fc-timeline-slot-cushion').map((el) => el.getBoundingClientRect().width));
     }
 }
 
-class TimelineSlatCell extends BaseComponent {
+class TimelineSlatCell extends internal.BaseComponent {
     render() {
         let { props, context } = this;
         let { dateEnv, options, theme } = context;
         let { date, tDateProfile, isEm } = props;
-        let dateMeta = getDateMeta(props.date, props.todayRange, props.nowDate, props.dateProfile);
+        let dateMeta = internal.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, { elTag: "td", elRef: props.elRef, elClasses: [
+        return (preact.createElement(internal.ContentContainer, { elTag: "td", elRef: props.elRef, elClasses: [
                 'fc-timeline-slot',
                 'fc-timeline-slot-lane',
                 isEm && 'fc-timeline-slot-em',
-                tDateProfile.isTimeScale ? (isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, props.date, tDateProfile.labelInterval)) ?
+                tDateProfile.isTimeScale ? (internal.isInt(dateEnv.countDurationsBetween(tDateProfile.normalizedRange.start, props.date, tDateProfile.labelInterval)) ?
                     'fc-timeline-slot-major' :
                     'fc-timeline-slot-minor') : '',
                 ...(props.isDay ?
-                    getDayClassNames(dateMeta, theme) :
-                    getSlotClassNames(dateMeta, theme)),
+                    internal.getDayClassNames(dateMeta, theme) :
+                    internal.getSlotClassNames(dateMeta, theme)),
             ], elAttrs: {
                 'data-date': dateEnv.formatIso(date, {
                     omitTimeZoneOffset: true,
                     omitTime: !tDateProfile.isTimeScale,
                 }),
-            }, renderProps: renderProps, generatorName: "slotLaneContent", generator: options.slotLaneContent, classNameGenerator: options.slotLaneClassNames, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount }, (InnerContent) => (createElement(InnerContent, { elTag: "div" }))));
+            }, renderProps: renderProps, generatorName: "slotLaneContent", generator: options.slotLaneContent, classNameGenerator: options.slotLaneClassNames, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount }, (InnerContent) => (preact.createElement(InnerContent, { elTag: "div" }))));
     }
 }
 
-class TimelineSlatsBody extends BaseComponent {
+class TimelineSlatsBody extends internal.BaseComponent {
     render() {
         let { props } = this;
         let { tDateProfile, cellElRefs } = props;
         let { slotDates, isWeekStarts } = tDateProfile;
         let isDay = !tDateProfile.isTimeScale && !tDateProfile.largeUnit;
-        return (createElement("tbody", null,
-            createElement("tr", null, slotDates.map((slotDate, i) => {
+        return (preact.createElement("tbody", null,
+            preact.createElement("tr", null, slotDates.map((slotDate, i) => {
                 let key = slotDate.toISOString();
-                return (createElement(TimelineSlatCell, { key: key, elRef: cellElRefs.createRef(key), date: slotDate, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isEm: isWeekStarts[i], isDay: isDay }));
+                return (preact.createElement(TimelineSlatCell, { key: key, elRef: cellElRefs.createRef(key), date: slotDate, dateProfile: props.dateProfile, tDateProfile: tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isEm: isWeekStarts[i], isDay: isDay }));
             }))));
     }
 }
 
-class TimelineSlats extends BaseComponent {
+class TimelineSlats extends internal.BaseComponent {
     constructor() {
         super(...arguments);
-        this.rootElRef = createRef();
-        this.cellElRefs = new RefMap();
+        this.rootElRef = preact.createRef();
+        this.cellElRefs = new internal.RefMap();
         this.handleScrollRequest = (request) => {
             let { onScrollLeftRequest } = this.props;
             let { coords } = this;
@@ -723,13 +727,13 @@ class TimelineSlats extends BaseComponent {
     }
     render() {
         let { props, context } = this;
-        return (createElement("div", { className: "fc-timeline-slots", ref: this.rootElRef },
-            createElement("table", { "aria-hidden": true, className: context.theme.getClass('table'), style: {
+        return (preact.createElement("div", { className: "fc-timeline-slots", ref: this.rootElRef },
+            preact.createElement("table", { "aria-hidden": true, className: context.theme.getClass('table'), style: {
                     minWidth: props.tableMinWidth,
                     width: props.clientWidth,
                 } },
                 props.tableColGroupNode,
-                createElement(TimelineSlatsBody, { cellElRefs: this.cellElRefs, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange }))));
+                preact.createElement(TimelineSlatsBody, { cellElRefs: this.cellElRefs, dateProfile: props.dateProfile, tDateProfile: props.tDateProfile, nowDate: props.nowDate, todayRange: props.todayRange }))));
     }
     componentDidMount() {
         this.updateSizing();
@@ -773,7 +777,7 @@ class TimelineSlats extends BaseComponent {
                 (outerCoordCache.rights[slatIndex] - leftPosition) / slatWidth :
                 (leftPosition - outerCoordCache.lefts[slatIndex]) / slatWidth;
             let localSnapIndex = Math.floor(partial * tDateProfile.snapsPerSlot);
-            let start = dateEnv.add(tDateProfile.slotDates[slatIndex], multiplyDuration(tDateProfile.snapDuration, localSnapIndex));
+            let start = dateEnv.add(tDateProfile.slotDates[slatIndex], internal.multiplyDuration(tDateProfile.snapDuration, localSnapIndex));
             let end = dateEnv.add(start, tDateProfile.snapDuration);
             return {
                 dateSpan: {
@@ -836,7 +840,7 @@ strictOrder, maxStackCnt) {
             });
         }
     }
-    let hierarchy = new SegHierarchy();
+    let hierarchy = new internal.SegHierarchy();
     if (strictOrder != null) {
         hierarchy.strictOrder = strictOrder;
     }
@@ -849,14 +853,14 @@ strictOrder, maxStackCnt) {
         hcoords: entry.span,
         top: null,
     }));
-    let hiddenGroups = groupIntersectingEntries(hiddenEntries);
+    let hiddenGroups = internal.groupIntersectingEntries(hiddenEntries);
     let moreLinkInputs = [];
     let moreLinkCrudePlacements = [];
     const extractSeg = (entry) => segs[entry.index];
     for (let i = 0; i < hiddenGroups.length; i += 1) {
         let hiddenGroup = hiddenGroups[i];
         let sortedSegs = hiddenGroup.entries.map(extractSeg);
-        let height = moreLinkHeights[buildIsoString(computeEarliestSegStart(sortedSegs))]; // not optimal :(
+        let height = moreLinkHeights[internal.buildIsoString(internal.computeEarliestSegStart(sortedSegs))]; // not optimal :(
         if (height != null) {
             // NOTE: the hiddenGroup's spanStart/spanEnd are already computed by rangeToCoords. computed during input.
             moreLinkInputs.push({
@@ -896,11 +900,11 @@ strictOrder, maxStackCnt) {
     ];
 }
 
-class TimelineLaneBg extends BaseComponent {
+class TimelineLaneBg extends internal.BaseComponent {
     render() {
         let { props } = this;
         let highlightSeg = [].concat(props.eventResizeSegs, props.dateSelectionSegs);
-        return props.timelineCoords && (createElement("div", { className: "fc-timeline-bg" },
+        return props.timelineCoords && (preact.createElement("div", { className: "fc-timeline-bg" },
             this.renderSegs(props.businessHourSegs || [], props.timelineCoords, 'non-business'),
             this.renderSegs(props.bgEventSegs || [], props.timelineCoords, 'bg-event'),
             this.renderSegs(highlightSeg, props.timelineCoords, 'highlight')));
@@ -912,15 +916,15 @@ class TimelineLaneBg extends BaseComponent {
         let children = segs.map((seg, i) => {
             let hcoords = segHCoords[i];
             let hStyle = coordsToCss(hcoords, isRtl);
-            return (createElement("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-timeline-bg-harness", style: hStyle }, fillType === 'bg-event' ?
-                createElement(BgEvent, Object.assign({ seg: seg }, getSegMeta(seg, todayRange, nowDate))) :
-                renderFill(fillType)));
+            return (preact.createElement("div", { key: internal.buildEventRangeKey(seg.eventRange), className: "fc-timeline-bg-harness", style: hStyle }, fillType === 'bg-event' ?
+                preact.createElement(internal.BgEvent, Object.assign({ seg: seg }, internal.getSegMeta(seg, todayRange, nowDate))) :
+                internal.renderFill(fillType)));
         });
-        return createElement(Fragment, null, children);
+        return preact.createElement(preact.Fragment, null, children);
     }
 }
 
-class TimelineLaneSlicer extends Slicer {
+class TimelineLaneSlicer extends internal.Slicer {
     sliceRange(origRange, dateProfile, dateProfileGenerator, tDateProfile, dateEnv) {
         let normalRange = normalizeRange(origRange, tDateProfile, dateEnv);
         let segs = [];
@@ -928,7 +932,7 @@ class TimelineLaneSlicer extends Slicer {
         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);
+            let slicedRange = internal.intersectRanges(normalRange, tDateProfile.normalizedRange);
             if (slicedRange) {
                 segs.push({
                     start: slicedRange.start,
@@ -936,7 +940,7 @@ class TimelineLaneSlicer extends Slicer {
                     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),
+                        && isValidDate(internal.addMs(slicedRange.end, -1), tDateProfile, dateProfile, dateProfileGenerator),
                 });
             }
         }
@@ -944,20 +948,20 @@ class TimelineLaneSlicer extends Slicer {
     }
 }
 
-const DEFAULT_TIME_FORMAT = createFormatter({
+const DEFAULT_TIME_FORMAT = internal.createFormatter({
     hour: 'numeric',
     minute: '2-digit',
     omitZeroMinute: true,
     meridiem: 'narrow',
 });
-class TimelineEvent extends BaseComponent {
+class TimelineEvent extends internal.BaseComponent {
     render() {
         let { props } = this;
-        return (createElement(StandardEvent, Object.assign({}, props, { elClasses: ['fc-timeline-event', 'fc-h-event'], defaultTimeFormat: DEFAULT_TIME_FORMAT, defaultDisplayEventTime: !props.isTimeScale })));
+        return (preact.createElement(internal.StandardEvent, Object.assign({}, props, { elClasses: ['fc-timeline-event', 'fc-h-event'], defaultTimeFormat: DEFAULT_TIME_FORMAT, defaultDisplayEventTime: !props.isTimeScale })));
     }
 }
 
-class TimelineLaneMoreLink extends BaseComponent {
+class TimelineLaneMoreLink extends internal.BaseComponent {
     render() {
         let { props, context } = this;
         let { hiddenSegs, placement, resourceId } = props;
@@ -965,22 +969,22 @@ class TimelineLaneMoreLink extends BaseComponent {
         let isVisible = hcoords && top !== null;
         let hStyle = coordsToCss(hcoords, context.isRtl);
         let extraDateSpan = resourceId ? { resourceId } : {};
-        return (createElement(MoreLinkContainer, { elRef: props.elRef, elClasses: ['fc-timeline-more-link'], elStyle: Object.assign({ visibility: isVisible ? '' : 'hidden', top: top || 0 }, hStyle), allDayDate: null, moreCnt: hiddenSegs.length, allSegs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: extraDateSpan, popoverContent: () => (createElement(Fragment, null, hiddenSegs.map((seg) => {
+        return (preact.createElement(internal.MoreLinkContainer, { elRef: props.elRef, elClasses: ['fc-timeline-more-link'], elStyle: Object.assign({ visibility: isVisible ? '' : 'hidden', top: top || 0 }, hStyle), allDayDate: null, moreCnt: hiddenSegs.length, allSegs: hiddenSegs, hiddenSegs: hiddenSegs, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: extraDateSpan, popoverContent: () => (preact.createElement(preact.Fragment, null, hiddenSegs.map((seg) => {
                 let instanceId = seg.eventRange.instance.instanceId;
-                return (createElement("div", { key: instanceId, style: { visibility: props.isForcedInvisible[instanceId] ? 'hidden' : '' } },
-                    createElement(TimelineEvent, Object.assign({ isTimeScale: props.isTimeScale, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === props.eventSelection }, getSegMeta(seg, props.todayRange, props.nowDate)))));
-            }))) }, (InnerContent) => (createElement(InnerContent, { elTag: "div", elClasses: ['fc-timeline-more-link-inner', 'fc-sticky'] }))));
+                return (preact.createElement("div", { key: instanceId, style: { visibility: props.isForcedInvisible[instanceId] ? 'hidden' : '' } },
+                    preact.createElement(TimelineEvent, Object.assign({ isTimeScale: props.isTimeScale, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === props.eventSelection }, internal.getSegMeta(seg, props.todayRange, props.nowDate)))));
+            }))) }, (InnerContent) => (preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-timeline-more-link-inner', 'fc-sticky'] }))));
     }
 }
 
-class TimelineLane extends BaseComponent {
+class TimelineLane extends internal.BaseComponent {
     constructor() {
         super(...arguments);
         this.slicer = new TimelineLaneSlicer();
-        this.sortEventSegs = memoize(sortEventSegs);
-        this.harnessElRefs = new RefMap();
-        this.moreElRefs = new RefMap();
-        this.innerElRef = createRef();
+        this.sortEventSegs = internal.memoize(internal.sortEventSegs);
+        this.harnessElRefs = new internal.RefMap();
+        this.moreElRefs = new internal.RefMap();
+        this.innerElRef = preact.createRef();
         // TODO: memoize event positioning
         this.state = {
             eventInstanceHeights: {},
@@ -1008,9 +1012,9 @@ class TimelineLane extends BaseComponent {
          (slicedProps.eventDrag ? slicedProps.eventDrag.affectedInstances : null) ||
             (slicedProps.eventResize ? slicedProps.eventResize.affectedInstances : null) ||
             {};
-        return (createElement(Fragment, null,
-            createElement(TimelineLaneBg, { businessHourSegs: slicedProps.businessHourSegs, bgEventSegs: slicedProps.bgEventSegs, timelineCoords: props.timelineCoords, eventResizeSegs: slicedProps.eventResize ? slicedProps.eventResize.segs : [] /* bad new empty array? */, dateSelectionSegs: slicedProps.dateSelectionSegs, nowDate: props.nowDate, todayRange: props.todayRange }),
-            createElement("div", { className: "fc-timeline-events fc-scrollgrid-sync-inner", ref: this.innerElRef, style: { height: fgHeight } },
+        return (preact.createElement(preact.Fragment, null,
+            preact.createElement(TimelineLaneBg, { businessHourSegs: slicedProps.businessHourSegs, bgEventSegs: slicedProps.bgEventSegs, timelineCoords: props.timelineCoords, eventResizeSegs: slicedProps.eventResize ? slicedProps.eventResize.segs : [] /* bad new empty array? */, dateSelectionSegs: slicedProps.dateSelectionSegs, nowDate: props.nowDate, todayRange: props.todayRange }),
+            preact.createElement("div", { className: "fc-timeline-events fc-scrollgrid-sync-inner", ref: this.innerElRef, style: { height: fgHeight } },
                 this.renderFgSegs(fgPlacements, isForcedInvisible, false, false, false),
                 this.renderFgSegs(buildMirrorPlacements(mirrorSegs, props.timelineCoords, fgPlacements), {}, Boolean(slicedProps.eventDrag), Boolean(slicedProps.eventResize), false))));
     }
@@ -1038,8 +1042,8 @@ class TimelineLane extends BaseComponent {
         }
         if (timelineCoords) {
             this.setState({
-                eventInstanceHeights: mapHash(this.harnessElRefs.currentMap, (harnessEl) => (Math.round(harnessEl.getBoundingClientRect().height))),
-                moreLinkHeights: mapHash(this.moreElRefs.currentMap, (moreEl) => (Math.round(moreEl.getBoundingClientRect().height))),
+                eventInstanceHeights: internal.mapHash(this.harnessElRefs.currentMap, (harnessEl) => (Math.round(harnessEl.getBoundingClientRect().height))),
+                moreLinkHeights: internal.mapHash(this.moreElRefs.currentMap, (moreEl) => (Math.round(moreEl.getBoundingClientRect().height))),
             }, () => {
                 if (props.onHeightChange) {
                     props.onHeightChange(innerEl, true);
@@ -1054,23 +1058,23 @@ class TimelineLane extends BaseComponent {
     renderFgSegs(segPlacements, isForcedInvisible, isDragging, isResizing, isDateSelecting) {
         let { harnessElRefs, moreElRefs, props, context } = this;
         let isMirror = isDragging || isResizing || isDateSelecting;
-        return (createElement(Fragment, null, segPlacements.map((segPlacement) => {
+        return (preact.createElement(preact.Fragment, null, segPlacements.map((segPlacement) => {
             let { seg, hcoords, top } = segPlacement;
             if (Array.isArray(seg)) { // a more-link
-                let isoStr = buildIsoString(computeEarliestSegStart(seg));
-                return (createElement(TimelineLaneMoreLink, { key: 'm:' + isoStr /* "m" for "more" */, elRef: moreElRefs.createRef(isoStr), hiddenSegs: seg, placement: segPlacement, dateProfile: props.dateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isTimeScale: props.tDateProfile.isTimeScale, eventSelection: props.eventSelection, resourceId: props.resourceId, isForcedInvisible: isForcedInvisible }));
+                let isoStr = internal.buildIsoString(internal.computeEarliestSegStart(seg));
+                return (preact.createElement(TimelineLaneMoreLink, { key: 'm:' + isoStr /* "m" for "more" */, elRef: moreElRefs.createRef(isoStr), hiddenSegs: seg, placement: segPlacement, dateProfile: props.dateProfile, nowDate: props.nowDate, todayRange: props.todayRange, isTimeScale: props.tDateProfile.isTimeScale, eventSelection: props.eventSelection, resourceId: props.resourceId, isForcedInvisible: isForcedInvisible }));
             }
             let instanceId = seg.eventRange.instance.instanceId;
             let isVisible = isMirror || Boolean(!isForcedInvisible[instanceId] && hcoords && top !== null);
             let hStyle = coordsToCss(hcoords, context.isRtl);
-            return (createElement("div", { key: 'e:' + instanceId /* "e" for "event" */, ref: isMirror ? null : harnessElRefs.createRef(instanceId), className: "fc-timeline-event-harness", style: Object.assign({ visibility: isVisible ? '' : 'hidden', top: top || 0 }, hStyle) },
-                createElement(TimelineEvent, Object.assign({ isTimeScale: props.tDateProfile.isTimeScale, seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === props.eventSelection /* TODO: bad for mirror? */ }, getSegMeta(seg, props.todayRange, props.nowDate)))));
+            return (preact.createElement("div", { key: 'e:' + instanceId /* "e" for "event" */, ref: isMirror ? null : harnessElRefs.createRef(instanceId), className: "fc-timeline-event-harness", style: Object.assign({ visibility: isVisible ? '' : 'hidden', top: top || 0 }, hStyle) },
+                preact.createElement(TimelineEvent, Object.assign({ isTimeScale: props.tDateProfile.isTimeScale, seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === props.eventSelection /* TODO: bad for mirror? */ }, internal.getSegMeta(seg, props.todayRange, props.nowDate)))));
         })));
     }
 }
 TimelineLane.addStateEquality({
-    eventInstanceHeights: isPropsEqual,
-    moreLinkHeights: isPropsEqual,
+    eventInstanceHeights: internal.isPropsEqual,
+    moreLinkHeights: internal.isPropsEqual,
 });
 function buildMirrorPlacements(mirrorSegs, timelineCoords, fgPlacements) {
     if (!mirrorSegs.length || !timelineCoords) {
@@ -1094,10 +1098,10 @@ function buildAbsoluteTopHash(placements) {
     return topsByInstanceId;
 }
 
-class TimelineGrid extends DateComponent {
+class TimelineGrid extends internal.DateComponent {
     constructor() {
         super(...arguments);
-        this.slatsRef = createRef();
+        this.slatsRef = preact.createRef();
         this.state = {
             coords: null,
         };
@@ -1120,17 +1124,17 @@ class TimelineGrid extends DateComponent {
         let { props, state, context } = this;
         let { options } = context;
         let { dateProfile, tDateProfile } = props;
-        let timerUnit = greatestDurationDenominator(tDateProfile.slotDuration).unit;
-        return (createElement("div", { className: "fc-timeline-body", ref: this.handeEl, style: {
+        let timerUnit = internal.greatestDurationDenominator(tDateProfile.slotDuration).unit;
+        return (preact.createElement("div", { className: "fc-timeline-body", ref: this.handeEl, style: {
                 minWidth: props.tableMinWidth,
                 height: props.clientHeight,
                 width: props.clientWidth,
             } },
-            createElement(NowTimer, { unit: timerUnit }, (nowDate, todayRange) => (createElement(Fragment, null,
-                createElement(TimelineSlats, { ref: this.slatsRef, dateProfile: dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, clientWidth: props.clientWidth, tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, onCoords: this.handleCoords, onScrollLeftRequest: props.onScrollLeftRequest }),
-                createElement(TimelineLane, { dateProfile: dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, nextDayThreshold: options.nextDayThreshold, businessHours: props.businessHours, eventStore: props.eventStore, eventUiBases: props.eventUiBases, dateSelection: props.dateSelection, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, timelineCoords: state.coords, syncParentMinHeight: true }),
-                (options.nowIndicator && state.coords && state.coords.isDateInRange(nowDate)) && (createElement("div", { className: "fc-timeline-now-indicator-container" },
-                    createElement(NowIndicatorContainer, { elClasses: ['fc-timeline-now-indicator-line'], elStyle: coordToCss(state.coords.dateToCoord(nowDate), context.isRtl), isAxis: false, date: nowDate }))))))));
+            preact.createElement(internal.NowTimer, { unit: timerUnit }, (nowDate, todayRange) => (preact.createElement(preact.Fragment, null,
+                preact.createElement(TimelineSlats, { ref: this.slatsRef, dateProfile: dateProfile, tDateProfile: tDateProfile, nowDate: nowDate, todayRange: todayRange, clientWidth: props.clientWidth, tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, onCoords: this.handleCoords, onScrollLeftRequest: props.onScrollLeftRequest }),
+                preact.createElement(TimelineLane, { dateProfile: dateProfile, tDateProfile: props.tDateProfile, nowDate: nowDate, todayRange: todayRange, nextDayThreshold: options.nextDayThreshold, businessHours: props.businessHours, eventStore: props.eventStore, eventUiBases: props.eventUiBases, dateSelection: props.dateSelection, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, timelineCoords: state.coords, syncParentMinHeight: true }),
+                (options.nowIndicator && state.coords && state.coords.isDateInRange(nowDate)) && (preact.createElement("div", { className: "fc-timeline-now-indicator-container" },
+                    preact.createElement(internal.NowIndicatorContainer, { elClasses: ['fc-timeline-now-indicator-line'], elStyle: coordToCss(state.coords.dateToCoord(nowDate), context.isRtl), isAxis: false, date: nowDate }))))))));
     }
     // Hit System
     // ------------------------------------------------------------------------------------------
@@ -1155,11 +1159,11 @@ class TimelineGrid extends DateComponent {
     }
 }
 
-class TimelineView extends DateComponent {
+class TimelineView extends internal.DateComponent {
     constructor() {
         super(...arguments);
-        this.buildTimelineDateProfile = memoize(buildTimelineDateProfile);
-        this.scrollGridRef = createRef();
+        this.buildTimelineDateProfile = internal.memoize(buildTimelineDateProfile);
+        this.scrollGridRef = preact.createRef();
         this.state = {
             slatCoords: null,
             slotCushionMaxWidth: null,
@@ -1180,8 +1184,8 @@ class TimelineView extends DateComponent {
     render() {
         let { props, state, context } = this;
         let { options } = context;
-        let stickyHeaderDates = !props.forPrint && getStickyHeaderDates(options);
-        let stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(options);
+        let stickyHeaderDates = !props.forPrint && internal.getStickyHeaderDates(options);
+        let stickyFooterScrollbar = !props.forPrint && internal.getStickyFooterScrollbar(options);
         let tDateProfile = this.buildTimelineDateProfile(props.dateProfile, context.dateEnv, options, context.dateProfileGenerator);
         let { slotMinWidth } = options;
         let slatCols = buildSlatCols(tDateProfile, slotMinWidth || this.computeFallbackSlotMinWidth(tDateProfile));
@@ -1192,7 +1196,7 @@ class TimelineView extends DateComponent {
                 isSticky: stickyHeaderDates,
                 chunks: [{
                         key: 'timeline',
-                        content: (contentArg) => (createElement(TimelineHeader, { dateProfile: props.dateProfile, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, tDateProfile: tDateProfile, slatCoords: state.slatCoords, onMaxCushionWidth: slotMinWidth ? null : this.handleMaxCushionWidth })),
+                        content: (contentArg) => (preact.createElement(TimelineHeader, { dateProfile: props.dateProfile, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, tDateProfile: tDateProfile, slatCoords: state.slatCoords, onMaxCushionWidth: slotMinWidth ? null : this.handleMaxCushionWidth })),
                     }],
             },
             {
@@ -1201,7 +1205,7 @@ class TimelineView extends DateComponent {
                 liquid: true,
                 chunks: [{
                         key: 'timeline',
-                        content: (contentArg) => (createElement(TimelineGrid, Object.assign({}, props, { clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, tDateProfile: tDateProfile, onSlatCoords: this.handleSlatCoords, onScrollLeftRequest: this.handleScrollLeftRequest }))),
+                        content: (contentArg) => (preact.createElement(TimelineGrid, Object.assign({}, props, { clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, tableMinWidth: contentArg.tableMinWidth, tableColGroupNode: contentArg.tableColGroupNode, tDateProfile: tDateProfile, onSlatCoords: this.handleSlatCoords, onScrollLeftRequest: this.handleScrollLeftRequest }))),
                     }],
             },
         ];
@@ -1212,17 +1216,17 @@ class TimelineView extends DateComponent {
                 isSticky: true,
                 chunks: [{
                         key: 'timeline',
-                        content: renderScrollShim,
+                        content: internal.renderScrollShim,
                     }],
             });
         }
-        return (createElement(ViewContainer, { elClasses: [
+        return (preact.createElement(internal.ViewContainer, { elClasses: [
                 'fc-timeline',
                 options.eventOverlap === false ?
                     'fc-timeline-overlap-disabled' :
                     '',
             ], viewSpec: context.viewSpec },
-            createElement(ScrollGrid, { ref: this.scrollGridRef, liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: false, colGroups: [
+            preact.createElement(internal$1.ScrollGrid, { ref: this.scrollGridRef, liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: false, colGroups: [
                     { cols: slatCols },
                 ], sections: sections })));
     }
@@ -1237,4 +1241,15 @@ function buildSlatCols(tDateProfile, slotMinWidth) {
         }];
 }
 
-export { TimelineCoords, TimelineHeader, TimelineHeaderRows, TimelineLane, TimelineLaneBg, TimelineLaneSlicer, TimelineSlats, TimelineView, buildSlatCols, buildTimelineDateProfile, coordToCss, coordsToCss };
+exports.TimelineCoords = TimelineCoords;
+exports.TimelineHeader = TimelineHeader;
+exports.TimelineHeaderRows = TimelineHeaderRows;
+exports.TimelineLane = TimelineLane;
+exports.TimelineLaneBg = TimelineLaneBg;
+exports.TimelineLaneSlicer = TimelineLaneSlicer;
+exports.TimelineSlats = TimelineSlats;
+exports.TimelineView = TimelineView;
+exports.buildSlatCols = buildSlatCols;
+exports.buildTimelineDateProfile = buildTimelineDateProfile;
+exports.coordToCss = coordToCss;
+exports.coordsToCss = coordsToCss;