/* eslint-disable */
/*eslint no-unused-vars: "off" */
/* Miqra Engineering: (c) 2020 added modifications to work as es6 module and preserve vue tag names during minification
*/
import './reflect-metadata';
import { Vue, Component, Prop } from './vue-property-decorator';

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */

function __decorate(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}

function __metadata(metadataKey, metadataValue) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}

/**
 * This is the class of the global object that holds the state of the drag and drop during its progress. It emits events
 * reporting its state evolution during the progress of the drag and drop. Its data is reactive and listeners can be
 * attachted to it using the method on.
 */
var DnD = function DnD() {
    this.inProgress = false;
    this.type = null;
    this.data = null;
    this.source = null;
    this.top = null;
    this.position = null;
    this.eventBus = new Vue();
    this.sourceListeners = null;
    this.success = null;
};
DnD.prototype.startDrag = function startDrag (source, event, x, y, type, data) {
    this.type = type;
    this.data = data;
    this.source = source;
    this.position = {
        x: x,
        y: y
    };
    this.top = null;
    this.sourceListeners = source.$listeners;
    this.inProgress = true;
    this.emit(event, "dragstart");
    this.emit(event, "dragtopchanged", { previousTop: null });
};
DnD.prototype.stopDrag = function stopDrag (event) {
    this.success = this.top !== null && this.top['compatibleMode'] && this.top['dropAllowed'];
    if (this.top !== null) {
        this.emit(event, "drop");
    }
    this.emit(event, "dragend");
    this.inProgress = false;
    this.data = null;
    this.source = null;
    this.position = null;
    this.success = null;
};
DnD.prototype.mouseMove = function mouseMove (event, comp) {
    if (this.inProgress) {
        var prevent = false;
        var previousTop = this.top;
        if (comp === null) {
            // The mouse move event reached the top of the document without hitting a drop component.
            this.top = null;
            prevent = true;
        }
        else if (comp['isDropMask']) {
            // The mouse move event bubbled until it reached a drop mask.
            this.top = null;
            prevent = true;
        }
        else if (comp['candidate'](this.type, this.data, this.source)) {
            // The mouse move event bubbled until it reached a drop component that participates in the current drag operation.
            this.top = comp;
            prevent = true;
        }
        if (prevent) {
            // We prevent the mouse move event from bubbling further up the tree because it reached the foremost drop component and that component is all that matters.
            event.stopPropagation();
        }
        if (this.top !== previousTop) {
            this.emit(event.detail.native, 'dragtopchanged', { previousTop: previousTop });
        }
        this.position = {
            x: event.detail.x,
            y: event.detail.y
        };
        this.emit(event.detail.native, 'dragpositionchanged');
    }
};
DnD.prototype.emit = function emit (native, event, data) {
    this.eventBus.$emit(event, Object.assign({}, {type: this.type,
        data: this.data,
        top: this.top,
        source: this.source,
        position: this.position,
        success: this.success,
        native: native},
        data));
};
DnD.prototype.on = function on (event, callback) {
    this.eventBus.$on(event, callback);
};
DnD.prototype.off = function off (event, callback) {
    this.eventBus.$off(event, callback);
};
var dnd = new DnD();
dnd = Vue.observable(dnd);

var DragAwareMixin = /*@__PURE__*/(function (Vue) {
    function DragAwareMixin () {
        Vue.apply(this, arguments);
    }

    if ( Vue ) DragAwareMixin.__proto__ = Vue;
    DragAwareMixin.prototype = Object.create( Vue && Vue.prototype );
    DragAwareMixin.prototype.constructor = DragAwareMixin;

    var prototypeAccessors = { dragInProgress: { configurable: true },dragData: { configurable: true },dragType: { configurable: true },dragPosition: { configurable: true },dragSource: { configurable: true },dragTop: { configurable: true } };

    prototypeAccessors.dragInProgress.get = function () {
        return dnd.inProgress;
    };
    prototypeAccessors.dragData.get = function () {
        return dnd.data;
    };
    prototypeAccessors.dragType.get = function () {
        return dnd.type;
    };
    prototypeAccessors.dragPosition.get = function () {
        return dnd.position;
    };
    prototypeAccessors.dragSource.get = function () {
        return dnd.source;
    };
    prototypeAccessors.dragTop.get = function () {
        return dnd.top;
    };

    Object.defineProperties( DragAwareMixin.prototype, prototypeAccessors );

    return DragAwareMixin;
}(Vue));
DragAwareMixin = __decorate([
    Component({ name: "DragAwareMixin",})
], DragAwareMixin);
var DragAwareMixin$1 = DragAwareMixin;

/**
 * This files contains the primitives required to create drag images from HTML elements that serve as models. A snapshot
 * of the computed styles of the model elements is taken when creating the drag image, so that it will look the same as
 * the model, no matter where the drag images is grafted into the DOM.
 */
/**
 * Creates a drag image using the given element as model.
 */
function createDragImage(el) {
    var clone = deepClone(el);
    clone.style.position = 'fixed';
    clone.style.margin = '0';
    clone.style["z-index"] = '1000';
    clone.style.transition = 'opacity 0.2s';
    return clone;
}
/**
 * Clones the given element and all its descendants.
 */
function deepClone(el) {
    var clone = el.cloneNode(true);
    copyStyle(el, clone);
    var vSrcElements = el.getElementsByTagName("*");
    var vDstElements = clone.getElementsByTagName("*");
    for (var i = vSrcElements.length; i--;) {
        var vSrcElement = vSrcElements[i];
        var vDstElement = vDstElements[i];
        copyStyle(vSrcElement, vDstElement);
    }
    return clone;
}
/**
 * Copy the computed styles from src to destination.
 */
function copyStyle(src, destination) {
    var computedStyle = window.getComputedStyle(src);
    Array.from(computedStyle).forEach(function (key) {
        destination.style.setProperty(key, computedStyle.getPropertyValue(key), computedStyle.getPropertyPriority(key));
    });
    destination.style.pointerEvents = 'none';
}

var DragMixin = /*@__PURE__*/(function (DragAwareMixin) {
    function DragMixin() {
        DragAwareMixin.apply(this, arguments);
        this.isDrag = true;
        this.mouseIn = null;
    }

    if ( DragAwareMixin ) DragMixin.__proto__ = DragAwareMixin;
    DragMixin.prototype = Object.create( DragAwareMixin && DragAwareMixin.prototype );
    DragMixin.prototype.constructor = DragMixin;

    var prototypeAccessors = { dragIn: { configurable: true },cssClasses: { configurable: true },currentDropMode: { configurable: true } };
    DragMixin.prototype.created = function created () {
        this.reEmit("dragstart");
        this.reEmit("dragend");
    };
    DragMixin.prototype.reEmit = function reEmit (eventName) {
        var this$1 = this;

        dnd.on(eventName, function (ev) {
            if (ev.source === this$1) {
                this$1.$emit(eventName, ev);
            }
        });
    };
    DragMixin.prototype.mounted = function mounted () {
        var isNodeList = function (el) {
            return 'item' in el;
        };
        var comp = this;
        var el = this.$el;
        var dragStarted = false;
        var initialUserSelect;
        var downEvent = null;
        var startPosition = null;
        if (this.handle) {
            el = this.$el.querySelectorAll(this.handle);
        }
        if (isNodeList(el)) {
            el.forEach(function (element) {
                element.addEventListener('mousedown', onMouseDown);
                element.addEventListener('touchstart', onMouseDown);
                element.addEventListener('mouseenter', onMouseEnter);
                element.addEventListener('mouseleave', onMouseLeave);
            });
        }
        else {
            el.addEventListener('mousedown', onMouseDown);
            el.addEventListener('touchstart', onMouseDown);
            el.addEventListener('mouseenter', onMouseEnter);
            el.addEventListener('mouseleave', onMouseLeave);
        }
        function onMouseEnter() {
            comp.mouseIn = true;
        }
        function onMouseLeave() {
            comp.mouseIn = false;
        }
        function noop(e) {
            e.stopPropagation();
            e.preventDefault();
        }
        function onMouseDown(e) {
            if (!comp.disabled && downEvent === null) {
                initialUserSelect = document.body.style.userSelect;
                document.documentElement.style.userSelect = 'none'; // Permet au drag de se poursuivre normalement même
                // quand on quitte un élémént avec overflow: hidden.
                dragStarted = false;
                downEvent = e;
                if (downEvent.type === 'mousedown') {
                    var mouse = event;
                    startPosition = {
                        x: mouse.clientX,
                        y: mouse.clientY
                    };
                }
                else {
                    var touch = event;
                    startPosition = {
                        x: touch.touches[0].clientX,
                        y: touch.touches[0].clientY
                    };
                }
                document.addEventListener('mousemove', onMouseMove);
                document.addEventListener('touchmove', onMouseMove, { passive: false });
                document.addEventListener('easy-dnd-move', onEasyDnDMove);
                document.addEventListener('mouseup', onMouseUp);
                document.addEventListener('touchend', onMouseUp);
                document.addEventListener('selectstart', noop);
                // Prevents event from bubbling to ancestor drag components and initiate several drags at the same time
                e.stopPropagation();
                // Prevents touchstart event to be converted to mousedown
                //e.preventDefault();
            }
        }
        function onMouseMove(e) {
            // We ignore the mousemove event that follows touchend :
            if (downEvent === null)
                { return; }
            // On touch devices, we ignore fake mouse events and deal with touch events only.
            if (downEvent.type === 'touchstart' && e.type === 'mousemove')
                { return; }
            // Find out event target and pointer position :
            var target;
            var x;
            var y;
            if (e.type === 'touchmove') {
                var touch = e;
                x = touch.touches[0].clientX;
                y = touch.touches[0].clientY;
                target = document.elementFromPoint(x, y);
            }
            else {
                var mouse = e;
                x = mouse.clientX;
                y = mouse.clientY;
                target = mouse.target;
            }
            // Distance between current event and start position :
            var dist = Math.sqrt(Math.pow(startPosition.x - x, 2) + Math.pow(startPosition.y - y, 2));
            // If the drag has not begun yet and distance from initial point is greater than delta, we start the drag :
            if (!dragStarted && dist > comp.delta) {
                dragStarted = true;
                dnd.startDrag(comp, downEvent, startPosition.x, startPosition.y, comp.type, comp.data);
                document.documentElement.classList.add('drag-in-progress');
            }
            // Dispatch custom easy-dnd-move event :
            if (dragStarted) {
                var custom = new CustomEvent("easy-dnd-move", {
                    bubbles: true,
                    cancelable: true,
                    detail: {
                        x: x,
                        y: y,
                        native: e
                    }
                });
                target.dispatchEvent(custom);
            }
            // Prevent scroll on touch devices :
            e.preventDefault();
        }
        function onEasyDnDMove(e) {
            dnd.mouseMove(e, null);
        }
        function onMouseUp(e) {
            // On touch devices, we ignore fake mouse events and deal with touch events only.
            if (downEvent.type === 'touchstart' && e.type === 'mouseup')
                { return; }
            downEvent = null;
            // This delay makes sure that when the click event that results from the mouseup is produced, the drag is still
            // in progress. So by checking the flag dnd.inProgress, one can tell appart true clicks from drag and drop artefacts.
            setTimeout(function () {
                if (dragStarted) {
                    document.documentElement.classList.remove('drag-in-progress');
                    dnd.stopDrag(e);
                }
                document.removeEventListener('mousemove', onMouseMove);
                document.removeEventListener('touchmove', onMouseMove);
                document.removeEventListener('easy-dnd-move', onEasyDnDMove);
                document.removeEventListener('mouseup', onMouseUp);
                document.removeEventListener('touchend', onMouseUp);
                document.removeEventListener('selectstart', noop);
                document.documentElement.style.userSelect = initialUserSelect;
            }, 0);
        }
    };
    prototypeAccessors.dragIn.get = function () {
        return !this.dragInProgress && this.mouseIn;
    };
    prototypeAccessors.cssClasses.get = function () {
        if (!this.disabled) {
            return {
                'drag-source': this.dragInProgress && this.dragSource === this,
                'drag-in': this.dragIn,
                'drag-out': !this.dragIn,
                'drag-mode-copy': this.currentDropMode === 'copy',
                'drag-mode-cut': this.currentDropMode === 'cut',
                'drag-mode-reordering': this.currentDropMode === 'reordering',
            };
        }
        else {
            return {};
        }
    };
    prototypeAccessors.currentDropMode.get = function () {
        if (this.dragInProgress && this.dragSource === this) {
            if (this.dragTop && this.dragTop['dropAllowed']) {
                if (this.dragTop['reordering'])
                    { return 'reordering'; }
                else
                    { return this.dragTop['mode']; }
            }
            else {
                return null;
            }
        }
        else {
            return null;
        }
    };
    DragMixin.prototype.createDragImage = function createDragImage$1 (selfTransform) {
        var image;
        if (this.$scopedSlots['drag-image']) {
            var el = this.$refs['drag-image'];
            if (el.childElementCount !== 1) {
                image = createDragImage(el);
            }
            else {
                image = createDragImage(el.children.item(0));
            }
        }
        else {
            image = createDragImage(this.$el);
            image.style.transform = selfTransform;
        }
        image['__opacity'] = this.dragImageOpacity;
        return image;
    };

    Object.defineProperties( DragMixin.prototype, prototypeAccessors );

    return DragMixin;
}(DragAwareMixin$1));
__decorate([
    Prop({ default: null, type: null }),
    __metadata("design:type", String)
], DragMixin.prototype, "type", void 0);
__decorate([
    Prop({ default: null, type: null }),
    __metadata("design:type", Object)
], DragMixin.prototype, "data", void 0);
__decorate([
    Prop({ default: 0.7, type: Number }),
    __metadata("design:type", Object)
], DragMixin.prototype, "dragImageOpacity", void 0);
__decorate([
    Prop({ default: false, type: Boolean }),
    __metadata("design:type", Boolean)
], DragMixin.prototype, "disabled", void 0);
__decorate([
    Prop({ default: false, type: Boolean }),
    __metadata("design:type", Boolean)
], DragMixin.prototype, "goBack", void 0);
__decorate([
    Prop({ required: false, type: String }),
    __metadata("design:type", String)
], DragMixin.prototype, "handle", void 0);
__decorate([
    Prop({ type: Number, default: 3 }),
    __metadata("design:type", Number)
], DragMixin.prototype, "delta", void 0);
DragMixin = __decorate([
    Component({ name: "DragMixin",})
], DragMixin);
var DragMixin$1 = DragMixin;

var Drag = /*@__PURE__*/(function (DragMixin) {
    function Drag () {
        DragMixin.apply(this, arguments);
    }if ( DragMixin ) Drag.__proto__ = DragMixin;
    Drag.prototype = Object.create( DragMixin && DragMixin.prototype );
    Drag.prototype.constructor = Drag;

    

    return Drag;
}(DragMixin$1));
__decorate([
    Prop({ default: 'div', type: [String, Object, Function] }),
    __metadata("design:type", Object)
], Drag.prototype, "tag", void 0);
Drag = __decorate([
    Component({ name: "Drag",})
], Drag);
var script = Drag;

function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier
/* server only */
, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
  if (typeof shadowMode !== 'boolean') {
    createInjectorSSR = createInjector;
    createInjector = shadowMode;
    shadowMode = false;
  } // Vue.extend constructor export interop.


  var options = typeof script === 'function' ? script.options : script; // render functions

  if (template && template.render) {
    options.render = template.render;
    options.staticRenderFns = template.staticRenderFns;
    options._compiled = true; // functional template

    if (isFunctionalTemplate) {
      options.functional = true;
    }
  } // scopedId


  if (scopeId) {
    options._scopeId = scopeId;
  }

  var hook;

  if (moduleIdentifier) {
    // server build
    hook = function hook(context) {
      // 2.3 injection
      context = context || // cached call
      this.$vnode && this.$vnode.ssrContext || // stateful
      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
      // 2.2 with runInNewContext: true

      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
        context = __VUE_SSR_CONTEXT__;
      } // inject component styles


      if (style) {
        style.call(this, createInjectorSSR(context));
      } // register component module identifier for async chunk inference


      if (context && context._registeredComponents) {
        context._registeredComponents.add(moduleIdentifier);
      }
    }; // used by ssr in case component is cached and beforeCreate
    // never gets called


    options._ssrRegister = hook;
  } else if (style) {
    hook = shadowMode ? function () {
      style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
    } : function (context) {
      style.call(this, createInjector(context));
    };
  }

  if (hook) {
    if (options.functional) {
      // register for functional component in vue file
      var originalRender = options.render;

      options.render = function renderWithStyleInjection(h, context) {
        hook.call(context);
        return originalRender(h, context);
      };
    } else {
      // inject component registration as beforeCreate hook
      var existing = options.beforeCreate;
      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
    }
  }

  return script;
}

var normalizeComponent_1 = normalizeComponent;

var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase());
function createInjector(context) {
  return function (id, style) {
    return addStyle(id, style);
  };
}
var HEAD;
var styles = {};

function addStyle(id, css) {
  var group = isOldIE ? css.media || 'default' : id;
  var style = styles[group] || (styles[group] = {
    ids: new Set(),
    styles: []
  });

  if (!style.ids.has(id)) {
    style.ids.add(id);
    var code = css.source;

    if (css.map) {
      // https://developer.chrome.com/devtools/docs/javascript-debugging
      // this makes source maps inside style tags work properly in Chrome
      code += '\n/*# sourceURL=' + css.map.sources[0] + ' */'; // http://stackoverflow.com/a/26603875

      code += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(css.map)))) + ' */';
    }

    if (!style.element) {
      style.element = document.createElement('style');
      style.element.type = 'text/css';
      if (css.media) { style.element.setAttribute('media', css.media); }

      if (HEAD === undefined) {
        HEAD = document.head || document.getElementsByTagName('head')[0];
      }

      HEAD.appendChild(style.element);
    }

    if ('styleSheet' in style.element) {
      style.styles.push(code);
      style.element.styleSheet.cssText = style.styles.filter(Boolean).join('\n');
    } else {
      var index = style.ids.size - 1;
      var textNode = document.createTextNode(code);
      var nodes = style.element.childNodes;
      if (nodes[index]) { style.element.removeChild(nodes[index]); }
      if (nodes.length) { style.element.insertBefore(textNode, nodes[index]); }else { style.element.appendChild(textNode); }
    }
  }
}

var browser = createInjector;

/* script */
var __vue_script__ = script;

/* template */
var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c(_vm.tag,_vm._g(_vm._b({tag:"component",class:_vm.cssClasses,style:({cursor: _vm.disabled || _vm.handle ? null : 'grab'}),scopedSlots:_vm._u([_vm._l((_vm.$scopedSlots),function(_,slot){return {key:slot,fn:function(scope){return [_vm._t(slot,null,null,scope)]}}})],null,true)},'component',_vm.$attrs,false),_vm.$listeners),[_vm._t("default"),_vm._v(" "),_vm._v(" "),_c('div',{ref:"drag-image",staticClass:"__drag-image"},[_vm._t("drag-image")],2)],2)};
var __vue_staticRenderFns__ = [];

  /* style */
  var __vue_inject_styles__ = function (inject) {
    if (!inject) { return }
    inject("data-v-15f89b5d_0", { source: ".drop-allowed.drop-in *{cursor:inherit!important}.drop-forbidden.drop-in,.drop-forbidden.drop-in *{cursor:no-drop!important}", map: undefined, media: undefined })
,inject("data-v-15f89b5d_1", { source: "html.drag-in-progress *{cursor:grabbing!important}", map: undefined, media: undefined })
,inject("data-v-15f89b5d_2", { source: ".__drag-image[data-v-15f89b5d]{position:fixed;top:-10000px;left:-10000px;will-change:left,top}", map: undefined, media: undefined });

  };
  /* scoped */
  var __vue_scope_id__ = "data-v-15f89b5d";
  /* module identifier */
  var __vue_module_identifier__ = undefined;
  /* functional template */
  var __vue_is_functional_template__ = false;
  /* style inject SSR */
  

  
  var Drag$1 = normalizeComponent_1(
    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
    __vue_inject_styles__,
    __vue_script__,
    __vue_scope_id__,
    __vue_is_functional_template__,
    __vue_module_identifier__,
    browser,
    undefined
  );

var DropMixin = /*@__PURE__*/(function (DragAwareMixin) {
    function DropMixin() {
        DragAwareMixin.call(this);
        this.isDrop = true;
    }

    if ( DragAwareMixin ) DropMixin.__proto__ = DragAwareMixin;
    DropMixin.prototype = Object.create( DragAwareMixin && DragAwareMixin.prototype );
    DropMixin.prototype.constructor = DropMixin;

    var prototypeAccessors = { compatibleMode: { configurable: true },dropIn: { configurable: true },typeAllowed: { configurable: true },dropAllowed: { configurable: true },cssClasses: { configurable: true },cssStyle: { configurable: true } };
    DropMixin.prototype.effectiveAcceptsType = function effectiveAcceptsType (type) {
        if (this.acceptsType === null)
            { return true; }
        else if (typeof (this.acceptsType) === 'string')
            { return this.acceptsType === type; }
        else if (typeof (this.acceptsType) === 'object' && Array.isArray(this.acceptsType)) {
            return this.acceptsType.includes(type);
        }
        else {
            return this.acceptsType(type);
        }
    };
    DropMixin.prototype.effectiveAcceptsData = function effectiveAcceptsData (data, type) {
        return this.acceptsData(data, type);
    };
    DropMixin.prototype.created = function created () {
        dnd.on("dragpositionchanged", this.onDragPositionChanged);
        dnd.on("dragtopchanged", this.onDragTopChanged);
        dnd.on("drop", this.onDrop);
    };
    DropMixin.prototype.destroyed = function destroyed () {
        dnd.off("dragpositionchanged", this.onDragPositionChanged);
        dnd.off("dragtopchanged", this.onDragTopChanged);
        dnd.off("drop", this.onDrop);
    };
    DropMixin.prototype.onDragPositionChanged = function onDragPositionChanged (event) {
        if (this === event.top) {
            this.$emit("dragover", event);
        }
    };
    DropMixin.prototype.onDragTopChanged = function onDragTopChanged (event) {
        if (this === event.top) {
            this.$emit("dragenter", event);
        }
        if (this === event.previousTop) {
            this.$emit("dragleave", event);
        }
    };
    DropMixin.prototype.onDrop = function onDrop (event) {
        if (this.dropIn && this.compatibleMode && this.dropAllowed) {
            this.doDrop(event);
        }
    };
    DropMixin.prototype.doDrop = function doDrop (event) {
        this.$emit('drop', event);
        event.source.$emit(this.mode, event);
    };
    DropMixin.prototype.mounted = function mounted () {
        var el = this.$el;
        var comp = this;
        el.addEventListener('easy-dnd-move', onMouseMove);
        function onMouseMove(e) {
            dnd.mouseMove(e, comp);
        }
    };
    prototypeAccessors.compatibleMode.get = function () {
        if (this.dragInProgress) {
            return this.mode === 'copy' || dnd.sourceListeners.hasOwnProperty(this.mode);
        }
        else {
            return null;
        }
    };
    prototypeAccessors.dropIn.get = function () {
        if (this.dragInProgress) {
            return this.dragTop === this;
        }
        else {
            return null;
        }
    };
    prototypeAccessors.typeAllowed.get = function () {
        if (this.dragInProgress) {
            return this.effectiveAcceptsType(this.dragType);
        }
        else {
            return null;
        }
    };
    prototypeAccessors.dropAllowed.get = function () {
        if (this.dragInProgress) {
            if (this.typeAllowed) {
                return this.compatibleMode && this.effectiveAcceptsData(this.dragData, this.dragType);
            }
            else {
                return null;
            }
        }
        else {
            return null;
        }
    };
    prototypeAccessors.cssClasses.get = function () {
        var clazz = {
            'dnd-drop': true
        };
        if (this.dropIn !== null) {
            clazz = Object.assign({}, clazz,
                {"drop-in": this.dropIn,
                "drop-out": !this.dropIn});
        }
        if (this.typeAllowed !== null) {
            clazz = Object.assign({}, clazz,
                {"type-allowed": this.typeAllowed,
                "type-forbidden": !this.typeAllowed});
        }
        if (this.dropAllowed !== null) {
            clazz = Object.assign({}, clazz,
                {"drop-allowed": this.dropAllowed,
                "drop-forbidden": !this.dropAllowed});
        }
        return clazz;
    };
    prototypeAccessors.cssStyle.get = function () {
        if (this.dropAllowed && this.dropIn) {
            return { cursor: this.cursor + ' !important' };
        }
        else {
            return { cursor: 'inherit' };
        }
    };
    /**
     * Returns true if the current drop area participates in the current drag operation.
     */
    DropMixin.prototype.candidate = function candidate (type, data, source) {
        return this.effectiveAcceptsType(type);
    };
    DropMixin.prototype.createDragImage = function createDragImage$1 () {
        var image;
        if (this.$refs['drag-image']) {
            var el = this.$refs['drag-image'];
            if (el.childElementCount !== 1) {
                image = createDragImage(el);
            }
            else {
                image = createDragImage(el.children.item(0));
            }
            image['__opacity'] = this.dragImageOpacity;
        }
        else {
            image = 'source';
        }
        return image;
    };

    Object.defineProperties( DropMixin.prototype, prototypeAccessors );

    return DropMixin;
}(DragAwareMixin$1));
__decorate([
    Prop({ default: function () { return function () { return true; }; }, type: [String, Array, Function] }),
    __metadata("design:type", Object)
], DropMixin.prototype, "acceptsType", void 0);
__decorate([
    Prop({ default: function () { return true; }, type: Function }),
    __metadata("design:type", Object)
], DropMixin.prototype, "acceptsData", void 0);
__decorate([
    Prop({ default: 'pointer' }),
    __metadata("design:type", String)
], DropMixin.prototype, "cursor", void 0);
__decorate([
    Prop({ default: 'copy' }),
    __metadata("design:type", String)
], DropMixin.prototype, "mode", void 0);
__decorate([
    Prop({ default: 0.7, type: Number }),
    __metadata("design:type", Object)
], DropMixin.prototype, "dragImageOpacity", void 0);
DropMixin = __decorate([
    Component({ name: "DropMixin",}),
    __metadata("design:paramtypes", [])
], DropMixin);
var DropMixin$1 = DropMixin;

var Drop = /*@__PURE__*/(function (DropMixin) {
    function Drop () {
        DropMixin.apply(this, arguments);
    }

    if ( DropMixin ) Drop.__proto__ = DropMixin;
    Drop.prototype = Object.create( DropMixin && DropMixin.prototype );
    Drop.prototype.constructor = Drop;

    var prototypeAccessors = { showDragImage: { configurable: true } };

    prototypeAccessors.showDragImage.get = function () {
        return this.dragInProgress && this.typeAllowed && this.$scopedSlots['drag-image'];
    };

    Object.defineProperties( Drop.prototype, prototypeAccessors );

    return Drop;
}(DropMixin$1));
__decorate([
    Prop({ default: 'div', type: [String, Object, Function] }),
    __metadata("design:type", Object)
], Drop.prototype, "tag", void 0);
Drop = __decorate([
    Component({ name: "Drop",})
], Drop);
var script$1 = Drop;

/* script */
var __vue_script__$1 = script$1;

/* template */
var __vue_render__$1 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c(_vm.tag,_vm._g(_vm._b({tag:"component",class:_vm.cssClasses,style:(_vm.cssStyle),scopedSlots:_vm._u([_vm._l((_vm.$scopedSlots),function(_,slot){return {key:slot,fn:function(scope){return [_vm._t(slot,null,null,scope)]}}})],null,true)},'component',_vm.$attrs,false),_vm.$listeners),[_vm._t("default"),_vm._v(" "),_vm._v(" "),(_vm.showDragImage)?_c('div',{ref:"drag-image",staticClass:"__drag-image"},[_vm._t("drag-image",null,{"type":_vm.dragType,"data":_vm.dragData})],2):_vm._e()],2)};
var __vue_staticRenderFns__$1 = [];

  /* style */
  var __vue_inject_styles__$1 = function (inject) {
    if (!inject) { return }
    inject("data-v-4eedfece_0", { source: ".drop-allowed.drop-in *{cursor:inherit!important}.drop-forbidden.drop-in,.drop-forbidden.drop-in *{cursor:no-drop!important}", map: undefined, media: undefined })
,inject("data-v-4eedfece_1", { source: ".__drag-image[data-v-4eedfece]{position:fixed;top:-10000px;left:-10000px;will-change:left,top}", map: undefined, media: undefined });

  };
  /* scoped */
  var __vue_scope_id__$1 = "data-v-4eedfece";
  /* module identifier */
  var __vue_module_identifier__$1 = undefined;
  /* functional template */
  var __vue_is_functional_template__$1 = false;
  /* style inject SSR */
  

  
  var Drop$1 = normalizeComponent_1(
    { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 },
    __vue_inject_styles__$1,
    __vue_script__$1,
    __vue_scope_id__$1,
    __vue_is_functional_template__$1,
    __vue_module_identifier__$1,
    browser,
    undefined
  );

var DropMask = /*@__PURE__*/(function (DragAwareMixin) {
    function DropMask() {
        DragAwareMixin.apply(this, arguments);
        this.isDropMask = true;
    }

    if ( DragAwareMixin ) DropMask.__proto__ = DragAwareMixin;
    DropMask.prototype = Object.create( DragAwareMixin && DragAwareMixin.prototype );
    DropMask.prototype.constructor = DropMask;
    DropMask.prototype.mounted = function mounted () {
        var el = this.$el;
        var comp = this;
        el.addEventListener('easy-dnd-move', onMouseMove);
        function onMouseMove(e) {
            dnd.mouseMove(e, comp);
        }
    };
    DropMask.prototype.createDragImage = function createDragImage () {
        return 'source';
    };

    return DropMask;
}(DragAwareMixin$1));
__decorate([
    Prop({ default: 'div', type: [String, Object, Function] }),
    __metadata("design:type", Object)
], DropMask.prototype, "tag", void 0);
DropMask = __decorate([
    Component({ name: "DropMask",})
], DropMask);
var script$2 = DropMask;

/* script */
var __vue_script__$2 = script$2;

/* template */
var __vue_render__$2 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c(_vm.tag,_vm._g(_vm._b({tag:"component",scopedSlots:_vm._u([_vm._l((_vm.$scopedSlots),function(_,slot){return {key:slot,fn:function(scope){return [_vm._t(slot,null,null,scope)]}}})],null,true)},'component',_vm.$attrs,false),_vm.$listeners),[_vm._t("default")],2)};
var __vue_staticRenderFns__$2 = [];

  /* style */
  var __vue_inject_styles__$2 = undefined;
  /* scoped */
  var __vue_scope_id__$2 = undefined;
  /* module identifier */
  var __vue_module_identifier__$2 = undefined;
  /* functional template */
  var __vue_is_functional_template__$2 = false;
  /* style inject */
  
  /* style inject SSR */
  

  
  var DropMask$1 = normalizeComponent_1(
    { render: __vue_render__$2, staticRenderFns: __vue_staticRenderFns__$2 },
    __vue_inject_styles__$2,
    __vue_script__$2,
    __vue_scope_id__$2,
    __vue_is_functional_template__$2,
    __vue_module_identifier__$2,
    undefined,
    undefined
  );

/**
 * This class reacts to drag events emitted by the dnd object to manage a sequence of drag images and fade from one to the
 * other as the drag progresses.
 */
var DragImagesManager = /*@__PURE__*/(function (Vue) {
    function DragImagesManager() {
        Vue.call(this);
        this.selfTransform = null;
        this.clones = null;
        this.source = null;
        this.sourcePos = null;
        this.sourceClone = null;
        dnd.on('dragstart', this.onDragStart);
        dnd.on('dragtopchanged', this.onDragTopChanged);
        dnd.on('dragpositionchanged', this.onDragPositionChanged);
        dnd.on('dragend', this.onDragEnd);
    }

    if ( Vue ) DragImagesManager.__proto__ = Vue;
    DragImagesManager.prototype = Object.create( Vue && Vue.prototype );
    DragImagesManager.prototype.constructor = DragImagesManager;
    DragImagesManager.prototype.onDragStart = function onDragStart (event) {
        this.sourcePos = {
            x: event.source.$el.getBoundingClientRect().left,
            y: event.source.$el.getBoundingClientRect().top
        };
        this.selfTransform = "translate(-" + (event.position.x - this.sourcePos.x) + "px, -" + (event.position.y - this.sourcePos.y) + "px)";
        this.clones = new Map();
        this.source = event.source;
    };
    DragImagesManager.prototype.onDragEnd = function onDragEnd (event) {
        var this$1 = this;

        Vue.nextTick(function () {
            if (!event.success && this$1.source['goBack']) {
                // Restore the drag image that is active when hovering outside any drop zone :
                var img = this$1.switch(null);
                // Move it back to its original place :
                window.requestAnimationFrame(function () {
                    img.style.transition = "all 0.5s";
                    window.requestAnimationFrame(function () {
                        img.style.left = this$1.sourcePos.x + "px";
                        img.style.top = this$1.sourcePos.y + "px";
                        img.style.transform = "translate(0,0)";
                        var handler = function () {
                            this$1.cleanUp();
                            img.removeEventListener("transitionend", handler);
                        };
                        img.addEventListener("transitionend", handler);
                    });
                });
            }
            else {
                this$1.cleanUp();
            }
        });
    };
    DragImagesManager.prototype.cleanUp = function cleanUp () {
        this.clones.forEach(function (clone) {
            clone.remove();
        });
        if (this.sourceClone !== null) {
            this.sourceClone.remove();
        }
        this.selfTransform = null;
        this.clones = null;
        this.source = null;
        this.sourceClone = null;
        this.sourcePos = null;
    };
    DragImagesManager.prototype.onDragTopChanged = function onDragTopChanged (event) {
        this.switch(event.top);
    };
    DragImagesManager.prototype.switch = function switch$1 (top) {
        this.clones.forEach(function (clone) {
            clone.style.opacity = "0";
        });
        if (this.sourceClone) {
            this.sourceClone.style.opacity = "0";
        }
        var activeClone;
        if (top === null) {
            activeClone = this.getSourceClone();
        }
        else {
            if (!this.clones.has(top)) {
                var clone = top['createDragImage'](this.selfTransform);
                if (clone === 'source') {
                    clone = this.getSourceClone();
                }
                else if (clone !== null) {
                    clone.style.opacity = '0';
                    document.body.append(clone);
                }
                this.clones.set(top, clone);
            }
            activeClone = this.clones.get(top);
        }
        if (activeClone !== null) {
            activeClone.offsetWidth; // Forces broswer reflow
            activeClone.style.opacity = activeClone['__opacity'];
            activeClone.style.visibility = 'visible';
        }
        return activeClone;
    };
    DragImagesManager.prototype.getSourceClone = function getSourceClone () {
        if (this.sourceClone === null) {
            this.sourceClone = this.source['createDragImage'](this.selfTransform);
            this.sourceClone.style.opacity = '0';
            document.body.append(this.sourceClone);
        }
        return this.sourceClone;
    };
    DragImagesManager.prototype.onDragPositionChanged = function onDragPositionChanged (event) {
        this.clones.forEach(function (clone) {
            clone.style.left = dnd.position.x + "px";
            clone.style.top = dnd.position.y + "px";
        });
        if (this.sourceClone) {
            this.sourceClone.style.left = dnd.position.x + "px";
            this.sourceClone.style.top = dnd.position.y + "px";
        }
    };

    return DragImagesManager;
}(Vue));
DragImagesManager = __decorate([
    Component({ name: "DragImagesManager",}) // Necessary to set proper "this" context in event listeners.
    ,
    __metadata("design:paramtypes", [])
], DragImagesManager);
new DragImagesManager();

var DragFeedback = /*@__PURE__*/(function (Vue) {
    function DragFeedback () {
        Vue.apply(this, arguments);
    }if ( Vue ) DragFeedback.__proto__ = Vue;
    DragFeedback.prototype = Object.create( Vue && Vue.prototype );
    DragFeedback.prototype.constructor = DragFeedback;

    

    return DragFeedback;
}(Vue));
DragFeedback = __decorate([
    Component({ name: "DragFeedback",})
], DragFeedback);
var script$3 = DragFeedback;

/* script */
var __vue_script__$3 = script$3;

/* template */
var __vue_render__$3 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"DragFeedback"},[_vm._t("default")],2)};
var __vue_staticRenderFns__$3 = [];

  /* style */
  var __vue_inject_styles__$3 = undefined;
  /* scoped */
  var __vue_scope_id__$3 = "data-v-0589f3cb";
  /* module identifier */
  var __vue_module_identifier__$3 = undefined;
  /* functional template */
  var __vue_is_functional_template__$3 = false;
  /* style inject */
  
  /* style inject SSR */
  

  
  var DragFeedback$1 = normalizeComponent_1(
    { render: __vue_render__$3, staticRenderFns: __vue_staticRenderFns__$3 },
    __vue_inject_styles__$3,
    __vue_script__$3,
    __vue_scope_id__$3,
    __vue_is_functional_template__$3,
    __vue_module_identifier__$3,
    undefined,
    undefined
  );

var Grid = function Grid(collection, upToIndex, row, fromIndex) {
    this.magnets = [];
    var index = 0;
    for (var i = 0, list = collection; i < list.length; i += 1) {
        var child = list[i];

        if (index > upToIndex)
            { break; }
        var rect = child.getBoundingClientRect();
        var hasNestedDrop = child.classList.contains("dnd-drop") || child.getElementsByClassName("dnd-drop").length > 0;
        var horizontal = null;
        if (hasNestedDrop) {
            if (row === 'auto') {
                // Auto mode not supported for now. Row or column must be defined explicitly if there are nested drop lists.
                throw new Error("Easy-DnD error : a drop list is missing one of these attributes : 'row' or 'column'.");
            }
            else {
                horizontal = row === 'row';
            }
        }
        if (fromIndex === null) {
            // Inserting mode.
            this.magnets.push(hasNestedDrop ? this.before(rect, horizontal) : this.center(rect));
        }
        else {
            // Reordering mode.
            this.magnets.push(hasNestedDrop ? (fromIndex < index ? this.after : this.before)(rect, horizontal) : this.center(rect));
        }
        // Debug : show magnets :
        //document.body.insertAdjacentHTML("beforeend", "<div style='background-color: red; position: fixed; width: 1px; height: 1px; top:" + this.magnets[index].y + "px; left:" + this.magnets[index].x + "px;' ></div>")
        index++;
    }
};
/**
 * Returns the center of the rectangle.
 */
Grid.prototype.center = function center (rect) {
    return {
        x: rect.left + rect.width / 2,
        y: rect.top + rect.height / 2
    };
};
/**
 * When horizontal is true / false, returns middle of the left / top side of the rectangle.
 */
Grid.prototype.before = function before (rect, horizontal) {
    return horizontal ? {
        x: rect.left,
        y: rect.top + rect.height / 2
    } : {
        x: rect.left + rect.width / 2,
        y: rect.top
    };
};
/**
 * When horizontal is true / false, returns middle of the right / bottom side of the rectangle.
 */
Grid.prototype.after = function after (rect, horizontal) {
    return horizontal ? {
        x: rect.left + rect.width,
        y: rect.top + rect.height / 2
    } : {
        x: rect.left + rect.width / 2,
        y: rect.top + rect.height
    };
};
Grid.prototype.closestIndex = function closestIndex (position) {
    var minDist = 999999;
    var index = -1;
    for (var i = 0; i < this.magnets.length; i++) {
        var magnet = this.magnets[i];
        var dist = Math.sqrt(Math.pow(magnet.x - position.x, 2) + Math.pow(magnet.y - position.y, 2));
        if (dist < minDist) {
            minDist = dist;
            index = i;
        }
    }
    return index;
};

var DnDEvent = function DnDEvent () {};
var ReorderEvent = function ReorderEvent(from, to) {
    this.from = from;
    this.to = to;
};
ReorderEvent.prototype.apply = function apply (array) {
    var tmp = array[this.from];
    array.splice(this.from, 1);
    array.splice(this.to, 0, tmp);
};
var InsertEvent = function InsertEvent(type, data, index) {
    this.type = type;
    this.data = data;
    this.index = index;
};

var DropList = /*@__PURE__*/(function (DropMixin) {
    function DropList() {
        DropMixin.apply(this, arguments);
        this.grid = null;
        this.forbiddenKeys = [];
        this.feedbackKey = null;
        this.fromIndex = null;
    }

    if ( DropMixin ) DropList.__proto__ = DropMixin;
    DropList.prototype = Object.create( DropMixin && DropMixin.prototype );
    DropList.prototype.constructor = DropList;

    var prototypeAccessors = { rootTag: { configurable: true },rootProps: { configurable: true },rootListeners: { configurable: true },direction: { configurable: true },reordering: { configurable: true },closestIndex: { configurable: true },dropAllowed: { configurable: true },itemsBeforeFeedback: { configurable: true },itemsAfterFeedback: { configurable: true },itemsBeforeReorderingFeedback: { configurable: true },itemsAfterReorderingFeedback: { configurable: true },reorderedItems: { configurable: true },clazz: { configurable: true },style: { configurable: true },showDragFeedback: { configurable: true },showInsertingDragImage: { configurable: true },showReorderingDragImage: { configurable: true },hasReorderingFeedback: { configurable: true } };
    prototypeAccessors.rootTag.get = function () {
        if (this.noAnimations) {
            return this.tag ? this.tag : 'div';
        }
        else {
            return "transition-group";
        }
    };
    prototypeAccessors.rootProps.get = function () {
        if (this.noAnimations) {
            return this.$attrs;
        }
        else {
            return {
                tag: this.tag,
                duration: { enter: 0, leave: 0 },
                css: false
            };
        }
    };
    prototypeAccessors.rootListeners.get = function () {
        if (this.noAnimations) {
            return this.$listeners;
        }
        else {
            return {};
        }
    };
    DropList.prototype.created = function created () {
        dnd.on("dragstart", this.onDragStart);
        dnd.on("dragend", this.onDragEnd);
    };
    prototypeAccessors.direction.get = function () {
        if (this.row)
            { return 'row'; }
        if (this.column)
            { return 'column'; }
        return 'auto';
    };
    DropList.prototype.destroyed = function destroyed () {
        dnd.off("dragstart", this.onDragStart);
        dnd.off("dragend", this.onDragEnd);
    };
    DropList.prototype.onDragStart = function onDragStart (event) {
        var this$1 = this;

        if (this.candidate(dnd.type, dnd.data, dnd.source)) {
            if (this.reordering) {
                this.fromIndex = Array.prototype.indexOf.call(event.source.$el.parentElement.children, event.source.$el);
                this.grid = this.computeReorderingGrid();
            }
            else {
                this.$nextTick(function () {
                    // Presence of feedback node in the DOM and of keys in the virtual DOM required => delayed until what
                    // depends on drag data has been processed.
                    this$1.grid = this$1.computeInsertingGrid();
                    this$1.feedbackKey = this$1.computeFeedbackKey();
                    this$1.forbiddenKeys = this$1.computeForbiddenKeys();
                });
            }
        }
    };
    DropList.prototype.onDragEnd = function onDragEnd () {
        this.fromIndex = null;
        this.feedbackKey = null;
        this.forbiddenKeys = null;
        this.grid = null;
    };
    prototypeAccessors.reordering.get = function () {
        if (dnd.inProgress) {
            return dnd.source.$el.parentElement === this.$el && this.$listeners.hasOwnProperty('reorder');
        }
        else {
            return null;
        }
    };
    prototypeAccessors.closestIndex.get = function () {
        if (this.grid) {
            return this.grid.closestIndex(dnd.position);
        }
        else {
            return null;
        }
    };
    prototypeAccessors.dropAllowed.get = function () {
        if (this.dragInProgress) {
            if (this.reordering) {
                return this.items.length > 1;
            }
            else {
                var superDropAllowed = DropMixin['options'].computed.dropAllowed.get.call(this);
                if (!superDropAllowed) {
                    return false;
                }
                else {
                    if (this.forbiddenKeys !== null && this.feedbackKey !== null) {
                        return !this.forbiddenKeys.includes(this.feedbackKey);
                    }
                    else {
                        return null;
                    }
                }
            }
        }
        else {
            return null;
        }
    };
    prototypeAccessors.itemsBeforeFeedback.get = function () {
        if (this.closestIndex === 0) {
            return [];
        }
        else {
            return this.items.slice(0, this.closestIndex);
        }
    };
    prototypeAccessors.itemsAfterFeedback.get = function () {
        if (this.closestIndex === this.items.length) {
            return [];
        }
        else {
            return this.items.slice(this.closestIndex);
        }
    };
    prototypeAccessors.itemsBeforeReorderingFeedback.get = function () {
        if (this.closestIndex <= this.fromIndex) {
            return this.items.slice(0, this.closestIndex);
        }
        else {
            return this.items.slice(0, this.closestIndex + 1);
        }
    };
    prototypeAccessors.itemsAfterReorderingFeedback.get = function () {
        if (this.closestIndex <= this.fromIndex) {
            return this.items.slice(this.closestIndex);
        }
        else {
            return this.items.slice(this.closestIndex + 1);
        }
    };
    prototypeAccessors.reorderedItems.get = function () {
        var toIndex = this.closestIndex;
        var reordered = [].concat( this.items );
        var temp = reordered[this.fromIndex];
        reordered.splice(this.fromIndex, 1);
        reordered.splice(toIndex, 0, temp);
        return reordered;
    };
    prototypeAccessors.clazz.get = function () {
        return Object.assign({}, {'drop-list': true,
            'reordering': this.reordering === true,
            'inserting': this.reordering === false},
            (this.reordering === false ? this.cssClasses : { 'dnd-drop': true }));
    };
    prototypeAccessors.style.get = function () {
        return Object.assign({}, (this.reordering === false ? this.cssStyle : {}));
    };
    prototypeAccessors.showDragFeedback.get = function () {
        return this.dragInProgress && this.typeAllowed && !this.reordering;
    };
    prototypeAccessors.showInsertingDragImage.get = function () {
        return this.dragInProgress && this.typeAllowed && !this.reordering && this.$scopedSlots.hasOwnProperty("drag-image");
    };
    prototypeAccessors.showReorderingDragImage.get = function () {
        return this.dragInProgress && this.reordering && this.$scopedSlots.hasOwnProperty("reordering-drag-image");
    };
    DropList.prototype.doDrop = function doDrop (event) {
        if (this.reordering) {
            if (this.fromIndex !== this.closestIndex) {
                this.$emit('reorder', new ReorderEvent(this.fromIndex, this.closestIndex));
            }
        }
        else {
            DropMixin['options'].methods.doDrop.call(this, event);
            this.$emit('insert', new InsertEvent(event.type, event.data, this.closestIndex));
        }
    };
    DropList.prototype.candidate = function candidate (type, data, source) {
        var i = arguments.length, argsArray = Array(i);
        while ( i-- ) argsArray[i] = arguments[i];
        var ref;

        var superCandidate = (ref = DropMixin['options'].methods.candidate).call.apply(ref, [ this ].concat( argsArray ));
        return (superCandidate && (this.$listeners.hasOwnProperty("insert") || this.$listeners.hasOwnProperty("drop"))) || this.reordering;
    };
    DropList.prototype.computeForbiddenKeys = function computeForbiddenKeys () {
        var vnodes = this.noAnimations ? [] : this.$children[0].$vnode.context.$children[0].$slots.default;
        return vnodes
            .map(function (vn) { return vn.key; })
            .filter(function (k) { return k !== undefined && k !== 'drag-image' && k !== 'drag-feedback'; });
    };
    DropList.prototype.computeFeedbackKey = function computeFeedbackKey () {
        return this.$refs['feedback']['$slots']['default'][0]['key'];
    };
    prototypeAccessors.hasReorderingFeedback.get = function () {
        return this.$scopedSlots.hasOwnProperty("reordering-feedback");
    };
    DropList.prototype.computeInsertingGrid = function computeInsertingGrid () {
        var feedbackParent = this.$refs['feedback']['$el'];
        if(feedbackParent.children.length == 0){
            console.warn("Feedback template has no children",$feedbackParent,this);
        }
        var feedback = feedbackParent.children[0];
        var clone = feedback.cloneNode(true);
        var tg = this.$el;
        if (tg.children.length > this.items.length) {
            tg.insertBefore(clone, tg.children[this.items.length]);
        }
        else {
            tg.append(clone);
        }
        var grid = new Grid(tg.children, this.items.length, this.direction, null);
        clone.remove();
        return grid;
    };
    DropList.prototype.computeReorderingGrid = function computeReorderingGrid () {
        var tg = this.$el;
        return new Grid(tg.children, this.items.length - 1, this.direction, this.fromIndex);
    };
    DropList.prototype.createDragImage = function createDragImage$1 () {
        var image;
        if (this.$refs['drag-image']) {
            var el = this.$refs['drag-image'];
            var model;
            if (el.childElementCount !== 1) {
                model = el;
            }
            else {
                model = el.children.item(0);
            }
            var clone = model.cloneNode(true);
            var tg = this.$el;
            tg.append(clone);
            image = createDragImage(clone);
            clone.remove();
            image['__opacity'] = this.dragImageOpacity;
        }
        else {
            image = 'source';
        }
        return image;
    };

    Object.defineProperties( DropList.prototype, prototypeAccessors );

    return DropList;
}(DropMixin$1));
__decorate([
    Prop({ default: 'div', type: [String, Object, Function] }),
    __metadata("design:type", Object)
], DropList.prototype, "tag", void 0);
__decorate([
    Prop(),
    __metadata("design:type", Array)
], DropList.prototype, "items", void 0);
__decorate([
    Prop({ default: null }),
    __metadata("design:type", Boolean)
], DropList.prototype, "row", void 0);
__decorate([
    Prop({ default: null, type: Boolean }),
    __metadata("design:type", Boolean)
], DropList.prototype, "column", void 0);
__decorate([
    Prop({ default: false, type: Boolean }),
    __metadata("design:type", Boolean)
], DropList.prototype, "noAnimations", void 0);
DropList = __decorate([
    Component({
        components: { DragFeedback: DragFeedback$1 },
        name: "DropList",
    })
], DropList);
var script$4 = DropList;

/* script */
var __vue_script__$4 = script$4;

/* template */
var __vue_render__$4 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c(_vm.rootTag,_vm._g(_vm._b({tag:"component",class:_vm.clazz,style:(_vm.style)},'component',_vm.rootProps,false),_vm.rootListeners),[(_vm.dropIn && _vm.dropAllowed)?[(_vm.reordering)?[(_vm.hasReorderingFeedback)?[_vm._l((_vm.itemsBeforeReorderingFeedback),function(item){return _vm._t("item",null,{"item":item})}),_vm._v(" "),_vm._t("reordering-feedback",null,{"item":_vm.items[_vm.fromIndex]}),_vm._v(" "),_vm._l((_vm.itemsAfterReorderingFeedback),function(item){return _vm._t("item",null,{"item":item})})]:[_vm._l((_vm.reorderedItems),function(item,index){return _vm._t("item",null,{"item":item,"reorder":index === _vm.closestIndex})})]]:[_vm._l((_vm.itemsBeforeFeedback),function(item){return _vm._t("item",null,{"item":item,"reorder":false})}),_vm._v(" "),_vm._t("feedback",null,{"data":_vm.dragData,"type":_vm.dragType}),_vm._v(" "),_vm._l((_vm.itemsAfterFeedback),function(item){return _vm._t("item",null,{"item":item,"reorder":false})})]]:[_vm._l((_vm.items),function(item){return _vm._t("item",null,{"item":item,"reorder":false})})],_vm._v(" "),(_vm.showDragFeedback)?_c('drag-feedback',{key:"drag-feedback",ref:"feedback",staticClass:"__feedback"},[_vm._t("feedback",null,{"data":_vm.dragData,"type":_vm.dragType})],2):_vm._e(),_vm._v(" "),(_vm.showInsertingDragImage)?_c('div',{key:"inserting-drag-image",ref:"drag-image",staticClass:"__drag-image"},[_vm._t("drag-image",null,{"type":_vm.dragType,"data":_vm.dragData})],2):_vm._e(),_vm._v(" "),(_vm.showReorderingDragImage)?_c('div',{key:"reordering-drag-image",ref:"drag-image",staticClass:"__drag-image"},[_vm._t("reordering-drag-image",null,{"item":_vm.items[_vm.fromIndex]})],2):_vm._e(),_vm._v(" "),_c('div',{key:"drop-list-content"},[_vm._t("default")],2)],2)};
var __vue_staticRenderFns__$4 = [];

  /* style */
  var __vue_inject_styles__$4 = function (inject) {
    if (!inject) { return }
    inject("data-v-56f28757_0", { source: ".drop-list[data-v-56f28757]>*{transition:transform .2s}.__feedback[data-v-56f28757]{display:none}.__drag-image[data-v-56f28757]{position:fixed;top:-10000px;left:-10000px;will-change:left,top}", map: undefined, media: undefined })
,inject("data-v-56f28757_1", { source: ".drop-allowed.drop-in *{cursor:inherit!important}.drop-forbidden.drop-in,.drop-forbidden.drop-in *{cursor:no-drop!important}", map: undefined, media: undefined });

  };
  /* scoped */
  var __vue_scope_id__$4 = "data-v-56f28757";
  /* module identifier */
  var __vue_module_identifier__$4 = undefined;
  /* functional template */
  var __vue_is_functional_template__$4 = false;
  /* style inject SSR */
  

  
  var DropList$1 = normalizeComponent_1(
    { render: __vue_render__$4, staticRenderFns: __vue_staticRenderFns__$4 },
    __vue_inject_styles__$4,
    __vue_script__$4,
    __vue_scope_id__$4,
    __vue_is_functional_template__$4,
    __vue_module_identifier__$4,
    browser,
    undefined
  );

// minor modifications to handle minification in moodle - the reflected property name does not survive minification. Do not want all our components to be known as 'b'

export { DnDEvent, Drag$1 as Drag, DragAwareMixin$1 as DragAwareMixin, DragImagesManager, DragMixin$1 as DragMixin, Drop$1 as Drop, DropList$1 as DropList, DropMask$1 as DropMask, DropMixin$1 as DropMixin, InsertEvent, ReorderEvent, createDragImage, dnd };
