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

package/{index.cjs → cjs/index.cjs}

@@ -2,10 +2,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index_cjs = require('@fullcalendar/core/index.cjs');
-var internal_cjs = require('@fullcalendar/core/internal.cjs');
+var core = require('@fullcalendar/core');
+var internal = require('@fullcalendar/core/internal');
+var classNames = require('@fullcalendar/core/internal-classnames');
 
-internal_cjs.config.touchMouseIgnoreWait = 500;
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
+
+internal.config.touchMouseIgnoreWait = 500;
 let ignoreMouseDepth = 0;
 let listenerCnt = 0;
 let isWindowTouchMoveCancelled = false;
@@ -33,7 +38,7 @@ class PointerDragging {
         // internal states
         this.isDragging = false;
         this.isTouchDragging = false;
-        this.wasTouchScroll = false;
+        this.wasTouchScroll = false; // HACK public
         // Mouse
         // ----------------------------------------------------------------------------------------------------
         this.handleMouseDown = (ev) => {
@@ -83,9 +88,11 @@ class PointerDragging {
             }
         };
         this.handleTouchMove = (ev) => {
-            let pev = this.createEventFromTouch(ev);
-            this.recordCoords(pev);
-            this.emitter.trigger('pointermove', pev);
+            if (this.isDragging) {
+                let pev = this.createEventFromTouch(ev);
+                this.recordCoords(pev);
+                this.emitter.trigger('pointermove', pev);
+            }
         };
         this.handleTouchEnd = (ev) => {
             if (this.isDragging) { // done to guard against touchend followed by touchcancel
@@ -119,7 +126,7 @@ class PointerDragging {
             }
         };
         this.containerEl = containerEl;
-        this.emitter = new internal_cjs.Emitter();
+        this.emitter = new internal.Emitter();
         containerEl.addEventListener('mousedown', this.handleMouseDown);
         containerEl.addEventListener('touchstart', this.handleTouchStart, { passive: true });
         listenerCreated();
@@ -129,6 +136,11 @@ class PointerDragging {
         this.containerEl.removeEventListener('touchstart', this.handleTouchStart, { passive: true });
         listenerDestroyed();
     }
+    cancel() {
+        if (this.isDragging) {
+            this.cleanup();
+        }
+    }
     tryStart(ev) {
         let subjectEl = this.querySubjectEl(ev);
         let downEl = ev.target;
@@ -254,7 +266,7 @@ function startIgnoringMouse() {
     ignoreMouseDepth += 1;
     setTimeout(() => {
         ignoreMouseDepth -= 1;
-    }, internal_cjs.config.touchMouseIgnoreWait);
+    }, internal.config.touchMouseIgnoreWait);
 }
 // We want to attach touchmove as early as possible for Safari
 // ----------------------------------------------------------------------------------------------------
@@ -311,7 +323,9 @@ class ElementMirror {
         if (bool) {
             if (!this.isVisible) {
                 if (this.mirrorEl) {
-                    this.mirrorEl.style.display = '';
+                    // important because competes with util.module.css classNames, which are all important
+                    // TODO: attach a util className here instead?
+                    this.mirrorEl.style.setProperty('display', '', 'important');
                 }
                 this.isVisible = bool; // needs to happen before updateElPosition
                 this.updateElPosition(); // because was not updating the position while invisible
@@ -319,7 +333,9 @@ class ElementMirror {
         }
         else if (this.isVisible) {
             if (this.mirrorEl) {
-                this.mirrorEl.style.display = 'none';
+                // important because competes with util.module.css classNames, which are all important
+                // TODO: attach a util className here instead?
+                this.mirrorEl.style.setProperty('display', 'none', 'important');
             }
             this.isVisible = bool;
         }
@@ -348,11 +364,11 @@ class ElementMirror {
         mirrorEl.style.transition =
             'top ' + revertDuration + 'ms,' +
                 'left ' + revertDuration + 'ms';
-        internal_cjs.applyStyle(mirrorEl, {
+        internal.applyStyle(mirrorEl, {
             left: finalSourceElRect.left,
             top: finalSourceElRect.top,
         });
-        internal_cjs.whenTransitionDone(mirrorEl, () => {
+        internal.whenTransitionDone(mirrorEl, () => {
             mirrorEl.style.transition = '';
             callback();
         });
@@ -366,7 +382,7 @@ class ElementMirror {
     }
     updateElPosition() {
         if (this.sourceEl && this.isVisible) {
-            internal_cjs.applyStyle(this.getMirrorEl(), {
+            internal.applyStyle(this.getMirrorEl(), {
                 left: this.sourceElRect.left + this.deltaX,
                 top: this.sourceElRect.top + this.deltaY,
             });
@@ -379,11 +395,11 @@ class ElementMirror {
             mirrorEl = this.mirrorEl = this.sourceEl.cloneNode(true); // cloneChildren=true
             // we don't want long taps or any mouse interaction causing selection/menus.
             // would use preventSelection(), but that prevents selectstart, causing problems.
+            // TODO: make className for this?
             mirrorEl.style.userSelect = 'none';
             mirrorEl.style.webkitUserSelect = 'none';
             mirrorEl.style.pointerEvents = 'none';
-            mirrorEl.classList.add('fc-event-dragging');
-            internal_cjs.applyStyle(mirrorEl, {
+            internal.applyStyle(mirrorEl, {
                 position: 'fixed',
                 zIndex: this.zIndex,
                 visibility: '',
@@ -408,7 +424,7 @@ The cache can be in one of two modes:
 - doesListening:false - ignores when the container is scrolled by someone else
 - doesListening:true - watch for scrolling and update the cache
 */
-class ScrollGeomCache extends internal_cjs.ScrollController {
+class ScrollGeomCache extends internal.ScrollController {
     constructor(scrollController, doesListening) {
         super();
         this.handleScroll = () => {
@@ -476,19 +492,19 @@ class ScrollGeomCache extends internal_cjs.ScrollController {
 
 class ElementScrollGeomCache extends ScrollGeomCache {
     constructor(el, doesListening) {
-        super(new internal_cjs.ElementScrollController(el), doesListening);
+        super(new internal.ElementScrollController(el), doesListening);
     }
     getEventTarget() {
         return this.scrollController.el;
     }
     computeClientRect() {
-        return internal_cjs.computeInnerRect(this.scrollController.el);
+        return internal.computeInnerRect(this.scrollController.el);
     }
 }
 
 class WindowScrollGeomCache extends ScrollGeomCache {
     constructor(doesListening) {
-        super(new internal_cjs.WindowScrollController(), doesListening);
+        super(new internal.WindowScrollController(), doesListening);
     }
     getEventTarget() {
         return window;
@@ -522,7 +538,7 @@ class AutoScroller {
     constructor() {
         // options that can be set by caller
         this.isEnabled = true;
-        this.scrollQuery = [window, '.fc-scroller'];
+        this.scrollQuery = [window, `.${classNames__default["default"].internalScroller}`];
         this.edgeThreshold = 50; // pixels
         this.maxVelocity = 300; // pixels per second
         // internal state
@@ -692,7 +708,7 @@ Monitors dragging on an element. Has a number of high-level features:
 - minimum wait time ("delay") before dragging
 - a mirror element that follows the pointer
 */
-class FeaturefulElementDragging extends internal_cjs.ElementDragging {
+class FeaturefulElementDragging extends internal.ElementDragging {
     constructor(containerEl, selector) {
         super(containerEl);
         this.containerEl = containerEl;
@@ -712,17 +728,16 @@ class FeaturefulElementDragging extends internal_cjs.ElementDragging {
                 this.isInteracting = true;
                 this.isDelayEnded = false;
                 this.isDistanceSurpassed = false;
-                internal_cjs.preventSelection(document.body);
-                internal_cjs.preventContextMenu(document.body);
-                // prevent links from being visited if there's an eventual drag.
-                // also prevents selection in older browsers (maybe?).
-                // not necessary for touch, besides, browser would complain about passiveness.
-                if (!ev.isTouch) {
-                    ev.origEvent.preventDefault();
-                }
                 this.emitter.trigger('pointerdown', ev);
-                if (this.isInteracting && // not destroyed via pointerdown handler
-                    !this.pointer.shouldIgnoreMove) {
+                if (this.isInteracting) { // not cancelled?
+                    internal.preventSelection(document.body);
+                    internal.preventContextMenu(document.body);
+                    // prevent links from being visited if there's an eventual drag.
+                    // also prevents selection in older browsers (maybe?).
+                    // not necessary for touch, besides, browser would complain about passiveness.
+                    if (!ev.isTouch) {
+                        ev.origEvent.preventDefault();
+                    }
                     // actions related to initiating dragstart+dragmove+dragend...
                     this.mirror.setIsVisible(false); // reset. caller must set-visible
                     this.mirror.start(ev.subjectEl, ev.pageX, ev.pageY); // must happen on first pointer down
@@ -758,8 +773,8 @@ class FeaturefulElementDragging extends internal_cjs.ElementDragging {
         this.onPointerUp = (ev) => {
             if (this.isInteracting) {
                 this.isInteracting = false;
-                internal_cjs.allowSelection(document.body);
-                internal_cjs.allowContextMenu(document.body);
+                internal.allowSelection(document.body);
+                internal.allowContextMenu(document.body);
                 this.emitter.trigger('pointerup', ev); // can potentially set mirrorNeedsRevert
                 if (this.isDragging) {
                     this.autoScroller.stop();
@@ -829,8 +844,14 @@ class FeaturefulElementDragging extends internal_cjs.ElementDragging {
         this.emitter.trigger('dragend', ev);
     }
     // fill in the implementations...
-    setIgnoreMove(bool) {
-        this.pointer.shouldIgnoreMove = bool;
+    /*
+    Can only be called by pointerdown to prevent drag
+    */
+    cancel() {
+        if (this.isInteracting) {
+            this.isInteracting = false;
+            this.pointer.cancel();
+        }
     }
     setMirrorIsVisible(bool) {
         this.mirror.setIsVisible(bool);
@@ -854,9 +875,10 @@ and an determine if a given point is inside the combined clipping rectangle.
 class OffsetTracker {
     constructor(el) {
         this.el = el;
-        this.origRect = internal_cjs.computeRect(el);
+        this.origRect = internal.computeRect(el);
+        this.isRtl = internal.computeElIsRtl(el);
         // will work fine for divs that have overflow:hidden
-        this.scrollCaches = internal_cjs.getClippingParents(el).map((scrollEl) => new ElementScrollGeomCache(scrollEl, true));
+        this.scrollCaches = internal.getClippingParents(el).map((scrollEl) => new ElementScrollGeomCache(scrollEl, true));
     }
     destroy() {
         for (let scrollCache of this.scrollCaches) {
@@ -881,7 +903,7 @@ class OffsetTracker {
         let point = { left: pageX, top: pageY };
         for (let scrollCache of this.scrollCaches) {
             if (!isIgnoredClipping(scrollCache.getEventTarget()) &&
-                !internal_cjs.pointInsideRect(point, scrollCache.clientRect)) {
+                !internal.pointInsideRect(point, scrollCache.clientRect)) {
                 return false;
             }
         }
@@ -925,12 +947,11 @@ class HitDragging {
             this.prepareHits();
             this.processFirstCoord(ev);
             if (this.initialHit || !this.requireInitial) {
-                dragging.setIgnoreMove(false);
                 // TODO: fire this before computing processFirstCoord, so listeners can cancel. this gets fired by almost every handler :(
                 this.emitter.trigger('pointerdown', ev);
             }
             else {
-                dragging.setIgnoreMove(true);
+                dragging.cancel();
             }
         };
         this.handleDragStart = (ev) => {
@@ -960,7 +981,7 @@ class HitDragging {
         dragging.emitter.on('pointerup', this.handlePointerUp);
         dragging.emitter.on('dragend', this.handleDragEnd);
         this.dragging = dragging;
-        this.emitter = new internal_cjs.Emitter();
+        this.emitter = new internal.Emitter();
     }
     // sets initialHit
     // sets coordAdjust
@@ -970,18 +991,18 @@ class HitDragging {
         let subjectEl = ev.subjectEl;
         let subjectRect;
         if (subjectEl instanceof HTMLElement) { // i.e. not a Document/ShadowRoot
-            subjectRect = internal_cjs.computeRect(subjectEl);
-            adjustedPoint = internal_cjs.constrainPoint(adjustedPoint, subjectRect);
+            subjectRect = internal.computeRect(subjectEl);
+            adjustedPoint = internal.constrainPoint(adjustedPoint, subjectRect);
         }
         let initialHit = this.initialHit = this.queryHitForOffset(adjustedPoint.left, adjustedPoint.top);
         if (initialHit) {
             if (this.useSubjectCenter && subjectRect) {
-                let slicedSubjectRect = internal_cjs.intersectRects(subjectRect, initialHit.rect);
+                let slicedSubjectRect = internal.intersectRects(subjectRect, initialHit.rect);
                 if (slicedSubjectRect) {
-                    adjustedPoint = internal_cjs.getRectCenter(slicedSubjectRect);
+                    adjustedPoint = internal.getRectCenter(slicedSubjectRect);
                 }
             }
-            this.coordAdjust = internal_cjs.diffPoints(adjustedPoint, origPoint);
+            this.coordAdjust = internal.diffPoints(adjustedPoint, origPoint);
         }
         else {
             this.coordAdjust = { left: 0, top: 0 };
@@ -995,7 +1016,7 @@ class HitDragging {
         }
     }
     prepareHits() {
-        this.offsetTrackers = internal_cjs.mapHash(this.droppableStore, (interactionSettings) => {
+        this.offsetTrackers = internal.mapHash(this.droppableStore, (interactionSettings) => {
             interactionSettings.component.prepareHits();
             return new OffsetTracker(interactionSettings.el);
         });
@@ -1026,10 +1047,10 @@ class HitDragging {
                 // must be within the element's bounds
                 positionLeft >= 0 && positionLeft < width &&
                     positionTop >= 0 && positionTop < height) {
-                    let hit = component.queryHit(positionLeft, positionTop, width, height);
+                    let hit = component.queryHit(offsetTracker.isRtl, positionLeft, positionTop, width, height);
                     if (hit && (
                     // make sure the hit is within activeRange, meaning it's not a dead cell
-                    internal_cjs.rangeContainsRange(hit.dateProfile.activeRange, hit.dateSpan.range)) &&
+                    internal.rangeContainsRange(hit.dateProfile.activeRange, hit.dateSpan.range)) &&
                         // Ensure the component we are querying for the hit is accessibly my the pointer
                         // Prevents obscured calendars (ex: under a modal dialog) from accepting hit
                         // https://github.com/fullcalendar/fullcalendar/issues/5026
@@ -1060,7 +1081,7 @@ function isHitsEqual(hit0, hit1) {
     if (Boolean(hit0) !== Boolean(hit1)) {
         return false;
     }
-    return internal_cjs.isDateSpansEqual(hit0.dateSpan, hit1.dateSpan);
+    return internal.isDateSpansEqual(hit0.dateSpan, hit1.dateSpan);
 }
 
 function buildDatePointApiWithContext(dateSpan, context) {
@@ -1083,14 +1104,20 @@ function buildDatePointApi(span, dateEnv) {
 Monitors when the user clicks on a specific date/time of a component.
 A pointerdown+pointerup on the same "hit" constitutes a click.
 */
-class DateClicking extends internal_cjs.Interaction {
+class DateClicking extends internal.Interaction {
     constructor(settings) {
         super(settings);
         this.handlePointerDown = (pev) => {
             let { dragging } = this;
             let downEl = pev.origEvent.target;
-            // do this in pointerdown (not dragend) because DOM might be mutated by the time dragend is fired
-            dragging.setIgnoreMove(!this.component.isValidDateDownEl(downEl));
+            /*
+            If no dateClick, allow text on dates to be text-selectable
+            */
+            const canDateClick = this.component.context.emitter.hasHandlers('dateClick') &&
+                this.component.isValidDateDownEl(downEl);
+            if (!canDateClick) {
+                dragging.cancel();
+            }
         };
         // won't even fire if moving was ignored
         this.handleDragEnd = (ev) => {
@@ -1100,15 +1127,15 @@ class DateClicking extends internal_cjs.Interaction {
                 let { initialHit, finalHit } = this.hitDragging;
                 if (initialHit && finalHit && isHitsEqual(initialHit, finalHit)) {
                     let { context } = component;
-                    let arg = Object.assign(Object.assign({}, buildDatePointApiWithContext(initialHit.dateSpan, context)), { dayEl: initialHit.dayEl, jsEvent: ev.origEvent, view: context.viewApi || context.calendarApi.view });
-                    context.emitter.trigger('dateClick', arg);
+                    let data = Object.assign(Object.assign({}, buildDatePointApiWithContext(initialHit.dateSpan, context)), { dayEl: initialHit.getDayEl(), jsEvent: ev.origEvent, view: context.viewApi || context.calendarApi.view });
+                    context.emitter.trigger('dateClick', data);
                 }
             }
         };
         // we DO want to watch pointer moves because otherwise finalHit won't get populated
         this.dragging = new FeaturefulElementDragging(settings.el);
         this.dragging.autoScroller.isEnabled = false;
-        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal_cjs.interactionSettingsToStore(settings));
+        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal.interactionSettingsToStore(settings));
         hitDragging.emitter.on('pointerdown', this.handlePointerDown);
         hitDragging.emitter.on('dragend', this.handleDragEnd);
     }
@@ -1121,19 +1148,22 @@ class DateClicking extends internal_cjs.Interaction {
 Tracks when the user selects a portion of time of a component,
 constituted by a drag over date cells, with a possible delay at the beginning of the drag.
 */
-class DateSelecting extends internal_cjs.Interaction {
+class DateSelecting extends internal.Interaction {
     constructor(settings) {
         super(settings);
         this.dragSelection = null;
         this.handlePointerDown = (ev) => {
             let { component, dragging } = this;
             let { options } = component.context;
-            let canSelect = options.selectable &&
+            let canDateSelect = options.selectable &&
                 component.isValidDateDownEl(ev.origEvent.target);
-            // don't bother to watch expensive moves if component won't do selection
-            dragging.setIgnoreMove(!canSelect);
-            // if touch, require user to hold down
-            dragging.delay = ev.isTouch ? getComponentTouchDelay$1(component) : null;
+            if (!canDateSelect) {
+                dragging.cancel();
+            }
+            else {
+                // if touch, require user to hold down
+                dragging.delay = ev.isTouch ? getComponentTouchDelay$1(component) : null;
+            }
         };
         this.handleDragStart = (ev) => {
             this.component.context.calendarApi.unselect(ev); // unselect previous selections
@@ -1150,7 +1180,7 @@ class DateSelecting extends internal_cjs.Interaction {
                 if (!disallowed) {
                     dragSelection = joinHitsIntoSelection(initialHit, hit, context.pluginHooks.dateSelectionTransformers);
                 }
-                if (!dragSelection || !internal_cjs.isDateSelectionValid(dragSelection, hit.dateProfile, context)) {
+                if (!dragSelection || !internal.isDateSelectionValid(dragSelection, hit.dateProfile, context)) {
                     isInvalid = true;
                     dragSelection = null;
                 }
@@ -1162,10 +1192,10 @@ class DateSelecting extends internal_cjs.Interaction {
                 context.dispatch({ type: 'UNSELECT_DATES' });
             }
             if (!isInvalid) {
-                internal_cjs.enableCursor();
+                internal.enableCursor();
             }
             else {
-                internal_cjs.disableCursor();
+                internal.disableCursor();
             }
             if (!isFinal) {
                 this.dragSelection = dragSelection; // only clear if moved away from all hits while dragging
@@ -1174,7 +1204,7 @@ class DateSelecting extends internal_cjs.Interaction {
         this.handlePointerUp = (pev) => {
             if (this.dragSelection) {
                 // selection is already rendered, so just need to report selection
-                internal_cjs.triggerDateSelect(this.dragSelection, pev, this.component.context);
+                internal.triggerDateSelect(this.dragSelection, pev, this.component.context);
                 this.dragSelection = null;
             }
         };
@@ -1184,7 +1214,7 @@ class DateSelecting extends internal_cjs.Interaction {
         dragging.touchScrollAllowed = false;
         dragging.minDistance = options.selectMinDistance || 0;
         dragging.autoScroller.isEnabled = options.dragScroll;
-        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal_cjs.interactionSettingsToStore(settings));
+        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal.interactionSettingsToStore(settings));
         hitDragging.emitter.on('pointerdown', this.handlePointerDown);
         hitDragging.emitter.on('dragstart', this.handleDragStart);
         hitDragging.emitter.on('hitupdate', this.handleHitUpdate);
@@ -1211,7 +1241,7 @@ function joinHitsIntoSelection(hit0, hit1, dateSelectionTransformers) {
         dateSpan1.range.start,
         dateSpan1.range.end,
     ];
-    ms.sort(internal_cjs.compareNumbers);
+    ms.sort(internal.compareNumbers);
     let props = {};
     for (let transformer of dateSelectionTransformers) {
         let res = transformer(hit0, hit1);
@@ -1227,7 +1257,7 @@ function joinHitsIntoSelection(hit0, hit1, dateSelectionTransformers) {
     return props;
 }
 
-class EventDragging extends internal_cjs.Interaction {
+class EventDragging extends internal.Interaction {
     constructor(settings) {
         super(settings);
         // internal state
@@ -1245,29 +1275,29 @@ class EventDragging extends internal_cjs.Interaction {
             let { options } = component.context;
             let initialContext = component.context;
             this.subjectEl = ev.subjectEl;
-            let eventRange = this.eventRange = internal_cjs.getElEventRange(ev.subjectEl);
+            let eventRange = this.eventRange = internal.getElEventRange(ev.subjectEl);
             let eventInstanceId = eventRange.instance.instanceId;
-            this.relevantEvents = internal_cjs.getRelevantEvents(initialContext.getCurrentData().eventStore, eventInstanceId);
+            this.relevantEvents = internal.getRelevantEvents(initialContext.getCurrentData().eventStore, eventInstanceId);
             dragging.minDistance = ev.isTouch ? 0 : options.eventDragMinDistance;
             dragging.delay =
                 // only do a touch delay if touch and this event hasn't been selected yet
                 (ev.isTouch && eventInstanceId !== component.props.eventSelection) ?
                     getComponentTouchDelay(component) :
                     null;
-            if (options.fixedMirrorParent) {
-                mirror.parentNode = options.fixedMirrorParent;
+            mirror.parentNode = internal.getAppendableRoot(origTarget);
+            mirror.revertDuration = options.dragRevertDuration;
+            let isValid = component.isValidSegDownEl(origTarget) &&
+                !origTarget.closest(`.${classNames__default["default"].internalEventResizer}`); // NOT on a resizer
+            if (!isValid) {
+                dragging.cancel();
             }
             else {
-                mirror.parentNode = origTarget.closest('.fc');
+                // disable dragging for elements that are resizable (ie, selectable)
+                // but are not draggable
+                // TODO: merge this with .cancel() ?
+                this.isDragging = ev.subjectEl
+                    .classList.contains(classNames__default["default"].internalEventDraggable);
             }
-            mirror.revertDuration = options.dragRevertDuration;
-            let isValid = component.isValidSegDownEl(origTarget) &&
-                !origTarget.closest('.fc-event-resizer'); // NOT on a resizer
-            dragging.setIgnoreMove(!isValid);
-            // disable dragging for elements that are resizable (ie, selectable)
-            // but are not draggable
-            this.isDragging = isValid &&
-                ev.subjectEl.classList.contains('fc-event-draggable');
         };
         this.handleDragStart = (ev) => {
             let initialContext = this.component.context;
@@ -1287,7 +1317,7 @@ class EventDragging extends internal_cjs.Interaction {
                 initialContext.calendarApi.unselect(ev); // unselect *date* selection
                 initialContext.emitter.trigger('eventDragStart', {
                     el: this.subjectEl,
-                    event: new internal_cjs.EventImpl(initialContext, eventRange.def, eventRange.instance),
+                    event: new internal.EventImpl(initialContext, eventRange.def, eventRange.instance),
                     jsEvent: ev.origEvent,
                     view: initialContext.viewApi,
                 });
@@ -1307,7 +1337,7 @@ class EventDragging extends internal_cjs.Interaction {
             let isInvalid = false;
             let interaction = {
                 affectedEvents: relevantEvents,
-                mutatedEvents: internal_cjs.createEmptyEventStore(),
+                mutatedEvents: internal.createEmptyEventStore(),
                 isEvent: true,
             };
             if (hit) {
@@ -1317,13 +1347,13 @@ class EventDragging extends internal_cjs.Interaction {
                     (receivingOptions.editable && receivingOptions.droppable)) {
                     mutation = computeEventMutation(initialHit, hit, this.eventRange.instance.range.start, receivingContext.getCurrentData().pluginHooks.eventDragMutationMassagers);
                     if (mutation) {
-                        mutatedRelevantEvents = internal_cjs.applyMutationToEventStore(relevantEvents, receivingContext.getCurrentData().eventUiBases, mutation, receivingContext);
+                        mutatedRelevantEvents = internal.applyMutationToEventStore(relevantEvents, receivingContext.getCurrentData().eventUiBases, mutation, receivingContext);
                         interaction.mutatedEvents = mutatedRelevantEvents;
-                        if (!internal_cjs.isInteractionValid(interaction, hit.dateProfile, receivingContext)) {
+                        if (!internal.isInteractionValid(interaction, hit.dateProfile, receivingContext)) {
                             isInvalid = true;
                             mutation = null;
                             mutatedRelevantEvents = null;
-                            interaction.mutatedEvents = internal_cjs.createEmptyEventStore();
+                            interaction.mutatedEvents = internal.createEmptyEventStore();
                         }
                     }
                 }
@@ -1333,10 +1363,10 @@ class EventDragging extends internal_cjs.Interaction {
             }
             this.displayDrag(receivingContext, interaction);
             if (!isInvalid) {
-                internal_cjs.enableCursor();
+                internal.enableCursor();
             }
             else {
-                internal_cjs.disableCursor();
+                internal.disableCursor();
             }
             if (!isFinal) {
                 if (initialContext === receivingContext && // TODO: write test for this
@@ -1346,7 +1376,7 @@ class EventDragging extends internal_cjs.Interaction {
                 this.dragging.setMirrorNeedsRevert(!mutation);
                 // render the mirror if no already-rendered mirror
                 // TODO: wish we could somehow wait for dispatch to guarantee render
-                this.dragging.setMirrorIsVisible(!hit || !this.subjectEl.getRootNode().querySelector('.fc-event-mirror'));
+                this.dragging.setMirrorIsVisible(!hit || !this.subjectEl.getRootNode().querySelector(`.${classNames__default["default"].internalEventMirror}`));
                 // assign states based on new hit
                 this.receivingContext = receivingContext;
                 this.validMutation = mutation;
@@ -1365,7 +1395,7 @@ class EventDragging extends internal_cjs.Interaction {
                 let { receivingContext, validMutation } = this;
                 let eventDef = this.eventRange.def;
                 let eventInstance = this.eventRange.instance;
-                let eventApi = new internal_cjs.EventImpl(initialContext, eventDef, eventInstance);
+                let eventApi = new internal.EventImpl(initialContext, eventDef, eventInstance);
                 let relevantEvents = this.relevantEvents;
                 let mutatedRelevantEvents = this.mutatedRelevantEvents;
                 let { finalHit } = this.hitDragging;
@@ -1379,15 +1409,15 @@ class EventDragging extends internal_cjs.Interaction {
                 if (validMutation) {
                     // dropped within same calendar
                     if (receivingContext === initialContext) {
-                        let updatedEventApi = new internal_cjs.EventImpl(initialContext, mutatedRelevantEvents.defs[eventDef.defId], eventInstance ? mutatedRelevantEvents.instances[eventInstance.instanceId] : null);
+                        let updatedEventApi = new internal.EventImpl(initialContext, mutatedRelevantEvents.defs[eventDef.defId], eventInstance ? mutatedRelevantEvents.instances[eventInstance.instanceId] : null);
                         initialContext.dispatch({
                             type: 'MERGE_EVENTS',
                             eventStore: mutatedRelevantEvents,
                         });
-                        let eventChangeArg = {
+                        let eventChangeData = {
                             oldEvent: eventApi,
                             event: updatedEventApi,
-                            relatedEvents: internal_cjs.buildEventApis(mutatedRelevantEvents, initialContext, eventInstance),
+                            relatedEvents: internal.buildEventApis(mutatedRelevantEvents, initialContext, eventInstance),
                             revert() {
                                 initialContext.dispatch({
                                     type: 'MERGE_EVENTS',
@@ -1399,14 +1429,14 @@ class EventDragging extends internal_cjs.Interaction {
                         for (let transformer of initialContext.getCurrentData().pluginHooks.eventDropTransformers) {
                             Object.assign(transformed, transformer(validMutation, initialContext));
                         }
-                        initialContext.emitter.trigger('eventDrop', Object.assign(Object.assign(Object.assign({}, eventChangeArg), transformed), { el: ev.subjectEl, delta: validMutation.datesDelta, jsEvent: ev.origEvent, view: initialView }));
-                        initialContext.emitter.trigger('eventChange', eventChangeArg);
+                        initialContext.emitter.trigger('eventDrop', Object.assign(Object.assign(Object.assign({}, eventChangeData), transformed), { el: ev.subjectEl, delta: validMutation.datesDelta, jsEvent: ev.origEvent, view: initialView }));
+                        initialContext.emitter.trigger('eventChange', eventChangeData);
                         // dropped in different calendar
                     }
                     else if (receivingContext) {
-                        let eventRemoveArg = {
+                        let eventRemoveData = {
                             event: eventApi,
-                            relatedEvents: internal_cjs.buildEventApis(relevantEvents, initialContext, eventInstance),
+                            relatedEvents: internal.buildEventApis(relevantEvents, initialContext, eventInstance),
                             revert() {
                                 initialContext.dispatch({
                                     type: 'MERGE_EVENTS',
@@ -1414,22 +1444,22 @@ class EventDragging extends internal_cjs.Interaction {
                                 });
                             },
                         };
-                        initialContext.emitter.trigger('eventLeave', Object.assign(Object.assign({}, eventRemoveArg), { draggedEl: ev.subjectEl, view: initialView }));
+                        initialContext.emitter.trigger('eventLeave', Object.assign(Object.assign({}, eventRemoveData), { draggedEl: ev.subjectEl, view: initialView }));
                         initialContext.dispatch({
                             type: 'REMOVE_EVENTS',
                             eventStore: relevantEvents,
                         });
-                        initialContext.emitter.trigger('eventRemove', eventRemoveArg);
+                        initialContext.emitter.trigger('eventRemove', eventRemoveData);
                         let addedEventDef = mutatedRelevantEvents.defs[eventDef.defId];
                         let addedEventInstance = mutatedRelevantEvents.instances[eventInstance.instanceId];
-                        let addedEventApi = new internal_cjs.EventImpl(receivingContext, addedEventDef, addedEventInstance);
+                        let addedEventApi = new internal.EventImpl(receivingContext, addedEventDef, addedEventInstance);
                         receivingContext.dispatch({
                             type: 'MERGE_EVENTS',
                             eventStore: mutatedRelevantEvents,
                         });
-                        let eventAddArg = {
+                        let eventAddData = {
                             event: addedEventApi,
-                            relatedEvents: internal_cjs.buildEventApis(mutatedRelevantEvents, receivingContext, addedEventInstance),
+                            relatedEvents: internal.buildEventApis(mutatedRelevantEvents, receivingContext, addedEventInstance),
                             revert() {
                                 receivingContext.dispatch({
                                     type: 'REMOVE_EVENTS',
@@ -1437,7 +1467,7 @@ class EventDragging extends internal_cjs.Interaction {
                                 });
                             },
                         };
-                        receivingContext.emitter.trigger('eventAdd', eventAddArg);
+                        receivingContext.emitter.trigger('eventAdd', eventAddData);
                         if (ev.isTouch) {
                             receivingContext.dispatch({
                                 type: 'SELECT_EVENT',
@@ -1445,7 +1475,7 @@ class EventDragging extends internal_cjs.Interaction {
                             });
                         }
                         receivingContext.emitter.trigger('drop', Object.assign(Object.assign({}, buildDatePointApiWithContext(finalHit.dateSpan, receivingContext)), { draggedEl: ev.subjectEl, jsEvent: ev.origEvent, view: finalHit.context.viewApi }));
-                        receivingContext.emitter.trigger('eventReceive', Object.assign(Object.assign({}, eventAddArg), { draggedEl: ev.subjectEl, view: finalHit.context.viewApi }));
+                        receivingContext.emitter.trigger('eventReceive', Object.assign(Object.assign({}, eventAddData), { draggedEl: ev.subjectEl, view: finalHit.context.viewApi }));
                     }
                 }
                 else {
@@ -1460,7 +1490,7 @@ class EventDragging extends internal_cjs.Interaction {
         dragging.pointer.selector = EventDragging.SELECTOR;
         dragging.touchScrollAllowed = false;
         dragging.autoScroller.isEnabled = options.dragScroll;
-        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal_cjs.interactionSettingsStore);
+        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal.interactionSettingsStore);
         hitDragging.useSubjectCenter = settings.useEventCenter;
         hitDragging.emitter.on('pointerdown', this.handlePointerDown);
         hitDragging.emitter.on('dragstart', this.handleDragStart);
@@ -1484,7 +1514,7 @@ class EventDragging extends internal_cjs.Interaction {
                     type: 'SET_EVENT_DRAG',
                     state: {
                         affectedEvents: state.affectedEvents,
-                        mutatedEvents: internal_cjs.createEmptyEventStore(),
+                        mutatedEvents: internal.createEmptyEventStore(),
                         isEvent: true,
                     },
                 });
@@ -1520,7 +1550,7 @@ class EventDragging extends internal_cjs.Interaction {
 }
 // TODO: test this in IE11
 // QUESTION: why do we need it on the resizable???
-EventDragging.SELECTOR = '.fc-event-draggable, .fc-event-resizable';
+EventDragging.SELECTOR = `.${classNames__default["default"].internalEventDraggable}, .${classNames__default["default"].internalEventResizable}`;
 function computeEventMutation(hit0, hit1, eventInstanceStart, massagers) {
     let dateSpan0 = hit0.dateSpan;
     let dateSpan1 = hit1.dateSpan;
@@ -1533,7 +1563,7 @@ function computeEventMutation(hit0, hit1, eventInstanceStart, massagers) {
         if (dateSpan1.allDay) {
             // means date1 is already start-of-day,
             // but date0 needs to be converted
-            date0 = internal_cjs.startOfDay(eventInstanceStart);
+            date0 = internal.startOfDay(eventInstanceStart);
         }
         else {
             // Moving from allDate->timed
@@ -1541,7 +1571,7 @@ function computeEventMutation(hit0, hit1, eventInstanceStart, massagers) {
             date0 = eventInstanceStart;
         }
     }
-    let delta = internal_cjs.diffDates(date0, date1, hit0.context.dateEnv, hit0.componentId === hit1.componentId ?
+    let delta = internal.diffDates(date0, date1, hit0.context.dateEnv, hit0.componentId === hit1.componentId ?
         hit0.largeUnit :
         null);
     if (delta.milliseconds) { // has hours/minutes/seconds
@@ -1565,7 +1595,7 @@ function getComponentTouchDelay(component) {
     return delay;
 }
 
-class EventResizing extends internal_cjs.Interaction {
+class EventResizing extends internal.Interaction {
     constructor(settings) {
         super(settings);
         // internal state
@@ -1578,23 +1608,25 @@ class EventResizing extends internal_cjs.Interaction {
         this.handlePointerDown = (ev) => {
             let { component } = this;
             let segEl = this.querySegEl(ev);
-            let eventRange = this.eventRange = internal_cjs.getElEventRange(segEl);
+            let eventRange = this.eventRange = internal.getElEventRange(segEl);
             this.dragging.minDistance = component.context.options.eventDragMinDistance;
-            // if touch, need to be working with a selected event
-            this.dragging.setIgnoreMove(!this.component.isValidSegDownEl(ev.origEvent.target) ||
-                (ev.isTouch && this.component.props.eventSelection !== eventRange.instance.instanceId));
+            const isValid = this.component.isValidSegDownEl(ev.origEvent.target) &&
+                !(ev.isTouch && this.component.props.eventSelection !== eventRange.instance.instanceId);
+            if (!isValid) {
+                this.dragging.cancel();
+            }
         };
         this.handleDragStart = (ev) => {
             let { context } = this.component;
             let eventRange = this.eventRange;
-            this.relevantEvents = internal_cjs.getRelevantEvents(context.getCurrentData().eventStore, this.eventRange.instance.instanceId);
+            this.relevantEvents = internal.getRelevantEvents(context.getCurrentData().eventStore, this.eventRange.instance.instanceId);
             let segEl = this.querySegEl(ev);
             this.draggingSegEl = segEl;
-            this.draggingEventRange = internal_cjs.getElEventRange(segEl);
+            this.draggingEventRange = internal.getElEventRange(segEl);
             context.calendarApi.unselect();
             context.emitter.trigger('eventResizeStart', {
                 el: segEl,
-                event: new internal_cjs.EventImpl(context, eventRange.def, eventRange.instance),
+                event: new internal.EventImpl(context, eventRange.def, eventRange.instance),
                 jsEvent: ev.origEvent,
                 view: context.viewApi,
             });
@@ -1609,7 +1641,7 @@ class EventResizing extends internal_cjs.Interaction {
             let isInvalid = false;
             let interaction = {
                 affectedEvents: relevantEvents,
-                mutatedEvents: internal_cjs.createEmptyEventStore(),
+                mutatedEvents: internal.createEmptyEventStore(),
                 isEvent: true,
             };
             if (hit) {
@@ -1617,13 +1649,13 @@ class EventResizing extends internal_cjs.Interaction {
                     && this.isHitComboAllowed
                     && !this.isHitComboAllowed(initialHit, hit);
                 if (!disallowed) {
-                    mutation = computeMutation(initialHit, hit, ev.subjectEl.classList.contains('fc-event-resizer-start'), eventInstance.range);
+                    mutation = computeMutation(initialHit, hit, ev.subjectEl.classList.contains(classNames__default["default"].internalEventResizerStart), eventInstance.range);
                 }
             }
             if (mutation) {
-                mutatedRelevantEvents = internal_cjs.applyMutationToEventStore(relevantEvents, context.getCurrentData().eventUiBases, mutation, context);
+                mutatedRelevantEvents = internal.applyMutationToEventStore(relevantEvents, context.getCurrentData().eventUiBases, mutation, context);
                 interaction.mutatedEvents = mutatedRelevantEvents;
-                if (!internal_cjs.isInteractionValid(interaction, hit.dateProfile, context)) {
+                if (!internal.isInteractionValid(interaction, hit.dateProfile, context)) {
                     isInvalid = true;
                     mutation = null;
                     mutatedRelevantEvents = null;
@@ -1640,10 +1672,10 @@ class EventResizing extends internal_cjs.Interaction {
                 context.dispatch({ type: 'UNSET_EVENT_RESIZE' });
             }
             if (!isInvalid) {
-                internal_cjs.enableCursor();
+                internal.enableCursor();
             }
             else {
-                internal_cjs.disableCursor();
+                internal.disableCursor();
             }
             if (!isFinal) {
                 if (mutation && isHitsEqual(initialHit, hit)) {
@@ -1657,7 +1689,7 @@ class EventResizing extends internal_cjs.Interaction {
             let { context } = this.component;
             let eventDef = this.eventRange.def;
             let eventInstance = this.eventRange.instance;
-            let eventApi = new internal_cjs.EventImpl(context, eventDef, eventInstance);
+            let eventApi = new internal.EventImpl(context, eventDef, eventInstance);
             let relevantEvents = this.relevantEvents;
             let mutatedRelevantEvents = this.mutatedRelevantEvents;
             context.emitter.trigger('eventResizeStop', {
@@ -1667,15 +1699,15 @@ class EventResizing extends internal_cjs.Interaction {
                 view: context.viewApi,
             });
             if (this.validMutation) {
-                let updatedEventApi = new internal_cjs.EventImpl(context, mutatedRelevantEvents.defs[eventDef.defId], eventInstance ? mutatedRelevantEvents.instances[eventInstance.instanceId] : null);
+                let updatedEventApi = new internal.EventImpl(context, mutatedRelevantEvents.defs[eventDef.defId], eventInstance ? mutatedRelevantEvents.instances[eventInstance.instanceId] : null);
                 context.dispatch({
                     type: 'MERGE_EVENTS',
                     eventStore: mutatedRelevantEvents,
                 });
-                let eventChangeArg = {
+                let eventChangeData = {
                     oldEvent: eventApi,
                     event: updatedEventApi,
-                    relatedEvents: internal_cjs.buildEventApis(mutatedRelevantEvents, context, eventInstance),
+                    relatedEvents: internal.buildEventApis(mutatedRelevantEvents, context, eventInstance),
                     revert() {
                         context.dispatch({
                             type: 'MERGE_EVENTS',
@@ -1683,8 +1715,8 @@ class EventResizing extends internal_cjs.Interaction {
                         });
                     },
                 };
-                context.emitter.trigger('eventResize', Object.assign(Object.assign({}, eventChangeArg), { el: this.draggingSegEl, startDelta: this.validMutation.startDelta || internal_cjs.createDuration(0), endDelta: this.validMutation.endDelta || internal_cjs.createDuration(0), jsEvent: ev.origEvent, view: context.viewApi }));
-                context.emitter.trigger('eventChange', eventChangeArg);
+                context.emitter.trigger('eventResize', Object.assign(Object.assign({}, eventChangeData), { el: this.draggingSegEl, startDelta: this.validMutation.startDelta || internal.createDuration(0), endDelta: this.validMutation.endDelta || internal.createDuration(0), jsEvent: ev.origEvent, view: context.viewApi }));
+                context.emitter.trigger('eventChange', eventChangeData);
             }
             else {
                 context.emitter.trigger('_noEventResize');
@@ -1697,10 +1729,10 @@ class EventResizing extends internal_cjs.Interaction {
         };
         let { component } = settings;
         let dragging = this.dragging = new FeaturefulElementDragging(settings.el);
-        dragging.pointer.selector = '.fc-event-resizer';
+        dragging.pointer.selector = `.${classNames__default["default"].internalEventResizer}`;
         dragging.touchScrollAllowed = false;
         dragging.autoScroller.isEnabled = component.context.options.dragScroll;
-        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal_cjs.interactionSettingsToStore(settings));
+        let hitDragging = this.hitDragging = new HitDragging(this.dragging, internal.interactionSettingsToStore(settings));
         hitDragging.emitter.on('pointerdown', this.handlePointerDown);
         hitDragging.emitter.on('dragstart', this.handleDragStart);
         hitDragging.emitter.on('hitupdate', this.handleHitUpdate);
@@ -1710,14 +1742,14 @@ class EventResizing extends internal_cjs.Interaction {
         this.dragging.destroy();
     }
     querySegEl(ev) {
-        return ev.subjectEl.closest('.fc-event');
+        return ev.subjectEl.closest(`.${classNames__default["default"].internalEvent}`);
     }
 }
 function computeMutation(hit0, hit1, isFromStart, instanceRange) {
     let dateEnv = hit0.context.dateEnv;
     let date0 = hit0.dateSpan.range.start;
     let date1 = hit1.dateSpan.range.start;
-    let delta = internal_cjs.diffDates(date0, date1, dateEnv, hit0.largeUnit);
+    let delta = internal.diffDates(date0, date1, dateEnv, hit0.largeUnit);
     if (isFromStart) {
         if (dateEnv.add(instanceRange.start, delta) < instanceRange.end) {
             return { startDelta: delta };
@@ -1735,14 +1767,14 @@ class UnselectAuto {
         this.isRecentPointerDateSelect = false; // wish we could use a selector to detect date selection, but uses hit system
         this.matchesCancel = false;
         this.matchesEvent = false;
-        this.onSelect = (selectInfo) => {
-            if (selectInfo.jsEvent) {
+        this.onSelect = (selectData) => {
+            if (selectData.jsEvent) {
                 this.isRecentPointerDateSelect = true;
             }
         };
         this.onDocumentPointerDown = (pev) => {
             let unselectCancel = this.context.options.unselectCancel;
-            let downEl = internal_cjs.getEventTargetViaRoot(pev.origEvent);
+            let downEl = internal.getEventTargetViaRoot(pev.origEvent);
             this.matchesCancel = !!downEl.closest(unselectCancel);
             this.matchesEvent = !!downEl.closest(EventDragging.SELECTOR); // interaction started on an event?
         };
@@ -1784,20 +1816,18 @@ class UnselectAuto {
     }
 }
 
-const OPTION_REFINERS = {
-    fixedMirrorParent: internal_cjs.identity,
-};
+const OPTION_REFINERS = {};
 const LISTENER_REFINERS = {
-    dateClick: internal_cjs.identity,
-    eventDragStart: internal_cjs.identity,
-    eventDragStop: internal_cjs.identity,
-    eventDrop: internal_cjs.identity,
-    eventResizeStart: internal_cjs.identity,
-    eventResizeStop: internal_cjs.identity,
-    eventResize: internal_cjs.identity,
-    drop: internal_cjs.identity,
-    eventReceive: internal_cjs.identity,
-    eventLeave: internal_cjs.identity,
+    dateClick: internal.identity,
+    eventDragStart: internal.identity,
+    eventDragStop: internal.identity,
+    eventDrop: internal.identity,
+    eventResizeStart: internal.identity,
+    eventResizeStop: internal.identity,
+    eventResize: internal.identity,
+    drop: internal.identity,
+    eventReceive: internal.identity,
+    eventLeave: internal.identity,
 };
 
 /*
@@ -1820,18 +1850,18 @@ class ExternalElementDragging {
             let droppableEvent = null;
             let isInvalid = false;
             let interaction = {
-                affectedEvents: internal_cjs.createEmptyEventStore(),
-                mutatedEvents: internal_cjs.createEmptyEventStore(),
+                affectedEvents: internal.createEmptyEventStore(),
+                mutatedEvents: internal.createEmptyEventStore(),
                 isEvent: this.dragMeta.create,
             };
             if (hit) {
                 receivingContext = hit.context;
                 if (this.canDropElOnCalendar(ev.subjectEl, receivingContext)) {
                     droppableEvent = computeEventForDateSpan(hit.dateSpan, this.dragMeta, receivingContext);
-                    interaction.mutatedEvents = internal_cjs.eventTupleToStore(droppableEvent);
-                    isInvalid = !internal_cjs.isInteractionValid(interaction, hit.dateProfile, receivingContext);
+                    interaction.mutatedEvents = internal.eventTupleToStore(droppableEvent);
+                    isInvalid = !internal.isInteractionValid(interaction, hit.dateProfile, receivingContext);
                     if (isInvalid) {
-                        interaction.mutatedEvents = internal_cjs.createEmptyEventStore();
+                        interaction.mutatedEvents = internal.createEmptyEventStore();
                         droppableEvent = null;
                     }
                 }
@@ -1839,12 +1869,14 @@ class ExternalElementDragging {
             this.displayDrag(receivingContext, interaction);
             // show mirror if no already-rendered mirror element OR if we are shutting down the mirror (?)
             // TODO: wish we could somehow wait for dispatch to guarantee render
-            dragging.setMirrorIsVisible(isFinal || !droppableEvent || !document.querySelector('.fc-event-mirror'));
+            dragging.setMirrorIsVisible(isFinal ||
+                !droppableEvent ||
+                !document.querySelector(`.${classNames__default["default"].internalEventMirror}`));
             if (!isInvalid) {
-                internal_cjs.enableCursor();
+                internal.enableCursor();
             }
             else {
-                internal_cjs.disableCursor();
+                internal.disableCursor();
             }
             if (!isFinal) {
                 dragging.setMirrorNeedsRevert(!droppableEvent);
@@ -1861,7 +1893,7 @@ class ExternalElementDragging {
                 let dragMeta = this.dragMeta;
                 receivingContext.emitter.trigger('drop', Object.assign(Object.assign({}, buildDatePointApiWithContext(finalHit.dateSpan, receivingContext)), { draggedEl: pev.subjectEl, jsEvent: pev.origEvent, view: finalView }));
                 if (dragMeta.create) {
-                    let addingEvents = internal_cjs.eventTupleToStore(droppableEvent);
+                    let addingEvents = internal.eventTupleToStore(droppableEvent);
                     receivingContext.dispatch({
                         type: 'MERGE_EVENTS',
                         eventStore: addingEvents,
@@ -1874,7 +1906,7 @@ class ExternalElementDragging {
                     }
                     // signal that an external event landed
                     receivingContext.emitter.trigger('eventReceive', {
-                        event: new internal_cjs.EventImpl(receivingContext, droppableEvent.def, droppableEvent.instance),
+                        event: new internal.EventImpl(receivingContext, droppableEvent.def, droppableEvent.instance),
                         relatedEvents: [],
                         revert() {
                             receivingContext.dispatch({
@@ -1890,7 +1922,7 @@ class ExternalElementDragging {
             this.receivingContext = null;
             this.droppableEvent = null;
         };
-        let hitDragging = this.hitDragging = new HitDragging(dragging, internal_cjs.interactionSettingsStore);
+        let hitDragging = this.hitDragging = new HitDragging(dragging, internal.interactionSettingsStore);
         hitDragging.requireInitial = false; // will start outside of a component
         hitDragging.emitter.on('dragstart', this.handleDragStart);
         hitDragging.emitter.on('hitupdate', this.handleHitUpdate);
@@ -1899,10 +1931,10 @@ class ExternalElementDragging {
     }
     buildDragMeta(subjectEl) {
         if (typeof this.suppliedDragMeta === 'object') {
-            return internal_cjs.parseDragMeta(this.suppliedDragMeta);
+            return internal.parseDragMeta(this.suppliedDragMeta);
         }
         if (typeof this.suppliedDragMeta === 'function') {
-            return internal_cjs.parseDragMeta(this.suppliedDragMeta(subjectEl));
+            return internal.parseDragMeta(this.suppliedDragMeta(subjectEl));
         }
         return getDragMetaFromEl(subjectEl);
     }
@@ -1938,8 +1970,8 @@ function computeEventForDateSpan(dateSpan, dragMeta, context) {
     for (let transform of context.pluginHooks.externalDefTransforms) {
         Object.assign(defProps, transform(dateSpan, dragMeta));
     }
-    let { refined, extra } = internal_cjs.refineEventDef(defProps, context);
-    let def = internal_cjs.parseEventDef(refined, extra, dragMeta.sourceId, dateSpan.allDay, context.options.forceEventDuration || Boolean(dragMeta.duration), // hasEnd
+    let { refined, extra } = internal.refineEventDef(defProps, context);
+    let def = internal.parseEventDef(refined, extra, dragMeta.sourceId, dateSpan.allDay, context.options.forceEventDuration || Boolean(dragMeta.duration), // hasEnd
     context);
     let start = dateSpan.range.start;
     // only rely on time info if drop zone is all-day,
@@ -1949,8 +1981,8 @@ function computeEventForDateSpan(dateSpan, dragMeta, context) {
     }
     let end = dragMeta.duration ?
         context.dateEnv.add(start, dragMeta.duration) :
-        internal_cjs.getDefaultEventEnd(dateSpan.allDay, start, context);
-    let instance = internal_cjs.createEventInstance(def.defId, { start, end });
+        internal.getDefaultEventEnd(dateSpan.allDay, start, context);
+    let instance = internal.createEventInstance(def.defId, { start, end });
     return { def, instance };
 }
 // Utils for extracting data from element
@@ -1960,11 +1992,11 @@ function getDragMetaFromEl(el) {
     let obj = str ?
         JSON.parse(str) :
         { create: false }; // if no embedded data, assume no event creation
-    return internal_cjs.parseDragMeta(obj);
+    return internal.parseDragMeta(obj);
 }
-internal_cjs.config.dataAttrPrefix = '';
+internal.config.dataAttrPrefix = '';
 function getEmbeddedElData(el, name) {
-    let prefix = internal_cjs.config.dataAttrPrefix;
+    let prefix = internal.config.dataAttrPrefix;
     let prefixedName = (prefix ? prefix + '-' : '') + name;
     return el.getAttribute('data-' + prefixedName) || '';
 }
@@ -1982,17 +2014,17 @@ class ExternalDraggable {
             dragging.minDistance =
                 minDistance != null ?
                     minDistance :
-                    (ev.isTouch ? 0 : internal_cjs.BASE_OPTION_DEFAULTS.eventDragMinDistance);
+                    (ev.isTouch ? 0 : internal.BASE_OPTION_DEFAULTS.eventDragMinDistance);
             dragging.delay =
                 ev.isTouch ? // TODO: eventually read eventLongPressDelay instead vvv
-                    (longPressDelay != null ? longPressDelay : internal_cjs.BASE_OPTION_DEFAULTS.longPressDelay) :
+                    (longPressDelay != null ? longPressDelay : internal.BASE_OPTION_DEFAULTS.longPressDelay) :
                     0;
         };
         this.handleDragStart = (ev) => {
             if (ev.isTouch &&
                 this.dragging.delay &&
-                ev.subjectEl.classList.contains('fc-event')) {
-                this.dragging.mirror.getMirrorEl().classList.add('fc-event-selected');
+                ev.subjectEl.classList.contains(classNames__default["default"].internalEvent)) {
+                this.dragging.mirror.getMirrorEl().classList.add(classNames__default["default"].internalEventSelected);
             }
         };
         this.settings = settings;
@@ -2019,7 +2051,7 @@ The third-party system is responsible for drawing the visuals effects of the dra
 This class simply monitors for pointer movements and fires events.
 It also has the ability to hide the moving element (the "mirror") during the drag.
 */
-class InferredElementDragging extends internal_cjs.ElementDragging {
+class InferredElementDragging extends internal.ElementDragging {
     constructor(containerEl) {
         super(containerEl);
         this.shouldIgnoreMove = false;
@@ -2052,8 +2084,8 @@ class InferredElementDragging extends internal_cjs.ElementDragging {
     destroy() {
         this.pointer.destroy();
     }
-    setIgnoreMove(bool) {
-        this.shouldIgnoreMove = bool;
+    cancel() {
+        this.shouldIgnoreMove = true;
     }
     setMirrorIsVisible(bool) {
         if (bool) {
@@ -2114,7 +2146,7 @@ class ThirdPartyDraggable {
     }
 }
 
-var index = index_cjs.createPlugin({
+var index = core.createPlugin({
     name: '@fullcalendar/interaction',
     componentInteractions: [DateClicking, DateSelecting, EventDragging, EventResizing],
     calendarInteractions: [UnselectAuto],