@fullcalendar/core 6.0.0 → 6.0.2

package/index.js

@@ -1,11 +1,13 @@
-import { i as injectStyles, g as globalLocales, m as mergeProps, T as Theme, a as mapHash, V as ViewContextType, C as ContentContainer, b as buildViewClassNames, c as greatestDurationDenominator, d as createDuration, B as BASE_OPTION_DEFAULTS, f as formatWithOrdinals, D as DelayedRunner, e as createFormatter, h as diffWholeDays, j as memoize, k as buildBuildPluginHooks, l as memoizeObjArg, n as isPropsEqual, E as Emitter, o as getInitialDate, r as rangeContainsMarker, p as initEventSources, q as createEmptyEventStore, s as reduceCurrentDate, t as reduceEventSources, u as reduceEventStore, v as computeEventSourcesLoading, w as reduceEventSourcesNewTimeZone, x as rezoneEventStoreDates, y as mergeRawOptions, z as globalPlugins, A as BASE_OPTION_REFINERS, F as CALENDAR_LISTENER_REFINERS, G as CALENDAR_OPTION_REFINERS, H as COMPLEX_OPTION_COMPARATORS, I as VIEW_OPTION_REFINERS, J as DateEnv, K as DateProfileGenerator, L as createEventUi, M as parseBusinessHours, N as BaseComponent, O as setRef, P as Interaction, Q as getElSeg, R as elementClosest, S as EventImpl, U as listenBySelector, W as listenToHoverBySelector, X as PureComponent, Y as buildViewContext, Z as getUniqueDomId, _ as parseInteractionSettings, $ as interactionSettingsStore, a0 as getNow, a1 as CalendarImpl, a2 as flushSync, a3 as CalendarRoot, a4 as RenderId, a5 as isArraysEqual, a6 as applyStyleProp, a7 as sliceEventStore } from './internal-common.js';
-export { a9 as JsonRequestError, a8 as createPlugin } from './internal-common.js';
+import { i as injectStyles, m as mergeProps, g as guid, a as isArraysEqual, T as Theme, b as mapHash, V as ViewContextType, C as ContentContainer, c as buildViewClassNames, d as greatestDurationDenominator, e as createDuration, B as BASE_OPTION_DEFAULTS, f as arrayToHash, h as filterHash, j as buildEventSourceRefiners, p as parseEventSource, k as formatWithOrdinals, u as unpromisify, l as buildRangeApiWithTimeZone, n as identity, r as requestJson, s as subtractDurations, o as intersectRanges, q as startOfDay, t as addDays, v as hashValuesToArray, w as buildEventApis, D as DelayedRunner, x as createFormatter, y as diffWholeDays, z as memoize, A as memoizeObjArg, E as isPropsEqual, F as Emitter, G as getInitialDate, H as rangeContainsMarker, I as createEmptyEventStore, J as reduceCurrentDate, K as reduceEventStore, L as rezoneEventStoreDates, M as mergeRawOptions, N as BASE_OPTION_REFINERS, O as CALENDAR_LISTENER_REFINERS, P as CALENDAR_OPTION_REFINERS, Q as COMPLEX_OPTION_COMPARATORS, R as VIEW_OPTION_REFINERS, S as DateEnv, U as DateProfileGenerator, W as createEventUi, X as parseBusinessHours, Y as BaseComponent, Z as setRef, _ as Interaction, $ as getElSeg, a0 as elementClosest, a1 as EventImpl, a2 as listenBySelector, a3 as listenToHoverBySelector, a4 as PureComponent, a5 as buildViewContext, a6 as getUniqueDomId, a7 as parseInteractionSettings, a8 as interactionSettingsStore, a9 as getNow, aa as CalendarImpl, ab as flushSync, ac as CalendarRoot, ad as RenderId, ae as applyStyleProp, af as sliceEventStore } from './internal-common.js';
+export { ag as JsonRequestError } from './internal-common.js';
 import { createElement, createRef, Fragment, render } from 'preact';
 import 'preact/compat';
 
 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-unselectable{-webkit-touch-callout:none;-webkit-tap-highlight-color:rgba(0,0,0,0);-webkit-user-select:none;-moz-user-select:none;user-select:none}.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,AAEAAAALAIAAAwAwT1MvMg8SBfAAAAC8AAAAYGNtYXAXVtKNAAABHAAAAFRnYXNwAAAAEAAAAXAAAAAIZ2x5ZgYydxIAAAF4AAAFNGhlYWQUJ7cIAAAGrAAAADZoaGVhB20DzAAABuQAAAAkaG10eCIABhQAAAcIAAAALGxvY2ED4AU6AAAHNAAAABhtYXhwAA8AjAAAB0wAAAAgbmFtZXsr690AAAdsAAABhnBvc3QAAwAAAAAI9AAAACAAAwPAAZAABQAAApkCzAAAAI8CmQLMAAAB6wAzAQkAAAAAAAAAAAAAAAAAAAABEAAAAAAAAAAAAAAAAAAAAABAAADpBgPA/8AAQAPAAEAAAAABAAAAAAAAAAAAAAAgAAAAAAADAAAAAwAAABwAAQADAAAAHAADAAEAAAAcAAQAOAAAAAoACAACAAIAAQAg6Qb//f//AAAAAAAg6QD//f//AAH/4xcEAAMAAQAAAAAAAAAAAAAAAQAB//8ADwABAAAAAAAAAAAAAgAANzkBAAAAAAEAAAAAAAAAAAACAAA3OQEAAAAAAQAAAAAAAAAAAAIAADc5AQAAAAABAWIAjQKeAskAEwAAJSc3NjQnJiIHAQYUFwEWMjc2NCcCnuLiDQ0MJAz/AA0NAQAMJAwNDcni4gwjDQwM/wANIwz/AA0NDCMNAAAAAQFiAI0CngLJABMAACUBNjQnASYiBwYUHwEHBhQXFjI3AZ4BAA0N/wAMJAwNDeLiDQ0MJAyNAQAMIw0BAAwMDSMM4uINIwwNDQAAAAIA4gC3Ax4CngATACcAACUnNzY0JyYiDwEGFB8BFjI3NjQnISc3NjQnJiIPAQYUHwEWMjc2NCcB87e3DQ0MIw3VDQ3VDSMMDQ0BK7e3DQ0MJAzVDQ3VDCQMDQ3zuLcMJAwNDdUNIwzWDAwNIwy4twwkDA0N1Q0jDNYMDA0jDAAAAgDiALcDHgKeABMAJwAAJTc2NC8BJiIHBhQfAQcGFBcWMjchNzY0LwEmIgcGFB8BBwYUFxYyNwJJ1Q0N1Q0jDA0Nt7cNDQwjDf7V1Q0N1QwkDA0Nt7cNDQwkDLfWDCMN1Q0NDCQMt7gMIw0MDNYMIw3VDQ0MJAy3uAwjDQwMAAADAFUAAAOrA1UAMwBoAHcAABMiBgcOAQcOAQcOARURFBYXHgEXHgEXHgEzITI2Nz4BNz4BNz4BNRE0JicuAScuAScuASMFITIWFx4BFx4BFx4BFREUBgcOAQcOAQcOASMhIiYnLgEnLgEnLgE1ETQ2Nz4BNz4BNz4BMxMhMjY1NCYjISIGFRQWM9UNGAwLFQkJDgUFBQUFBQ4JCRULDBgNAlYNGAwLFQkJDgUFBQUFBQ4JCRULDBgN/aoCVgQIBAQHAwMFAQIBAQIBBQMDBwQECAT9qgQIBAQHAwMFAQIBAQIBBQMDBwQECASAAVYRGRkR/qoRGRkRA1UFBAUOCQkVDAsZDf2rDRkLDBUJCA4FBQUFBQUOCQgVDAsZDQJVDRkLDBUJCQ4FBAVVAgECBQMCBwQECAX9qwQJAwQHAwMFAQICAgIBBQMDBwQDCQQCVQUIBAQHAgMFAgEC/oAZEhEZGRESGQAAAAADAFUAAAOrA1UAMwBoAIkAABMiBgcOAQcOAQcOARURFBYXHgEXHgEXHgEzITI2Nz4BNz4BNz4BNRE0JicuAScuAScuASMFITIWFx4BFx4BFx4BFREUBgcOAQcOAQcOASMhIiYnLgEnLgEnLgE1ETQ2Nz4BNz4BNz4BMxMzFRQWMzI2PQEzMjY1NCYrATU0JiMiBh0BIyIGFRQWM9UNGAwLFQkJDgUFBQUFBQ4JCRULDBgNAlYNGAwLFQkJDgUFBQUFBQ4JCRULDBgN/aoCVgQIBAQHAwMFAQIBAQIBBQMDBwQECAT9qgQIBAQHAwMFAQIBAQIBBQMDBwQECASAgBkSEhmAERkZEYAZEhIZgBEZGREDVQUEBQ4JCRUMCxkN/asNGQsMFQkIDgUFBQUFBQ4JCBUMCxkNAlUNGQsMFQkJDgUEBVUCAQIFAwIHBAQIBf2rBAkDBAcDAwUBAgICAgEFAwMHBAMJBAJVBQgEBAcCAwUCAQL+gIASGRkSgBkSERmAEhkZEoAZERIZAAABAOIAjQMeAskAIAAAExcHBhQXFjI/ARcWMjc2NC8BNzY0JyYiDwEnJiIHBhQX4uLiDQ0MJAzi4gwkDA0N4uINDQwkDOLiDCQMDQ0CjeLiDSMMDQ3h4Q0NDCMN4uIMIw0MDOLiDAwNIwwAAAABAAAAAQAAa5n0y18PPPUACwQAAAAAANivOVsAAAAA2K85WwAAAAADqwNVAAAACAACAAAAAAAAAAEAAAPA/8AAAAQAAAAAAAOrAAEAAAAAAAAAAAAAAAAAAAALBAAAAAAAAAAAAAAAAgAAAAQAAWIEAAFiBAAA4gQAAOIEAABVBAAAVQQAAOIAAAAAAAoAFAAeAEQAagCqAOoBngJkApoAAQAAAAsAigADAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAA4ArgABAAAAAAABAAcAAAABAAAAAAACAAcAYAABAAAAAAADAAcANgABAAAAAAAEAAcAdQABAAAAAAAFAAsAFQABAAAAAAAGAAcASwABAAAAAAAKABoAigADAAEECQABAA4ABwADAAEECQACAA4AZwADAAEECQADAA4APQADAAEECQAEAA4AfAADAAEECQAFABYAIAADAAEECQAGAA4AUgADAAEECQAKADQApGZjaWNvbnMAZgBjAGkAYwBvAG4Ac1ZlcnNpb24gMS4wAFYAZQByAHMAaQBvAG4AIAAxAC4AMGZjaWNvbnMAZgBjAGkAYwBvAG4Ac2ZjaWNvbnMAZgBjAGkAYwBvAG4Ac1JlZ3VsYXIAUgBlAGcAdQBsAGEAcmZjaWNvbnMAZgBjAGkAYwBvAG4Ac0ZvbnQgZ2VuZXJhdGVkIGJ5IEljb01vb24uAEYAbwBuAHQAIABnAGUAbgBlAHIAYQB0AGUAZAAgAGIAeQAgAEkAYwBvAE0AbwBvAG4ALgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\") 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;-webkit-user-select: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::-moz-focus-inner{border-style:none;padding:0}.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;-webkit-user-select:none;-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)}";
 injectStyles(css_248z);
 
+const globalLocales = [];
+
 const MINIMAL_RAW_EN_LOCALE = {
     code: 'en',
     week: {
@@ -99,6 +101,165 @@ function parseLocale(codeArg, codes, raw) {
     };
 }
 
+// TODO: easier way to add new hooks? need to update a million things
+function createPlugin(input) {
+    return {
+        id: guid(),
+        name: input.name,
+        premiumReleaseDate: input.premiumReleaseDate ? new Date(input.premiumReleaseDate) : undefined,
+        deps: input.deps || [],
+        reducers: input.reducers || [],
+        isLoadingFuncs: input.isLoadingFuncs || [],
+        contextInit: [].concat(input.contextInit || []),
+        eventRefiners: input.eventRefiners || {},
+        eventDefMemberAdders: input.eventDefMemberAdders || [],
+        eventSourceRefiners: input.eventSourceRefiners || {},
+        isDraggableTransformers: input.isDraggableTransformers || [],
+        eventDragMutationMassagers: input.eventDragMutationMassagers || [],
+        eventDefMutationAppliers: input.eventDefMutationAppliers || [],
+        dateSelectionTransformers: input.dateSelectionTransformers || [],
+        datePointTransforms: input.datePointTransforms || [],
+        dateSpanTransforms: input.dateSpanTransforms || [],
+        views: input.views || {},
+        viewPropsTransformers: input.viewPropsTransformers || [],
+        isPropsValid: input.isPropsValid || null,
+        externalDefTransforms: input.externalDefTransforms || [],
+        viewContainerAppends: input.viewContainerAppends || [],
+        eventDropTransformers: input.eventDropTransformers || [],
+        componentInteractions: input.componentInteractions || [],
+        calendarInteractions: input.calendarInteractions || [],
+        themeClasses: input.themeClasses || {},
+        eventSourceDefs: input.eventSourceDefs || [],
+        cmdFormatter: input.cmdFormatter,
+        recurringTypes: input.recurringTypes || [],
+        namedTimeZonedImpl: input.namedTimeZonedImpl,
+        initialView: input.initialView || '',
+        elementDraggingImpl: input.elementDraggingImpl,
+        optionChangeHandlers: input.optionChangeHandlers || {},
+        scrollGridImpl: input.scrollGridImpl || null,
+        listenerRefiners: input.listenerRefiners || {},
+        optionRefiners: input.optionRefiners || {},
+        propSetHandlers: input.propSetHandlers || {},
+    };
+}
+function buildPluginHooks(pluginDefs, globalDefs) {
+    let currentPluginIds = {};
+    let hooks = {
+        premiumReleaseDate: undefined,
+        reducers: [],
+        isLoadingFuncs: [],
+        contextInit: [],
+        eventRefiners: {},
+        eventDefMemberAdders: [],
+        eventSourceRefiners: {},
+        isDraggableTransformers: [],
+        eventDragMutationMassagers: [],
+        eventDefMutationAppliers: [],
+        dateSelectionTransformers: [],
+        datePointTransforms: [],
+        dateSpanTransforms: [],
+        views: {},
+        viewPropsTransformers: [],
+        isPropsValid: null,
+        externalDefTransforms: [],
+        viewContainerAppends: [],
+        eventDropTransformers: [],
+        componentInteractions: [],
+        calendarInteractions: [],
+        themeClasses: {},
+        eventSourceDefs: [],
+        cmdFormatter: null,
+        recurringTypes: [],
+        namedTimeZonedImpl: null,
+        initialView: '',
+        elementDraggingImpl: null,
+        optionChangeHandlers: {},
+        scrollGridImpl: null,
+        listenerRefiners: {},
+        optionRefiners: {},
+        propSetHandlers: {},
+    };
+    function addDefs(defs) {
+        for (let def of defs) {
+            const pluginName = def.name;
+            const currentId = currentPluginIds[pluginName];
+            if (currentId === undefined) {
+                currentPluginIds[pluginName] = def.id;
+                addDefs(def.deps);
+                hooks = combineHooks(hooks, def);
+            }
+            else if (currentId !== def.id) {
+                // different ID than the one already added
+                console.warn(`Duplicate plugin '${pluginName}'`);
+            }
+        }
+    }
+    if (pluginDefs) {
+        addDefs(pluginDefs);
+    }
+    addDefs(globalDefs);
+    return hooks;
+}
+function buildBuildPluginHooks() {
+    let currentOverrideDefs = [];
+    let currentGlobalDefs = [];
+    let currentHooks;
+    return (overrideDefs, globalDefs) => {
+        if (!currentHooks || !isArraysEqual(overrideDefs, currentOverrideDefs) || !isArraysEqual(globalDefs, currentGlobalDefs)) {
+            currentHooks = buildPluginHooks(overrideDefs, globalDefs);
+        }
+        currentOverrideDefs = overrideDefs;
+        currentGlobalDefs = globalDefs;
+        return currentHooks;
+    };
+}
+function combineHooks(hooks0, hooks1) {
+    return {
+        premiumReleaseDate: compareOptionalDates(hooks0.premiumReleaseDate, hooks1.premiumReleaseDate),
+        reducers: hooks0.reducers.concat(hooks1.reducers),
+        isLoadingFuncs: hooks0.isLoadingFuncs.concat(hooks1.isLoadingFuncs),
+        contextInit: hooks0.contextInit.concat(hooks1.contextInit),
+        eventRefiners: Object.assign(Object.assign({}, hooks0.eventRefiners), hooks1.eventRefiners),
+        eventDefMemberAdders: hooks0.eventDefMemberAdders.concat(hooks1.eventDefMemberAdders),
+        eventSourceRefiners: Object.assign(Object.assign({}, hooks0.eventSourceRefiners), hooks1.eventSourceRefiners),
+        isDraggableTransformers: hooks0.isDraggableTransformers.concat(hooks1.isDraggableTransformers),
+        eventDragMutationMassagers: hooks0.eventDragMutationMassagers.concat(hooks1.eventDragMutationMassagers),
+        eventDefMutationAppliers: hooks0.eventDefMutationAppliers.concat(hooks1.eventDefMutationAppliers),
+        dateSelectionTransformers: hooks0.dateSelectionTransformers.concat(hooks1.dateSelectionTransformers),
+        datePointTransforms: hooks0.datePointTransforms.concat(hooks1.datePointTransforms),
+        dateSpanTransforms: hooks0.dateSpanTransforms.concat(hooks1.dateSpanTransforms),
+        views: Object.assign(Object.assign({}, hooks0.views), hooks1.views),
+        viewPropsTransformers: hooks0.viewPropsTransformers.concat(hooks1.viewPropsTransformers),
+        isPropsValid: hooks1.isPropsValid || hooks0.isPropsValid,
+        externalDefTransforms: hooks0.externalDefTransforms.concat(hooks1.externalDefTransforms),
+        viewContainerAppends: hooks0.viewContainerAppends.concat(hooks1.viewContainerAppends),
+        eventDropTransformers: hooks0.eventDropTransformers.concat(hooks1.eventDropTransformers),
+        calendarInteractions: hooks0.calendarInteractions.concat(hooks1.calendarInteractions),
+        componentInteractions: hooks0.componentInteractions.concat(hooks1.componentInteractions),
+        themeClasses: Object.assign(Object.assign({}, hooks0.themeClasses), hooks1.themeClasses),
+        eventSourceDefs: hooks0.eventSourceDefs.concat(hooks1.eventSourceDefs),
+        cmdFormatter: hooks1.cmdFormatter || hooks0.cmdFormatter,
+        recurringTypes: hooks0.recurringTypes.concat(hooks1.recurringTypes),
+        namedTimeZonedImpl: hooks1.namedTimeZonedImpl || hooks0.namedTimeZonedImpl,
+        initialView: hooks0.initialView || hooks1.initialView,
+        elementDraggingImpl: hooks0.elementDraggingImpl || hooks1.elementDraggingImpl,
+        optionChangeHandlers: Object.assign(Object.assign({}, hooks0.optionChangeHandlers), hooks1.optionChangeHandlers),
+        scrollGridImpl: hooks1.scrollGridImpl || hooks0.scrollGridImpl,
+        listenerRefiners: Object.assign(Object.assign({}, hooks0.listenerRefiners), hooks1.listenerRefiners),
+        optionRefiners: Object.assign(Object.assign({}, hooks0.optionRefiners), hooks1.optionRefiners),
+        propSetHandlers: Object.assign(Object.assign({}, hooks0.propSetHandlers), hooks1.propSetHandlers),
+    };
+}
+function compareOptionalDates(date0, date1) {
+    if (date0 === undefined) {
+        return date1;
+    }
+    if (date1 === undefined) {
+        return date0;
+    }
+    return new Date(Math.max(date0.valueOf(), date1.valueOf()));
+}
+
 class StandardTheme extends Theme {
 }
 StandardTheme.prototype.classes = {
@@ -328,6 +489,170 @@ function reduceDateProfile(currentDateProfile, action, currentDate, dateProfileG
     return currentDateProfile;
 }
 
+function initEventSources(calendarOptions, dateProfile, context) {
+    let activeRange = dateProfile ? dateProfile.activeRange : null;
+    return addSources({}, parseInitialSources(calendarOptions, context), activeRange, context);
+}
+function reduceEventSources(eventSources, action, dateProfile, context) {
+    let activeRange = dateProfile ? dateProfile.activeRange : null; // need this check?
+    switch (action.type) {
+        case 'ADD_EVENT_SOURCES': // already parsed
+            return addSources(eventSources, action.sources, activeRange, context);
+        case 'REMOVE_EVENT_SOURCE':
+            return removeSource(eventSources, action.sourceId);
+        case 'PREV': // TODO: how do we track all actions that affect dateProfile :(
+        case 'NEXT':
+        case 'CHANGE_DATE':
+        case 'CHANGE_VIEW_TYPE':
+            if (dateProfile) {
+                return fetchDirtySources(eventSources, activeRange, context);
+            }
+            return eventSources;
+        case 'FETCH_EVENT_SOURCES':
+            return fetchSourcesByIds(eventSources, action.sourceIds ? // why no type?
+                arrayToHash(action.sourceIds) :
+                excludeStaticSources(eventSources, context), activeRange, action.isRefetch || false, context);
+        case 'RECEIVE_EVENTS':
+        case 'RECEIVE_EVENT_ERROR':
+            return receiveResponse(eventSources, action.sourceId, action.fetchId, action.fetchRange);
+        case 'REMOVE_ALL_EVENT_SOURCES':
+            return {};
+        default:
+            return eventSources;
+    }
+}
+function reduceEventSourcesNewTimeZone(eventSources, dateProfile, context) {
+    let activeRange = dateProfile ? dateProfile.activeRange : null; // need this check?
+    return fetchSourcesByIds(eventSources, excludeStaticSources(eventSources, context), activeRange, true, context);
+}
+function computeEventSourcesLoading(eventSources) {
+    for (let sourceId in eventSources) {
+        if (eventSources[sourceId].isFetching) {
+            return true;
+        }
+    }
+    return false;
+}
+function addSources(eventSourceHash, sources, fetchRange, context) {
+    let hash = {};
+    for (let source of sources) {
+        hash[source.sourceId] = source;
+    }
+    if (fetchRange) {
+        hash = fetchDirtySources(hash, fetchRange, context);
+    }
+    return Object.assign(Object.assign({}, eventSourceHash), hash);
+}
+function removeSource(eventSourceHash, sourceId) {
+    return filterHash(eventSourceHash, (eventSource) => eventSource.sourceId !== sourceId);
+}
+function fetchDirtySources(sourceHash, fetchRange, context) {
+    return fetchSourcesByIds(sourceHash, filterHash(sourceHash, (eventSource) => isSourceDirty(eventSource, fetchRange, context)), fetchRange, false, context);
+}
+function isSourceDirty(eventSource, fetchRange, context) {
+    if (!doesSourceNeedRange(eventSource, context)) {
+        return !eventSource.latestFetchId;
+    }
+    return !context.options.lazyFetching ||
+        !eventSource.fetchRange ||
+        eventSource.isFetching || // always cancel outdated in-progress fetches
+        fetchRange.start < eventSource.fetchRange.start ||
+        fetchRange.end > eventSource.fetchRange.end;
+}
+function fetchSourcesByIds(prevSources, sourceIdHash, fetchRange, isRefetch, context) {
+    let nextSources = {};
+    for (let sourceId in prevSources) {
+        let source = prevSources[sourceId];
+        if (sourceIdHash[sourceId]) {
+            nextSources[sourceId] = fetchSource(source, fetchRange, isRefetch, context);
+        }
+        else {
+            nextSources[sourceId] = source;
+        }
+    }
+    return nextSources;
+}
+function fetchSource(eventSource, fetchRange, isRefetch, context) {
+    let { options, calendarApi } = context;
+    let sourceDef = context.pluginHooks.eventSourceDefs[eventSource.sourceDefId];
+    let fetchId = guid();
+    sourceDef.fetch({
+        eventSource,
+        range: fetchRange,
+        isRefetch,
+        context,
+    }, (res) => {
+        let { rawEvents } = res;
+        if (options.eventSourceSuccess) {
+            rawEvents = options.eventSourceSuccess.call(calendarApi, rawEvents, res.response) || rawEvents;
+        }
+        if (eventSource.success) {
+            rawEvents = eventSource.success.call(calendarApi, rawEvents, res.response) || rawEvents;
+        }
+        context.dispatch({
+            type: 'RECEIVE_EVENTS',
+            sourceId: eventSource.sourceId,
+            fetchId,
+            fetchRange,
+            rawEvents,
+        });
+    }, (error) => {
+        let errorHandled = false;
+        if (options.eventSourceFailure) {
+            options.eventSourceFailure.call(calendarApi, error);
+            errorHandled = true;
+        }
+        if (eventSource.failure) {
+            eventSource.failure(error);
+            errorHandled = true;
+        }
+        if (!errorHandled) {
+            console.warn(error.message, error);
+        }
+        context.dispatch({
+            type: 'RECEIVE_EVENT_ERROR',
+            sourceId: eventSource.sourceId,
+            fetchId,
+            fetchRange,
+            error,
+        });
+    });
+    return Object.assign(Object.assign({}, eventSource), { isFetching: true, latestFetchId: fetchId });
+}
+function receiveResponse(sourceHash, sourceId, fetchId, fetchRange) {
+    let eventSource = sourceHash[sourceId];
+    if (eventSource && // not already removed
+        fetchId === eventSource.latestFetchId) {
+        return Object.assign(Object.assign({}, sourceHash), { [sourceId]: Object.assign(Object.assign({}, eventSource), { isFetching: false, fetchRange }) });
+    }
+    return sourceHash;
+}
+function excludeStaticSources(eventSources, context) {
+    return filterHash(eventSources, (eventSource) => doesSourceNeedRange(eventSource, context));
+}
+function parseInitialSources(rawOptions, context) {
+    let refiners = buildEventSourceRefiners(context);
+    let rawSources = [].concat(rawOptions.eventSources || []);
+    let sources = []; // parsed
+    if (rawOptions.initialEvents) {
+        rawSources.unshift(rawOptions.initialEvents);
+    }
+    if (rawOptions.events) {
+        rawSources.unshift(rawOptions.events);
+    }
+    for (let rawSource of rawSources) {
+        let source = parseEventSource(rawSource, context, refiners);
+        if (source) {
+            sources.push(source);
+        }
+    }
+    return sources;
+}
+function doesSourceNeedRange(eventSource, context) {
+    let defs = context.pluginHooks.eventSourceDefs;
+    return !defs[eventSource.sourceDefId].ignoreRange;
+}
+
 function reduceDateSelection(currentSelection, action) {
     switch (action.type) {
         case 'UNSELECT_DATES':
@@ -513,6 +838,257 @@ class ViewImpl {
     }
 }
 
+let eventSourceDef$2 = {
+    ignoreRange: true,
+    parseMeta(refined) {
+        if (Array.isArray(refined.events)) {
+            return refined.events;
+        }
+        return null;
+    },
+    fetch(arg, successCallback) {
+        successCallback({
+            rawEvents: arg.eventSource.meta,
+        });
+    },
+};
+const arrayEventSourcePlugin = createPlugin({
+    name: 'array-event-source',
+    eventSourceDefs: [eventSourceDef$2],
+});
+
+let eventSourceDef$1 = {
+    parseMeta(refined) {
+        if (typeof refined.events === 'function') {
+            return refined.events;
+        }
+        return null;
+    },
+    fetch(arg, successCallback, errorCallback) {
+        const { dateEnv } = arg.context;
+        const func = arg.eventSource.meta;
+        unpromisify(func.bind(null, buildRangeApiWithTimeZone(arg.range, dateEnv)), (rawEvents) => successCallback({ rawEvents }), errorCallback);
+    },
+};
+const funcEventSourcePlugin = createPlugin({
+    name: 'func-event-source',
+    eventSourceDefs: [eventSourceDef$1],
+});
+
+const JSON_FEED_EVENT_SOURCE_REFINERS = {
+    method: String,
+    extraParams: identity,
+    startParam: String,
+    endParam: String,
+    timeZoneParam: String,
+};
+
+let eventSourceDef = {
+    parseMeta(refined) {
+        if (refined.url && (refined.format === 'json' || !refined.format)) {
+            return {
+                url: refined.url,
+                format: 'json',
+                method: (refined.method || 'GET').toUpperCase(),
+                extraParams: refined.extraParams,
+                startParam: refined.startParam,
+                endParam: refined.endParam,
+                timeZoneParam: refined.timeZoneParam,
+            };
+        }
+        return null;
+    },
+    fetch(arg, successCallback, errorCallback) {
+        const { meta } = arg.eventSource;
+        const requestParams = buildRequestParams(meta, arg.range, arg.context);
+        requestJson(meta.method, meta.url, requestParams).then(([rawEvents, response]) => {
+            successCallback({ rawEvents, response });
+        }, errorCallback);
+    },
+};
+const jsonFeedEventSourcePlugin = createPlugin({
+    name: 'json-event-source',
+    eventSourceRefiners: JSON_FEED_EVENT_SOURCE_REFINERS,
+    eventSourceDefs: [eventSourceDef],
+});
+function buildRequestParams(meta, range, context) {
+    let { dateEnv, options } = context;
+    let startParam;
+    let endParam;
+    let timeZoneParam;
+    let customRequestParams;
+    let params = {};
+    startParam = meta.startParam;
+    if (startParam == null) {
+        startParam = options.startParam;
+    }
+    endParam = meta.endParam;
+    if (endParam == null) {
+        endParam = options.endParam;
+    }
+    timeZoneParam = meta.timeZoneParam;
+    if (timeZoneParam == null) {
+        timeZoneParam = options.timeZoneParam;
+    }
+    // retrieve any outbound GET/POST data from the options
+    if (typeof meta.extraParams === 'function') {
+        // supplied as a function that returns a key/value object
+        customRequestParams = meta.extraParams();
+    }
+    else {
+        // probably supplied as a straight key/value object
+        customRequestParams = meta.extraParams || {};
+    }
+    Object.assign(params, customRequestParams);
+    params[startParam] = dateEnv.formatIso(range.start);
+    params[endParam] = dateEnv.formatIso(range.end);
+    if (dateEnv.timeZone !== 'local') {
+        params[timeZoneParam] = dateEnv.timeZone;
+    }
+    return params;
+}
+
+const SIMPLE_RECURRING_REFINERS = {
+    daysOfWeek: identity,
+    startTime: createDuration,
+    endTime: createDuration,
+    duration: createDuration,
+    startRecur: identity,
+    endRecur: identity,
+};
+
+let recurring = {
+    parse(refined, dateEnv) {
+        if (refined.daysOfWeek || refined.startTime || refined.endTime || refined.startRecur || refined.endRecur) {
+            let recurringData = {
+                daysOfWeek: refined.daysOfWeek || null,
+                startTime: refined.startTime || null,
+                endTime: refined.endTime || null,
+                startRecur: refined.startRecur ? dateEnv.createMarker(refined.startRecur) : null,
+                endRecur: refined.endRecur ? dateEnv.createMarker(refined.endRecur) : null,
+            };
+            let duration;
+            if (refined.duration) {
+                duration = refined.duration;
+            }
+            if (!duration && refined.startTime && refined.endTime) {
+                duration = subtractDurations(refined.endTime, refined.startTime);
+            }
+            return {
+                allDayGuess: Boolean(!refined.startTime && !refined.endTime),
+                duration,
+                typeData: recurringData, // doesn't need endTime anymore but oh well
+            };
+        }
+        return null;
+    },
+    expand(typeData, framingRange, dateEnv) {
+        let clippedFramingRange = intersectRanges(framingRange, { start: typeData.startRecur, end: typeData.endRecur });
+        if (clippedFramingRange) {
+            return expandRanges(typeData.daysOfWeek, typeData.startTime, clippedFramingRange, dateEnv);
+        }
+        return [];
+    },
+};
+const simpleRecurringEventsPlugin = createPlugin({
+    name: 'simple-recurring-event',
+    recurringTypes: [recurring],
+    eventRefiners: SIMPLE_RECURRING_REFINERS,
+});
+function expandRanges(daysOfWeek, startTime, framingRange, dateEnv) {
+    let dowHash = daysOfWeek ? arrayToHash(daysOfWeek) : null;
+    let dayMarker = startOfDay(framingRange.start);
+    let endMarker = framingRange.end;
+    let instanceStarts = [];
+    while (dayMarker < endMarker) {
+        let instanceStart;
+        // if everyday, or this particular day-of-week
+        if (!dowHash || dowHash[dayMarker.getUTCDay()]) {
+            if (startTime) {
+                instanceStart = dateEnv.add(dayMarker, startTime);
+            }
+            else {
+                instanceStart = dayMarker;
+            }
+            instanceStarts.push(instanceStart);
+        }
+        dayMarker = addDays(dayMarker, 1);
+    }
+    return instanceStarts;
+}
+
+const changeHandlerPlugin = createPlugin({
+    name: 'change-handler',
+    optionChangeHandlers: {
+        events(events, context) {
+            handleEventSources([events], context);
+        },
+        eventSources: handleEventSources,
+    },
+});
+/*
+BUG: if `event` was supplied, all previously-given `eventSources` will be wiped out
+*/
+function handleEventSources(inputs, context) {
+    let unfoundSources = hashValuesToArray(context.getCurrentData().eventSources);
+    let newInputs = [];
+    for (let input of inputs) {
+        let inputFound = false;
+        for (let i = 0; i < unfoundSources.length; i += 1) {
+            if (unfoundSources[i]._raw === input) {
+                unfoundSources.splice(i, 1); // delete
+                inputFound = true;
+                break;
+            }
+        }
+        if (!inputFound) {
+            newInputs.push(input);
+        }
+    }
+    for (let unfoundSource of unfoundSources) {
+        context.dispatch({
+            type: 'REMOVE_EVENT_SOURCE',
+            sourceId: unfoundSource.sourceId,
+        });
+    }
+    for (let newInput of newInputs) {
+        context.calendarApi.addEventSource(newInput);
+    }
+}
+
+function handleDateProfile(dateProfile, context) {
+    context.emitter.trigger('datesSet', Object.assign(Object.assign({}, buildRangeApiWithTimeZone(dateProfile.activeRange, context.dateEnv)), { view: context.viewApi }));
+}
+
+function handleEventStore(eventStore, context) {
+    let { emitter } = context;
+    if (emitter.hasHandlers('eventsSet')) {
+        emitter.trigger('eventsSet', buildEventApis(eventStore, context));
+    }
+}
+
+/*
+this array is exposed on the root namespace so that UMD plugins can add to it.
+see the rollup-bundles script.
+*/
+const globalPlugins = [
+    arrayEventSourcePlugin,
+    funcEventSourcePlugin,
+    jsonFeedEventSourcePlugin,
+    simpleRecurringEventsPlugin,
+    changeHandlerPlugin,
+    createPlugin({
+        name: 'misc',
+        isLoadingFuncs: [
+            (state) => computeEventSourcesLoading(state.eventSources),
+        ],
+        propSetHandlers: {
+            dateProfile: handleDateProfile,
+            eventStore: handleEventStore,
+        },
+    }),
+];
+
 class TaskRunner {
     constructor(runTaskOption, drainedOption) {
         this.runTaskOption = runTaskOption;
@@ -1531,6 +2107,6 @@ function sliceEvents(props, allDay) {
     return sliceEventStore(props.eventStore, props.eventUiBases, props.dateProfile.activeRange, allDay ? props.nextDayThreshold : null).fg;
 }
 
-const version = '6.0.0';
+const version = '6.0.2';
 
-export { Calendar, formatDate, formatRange, sliceEvents, version };
+export { Calendar, createPlugin, formatDate, formatRange, globalLocales, globalPlugins, sliceEvents, version };