@fullcalendar/core 6.1.15 → 7.0.0-beta.1

package/internal-common.js

@@ -1,5 +1,5 @@
 import * as preact from 'preact';
-import { Component, createElement, isValidElement, Fragment } from 'preact';
+import { Component, createElement, isValidElement, Fragment, createRef } from 'preact';
 import { createPortal } from 'preact/compat';
 
 const styleTexts = [];
@@ -82,7 +82,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 {
@@ -444,20 +444,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))?)?/;
@@ -1370,8 +1356,6 @@ const BASE_OPTION_REFINERS = {
     dropAccept: identity,
     eventOrder: parseFieldSpecs,
     eventOrderStrict: Boolean,
-    handleWindowResize: Boolean,
-    windowResizeDelay: Number,
     longPressDelay: Number,
     eventDragMinDistance: Number,
     expandRows: Boolean,
@@ -1521,8 +1505,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,
@@ -1541,7 +1523,6 @@ const CALENDAR_LISTENER_REFINERS = {
     eventAdd: identity,
     eventChange: identity,
     eventRemove: identity,
-    windowResize: identity,
     eventClick: identity,
     eventMouseEnter: identity,
     eventMouseLeave: identity,
@@ -1554,8 +1535,7 @@ const CALENDAR_LISTENER_REFINERS = {
     _afterprint: identity,
     _noEventDrop: identity,
     _noEventResize: identity,
-    _resize: identity,
-    _scrollRequest: identity,
+    _timeScrollRequest: identity,
 };
 // calendar-specific options
 // -------------------------
@@ -2225,6 +2205,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.options.debounceRendering; // orig
@@ -2274,42 +2257,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 {
@@ -2325,15 +2272,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,
     };
@@ -3396,6 +3334,9 @@ function parseClassNames(raw) {
     }
     return [];
 }
+function fracToCssDim(frac) {
+    return frac * 100 + '%';
+}
 
 // TODO: better called "EventSettings" or "EventConfig"
 // TODO: move this file into structs
@@ -4335,12 +4276,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
@@ -4360,7 +4301,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
@@ -4373,29 +4314,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;
     }
@@ -4404,8 +4339,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)) {
@@ -4423,8 +4358,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),
@@ -4474,8 +4409,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 };
@@ -4655,33 +4590,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);
@@ -4700,21 +4608,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;
@@ -4752,978 +4655,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
     // -----------------------------------------------------------------------------------------------------------------
@@ -5753,440 +5373,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 (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 createPortal(createElement("div", Object.assign({}, props.extraAttrs, { id: props.id, className: classNames.join(' '), "aria-labelledby": state.titleId, ref: this.handleRootEl }),
+            createElement("div", { className: 'fc-popover-header ' + theme.getClass('popoverHeader') },
+                createElement("span", { className: "fc-popover-title", id: state.titleId }, props.title),
+                createElement("span", { className: 'fc-popover-close ' + theme.getIconClass('close'), title: options.closeHint, onClick: this.handleCloseClick })),
+            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 (createElement(DayCellContainer, { elRef: this.handleRootEl, date: startDate, dateProfile: dateProfile, todayRange: todayRange }, (InnerContent, renderProps, elAttrs) => (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) && (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 (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 (createElement(Fragment, null,
+                Boolean(moreCnt) && (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 && (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 (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) => (createElement("div", { className: "fc-scrollgrid-sync-inner" }, !dayMeta.isDisabled && (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 (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) => (createElement("div", { className: "fc-scrollgrid-sync-inner" },
-            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 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 (createElement(NowTimer, { unit: "day" }, (nowDate, todayRange) => (createElement("tr", { role: "row" },
-            renderIntro && renderIntro('day'),
-            dates.map((date) => (datesRepDistinctDays ? (createElement(TableDateCell, { key: date.toISOString(), date: date, dateProfile: dateProfile, todayRange: todayRange, colCnt: dates.length, dayHeaderFormat: dayHeaderFormat })) : (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 {
@@ -6270,7 +6053,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() {
@@ -6294,7 +6077,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;
     }
@@ -6322,18 +6105,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 = 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 (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),
@@ -6624,423 +6661,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 (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) :
-        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, 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(createElement("col", { style: {
-                    width: colProps.width === 'shrink' ? sanitizeShrinkWidth(shrinkWidth) : (colProps.width || ''),
-                    minWidth: colProps.minWidth || '',
-                } }));
-        }
-    }
-    return 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 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 (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 createElement('table', {
-            role: 'grid',
-            className: classNames.join(' '),
-            style: { height: props.height },
-        }, Boolean(!isBuggy && headSectionNodes.length) && createElement('thead', roleAttrs, ...headSectionNodes), Boolean(!isBuggy && bodySectionNodes.length) && createElement('tbody', roleAttrs, ...bodySectionNodes), Boolean(!isBuggy && footSectionNodes.length) && createElement('tfoot', roleAttrs, ...footSectionNodes), isBuggy && createElement('tbody', roleAttrs, ...headSectionNodes, ...bodySectionNodes, ...footSectionNodes));
-    }
-    renderSection(sectionConfig, microColGroupNode, isHeader) {
-        if ('outerContent' in sectionConfig) {
-            return (createElement(Fragment, { key: sectionConfig.key }, sectionConfig.outerContent));
-        }
-        return (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 createElement(isHeader ? 'th' : 'td', {
-            ref: chunkConfig.elRef,
-            role: 'presentation',
-        }, createElement("div", { className: `fc-scroller-harness${isLiquid ? ' fc-scroller-harness-liquid' : ''}` },
-            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 {
@@ -7049,15 +6787,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),
@@ -7066,12 +6803,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),
@@ -7081,13 +6818,13 @@ class EventContainer extends BaseComponent {
         };
         return (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);
         }
     }
 }
@@ -7097,24 +6834,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 (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) => (createElement(Fragment, null,
-            createElement(InnerContent, { elTag: "div", elClasses: ['fc-event-main'], elStyle: { color: eventContentArg.textColor } }),
+            }, elAttrs: getEventRangeAnchorAttrs(eventRange, context), defaultGenerator: renderInnerContent$1, timeText: timeText }), (InnerContent, eventContentArg) => (createElement(Fragment, null,
+            createElement(InnerContent, { elTag: "div", elClasses: ['fc-event-inner'], elStyle: { color: eventContentArg.textColor } }),
             Boolean(eventContentArg.isStartResizable) && (createElement("div", { className: "fc-event-resizer fc-event-resizer-start" })),
             Boolean(eventContentArg.isEndResizable) && (createElement("div", { className: "fc-event-resizer fc-event-resizer-end" }))))));
     }
 }
 function renderInnerContent$1(innerProps) {
-    return (createElement("div", { className: "fc-event-main-frame" },
+    return (createElement(Fragment, null,
         innerProps.timeText && (createElement("div", { className: "fc-event-time" }, innerProps.timeText)),
-        createElement("div", { className: "fc-event-title-container" },
-            createElement("div", { className: "fc-event-title fc-sticky" }, innerProps.event.title || createElement(Fragment, null, "\u00A0")))));
+        createElement("div", { className: "fc-event-title-outer" },
+            createElement("div", { className: "fc-event-title" }, innerProps.event.title || createElement(Fragment, null, "\u00A0")))));
 }
 
 const NowIndicatorContainer = (props) => (createElement(ViewContextType.Consumer, null, (context) => {
@@ -7127,50 +6864,11 @@ const NowIndicatorContainer = (props) => (createElement(ViewContextType.Consumer
     return (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 (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 (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 (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) {
@@ -7195,250 +6893,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 createPortal(createElement("div", Object.assign({}, props.extraAttrs, { id: props.id, className: classNames.join(' '), "aria-labelledby": state.titleId, ref: this.handleRootEl }),
-            createElement("div", { className: 'fc-popover-header ' + theme.getClass('popoverHeader') },
-                createElement("span", { className: "fc-popover-title", id: state.titleId }, props.title),
-                createElement("span", { className: 'fc-popover-close ' + theme.getIconClass('close'), title: options.closeHint, onClick: this.handleCloseClick })),
-            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 (createElement(DayCellContainer, { elRef: this.handleRootEl, date: startDate, dateProfile: dateProfile, todayRange: todayRange }, (InnerContent, renderProps, elAttrs) => (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) && (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 (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 (createElement(Fragment, null,
-                Boolean(props.moreCnt) && (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 && (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() {
@@ -7484,4 +7316,4 @@ class CustomRenderingStore extends Store {
     }
 }
 
-export { elementClosest as $, memoizeObjArg as A, BaseComponent as B, ContentContainer as C, DelayedRunner as D, isPropsEqual as E, Emitter as F, getInitialDate as G, rangeContainsMarker as H, createEmptyEventStore as I, reduceCurrentDate as J, reduceEventStore as K, rezoneEventStoreDates as L, mergeRawOptions as M, BASE_OPTION_REFINERS as N, CALENDAR_LISTENER_REFINERS as O, CALENDAR_OPTION_REFINERS as P, COMPLEX_OPTION_COMPARATORS as Q, VIEW_OPTION_REFINERS as R, DateEnv as S, Theme as T, DateProfileGenerator as U, ViewContextType as V, createEventUi as W, parseBusinessHours as X, setRef as Y, Interaction as Z, getElSeg as _, mapHash as a, getSlotClassNames as a$, EventImpl as a0, listenBySelector as a1, listenToHoverBySelector as a2, PureComponent as a3, buildViewContext as a4, getUniqueDomId as a5, parseInteractionSettings as a6, interactionSettingsStore as a7, getNow as a8, CalendarImpl as a9, diffDates as aA, removeExact as aB, memoizeArraylike as aC, memoizeHashlike as aD, intersectRects as aE, pointInsideRect as aF, constrainPoint as aG, getRectCenter as aH, diffPoints as aI, translateRect as aJ, compareObjs as aK, collectFromHash as aL, findElements as aM, findDirectChildren as aN, removeElement as aO, applyStyle as aP, elementMatches as aQ, getEventTargetViaRoot as aR, parseClassNames as aS, getCanVGrowWithinCell as aT, mergeEventStores as aU, getRelevantEvents as aV, eventTupleToStore as aW, combineEventUis as aX, Splitter as aY, getDayClassNames as aZ, getDateMeta as a_, flushSync as aa, CalendarRoot as ab, RenderId as ac, ensureElHasStyles as ad, applyStyleProp as ae, sliceEventStore as af, JsonRequestError as ag, createContext as ah, refineProps as ai, createEventInstance as aj, parseEventDef as ak, refineEventDef as al, padStart as am, isInt as an, parseFieldSpecs as ao, compareByFieldSpecs as ap, flexibleCompare as aq, preventSelection as ar, allowSelection as as, preventContextMenu as at, allowContextMenu as au, compareNumbers as av, enableCursor as aw, disableCursor as ax, computeVisibleDayRange as ay, isMultiDayRange as az, buildViewClassNames as b, SimpleScrollGrid as b$, buildNavLinkAttrs as b0, preventDefault as b1, whenTransitionDone as b2, computeInnerRect as b3, computeEdges as b4, getClippingParents as b5, computeRect as b6, rangesEqual as b7, rangesIntersect as b8, rangeContainsRange as b9, SegHierarchy as bA, buildEntryKey as bB, getEntrySpanEnd as bC, binarySearch as bD, groupIntersectingEntries as bE, intersectSpans as bF, interactionSettingsToStore as bG, ElementDragging as bH, config as bI, parseDragMeta as bJ, DayHeader as bK, computeFallbackHeaderFormat as bL, TableDateCell as bM, TableDowCell as bN, DaySeriesModel as bO, hasBgRendering as bP, buildSegTimeText as bQ, sortEventSegs as bR, getSegMeta as bS, buildEventRangeKey as bT, getSegAnchorAttrs as bU, DayTableModel as bV, Slicer as bW, applyMutationToEventStore as bX, isPropsValid as bY, isInteractionValid as bZ, isDateSelectionValid as b_, PositionCache as ba, ScrollController as bb, ElementScrollController as bc, WindowScrollController as bd, DateComponent as be, isDateSpansEqual as bf, addMs as bg, addWeeks as bh, diffWeeks as bi, diffWholeWeeks as bj, diffDayAndTime as bk, diffDays as bl, isValidDate as bm, asCleanDays as bn, multiplyDuration as bo, addDurations as bp, asRoughMinutes as bq, asRoughSeconds as br, asRoughMs as bs, wholeDivideDurations as bt, formatIsoTimeString as bu, formatDayString as bv, buildIsoString as bw, formatIsoMonthStr as bx, NamedTimeZoneImpl as by, parse as bz, greatestDurationDenominator as c, hasShrinkWidth as c0, renderMicroColGroup as c1, getScrollGridClassNames as c2, getSectionClassNames as c3, getSectionHasLiquidHeight as c4, getAllowYScrolling as c5, renderChunkContent as c6, computeShrinkWidth as c7, sanitizeShrinkWidth as c8, isColPropsEqual as c9, renderScrollShim as ca, getStickyFooterScrollbar as cb, getStickyHeaderDates as cc, Scroller as cd, getScrollbarWidths as ce, RefMap as cf, getIsRtlScrollbarOnLeft as cg, NowTimer as ch, ScrollResponder as ci, StandardEvent as cj, NowIndicatorContainer as ck, DayCellContainer as cl, hasCustomDayCellContent as cm, EventContainer as cn, renderFill as co, BgEvent as cp, WeekNumberContainer as cq, MoreLinkContainer as cr, computeEarliestSegStart as cs, ViewContainer as ct, triggerDateSelect as cu, getDefaultEventEnd as cv, injectStyles as cw, buildElAttrs as cx, CustomRenderingStore as cy, createDuration as d, BASE_OPTION_DEFAULTS as e, arrayToHash as f, guid as g, filterHash as h, isArraysEqual as i, buildEventSourceRefiners as j, formatWithOrdinals as k, buildRangeApiWithTimeZone as l, mergeProps as m, identity as n, intersectRanges as o, parseEventSource as p, startOfDay as q, requestJson as r, subtractDurations as s, addDays as t, unpromisify as u, hashValuesToArray as v, buildEventApis as w, createFormatter as x, diffWholeDays as y, memoize as z };
+export { EventImpl as $, memoizeObjArg as A, BaseComponent as B, ContentContainer as C, DelayedRunner as D, isPropsEqual as E, Emitter as F, getInitialDate as G, rangeContainsMarker as H, createEmptyEventStore as I, reduceCurrentDate as J, reduceEventStore as K, rezoneEventStoreDates as L, mergeRawOptions as M, BASE_OPTION_REFINERS as N, CALENDAR_LISTENER_REFINERS as O, CALENDAR_OPTION_REFINERS as P, COMPLEX_OPTION_COMPARATORS as Q, VIEW_OPTION_REFINERS as R, DateEnv as S, Theme as T, DateProfileGenerator as U, ViewContextType as V, createEventUi as W, parseBusinessHours as X, Interaction as Y, getElEventRange as Z, elementClosest as _, mapHash as a, getSlotClassNames as a$, listenBySelector as a0, listenToHoverBySelector as a1, PureComponent as a2, buildViewContext as a3, parseInteractionSettings as a4, interactionSettingsStore as a5, getNow as a6, getIsHeightAuto as a7, CalendarImpl as a8, flushSync as a9, removeExact as aA, memoizeArraylike as aB, memoizeHashlike as aC, intersectRects as aD, pointInsideRect as aE, constrainPoint as aF, getRectCenter as aG, diffPoints as aH, translateRect as aI, compareObjs as aJ, collectFromHash as aK, findElements as aL, findDirectChildren as aM, removeElement as aN, applyStyle as aO, elementMatches as aP, getEventTargetViaRoot as aQ, getUniqueDomId as aR, parseClassNames as aS, fracToCssDim as aT, mergeEventStores as aU, getRelevantEvents as aV, eventTupleToStore as aW, combineEventUis as aX, Splitter as aY, getDayClassNames as aZ, getDateMeta as a_, CalendarRoot as aa, RenderId as ab, ensureElHasStyles as ac, applyStyleProp as ad, sliceEventStore as ae, JsonRequestError as af, createContext as ag, refineProps as ah, createEventInstance as ai, parseEventDef as aj, refineEventDef as ak, padStart as al, isInt as am, parseFieldSpecs as an, compareByFieldSpecs as ao, flexibleCompare as ap, preventSelection as aq, allowSelection as ar, preventContextMenu as as, allowContextMenu as at, compareNumbers as au, enableCursor as av, disableCursor as aw, computeVisibleDayRange as ax, isMultiDayRange as ay, diffDates as az, buildViewClassNames as b, setNormalizedScrollX as b$, setStateDimMap as b0, isDimMapsEqual as b1, isDimsEqual as b2, watchSize as b3, watchWidth as b4, watchHeight as b5, afterSize as b6, buildNavLinkAttrs as b7, preventDefault as b8, whenTransitionDone as b9, wholeDivideDurations as bA, formatIsoTimeString as bB, formatDayString as bC, buildIsoString as bD, formatIsoMonthStr as bE, NamedTimeZoneImpl as bF, parse as bG, SegHierarchy as bH, buildEntryKey as bI, getEntrySpanEnd as bJ, binarySearch as bK, groupIntersectingEntries as bL, intersectSpans as bM, interactionSettingsToStore as bN, ElementDragging as bO, config as bP, parseDragMeta as bQ, DaySeriesModel as bR, hasBgRendering as bS, buildEventRangeTimeText as bT, sortEventSegs as bU, getEventRangeMeta as bV, buildEventRangeKey as bW, getEventRangeAnchorAttrs as bX, DayTableModel as bY, Scroller as bZ, getNormalizedScrollX as b_, computeInnerRect as ba, computeEdges as bb, getClippingParents as bc, computeRect as bd, rangesEqual as be, rangesIntersect as bf, rangeContainsRange as bg, PositionCache as bh, ScrollController as bi, ElementScrollController as bj, WindowScrollController as bk, DateComponent as bl, isDateSpansEqual as bm, addMs as bn, addWeeks as bo, diffWeeks as bp, diffWholeWeeks as bq, diffDayAndTime as br, diffDays as bs, isValidDate as bt, asCleanDays as bu, multiplyDuration as bv, addDurations as bw, asRoughMinutes as bx, asRoughSeconds as by, asRoughMs as bz, greatestDurationDenominator as c, Slicer as c0, applyMutationToEventStore as c1, isPropsValid as c2, isInteractionValid as c3, isDateSelectionValid as c4, setRef as c5, getStickyFooterScrollbar as c6, getStickyHeaderDates as c7, getScrollerSyncerClass as c8, getScrollbarWidths as c9, RefMap as ca, getIsRtlScrollbarOnLeft as cb, NowTimer as cc, StandardEvent as cd, NowIndicatorContainer as ce, DayCellContainer as cf, hasCustomDayCellContent as cg, EventContainer as ch, renderFill as ci, BgEvent as cj, WeekNumberContainer as ck, MoreLinkContainer as cl, computeEarliestSegStart as cm, ViewContainer as cn, triggerDateSelect as co, getDefaultEventEnd as cp, injectStyles as cq, buildElAttrs as cr, CustomRenderingStore as cs, createDuration as d, BASE_OPTION_DEFAULTS as e, arrayToHash as f, guid as g, filterHash as h, isArraysEqual as i, buildEventSourceRefiners as j, formatWithOrdinals as k, buildRangeApiWithTimeZone as l, mergeProps as m, identity as n, intersectRanges as o, parseEventSource as p, startOfDay as q, requestJson as r, subtractDurations as s, addDays as t, unpromisify as u, hashValuesToArray as v, buildEventApis as w, createFormatter as x, diffWholeDays as y, memoize as z };