@fullcalendar/core 6.1.15 → 7.0.0-beta.1

package/internal-common.cjs

@@ -103,7 +103,7 @@ if (typeof document !== 'undefined') {
     registerStylesRoot(document);
 }
 
-var css_248z = ":root{--fc-small-font-size:.85em;--fc-page-bg-color:#fff;--fc-neutral-bg-color:hsla(0,0%,82%,.3);--fc-neutral-text-color:grey;--fc-border-color:#ddd;--fc-button-text-color:#fff;--fc-button-bg-color:#2c3e50;--fc-button-border-color:#2c3e50;--fc-button-hover-bg-color:#1e2b37;--fc-button-hover-border-color:#1a252f;--fc-button-active-bg-color:#1a252f;--fc-button-active-border-color:#151e27;--fc-event-bg-color:#3788d8;--fc-event-border-color:#3788d8;--fc-event-text-color:#fff;--fc-event-selected-overlay-color:rgba(0,0,0,.25);--fc-more-link-bg-color:#d0d0d0;--fc-more-link-text-color:inherit;--fc-event-resizer-thickness:8px;--fc-event-resizer-dot-total-width:8px;--fc-event-resizer-dot-border-width:1px;--fc-non-business-color:hsla(0,0%,84%,.3);--fc-bg-event-color:#8fdf82;--fc-bg-event-opacity:0.3;--fc-highlight-color:rgba(188,232,241,.3);--fc-today-bg-color:rgba(255,220,40,.15);--fc-now-indicator-color:red}.fc-not-allowed,.fc-not-allowed .fc-event{cursor:not-allowed}.fc{display:flex;flex-direction:column;font-size:1em}.fc,.fc *,.fc :after,.fc :before{box-sizing:border-box}.fc table{border-collapse:collapse;border-spacing:0;font-size:1em}.fc th{text-align:center}.fc td,.fc th{padding:0;vertical-align:top}.fc a[data-navlink]{cursor:pointer}.fc a[data-navlink]:hover{text-decoration:underline}.fc-direction-ltr{direction:ltr;text-align:left}.fc-direction-rtl{direction:rtl;text-align:right}.fc-theme-standard td,.fc-theme-standard th{border:1px solid var(--fc-border-color)}.fc-liquid-hack td,.fc-liquid-hack th{position:relative}@font-face{font-family:fcicons;font-style:normal;font-weight:400;src:url(\"data:application/x-font-ttf;charset=utf-8;base64,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\") format(\"truetype\")}.fc-icon{speak:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;display:inline-block;font-family:fcicons!important;font-style:normal;font-variant:normal;font-weight:400;height:1em;line-height:1;text-align:center;text-transform:none;-moz-user-select:none;user-select:none;width:1em}.fc-icon-chevron-left:before{content:\"\\e900\"}.fc-icon-chevron-right:before{content:\"\\e901\"}.fc-icon-chevrons-left:before{content:\"\\e902\"}.fc-icon-chevrons-right:before{content:\"\\e903\"}.fc-icon-minus-square:before{content:\"\\e904\"}.fc-icon-plus-square:before{content:\"\\e905\"}.fc-icon-x:before{content:\"\\e906\"}.fc .fc-button{border-radius:0;font-family:inherit;font-size:inherit;line-height:inherit;margin:0;overflow:visible;text-transform:none}.fc .fc-button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}.fc .fc-button{-webkit-appearance:button}.fc .fc-button:not(:disabled){cursor:pointer}.fc .fc-button{background-color:transparent;border:1px solid transparent;border-radius:.25em;display:inline-block;font-size:1em;font-weight:400;line-height:1.5;padding:.4em .65em;text-align:center;-moz-user-select:none;user-select:none;vertical-align:middle}.fc .fc-button:hover{text-decoration:none}.fc .fc-button:focus{box-shadow:0 0 0 .2rem rgba(44,62,80,.25);outline:0}.fc .fc-button:disabled{opacity:.65}.fc .fc-button-primary{background-color:var(--fc-button-bg-color);border-color:var(--fc-button-border-color);color:var(--fc-button-text-color)}.fc .fc-button-primary:hover{background-color:var(--fc-button-hover-bg-color);border-color:var(--fc-button-hover-border-color);color:var(--fc-button-text-color)}.fc .fc-button-primary:disabled{background-color:var(--fc-button-bg-color);border-color:var(--fc-button-border-color);color:var(--fc-button-text-color)}.fc .fc-button-primary:focus{box-shadow:0 0 0 .2rem rgba(76,91,106,.5)}.fc .fc-button-primary:not(:disabled).fc-button-active,.fc .fc-button-primary:not(:disabled):active{background-color:var(--fc-button-active-bg-color);border-color:var(--fc-button-active-border-color);color:var(--fc-button-text-color)}.fc .fc-button-primary:not(:disabled).fc-button-active:focus,.fc .fc-button-primary:not(:disabled):active:focus{box-shadow:0 0 0 .2rem rgba(76,91,106,.5)}.fc .fc-button .fc-icon{font-size:1.5em;vertical-align:middle}.fc .fc-button-group{display:inline-flex;position:relative;vertical-align:middle}.fc .fc-button-group>.fc-button{flex:1 1 auto;position:relative}.fc .fc-button-group>.fc-button.fc-button-active,.fc .fc-button-group>.fc-button:active,.fc .fc-button-group>.fc-button:focus,.fc .fc-button-group>.fc-button:hover{z-index:1}.fc-direction-ltr .fc-button-group>.fc-button:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0;margin-left:-1px}.fc-direction-ltr .fc-button-group>.fc-button:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0}.fc-direction-rtl .fc-button-group>.fc-button:not(:first-child){border-bottom-right-radius:0;border-top-right-radius:0;margin-right:-1px}.fc-direction-rtl .fc-button-group>.fc-button:not(:last-child){border-bottom-left-radius:0;border-top-left-radius:0}.fc .fc-toolbar{align-items:center;display:flex;justify-content:space-between}.fc .fc-toolbar.fc-header-toolbar{margin-bottom:1.5em}.fc .fc-toolbar.fc-footer-toolbar{margin-top:1.5em}.fc .fc-toolbar-title{font-size:1.75em;margin:0}.fc-direction-ltr .fc-toolbar>*>:not(:first-child){margin-left:.75em}.fc-direction-rtl .fc-toolbar>*>:not(:first-child){margin-right:.75em}.fc-direction-rtl .fc-toolbar-ltr{flex-direction:row-reverse}.fc .fc-scroller{-webkit-overflow-scrolling:touch;position:relative}.fc .fc-scroller-liquid{height:100%}.fc .fc-scroller-liquid-absolute{bottom:0;left:0;position:absolute;right:0;top:0}.fc .fc-scroller-harness{direction:ltr;overflow:hidden;position:relative}.fc .fc-scroller-harness-liquid{height:100%}.fc-direction-rtl .fc-scroller-harness>.fc-scroller{direction:rtl}.fc-theme-standard .fc-scrollgrid{border:1px solid var(--fc-border-color)}.fc .fc-scrollgrid,.fc .fc-scrollgrid table{table-layout:fixed;width:100%}.fc .fc-scrollgrid table{border-left-style:hidden;border-right-style:hidden;border-top-style:hidden}.fc .fc-scrollgrid{border-bottom-width:0;border-collapse:separate;border-right-width:0}.fc .fc-scrollgrid-liquid{height:100%}.fc .fc-scrollgrid-section,.fc .fc-scrollgrid-section table,.fc .fc-scrollgrid-section>td{height:1px}.fc .fc-scrollgrid-section-liquid>td{height:100%}.fc .fc-scrollgrid-section>*{border-left-width:0;border-top-width:0}.fc .fc-scrollgrid-section-footer>*,.fc .fc-scrollgrid-section-header>*{border-bottom-width:0}.fc .fc-scrollgrid-section-body table,.fc .fc-scrollgrid-section-footer table{border-bottom-style:hidden}.fc .fc-scrollgrid-section-sticky>*{background:var(--fc-page-bg-color);position:sticky;z-index:3}.fc .fc-scrollgrid-section-header.fc-scrollgrid-section-sticky>*{top:0}.fc .fc-scrollgrid-section-footer.fc-scrollgrid-section-sticky>*{bottom:0}.fc .fc-scrollgrid-sticky-shim{height:1px;margin-bottom:-1px}.fc-sticky{position:sticky}.fc .fc-view-harness{flex-grow:1;position:relative}.fc .fc-view-harness-active>.fc-view{bottom:0;left:0;position:absolute;right:0;top:0}.fc .fc-col-header-cell-cushion{display:inline-block;padding:2px 4px}.fc .fc-bg-event,.fc .fc-highlight,.fc .fc-non-business{bottom:0;left:0;position:absolute;right:0;top:0}.fc .fc-non-business{background:var(--fc-non-business-color)}.fc .fc-bg-event{background:var(--fc-bg-event-color);opacity:var(--fc-bg-event-opacity)}.fc .fc-bg-event .fc-event-title{font-size:var(--fc-small-font-size);font-style:italic;margin:.5em}.fc .fc-highlight{background:var(--fc-highlight-color)}.fc .fc-cell-shaded,.fc .fc-day-disabled{background:var(--fc-neutral-bg-color)}a.fc-event,a.fc-event:hover{text-decoration:none}.fc-event.fc-event-draggable,.fc-event[href]{cursor:pointer}.fc-event .fc-event-main{position:relative;z-index:2}.fc-event-dragging:not(.fc-event-selected){opacity:.75}.fc-event-dragging.fc-event-selected{box-shadow:0 2px 7px rgba(0,0,0,.3)}.fc-event .fc-event-resizer{display:none;position:absolute;z-index:4}.fc-event-selected .fc-event-resizer,.fc-event:hover .fc-event-resizer{display:block}.fc-event-selected .fc-event-resizer{background:var(--fc-page-bg-color);border-color:inherit;border-radius:calc(var(--fc-event-resizer-dot-total-width)/2);border-style:solid;border-width:var(--fc-event-resizer-dot-border-width);height:var(--fc-event-resizer-dot-total-width);width:var(--fc-event-resizer-dot-total-width)}.fc-event-selected .fc-event-resizer:before{bottom:-20px;content:\"\";left:-20px;position:absolute;right:-20px;top:-20px}.fc-event-selected,.fc-event:focus{box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event-selected:before,.fc-event:focus:before{bottom:0;content:\"\";left:0;position:absolute;right:0;top:0;z-index:3}.fc-event-selected:after,.fc-event:focus:after{background:var(--fc-event-selected-overlay-color);bottom:-1px;content:\"\";left:-1px;position:absolute;right:-1px;top:-1px;z-index:1}.fc-h-event{background-color:var(--fc-event-bg-color);border:1px solid var(--fc-event-border-color);display:block}.fc-h-event .fc-event-main{color:var(--fc-event-text-color)}.fc-h-event .fc-event-main-frame{display:flex}.fc-h-event .fc-event-time{max-width:100%;overflow:hidden}.fc-h-event .fc-event-title-container{flex-grow:1;flex-shrink:1;min-width:0}.fc-h-event .fc-event-title{display:inline-block;left:0;max-width:100%;overflow:hidden;right:0;vertical-align:top}.fc-h-event.fc-event-selected:before{bottom:-10px;top:-10px}.fc-direction-ltr .fc-daygrid-block-event:not(.fc-event-start),.fc-direction-rtl .fc-daygrid-block-event:not(.fc-event-end){border-bottom-left-radius:0;border-left-width:0;border-top-left-radius:0}.fc-direction-ltr .fc-daygrid-block-event:not(.fc-event-end),.fc-direction-rtl .fc-daygrid-block-event:not(.fc-event-start){border-bottom-right-radius:0;border-right-width:0;border-top-right-radius:0}.fc-h-event:not(.fc-event-selected) .fc-event-resizer{bottom:0;top:0;width:var(--fc-event-resizer-thickness)}.fc-direction-ltr .fc-h-event:not(.fc-event-selected) .fc-event-resizer-start,.fc-direction-rtl .fc-h-event:not(.fc-event-selected) .fc-event-resizer-end{cursor:w-resize;left:calc(var(--fc-event-resizer-thickness)*-.5)}.fc-direction-ltr .fc-h-event:not(.fc-event-selected) .fc-event-resizer-end,.fc-direction-rtl .fc-h-event:not(.fc-event-selected) .fc-event-resizer-start{cursor:e-resize;right:calc(var(--fc-event-resizer-thickness)*-.5)}.fc-h-event.fc-event-selected .fc-event-resizer{margin-top:calc(var(--fc-event-resizer-dot-total-width)*-.5);top:50%}.fc-direction-ltr .fc-h-event.fc-event-selected .fc-event-resizer-start,.fc-direction-rtl .fc-h-event.fc-event-selected .fc-event-resizer-end{left:calc(var(--fc-event-resizer-dot-total-width)*-.5)}.fc-direction-ltr .fc-h-event.fc-event-selected .fc-event-resizer-end,.fc-direction-rtl .fc-h-event.fc-event-selected .fc-event-resizer-start{right:calc(var(--fc-event-resizer-dot-total-width)*-.5)}.fc .fc-popover{box-shadow:0 2px 6px rgba(0,0,0,.15);position:absolute;z-index:9999}.fc .fc-popover-header{align-items:center;display:flex;flex-direction:row;justify-content:space-between;padding:3px 4px}.fc .fc-popover-title{margin:0 2px}.fc .fc-popover-close{cursor:pointer;font-size:1.1em;opacity:.65}.fc-theme-standard .fc-popover{background:var(--fc-page-bg-color);border:1px solid var(--fc-border-color)}.fc-theme-standard .fc-popover-header{background:var(--fc-neutral-bg-color)}";
+var css_248z = ":root{--fc-small-font-size:.85em;--fc-page-bg-color:#fff;--fc-neutral-bg-color:hsla(0,0%,82%,.3);--fc-neutral-text-color:grey;--fc-border-color:#ddd;--fc-button-text-color:#fff;--fc-button-bg-color:#2c3e50;--fc-button-border-color:#2c3e50;--fc-button-hover-bg-color:#1e2b37;--fc-button-hover-border-color:#1a252f;--fc-button-active-bg-color:#1a252f;--fc-button-active-border-color:#151e27;--fc-event-bg-color:#3788d8;--fc-event-border-color:#3788d8;--fc-event-text-color:#fff;--fc-event-selected-overlay-color:rgba(0,0,0,.25);--fc-more-link-bg-color:#d0d0d0;--fc-more-link-text-color:inherit;--fc-event-resizer-thickness:8px;--fc-event-resizer-dot-total-width:8px;--fc-event-resizer-dot-border-width:1px;--fc-non-business-color:hsla(0,0%,84%,.3);--fc-bg-event-color:#8fdf82;--fc-bg-event-opacity:0.3;--fc-highlight-color:rgba(188,232,241,.3);--fc-today-bg-color:rgba(255,220,40,.15);--fc-now-indicator-color:red}.fc{display:flex;flex-direction:column;gap:1.5em}.fc,.fc *,.fc :after,.fc :before{box-sizing:border-box}.fc-direction-ltr{direction:ltr;text-align:left}.fc-direction-rtl{direction:rtl;text-align:right}.fc-flex-row{display:flex;flex-direction:row}.fc-flex-column{display:flex;flex-direction:column}.fc-grow{flex-grow:1}.fc-basis0,.fc-liquid{flex-basis:0}.fc-liquid{flex-grow:1;min-height:0;min-width:0}.fc-row{display:flex;flex-direction:row}.fc-rowgroup{display:flex;flex-direction:column}.fc-row,.fc-rowdivider,.fc-rowgroup{border-color:var(--fc-border-color);border-style:solid;border-width:1px 0 0}.fc-row:first-child:not(.fc-not-first),.fc-rowdivider+.fc-row,.fc-rowdivider+.fc-rowgroup,.fc-rowdivider:first-child,.fc-rowgroup:first-child,.fc-sticky-header+.fc-row,.fc-sticky-header+.fc-rowgroup{border-top-width:0}.fc-cell,.fc-celldivider{border:0 solid var(--fc-border-color)}.fc-cell{margin:0!important;padding:0!important}.fc-cell-inner{overflow:hidden;white-space:nowrap}.fc-direction-ltr .fc-cell,.fc-direction-ltr .fc-celldivider{border-left-width:1px}.fc-direction-ltr .fc-cell:first-child:not(.fc-not-first),.fc-direction-ltr .fc-celldivider+.fc-cell{border-left-width:0}.fc-direction-ltr .fc-celldivider,.fc-direction-rtl .fc-cell,.fc-direction-rtl .fc-celldivider{border-right-width:1px}.fc-direction-rtl .fc-cell:first-child:not(.fc-not-first),.fc-direction-rtl .fc-celldivider+.fc-cell{border-right-width:0}.fc-direction-rtl .fc-celldivider{border-left-width:1px}.fc-cell:only-child{flex-basis:0;flex-grow:1;min-width:0}.fc-celldivider,.fc-rowdivider{background:var(--fc-neutral-bg-color)}.fc-celldivider{padding-left:2px}.fc-rowdivider{padding-bottom:2px}.fc-rowdivider,.fc-sticky-header{border-bottom-width:1px}.fc-rel{position:relative}.fc-abs{position:absolute}.fc-fill{bottom:0;top:0}.fc-fill,.fc-fill-x{left:0;position:absolute;right:0}.fc-fill-y{bottom:0;position:absolute;top:0}.fc-sticky-y{bottom:0;position:sticky;top:0}.fc-sticky-x{left:0;position:sticky;right:0}.fc-sticky-header{background:var(--fc-page-bg-color);position:sticky;top:0;z-index:9999}.fc-sticky-footer{bottom:0;position:sticky;z-index:9999}.fc-content-box{box-sizing:content-box}.fc-border{border:1px solid var(--fc-border-color)}.fc-offscreen{left:-10000px;position:absolute}.fc-shaded{background-color:var(--fc-neutral-bg-color)}.fc-padding-sm{padding:2px 4px}.fc-padding-md{padding:4px 5px}.fc-padding-lg{padding:8px}.fc-justify-center{justify-content:center}.fc-align-center{align-items:center}.fc-align-start{align-items:flex-start}.fc a[data-navlink]{cursor:pointer}.fc a[data-navlink]:hover{text-decoration:underline}.fc-view-harness{position:relative}.fc-view-harness-fixedheight,.fc-view-harness-liquid{display:flex;flex-direction:column}.fc-view-harness-fixedheight>.fc-view,.fc-view-harness-liquid,.fc-view-harness-liquid>.fc-view{flex-basis:0;flex-grow:1;min-height:0}.fc-view-harness-aspectratio>.fc-view{bottom:0;left:0;position:absolute;right:0;top:0}a.fc-event,a.fc-event:hover{text-decoration:none}.fc-event.fc-event-draggable,.fc-event[href]{cursor:pointer}.fc-event-dragging:not(.fc-event-selected){opacity:.75}.fc-event-dragging.fc-event-selected{box-shadow:0 2px 7px rgba(0,0,0,.3)}.fc-event-selected,.fc-event:focus{box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event-selected:before,.fc-event:focus:before{bottom:0;content:\"\";left:0;position:absolute;right:0;top:0;z-index:3}.fc-event-selected:after,.fc-event:focus:after{background:var(--fc-event-selected-overlay-color);bottom:-1px;content:\"\";left:-1px;position:absolute;right:-1px;top:-1px;z-index:1}.fc-event-inner{position:relative;z-index:2}.fc-event-resizer{display:none;position:absolute;z-index:4}.fc-event-selected .fc-event-resizer,.fc-event:hover .fc-event-resizer{display:block}.fc-event-selected .fc-event-resizer{background:var(--fc-page-bg-color);border-color:inherit;border-radius:calc(var(--fc-event-resizer-dot-total-width)/2);border-style:solid;border-width:var(--fc-event-resizer-dot-border-width);height:var(--fc-event-resizer-dot-total-width);width:var(--fc-event-resizer-dot-total-width)}.fc-event-selected .fc-event-resizer:before{bottom:-20px;content:\"\";left:-20px;position:absolute;right:-20px;top:-20px}.fc-bg-event,.fc-highlight,.fc-non-business{bottom:0;left:0;position:absolute;right:0;top:0}.fc-non-business{background:var(--fc-non-business-color)}.fc-bg-event{background:var(--fc-bg-event-color);opacity:var(--fc-bg-event-opacity)}.fc-bg-event .fc-event-title{font-size:var(--fc-small-font-size);font-style:italic;margin:.5em}.fc-highlight{background:var(--fc-highlight-color)}.fc-day-disabled{background:var(--fc-neutral-bg-color)}.fc-h-event{background-color:var(--fc-event-bg-color);border:1px solid var(--fc-event-border-color);display:flex;flex-direction:column;position:relative}.fc-h-event.fc-event-selected:before{bottom:-10px;top:-10px}.fc-h-event .fc-event-inner{color:var(--fc-event-text-color);display:flex;flex-direction:row;flex-grow:1;min-width:0}.fc-h-event .fc-event-time,.fc-h-event .fc-event-title{overflow:hidden;white-space:nowrap}.fc-h-event .fc-event-title-outer{display:flex;flex-basis:0;flex-direction:row;flex-grow:1;min-width:0}.fc-h-event .fc-event-title{left:0;position:sticky;right:0}.fc-h-event:not(.fc-event-selected) .fc-event-resizer{bottom:0;top:0;width:var(--fc-event-resizer-thickness)}.fc-direction-ltr .fc-h-event:not(.fc-event-selected) .fc-event-resizer-start,.fc-direction-rtl .fc-h-event:not(.fc-event-selected) .fc-event-resizer-end{cursor:w-resize;left:calc(var(--fc-event-resizer-thickness)*-.5)}.fc-direction-ltr .fc-h-event:not(.fc-event-selected) .fc-event-resizer-end,.fc-direction-rtl .fc-h-event:not(.fc-event-selected) .fc-event-resizer-start{cursor:e-resize;right:calc(var(--fc-event-resizer-thickness)*-.5)}.fc-h-event.fc-event-selected .fc-event-resizer{margin-top:calc(var(--fc-event-resizer-dot-total-width)*-.5);top:50%}.fc-direction-ltr .fc-h-event.fc-event-selected .fc-event-resizer-start,.fc-direction-rtl .fc-h-event.fc-event-selected .fc-event-resizer-end{left:calc(var(--fc-event-resizer-dot-total-width)*-.5)}.fc-direction-ltr .fc-h-event.fc-event-selected .fc-event-resizer-end,.fc-direction-rtl .fc-h-event.fc-event-selected .fc-event-resizer-start{right:calc(var(--fc-event-resizer-dot-total-width)*-.5)}.fc-popover{box-shadow:0 2px 6px rgba(0,0,0,.15);position:absolute;z-index:9999}.fc-popover-header{align-items:center;display:flex;flex-direction:row;justify-content:space-between;padding:3px 4px}.fc-popover-title{margin:0 2px}.fc-popover-close{cursor:pointer;font-size:1.1em;opacity:.65}.fc-theme-standard .fc-popover{background:var(--fc-page-bg-color);border:1px solid var(--fc-border-color)}.fc-theme-standard .fc-popover-header{background:var(--fc-neutral-bg-color)}.fc-scroller-nobars{-ms-overflow-style:none;scrollbar-width:none}.fc-scroller-nobars::-webkit-scrollbar{display:none}.fc-not-allowed,.fc-not-allowed .fc-event{cursor:not-allowed}@font-face{font-family:fcicons;font-style:normal;font-weight:400;src:url(\"data:application/x-font-ttf;charset=utf-8;base64,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\") format(\"truetype\")}.fc-icon{speak:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;display:inline-block;font-family:fcicons!important;font-style:normal;font-variant:normal;font-weight:400;height:1em;line-height:1;text-align:center;text-transform:none;-moz-user-select:none;user-select:none;width:1em}.fc-icon-chevron-left:before{content:\"\\e900\"}.fc-icon-chevron-right:before{content:\"\\e901\"}.fc-icon-chevrons-left:before{content:\"\\e902\"}.fc-icon-chevrons-right:before{content:\"\\e903\"}.fc-icon-minus-square:before{content:\"\\e904\"}.fc-icon-plus-square:before{content:\"\\e905\"}.fc-icon-x:before{content:\"\\e906\"}.fc-button{border-radius:0;font-family:inherit;font-size:inherit;line-height:inherit;margin:0;overflow:visible;text-transform:none}.fc-button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}.fc-button{-webkit-appearance:button}.fc-button:not(:disabled){cursor:pointer}.fc-button{background-color:transparent;border:1px solid transparent;border-radius:.25em;display:inline-block;font-size:1em;font-weight:400;line-height:1.5;padding:.4em .65em;text-align:center;-moz-user-select:none;user-select:none;vertical-align:middle}.fc-button:hover{text-decoration:none}.fc-button:focus{box-shadow:0 0 0 .2rem rgba(44,62,80,.25);outline:0}.fc-button:disabled{opacity:.65}.fc-button-primary{background-color:var(--fc-button-bg-color);border-color:var(--fc-button-border-color);color:var(--fc-button-text-color)}.fc-button-primary:hover{background-color:var(--fc-button-hover-bg-color);border-color:var(--fc-button-hover-border-color);color:var(--fc-button-text-color)}.fc-button-primary:disabled{background-color:var(--fc-button-bg-color);border-color:var(--fc-button-border-color);color:var(--fc-button-text-color)}.fc-button-primary:focus{box-shadow:0 0 0 .2rem rgba(76,91,106,.5)}.fc-button-primary:not(:disabled).fc-button-active,.fc-button-primary:not(:disabled):active{background-color:var(--fc-button-active-bg-color);border-color:var(--fc-button-active-border-color);color:var(--fc-button-text-color)}.fc-button-primary:not(:disabled).fc-button-active:focus,.fc-button-primary:not(:disabled):active:focus{box-shadow:0 0 0 .2rem rgba(76,91,106,.5)}.fc-button .fc-icon{font-size:1.5em;vertical-align:middle}.fc-button-group{display:inline-flex;position:relative;vertical-align:middle}.fc-button-group>.fc-button{flex:1 1 auto;position:relative}.fc-button-group>.fc-button.fc-button-active,.fc-button-group>.fc-button:active,.fc-button-group>.fc-button:focus,.fc-button-group>.fc-button:hover{z-index:1}.fc-direction-ltr .fc-button-group>.fc-button:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0;margin-left:-1px}.fc-direction-ltr .fc-button-group>.fc-button:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0}.fc-direction-rtl .fc-button-group>.fc-button:not(:first-child){border-bottom-right-radius:0;border-top-right-radius:0;margin-right:-1px}.fc-direction-rtl .fc-button-group>.fc-button:not(:last-child){border-bottom-left-radius:0;border-top-left-radius:0}.fc-toolbar{align-items:center;display:flex;flex-direction:row;gap:.75em;justify-content:space-between}.fc-direction-rtl .fc-toolbar-ltr{flex-direction:row-reverse}.fc-toolbar-chunk{display:flex;flex-direction:row;flex-shrink:0;gap:.75em}.fc-toolbar-title{font-size:1.75em;margin:0;white-space:nowrap}";
 injectStyles(css_248z);
 
 class DelayedRunner {
@@ -465,20 +465,6 @@ function compareNumbers(a, b) {
 function isInt(n) {
     return n % 1 === 0;
 }
-/* FC-specific DOM dimension stuff
-----------------------------------------------------------------------------------------------------------------------*/
-function computeSmallestCellWidth(cellEl) {
-    let allWidthEl = cellEl.querySelector('.fc-scrollgrid-shrink-frame');
-    let contentWidthEl = cellEl.querySelector('.fc-scrollgrid-shrink-cushion');
-    if (!allWidthEl) {
-        throw new Error('needs fc-scrollgrid-shrink-frame className'); // TODO: use const
-    }
-    if (!contentWidthEl) {
-        throw new Error('needs fc-scrollgrid-shrink-cushion className');
-    }
-    return cellEl.getBoundingClientRect().width - allWidthEl.getBoundingClientRect().width + // the cell padding+border
-        contentWidthEl.getBoundingClientRect().width;
-}
 
 const INTERNAL_UNITS = ['years', 'months', 'days', 'milliseconds'];
 const PARSE_RE = /^(-?)(?:(\d+)\.)?(\d+):(\d\d)(?::(\d\d)(?:\.(\d\d\d))?)?/;
@@ -1391,8 +1377,6 @@ const BASE_OPTION_REFINERS = {
     dropAccept: identity,
     eventOrder: parseFieldSpecs,
     eventOrderStrict: Boolean,
-    handleWindowResize: Boolean,
-    windowResizeDelay: Number,
     longPressDelay: Number,
     eventDragMinDistance: Number,
     expandRows: Boolean,
@@ -1542,8 +1526,6 @@ const BASE_OPTION_DEFAULTS = {
     dropAccept: '*',
     eventOrder: 'start,-duration,allDay,title',
     dayPopoverFormat: { month: 'long', day: 'numeric', year: 'numeric' },
-    handleWindowResize: true,
-    windowResizeDelay: 100,
     longPressDelay: 1000,
     eventDragMinDistance: 5,
     expandRows: false,
@@ -1562,7 +1544,6 @@ const CALENDAR_LISTENER_REFINERS = {
     eventAdd: identity,
     eventChange: identity,
     eventRemove: identity,
-    windowResize: identity,
     eventClick: identity,
     eventMouseEnter: identity,
     eventMouseLeave: identity,
@@ -1575,8 +1556,7 @@ const CALENDAR_LISTENER_REFINERS = {
     _afterprint: identity,
     _noEventDrop: identity,
     _noEventResize: identity,
-    _resize: identity,
-    _scrollRequest: identity,
+    _timeScrollRequest: identity,
 };
 // calendar-specific options
 // -------------------------
@@ -2246,6 +2226,9 @@ Theme.prototype.iconOverridePrefix = '';
 NOTE: this can be a public API, especially createElement for hooks.
 See examples/typescript-scheduler/src/index.ts
 */
+/*
+TODO: rethink this
+*/
 function flushSync(runBeforeFlush) {
     runBeforeFlush();
     let oldDebounceRendering = preact__namespace.options.debounceRendering; // orig
@@ -2295,42 +2278,6 @@ function createContext(defaultValue) {
     return ContextType;
 }
 
-class ScrollResponder {
-    constructor(execFunc, emitter, scrollTime, scrollTimeReset) {
-        this.execFunc = execFunc;
-        this.emitter = emitter;
-        this.scrollTime = scrollTime;
-        this.scrollTimeReset = scrollTimeReset;
-        this.handleScrollRequest = (request) => {
-            this.queuedRequest = Object.assign({}, this.queuedRequest || {}, request);
-            this.drain();
-        };
-        emitter.on('_scrollRequest', this.handleScrollRequest);
-        this.fireInitialScroll();
-    }
-    detach() {
-        this.emitter.off('_scrollRequest', this.handleScrollRequest);
-    }
-    update(isDatesNew) {
-        if (isDatesNew && this.scrollTimeReset) {
-            this.fireInitialScroll(); // will drain
-        }
-        else {
-            this.drain();
-        }
-    }
-    fireInitialScroll() {
-        this.handleScrollRequest({
-            time: this.scrollTime,
-        });
-    }
-    drain() {
-        if (this.queuedRequest && this.execFunc(this.queuedRequest)) {
-            this.queuedRequest = null;
-        }
-    }
-}
-
 const ViewContextType = createContext({}); // for Components
 function buildViewContext(viewSpec, viewApi, viewOptions, dateProfileGenerator, dateEnv, theme, pluginHooks, dispatch, getCurrentData, emitter, calendarApi, registerInteractiveComponent, unregisterInteractiveComponent) {
     return {
@@ -2346,15 +2293,6 @@ function buildViewContext(viewSpec, viewApi, viewOptions, dateProfileGenerator,
         dateProfileGenerator,
         theme,
         isRtl: viewOptions.direction === 'rtl',
-        addResizeHandler(handler) {
-            emitter.on('_resize', handler);
-        },
-        removeResizeHandler(handler) {
-            emitter.off('_resize', handler);
-        },
-        createScrollResponder(execFunc) {
-            return new ScrollResponder(execFunc, emitter, createDuration(viewOptions.scrollTime), viewOptions.scrollTimeReset);
-        },
         registerInteractiveComponent,
         unregisterInteractiveComponent,
     };
@@ -3417,6 +3355,9 @@ function parseClassNames(raw) {
     }
     return [];
 }
+function fracToCssDim(frac) {
+    return frac * 100 + '%';
+}
 
 // TODO: better called "EventSettings" or "EventConfig"
 // TODO: move this file into structs
@@ -4356,12 +4297,12 @@ function sliceEventStore(eventStore, eventUiBases, framingRange, nextDayThreshol
 function hasBgRendering(def) {
     return def.ui.display === 'background' || def.ui.display === 'inverse-background';
 }
-function setElSeg(el, seg) {
-    el.fcSeg = seg;
+function setElEventRange(el, eventRange) {
+    el.fcEventRange = eventRange;
 }
-function getElSeg(el) {
-    return el.fcSeg ||
-        el.parentNode.fcSeg || // for the harness
+function getElEventRange(el) {
+    return el.fcEventRange ||
+        el.parentNode.fcEventRange || // for the harness
         null;
 }
 // event ui computation
@@ -4381,7 +4322,7 @@ function compileEventUi(eventDef, eventUiBases) {
 }
 function sortEventSegs(segs, eventOrderSpecs) {
     let objs = segs.map(buildSegCompareObj);
-    objs.sort((obj0, obj1) => compareByFieldSpecs(obj0, obj1, eventOrderSpecs));
+    objs.sort((obj0, obj1) => compareByFieldSpecs(obj0, obj1, eventOrderSpecs)); // !!!
     return objs.map((c) => c._seg);
 }
 // returns a object with all primitive props that can be compared
@@ -4394,29 +4335,23 @@ function buildSegCompareObj(seg) {
     return Object.assign(Object.assign(Object.assign({}, eventDef.extendedProps), eventDef), { id: eventDef.publicId, start,
         end, duration: end - start, allDay: Number(eventDef.allDay), _seg: seg });
 }
-function computeSegDraggable(seg, context) {
+function computeEventRangeDraggable(eventRange, context) {
     let { pluginHooks } = context;
     let transformers = pluginHooks.isDraggableTransformers;
-    let { def, ui } = seg.eventRange;
+    let { def, ui } = eventRange;
     let val = ui.startEditable;
     for (let transformer of transformers) {
         val = transformer(val, def, ui, context);
     }
     return val;
 }
-function computeSegStartResizable(seg, context) {
-    return seg.isStart && seg.eventRange.ui.durationEditable && context.options.eventResizableFromStart;
-}
-function computeSegEndResizable(seg, context) {
-    return seg.isEnd && seg.eventRange.ui.durationEditable;
-}
-function buildSegTimeText(seg, timeFormat, context, defaultDisplayEventTime, // defaults to true
+function buildEventRangeTimeText(eventRange, timeFormat, context, defaultDisplayEventTime, // defaults to true
 defaultDisplayEventEnd, // defaults to true
 startOverride, endOverride) {
     let { dateEnv, options } = context;
     let { displayEventTime, displayEventEnd } = options;
-    let eventDef = seg.eventRange.def;
-    let eventInstance = seg.eventRange.instance;
+    let eventDef = eventRange.def;
+    let eventInstance = eventRange.instance;
     if (displayEventTime == null) {
         displayEventTime = defaultDisplayEventTime !== false;
     }
@@ -4425,8 +4360,8 @@ startOverride, endOverride) {
     }
     let wholeEventStart = eventInstance.range.start;
     let wholeEventEnd = eventInstance.range.end;
-    let segStart = startOverride || seg.start || seg.eventRange.range.start;
-    let segEnd = endOverride || seg.end || seg.eventRange.range.end;
+    let segStart = startOverride || eventRange.range.start;
+    let segEnd = endOverride || eventRange.range.end;
     let isStartDay = startOfDay(wholeEventStart).valueOf() === startOfDay(segStart).valueOf();
     let isEndDay = startOfDay(addMs(wholeEventEnd, -1)).valueOf() === startOfDay(addMs(segEnd, -1)).valueOf();
     if (displayEventTime && !eventDef.allDay && (isStartDay || isEndDay)) {
@@ -4444,8 +4379,8 @@ startOverride, endOverride) {
     }
     return '';
 }
-function getSegMeta(seg, todayRange, nowDate) {
-    let segRange = seg.eventRange.range;
+function getEventRangeMeta(eventRange, todayRange, nowDate) {
+    let segRange = eventRange.range;
     return {
         isPast: segRange.end <= (nowDate || todayRange.start),
         isFuture: segRange.start >= (nowDate || todayRange.end),
@@ -4495,8 +4430,8 @@ function buildEventRangeKey(eventRange) {
         : `${eventRange.def.defId}:${eventRange.range.start.toISOString()}`;
     // inverse-background events don't have specific instances. TODO: better solution
 }
-function getSegAnchorAttrs(seg, context) {
-    let { def, instance } = seg.eventRange;
+function getEventRangeAnchorAttrs(eventRange, context) {
+    let { def, instance } = eventRange;
     let { url } = def;
     if (url) {
         return { href: url };
@@ -4676,33 +4611,6 @@ function requestJson(method, url, params) {
     });
 }
 
-let canVGrowWithinCell;
-function getCanVGrowWithinCell() {
-    if (canVGrowWithinCell == null) {
-        canVGrowWithinCell = computeCanVGrowWithinCell();
-    }
-    return canVGrowWithinCell;
-}
-function computeCanVGrowWithinCell() {
-    // for SSR, because this function is call immediately at top-level
-    // TODO: just make this logic execute top-level, immediately, instead of doing lazily
-    if (typeof document === 'undefined') {
-        return true;
-    }
-    let el = document.createElement('div');
-    el.style.position = 'absolute';
-    el.style.top = '0px';
-    el.style.left = '0px';
-    el.innerHTML = '<table><tr><td><div></div></td></tr></table>';
-    el.querySelector('table').style.height = '100px';
-    el.querySelector('div').style.height = '100%';
-    document.body.appendChild(el);
-    let div = el.querySelector('div');
-    let possible = div.offsetHeight > 0;
-    document.body.removeChild(el);
-    return possible;
-}
-
 class CalendarRoot extends BaseComponent {
     constructor() {
         super(...arguments);
@@ -4721,21 +4629,16 @@ class CalendarRoot extends BaseComponent {
         };
     }
     render() {
-        let { props } = this;
+        let { props, state } = this;
         let { options } = props;
-        let { forPrint } = this.state;
-        let isHeightAuto = forPrint || options.height === 'auto' || options.contentHeight === 'auto';
-        let height = (!isHeightAuto && options.height != null) ? options.height : '';
+        let { forPrint } = state;
         let classNames = [
             'fc',
             forPrint ? 'fc-media-print' : 'fc-media-screen',
             `fc-direction-${options.direction}`,
             props.theme.getClass('root'),
         ];
-        if (!getCanVGrowWithinCell()) {
-            classNames.push('fc-liquid-hack');
-        }
-        return props.children(classNames, height, isHeightAuto, forPrint);
+        return props.children(classNames, options.height, forPrint);
     }
     componentDidMount() {
         let { emitter } = this.props;
@@ -4773,978 +4676,695 @@ function interactionSettingsToStore(settings) {
 // global state
 const interactionSettingsStore = {};
 
-class CalendarImpl {
-    getCurrentData() {
-        return this.currentDataManager.getCurrentData();
-    }
-    dispatch(action) {
-        this.currentDataManager.dispatch(action);
-    }
-    get view() { return this.getCurrentData().viewApi; }
-    batchRendering(callback) {
-        callback();
-    }
-    updateSize() {
-        this.trigger('_resize', true);
-    }
-    // Options
-    // -----------------------------------------------------------------------------------------------------------------
-    setOption(name, val) {
-        this.dispatch({
-            type: 'SET_OPTION',
-            optionName: name,
-            rawOptionValue: val,
-        });
-    }
-    getOption(name) {
-        return this.currentDataManager.currentCalendarOptionsInput[name];
+function pointInsideRect(point, rect) {
+    return point.left >= rect.left &&
+        point.left < rect.right &&
+        point.top >= rect.top &&
+        point.top < rect.bottom;
+}
+// Returns a new rectangle that is the intersection of the two rectangles. If they don't intersect, returns false
+function intersectRects(rect1, rect2) {
+    let res = {
+        left: Math.max(rect1.left, rect2.left),
+        right: Math.min(rect1.right, rect2.right),
+        top: Math.max(rect1.top, rect2.top),
+        bottom: Math.min(rect1.bottom, rect2.bottom),
+    };
+    if (res.left < res.right && res.top < res.bottom) {
+        return res;
     }
-    getAvailableLocaleCodes() {
-        return Object.keys(this.getCurrentData().availableRawLocales);
+    return false;
+}
+function translateRect(rect, deltaX, deltaY) {
+    return {
+        left: rect.left + deltaX,
+        right: rect.right + deltaX,
+        top: rect.top + deltaY,
+        bottom: rect.bottom + deltaY,
+    };
+}
+// Returns a new point that will have been moved to reside within the given rectangle
+function constrainPoint(point, rect) {
+    return {
+        left: Math.min(Math.max(point.left, rect.left), rect.right),
+        top: Math.min(Math.max(point.top, rect.top), rect.bottom),
+    };
+}
+// Returns a point that is the center of the given rectangle
+function getRectCenter(rect) {
+    return {
+        left: (rect.left + rect.right) / 2,
+        top: (rect.top + rect.bottom) / 2,
+    };
+}
+// Subtracts point2's coordinates from point1's coordinates, returning a delta
+function diffPoints(point1, point2) {
+    return {
+        left: point1.left - point2.left,
+        top: point1.top - point2.top,
+    };
+}
+
+const EMPTY_EVENT_STORE = createEmptyEventStore(); // for purecomponents. TODO: keep elsewhere
+class Splitter {
+    constructor() {
+        this.getKeysForEventDefs = memoize(this._getKeysForEventDefs);
+        this.splitDateSelection = memoize(this._splitDateSpan);
+        this.splitEventStore = memoize(this._splitEventStore);
+        this.splitIndividualUi = memoize(this._splitIndividualUi);
+        this.splitEventDrag = memoize(this._splitInteraction);
+        this.splitEventResize = memoize(this._splitInteraction);
+        this.eventUiBuilders = {}; // TODO: typescript protection
     }
-    // Trigger
-    // -----------------------------------------------------------------------------------------------------------------
-    on(handlerName, handler) {
-        let { currentDataManager } = this;
-        if (currentDataManager.currentCalendarOptionsRefiners[handlerName]) {
-            currentDataManager.emitter.on(handlerName, handler);
-        }
-        else {
-            console.warn(`Unknown listener name '${handlerName}'`);
+    splitProps(props) {
+        let keyInfos = this.getKeyInfo(props);
+        let defKeys = this.getKeysForEventDefs(props.eventStore);
+        let dateSelections = this.splitDateSelection(props.dateSelection);
+        let individualUi = this.splitIndividualUi(props.eventUiBases, defKeys); // the individual *bases*
+        let eventStores = this.splitEventStore(props.eventStore, defKeys);
+        let eventDrags = this.splitEventDrag(props.eventDrag);
+        let eventResizes = this.splitEventResize(props.eventResize);
+        let splitProps = {};
+        this.eventUiBuilders = mapHash(keyInfos, (info, key) => this.eventUiBuilders[key] || memoize(buildEventUiForKey));
+        for (let key in keyInfos) {
+            let keyInfo = keyInfos[key];
+            let eventStore = eventStores[key] || EMPTY_EVENT_STORE;
+            let buildEventUi = this.eventUiBuilders[key];
+            splitProps[key] = {
+                businessHours: keyInfo.businessHours || props.businessHours,
+                dateSelection: dateSelections[key] || null,
+                eventStore,
+                eventUiBases: buildEventUi(props.eventUiBases[''], keyInfo.ui, individualUi[key]),
+                eventDrag: eventDrags[key] || null,
+                eventResize: eventResizes[key] || null,
+                eventSelection: eventStore.instances[props.eventSelection] ? props.eventSelection : '',
+            };
         }
+        return splitProps;
     }
-    off(handlerName, handler) {
-        this.currentDataManager.emitter.off(handlerName, handler);
+    _splitDateSpan(dateSpan) {
+        let dateSpans = {};
+        if (dateSpan) {
+            let keys = this.getKeysForDateSpan(dateSpan);
+            for (let key of keys) {
+                dateSpans[key] = dateSpan;
+            }
+        }
+        return dateSpans;
     }
-    // not meant for public use
-    trigger(handlerName, ...args) {
-        this.currentDataManager.emitter.trigger(handlerName, ...args);
+    _getKeysForEventDefs(eventStore) {
+        return mapHash(eventStore.defs, (eventDef) => this.getKeysForEventDef(eventDef));
     }
-    // View
-    // -----------------------------------------------------------------------------------------------------------------
-    changeView(viewType, dateOrRange) {
-        this.batchRendering(() => {
-            this.unselect();
-            if (dateOrRange) {
-                if (dateOrRange.start && dateOrRange.end) { // a range
-                    this.dispatch({
-                        type: 'CHANGE_VIEW_TYPE',
-                        viewType,
-                    });
-                    this.dispatch({
-                        type: 'SET_OPTION',
-                        optionName: 'visibleRange',
-                        rawOptionValue: dateOrRange,
-                    });
-                }
-                else {
-                    let { dateEnv } = this.getCurrentData();
-                    this.dispatch({
-                        type: 'CHANGE_VIEW_TYPE',
-                        viewType,
-                        dateMarker: dateEnv.createMarker(dateOrRange),
-                    });
+    _splitEventStore(eventStore, defKeys) {
+        let { defs, instances } = eventStore;
+        let splitStores = {};
+        for (let defId in defs) {
+            for (let key of defKeys[defId]) {
+                if (!splitStores[key]) {
+                    splitStores[key] = createEmptyEventStore();
                 }
+                splitStores[key].defs[defId] = defs[defId];
             }
-            else {
-                this.dispatch({
-                    type: 'CHANGE_VIEW_TYPE',
-                    viewType,
-                });
-            }
-        });
-    }
-    // Forces navigation to a view for the given date.
-    // `viewType` can be a specific view name or a generic one like "week" or "day".
-    // needs to change
-    zoomTo(dateMarker, viewType) {
-        let state = this.getCurrentData();
-        let spec;
-        viewType = viewType || 'day'; // day is default zoom
-        spec = state.viewSpecs[viewType] || this.getUnitViewSpec(viewType);
-        this.unselect();
-        if (spec) {
-            this.dispatch({
-                type: 'CHANGE_VIEW_TYPE',
-                viewType: spec.type,
-                dateMarker,
-            });
-        }
-        else {
-            this.dispatch({
-                type: 'CHANGE_DATE',
-                dateMarker,
-            });
-        }
-    }
-    // Given a duration singular unit, like "week" or "day", finds a matching view spec.
-    // Preference is given to views that have corresponding buttons.
-    getUnitViewSpec(unit) {
-        let { viewSpecs, toolbarConfig } = this.getCurrentData();
-        let viewTypes = [].concat(toolbarConfig.header ? toolbarConfig.header.viewsWithButtons : [], toolbarConfig.footer ? toolbarConfig.footer.viewsWithButtons : []);
-        let i;
-        let spec;
-        for (let viewType in viewSpecs) {
-            viewTypes.push(viewType);
         }
-        for (i = 0; i < viewTypes.length; i += 1) {
-            spec = viewSpecs[viewTypes[i]];
-            if (spec) {
-                if (spec.singleUnit === unit) {
-                    return spec;
+        for (let instanceId in instances) {
+            let instance = instances[instanceId];
+            for (let key of defKeys[instance.defId]) {
+                if (splitStores[key]) { // must have already been created
+                    splitStores[key].instances[instanceId] = instance;
                 }
             }
         }
-        return null;
+        return splitStores;
     }
-    // Current Date
-    // -----------------------------------------------------------------------------------------------------------------
-    prev() {
-        this.unselect();
-        this.dispatch({ type: 'PREV' });
+    _splitIndividualUi(eventUiBases, defKeys) {
+        let splitHashes = {};
+        for (let defId in eventUiBases) {
+            if (defId) { // not the '' key
+                for (let key of defKeys[defId]) {
+                    if (!splitHashes[key]) {
+                        splitHashes[key] = {};
+                    }
+                    splitHashes[key][defId] = eventUiBases[defId];
+                }
+            }
+        }
+        return splitHashes;
     }
-    next() {
-        this.unselect();
-        this.dispatch({ type: 'NEXT' });
+    _splitInteraction(interaction) {
+        let splitStates = {};
+        if (interaction) {
+            let affectedStores = this._splitEventStore(interaction.affectedEvents, this._getKeysForEventDefs(interaction.affectedEvents));
+            // can't rely on defKeys because event data is mutated
+            let mutatedKeysByDefId = this._getKeysForEventDefs(interaction.mutatedEvents);
+            let mutatedStores = this._splitEventStore(interaction.mutatedEvents, mutatedKeysByDefId);
+            let populate = (key) => {
+                if (!splitStates[key]) {
+                    splitStates[key] = {
+                        affectedEvents: affectedStores[key] || EMPTY_EVENT_STORE,
+                        mutatedEvents: mutatedStores[key] || EMPTY_EVENT_STORE,
+                        isEvent: interaction.isEvent,
+                    };
+                }
+            };
+            for (let key in affectedStores) {
+                populate(key);
+            }
+            for (let key in mutatedStores) {
+                populate(key);
+            }
+        }
+        return splitStates;
     }
-    prevYear() {
-        let state = this.getCurrentData();
-        this.unselect();
-        this.dispatch({
-            type: 'CHANGE_DATE',
-            dateMarker: state.dateEnv.addYears(state.currentDate, -1),
-        });
+}
+function buildEventUiForKey(allUi, eventUiForKey, individualUi) {
+    let baseParts = [];
+    if (allUi) {
+        baseParts.push(allUi);
     }
-    nextYear() {
-        let state = this.getCurrentData();
-        this.unselect();
-        this.dispatch({
-            type: 'CHANGE_DATE',
-            dateMarker: state.dateEnv.addYears(state.currentDate, 1),
-        });
+    if (eventUiForKey) {
+        baseParts.push(eventUiForKey);
     }
-    today() {
-        let state = this.getCurrentData();
-        this.unselect();
-        this.dispatch({
-            type: 'CHANGE_DATE',
-            dateMarker: getNow(state.calendarOptions.now, state.dateEnv),
-        });
+    let stuff = {
+        '': combineEventUis(baseParts),
+    };
+    if (individualUi) {
+        Object.assign(stuff, individualUi);
     }
-    gotoDate(zonedDateInput) {
-        let state = this.getCurrentData();
-        this.unselect();
-        this.dispatch({
-            type: 'CHANGE_DATE',
-            dateMarker: state.dateEnv.createMarker(zonedDateInput),
-        });
+    return stuff;
+}
+
+function getDateMeta(date, todayRange, nowDate, dateProfile) {
+    return {
+        dow: date.getUTCDay(),
+        isDisabled: Boolean(dateProfile && !rangeContainsMarker(dateProfile.activeRange, date)),
+        isOther: Boolean(dateProfile && !rangeContainsMarker(dateProfile.currentRange, date)),
+        isToday: Boolean(todayRange && rangeContainsMarker(todayRange, date)),
+        isPast: Boolean(nowDate ? (date < nowDate) : todayRange ? (date < todayRange.start) : false),
+        isFuture: Boolean(nowDate ? (date > nowDate) : todayRange ? (date >= todayRange.end) : false),
+    };
+}
+function getDayClassNames(meta, theme) {
+    let classNames = [
+        'fc-day',
+        `fc-day-${DAY_IDS[meta.dow]}`,
+    ];
+    if (meta.isDisabled) {
+        classNames.push('fc-day-disabled');
     }
-    incrementDate(deltaInput) {
-        let state = this.getCurrentData();
-        let delta = createDuration(deltaInput);
-        if (delta) { // else, warn about invalid input?
-            this.unselect();
-            this.dispatch({
-                type: 'CHANGE_DATE',
-                dateMarker: state.dateEnv.add(state.currentDate, delta),
-            });
+    else {
+        if (meta.isToday) {
+            classNames.push('fc-day-today');
+        }
+        if (meta.isPast) {
+            classNames.push('fc-day-past');
+        }
+        if (meta.isFuture) {
+            classNames.push('fc-day-future');
+        }
+        if (meta.isOther) {
+            classNames.push('fc-day-other');
         }
     }
-    getDate() {
-        let state = this.getCurrentData();
-        return state.dateEnv.toDate(state.currentDate);
-    }
-    // Date Formatting Utils
-    // -----------------------------------------------------------------------------------------------------------------
-    formatDate(d, formatter) {
-        let { dateEnv } = this.getCurrentData();
-        return dateEnv.format(dateEnv.createMarker(d), createFormatter(formatter));
+    return classNames;
+}
+function getSlotClassNames(meta, theme) {
+    let classNames = [
+        'fc-slot',
+        `fc-slot-${DAY_IDS[meta.dow]}`,
+    ];
+    if (meta.isDisabled) {
+        classNames.push('fc-slot-disabled');
     }
-    // `settings` is for formatter AND isEndExclusive
-    formatRange(d0, d1, settings) {
-        let { dateEnv } = this.getCurrentData();
-        return dateEnv.formatRange(dateEnv.createMarker(d0), dateEnv.createMarker(d1), createFormatter(settings), settings);
+    else {
+        if (meta.isToday) {
+            classNames.push('fc-slot-today');
+        }
+        if (meta.isPast) {
+            classNames.push('fc-slot-past');
+        }
+        if (meta.isFuture) {
+            classNames.push('fc-slot-future');
+        }
     }
-    formatIso(d, omitTime) {
-        let { dateEnv } = this.getCurrentData();
-        return dateEnv.formatIso(dateEnv.createMarker(d), { omitTime });
+    return classNames;
+}
+
+// TODO: kill Component::safeSetState
+// TODO: kill
+function setStateDimMap(component, key, newMap) {
+    const currentMap = component.state[key];
+    if (!currentMap || !isDimMapsEqual(currentMap, newMap)) {
+        component.setState({ [key]: newMap });
+    }
+}
+// TODO: kill
+function isDimMapsEqual(oldMap, newMap) {
+    for (const key in newMap) {
+        if (!isDimsEqual(oldMap[key], newMap[key])) {
+            return false;
+        }
     }
-    // Date Selection / Event Selection / DayClick
-    // -----------------------------------------------------------------------------------------------------------------
-    select(dateOrObj, endDate) {
-        let selectionInput;
-        if (endDate == null) {
-            if (dateOrObj.start != null) {
-                selectionInput = dateOrObj;
+    return true;
+}
+// TODO: kill
+function isDimsEqual(v0, v1) {
+    return v0 != null && (v0 === v1 || Math.abs(v0 - v1) < 0.01);
+}
+
+const callbackMap = new Map();
+let flushedCallbackSet = new Set();
+let isHandling = false;
+/*
+Performant from multiple perspectives:
+- less memory with one ResizeObserver
+- batches firing
+*/
+const resizeObserver = new ResizeObserver((entries) => {
+    isHandling = true;
+    for (let entry of entries) {
+        const callback = callbackMap.get(entry.target);
+        if (entry.contentBoxSize) {
+            // The standard makes contentBoxSize an array...
+            if (entry.contentBoxSize[0]) {
+                callback(entry.contentBoxSize[0].inlineSize, entry.contentBoxSize[0].blockSize);
             }
             else {
-                selectionInput = {
-                    start: dateOrObj,
-                    end: null,
-                };
+                // ...but old versions of Firefox treat it as a single item
+                callback(entry.contentBoxSize.inlineSize, entry.contentBoxSize.blockSize);
             }
         }
         else {
-            selectionInput = {
-                start: dateOrObj,
-                end: endDate,
-            };
-        }
-        let state = this.getCurrentData();
-        let selection = parseDateSpan(selectionInput, state.dateEnv, createDuration({ days: 1 }));
-        if (selection) { // throw parse error otherwise?
-            this.dispatch({ type: 'SELECT_DATES', selection });
-            triggerDateSelect(selection, null, state);
+            callback(entry.contentRect.width, entry.contentRect.height);
         }
     }
-    unselect(pev) {
-        let state = this.getCurrentData();
-        if (state.dateSelection) {
-            this.dispatch({ type: 'UNSELECT_DATES' });
-            triggerDateUnselect(pev, state);
-        }
+    for (const flushedCallback of flushedCallbackSet.values()) {
+        flushedCallback();
+        flushedCallbackSet.delete(flushedCallback);
     }
-    // Public Events API
-    // -----------------------------------------------------------------------------------------------------------------
-    addEvent(eventInput, sourceInput) {
-        if (eventInput instanceof EventImpl) {
-            let def = eventInput._def;
-            let instance = eventInput._instance;
-            let currentData = this.getCurrentData();
-            // not already present? don't want to add an old snapshot
-            if (!currentData.eventStore.defs[def.defId]) {
-                this.dispatch({
-                    type: 'ADD_EVENTS',
-                    eventStore: eventTupleToStore({ def, instance }), // TODO: better util for two args?
-                });
-                this.triggerEventAdd(eventInput);
-            }
-            return eventInput;
-        }
-        let state = this.getCurrentData();
-        let eventSource;
-        if (sourceInput instanceof EventSourceImpl) {
-            eventSource = sourceInput.internalEventSource;
-        }
-        else if (typeof sourceInput === 'boolean') {
-            if (sourceInput) { // true. part of the first event source
-                [eventSource] = hashValuesToArray(state.eventSources);
-            }
-        }
-        else if (sourceInput != null) { // an ID. accepts a number too
-            let sourceApi = this.getEventSourceById(sourceInput); // TODO: use an internal function
-            if (!sourceApi) {
-                console.warn(`Could not find an event source with ID "${sourceInput}"`); // TODO: test
-                return null;
-            }
-            eventSource = sourceApi.internalEventSource;
+    isHandling = false;
+});
+/*
+PRECONDITIONS:
+- element can only have one listener attached ever
+- element cannot have border or padding
+
+TODO:
+- always force border/padding on these elements to `0 !important` ???
+*/
+function watchSize(el, callback) {
+    callbackMap.set(el, callback);
+    resizeObserver.observe(el);
+    return () => {
+        callbackMap.delete(el);
+        resizeObserver.unobserve(el);
+    };
+}
+function watchWidth(el, callback) {
+    let currentWidth;
+    return watchSize(el, (width) => {
+        if (currentWidth == null || currentWidth !== width) {
+            callback(currentWidth = width);
         }
-        let tuple = parseEvent(eventInput, eventSource, state, false);
-        if (tuple) {
-            let newEventApi = new EventImpl(state, tuple.def, tuple.def.recurringDef ? null : tuple.instance);
-            this.dispatch({
-                type: 'ADD_EVENTS',
-                eventStore: eventTupleToStore(tuple),
-            });
-            this.triggerEventAdd(newEventApi);
-            return newEventApi;
+    });
+}
+function watchHeight(el, callback) {
+    let currentHeight;
+    return watchSize(el, (_width, height) => {
+        if (currentHeight == null || currentHeight !== height) {
+            callback(currentHeight = height);
         }
-        return null;
+    });
+}
+function afterSize(callback) {
+    if (isHandling) {
+        flushedCallbackSet.add(callback);
     }
-    triggerEventAdd(eventApi) {
-        let { emitter } = this.getCurrentData();
-        emitter.trigger('eventAdd', {
-            event: eventApi,
-            relatedEvents: [],
-            revert: () => {
-                this.dispatch({
-                    type: 'REMOVE_EVENTS',
-                    eventStore: eventApiToStore(eventApi),
-                });
-            },
-        });
-    }
-    // TODO: optimize
-    getEventById(id) {
-        let state = this.getCurrentData();
-        let { defs, instances } = state.eventStore;
-        id = String(id);
-        for (let defId in defs) {
-            let def = defs[defId];
-            if (def.publicId === id) {
-                if (def.recurringDef) {
-                    return new EventImpl(state, def, null);
-                }
-                for (let instanceId in instances) {
-                    let instance = instances[instanceId];
-                    if (instance.defId === def.defId) {
-                        return new EventImpl(state, def, instance);
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    getEvents() {
-        let currentData = this.getCurrentData();
-        return buildEventApis(currentData.eventStore, currentData);
-    }
-    removeAllEvents() {
-        this.dispatch({ type: 'REMOVE_ALL_EVENTS' });
-    }
-    // Public Event Sources API
-    // -----------------------------------------------------------------------------------------------------------------
-    getEventSources() {
-        let state = this.getCurrentData();
-        let sourceHash = state.eventSources;
-        let sourceApis = [];
-        for (let internalId in sourceHash) {
-            sourceApis.push(new EventSourceImpl(state, sourceHash[internalId]));
-        }
-        return sourceApis;
+    else {
+        callback(); // TODO: should we queue microtask?
     }
-    getEventSourceById(id) {
-        let state = this.getCurrentData();
-        let sourceHash = state.eventSources;
-        id = String(id);
-        for (let sourceId in sourceHash) {
-            if (sourceHash[sourceId].publicId === id) {
-                return new EventSourceImpl(state, sourceHash[sourceId]);
+}
+
+const DAY_FORMAT = createFormatter({ year: 'numeric', month: 'long', day: 'numeric' });
+const WEEK_FORMAT = createFormatter({ week: 'long' });
+function buildNavLinkAttrs(context, dateMarker, viewType = 'day', isTabbable = true) {
+    const { dateEnv, options, calendarApi } = context;
+    let dateStr = dateEnv.format(dateMarker, viewType === 'week' ? WEEK_FORMAT : DAY_FORMAT);
+    if (options.navLinks) {
+        let zonedDate = dateEnv.toDate(dateMarker);
+        const handleInteraction = (ev) => {
+            let customAction = viewType === 'day' ? options.navLinkDayClick :
+                viewType === 'week' ? options.navLinkWeekClick : null;
+            if (typeof customAction === 'function') {
+                customAction.call(calendarApi, dateEnv.toDate(dateMarker), ev);
             }
-        }
-        return null;
-    }
-    addEventSource(sourceInput) {
-        let state = this.getCurrentData();
-        if (sourceInput instanceof EventSourceImpl) {
-            // not already present? don't want to add an old snapshot
-            if (!state.eventSources[sourceInput.internalEventSource.sourceId]) {
-                this.dispatch({
-                    type: 'ADD_EVENT_SOURCES',
-                    sources: [sourceInput.internalEventSource],
-                });
+            else {
+                if (typeof customAction === 'string') {
+                    viewType = customAction;
+                }
+                calendarApi.zoomTo(dateMarker, viewType);
             }
-            return sourceInput;
-        }
-        let eventSource = parseEventSource(sourceInput, state);
-        if (eventSource) { // TODO: error otherwise?
-            this.dispatch({ type: 'ADD_EVENT_SOURCES', sources: [eventSource] });
-            return new EventSourceImpl(state, eventSource);
-        }
-        return null;
-    }
-    removeAllEventSources() {
-        this.dispatch({ type: 'REMOVE_ALL_EVENT_SOURCES' });
-    }
-    refetchEvents() {
-        this.dispatch({ type: 'FETCH_EVENT_SOURCES', isRefetch: true });
-    }
-    // Scroll
-    // -----------------------------------------------------------------------------------------------------------------
-    scrollToTime(timeInput) {
-        let time = createDuration(timeInput);
-        if (time) {
-            this.trigger('_scrollRequest', { time });
-        }
+        };
+        return Object.assign({ title: formatWithOrdinals(options.navLinkHint, [dateStr, zonedDate], dateStr), 'data-navlink': '' }, (isTabbable
+            ? createAriaClickAttrs(handleInteraction)
+            : { onClick: handleInteraction }));
     }
+    return { 'aria-label': dateStr };
 }
 
-function pointInsideRect(point, rect) {
-    return point.left >= rect.left &&
-        point.left < rect.right &&
-        point.top >= rect.top &&
-        point.top < rect.bottom;
+let _isRtlScrollbarOnLeft = null;
+function getIsRtlScrollbarOnLeft() {
+    if (_isRtlScrollbarOnLeft === null) {
+        _isRtlScrollbarOnLeft = computeIsRtlScrollbarOnLeft();
+    }
+    return _isRtlScrollbarOnLeft;
 }
-// Returns a new rectangle that is the intersection of the two rectangles. If they don't intersect, returns false
-function intersectRects(rect1, rect2) {
-    let res = {
-        left: Math.max(rect1.left, rect2.left),
-        right: Math.min(rect1.right, rect2.right),
-        top: Math.max(rect1.top, rect2.top),
-        bottom: Math.min(rect1.bottom, rect2.bottom),
-    };
-    if (res.left < res.right && res.top < res.bottom) {
-        return res;
+function computeIsRtlScrollbarOnLeft() {
+    let outerEl = document.createElement('div');
+    applyStyle(outerEl, {
+        position: 'absolute',
+        top: -1000,
+        left: 0,
+        border: 0,
+        padding: 0,
+        overflow: 'scroll',
+        direction: 'rtl',
+    });
+    outerEl.innerHTML = '<div></div>';
+    document.body.appendChild(outerEl);
+    let innerEl = outerEl.firstChild;
+    let res = innerEl.getBoundingClientRect().left > outerEl.getBoundingClientRect().left;
+    removeElement(outerEl);
+    return res;
+}
+
+let _scrollbarWidths;
+function getScrollbarWidths() {
+    if (!_scrollbarWidths) {
+        _scrollbarWidths = computeScrollbarWidths();
     }
-    return false;
+    return _scrollbarWidths;
 }
-function translateRect(rect, deltaX, deltaY) {
+function computeScrollbarWidths() {
+    let el = document.createElement('div');
+    el.style.overflow = 'scroll';
+    el.style.position = 'absolute';
+    el.style.top = '-9999px';
+    el.style.left = '-9999px';
+    document.body.appendChild(el);
+    let res = computeScrollbarWidthsForEl(el);
+    document.body.removeChild(el);
+    return res;
+}
+// WARNING: will include border
+function computeScrollbarWidthsForEl(el) {
     return {
-        left: rect.left + deltaX,
-        right: rect.right + deltaX,
-        top: rect.top + deltaY,
-        bottom: rect.bottom + deltaY,
+        x: el.offsetHeight - el.clientHeight,
+        y: el.offsetWidth - el.clientWidth,
     };
 }
-// Returns a new point that will have been moved to reside within the given rectangle
-function constrainPoint(point, rect) {
-    return {
-        left: Math.min(Math.max(point.left, rect.left), rect.right),
-        top: Math.min(Math.max(point.top, rect.top), rect.bottom),
+
+function computeEdges(el, getPadding = false) {
+    let computedStyle = window.getComputedStyle(el);
+    let borderLeft = parseInt(computedStyle.borderLeftWidth, 10) || 0;
+    let borderRight = parseInt(computedStyle.borderRightWidth, 10) || 0;
+    let borderTop = parseInt(computedStyle.borderTopWidth, 10) || 0;
+    let borderBottom = parseInt(computedStyle.borderBottomWidth, 10) || 0;
+    let badScrollbarWidths = computeScrollbarWidthsForEl(el); // includes border!
+    let scrollbarLeftRight = badScrollbarWidths.y - borderLeft - borderRight;
+    let scrollbarBottom = badScrollbarWidths.x - borderTop - borderBottom;
+    let res = {
+        borderLeft,
+        borderRight,
+        borderTop,
+        borderBottom,
+        scrollbarBottom,
+        scrollbarLeft: 0,
+        scrollbarRight: 0,
     };
+    if (getIsRtlScrollbarOnLeft() && computedStyle.direction === 'rtl') { // is the scrollbar on the left side?
+        res.scrollbarLeft = scrollbarLeftRight;
+    }
+    else {
+        res.scrollbarRight = scrollbarLeftRight;
+    }
+    if (getPadding) {
+        res.paddingLeft = parseInt(computedStyle.paddingLeft, 10) || 0;
+        res.paddingRight = parseInt(computedStyle.paddingRight, 10) || 0;
+        res.paddingTop = parseInt(computedStyle.paddingTop, 10) || 0;
+        res.paddingBottom = parseInt(computedStyle.paddingBottom, 10) || 0;
+    }
+    return res;
 }
-// Returns a point that is the center of the given rectangle
-function getRectCenter(rect) {
-    return {
-        left: (rect.left + rect.right) / 2,
-        top: (rect.top + rect.bottom) / 2,
+function computeInnerRect(el, goWithinPadding = false, doFromWindowViewport) {
+    let outerRect = doFromWindowViewport ? el.getBoundingClientRect() : computeRect(el);
+    let edges = computeEdges(el, goWithinPadding);
+    let res = {
+        left: outerRect.left + edges.borderLeft + edges.scrollbarLeft,
+        right: outerRect.right - edges.borderRight - edges.scrollbarRight,
+        top: outerRect.top + edges.borderTop,
+        bottom: outerRect.bottom - edges.borderBottom - edges.scrollbarBottom,
     };
+    if (goWithinPadding) {
+        res.left += edges.paddingLeft;
+        res.right -= edges.paddingRight;
+        res.top += edges.paddingTop;
+        res.bottom -= edges.paddingBottom;
+    }
+    return res;
 }
-// Subtracts point2's coordinates from point1's coordinates, returning a delta
-function diffPoints(point1, point2) {
+function computeRect(el) {
+    let rect = el.getBoundingClientRect();
     return {
-        left: point1.left - point2.left,
-        top: point1.top - point2.top,
+        left: rect.left + window.scrollX,
+        top: rect.top + window.scrollY,
+        right: rect.right + window.scrollX,
+        bottom: rect.bottom + window.scrollY,
     };
 }
-
-const EMPTY_EVENT_STORE = createEmptyEventStore(); // for purecomponents. TODO: keep elsewhere
-class Splitter {
-    constructor() {
-        this.getKeysForEventDefs = memoize(this._getKeysForEventDefs);
-        this.splitDateSelection = memoize(this._splitDateSpan);
-        this.splitEventStore = memoize(this._splitEventStore);
-        this.splitIndividualUi = memoize(this._splitIndividualUi);
-        this.splitEventDrag = memoize(this._splitInteraction);
-        this.splitEventResize = memoize(this._splitInteraction);
-        this.eventUiBuilders = {}; // TODO: typescript protection
-    }
-    splitProps(props) {
-        let keyInfos = this.getKeyInfo(props);
-        let defKeys = this.getKeysForEventDefs(props.eventStore);
-        let dateSelections = this.splitDateSelection(props.dateSelection);
-        let individualUi = this.splitIndividualUi(props.eventUiBases, defKeys); // the individual *bases*
-        let eventStores = this.splitEventStore(props.eventStore, defKeys);
-        let eventDrags = this.splitEventDrag(props.eventDrag);
-        let eventResizes = this.splitEventResize(props.eventResize);
-        let splitProps = {};
-        this.eventUiBuilders = mapHash(keyInfos, (info, key) => this.eventUiBuilders[key] || memoize(buildEventUiForKey));
-        for (let key in keyInfos) {
-            let keyInfo = keyInfos[key];
-            let eventStore = eventStores[key] || EMPTY_EVENT_STORE;
-            let buildEventUi = this.eventUiBuilders[key];
-            splitProps[key] = {
-                businessHours: keyInfo.businessHours || props.businessHours,
-                dateSelection: dateSelections[key] || null,
-                eventStore,
-                eventUiBases: buildEventUi(props.eventUiBases[''], keyInfo.ui, individualUi[key]),
-                eventSelection: eventStore.instances[props.eventSelection] ? props.eventSelection : '',
-                eventDrag: eventDrags[key] || null,
-                eventResize: eventResizes[key] || null,
-            };
+function computeClippedClientRect(el) {
+    let clippingParents = getClippingParents(el);
+    let rect = el.getBoundingClientRect();
+    for (let clippingParent of clippingParents) {
+        let intersection = intersectRects(rect, clippingParent.getBoundingClientRect());
+        if (intersection) {
+            rect = intersection;
+        }
+        else {
+            return null;
         }
-        return splitProps;
     }
-    _splitDateSpan(dateSpan) {
-        let dateSpans = {};
-        if (dateSpan) {
-            let keys = this.getKeysForDateSpan(dateSpan);
-            for (let key of keys) {
-                dateSpans[key] = dateSpan;
-            }
+    return rect;
+}
+// does not return window
+function getClippingParents(el) {
+    let parents = [];
+    while (el instanceof HTMLElement) { // will stop when gets to document or null
+        let computedStyle = window.getComputedStyle(el);
+        if (computedStyle.position === 'fixed') {
+            break;
         }
-        return dateSpans;
+        if ((/(auto|scroll)/).test(computedStyle.overflow + computedStyle.overflowY + computedStyle.overflowX)) {
+            parents.push(el);
+        }
+        el = el.parentNode;
     }
-    _getKeysForEventDefs(eventStore) {
-        return mapHash(eventStore.defs, (eventDef) => this.getKeysForEventDef(eventDef));
+    return parents;
+}
+
+/*
+Records offset information for a set of elements, relative to an origin element.
+Can record the left/right OR the top/bottom OR both.
+Provides methods for querying the cache by position.
+*/
+class PositionCache {
+    constructor(originEl, els, isHorizontal, isVertical) {
+        this.els = els;
+        let originClientRect = this.originClientRect = originEl.getBoundingClientRect(); // relative to viewport top-left
+        if (isHorizontal) {
+            this.buildElHorizontals(originClientRect.left);
+        }
+        if (isVertical) {
+            this.buildElVerticals(originClientRect.top);
+        }
     }
-    _splitEventStore(eventStore, defKeys) {
-        let { defs, instances } = eventStore;
-        let splitStores = {};
-        for (let defId in defs) {
-            for (let key of defKeys[defId]) {
-                if (!splitStores[key]) {
-                    splitStores[key] = createEmptyEventStore();
-                }
-                splitStores[key].defs[defId] = defs[defId];
-            }
+    // Populates the left/right internal coordinate arrays
+    buildElHorizontals(originClientLeft) {
+        let lefts = [];
+        let rights = [];
+        for (let el of this.els) {
+            let rect = el.getBoundingClientRect();
+            lefts.push(rect.left - originClientLeft);
+            rights.push(rect.right - originClientLeft);
         }
-        for (let instanceId in instances) {
-            let instance = instances[instanceId];
-            for (let key of defKeys[instance.defId]) {
-                if (splitStores[key]) { // must have already been created
-                    splitStores[key].instances[instanceId] = instance;
-                }
-            }
+        this.lefts = lefts;
+        this.rights = rights;
+    }
+    // Populates the top/bottom internal coordinate arrays
+    buildElVerticals(originClientTop) {
+        let tops = [];
+        let bottoms = [];
+        for (let el of this.els) {
+            let rect = el.getBoundingClientRect();
+            tops.push(rect.top - originClientTop);
+            bottoms.push(rect.bottom - originClientTop);
         }
-        return splitStores;
+        this.tops = tops;
+        this.bottoms = bottoms;
     }
-    _splitIndividualUi(eventUiBases, defKeys) {
-        let splitHashes = {};
-        for (let defId in eventUiBases) {
-            if (defId) { // not the '' key
-                for (let key of defKeys[defId]) {
-                    if (!splitHashes[key]) {
-                        splitHashes[key] = {};
-                    }
-                    splitHashes[key][defId] = eventUiBases[defId];
-                }
+    // Given a left offset (from document left), returns the index of the el that it horizontally intersects.
+    // If no intersection is made, returns undefined.
+    leftToIndex(leftPosition) {
+        let { lefts, rights } = this;
+        let len = lefts.length;
+        let i;
+        for (i = 0; i < len; i += 1) {
+            if (leftPosition >= lefts[i] && leftPosition < rights[i]) {
+                return i;
             }
         }
-        return splitHashes;
+        return undefined; // TODO: better
     }
-    _splitInteraction(interaction) {
-        let splitStates = {};
-        if (interaction) {
-            let affectedStores = this._splitEventStore(interaction.affectedEvents, this._getKeysForEventDefs(interaction.affectedEvents));
-            // can't rely on defKeys because event data is mutated
-            let mutatedKeysByDefId = this._getKeysForEventDefs(interaction.mutatedEvents);
-            let mutatedStores = this._splitEventStore(interaction.mutatedEvents, mutatedKeysByDefId);
-            let populate = (key) => {
-                if (!splitStates[key]) {
-                    splitStates[key] = {
-                        affectedEvents: affectedStores[key] || EMPTY_EVENT_STORE,
-                        mutatedEvents: mutatedStores[key] || EMPTY_EVENT_STORE,
-                        isEvent: interaction.isEvent,
-                    };
-                }
-            };
-            for (let key in affectedStores) {
-                populate(key);
-            }
-            for (let key in mutatedStores) {
-                populate(key);
+    // Given a top offset (from document top), returns the index of the el that it vertically intersects.
+    // If no intersection is made, returns undefined.
+    topToIndex(topPosition) {
+        let { tops, bottoms } = this;
+        let len = tops.length;
+        let i;
+        for (i = 0; i < len; i += 1) {
+            if (topPosition >= tops[i] && topPosition < bottoms[i]) {
+                return i;
             }
         }
-        return splitStates;
-    }
-}
-function buildEventUiForKey(allUi, eventUiForKey, individualUi) {
-    let baseParts = [];
-    if (allUi) {
-        baseParts.push(allUi);
-    }
-    if (eventUiForKey) {
-        baseParts.push(eventUiForKey);
+        return undefined; // TODO: better
     }
-    let stuff = {
-        '': combineEventUis(baseParts),
-    };
-    if (individualUi) {
-        Object.assign(stuff, individualUi);
+    // Gets the width of the element at the given index
+    getWidth(leftIndex) {
+        return this.rights[leftIndex] - this.lefts[leftIndex];
     }
-    return stuff;
-}
-
-function getDateMeta(date, todayRange, nowDate, dateProfile) {
-    return {
-        dow: date.getUTCDay(),
-        isDisabled: Boolean(dateProfile && !rangeContainsMarker(dateProfile.activeRange, date)),
-        isOther: Boolean(dateProfile && !rangeContainsMarker(dateProfile.currentRange, date)),
-        isToday: Boolean(todayRange && rangeContainsMarker(todayRange, date)),
-        isPast: Boolean(nowDate ? (date < nowDate) : todayRange ? (date < todayRange.start) : false),
-        isFuture: Boolean(nowDate ? (date > nowDate) : todayRange ? (date >= todayRange.end) : false),
-    };
-}
-function getDayClassNames(meta, theme) {
-    let classNames = [
-        'fc-day',
-        `fc-day-${DAY_IDS[meta.dow]}`,
-    ];
-    if (meta.isDisabled) {
-        classNames.push('fc-day-disabled');
+    // Gets the height of the element at the given index
+    getHeight(topIndex) {
+        return this.bottoms[topIndex] - this.tops[topIndex];
     }
-    else {
-        if (meta.isToday) {
-            classNames.push('fc-day-today');
-            classNames.push(theme.getClass('today'));
-        }
-        if (meta.isPast) {
-            classNames.push('fc-day-past');
-        }
-        if (meta.isFuture) {
-            classNames.push('fc-day-future');
-        }
-        if (meta.isOther) {
-            classNames.push('fc-day-other');
-        }
+    similarTo(otherCache) {
+        return similarNumArrays(this.tops || [], otherCache.tops || []) &&
+            similarNumArrays(this.bottoms || [], otherCache.bottoms || []) &&
+            similarNumArrays(this.lefts || [], otherCache.lefts || []) &&
+            similarNumArrays(this.rights || [], otherCache.rights || []);
     }
-    return classNames;
 }
-function getSlotClassNames(meta, theme) {
-    let classNames = [
-        'fc-slot',
-        `fc-slot-${DAY_IDS[meta.dow]}`,
-    ];
-    if (meta.isDisabled) {
-        classNames.push('fc-slot-disabled');
+function similarNumArrays(a, b) {
+    const len = a.length;
+    if (len !== b.length) {
+        return false;
     }
-    else {
-        if (meta.isToday) {
-            classNames.push('fc-slot-today');
-            classNames.push(theme.getClass('today'));
-        }
-        if (meta.isPast) {
-            classNames.push('fc-slot-past');
-        }
-        if (meta.isFuture) {
-            classNames.push('fc-slot-future');
+    for (let i = 0; i < len; i++) {
+        if (Math.round(a[i]) !== Math.round(b[i])) {
+            return false;
         }
     }
-    return classNames;
+    return true;
 }
 
-const DAY_FORMAT = createFormatter({ year: 'numeric', month: 'long', day: 'numeric' });
-const WEEK_FORMAT = createFormatter({ week: 'long' });
-function buildNavLinkAttrs(context, dateMarker, viewType = 'day', isTabbable = true) {
-    const { dateEnv, options, calendarApi } = context;
-    let dateStr = dateEnv.format(dateMarker, viewType === 'week' ? WEEK_FORMAT : DAY_FORMAT);
-    if (options.navLinks) {
-        let zonedDate = dateEnv.toDate(dateMarker);
-        const handleInteraction = (ev) => {
-            let customAction = viewType === 'day' ? options.navLinkDayClick :
-                viewType === 'week' ? options.navLinkWeekClick : null;
-            if (typeof customAction === 'function') {
-                customAction.call(calendarApi, dateEnv.toDate(dateMarker), ev);
-            }
-            else {
-                if (typeof customAction === 'string') {
-                    viewType = customAction;
-                }
-                calendarApi.zoomTo(dateMarker, viewType);
-            }
-        };
-        return Object.assign({ title: formatWithOrdinals(options.navLinkHint, [dateStr, zonedDate], dateStr), 'data-navlink': '' }, (isTabbable
-            ? createAriaClickAttrs(handleInteraction)
-            : { onClick: handleInteraction }));
+/* eslint max-classes-per-file: "off" */
+/*
+An object for getting/setting scroll-related information for an element.
+Internally, this is done very differently for window versus DOM element,
+so this object serves as a common interface.
+*/
+class ScrollController {
+    getMaxScrollTop() {
+        return this.getScrollHeight() - this.getClientHeight();
     }
-    return { 'aria-label': dateStr };
-}
-
-let _isRtlScrollbarOnLeft = null;
-function getIsRtlScrollbarOnLeft() {
-    if (_isRtlScrollbarOnLeft === null) {
-        _isRtlScrollbarOnLeft = computeIsRtlScrollbarOnLeft();
+    getMaxScrollLeft() {
+        return this.getScrollWidth() - this.getClientWidth();
     }
-    return _isRtlScrollbarOnLeft;
-}
-function computeIsRtlScrollbarOnLeft() {
-    let outerEl = document.createElement('div');
-    applyStyle(outerEl, {
-        position: 'absolute',
-        top: -1000,
-        left: 0,
-        border: 0,
-        padding: 0,
-        overflow: 'scroll',
-        direction: 'rtl',
-    });
-    outerEl.innerHTML = '<div></div>';
-    document.body.appendChild(outerEl);
-    let innerEl = outerEl.firstChild;
-    let res = innerEl.getBoundingClientRect().left > outerEl.getBoundingClientRect().left;
-    removeElement(outerEl);
-    return res;
-}
-
-let _scrollbarWidths;
-function getScrollbarWidths() {
-    if (!_scrollbarWidths) {
-        _scrollbarWidths = computeScrollbarWidths();
+    canScrollVertically() {
+        return this.getMaxScrollTop() > 0;
     }
-    return _scrollbarWidths;
-}
-function computeScrollbarWidths() {
-    let el = document.createElement('div');
-    el.style.overflow = 'scroll';
-    el.style.position = 'absolute';
-    el.style.top = '-9999px';
-    el.style.left = '-9999px';
-    document.body.appendChild(el);
-    let res = computeScrollbarWidthsForEl(el);
-    document.body.removeChild(el);
-    return res;
-}
-// WARNING: will include border
-function computeScrollbarWidthsForEl(el) {
-    return {
-        x: el.offsetHeight - el.clientHeight,
-        y: el.offsetWidth - el.clientWidth,
-    };
-}
-
-function computeEdges(el, getPadding = false) {
-    let computedStyle = window.getComputedStyle(el);
-    let borderLeft = parseInt(computedStyle.borderLeftWidth, 10) || 0;
-    let borderRight = parseInt(computedStyle.borderRightWidth, 10) || 0;
-    let borderTop = parseInt(computedStyle.borderTopWidth, 10) || 0;
-    let borderBottom = parseInt(computedStyle.borderBottomWidth, 10) || 0;
-    let badScrollbarWidths = computeScrollbarWidthsForEl(el); // includes border!
-    let scrollbarLeftRight = badScrollbarWidths.y - borderLeft - borderRight;
-    let scrollbarBottom = badScrollbarWidths.x - borderTop - borderBottom;
-    let res = {
-        borderLeft,
-        borderRight,
-        borderTop,
-        borderBottom,
-        scrollbarBottom,
-        scrollbarLeft: 0,
-        scrollbarRight: 0,
-    };
-    if (getIsRtlScrollbarOnLeft() && computedStyle.direction === 'rtl') { // is the scrollbar on the left side?
-        res.scrollbarLeft = scrollbarLeftRight;
+    canScrollHorizontally() {
+        return this.getMaxScrollLeft() > 0;
     }
-    else {
-        res.scrollbarRight = scrollbarLeftRight;
+    canScrollUp() {
+        return this.getScrollTop() > 0;
     }
-    if (getPadding) {
-        res.paddingLeft = parseInt(computedStyle.paddingLeft, 10) || 0;
-        res.paddingRight = parseInt(computedStyle.paddingRight, 10) || 0;
-        res.paddingTop = parseInt(computedStyle.paddingTop, 10) || 0;
-        res.paddingBottom = parseInt(computedStyle.paddingBottom, 10) || 0;
+    canScrollDown() {
+        return this.getScrollTop() < this.getMaxScrollTop();
     }
-    return res;
-}
-function computeInnerRect(el, goWithinPadding = false, doFromWindowViewport) {
-    let outerRect = doFromWindowViewport ? el.getBoundingClientRect() : computeRect(el);
-    let edges = computeEdges(el, goWithinPadding);
-    let res = {
-        left: outerRect.left + edges.borderLeft + edges.scrollbarLeft,
-        right: outerRect.right - edges.borderRight - edges.scrollbarRight,
-        top: outerRect.top + edges.borderTop,
-        bottom: outerRect.bottom - edges.borderBottom - edges.scrollbarBottom,
-    };
-    if (goWithinPadding) {
-        res.left += edges.paddingLeft;
-        res.right -= edges.paddingRight;
-        res.top += edges.paddingTop;
-        res.bottom -= edges.paddingBottom;
+    canScrollLeft() {
+        return this.getScrollLeft() > 0;
+    }
+    canScrollRight() {
+        return this.getScrollLeft() < this.getMaxScrollLeft();
     }
-    return res;
-}
-function computeRect(el) {
-    let rect = el.getBoundingClientRect();
-    return {
-        left: rect.left + window.scrollX,
-        top: rect.top + window.scrollY,
-        right: rect.right + window.scrollX,
-        bottom: rect.bottom + window.scrollY,
-    };
 }
-function computeClippedClientRect(el) {
-    let clippingParents = getClippingParents(el);
-    let rect = el.getBoundingClientRect();
-    for (let clippingParent of clippingParents) {
-        let intersection = intersectRects(rect, clippingParent.getBoundingClientRect());
-        if (intersection) {
-            rect = intersection;
-        }
-        else {
-            return null;
-        }
+class ElementScrollController extends ScrollController {
+    constructor(el) {
+        super();
+        this.el = el;
+    }
+    getScrollTop() {
+        return this.el.scrollTop;
+    }
+    getScrollLeft() {
+        return this.el.scrollLeft;
+    }
+    setScrollTop(top) {
+        this.el.scrollTop = top;
+    }
+    setScrollLeft(left) {
+        this.el.scrollLeft = left;
+    }
+    getScrollWidth() {
+        return this.el.scrollWidth;
+    }
+    getScrollHeight() {
+        return this.el.scrollHeight;
+    }
+    getClientHeight() {
+        return this.el.clientHeight;
+    }
+    getClientWidth() {
+        return this.el.clientWidth;
     }
-    return rect;
 }
-// does not return window
-function getClippingParents(el) {
-    let parents = [];
-    while (el instanceof HTMLElement) { // will stop when gets to document or null
-        let computedStyle = window.getComputedStyle(el);
-        if (computedStyle.position === 'fixed') {
-            break;
-        }
-        if ((/(auto|scroll)/).test(computedStyle.overflow + computedStyle.overflowY + computedStyle.overflowX)) {
-            parents.push(el);
-        }
-        el = el.parentNode;
+class WindowScrollController extends ScrollController {
+    getScrollTop() {
+        return window.scrollY;
+    }
+    getScrollLeft() {
+        return window.scrollX;
+    }
+    setScrollTop(n) {
+        window.scroll(window.scrollX, n);
+    }
+    setScrollLeft(n) {
+        window.scroll(n, window.scrollY);
+    }
+    getScrollWidth() {
+        return document.documentElement.scrollWidth;
+    }
+    getScrollHeight() {
+        return document.documentElement.scrollHeight;
+    }
+    getClientHeight() {
+        return document.documentElement.clientHeight;
+    }
+    getClientWidth() {
+        return document.documentElement.clientWidth;
     }
-    return parents;
 }
 
 /*
-Records offset information for a set of elements, relative to an origin element.
-Can record the left/right OR the top/bottom OR both.
-Provides methods for querying the cache by position.
+an INTERACTABLE date component
+
+PURPOSES:
+- hook up to fg, fill, and mirror renderers
+- interface for dragging and hits
 */
-class PositionCache {
-    constructor(originEl, els, isHorizontal, isVertical) {
-        this.els = els;
-        let originClientRect = this.originClientRect = originEl.getBoundingClientRect(); // relative to viewport top-left
-        if (isHorizontal) {
-            this.buildElHorizontals(originClientRect.left);
-        }
-        if (isVertical) {
-            this.buildElVerticals(originClientRect.top);
-        }
-    }
-    // Populates the left/right internal coordinate arrays
-    buildElHorizontals(originClientLeft) {
-        let lefts = [];
-        let rights = [];
-        for (let el of this.els) {
-            let rect = el.getBoundingClientRect();
-            lefts.push(rect.left - originClientLeft);
-            rights.push(rect.right - originClientLeft);
-        }
-        this.lefts = lefts;
-        this.rights = rights;
-    }
-    // Populates the top/bottom internal coordinate arrays
-    buildElVerticals(originClientTop) {
-        let tops = [];
-        let bottoms = [];
-        for (let el of this.els) {
-            let rect = el.getBoundingClientRect();
-            tops.push(rect.top - originClientTop);
-            bottoms.push(rect.bottom - originClientTop);
-        }
-        this.tops = tops;
-        this.bottoms = bottoms;
-    }
-    // Given a left offset (from document left), returns the index of the el that it horizontally intersects.
-    // If no intersection is made, returns undefined.
-    leftToIndex(leftPosition) {
-        let { lefts, rights } = this;
-        let len = lefts.length;
-        let i;
-        for (i = 0; i < len; i += 1) {
-            if (leftPosition >= lefts[i] && leftPosition < rights[i]) {
-                return i;
-            }
-        }
-        return undefined; // TODO: better
-    }
-    // Given a top offset (from document top), returns the index of the el that it vertically intersects.
-    // If no intersection is made, returns undefined.
-    topToIndex(topPosition) {
-        let { tops, bottoms } = this;
-        let len = tops.length;
-        let i;
-        for (i = 0; i < len; i += 1) {
-            if (topPosition >= tops[i] && topPosition < bottoms[i]) {
-                return i;
-            }
-        }
-        return undefined; // TODO: better
-    }
-    // Gets the width of the element at the given index
-    getWidth(leftIndex) {
-        return this.rights[leftIndex] - this.lefts[leftIndex];
-    }
-    // Gets the height of the element at the given index
-    getHeight(topIndex) {
-        return this.bottoms[topIndex] - this.tops[topIndex];
-    }
-    similarTo(otherCache) {
-        return similarNumArrays(this.tops || [], otherCache.tops || []) &&
-            similarNumArrays(this.bottoms || [], otherCache.bottoms || []) &&
-            similarNumArrays(this.lefts || [], otherCache.lefts || []) &&
-            similarNumArrays(this.rights || [], otherCache.rights || []);
-    }
-}
-function similarNumArrays(a, b) {
-    const len = a.length;
-    if (len !== b.length) {
-        return false;
-    }
-    for (let i = 0; i < len; i++) {
-        if (Math.round(a[i]) !== Math.round(b[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/* eslint max-classes-per-file: "off" */
-/*
-An object for getting/setting scroll-related information for an element.
-Internally, this is done very differently for window versus DOM element,
-so this object serves as a common interface.
-*/
-class ScrollController {
-    getMaxScrollTop() {
-        return this.getScrollHeight() - this.getClientHeight();
-    }
-    getMaxScrollLeft() {
-        return this.getScrollWidth() - this.getClientWidth();
-    }
-    canScrollVertically() {
-        return this.getMaxScrollTop() > 0;
-    }
-    canScrollHorizontally() {
-        return this.getMaxScrollLeft() > 0;
-    }
-    canScrollUp() {
-        return this.getScrollTop() > 0;
-    }
-    canScrollDown() {
-        return this.getScrollTop() < this.getMaxScrollTop();
-    }
-    canScrollLeft() {
-        return this.getScrollLeft() > 0;
-    }
-    canScrollRight() {
-        return this.getScrollLeft() < this.getMaxScrollLeft();
-    }
-}
-class ElementScrollController extends ScrollController {
-    constructor(el) {
-        super();
-        this.el = el;
-    }
-    getScrollTop() {
-        return this.el.scrollTop;
-    }
-    getScrollLeft() {
-        return this.el.scrollLeft;
-    }
-    setScrollTop(top) {
-        this.el.scrollTop = top;
-    }
-    setScrollLeft(left) {
-        this.el.scrollLeft = left;
-    }
-    getScrollWidth() {
-        return this.el.scrollWidth;
-    }
-    getScrollHeight() {
-        return this.el.scrollHeight;
-    }
-    getClientHeight() {
-        return this.el.clientHeight;
-    }
-    getClientWidth() {
-        return this.el.clientWidth;
-    }
-}
-class WindowScrollController extends ScrollController {
-    getScrollTop() {
-        return window.scrollY;
-    }
-    getScrollLeft() {
-        return window.scrollX;
-    }
-    setScrollTop(n) {
-        window.scroll(window.scrollX, n);
-    }
-    setScrollLeft(n) {
-        window.scroll(n, window.scrollY);
-    }
-    getScrollWidth() {
-        return document.documentElement.scrollWidth;
-    }
-    getScrollHeight() {
-        return document.documentElement.scrollHeight;
-    }
-    getClientHeight() {
-        return document.documentElement.clientHeight;
-    }
-    getClientWidth() {
-        return document.documentElement.clientWidth;
-    }
-}
-
-/*
-an INTERACTABLE date component
-
-PURPOSES:
-- hook up to fg, fill, and mirror renderers
-- interface for dragging and hits
-*/
-class DateComponent extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.uid = guid();
+class DateComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.uid = guid();
     }
     // Hit System
     // -----------------------------------------------------------------------------------------------------------------
@@ -5774,440 +5394,603 @@ class NamedTimeZoneImpl {
     }
 }
 
-class SegHierarchy {
-    constructor(getEntryThickness = (entry) => {
-        // if no thickness known, assume 1 (if 0, so small it always fits)
-        return entry.thickness || 1;
-    }) {
-        this.getEntryThickness = getEntryThickness;
-        // settings
-        this.strictOrder = false;
-        this.allowReslicing = false;
-        this.maxCoord = -1; // -1 means no max
-        this.maxStackCnt = -1; // -1 means no max
-        this.levelCoords = []; // ordered
-        this.entriesByLevel = []; // parallel with levelCoords
-        this.stackCnts = {}; // TODO: use better technique!?
-    }
-    addSegs(inputs) {
-        let hiddenEntries = [];
-        for (let input of inputs) {
-            this.insertEntry(input, hiddenEntries);
-        }
-        return hiddenEntries;
-    }
-    insertEntry(entry, hiddenEntries) {
-        let insertion = this.findInsertion(entry);
-        if (this.isInsertionValid(insertion, entry)) {
-            this.insertEntryAt(entry, insertion);
-        }
-        else {
-            this.handleInvalidInsertion(insertion, entry, hiddenEntries);
-        }
-    }
-    isInsertionValid(insertion, entry) {
-        return (this.maxCoord === -1 || insertion.levelCoord + this.getEntryThickness(entry) <= this.maxCoord) &&
-            (this.maxStackCnt === -1 || insertion.stackCnt < this.maxStackCnt);
-    }
-    handleInvalidInsertion(insertion, entry, hiddenEntries) {
-        if (this.allowReslicing && insertion.touchingEntry) {
-            const hiddenEntry = Object.assign(Object.assign({}, entry), { span: intersectSpans(entry.span, insertion.touchingEntry.span) });
-            hiddenEntries.push(hiddenEntry);
-            this.splitEntry(entry, insertion.touchingEntry, hiddenEntries);
-        }
-        else {
-            hiddenEntries.push(entry);
-        }
+const DAY_NUM_FORMAT = createFormatter({ day: 'numeric' });
+class DayCellContainer extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.refineRenderProps = memoizeObjArg(refineRenderProps);
     }
-    /*
-    Does NOT add what hit the `barrier` into hiddenEntries. Should already be done.
-    */
-    splitEntry(entry, barrier, hiddenEntries) {
-        let entrySpan = entry.span;
-        let barrierSpan = barrier.span;
-        if (entrySpan.start < barrierSpan.start) {
-            this.insertEntry({
-                index: entry.index,
-                thickness: entry.thickness,
-                span: { start: entrySpan.start, end: barrierSpan.start },
-            }, hiddenEntries);
-        }
-        if (entrySpan.end > barrierSpan.end) {
-            this.insertEntry({
-                index: entry.index,
-                thickness: entry.thickness,
-                span: { start: barrierSpan.end, end: entrySpan.end },
-            }, hiddenEntries);
-        }
+    render() {
+        let { props, context } = this;
+        let { options } = context;
+        let renderProps = this.refineRenderProps({
+            date: props.date,
+            dateProfile: props.dateProfile,
+            todayRange: props.todayRange,
+            isMonthStart: props.isMonthStart || false,
+            showDayNumber: props.showDayNumber,
+            extraRenderProps: props.extraRenderProps,
+            viewApi: context.viewApi,
+            dateEnv: context.dateEnv,
+            monthStartFormat: options.monthStartFormat,
+        });
+        return (preact.createElement(ContentContainer, Object.assign({}, props /* includes children */, { elClasses: [
+                ...getDayClassNames(renderProps, context.theme),
+                ...(props.elClasses || []),
+            ], elAttrs: Object.assign(Object.assign({}, props.elAttrs), (renderProps.isDisabled ? {} : { 'data-date': formatDayString(props.date) })), renderProps: renderProps, generatorName: "dayCellContent", customGenerator: options.dayCellContent, defaultGenerator: props.defaultGenerator, classNameGenerator: 
+            // don't use custom classNames if disabled
+            renderProps.isDisabled ? undefined : options.dayCellClassNames, didMount: options.dayCellDidMount, willUnmount: options.dayCellWillUnmount })));
     }
-    insertEntryAt(entry, insertion) {
-        let { entriesByLevel, levelCoords } = this;
-        if (insertion.lateral === -1) {
-            // create a new level
-            insertAt(levelCoords, insertion.level, insertion.levelCoord);
-            insertAt(entriesByLevel, insertion.level, [entry]);
-        }
-        else {
-            // insert into existing level
-            insertAt(entriesByLevel[insertion.level], insertion.lateral, entry);
-        }
-        this.stackCnts[buildEntryKey(entry)] = insertion.stackCnt;
-    }
-    /*
-    does not care about limits
-    */
-    findInsertion(newEntry) {
-        let { levelCoords, entriesByLevel, strictOrder, stackCnts } = this;
-        let levelCnt = levelCoords.length;
-        let candidateCoord = 0;
-        let touchingLevel = -1;
-        let touchingLateral = -1;
-        let touchingEntry = null;
-        let stackCnt = 0;
-        for (let trackingLevel = 0; trackingLevel < levelCnt; trackingLevel += 1) {
-            const trackingCoord = levelCoords[trackingLevel];
-            // if the current level is past the placed entry, we have found a good empty space and can stop.
-            // if strictOrder, keep finding more lateral intersections.
-            if (!strictOrder && trackingCoord >= candidateCoord + this.getEntryThickness(newEntry)) {
-                break;
+}
+function hasCustomDayCellContent(options) {
+    return Boolean(options.dayCellContent || hasCustomRenderingHandler('dayCellContent', options));
+}
+function refineRenderProps(raw) {
+    let { date, dateEnv, dateProfile, isMonthStart } = raw;
+    let dayMeta = getDateMeta(date, raw.todayRange, null, dateProfile);
+    let dayNumberText = raw.showDayNumber ? (dateEnv.format(date, isMonthStart ? raw.monthStartFormat : DAY_NUM_FORMAT)) : '';
+    return Object.assign(Object.assign(Object.assign({ date: dateEnv.toDate(date), view: raw.viewApi }, dayMeta), { isMonthStart,
+        dayNumberText }), raw.extraRenderProps);
+}
+
+const PADDING_FROM_VIEWPORT = 10;
+class Popover extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.state = {
+            titleId: getUniqueDomId(),
+        };
+        this.handleRootEl = (el) => {
+            this.rootEl = el;
+            if (this.props.elRef) {
+                setRef(this.props.elRef, el);
             }
-            let trackingEntries = entriesByLevel[trackingLevel];
-            let trackingEntry;
-            let searchRes = binarySearch(trackingEntries, newEntry.span.start, getEntrySpanEnd); // find first entry after newEntry's end
-            let lateralIndex = searchRes[0] + searchRes[1]; // if exact match (which doesn't collide), go to next one
-            while ( // loop through entries that horizontally intersect
-            (trackingEntry = trackingEntries[lateralIndex]) && // but not past the whole entry list
-                trackingEntry.span.start < newEntry.span.end // and not entirely past newEntry
-            ) {
-                let trackingEntryBottom = trackingCoord + this.getEntryThickness(trackingEntry);
-                // intersects into the top of the candidate?
-                if (trackingEntryBottom > candidateCoord) {
-                    candidateCoord = trackingEntryBottom;
-                    touchingEntry = trackingEntry;
-                    touchingLevel = trackingLevel;
-                    touchingLateral = lateralIndex;
-                }
-                // butts up against top of candidate? (will happen if just intersected as well)
-                if (trackingEntryBottom === candidateCoord) {
-                    // accumulate the highest possible stackCnt of the trackingEntries that butt up
-                    stackCnt = Math.max(stackCnt, stackCnts[buildEntryKey(trackingEntry)] + 1);
-                }
-                lateralIndex += 1;
+        };
+        // Triggered when the user clicks *anywhere* in the document, for the autoHide feature
+        this.handleDocumentMouseDown = (ev) => {
+            // only hide the popover if the click happened outside the popover
+            const target = getEventTargetViaRoot(ev);
+            if (!this.rootEl.contains(target)) {
+                this.handleCloseClick();
             }
-        }
-        // the destination level will be after touchingEntry's level. find it
-        let destLevel = 0;
-        if (touchingEntry) {
-            destLevel = touchingLevel + 1;
-            while (destLevel < levelCnt && levelCoords[destLevel] < candidateCoord) {
-                destLevel += 1;
+        };
+        this.handleDocumentKeyDown = (ev) => {
+            if (ev.key === 'Escape') {
+                this.handleCloseClick();
+            }
+        };
+        this.handleCloseClick = () => {
+            let { onClose } = this.props;
+            if (onClose) {
+                onClose();
             }
-        }
-        // if adding to an existing level, find where to insert
-        let destLateral = -1;
-        if (destLevel < levelCnt && levelCoords[destLevel] === candidateCoord) {
-            destLateral = binarySearch(entriesByLevel[destLevel], newEntry.span.end, getEntrySpanEnd)[0];
-        }
-        return {
-            touchingLevel,
-            touchingLateral,
-            touchingEntry,
-            stackCnt,
-            levelCoord: candidateCoord,
-            level: destLevel,
-            lateral: destLateral,
         };
     }
-    // sorted by levelCoord (lowest to highest)
-    toRects() {
-        let { entriesByLevel, levelCoords } = this;
-        let levelCnt = entriesByLevel.length;
-        let rects = [];
-        for (let level = 0; level < levelCnt; level += 1) {
-            let entries = entriesByLevel[level];
-            let levelCoord = levelCoords[level];
-            for (let entry of entries) {
-                rects.push(Object.assign(Object.assign({}, entry), { thickness: this.getEntryThickness(entry), levelCoord }));
+    render() {
+        let { theme, options } = this.context;
+        let { props, state } = this;
+        let classNames = [
+            'fc-popover',
+            theme.getClass('popover'),
+        ].concat(props.extraClassNames || []);
+        return compat.createPortal(preact.createElement("div", Object.assign({}, props.extraAttrs, { id: props.id, className: classNames.join(' '), "aria-labelledby": state.titleId, ref: this.handleRootEl }),
+            preact.createElement("div", { className: 'fc-popover-header ' + theme.getClass('popoverHeader') },
+                preact.createElement("span", { className: "fc-popover-title", id: state.titleId }, props.title),
+                preact.createElement("span", { className: 'fc-popover-close ' + theme.getIconClass('close'), title: options.closeHint, onClick: this.handleCloseClick })),
+            preact.createElement("div", { className: 'fc-popover-body ' + theme.getClass('popoverContent') }, props.children)), props.parentEl);
+    }
+    componentDidMount() {
+        document.addEventListener('mousedown', this.handleDocumentMouseDown);
+        document.addEventListener('keydown', this.handleDocumentKeyDown);
+        this.updateSize();
+    }
+    componentWillUnmount() {
+        document.removeEventListener('mousedown', this.handleDocumentMouseDown);
+        document.removeEventListener('keydown', this.handleDocumentKeyDown);
+    }
+    updateSize() {
+        let { isRtl } = this.context;
+        let { alignmentEl, alignGridTop } = this.props;
+        let { rootEl } = this;
+        let alignmentRect = computeClippedClientRect(alignmentEl);
+        if (alignmentRect) {
+            let popoverDims = rootEl.getBoundingClientRect();
+            if (alignGridTop) {
+                throw new Error('alignGridTop not supported yet');
             }
+            // position relative to viewport
+            let popoverTop = alignGridTop
+                ? elementClosest(alignmentEl, '.fc-scrollgrid').getBoundingClientRect().top // BAD!!!
+                : alignmentRect.top;
+            let popoverLeft = isRtl ? alignmentRect.right - popoverDims.width : alignmentRect.left;
+            // constrain
+            popoverTop = Math.max(popoverTop, PADDING_FROM_VIEWPORT);
+            popoverLeft = Math.min(popoverLeft, document.documentElement.clientWidth - PADDING_FROM_VIEWPORT - popoverDims.width);
+            popoverLeft = Math.max(popoverLeft, PADDING_FROM_VIEWPORT);
+            let origin = rootEl.offsetParent.getBoundingClientRect();
+            applyStyle(rootEl, {
+                top: popoverTop - origin.top,
+                left: popoverLeft - origin.left,
+            });
         }
-        return rects;
     }
 }
-function getEntrySpanEnd(entry) {
-    return entry.span.end;
-}
-function buildEntryKey(entry) {
-    return entry.index + ':' + entry.span.start;
-}
-// returns groups with entries sorted by input order
-function groupIntersectingEntries(entries) {
-    let merges = [];
-    for (let entry of entries) {
-        let filteredMerges = [];
-        let hungryMerge = {
-            span: entry.span,
-            entries: [entry],
-        };
-        for (let merge of merges) {
-            if (intersectSpans(merge.span, hungryMerge.span)) {
-                hungryMerge = {
-                    entries: merge.entries.concat(hungryMerge.entries),
-                    span: joinSpans(merge.span, hungryMerge.span),
-                };
+
+class MorePopover extends DateComponent {
+    constructor() {
+        super(...arguments);
+        this.handleRootEl = (rootEl) => {
+            this.rootEl = rootEl;
+            if (rootEl) {
+                this.context.registerInteractiveComponent(this, {
+                    el: rootEl,
+                    useEventCenter: false,
+                });
             }
             else {
-                filteredMerges.push(merge);
+                this.context.unregisterInteractiveComponent(this);
             }
-        }
-        filteredMerges.push(hungryMerge);
-        merges = filteredMerges;
-    }
-    return merges;
-}
-function joinSpans(span0, span1) {
-    return {
-        start: Math.min(span0.start, span1.start),
-        end: Math.max(span0.end, span1.end),
-    };
-}
-function intersectSpans(span0, span1) {
-    let start = Math.max(span0.start, span1.start);
-    let end = Math.min(span0.end, span1.end);
-    if (start < end) {
-        return { start, end };
+        };
     }
-    return null;
-}
-// general util
-// ---------------------------------------------------------------------------------------------------------------------
-function insertAt(arr, index, item) {
-    arr.splice(index, 0, item);
-}
-function binarySearch(a, searchVal, getItemVal) {
-    let startIndex = 0;
-    let endIndex = a.length; // exclusive
-    if (!endIndex || searchVal < getItemVal(a[startIndex])) { // no items OR before first item
-        return [0, 0];
+    render() {
+        let { options, dateEnv } = this.context;
+        let { props } = this;
+        let { startDate, todayRange, dateProfile } = props;
+        let title = dateEnv.format(startDate, options.dayPopoverFormat);
+        return (preact.createElement(DayCellContainer, { elRef: this.handleRootEl, date: startDate, dateProfile: dateProfile, todayRange: todayRange }, (InnerContent, renderProps, elAttrs) => (preact.createElement(Popover, { elRef: elAttrs.ref, id: props.id, title: title, extraClassNames: ['fc-more-popover'].concat(elAttrs.className || []), extraAttrs: elAttrs /* TODO: make these time-based when not whole-day? */, parentEl: props.parentEl, alignmentEl: props.alignmentEl, alignGridTop: props.alignGridTop, onClose: props.onClose },
+            hasCustomDayCellContent(options) && (preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-more-popover-misc'] })),
+            props.children))));
     }
-    if (searchVal > getItemVal(a[endIndex - 1])) { // after last item
-        return [endIndex, 0];
+    queryHit(positionLeft, positionTop, elWidth, elHeight) {
+        let { rootEl, props } = this;
+        if (positionLeft >= 0 && positionLeft < elWidth &&
+            positionTop >= 0 && positionTop < elHeight) {
+            return {
+                dateProfile: props.dateProfile,
+                dateSpan: Object.assign({ allDay: !props.forceTimed, range: {
+                        start: props.startDate,
+                        end: props.endDate,
+                    } }, props.extraDateSpan),
+                dayEl: rootEl,
+                rect: {
+                    left: 0,
+                    top: 0,
+                    right: elWidth,
+                    bottom: elHeight,
+                },
+                layer: 1, // important when comparing with hits from other components
+            };
+        }
+        return null;
     }
-    while (startIndex < endIndex) {
-        let middleIndex = Math.floor(startIndex + (endIndex - startIndex) / 2);
-        let middleVal = getItemVal(a[middleIndex]);
-        if (searchVal < middleVal) {
-            endIndex = middleIndex;
-        }
-        else if (searchVal > middleVal) {
-            startIndex = middleIndex + 1;
-        }
-        else { // equal!
-            return [middleIndex, 1];
-        }
-    }
-    return [startIndex, 0];
 }
 
-/*
-An abstraction for a dragging interaction originating on an event.
-Does higher-level things than PointerDragger, such as possibly:
-- a "mirror" that moves with the pointer
-- a minimum number of pixels or other criteria for a true drag to begin
-
-subclasses must emit:
-- pointerdown
-- dragstart
-- dragmove
-- pointerup
-- dragend
-*/
-class ElementDragging {
-    constructor(el, selector) {
-        this.emitter = new Emitter();
+class MoreLinkContainer extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.state = {
+            isPopoverOpen: false,
+            popoverId: getUniqueDomId(),
+        };
+        this.handleLinkEl = (linkEl) => {
+            this.linkEl = linkEl;
+            if (this.props.elRef) {
+                setRef(this.props.elRef, linkEl);
+            }
+        };
+        this.handleClick = (ev) => {
+            let { props, context } = this;
+            let { moreLinkClick } = context.options;
+            let date = computeRange(props).start;
+            function buildPublicSeg(seg) {
+                let { def, instance, range } = seg.eventRange;
+                return {
+                    event: new EventImpl(context, def, instance),
+                    start: context.dateEnv.toDate(range.start),
+                    end: context.dateEnv.toDate(range.end),
+                    isStart: seg.isStart,
+                    isEnd: seg.isEnd,
+                };
+            }
+            if (typeof moreLinkClick === 'function') {
+                moreLinkClick = moreLinkClick({
+                    date,
+                    allDay: Boolean(props.allDayDate),
+                    allSegs: props.segs.map(buildPublicSeg),
+                    hiddenSegs: props.hiddenSegs.map(buildPublicSeg),
+                    jsEvent: ev,
+                    view: context.viewApi,
+                });
+            }
+            if (!moreLinkClick || moreLinkClick === 'popover') {
+                this.setState({ isPopoverOpen: true });
+            }
+            else if (typeof moreLinkClick === 'string') { // a view name
+                context.calendarApi.zoomTo(date, moreLinkClick);
+            }
+        };
+        this.handlePopoverClose = () => {
+            this.setState({ isPopoverOpen: false });
+        };
     }
-    destroy() {
+    render() {
+        let { props, state } = this;
+        return (preact.createElement(ViewContextType.Consumer, null, (context) => {
+            let { viewApi, options, calendarApi } = context;
+            let { moreLinkText } = options;
+            let moreCnt = props.hiddenSegs.length;
+            let range = computeRange(props);
+            let text = typeof moreLinkText === 'function' // TODO: eventually use formatWithOrdinals
+                ? moreLinkText.call(calendarApi, moreCnt)
+                : `+${moreCnt} ${moreLinkText}`;
+            let hint = formatWithOrdinals(options.moreLinkHint, [moreCnt], text);
+            let renderProps = {
+                num: moreCnt,
+                shortText: `+${moreCnt}`,
+                text,
+                view: viewApi,
+            };
+            return (preact.createElement(preact.Fragment, null,
+                Boolean(moreCnt) && (preact.createElement(ContentContainer, { elTag: props.elTag || 'a', elRef: this.handleLinkEl, elClasses: [
+                        ...(props.elClasses || []),
+                        'fc-more-link',
+                    ], elStyle: props.elStyle, elAttrs: Object.assign(Object.assign(Object.assign({}, props.elAttrs), createAriaClickAttrs(this.handleClick)), { title: hint, 'aria-expanded': state.isPopoverOpen, 'aria-controls': state.isPopoverOpen ? state.popoverId : '' }), renderProps: renderProps, generatorName: "moreLinkContent", customGenerator: options.moreLinkContent, defaultGenerator: props.defaultGenerator || renderMoreLinkInner, classNameGenerator: options.moreLinkClassNames, didMount: options.moreLinkDidMount, willUnmount: options.moreLinkWillUnmount }, props.children)),
+                state.isPopoverOpen && (preact.createElement(MorePopover, { id: state.popoverId, startDate: range.start, endDate: range.end, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: props.extraDateSpan, parentEl: this.parentEl, alignmentEl: props.alignmentElRef ?
+                        props.alignmentElRef.current :
+                        this.linkEl, alignGridTop: props.alignGridTop, forceTimed: props.forceTimed, onClose: this.handlePopoverClose }, props.popoverContent()))));
+        }));
     }
-    setMirrorIsVisible(bool) {
-        // optional if subclass doesn't want to support a mirror
+    componentDidMount() {
+        this.updateParentEl();
     }
-    setMirrorNeedsRevert(bool) {
-        // optional if subclass doesn't want to support a mirror
+    componentDidUpdate() {
+        this.updateParentEl();
     }
-    setAutoScrollEnabled(bool) {
-        // optional
+    updateParentEl() {
+        if (this.linkEl) {
+            this.parentEl = elementClosest(this.linkEl, '.fc-view-harness'); // HACK. reconsider
+        }
     }
 }
-
-// TODO: get rid of this in favor of options system,
-// tho it's really easy to access this globally rather than pass thru options.
-const config = {};
-
-/*
-Information about what will happen when an external element is dragged-and-dropped
-onto a calendar. Contains information for creating an event.
-*/
-const DRAG_META_REFINERS = {
-    startTime: createDuration,
-    duration: createDuration,
-    create: Boolean,
-    sourceId: String,
-};
-function parseDragMeta(raw) {
-    let { refined, extra } = refineProps(raw, DRAG_META_REFINERS);
+function renderMoreLinkInner(props) {
+    return props.text;
+}
+function computeRange(props) {
+    if (props.allDayDate) {
+        return {
+            start: props.allDayDate,
+            end: addDays(props.allDayDate, 1),
+        };
+    }
     return {
-        startTime: refined.startTime || null,
-        duration: refined.duration || null,
-        create: refined.create != null ? refined.create : true,
-        sourceId: refined.sourceId,
-        leftoverProps: extra,
+        start: computeEarliestSegStart(props.hiddenSegs),
+        end: computeLatestSegEnd(props.hiddenSegs),
     };
 }
-
-// Computes a default column header formatting string if `colFormat` is not explicitly defined
-function computeFallbackHeaderFormat(datesRepDistinctDays, dayCnt) {
-    // if more than one week row, or if there are a lot of columns with not much space,
-    // put just the day numbers will be in each cell
-    if (!datesRepDistinctDays || dayCnt > 10) {
-        return createFormatter({ weekday: 'short' }); // "Sat"
-    }
-    if (dayCnt > 1) {
-        return createFormatter({ weekday: 'short', month: 'numeric', day: 'numeric', omitCommas: true }); // "Sat 11/12"
-    }
-    return createFormatter({ weekday: 'long' }); // "Saturday"
+function computeEarliestSegStart(segs) {
+    return segs.reduce(pickEarliestStart).eventRange.range.start;
 }
-
-const CLASS_NAME = 'fc-col-header-cell'; // do the cushion too? no
-function renderInner$1(renderProps) {
-    return renderProps.text;
+function pickEarliestStart(seg0, seg1) {
+    return seg0.eventRange.range.start < seg1.eventRange.range.start ? seg0 : seg1;
 }
-
-// BAD name for this class now. used in the Header
-class TableDateCell extends BaseComponent {
-    render() {
-        let { dateEnv, options, theme, viewApi } = this.context;
-        let { props } = this;
-        let { date, dateProfile } = props;
-        let dayMeta = getDateMeta(date, props.todayRange, null, dateProfile);
-        let classNames = [CLASS_NAME].concat(getDayClassNames(dayMeta, theme));
-        let text = dateEnv.format(date, props.dayHeaderFormat);
-        // if colCnt is 1, we are already in a day-view and don't need a navlink
-        let navLinkAttrs = (!dayMeta.isDisabled && props.colCnt > 1)
-            ? buildNavLinkAttrs(this.context, date)
-            : {};
-        let renderProps = Object.assign(Object.assign(Object.assign({ date: dateEnv.toDate(date), view: viewApi }, props.extraRenderProps), { text }), dayMeta);
-        return (preact.createElement(ContentContainer, { elTag: "th", elClasses: classNames, elAttrs: Object.assign({ role: 'columnheader', colSpan: props.colSpan, 'data-date': !dayMeta.isDisabled ? formatDayString(date) : undefined }, props.extraDataAttrs), renderProps: renderProps, generatorName: "dayHeaderContent", customGenerator: options.dayHeaderContent, defaultGenerator: renderInner$1, classNameGenerator: options.dayHeaderClassNames, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, (InnerContainer) => (preact.createElement("div", { className: "fc-scrollgrid-sync-inner" }, !dayMeta.isDisabled && (preact.createElement(InnerContainer, { elTag: "a", elAttrs: navLinkAttrs, elClasses: [
-                'fc-col-header-cell-cushion',
-                props.isSticky && 'fc-sticky',
-            ] }))))));
-    }
+function computeLatestSegEnd(segs) {
+    return segs.reduce(pickLatestEnd).eventRange.range.end;
 }
-
-const WEEKDAY_FORMAT = createFormatter({ weekday: 'long' });
-class TableDowCell extends BaseComponent {
-    render() {
-        let { props } = this;
-        let { dateEnv, theme, viewApi, options } = this.context;
-        let date = addDays(new Date(259200000), props.dow); // start with Sun, 04 Jan 1970 00:00:00 GMT
-        let dateMeta = {
-            dow: props.dow,
-            isDisabled: false,
-            isFuture: false,
-            isPast: false,
-            isToday: false,
-            isOther: false,
-        };
-        let text = dateEnv.format(date, props.dayHeaderFormat);
-        let renderProps = Object.assign(Object.assign(Object.assign(Object.assign({ // TODO: make this public?
-            date }, dateMeta), { view: viewApi }), props.extraRenderProps), { text });
-        return (preact.createElement(ContentContainer, { elTag: "th", elClasses: [
-                CLASS_NAME,
-                ...getDayClassNames(dateMeta, theme),
-                ...(props.extraClassNames || []),
-            ], elAttrs: Object.assign({ role: 'columnheader', colSpan: props.colSpan }, props.extraDataAttrs), renderProps: renderProps, generatorName: "dayHeaderContent", customGenerator: options.dayHeaderContent, defaultGenerator: renderInner$1, classNameGenerator: options.dayHeaderClassNames, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, (InnerContent) => (preact.createElement("div", { className: "fc-scrollgrid-sync-inner" },
-            preact.createElement(InnerContent, { elTag: "a", elClasses: [
-                    'fc-col-header-cell-cushion',
-                    props.isSticky && 'fc-sticky',
-                ], elAttrs: {
-                    'aria-label': dateEnv.format(date, WEEKDAY_FORMAT),
-                } })))));
-    }
+function pickLatestEnd(seg0, seg1) {
+    return seg0.eventRange.range.end > seg1.eventRange.range.end ? seg0 : seg1;
 }
 
-class NowTimer extends preact.Component {
-    constructor(props, context) {
-        super(props, context);
-        this.initialNowDate = getNow(context.options.now, context.dateEnv);
-        this.initialNowQueriedMs = new Date().valueOf();
-        this.state = this.computeTiming().currentState;
-    }
-    render() {
-        let { props, state } = this;
-        return props.children(state.nowDate, state.todayRange);
-    }
-    componentDidMount() {
-        this.setTimeout();
+class SegHierarchy {
+    constructor(getEntryThickness = (entry) => {
+        // if no thickness known, assume 1 (if 0, so small it always fits)
+        return entry.thickness;
+    }) {
+        this.getEntryThickness = getEntryThickness;
+        // settings
+        this.strictOrder = false;
+        this.allowReslicing = false;
+        this.maxCoord = -1; // -1 means no max
+        this.maxStackCnt = -1; // -1 means no max
+        this.levelCoords = []; // ordered
+        this.entriesByLevel = []; // parallel with levelCoords
+        this.stackCnts = {}; // TODO: use better technique!?
     }
-    componentDidUpdate(prevProps) {
-        if (prevProps.unit !== this.props.unit) {
-            this.clearTimeout();
-            this.setTimeout();
+    addSegs(inputs) {
+        let hiddenEntries = [];
+        for (let input of inputs) {
+            this.insertEntry(input, hiddenEntries);
         }
+        return hiddenEntries;
     }
-    componentWillUnmount() {
-        this.clearTimeout();
-    }
-    computeTiming() {
-        let { props, context } = this;
-        let unroundedNow = addMs(this.initialNowDate, new Date().valueOf() - this.initialNowQueriedMs);
-        let currentUnitStart = context.dateEnv.startOf(unroundedNow, props.unit);
-        let nextUnitStart = context.dateEnv.add(currentUnitStart, createDuration(1, props.unit));
-        let waitMs = nextUnitStart.valueOf() - unroundedNow.valueOf();
-        // there is a max setTimeout ms value (https://stackoverflow.com/a/3468650/96342)
-        // ensure no longer than a day
-        waitMs = Math.min(1000 * 60 * 60 * 24, waitMs);
-        return {
-            currentState: { nowDate: currentUnitStart, todayRange: buildDayRange(currentUnitStart) },
-            nextState: { nowDate: nextUnitStart, todayRange: buildDayRange(nextUnitStart) },
-            waitMs,
-        };
+    insertEntry(entry, hiddenEntries) {
+        let entryThickness = this.getEntryThickness(entry);
+        if (entryThickness == null) {
+            hiddenEntries.push(entry);
+        }
+        else {
+            let insertion = this.findInsertion(entry, entryThickness);
+            if (this.isInsertionValid(insertion, entry, entryThickness)) {
+                this.insertEntryAt(entry, insertion);
+            }
+            else {
+                this.handleInvalidInsertion(insertion, entry, hiddenEntries);
+            }
+        }
     }
-    setTimeout() {
-        let { nextState, waitMs } = this.computeTiming();
-        this.timeoutId = setTimeout(() => {
-            this.setState(nextState, () => {
-                this.setTimeout();
-            });
-        }, waitMs);
+    isInsertionValid(insertion, entry, entryThickness) {
+        return (this.maxCoord === -1 || insertion.levelCoord + entryThickness <= this.maxCoord) &&
+            (this.maxStackCnt === -1 || insertion.stackCnt < this.maxStackCnt);
     }
-    clearTimeout() {
-        if (this.timeoutId) {
-            clearTimeout(this.timeoutId);
+    handleInvalidInsertion(insertion, entry, hiddenEntries) {
+        if (this.allowReslicing && insertion.touchingEntry) {
+            const hiddenEntry = Object.assign(Object.assign({}, entry), { span: intersectSpans(entry.span, insertion.touchingEntry.span) });
+            hiddenEntries.push(hiddenEntry);
+            this.splitEntry(entry, insertion.touchingEntry, hiddenEntries);
+        }
+        else {
+            hiddenEntries.push(entry);
         }
     }
-}
-NowTimer.contextType = ViewContextType;
-function buildDayRange(date) {
-    let start = startOfDay(date);
-    let end = addDays(start, 1);
-    return { start, end };
-}
-
-class DayHeader extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.createDayHeaderFormatter = memoize(createDayHeaderFormatter);
-    }
-    render() {
-        let { context } = this;
-        let { dates, dateProfile, datesRepDistinctDays, renderIntro } = this.props;
-        let dayHeaderFormat = this.createDayHeaderFormatter(context.options.dayHeaderFormat, datesRepDistinctDays, dates.length);
-        return (preact.createElement(NowTimer, { unit: "day" }, (nowDate, todayRange) => (preact.createElement("tr", { role: "row" },
-            renderIntro && renderIntro('day'),
-            dates.map((date) => (datesRepDistinctDays ? (preact.createElement(TableDateCell, { key: date.toISOString(), date: date, dateProfile: dateProfile, todayRange: todayRange, colCnt: dates.length, dayHeaderFormat: dayHeaderFormat })) : (preact.createElement(TableDowCell, { key: date.getUTCDay(), dow: date.getUTCDay(), dayHeaderFormat: dayHeaderFormat }))))))));
+    /*
+    Does NOT add what hit the `barrier` into hiddenEntries. Should already be done.
+    */
+    splitEntry(entry, barrier, hiddenEntries) {
+        let entrySpan = entry.span;
+        let barrierSpan = barrier.span;
+        if (entrySpan.start < barrierSpan.start) {
+            this.insertEntry({
+                index: entry.index,
+                seg: entry.seg,
+                thickness: entry.thickness,
+                span: { start: entrySpan.start, end: barrierSpan.start },
+            }, hiddenEntries);
+        }
+        if (entrySpan.end > barrierSpan.end) {
+            this.insertEntry({
+                index: entry.index,
+                seg: entry.seg,
+                thickness: entry.thickness,
+                span: { start: barrierSpan.end, end: entrySpan.end },
+            }, hiddenEntries);
+        }
+    }
+    insertEntryAt(entry, insertion) {
+        let { entriesByLevel, levelCoords } = this;
+        if (insertion.lateral === -1) {
+            // create a new level
+            insertAt(levelCoords, insertion.level, insertion.levelCoord);
+            insertAt(entriesByLevel, insertion.level, [entry]);
+        }
+        else {
+            // insert into existing level
+            insertAt(entriesByLevel[insertion.level], insertion.lateral, entry);
+        }
+        this.stackCnts[buildEntryKey(entry)] = insertion.stackCnt;
+    }
+    /*
+    does not care about limits
+    */
+    findInsertion(newEntry, newEntryThickness) {
+        let { levelCoords, entriesByLevel, strictOrder, stackCnts } = this;
+        let levelCnt = levelCoords.length;
+        let candidateCoord = 0;
+        let touchingLevel = -1;
+        let touchingLateral = -1;
+        let touchingEntry = null;
+        let stackCnt = 0;
+        for (let trackingLevel = 0; trackingLevel < levelCnt; trackingLevel += 1) {
+            const trackingCoord = levelCoords[trackingLevel];
+            // if the current level is past the placed entry, we have found a good empty space and can stop.
+            // if strictOrder, keep finding more lateral intersections.
+            if (!strictOrder && trackingCoord >= candidateCoord + newEntryThickness) {
+                break;
+            }
+            let trackingEntries = entriesByLevel[trackingLevel];
+            let trackingEntry;
+            let searchRes = binarySearch(trackingEntries, newEntry.span.start, getEntrySpanEnd); // find first entry after newEntry's end
+            let lateralIndex = searchRes[0] + searchRes[1]; // if exact match (which doesn't collide), go to next one
+            while ( // loop through entries that horizontally intersect
+            (trackingEntry = trackingEntries[lateralIndex]) && // but not past the whole entry list
+                trackingEntry.span.start < newEntry.span.end // and not entirely past newEntry
+            ) {
+                let trackingEntryBottom = trackingCoord + this.getEntryThickness(trackingEntry);
+                // intersects into the top of the candidate?
+                if (trackingEntryBottom > candidateCoord) {
+                    candidateCoord = trackingEntryBottom;
+                    touchingEntry = trackingEntry;
+                    touchingLevel = trackingLevel;
+                    touchingLateral = lateralIndex;
+                }
+                // butts up against top of candidate? (will happen if just intersected as well)
+                if (trackingEntryBottom === candidateCoord) {
+                    // accumulate the highest possible stackCnt of the trackingEntries that butt up
+                    stackCnt = Math.max(stackCnt, stackCnts[buildEntryKey(trackingEntry)] + 1);
+                }
+                lateralIndex += 1;
+            }
+        }
+        // the destination level will be after touchingEntry's level. find it
+        let destLevel = 0;
+        if (touchingEntry) {
+            destLevel = touchingLevel + 1;
+            while (destLevel < levelCnt && levelCoords[destLevel] < candidateCoord) {
+                destLevel += 1;
+            }
+        }
+        // if adding to an existing level, find where to insert
+        let destLateral = -1;
+        if (destLevel < levelCnt && levelCoords[destLevel] === candidateCoord) {
+            destLateral = binarySearch(entriesByLevel[destLevel], newEntry.span.end, getEntrySpanEnd)[0];
+        }
+        return {
+            touchingLevel,
+            touchingLateral,
+            touchingEntry,
+            stackCnt,
+            levelCoord: candidateCoord,
+            level: destLevel,
+            lateral: destLateral,
+        };
+    }
+    // sorted by levelCoord (lowest to highest)
+    toRects() {
+        let { entriesByLevel, levelCoords } = this;
+        let levelCnt = entriesByLevel.length;
+        let rects = [];
+        for (let level = 0; level < levelCnt; level += 1) {
+            let entries = entriesByLevel[level];
+            let levelCoord = levelCoords[level];
+            for (let entry of entries) {
+                rects.push(Object.assign(Object.assign({}, entry), { thickness: this.getEntryThickness(entry), levelCoord }));
+            }
+        }
+        return rects;
+    }
+}
+function getEntrySpanEnd(entry) {
+    return entry.span.end;
+}
+/*
+Generates a unique ID whose lifespan is a single run of SegHierarchy, so can be really specific
+without fear of accidentally busting the cache on subsequent rerenders
+*/
+function buildEntryKey(entry) {
+    return entry.index + ':' + entry.span.start;
+}
+/*
+returns groups with entries sorted by input order
+*/
+function groupIntersectingEntries(entries) {
+    let merges = [];
+    for (let entry of entries) {
+        let filteredMerges = [];
+        let hungryMerge = {
+            span: entry.span,
+            entries: [entry],
+        };
+        for (let merge of merges) {
+            if (intersectSpans(merge.span, hungryMerge.span)) {
+                hungryMerge = {
+                    span: joinSpans(merge.span, hungryMerge.span),
+                    entries: merge.entries.concat(hungryMerge.entries), // keep preexisting merge's items first. maintains order
+                };
+            }
+            else {
+                filteredMerges.push(merge);
+            }
+        }
+        filteredMerges.push(hungryMerge);
+        merges = filteredMerges;
+    }
+    return merges.map((merge) => {
+        const segs = merge.entries.map(extractEntrySeg);
+        return {
+            key: buildIsoString(computeEarliestSegStart(segs)),
+            span: merge.span,
+            segs,
+        };
+    });
+}
+function extractEntrySeg(entry) {
+    return entry.seg;
+}
+function joinSpans(span0, span1) {
+    return {
+        start: Math.min(span0.start, span1.start),
+        end: Math.max(span0.end, span1.end),
+    };
+}
+function intersectSpans(span0, span1) {
+    let start = Math.max(span0.start, span1.start);
+    let end = Math.min(span0.end, span1.end);
+    if (start < end) {
+        return { start, end };
+    }
+    return null;
+}
+// general util
+// ---------------------------------------------------------------------------------------------------------------------
+function insertAt(arr, index, item) {
+    arr.splice(index, 0, item);
+}
+function binarySearch(a, searchVal, getItemVal) {
+    let startIndex = 0;
+    let endIndex = a.length; // exclusive
+    if (!endIndex || searchVal < getItemVal(a[startIndex])) { // no items OR before first item
+        return [0, 0];
+    }
+    if (searchVal > getItemVal(a[endIndex - 1])) { // after last item
+        return [endIndex, 0];
+    }
+    while (startIndex < endIndex) {
+        let middleIndex = Math.floor(startIndex + (endIndex - startIndex) / 2);
+        let middleVal = getItemVal(a[middleIndex]);
+        if (searchVal < middleVal) {
+            endIndex = middleIndex;
+        }
+        else if (searchVal > middleVal) {
+            startIndex = middleIndex + 1;
+        }
+        else { // equal!
+            return [middleIndex, 1];
+        }
+    }
+    return [startIndex, 0];
+}
+
+/*
+An abstraction for a dragging interaction originating on an event.
+Does higher-level things than PointerDragger, such as possibly:
+- a "mirror" that moves with the pointer
+- a minimum number of pixels or other criteria for a true drag to begin
+
+subclasses must emit:
+- pointerdown
+- dragstart
+- dragmove
+- pointerup
+- dragend
+*/
+class ElementDragging {
+    constructor(el, selector) {
+        this.emitter = new Emitter();
+    }
+    destroy() {
+    }
+    setMirrorIsVisible(bool) {
+        // optional if subclass doesn't want to support a mirror
+    }
+    setMirrorNeedsRevert(bool) {
+        // optional if subclass doesn't want to support a mirror
+    }
+    setAutoScrollEnabled(bool) {
+        // optional
     }
 }
-function createDayHeaderFormatter(explicitFormat, datesRepDistinctDays, dateCnt) {
-    return explicitFormat || computeFallbackHeaderFormat(datesRepDistinctDays, dateCnt);
+
+// TODO: get rid of this in favor of options system,
+// tho it's really easy to access this globally rather than pass thru options.
+const config = {};
+
+/*
+Information about what will happen when an external element is dragged-and-dropped
+onto a calendar. Contains information for creating an event.
+*/
+const DRAG_META_REFINERS = {
+    startTime: createDuration,
+    duration: createDuration,
+    create: Boolean,
+    sourceId: String,
+};
+function parseDragMeta(raw) {
+    let { refined, extra } = refineProps(raw, DRAG_META_REFINERS);
+    return {
+        startTime: refined.startTime || null,
+        duration: refined.duration || null,
+        create: refined.create != null ? refined.create : true,
+        sourceId: refined.sourceId,
+        leftoverProps: extra,
+    };
 }
 
 class DaySeriesModel {
@@ -6291,7 +6074,7 @@ class DayTableModel {
         this.rowCnt = rowCnt;
         this.colCnt = daysPerRow;
         this.daySeries = daySeries;
-        this.cells = this.buildCells();
+        this.cellRows = this.buildCells();
         this.headerDates = this.buildHeaderDates();
     }
     buildCells() {
@@ -6315,7 +6098,7 @@ class DayTableModel {
     buildHeaderDates() {
         let dates = [];
         for (let col = 0; col < this.colCnt; col += 1) {
-            dates.push(this.cells[0][col].date);
+            dates.push(this.cellRows[0][col].date);
         }
         return dates;
     }
@@ -6343,18 +6126,272 @@ class DayTableModel {
     }
 }
 
-class Slicer {
-    constructor() {
-        this.sliceBusinessHours = memoize(this._sliceBusinessHours);
-        this.sliceDateSelection = memoize(this._sliceDateSpan);
-        this.sliceEventStore = memoize(this._sliceEventStore);
-        this.sliceEventDrag = memoize(this._sliceInteraction);
-        this.sliceEventResize = memoize(this._sliceInteraction);
-        this.forceDayIfListItem = false; // hack
-    }
-    sliceProps(props, dateProfile, nextDayThreshold, context, ...extraArgs) {
-        let { eventUiBases } = props;
-        let eventSegs = this.sliceEventStore(props.eventStore, eventUiBases, dateProfile, nextDayThreshold, ...extraArgs);
+const WHEEL_EVENT_NAMES = 'wheel mousewheel DomMouseScroll MozMousePixelScroll'.split(' ');
+/*
+Fires:
+- scrollStart (always user)
+- scroll
+- scrollEnd (always user)
+
+NOTE: detection is complicated (w/ touch and wheel) because ScrollerSyncer needs to know about it,
+but are we sure we can't just ignore programmatic scrollTo() calls with a flag? and determine the
+the scroll-master simply by who was the newest scroller? Does passive:true do things asynchronously?
+*/
+class ScrollListener {
+    constructor(el) {
+        this.el = el;
+        this.emitter = new Emitter();
+        this.isScrolling = false;
+        this.isTouching = false; // user currently has finger down?
+        this.isRecentlyWheeled = false;
+        this.isRecentlyScrolled = false;
+        this.wheelWaiter = new DelayedRunner(this._handleWheelWaited.bind(this));
+        this.scrollWaiter = new DelayedRunner(this._handleScrollWaited.bind(this));
+        // Handlers
+        // ----------------------------------------------------------------------------------------------
+        this.handleScroll = () => {
+            this.startScroll();
+            this.emitter.trigger('scroll', this.isRecentlyWheeled, this.isTouching);
+            this.isRecentlyScrolled = true;
+            this.scrollWaiter.request(500);
+        };
+        // will fire *before* the scroll event is fired (might not cause a scroll)
+        this.handleWheel = () => {
+            this.isRecentlyWheeled = true;
+            this.wheelWaiter.request(500);
+        };
+        // will fire *before* the scroll event is fired (might not cause a scroll)
+        this.handleTouchStart = () => {
+            this.isTouching = true;
+        };
+        this.handleTouchEnd = () => {
+            this.isTouching = false;
+            // if the user ended their touch, and the scroll area wasn't moving,
+            // we consider this to be the end of the scroll.
+            if (!this.isRecentlyScrolled) {
+                this.endScroll(); // won't fire if already ended
+            }
+        };
+        el.addEventListener('scroll', this.handleScroll);
+        el.addEventListener('touchstart', this.handleTouchStart, { passive: true });
+        el.addEventListener('touchend', this.handleTouchEnd);
+        for (let eventName of WHEEL_EVENT_NAMES) {
+            el.addEventListener(eventName, this.handleWheel, { passive: true });
+        }
+    }
+    destroy() {
+        let { el } = this;
+        el.removeEventListener('scroll', this.handleScroll);
+        el.removeEventListener('touchstart', this.handleTouchStart, { passive: true });
+        el.removeEventListener('touchend', this.handleTouchEnd);
+        for (let eventName of WHEEL_EVENT_NAMES) {
+            el.removeEventListener(eventName, this.handleWheel, { passive: true });
+        }
+    }
+    // Start / Stop
+    // ----------------------------------------------------------------------------------------------
+    startScroll() {
+        if (!this.isScrolling) {
+            this.isScrolling = true;
+            this.emitter.trigger('scrollStart', this.isRecentlyWheeled, this.isTouching);
+        }
+    }
+    endScroll() {
+        if (this.isScrolling) {
+            this.emitter.trigger('scrollEnd');
+            this.isScrolling = false;
+            this.isRecentlyScrolled = true;
+            this.isRecentlyWheeled = false;
+            this.scrollWaiter.clear();
+            this.wheelWaiter.clear();
+        }
+    }
+    _handleScrollWaited() {
+        this.isRecentlyScrolled = false;
+        // only end the scroll if not currently touching.
+        // if touching, the scrolling will end later, on touchend.
+        if (!this.isTouching) {
+            this.endScroll(); // won't fire if already ended
+        }
+    }
+    _handleWheelWaited() {
+        this.isRecentlyWheeled = false;
+    }
+}
+
+class Scroller extends DateComponent {
+    constructor() {
+        super(...arguments);
+        // ref
+        this.elRef = preact.createRef();
+    }
+    render() {
+        const { props } = this;
+        // if there's only one axis that needs scrolling, the other axis will unintentionally have
+        // scrollbars too, so we must force to 'hidden'
+        const fallbackOverflow = (props.horizontal || props.vertical) ? 'hidden' : '';
+        return (preact.createElement("div", { ref: this.elRef, className: [
+                'fc-scroller',
+                props.hideScrollbars ? 'fc-scroller-nobars' : '',
+                ...(props.elClassNames || []),
+            ].join(' '), style: Object.assign(Object.assign({}, props.elStyle), { overflowX: props.horizontal ? 'auto' : fallbackOverflow, overflowY: props.vertical ? 'auto' : fallbackOverflow }) }, props.children));
+    }
+    componentDidMount() {
+        const el = this.elRef.current; // TODO: make dynamic with useEffect
+        this.listener = new ScrollListener(el);
+        this.disconnectSize = watchSize(el, (contentWidth, contentHeight) => {
+            const { props, context } = this;
+            const bottomScrollbarWidth = el.offsetHeight - el.clientHeight;
+            const horizontalScrollbarWidth = el.offsetWidth - el.clientWidth;
+            let rightScrollbarWidth = 0;
+            let leftScrollbarWidth = 0;
+            if (context.isRtl && getRtlScrollerConfig().leftScrollbars) {
+                leftScrollbarWidth = horizontalScrollbarWidth;
+            }
+            else {
+                rightScrollbarWidth = horizontalScrollbarWidth;
+            }
+            if (!isDimsEqual(this.currentWidth, contentWidth)) {
+                setRef(props.widthRef, this.currentWidth = contentWidth);
+            }
+            if (!isDimsEqual(this.currentHeight, contentHeight)) {
+                setRef(props.heightRef, this.currentHeight = contentHeight);
+            }
+            if (!isDimsEqual(this.currentBottomScrollbarWidth, bottomScrollbarWidth)) {
+                setRef(props.bottomScrollbarWidthRef, this.currentBottomScrollbarWidth = bottomScrollbarWidth);
+            }
+            if (!isDimsEqual(this.currentRightScrollbarWidth, rightScrollbarWidth)) {
+                setRef(props.rightScrollbarWidthRef, this.currentRightScrollbarWidth = rightScrollbarWidth);
+            }
+            if (!isDimsEqual(this.currentLeftScrollbarWidth, leftScrollbarWidth)) {
+                setRef(props.leftScrollbarWidthRef, this.currentLeftScrollbarWidth = leftScrollbarWidth);
+            }
+        });
+    }
+    componentWillUnmount() {
+        const { props } = this;
+        this.disconnectSize();
+        this.listener.destroy();
+        setRef(props.widthRef, null);
+        setRef(props.heightRef, null);
+        setRef(props.bottomScrollbarWidthRef, null);
+        setRef(props.rightScrollbarWidthRef, null);
+        setRef(props.leftScrollbarWidthRef, null);
+    }
+    endScroll() {
+        this.listener.endScroll();
+    }
+    // Public API
+    // -----------------------------------------------------------------------------------------------
+    get x() {
+        const { isRtl } = this.context;
+        const el = this.elRef.current;
+        return getNormalizedScrollX(el, isRtl);
+    }
+    get y() {
+        const el = this.elRef.current;
+        return el.scrollTop;
+    }
+    scrollTo({ x, y }) {
+        const { isRtl } = this.context;
+        const el = this.elRef.current;
+        if (y != null) {
+            el.scrollTop = y;
+        }
+        if (x != null) {
+            setNormalizedScrollX(el, isRtl, x);
+        }
+    }
+    addScrollEndListener(handler) {
+        this.listener.emitter.on('scrollEnd', handler);
+    }
+    removeScrollEndListener(handler) {
+        this.listener.emitter.off('scrollEnd', handler);
+    }
+}
+// Public API
+// -------------------------------------------------------------------------------------------------
+// TODO: consolidate with scroll-left-norm.ts
+function getNormalizedScrollX(el, isRtl) {
+    const { scrollLeft } = el;
+    return isRtl ? getNormalizedRtlScrollX(scrollLeft, el) : scrollLeft;
+}
+function setNormalizedScrollX(el, isRtl, x) {
+    el.scrollLeft = isRtl ? getNormalizedRtlScrollLeft(x, el) : x;
+}
+/*
+Returns a value in the 'reverse' system
+*/
+function getNormalizedRtlScrollX(scrollLeft, el) {
+    switch (getRtlScrollerConfig().system) {
+        case 'positive':
+            return el.scrollWidth - el.clientWidth - scrollLeft;
+        case 'negative':
+            return -scrollLeft;
+    }
+    return scrollLeft;
+}
+/*
+Receives a value in the 'reverse' system
+TODO: is this really the same equations as getNormalizedRtlScrollX??? I think so
+  If so, consolidate. With isRtl check too
+*/
+function getNormalizedRtlScrollLeft(x, el) {
+    switch (getRtlScrollerConfig().system) {
+        case 'positive':
+            return el.scrollWidth - el.clientWidth - x;
+        case 'negative':
+            return -x;
+    }
+    return x;
+}
+let _rtlScrollerConfig;
+function getRtlScrollerConfig() {
+    return _rtlScrollerConfig || (_rtlScrollerConfig = detectRtlScrollerConfig());
+}
+function detectRtlScrollerConfig() {
+    let el = document.createElement('div');
+    el.style.position = 'absolute';
+    el.style.top = '-1000px';
+    el.style.width = '100px'; // must be at least the side of scrollbars or you get inaccurate values (#7335)
+    el.style.height = '100px'; // "
+    el.style.overflow = 'scroll';
+    el.style.direction = 'rtl';
+    let innerEl = document.createElement('div');
+    innerEl.style.width = '200px';
+    innerEl.style.height = '200px';
+    el.appendChild(innerEl);
+    document.body.appendChild(el);
+    let system;
+    if (el.scrollLeft > 0) {
+        system = 'positive'; // scroll is a positive number from the left edge
+    }
+    else {
+        el.scrollLeft = 50;
+        if (el.scrollLeft > 0) {
+            system = 'reverse'; // scroll is a positive number from the right edge
+        }
+        else {
+            system = 'negative'; // scroll is a negative number from the right edge
+        }
+    }
+    let rightScrollbars = innerEl.getBoundingClientRect().right < el.getBoundingClientRect().right;
+    removeElement(el);
+    return { system, leftScrollbars: !rightScrollbars };
+}
+
+class Slicer {
+    constructor() {
+        this.sliceBusinessHours = memoize(this._sliceBusinessHours);
+        this.sliceDateSelection = memoize(this._sliceDateSpan);
+        this.sliceEventStore = memoize(this._sliceEventStore);
+        this.sliceEventDrag = memoize(this._sliceInteraction);
+        this.sliceEventResize = memoize(this._sliceInteraction);
+        this.forceDayIfListItem = false; // hack
+    }
+    sliceProps(props, dateProfile, nextDayThreshold, context, ...extraArgs) {
+        let { eventUiBases } = props;
+        let eventSegs = this.sliceEventStore(props.eventStore, eventUiBases, dateProfile, nextDayThreshold, ...extraArgs);
         return {
             dateSelectionSegs: this.sliceDateSelection(props.dateSelection, dateProfile, nextDayThreshold, eventUiBases, context, ...extraArgs),
             businessHourSegs: this.sliceBusinessHours(props.businessHours, dateProfile, nextDayThreshold, context, ...extraArgs),
@@ -6645,423 +6682,124 @@ function anyRangesContainRange(outerRanges, innerRange) {
     return false;
 }
 
-const VISIBLE_HIDDEN_RE = /^(visible|hidden)$/;
-class Scroller extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.handleEl = (el) => {
-            this.el = el;
-            setRef(this.props.elRef, el);
-        };
-    }
-    render() {
-        let { props } = this;
-        let { liquid, liquidIsAbsolute } = props;
-        let isAbsolute = liquid && liquidIsAbsolute;
-        let className = ['fc-scroller'];
-        if (liquid) {
-            if (liquidIsAbsolute) {
-                className.push('fc-scroller-liquid-absolute');
-            }
-            else {
-                className.push('fc-scroller-liquid');
-            }
-        }
-        return (preact.createElement("div", { ref: this.handleEl, className: className.join(' '), style: {
-                overflowX: props.overflowX,
-                overflowY: props.overflowY,
-                left: (isAbsolute && -(props.overcomeLeft || 0)) || '',
-                right: (isAbsolute && -(props.overcomeRight || 0)) || '',
-                bottom: (isAbsolute && -(props.overcomeBottom || 0)) || '',
-                marginLeft: (!isAbsolute && -(props.overcomeLeft || 0)) || '',
-                marginRight: (!isAbsolute && -(props.overcomeRight || 0)) || '',
-                marginBottom: (!isAbsolute && -(props.overcomeBottom || 0)) || '',
-                maxHeight: props.maxHeight || '',
-            } }, props.children));
-    }
-    needsXScrolling() {
-        if (VISIBLE_HIDDEN_RE.test(this.props.overflowX)) {
-            return false;
-        }
-        // testing scrollWidth>clientWidth is unreliable cross-browser when pixel heights aren't integers.
-        // much more reliable to see if children are taller than the scroller, even tho doesn't account for
-        // inner-child margins and absolute positioning
-        let { el } = this;
-        let realClientWidth = this.el.getBoundingClientRect().width - this.getYScrollbarWidth();
-        let { children } = el;
-        for (let i = 0; i < children.length; i += 1) {
-            let childEl = children[i];
-            if (childEl.getBoundingClientRect().width > realClientWidth) {
-                return true;
-            }
-        }
-        return false;
-    }
-    needsYScrolling() {
-        if (VISIBLE_HIDDEN_RE.test(this.props.overflowY)) {
-            return false;
-        }
-        // testing scrollHeight>clientHeight is unreliable cross-browser when pixel heights aren't integers.
-        // much more reliable to see if children are taller than the scroller, even tho doesn't account for
-        // inner-child margins and absolute positioning
-        let { el } = this;
-        let realClientHeight = this.el.getBoundingClientRect().height - this.getXScrollbarWidth();
-        let { children } = el;
-        for (let i = 0; i < children.length; i += 1) {
-            let childEl = children[i];
-            if (childEl.getBoundingClientRect().height > realClientHeight) {
-                return true;
-            }
-        }
-        return false;
+function getIsHeightAuto(options) {
+    return options.height === 'auto' || options.viewHeight === 'auto';
+}
+function getStickyHeaderDates(options) {
+    let { stickyHeaderDates } = options;
+    if (stickyHeaderDates == null || stickyHeaderDates === 'auto') {
+        stickyHeaderDates = getIsHeightAuto(options);
     }
-    getXScrollbarWidth() {
-        if (VISIBLE_HIDDEN_RE.test(this.props.overflowX)) {
-            return 0;
-        }
-        return this.el.offsetHeight - this.el.clientHeight; // only works because we guarantee no borders. TODO: add to CSS with important?
+    return stickyHeaderDates;
+}
+function getStickyFooterScrollbar(options) {
+    let { stickyFooterScrollbar } = options;
+    if (stickyFooterScrollbar == null || stickyFooterScrollbar === 'auto') {
+        stickyFooterScrollbar = getIsHeightAuto(options);
     }
-    getYScrollbarWidth() {
-        if (VISIBLE_HIDDEN_RE.test(this.props.overflowY)) {
-            return 0;
-        }
-        return this.el.offsetWidth - this.el.clientWidth; // only works because we guarantee no borders. TODO: add to CSS with important?
+    return stickyFooterScrollbar;
+}
+function getScrollerSyncerClass(pluginHooks) {
+    const ScrollerSyncer = pluginHooks.scrollerSyncerClass;
+    if (!ScrollerSyncer) {
+        throw new RangeError('Must import @fullcalendar/scrollgrid');
     }
+    return ScrollerSyncer;
 }
 
 /*
-TODO: somehow infer OtherArgs from masterCallback?
-TODO: infer RefType from masterCallback if provided
+TODO: make API where createRefMap() called
 */
 class RefMap {
     constructor(masterCallback) {
         this.masterCallback = masterCallback;
-        this.currentMap = {};
-        this.depths = {};
-        this.callbackMap = {};
+        this.rev = '';
+        this.current = new Map();
+        this.callbacks = new Map;
         this.handleValue = (val, key) => {
-            let { depths, currentMap } = this;
-            let removed = false;
-            let added = false;
-            if (val !== null) {
-                // for bug... ACTUALLY: can probably do away with this now that callers don't share numeric indices anymore
-                removed = (key in currentMap);
-                currentMap[key] = val;
-                depths[key] = (depths[key] || 0) + 1;
-                added = true;
+            let { current, callbacks } = this;
+            if (val === null) {
+                current.delete(key);
+                callbacks.delete(key);
             }
             else {
-                depths[key] -= 1;
-                if (!depths[key]) {
-                    delete currentMap[key];
-                    delete this.callbackMap[key];
-                    removed = true;
-                }
+                current.set(key, val);
             }
+            this.rev = guid();
             if (this.masterCallback) {
-                if (removed) {
-                    this.masterCallback(null, String(key));
-                }
-                if (added) {
-                    this.masterCallback(val, String(key));
-                }
+                this.masterCallback(val, key);
             }
         };
     }
     createRef(key) {
-        let refCallback = this.callbackMap[key];
+        let refCallback = this.callbacks.get(key);
         if (!refCallback) {
-            refCallback = this.callbackMap[key] = (val) => {
-                this.handleValue(val, String(key));
+            refCallback = (val) => {
+                this.handleValue(val, key);
             };
+            this.callbacks.set(key, refCallback);
         }
         return refCallback;
     }
-    // TODO: check callers that don't care about order. should use getAll instead
-    // NOTE: this method has become less valuable now that we are encouraged to map order by some other index
-    // TODO: provide ONE array-export function, buildArray, which fails on non-numeric indexes. caller can manipulate and "collect"
-    collect(startIndex, endIndex, step) {
-        return collectFromHash(this.currentMap, startIndex, endIndex, step);
-    }
-    getAll() {
-        return hashValuesToArray(this.currentMap);
-    }
 }
 
-function computeShrinkWidth(chunkEls) {
-    let shrinkCells = findElements(chunkEls, '.fc-scrollgrid-shrink');
-    let largestWidth = 0;
-    for (let shrinkCell of shrinkCells) {
-        largestWidth = Math.max(largestWidth, computeSmallestCellWidth(shrinkCell));
-    }
-    return Math.ceil(largestWidth); // <table> elements work best with integers. round up to ensure contents fits
-}
-function getSectionHasLiquidHeight(props, sectionConfig) {
-    return props.liquid && sectionConfig.liquid; // does the section do liquid-height? (need to have whole scrollgrid liquid-height as well)
-}
-function getAllowYScrolling(props, sectionConfig) {
-    return sectionConfig.maxHeight != null || // if its possible for the height to max out, we might need scrollbars
-        getSectionHasLiquidHeight(props, sectionConfig); // if the section is liquid height, it might condense enough to require scrollbars
-}
-// TODO: ONLY use `arg`. force out internal function to use same API
-function renderChunkContent(sectionConfig, chunkConfig, arg, isHeader) {
-    let { expandRows } = arg;
-    let content = typeof chunkConfig.content === 'function' ?
-        chunkConfig.content(arg) :
-        preact.createElement('table', {
-            role: 'presentation',
-            className: [
-                chunkConfig.tableClassName,
-                sectionConfig.syncRowHeights ? 'fc-scrollgrid-sync-table' : '',
-            ].join(' '),
-            style: {
-                minWidth: arg.tableMinWidth,
-                width: arg.clientWidth,
-                height: expandRows ? arg.clientHeight : '', // css `height` on a <table> serves as a min-height
-            },
-        }, arg.tableColGroupNode, preact.createElement(isHeader ? 'thead' : 'tbody', {
-            role: 'presentation',
-        }, typeof chunkConfig.rowContent === 'function'
-            ? chunkConfig.rowContent(arg)
-            : chunkConfig.rowContent));
-    return content;
-}
-function isColPropsEqual(cols0, cols1) {
-    return isArraysEqual(cols0, cols1, isPropsEqual);
-}
-function renderMicroColGroup(cols, shrinkWidth) {
-    let colNodes = [];
-    /*
-    for ColProps with spans, it would have been great to make a single <col span="">
-    HOWEVER, Chrome was getting messing up distributing the width to <td>/<th> elements with colspans.
-    SOLUTION: making individual <col> elements makes Chrome behave.
-    */
-    for (let colProps of cols) {
-        let span = colProps.span || 1;
-        for (let i = 0; i < span; i += 1) {
-            colNodes.push(preact.createElement("col", { style: {
-                    width: colProps.width === 'shrink' ? sanitizeShrinkWidth(shrinkWidth) : (colProps.width || ''),
-                    minWidth: colProps.minWidth || '',
-                } }));
-        }
-    }
-    return preact.createElement('colgroup', {}, ...colNodes);
-}
-function sanitizeShrinkWidth(shrinkWidth) {
-    /* why 4? if we do 0, it will kill any border, which are needed for computeSmallestCellWidth
-    4 accounts for 2 2-pixel borders. TODO: better solution? */
-    return shrinkWidth == null ? 4 : shrinkWidth;
-}
-function hasShrinkWidth(cols) {
-    for (let col of cols) {
-        if (col.width === 'shrink') {
-            return true;
-        }
-    }
-    return false;
-}
-function getScrollGridClassNames(liquid, context) {
-    let classNames = [
-        'fc-scrollgrid',
-        context.theme.getClass('table'),
-    ];
-    if (liquid) {
-        classNames.push('fc-scrollgrid-liquid');
+class NowTimer extends preact.Component {
+    constructor(props, context) {
+        super(props, context);
+        this.initialNowDate = getNow(context.options.now, context.dateEnv);
+        this.initialNowQueriedMs = new Date().valueOf();
+        this.state = this.computeTiming().currentState;
     }
-    return classNames;
-}
-function getSectionClassNames(sectionConfig, wholeTableVGrow) {
-    let classNames = [
-        'fc-scrollgrid-section',
-        `fc-scrollgrid-section-${sectionConfig.type}`,
-        sectionConfig.className, // used?
-    ];
-    if (wholeTableVGrow && sectionConfig.liquid && sectionConfig.maxHeight == null) {
-        classNames.push('fc-scrollgrid-section-liquid');
+    render() {
+        let { props, state } = this;
+        return props.children(state.nowDate, state.todayRange);
     }
-    if (sectionConfig.isSticky) {
-        classNames.push('fc-scrollgrid-section-sticky');
+    componentDidMount() {
+        this.setTimeout();
     }
-    return classNames;
-}
-function renderScrollShim(arg) {
-    return (preact.createElement("div", { className: "fc-scrollgrid-sticky-shim", style: {
-            width: arg.clientWidth,
-            minWidth: arg.tableMinWidth,
-        } }));
-}
-function getStickyHeaderDates(options) {
-    let { stickyHeaderDates } = options;
-    if (stickyHeaderDates == null || stickyHeaderDates === 'auto') {
-        stickyHeaderDates = options.height === 'auto' || options.viewHeight === 'auto';
+    componentDidUpdate(prevProps) {
+        if (prevProps.unit !== this.props.unit) {
+            this.clearTimeout();
+            this.setTimeout();
+        }
     }
-    return stickyHeaderDates;
-}
-function getStickyFooterScrollbar(options) {
-    let { stickyFooterScrollbar } = options;
-    if (stickyFooterScrollbar == null || stickyFooterScrollbar === 'auto') {
-        stickyFooterScrollbar = options.height === 'auto' || options.viewHeight === 'auto';
+    componentWillUnmount() {
+        this.clearTimeout();
     }
-    return stickyFooterScrollbar;
-}
-
-class SimpleScrollGrid extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.processCols = memoize((a) => a, isColPropsEqual); // so we get same `cols` props every time
-        // yucky to memoize VNodes, but much more efficient for consumers
-        this.renderMicroColGroup = memoize(renderMicroColGroup);
-        this.scrollerRefs = new RefMap();
-        this.scrollerElRefs = new RefMap(this._handleScrollerEl.bind(this));
-        this.state = {
-            shrinkWidth: null,
-            forceYScrollbars: false,
-            scrollerClientWidths: {},
-            scrollerClientHeights: {},
-        };
-        // TODO: can do a really simple print-view. dont need to join rows
-        this.handleSizing = () => {
-            this.safeSetState(Object.assign({ shrinkWidth: this.computeShrinkWidth() }, this.computeScrollerDims()));
+    computeTiming() {
+        let { props, context } = this;
+        let unroundedNow = addMs(this.initialNowDate, new Date().valueOf() - this.initialNowQueriedMs);
+        let currentUnitStart = context.dateEnv.startOf(unroundedNow, props.unit);
+        let nextUnitStart = context.dateEnv.add(currentUnitStart, createDuration(1, props.unit));
+        let waitMs = nextUnitStart.valueOf() - unroundedNow.valueOf();
+        // there is a max setTimeout ms value (https://stackoverflow.com/a/3468650/96342)
+        // ensure no longer than a day
+        waitMs = Math.min(1000 * 60 * 60 * 24, waitMs);
+        return {
+            currentState: { nowDate: currentUnitStart, todayRange: buildDayRange(currentUnitStart) },
+            nextState: { nowDate: nextUnitStart, todayRange: buildDayRange(nextUnitStart) },
+            waitMs,
         };
     }
-    render() {
-        let { props, state, context } = this;
-        let sectionConfigs = props.sections || [];
-        let cols = this.processCols(props.cols);
-        let microColGroupNode = this.renderMicroColGroup(cols, state.shrinkWidth);
-        let classNames = getScrollGridClassNames(props.liquid, context);
-        if (props.collapsibleWidth) {
-            classNames.push('fc-scrollgrid-collapsible');
-        }
-        // TODO: make DRY
-        let configCnt = sectionConfigs.length;
-        let configI = 0;
-        let currentConfig;
-        let headSectionNodes = [];
-        let bodySectionNodes = [];
-        let footSectionNodes = [];
-        while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'header') {
-            headSectionNodes.push(this.renderSection(currentConfig, microColGroupNode, true));
-            configI += 1;
-        }
-        while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'body') {
-            bodySectionNodes.push(this.renderSection(currentConfig, microColGroupNode, false));
-            configI += 1;
-        }
-        while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === 'footer') {
-            footSectionNodes.push(this.renderSection(currentConfig, microColGroupNode, true));
-            configI += 1;
-        }
-        // firefox bug: when setting height on table and there is a thead or tfoot,
-        // the necessary height:100% on the liquid-height body section forces the *whole* table to be taller. (bug #5524)
-        // use getCanVGrowWithinCell as a way to detect table-stupid firefox.
-        // if so, use a simpler dom structure, jam everything into a lone tbody.
-        let isBuggy = !getCanVGrowWithinCell();
-        const roleAttrs = { role: 'rowgroup' };
-        return preact.createElement('table', {
-            role: 'grid',
-            className: classNames.join(' '),
-            style: { height: props.height },
-        }, Boolean(!isBuggy && headSectionNodes.length) && preact.createElement('thead', roleAttrs, ...headSectionNodes), Boolean(!isBuggy && bodySectionNodes.length) && preact.createElement('tbody', roleAttrs, ...bodySectionNodes), Boolean(!isBuggy && footSectionNodes.length) && preact.createElement('tfoot', roleAttrs, ...footSectionNodes), isBuggy && preact.createElement('tbody', roleAttrs, ...headSectionNodes, ...bodySectionNodes, ...footSectionNodes));
-    }
-    renderSection(sectionConfig, microColGroupNode, isHeader) {
-        if ('outerContent' in sectionConfig) {
-            return (preact.createElement(preact.Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
-        }
-        return (preact.createElement("tr", { key: sectionConfig.key, role: "presentation", className: getSectionClassNames(sectionConfig, this.props.liquid).join(' ') }, this.renderChunkTd(sectionConfig, microColGroupNode, sectionConfig.chunk, isHeader)));
-    }
-    renderChunkTd(sectionConfig, microColGroupNode, chunkConfig, isHeader) {
-        if ('outerContent' in chunkConfig) {
-            return chunkConfig.outerContent;
-        }
-        let { props } = this;
-        let { forceYScrollbars, scrollerClientWidths, scrollerClientHeights } = this.state;
-        let needsYScrolling = getAllowYScrolling(props, sectionConfig); // TODO: do lazily. do in section config?
-        let isLiquid = getSectionHasLiquidHeight(props, sectionConfig);
-        // for `!props.liquid` - is WHOLE scrollgrid natural height?
-        // TODO: do same thing in advanced scrollgrid? prolly not b/c always has horizontal scrollbars
-        let overflowY = !props.liquid ? 'visible' :
-            forceYScrollbars ? 'scroll' :
-                !needsYScrolling ? 'hidden' :
-                    'auto';
-        let sectionKey = sectionConfig.key;
-        let content = renderChunkContent(sectionConfig, chunkConfig, {
-            tableColGroupNode: microColGroupNode,
-            tableMinWidth: '',
-            clientWidth: (!props.collapsibleWidth && scrollerClientWidths[sectionKey] !== undefined) ? scrollerClientWidths[sectionKey] : null,
-            clientHeight: scrollerClientHeights[sectionKey] !== undefined ? scrollerClientHeights[sectionKey] : null,
-            expandRows: sectionConfig.expandRows,
-            syncRowHeights: false,
-            rowSyncHeights: [],
-            reportRowHeightChange: () => { },
-        }, isHeader);
-        return preact.createElement(isHeader ? 'th' : 'td', {
-            ref: chunkConfig.elRef,
-            role: 'presentation',
-        }, preact.createElement("div", { className: `fc-scroller-harness${isLiquid ? ' fc-scroller-harness-liquid' : ''}` },
-            preact.createElement(Scroller, { ref: this.scrollerRefs.createRef(sectionKey), elRef: this.scrollerElRefs.createRef(sectionKey), overflowY: overflowY, overflowX: !props.liquid ? 'visible' : 'hidden' /* natural height? */, maxHeight: sectionConfig.maxHeight, liquid: isLiquid, liquidIsAbsolute // because its within a harness
-                : true }, content)));
-    }
-    _handleScrollerEl(scrollerEl, key) {
-        let section = getSectionByKey(this.props.sections, key);
-        if (section) {
-            setRef(section.chunk.scrollerElRef, scrollerEl);
-        }
-    }
-    componentDidMount() {
-        this.handleSizing();
-        this.context.addResizeHandler(this.handleSizing);
-    }
-    componentDidUpdate() {
-        // TODO: need better solution when state contains non-sizing things
-        this.handleSizing();
+    setTimeout() {
+        let { nextState, waitMs } = this.computeTiming();
+        this.timeoutId = setTimeout(() => {
+            this.setState(nextState, () => {
+                this.setTimeout();
+            });
+        }, waitMs);
     }
-    componentWillUnmount() {
-        this.context.removeResizeHandler(this.handleSizing);
-    }
-    computeShrinkWidth() {
-        return hasShrinkWidth(this.props.cols)
-            ? computeShrinkWidth(this.scrollerElRefs.getAll())
-            : 0;
-    }
-    computeScrollerDims() {
-        let scrollbarWidth = getScrollbarWidths();
-        let { scrollerRefs, scrollerElRefs } = this;
-        let forceYScrollbars = false;
-        let scrollerClientWidths = {};
-        let scrollerClientHeights = {};
-        for (let sectionKey in scrollerRefs.currentMap) {
-            let scroller = scrollerRefs.currentMap[sectionKey];
-            if (scroller && scroller.needsYScrolling()) {
-                forceYScrollbars = true;
-                break;
-            }
-        }
-        for (let section of this.props.sections) {
-            let sectionKey = section.key;
-            let scrollerEl = scrollerElRefs.currentMap[sectionKey];
-            if (scrollerEl) {
-                let harnessEl = scrollerEl.parentNode; // TODO: weird way to get this. need harness b/c doesn't include table borders
-                scrollerClientWidths[sectionKey] = Math.floor(harnessEl.getBoundingClientRect().width - (forceYScrollbars
-                    ? scrollbarWidth.y // use global because scroller might not have scrollbars yet but will need them in future
-                    : 0));
-                scrollerClientHeights[sectionKey] = Math.floor(harnessEl.getBoundingClientRect().height);
-            }
+    clearTimeout() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
         }
-        return { forceYScrollbars, scrollerClientWidths, scrollerClientHeights };
     }
 }
-SimpleScrollGrid.addStateEquality({
-    scrollerClientWidths: isPropsEqual,
-    scrollerClientHeights: isPropsEqual,
-});
-function getSectionByKey(sections, key) {
-    for (let section of sections) {
-        if (section.key === key) {
-            return section;
-        }
-    }
-    return null;
+NowTimer.contextType = ViewContextType;
+function buildDayRange(date) {
+    let start = startOfDay(date);
+    let end = addDays(start, 1);
+    return { start, end };
 }
 
 class EventContainer extends BaseComponent {
@@ -7070,15 +6808,14 @@ class EventContainer extends BaseComponent {
         this.handleEl = (el) => {
             this.el = el;
             if (el) {
-                setElSeg(el, this.props.seg);
+                setElEventRange(el, this.props.eventRange);
             }
         };
     }
     render() {
         const { props, context } = this;
         const { options } = context;
-        const { seg } = props;
-        const { eventRange } = seg;
+        const { eventRange } = props;
         const { ui } = eventRange;
         const renderProps = {
             event: new EventImpl(context, eventRange.def, eventRange.instance),
@@ -7087,12 +6824,12 @@ class EventContainer extends BaseComponent {
             textColor: ui.textColor,
             backgroundColor: ui.backgroundColor,
             borderColor: ui.borderColor,
-            isDraggable: !props.disableDragging && computeSegDraggable(seg, context),
-            isStartResizable: !props.disableResizing && computeSegStartResizable(seg, context),
-            isEndResizable: !props.disableResizing && computeSegEndResizable(seg),
+            isDraggable: !props.disableDragging && computeEventRangeDraggable(eventRange, context),
+            isStartResizable: !props.disableResizing && props.isStart && eventRange.ui.durationEditable && options.eventResizableFromStart,
+            isEndResizable: !props.disableResizing && props.isEnd && eventRange.ui.durationEditable,
             isMirror: Boolean(props.isDragging || props.isResizing || props.isDateSelecting),
-            isStart: Boolean(seg.isStart),
-            isEnd: Boolean(seg.isEnd),
+            isStart: Boolean(props.isStart),
+            isEnd: Boolean(props.isEnd),
             isPast: Boolean(props.isPast),
             isFuture: Boolean(props.isFuture),
             isToday: Boolean(props.isToday),
@@ -7102,13 +6839,13 @@ class EventContainer extends BaseComponent {
         };
         return (preact.createElement(ContentContainer, Object.assign({}, props /* contains children */, { elRef: this.handleEl, elClasses: [
                 ...getEventClassNames(renderProps),
-                ...seg.eventRange.ui.classNames,
+                ...eventRange.ui.classNames,
                 ...(props.elClasses || []),
             ], renderProps: renderProps, generatorName: "eventContent", customGenerator: options.eventContent, defaultGenerator: props.defaultGenerator, classNameGenerator: options.eventClassNames, didMount: options.eventDidMount, willUnmount: options.eventWillUnmount })));
     }
     componentDidUpdate(prevProps) {
-        if (this.el && this.props.seg !== prevProps.seg) {
-            setElSeg(this.el, this.props.seg);
+        if (this.el && this.props.eventRange !== prevProps.eventRange) {
+            setElEventRange(this.el, this.props.eventRange);
         }
     }
 }
@@ -7118,24 +6855,24 @@ class StandardEvent extends BaseComponent {
     render() {
         let { props, context } = this;
         let { options } = context;
-        let { seg } = props;
-        let { ui } = seg.eventRange;
+        let { eventRange } = props;
+        let { ui } = eventRange;
         let timeFormat = options.eventTimeFormat || props.defaultTimeFormat;
-        let timeText = buildSegTimeText(seg, timeFormat, context, props.defaultDisplayEventTime, props.defaultDisplayEventEnd);
+        let timeText = buildEventRangeTimeText(eventRange, timeFormat, context, props.defaultDisplayEventTime, props.defaultDisplayEventEnd, props.startOverride, props.endOverride);
         return (preact.createElement(EventContainer, Object.assign({}, props /* includes elRef */, { elTag: "a", elStyle: {
                 borderColor: ui.borderColor,
                 backgroundColor: ui.backgroundColor,
-            }, elAttrs: getSegAnchorAttrs(seg, context), defaultGenerator: renderInnerContent$1, timeText: timeText }), (InnerContent, eventContentArg) => (preact.createElement(preact.Fragment, null,
-            preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-event-main'], elStyle: { color: eventContentArg.textColor } }),
+            }, elAttrs: getEventRangeAnchorAttrs(eventRange, context), defaultGenerator: renderInnerContent$1, timeText: timeText }), (InnerContent, eventContentArg) => (preact.createElement(preact.Fragment, null,
+            preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-event-inner'], elStyle: { color: eventContentArg.textColor } }),
             Boolean(eventContentArg.isStartResizable) && (preact.createElement("div", { className: "fc-event-resizer fc-event-resizer-start" })),
             Boolean(eventContentArg.isEndResizable) && (preact.createElement("div", { className: "fc-event-resizer fc-event-resizer-end" }))))));
     }
 }
 function renderInnerContent$1(innerProps) {
-    return (preact.createElement("div", { className: "fc-event-main-frame" },
+    return (preact.createElement(preact.Fragment, null,
         innerProps.timeText && (preact.createElement("div", { className: "fc-event-time" }, innerProps.timeText)),
-        preact.createElement("div", { className: "fc-event-title-container" },
-            preact.createElement("div", { className: "fc-event-title fc-sticky" }, innerProps.event.title || preact.createElement(preact.Fragment, null, "\u00A0")))));
+        preact.createElement("div", { className: "fc-event-title-outer" },
+            preact.createElement("div", { className: "fc-event-title" }, innerProps.event.title || preact.createElement(preact.Fragment, null, "\u00A0")))));
 }
 
 const NowIndicatorContainer = (props) => (preact.createElement(ViewContextType.Consumer, null, (context) => {
@@ -7148,50 +6885,11 @@ const NowIndicatorContainer = (props) => (preact.createElement(ViewContextType.C
     return (preact.createElement(ContentContainer, Object.assign({}, props /* includes children */, { elTag: props.elTag || 'div', renderProps: renderProps, generatorName: "nowIndicatorContent", customGenerator: options.nowIndicatorContent, classNameGenerator: options.nowIndicatorClassNames, didMount: options.nowIndicatorDidMount, willUnmount: options.nowIndicatorWillUnmount })));
 }));
 
-const DAY_NUM_FORMAT = createFormatter({ day: 'numeric' });
-class DayCellContainer extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.refineRenderProps = memoizeObjArg(refineRenderProps);
-    }
-    render() {
-        let { props, context } = this;
-        let { options } = context;
-        let renderProps = this.refineRenderProps({
-            date: props.date,
-            dateProfile: props.dateProfile,
-            todayRange: props.todayRange,
-            isMonthStart: props.isMonthStart || false,
-            showDayNumber: props.showDayNumber,
-            extraRenderProps: props.extraRenderProps,
-            viewApi: context.viewApi,
-            dateEnv: context.dateEnv,
-            monthStartFormat: options.monthStartFormat,
-        });
-        return (preact.createElement(ContentContainer, Object.assign({}, props /* includes children */, { elClasses: [
-                ...getDayClassNames(renderProps, context.theme),
-                ...(props.elClasses || []),
-            ], elAttrs: Object.assign(Object.assign({}, props.elAttrs), (renderProps.isDisabled ? {} : { 'data-date': formatDayString(props.date) })), renderProps: renderProps, generatorName: "dayCellContent", customGenerator: options.dayCellContent, defaultGenerator: props.defaultGenerator, classNameGenerator: 
-            // don't use custom classNames if disabled
-            renderProps.isDisabled ? undefined : options.dayCellClassNames, didMount: options.dayCellDidMount, willUnmount: options.dayCellWillUnmount })));
-    }
-}
-function hasCustomDayCellContent(options) {
-    return Boolean(options.dayCellContent || hasCustomRenderingHandler('dayCellContent', options));
-}
-function refineRenderProps(raw) {
-    let { date, dateEnv, dateProfile, isMonthStart } = raw;
-    let dayMeta = getDateMeta(date, raw.todayRange, null, dateProfile);
-    let dayNumberText = raw.showDayNumber ? (dateEnv.format(date, isMonthStart ? raw.monthStartFormat : DAY_NUM_FORMAT)) : '';
-    return Object.assign(Object.assign(Object.assign({ date: dateEnv.toDate(date), view: raw.viewApi }, dayMeta), { isMonthStart,
-        dayNumberText }), raw.extraRenderProps);
-}
-
-class BgEvent extends BaseComponent {
+class BgEvent extends BaseComponent {
     render() {
         let { props } = this;
-        let { seg } = props;
-        return (preact.createElement(EventContainer, { elTag: "div", elClasses: ['fc-bg-event'], elStyle: { backgroundColor: seg.eventRange.ui.backgroundColor }, defaultGenerator: renderInnerContent, seg: seg, timeText: "", isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday, disableDragging: true, disableResizing: true }));
+        let { eventRange } = props;
+        return (preact.createElement(EventContainer, { elTag: "div", elClasses: ['fc-bg-event'], elStyle: { backgroundColor: eventRange.ui.backgroundColor }, defaultGenerator: renderInnerContent, eventRange: eventRange, isStart: props.isStart, isEnd: props.isEnd, timeText: "", isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday, disableDragging: true, disableResizing: true }));
     }
 }
 function renderInnerContent(props) {
@@ -7216,250 +6914,384 @@ function renderInner(innerProps) {
     return innerProps.text;
 }
 
-const PADDING_FROM_VIEWPORT = 10;
-class Popover extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.state = {
-            titleId: getUniqueDomId(),
-        };
-        this.handleRootEl = (el) => {
-            this.rootEl = el;
-            if (this.props.elRef) {
-                setRef(this.props.elRef, el);
-            }
-        };
-        // Triggered when the user clicks *anywhere* in the document, for the autoHide feature
-        this.handleDocumentMouseDown = (ev) => {
-            // only hide the popover if the click happened outside the popover
-            const target = getEventTargetViaRoot(ev);
-            if (!this.rootEl.contains(target)) {
-                this.handleCloseClick();
+/*
+Calendar instance for ALL frameworks
+*/
+class CalendarImpl {
+    getCurrentData() {
+        return this.currentDataManager.getCurrentData();
+    }
+    dispatch(action) {
+        this.currentDataManager.dispatch(action);
+    }
+    get view() { return this.getCurrentData().viewApi; }
+    batchRendering(callback) {
+        callback();
+    }
+    updateSize() {
+        console.warn('Doesnt do anything!');
+    }
+    // Options
+    // -----------------------------------------------------------------------------------------------------------------
+    setOption(name, val) {
+        this.dispatch({
+            type: 'SET_OPTION',
+            optionName: name,
+            rawOptionValue: val,
+        });
+    }
+    getOption(name) {
+        return this.currentDataManager.currentCalendarOptionsInput[name];
+    }
+    getAvailableLocaleCodes() {
+        return Object.keys(this.getCurrentData().availableRawLocales);
+    }
+    // Trigger
+    // -----------------------------------------------------------------------------------------------------------------
+    on(handlerName, handler) {
+        let { currentDataManager } = this;
+        if (currentDataManager.currentCalendarOptionsRefiners[handlerName]) {
+            currentDataManager.emitter.on(handlerName, handler);
+        }
+        else {
+            console.warn(`Unknown listener name '${handlerName}'`);
+        }
+    }
+    off(handlerName, handler) {
+        this.currentDataManager.emitter.off(handlerName, handler);
+    }
+    // not meant for public use
+    trigger(handlerName, ...args) {
+        this.currentDataManager.emitter.trigger(handlerName, ...args);
+    }
+    // View
+    // -----------------------------------------------------------------------------------------------------------------
+    changeView(viewType, dateOrRange) {
+        this.batchRendering(() => {
+            this.unselect();
+            if (dateOrRange) {
+                if (dateOrRange.start && dateOrRange.end) { // a range
+                    this.dispatch({
+                        type: 'CHANGE_VIEW_TYPE',
+                        viewType,
+                    });
+                    this.dispatch({
+                        type: 'SET_OPTION',
+                        optionName: 'visibleRange',
+                        rawOptionValue: dateOrRange,
+                    });
+                }
+                else {
+                    let { dateEnv } = this.getCurrentData();
+                    this.dispatch({
+                        type: 'CHANGE_VIEW_TYPE',
+                        viewType,
+                        dateMarker: dateEnv.createMarker(dateOrRange),
+                    });
+                }
             }
-        };
-        this.handleDocumentKeyDown = (ev) => {
-            if (ev.key === 'Escape') {
-                this.handleCloseClick();
+            else {
+                this.dispatch({
+                    type: 'CHANGE_VIEW_TYPE',
+                    viewType,
+                });
             }
-        };
-        this.handleCloseClick = () => {
-            let { onClose } = this.props;
-            if (onClose) {
-                onClose();
+        });
+    }
+    // Forces navigation to a view for the given date.
+    // `viewType` can be a specific view name or a generic one like "week" or "day".
+    // needs to change
+    zoomTo(dateMarker, viewType) {
+        let state = this.getCurrentData();
+        let spec;
+        viewType = viewType || 'day'; // day is default zoom
+        spec = state.viewSpecs[viewType] || this.getUnitViewSpec(viewType);
+        this.unselect();
+        if (spec) {
+            this.dispatch({
+                type: 'CHANGE_VIEW_TYPE',
+                viewType: spec.type,
+                dateMarker,
+            });
+        }
+        else {
+            this.dispatch({
+                type: 'CHANGE_DATE',
+                dateMarker,
+            });
+        }
+    }
+    // Given a duration singular unit, like "week" or "day", finds a matching view spec.
+    // Preference is given to views that have corresponding buttons.
+    getUnitViewSpec(unit) {
+        let { viewSpecs, toolbarConfig } = this.getCurrentData();
+        let viewTypes = [].concat(toolbarConfig.header ? toolbarConfig.header.viewsWithButtons : [], toolbarConfig.footer ? toolbarConfig.footer.viewsWithButtons : []);
+        let i;
+        let spec;
+        for (let viewType in viewSpecs) {
+            viewTypes.push(viewType);
+        }
+        for (i = 0; i < viewTypes.length; i += 1) {
+            spec = viewSpecs[viewTypes[i]];
+            if (spec) {
+                if (spec.singleUnit === unit) {
+                    return spec;
+                }
             }
-        };
+        }
+        return null;
     }
-    render() {
-        let { theme, options } = this.context;
-        let { props, state } = this;
-        let classNames = [
-            'fc-popover',
-            theme.getClass('popover'),
-        ].concat(props.extraClassNames || []);
-        return compat.createPortal(preact.createElement("div", Object.assign({}, props.extraAttrs, { id: props.id, className: classNames.join(' '), "aria-labelledby": state.titleId, ref: this.handleRootEl }),
-            preact.createElement("div", { className: 'fc-popover-header ' + theme.getClass('popoverHeader') },
-                preact.createElement("span", { className: "fc-popover-title", id: state.titleId }, props.title),
-                preact.createElement("span", { className: 'fc-popover-close ' + theme.getIconClass('close'), title: options.closeHint, onClick: this.handleCloseClick })),
-            preact.createElement("div", { className: 'fc-popover-body ' + theme.getClass('popoverContent') }, props.children)), props.parentEl);
+    // Current Date
+    // -----------------------------------------------------------------------------------------------------------------
+    prev() {
+        this.unselect();
+        this.dispatch({ type: 'PREV' });
     }
-    componentDidMount() {
-        document.addEventListener('mousedown', this.handleDocumentMouseDown);
-        document.addEventListener('keydown', this.handleDocumentKeyDown);
-        this.updateSize();
+    next() {
+        this.unselect();
+        this.dispatch({ type: 'NEXT' });
     }
-    componentWillUnmount() {
-        document.removeEventListener('mousedown', this.handleDocumentMouseDown);
-        document.removeEventListener('keydown', this.handleDocumentKeyDown);
+    prevYear() {
+        let state = this.getCurrentData();
+        this.unselect();
+        this.dispatch({
+            type: 'CHANGE_DATE',
+            dateMarker: state.dateEnv.addYears(state.currentDate, -1),
+        });
     }
-    updateSize() {
-        let { isRtl } = this.context;
-        let { alignmentEl, alignGridTop } = this.props;
-        let { rootEl } = this;
-        let alignmentRect = computeClippedClientRect(alignmentEl);
-        if (alignmentRect) {
-            let popoverDims = rootEl.getBoundingClientRect();
-            // position relative to viewport
-            let popoverTop = alignGridTop
-                ? elementClosest(alignmentEl, '.fc-scrollgrid').getBoundingClientRect().top
-                : alignmentRect.top;
-            let popoverLeft = isRtl ? alignmentRect.right - popoverDims.width : alignmentRect.left;
-            // constrain
-            popoverTop = Math.max(popoverTop, PADDING_FROM_VIEWPORT);
-            popoverLeft = Math.min(popoverLeft, document.documentElement.clientWidth - PADDING_FROM_VIEWPORT - popoverDims.width);
-            popoverLeft = Math.max(popoverLeft, PADDING_FROM_VIEWPORT);
-            let origin = rootEl.offsetParent.getBoundingClientRect();
-            applyStyle(rootEl, {
-                top: popoverTop - origin.top,
-                left: popoverLeft - origin.left,
+    nextYear() {
+        let state = this.getCurrentData();
+        this.unselect();
+        this.dispatch({
+            type: 'CHANGE_DATE',
+            dateMarker: state.dateEnv.addYears(state.currentDate, 1),
+        });
+    }
+    today() {
+        let state = this.getCurrentData();
+        this.unselect();
+        this.dispatch({
+            type: 'CHANGE_DATE',
+            dateMarker: getNow(state.calendarOptions.now, state.dateEnv),
+        });
+    }
+    gotoDate(zonedDateInput) {
+        let state = this.getCurrentData();
+        this.unselect();
+        this.dispatch({
+            type: 'CHANGE_DATE',
+            dateMarker: state.dateEnv.createMarker(zonedDateInput),
+        });
+    }
+    incrementDate(deltaInput) {
+        let state = this.getCurrentData();
+        let delta = createDuration(deltaInput);
+        if (delta) { // else, warn about invalid input?
+            this.unselect();
+            this.dispatch({
+                type: 'CHANGE_DATE',
+                dateMarker: state.dateEnv.add(state.currentDate, delta),
+            });
+        }
+    }
+    getDate() {
+        let state = this.getCurrentData();
+        return state.dateEnv.toDate(state.currentDate);
+    }
+    // Date Formatting Utils
+    // -----------------------------------------------------------------------------------------------------------------
+    formatDate(d, formatter) {
+        let { dateEnv } = this.getCurrentData();
+        return dateEnv.format(dateEnv.createMarker(d), createFormatter(formatter));
+    }
+    // `settings` is for formatter AND isEndExclusive
+    formatRange(d0, d1, settings) {
+        let { dateEnv } = this.getCurrentData();
+        return dateEnv.formatRange(dateEnv.createMarker(d0), dateEnv.createMarker(d1), createFormatter(settings), settings);
+    }
+    formatIso(d, omitTime) {
+        let { dateEnv } = this.getCurrentData();
+        return dateEnv.formatIso(dateEnv.createMarker(d), { omitTime });
+    }
+    // Date Selection / Event Selection / DayClick
+    // -----------------------------------------------------------------------------------------------------------------
+    select(dateOrObj, endDate) {
+        let selectionInput;
+        if (endDate == null) {
+            if (dateOrObj.start != null) {
+                selectionInput = dateOrObj;
+            }
+            else {
+                selectionInput = {
+                    start: dateOrObj,
+                    end: null,
+                };
+            }
+        }
+        else {
+            selectionInput = {
+                start: dateOrObj,
+                end: endDate,
+            };
+        }
+        let state = this.getCurrentData();
+        let selection = parseDateSpan(selectionInput, state.dateEnv, createDuration({ days: 1 }));
+        if (selection) { // throw parse error otherwise?
+            this.dispatch({ type: 'SELECT_DATES', selection });
+            triggerDateSelect(selection, null, state);
+        }
+    }
+    unselect(pev) {
+        let state = this.getCurrentData();
+        if (state.dateSelection) {
+            this.dispatch({ type: 'UNSELECT_DATES' });
+            triggerDateUnselect(pev, state);
+        }
+    }
+    // Public Events API
+    // -----------------------------------------------------------------------------------------------------------------
+    addEvent(eventInput, sourceInput) {
+        if (eventInput instanceof EventImpl) {
+            let def = eventInput._def;
+            let instance = eventInput._instance;
+            let currentData = this.getCurrentData();
+            // not already present? don't want to add an old snapshot
+            if (!currentData.eventStore.defs[def.defId]) {
+                this.dispatch({
+                    type: 'ADD_EVENTS',
+                    eventStore: eventTupleToStore({ def, instance }), // TODO: better util for two args?
+                });
+                this.triggerEventAdd(eventInput);
+            }
+            return eventInput;
+        }
+        let state = this.getCurrentData();
+        let eventSource;
+        if (sourceInput instanceof EventSourceImpl) {
+            eventSource = sourceInput.internalEventSource;
+        }
+        else if (typeof sourceInput === 'boolean') {
+            if (sourceInput) { // true. part of the first event source
+                [eventSource] = hashValuesToArray(state.eventSources);
+            }
+        }
+        else if (sourceInput != null) { // an ID. accepts a number too
+            let sourceApi = this.getEventSourceById(sourceInput); // TODO: use an internal function
+            if (!sourceApi) {
+                console.warn(`Could not find an event source with ID "${sourceInput}"`); // TODO: test
+                return null;
+            }
+            eventSource = sourceApi.internalEventSource;
+        }
+        let tuple = parseEvent(eventInput, eventSource, state, false);
+        if (tuple) {
+            let newEventApi = new EventImpl(state, tuple.def, tuple.def.recurringDef ? null : tuple.instance);
+            this.dispatch({
+                type: 'ADD_EVENTS',
+                eventStore: eventTupleToStore(tuple),
             });
+            this.triggerEventAdd(newEventApi);
+            return newEventApi;
         }
+        return null;
     }
-}
-
-class MorePopover extends DateComponent {
-    constructor() {
-        super(...arguments);
-        this.handleRootEl = (rootEl) => {
-            this.rootEl = rootEl;
-            if (rootEl) {
-                this.context.registerInteractiveComponent(this, {
-                    el: rootEl,
-                    useEventCenter: false,
+    triggerEventAdd(eventApi) {
+        let { emitter } = this.getCurrentData();
+        emitter.trigger('eventAdd', {
+            event: eventApi,
+            relatedEvents: [],
+            revert: () => {
+                this.dispatch({
+                    type: 'REMOVE_EVENTS',
+                    eventStore: eventApiToStore(eventApi),
                 });
+            },
+        });
+    }
+    // TODO: optimize
+    getEventById(id) {
+        let state = this.getCurrentData();
+        let { defs, instances } = state.eventStore;
+        id = String(id);
+        for (let defId in defs) {
+            let def = defs[defId];
+            if (def.publicId === id) {
+                if (def.recurringDef) {
+                    return new EventImpl(state, def, null);
+                }
+                for (let instanceId in instances) {
+                    let instance = instances[instanceId];
+                    if (instance.defId === def.defId) {
+                        return new EventImpl(state, def, instance);
+                    }
+                }
             }
-            else {
-                this.context.unregisterInteractiveComponent(this);
-            }
-        };
+        }
+        return null;
     }
-    render() {
-        let { options, dateEnv } = this.context;
-        let { props } = this;
-        let { startDate, todayRange, dateProfile } = props;
-        let title = dateEnv.format(startDate, options.dayPopoverFormat);
-        return (preact.createElement(DayCellContainer, { elRef: this.handleRootEl, date: startDate, dateProfile: dateProfile, todayRange: todayRange }, (InnerContent, renderProps, elAttrs) => (preact.createElement(Popover, { elRef: elAttrs.ref, id: props.id, title: title, extraClassNames: ['fc-more-popover'].concat(elAttrs.className || []), extraAttrs: elAttrs /* TODO: make these time-based when not whole-day? */, parentEl: props.parentEl, alignmentEl: props.alignmentEl, alignGridTop: props.alignGridTop, onClose: props.onClose },
-            hasCustomDayCellContent(options) && (preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-more-popover-misc'] })),
-            props.children))));
+    getEvents() {
+        let currentData = this.getCurrentData();
+        return buildEventApis(currentData.eventStore, currentData);
     }
-    queryHit(positionLeft, positionTop, elWidth, elHeight) {
-        let { rootEl, props } = this;
-        if (positionLeft >= 0 && positionLeft < elWidth &&
-            positionTop >= 0 && positionTop < elHeight) {
-            return {
-                dateProfile: props.dateProfile,
-                dateSpan: Object.assign({ allDay: !props.forceTimed, range: {
-                        start: props.startDate,
-                        end: props.endDate,
-                    } }, props.extraDateSpan),
-                dayEl: rootEl,
-                rect: {
-                    left: 0,
-                    top: 0,
-                    right: elWidth,
-                    bottom: elHeight,
-                },
-                layer: 1, // important when comparing with hits from other components
-            };
+    removeAllEvents() {
+        this.dispatch({ type: 'REMOVE_ALL_EVENTS' });
+    }
+    // Public Event Sources API
+    // -----------------------------------------------------------------------------------------------------------------
+    getEventSources() {
+        let state = this.getCurrentData();
+        let sourceHash = state.eventSources;
+        let sourceApis = [];
+        for (let internalId in sourceHash) {
+            sourceApis.push(new EventSourceImpl(state, sourceHash[internalId]));
         }
-        return null;
+        return sourceApis;
     }
-}
-
-class MoreLinkContainer extends BaseComponent {
-    constructor() {
-        super(...arguments);
-        this.state = {
-            isPopoverOpen: false,
-            popoverId: getUniqueDomId(),
-        };
-        this.handleLinkEl = (linkEl) => {
-            this.linkEl = linkEl;
-            if (this.props.elRef) {
-                setRef(this.props.elRef, linkEl);
-            }
-        };
-        this.handleClick = (ev) => {
-            let { props, context } = this;
-            let { moreLinkClick } = context.options;
-            let date = computeRange(props).start;
-            function buildPublicSeg(seg) {
-                let { def, instance, range } = seg.eventRange;
-                return {
-                    event: new EventImpl(context, def, instance),
-                    start: context.dateEnv.toDate(range.start),
-                    end: context.dateEnv.toDate(range.end),
-                    isStart: seg.isStart,
-                    isEnd: seg.isEnd,
-                };
+    getEventSourceById(id) {
+        let state = this.getCurrentData();
+        let sourceHash = state.eventSources;
+        id = String(id);
+        for (let sourceId in sourceHash) {
+            if (sourceHash[sourceId].publicId === id) {
+                return new EventSourceImpl(state, sourceHash[sourceId]);
             }
-            if (typeof moreLinkClick === 'function') {
-                moreLinkClick = moreLinkClick({
-                    date,
-                    allDay: Boolean(props.allDayDate),
-                    allSegs: props.allSegs.map(buildPublicSeg),
-                    hiddenSegs: props.hiddenSegs.map(buildPublicSeg),
-                    jsEvent: ev,
-                    view: context.viewApi,
+        }
+        return null;
+    }
+    addEventSource(sourceInput) {
+        let state = this.getCurrentData();
+        if (sourceInput instanceof EventSourceImpl) {
+            // not already present? don't want to add an old snapshot
+            if (!state.eventSources[sourceInput.internalEventSource.sourceId]) {
+                this.dispatch({
+                    type: 'ADD_EVENT_SOURCES',
+                    sources: [sourceInput.internalEventSource],
                 });
             }
-            if (!moreLinkClick || moreLinkClick === 'popover') {
-                this.setState({ isPopoverOpen: true });
-            }
-            else if (typeof moreLinkClick === 'string') { // a view name
-                context.calendarApi.zoomTo(date, moreLinkClick);
-            }
-        };
-        this.handlePopoverClose = () => {
-            this.setState({ isPopoverOpen: false });
-        };
-    }
-    render() {
-        let { props, state } = this;
-        return (preact.createElement(ViewContextType.Consumer, null, (context) => {
-            let { viewApi, options, calendarApi } = context;
-            let { moreLinkText } = options;
-            let { moreCnt } = props;
-            let range = computeRange(props);
-            let text = typeof moreLinkText === 'function' // TODO: eventually use formatWithOrdinals
-                ? moreLinkText.call(calendarApi, moreCnt)
-                : `+${moreCnt} ${moreLinkText}`;
-            let hint = formatWithOrdinals(options.moreLinkHint, [moreCnt], text);
-            let renderProps = {
-                num: moreCnt,
-                shortText: `+${moreCnt}`,
-                text,
-                view: viewApi,
-            };
-            return (preact.createElement(preact.Fragment, null,
-                Boolean(props.moreCnt) && (preact.createElement(ContentContainer, { elTag: props.elTag || 'a', elRef: this.handleLinkEl, elClasses: [
-                        ...(props.elClasses || []),
-                        'fc-more-link',
-                    ], elStyle: props.elStyle, elAttrs: Object.assign(Object.assign(Object.assign({}, props.elAttrs), createAriaClickAttrs(this.handleClick)), { title: hint, 'aria-expanded': state.isPopoverOpen, 'aria-controls': state.isPopoverOpen ? state.popoverId : '' }), renderProps: renderProps, generatorName: "moreLinkContent", customGenerator: options.moreLinkContent, defaultGenerator: props.defaultGenerator || renderMoreLinkInner, classNameGenerator: options.moreLinkClassNames, didMount: options.moreLinkDidMount, willUnmount: options.moreLinkWillUnmount }, props.children)),
-                state.isPopoverOpen && (preact.createElement(MorePopover, { id: state.popoverId, startDate: range.start, endDate: range.end, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: props.extraDateSpan, parentEl: this.parentEl, alignmentEl: props.alignmentElRef ?
-                        props.alignmentElRef.current :
-                        this.linkEl, alignGridTop: props.alignGridTop, forceTimed: props.forceTimed, onClose: this.handlePopoverClose }, props.popoverContent()))));
-        }));
+            return sourceInput;
+        }
+        let eventSource = parseEventSource(sourceInput, state);
+        if (eventSource) { // TODO: error otherwise?
+            this.dispatch({ type: 'ADD_EVENT_SOURCES', sources: [eventSource] });
+            return new EventSourceImpl(state, eventSource);
+        }
+        return null;
     }
-    componentDidMount() {
-        this.updateParentEl();
+    removeAllEventSources() {
+        this.dispatch({ type: 'REMOVE_ALL_EVENT_SOURCES' });
     }
-    componentDidUpdate() {
-        this.updateParentEl();
+    refetchEvents() {
+        this.dispatch({ type: 'FETCH_EVENT_SOURCES', isRefetch: true });
     }
-    updateParentEl() {
-        if (this.linkEl) {
-            this.parentEl = elementClosest(this.linkEl, '.fc-view-harness');
+    // Scroll
+    // -----------------------------------------------------------------------------------------------------------------
+    scrollToTime(timeInput) {
+        let time = createDuration(timeInput);
+        if (time) {
+            this.trigger('_timeScrollRequest', time);
         }
     }
 }
-function renderMoreLinkInner(props) {
-    return props.text;
-}
-function computeRange(props) {
-    if (props.allDayDate) {
-        return {
-            start: props.allDayDate,
-            end: addDays(props.allDayDate, 1),
-        };
-    }
-    let { hiddenSegs } = props;
-    return {
-        start: computeEarliestSegStart(hiddenSegs),
-        end: computeLatestSegEnd(hiddenSegs),
-    };
-}
-function computeEarliestSegStart(segs) {
-    return segs.reduce(pickEarliestStart).eventRange.range.start;
-}
-function pickEarliestStart(seg0, seg1) {
-    return seg0.eventRange.range.start < seg1.eventRange.range.start ? seg0 : seg1;
-}
-function computeLatestSegEnd(segs) {
-    return segs.reduce(pickLatestEnd).eventRange.range.end;
-}
-function pickLatestEnd(seg0, seg1) {
-    return seg0.eventRange.range.end > seg1.eventRange.range.end ? seg0 : seg1;
-}
 
 class Store {
     constructor() {
@@ -7520,7 +7352,6 @@ exports.DateComponent = DateComponent;
 exports.DateEnv = DateEnv;
 exports.DateProfileGenerator = DateProfileGenerator;
 exports.DayCellContainer = DayCellContainer;
-exports.DayHeader = DayHeader;
 exports.DaySeriesModel = DaySeriesModel;
 exports.DayTableModel = DayTableModel;
 exports.DelayedRunner = DelayedRunner;
@@ -7540,15 +7371,11 @@ exports.PureComponent = PureComponent;
 exports.RefMap = RefMap;
 exports.RenderId = RenderId;
 exports.ScrollController = ScrollController;
-exports.ScrollResponder = ScrollResponder;
 exports.Scroller = Scroller;
 exports.SegHierarchy = SegHierarchy;
-exports.SimpleScrollGrid = SimpleScrollGrid;
 exports.Slicer = Slicer;
 exports.Splitter = Splitter;
 exports.StandardEvent = StandardEvent;
-exports.TableDateCell = TableDateCell;
-exports.TableDowCell = TableDowCell;
 exports.Theme = Theme;
 exports.VIEW_OPTION_REFINERS = VIEW_OPTION_REFINERS;
 exports.ViewContainer = ViewContainer;
@@ -7559,6 +7386,7 @@ exports.addDays = addDays;
 exports.addDurations = addDurations;
 exports.addMs = addMs;
 exports.addWeeks = addWeeks;
+exports.afterSize = afterSize;
 exports.allowContextMenu = allowContextMenu;
 exports.allowSelection = allowSelection;
 exports.applyMutationToEventStore = applyMutationToEventStore;
@@ -7574,11 +7402,11 @@ exports.buildElAttrs = buildElAttrs;
 exports.buildEntryKey = buildEntryKey;
 exports.buildEventApis = buildEventApis;
 exports.buildEventRangeKey = buildEventRangeKey;
+exports.buildEventRangeTimeText = buildEventRangeTimeText;
 exports.buildEventSourceRefiners = buildEventSourceRefiners;
 exports.buildIsoString = buildIsoString;
 exports.buildNavLinkAttrs = buildNavLinkAttrs;
 exports.buildRangeApiWithTimeZone = buildRangeApiWithTimeZone;
-exports.buildSegTimeText = buildSegTimeText;
 exports.buildViewClassNames = buildViewClassNames;
 exports.buildViewContext = buildViewContext;
 exports.collectFromHash = collectFromHash;
@@ -7588,10 +7416,8 @@ exports.compareNumbers = compareNumbers;
 exports.compareObjs = compareObjs;
 exports.computeEarliestSegStart = computeEarliestSegStart;
 exports.computeEdges = computeEdges;
-exports.computeFallbackHeaderFormat = computeFallbackHeaderFormat;
 exports.computeInnerRect = computeInnerRect;
 exports.computeRect = computeRect;
-exports.computeShrinkWidth = computeShrinkWidth;
 exports.computeVisibleDayRange = computeVisibleDayRange;
 exports.config = config;
 exports.constrainPoint = constrainPoint;
@@ -7623,26 +7449,25 @@ exports.formatDayString = formatDayString;
 exports.formatIsoMonthStr = formatIsoMonthStr;
 exports.formatIsoTimeString = formatIsoTimeString;
 exports.formatWithOrdinals = formatWithOrdinals;
-exports.getAllowYScrolling = getAllowYScrolling;
-exports.getCanVGrowWithinCell = getCanVGrowWithinCell;
+exports.fracToCssDim = fracToCssDim;
 exports.getClippingParents = getClippingParents;
 exports.getDateMeta = getDateMeta;
 exports.getDayClassNames = getDayClassNames;
 exports.getDefaultEventEnd = getDefaultEventEnd;
-exports.getElSeg = getElSeg;
+exports.getElEventRange = getElEventRange;
 exports.getEntrySpanEnd = getEntrySpanEnd;
+exports.getEventRangeAnchorAttrs = getEventRangeAnchorAttrs;
+exports.getEventRangeMeta = getEventRangeMeta;
 exports.getEventTargetViaRoot = getEventTargetViaRoot;
 exports.getInitialDate = getInitialDate;
+exports.getIsHeightAuto = getIsHeightAuto;
 exports.getIsRtlScrollbarOnLeft = getIsRtlScrollbarOnLeft;
+exports.getNormalizedScrollX = getNormalizedScrollX;
 exports.getNow = getNow;
 exports.getRectCenter = getRectCenter;
 exports.getRelevantEvents = getRelevantEvents;
-exports.getScrollGridClassNames = getScrollGridClassNames;
 exports.getScrollbarWidths = getScrollbarWidths;
-exports.getSectionClassNames = getSectionClassNames;
-exports.getSectionHasLiquidHeight = getSectionHasLiquidHeight;
-exports.getSegAnchorAttrs = getSegAnchorAttrs;
-exports.getSegMeta = getSegMeta;
+exports.getScrollerSyncerClass = getScrollerSyncerClass;
 exports.getSlotClassNames = getSlotClassNames;
 exports.getStickyFooterScrollbar = getStickyFooterScrollbar;
 exports.getStickyHeaderDates = getStickyHeaderDates;
@@ -7652,7 +7477,6 @@ exports.groupIntersectingEntries = groupIntersectingEntries;
 exports.guid = guid;
 exports.hasBgRendering = hasBgRendering;
 exports.hasCustomDayCellContent = hasCustomDayCellContent;
-exports.hasShrinkWidth = hasShrinkWidth;
 exports.hashValuesToArray = hashValuesToArray;
 exports.identity = identity;
 exports.injectStyles = injectStyles;
@@ -7662,9 +7486,10 @@ exports.intersectRanges = intersectRanges;
 exports.intersectRects = intersectRects;
 exports.intersectSpans = intersectSpans;
 exports.isArraysEqual = isArraysEqual;
-exports.isColPropsEqual = isColPropsEqual;
 exports.isDateSelectionValid = isDateSelectionValid;
 exports.isDateSpansEqual = isDateSpansEqual;
+exports.isDimMapsEqual = isDimMapsEqual;
+exports.isDimsEqual = isDimsEqual;
 exports.isInt = isInt;
 exports.isInteractionValid = isInteractionValid;
 exports.isMultiDayRange = isMultiDayRange;
@@ -7705,14 +7530,12 @@ exports.refineEventDef = refineEventDef;
 exports.refineProps = refineProps;
 exports.removeElement = removeElement;
 exports.removeExact = removeExact;
-exports.renderChunkContent = renderChunkContent;
 exports.renderFill = renderFill;
-exports.renderMicroColGroup = renderMicroColGroup;
-exports.renderScrollShim = renderScrollShim;
 exports.requestJson = requestJson;
 exports.rezoneEventStoreDates = rezoneEventStoreDates;
-exports.sanitizeShrinkWidth = sanitizeShrinkWidth;
+exports.setNormalizedScrollX = setNormalizedScrollX;
 exports.setRef = setRef;
+exports.setStateDimMap = setStateDimMap;
 exports.sliceEventStore = sliceEventStore;
 exports.sortEventSegs = sortEventSegs;
 exports.startOfDay = startOfDay;
@@ -7720,5 +7543,8 @@ exports.subtractDurations = subtractDurations;
 exports.translateRect = translateRect;
 exports.triggerDateSelect = triggerDateSelect;
 exports.unpromisify = unpromisify;
+exports.watchHeight = watchHeight;
+exports.watchSize = watchSize;
+exports.watchWidth = watchWidth;
 exports.whenTransitionDone = whenTransitionDone;
 exports.wholeDivideDurations = wholeDivideDurations;