"use strict";

function _typeof2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }

/**
 * interact.js 1.9.20
 *
 * Copyright (c) 2012-present Taye Adeyemi <dev@taye.me>
 * Released under the MIT License.
 * https://raw.github.com/taye/interact.js/master/LICENSE
 */
(function (f) {
  if ((typeof exports === "undefined" ? "undefined" : _typeof2(exports)) === "object" && typeof module !== "undefined") {
    module.exports = f();
  } else if (typeof define === "function" && define.amd) {
    define([], f);
  } else {
    var g;

    if (typeof window !== "undefined") {
      g = window;
    } else if (typeof global !== "undefined") {
      g = global;
    } else if (typeof self !== "undefined") {
      g = self;
    } else {
      g = this;
    }

    g.interact = f();
  }
})(function () {
  var define, module, exports;
  var _$isWindow_77 = {};
  "use strict";

  Object.defineProperty(_$isWindow_77, "__esModule", {
    value: true
  });
  _$isWindow_77["default"] = void 0;

  var _default = function _default(thing) {
    return !!(thing && thing.Window) && thing instanceof thing.Window;
  };

  _$isWindow_77["default"] = _default;
  var _$window_84 = {};
  "use strict";

  Object.defineProperty(_$window_84, "__esModule", {
    value: true
  });
  _$window_84.init = init;
  _$window_84.getWindow = getWindow;
  _$window_84["default"] = void 0;
  /* removed: var _$isWindow_77 = require("./isWindow.js"); */

  ;
  var win = {
    realWindow: undefined,
    window: undefined,
    getWindow: getWindow,
    init: init
  };

  function init(window) {
    // get wrapped window if using Shadow DOM polyfill
    win.realWindow = window; // create a TextNode

    var el = window.document.createTextNode(''); // check if it's wrapped by a polyfill

    if (el.ownerDocument !== window.document && typeof window.wrap === 'function' && window.wrap(el) === el) {
      // use wrapped window
      window = window.wrap(window);
    }

    win.window = window;
  }

  if (typeof window === 'undefined') {
    win.window = undefined;
    win.realWindow = undefined;
  } else {
    init(window);
  }

  function getWindow(node) {
    if ((0, _$isWindow_77["default"])(node)) {
      return node;
    }

    var rootNode = node.ownerDocument || node;
    return rootNode.defaultView || win.window;
  }

  win.init = init;
  var ___default_84 = win;
  _$window_84["default"] = ___default_84;
  var _$is_76 = {};
  "use strict";

  Object.defineProperty(_$is_76, "__esModule", {
    value: true
  });
  _$is_76["default"] = void 0;
  /* removed: var _$isWindow_77 = require("./isWindow.js"); */

  ;
  /* removed: var _$window_84 = require("./window.js"); */

  ;

  function _typeof(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      _typeof = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      _typeof = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return _typeof(obj);
  }

  var __window_76 = function window(thing) {
    return thing === _$window_84["default"].window || (0, _$isWindow_77["default"])(thing);
  };

  var docFrag = function docFrag(thing) {
    return object(thing) && thing.nodeType === 11;
  };

  var object = function object(thing) {
    return !!thing && _typeof(thing) === 'object';
  };

  var func = function func(thing) {
    return typeof thing === 'function';
  };

  var number = function number(thing) {
    return typeof thing === 'number';
  };

  var bool = function bool(thing) {
    return typeof thing === 'boolean';
  };

  var string = function string(thing) {
    return typeof thing === 'string';
  };

  var element = function element(thing) {
    if (!thing || _typeof(thing) !== 'object') {
      return false;
    } // eslint-disable-next-line import/no-named-as-default-member


    var _window = _$window_84["default"].getWindow(thing) || _$window_84["default"].window;

    return /object|function/.test(_typeof(_window.Element)) ? thing instanceof _window.Element // DOM2
    : thing.nodeType === 1 && typeof thing.nodeName === 'string';
  };

  var plainObject = function plainObject(thing) {
    return object(thing) && !!thing.constructor && /function Object\b/.test(thing.constructor.toString());
  };

  var array = function array(thing) {
    return object(thing) && typeof thing.length !== 'undefined' && func(thing.splice);
  };

  var ___default_76 = {
    window: __window_76,
    docFrag: docFrag,
    object: object,
    func: func,
    number: number,
    bool: bool,
    string: string,
    element: element,
    plainObject: plainObject,
    array: array
  };
  _$is_76["default"] = ___default_76;
  var _$plugin_1 = {};
  "use strict";

  Object.defineProperty(_$plugin_1, "__esModule", {
    value: true
  });
  _$plugin_1["default"] = void 0;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;

  function install(scope) {
    var actions = scope.actions,
        Interactable = scope.Interactable,
        defaults = scope.defaults;
    Interactable.prototype.draggable = drag.draggable;
    actions.map.drag = drag;
    actions.methodDict.drag = 'draggable';
    defaults.actions.drag = drag.defaults;
  }

  function beforeMove(_ref) {
    var interaction = _ref.interaction;

    if (interaction.prepared.name !== 'drag') {
      return;
    }

    var axis = interaction.prepared.axis;

    if (axis === 'x') {
      interaction.coords.cur.page.y = interaction.coords.start.page.y;
      interaction.coords.cur.client.y = interaction.coords.start.client.y;
      interaction.coords.velocity.client.y = 0;
      interaction.coords.velocity.page.y = 0;
    } else if (axis === 'y') {
      interaction.coords.cur.page.x = interaction.coords.start.page.x;
      interaction.coords.cur.client.x = interaction.coords.start.client.x;
      interaction.coords.velocity.client.x = 0;
      interaction.coords.velocity.page.x = 0;
    }
  }

  function move(_ref2) {
    var iEvent = _ref2.iEvent,
        interaction = _ref2.interaction;

    if (interaction.prepared.name !== 'drag') {
      return;
    }

    var axis = interaction.prepared.axis;

    if (axis === 'x' || axis === 'y') {
      var opposite = axis === 'x' ? 'y' : 'x';
      iEvent.page[opposite] = interaction.coords.start.page[opposite];
      iEvent.client[opposite] = interaction.coords.start.client[opposite];
      iEvent.delta[opposite] = 0;
    }
  }
  /**
   * ```js
   * interact(element).draggable({
   *     onstart: function (event) {},
   *     onmove : function (event) {},
   *     onend  : function (event) {},
   *
   *     // the axis in which the first movement must be
   *     // for the drag sequence to start
   *     // 'xy' by default - any direction
   *     startAxis: 'x' || 'y' || 'xy',
   *
   *     // 'xy' by default - don't restrict to one axis (move in any direction)
   *     // 'x' or 'y' to restrict movement to either axis
   *     // 'start' to restrict movement to the axis the drag started in
   *     lockAxis: 'x' || 'y' || 'xy' || 'start',
   *
   *     // max number of drags that can happen concurrently
   *     // with elements of this Interactable. Infinity by default
   *     max: Infinity,
   *
   *     // max number of drags that can target the same element+Interactable
   *     // 1 by default
   *     maxPerElement: 2
   * })
   *
   * var isDraggable = interact('element').draggable(); // true
   * ```
   *
   * Get or set whether drag actions can be performed on the target
   *
   * @alias Interactable.prototype.draggable
   *
   * @param {boolean | object} [options] true/false or An object with event
   * listeners to be fired on drag events (object makes the Interactable
   * draggable)
   * @return {boolean | Interactable} boolean indicating if this can be the
   * target of drag events, or this Interctable
   */


  var draggable = function draggable(options) {
    if (_$is_76["default"].object(options)) {
      this.options.drag.enabled = options.enabled !== false;
      this.setPerAction('drag', options);
      this.setOnEvents('drag', options);

      if (/^(xy|x|y|start)$/.test(options.lockAxis)) {
        this.options.drag.lockAxis = options.lockAxis;
      }

      if (/^(xy|x|y)$/.test(options.startAxis)) {
        this.options.drag.startAxis = options.startAxis;
      }

      return this;
    }

    if (_$is_76["default"].bool(options)) {
      this.options.drag.enabled = options;
      return this;
    }

    return this.options.drag;
  };

  var drag = {
    id: 'actions/drag',
    install: install,
    listeners: {
      'interactions:before-action-move': beforeMove,
      'interactions:action-resume': beforeMove,
      // dragmove
      'interactions:action-move': move,
      'auto-start:check': function autoStartCheck(arg) {
        var interaction = arg.interaction,
            interactable = arg.interactable,
            buttons = arg.buttons;
        var dragOptions = interactable.options.drag;

        if (!(dragOptions && dragOptions.enabled) || // check mouseButton setting if the pointer is down
        interaction.pointerIsDown && /mouse|pointer/.test(interaction.pointerType) && (buttons & interactable.options.drag.mouseButtons) === 0) {
          return undefined;
        }

        arg.action = {
          name: 'drag',
          axis: dragOptions.lockAxis === 'start' ? dragOptions.startAxis : dragOptions.lockAxis
        };
        return false;
      }
    },
    draggable: draggable,
    beforeMove: beforeMove,
    move: move,
    defaults: {
      startAxis: 'xy',
      lockAxis: 'xy'
    },
    getCursor: function getCursor() {
      return 'move';
    }
  };
  var ___default_1 = drag;
  _$plugin_1["default"] = ___default_1;
  var _$domObjects_70 = {};
  "use strict";

  Object.defineProperty(_$domObjects_70, "__esModule", {
    value: true
  });
  _$domObjects_70["default"] = void 0;
  var domObjects = {
    init: __init_70,
    document: null,
    DocumentFragment: null,
    SVGElement: null,
    SVGSVGElement: null,
    SVGElementInstance: null,
    Element: null,
    HTMLElement: null,
    Event: null,
    Touch: null,
    PointerEvent: null
  };

  function blank() {}

  var ___default_70 = domObjects;
  _$domObjects_70["default"] = ___default_70;

  function __init_70(window) {
    var win = window;
    domObjects.document = win.document;
    domObjects.DocumentFragment = win.DocumentFragment || blank;
    domObjects.SVGElement = win.SVGElement || blank;
    domObjects.SVGSVGElement = win.SVGSVGElement || blank;
    domObjects.SVGElementInstance = win.SVGElementInstance || blank;
    domObjects.Element = win.Element || blank;
    domObjects.HTMLElement = win.HTMLElement || domObjects.Element;
    domObjects.Event = win.Event;
    domObjects.Touch = win.Touch || blank;
    domObjects.PointerEvent = win.PointerEvent || win.MSPointerEvent;
  }

  var _$browser_67 = {};
  "use strict";

  Object.defineProperty(_$browser_67, "__esModule", {
    value: true
  });
  _$browser_67["default"] = void 0;
  /* removed: var _$domObjects_70 = require("./domObjects.js"); */

  ;
  /* removed: var _$is_76 = require("./is.js"); */

  ;
  /* removed: var _$window_84 = require("./window.js"); */

  ;
  var browser = {
    init: __init_67,
    supportsTouch: null,
    supportsPointerEvent: null,
    isIOS7: null,
    isIOS: null,
    isIe9: null,
    isOperaMobile: null,
    prefixedMatchesSelector: null,
    pEventTypes: null,
    wheelEvent: null
  };

  function __init_67(window) {
    var Element = _$domObjects_70["default"].Element;
    var navigator = _$window_84["default"].window.navigator; // Does the browser support touch input?

    browser.supportsTouch = 'ontouchstart' in window || _$is_76["default"].func(window.DocumentTouch) && _$domObjects_70["default"].document instanceof window.DocumentTouch; // Does the browser support PointerEvents

    browser.supportsPointerEvent = navigator.pointerEnabled !== false && !!_$domObjects_70["default"].PointerEvent;
    browser.isIOS = /iP(hone|od|ad)/.test(navigator.platform); // scrolling doesn't change the result of getClientRects on iOS 7

    browser.isIOS7 = /iP(hone|od|ad)/.test(navigator.platform) && /OS 7[^\d]/.test(navigator.appVersion);
    browser.isIe9 = /MSIE 9/.test(navigator.userAgent); // Opera Mobile must be handled differently

    browser.isOperaMobile = navigator.appName === 'Opera' && browser.supportsTouch && /Presto/.test(navigator.userAgent); // prefix matchesSelector

    browser.prefixedMatchesSelector = 'matches' in Element.prototype ? 'matches' : 'webkitMatchesSelector' in Element.prototype ? 'webkitMatchesSelector' : 'mozMatchesSelector' in Element.prototype ? 'mozMatchesSelector' : 'oMatchesSelector' in Element.prototype ? 'oMatchesSelector' : 'msMatchesSelector';
    browser.pEventTypes = browser.supportsPointerEvent ? _$domObjects_70["default"].PointerEvent === window.MSPointerEvent ? {
      up: 'MSPointerUp',
      down: 'MSPointerDown',
      over: 'mouseover',
      out: 'mouseout',
      move: 'MSPointerMove',
      cancel: 'MSPointerCancel'
    } : {
      up: 'pointerup',
      down: 'pointerdown',
      over: 'pointerover',
      out: 'pointerout',
      move: 'pointermove',
      cancel: 'pointercancel'
    } : null; // because Webkit and Opera still use 'mousewheel' event type

    browser.wheelEvent = 'onmousewheel' in _$domObjects_70["default"].document ? 'mousewheel' : 'wheel';
  }

  var ___default_67 = browser;
  _$browser_67["default"] = ___default_67;
  var _$domUtils_71 = {};
  "use strict";

  Object.defineProperty(_$domUtils_71, "__esModule", {
    value: true
  });
  _$domUtils_71.nodeContains = nodeContains;
  _$domUtils_71.closest = closest;
  _$domUtils_71.parentNode = parentNode;
  _$domUtils_71.matchesSelector = matchesSelector;
  _$domUtils_71.indexOfDeepestElement = indexOfDeepestElement;
  _$domUtils_71.matchesUpTo = matchesUpTo;
  _$domUtils_71.getActualElement = getActualElement;
  _$domUtils_71.getScrollXY = getScrollXY;
  _$domUtils_71.getElementClientRect = getElementClientRect;
  _$domUtils_71.getElementRect = getElementRect;
  _$domUtils_71.getPath = getPath;
  _$domUtils_71.trySelector = trySelector;
  /* removed: var _$browser_67 = require("./browser.js"); */

  ;
  /* removed: var _$domObjects_70 = require("./domObjects.js"); */

  ;
  /* removed: var _$is_76 = require("./is.js"); */

  ;
  /* removed: var _$window_84 = require("./window.js"); */

  ;

  function nodeContains(parent, child) {
    while (child) {
      if (child === parent) {
        return true;
      }

      child = child.parentNode;
    }

    return false;
  }

  function closest(element, selector) {
    while (_$is_76["default"].element(element)) {
      if (matchesSelector(element, selector)) {
        return element;
      }

      element = parentNode(element);
    }

    return null;
  }

  function parentNode(node) {
    var parent = node.parentNode;

    if (_$is_76["default"].docFrag(parent)) {
      // skip past #shado-root fragments
      // tslint:disable-next-line
      while ((parent = parent.host) && _$is_76["default"].docFrag(parent)) {
        continue;
      }

      return parent;
    }

    return parent;
  }

  function matchesSelector(element, selector) {
    // remove /deep/ from selectors if shadowDOM polyfill is used
    if (_$window_84["default"].window !== _$window_84["default"].realWindow) {
      selector = selector.replace(/\/deep\//g, ' ');
    }

    return element[_$browser_67["default"].prefixedMatchesSelector](selector);
  }

  var getParent = function getParent(el) {
    return el.parentNode || el.host;
  }; // Test for the element that's "above" all other qualifiers


  function indexOfDeepestElement(elements) {
    var deepestNodeParents = [];
    var deepestNodeIndex;

    for (var i = 0; i < elements.length; i++) {
      var currentNode = elements[i];
      var deepestNode = elements[deepestNodeIndex]; // node may appear in elements array multiple times

      if (!currentNode || i === deepestNodeIndex) {
        continue;
      }

      if (!deepestNode) {
        deepestNodeIndex = i;
        continue;
      }

      var currentNodeParent = getParent(currentNode);
      var deepestNodeParent = getParent(deepestNode); // check if the deepest or current are document.documentElement/rootElement
      // - if the current node is, do nothing and continue

      if (currentNodeParent === currentNode.ownerDocument) {
        continue;
      } // - if deepest is, update with the current node and continue to next
      else if (deepestNodeParent === currentNode.ownerDocument) {
          deepestNodeIndex = i;
          continue;
        } // compare zIndex of siblings


      if (currentNodeParent === deepestNodeParent) {
        if (zIndexIsHigherThan(currentNode, deepestNode)) {
          deepestNodeIndex = i;
        }

        continue;
      } // populate the ancestry array for the latest deepest node


      deepestNodeParents = deepestNodeParents.length ? deepestNodeParents : getNodeParents(deepestNode);
      var ancestryStart = void 0; // if the deepest node is an HTMLElement and the current node is a non root svg element

      if (deepestNode instanceof _$domObjects_70["default"].HTMLElement && currentNode instanceof _$domObjects_70["default"].SVGElement && !(currentNode instanceof _$domObjects_70["default"].SVGSVGElement)) {
        // TODO: is this check necessary? Was this for HTML elements embedded in SVG?
        if (currentNode === deepestNodeParent) {
          continue;
        }

        ancestryStart = currentNode.ownerSVGElement;
      } else {
        ancestryStart = currentNode;
      }

      var currentNodeParents = getNodeParents(ancestryStart, deepestNode.ownerDocument);
      var commonIndex = 0; // get (position of closest common ancestor) + 1

      while (currentNodeParents[commonIndex] && currentNodeParents[commonIndex] === deepestNodeParents[commonIndex]) {
        commonIndex++;
      }

      var parents = [currentNodeParents[commonIndex - 1], currentNodeParents[commonIndex], deepestNodeParents[commonIndex]];
      var child = parents[0].lastChild;

      while (child) {
        if (child === parents[1]) {
          deepestNodeIndex = i;
          deepestNodeParents = currentNodeParents;
          break;
        } else if (child === parents[2]) {
          break;
        }

        child = child.previousSibling;
      }
    }

    return deepestNodeIndex;
  }

  function getNodeParents(node, limit) {
    var parents = [];
    var parent = node;
    var parentParent;

    while ((parentParent = getParent(parent)) && parent !== limit && parentParent !== parent.ownerDocument) {
      parents.unshift(parent);
      parent = parentParent;
    }

    return parents;
  }

  function zIndexIsHigherThan(higherNode, lowerNode) {
    var higherIndex = parseInt((0, _$window_84.getWindow)(higherNode).getComputedStyle(higherNode).zIndex, 10) || 0;
    var lowerIndex = parseInt((0, _$window_84.getWindow)(lowerNode).getComputedStyle(lowerNode).zIndex, 10) || 0;
    return higherIndex >= lowerIndex;
  }

  function matchesUpTo(element, selector, limit) {
    while (_$is_76["default"].element(element)) {
      if (matchesSelector(element, selector)) {
        return true;
      }

      element = parentNode(element);

      if (element === limit) {
        return matchesSelector(element, selector);
      }
    }

    return false;
  }

  function getActualElement(element) {
    return element instanceof _$domObjects_70["default"].SVGElementInstance ? element.correspondingUseElement : element;
  }

  function getScrollXY(relevantWindow) {
    relevantWindow = relevantWindow || _$window_84["default"].window;
    return {
      x: relevantWindow.scrollX || relevantWindow.document.documentElement.scrollLeft,
      y: relevantWindow.scrollY || relevantWindow.document.documentElement.scrollTop
    };
  }

  function getElementClientRect(element) {
    var clientRect = element instanceof _$domObjects_70["default"].SVGElement ? element.getBoundingClientRect() : element.getClientRects()[0];
    return clientRect && {
      left: clientRect.left,
      right: clientRect.right,
      top: clientRect.top,
      bottom: clientRect.bottom,
      width: clientRect.width || clientRect.right - clientRect.left,
      height: clientRect.height || clientRect.bottom - clientRect.top
    };
  }

  function getElementRect(element) {
    var clientRect = getElementClientRect(element);

    if (!_$browser_67["default"].isIOS7 && clientRect) {
      var scroll = getScrollXY(_$window_84["default"].getWindow(element));
      clientRect.left += scroll.x;
      clientRect.right += scroll.x;
      clientRect.top += scroll.y;
      clientRect.bottom += scroll.y;
    }

    return clientRect;
  }

  function getPath(node) {
    var path = [];

    while (node) {
      path.push(node);
      node = parentNode(node);
    }

    return path;
  }

  function trySelector(value) {
    if (!_$is_76["default"].string(value)) {
      return false;
    } // an exception will be raised if it is invalid


    _$domObjects_70["default"].document.querySelector(value);

    return true;
  }

  var _$extend_73 = {};
  "use strict";

  Object.defineProperty(_$extend_73, "__esModule", {
    value: true
  });
  _$extend_73["default"] = extend;

  function extend(dest, source) {
    for (var prop in source) {
      dest[prop] = source[prop];
    }

    var ret = dest;
    return ret;
  }

  var _$rect_83 = {};
  "use strict";

  Object.defineProperty(_$rect_83, "__esModule", {
    value: true
  });
  _$rect_83.getStringOptionResult = getStringOptionResult;
  _$rect_83.resolveRectLike = resolveRectLike;
  _$rect_83.rectToXY = rectToXY;
  _$rect_83.xywhToTlbr = xywhToTlbr;
  _$rect_83.tlbrToXywh = tlbrToXywh;
  _$rect_83.addEdges = addEdges;
  /* removed: var _$domUtils_71 = require("./domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("./extend.js"); */

  ;
  /* removed: var _$is_76 = require("./is.js"); */

  ;

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
  }

  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }

  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
  }

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
  }

  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function getStringOptionResult(value, target, element) {
    if (value === 'parent') {
      return (0, _$domUtils_71.parentNode)(element);
    }

    if (value === 'self') {
      return target.getRect(element);
    }

    return (0, _$domUtils_71.closest)(element, value);
  }

  function resolveRectLike(value, target, element, functionArgs) {
    var returnValue = value;

    if (_$is_76["default"].string(returnValue)) {
      returnValue = getStringOptionResult(returnValue, target, element);
    } else if (_$is_76["default"].func(returnValue)) {
      returnValue = returnValue.apply(void 0, _toConsumableArray(functionArgs));
    }

    if (_$is_76["default"].element(returnValue)) {
      returnValue = (0, _$domUtils_71.getElementRect)(returnValue);
    }

    return returnValue;
  }

  function rectToXY(rect) {
    return rect && {
      x: 'x' in rect ? rect.x : rect.left,
      y: 'y' in rect ? rect.y : rect.top
    };
  }

  function xywhToTlbr(rect) {
    if (rect && !('left' in rect && 'top' in rect)) {
      rect = (0, _$extend_73["default"])({}, rect);
      rect.left = rect.x || 0;
      rect.top = rect.y || 0;
      rect.right = rect.right || rect.left + rect.width;
      rect.bottom = rect.bottom || rect.top + rect.height;
    }

    return rect;
  }

  function tlbrToXywh(rect) {
    if (rect && !('x' in rect && 'y' in rect)) {
      rect = (0, _$extend_73["default"])({}, rect);
      rect.x = rect.left || 0;
      rect.y = rect.top || 0;
      rect.width = rect.width || (rect.right || 0) - rect.x;
      rect.height = rect.height || (rect.bottom || 0) - rect.y;
    }

    return rect;
  }

  function addEdges(edges, rect, delta) {
    if (edges.left) {
      rect.left += delta.x;
    }

    if (edges.right) {
      rect.right += delta.x;
    }

    if (edges.top) {
      rect.top += delta.y;
    }

    if (edges.bottom) {
      rect.bottom += delta.y;
    }

    rect.width = rect.right - rect.left;
    rect.height = rect.bottom - rect.top;
  }

  var _$getOriginXY_74 = {};
  "use strict";

  Object.defineProperty(_$getOriginXY_74, "__esModule", {
    value: true
  });
  _$getOriginXY_74["default"] = ___default_74;
  /* removed: var _$rect_83 = require("./rect.js"); */

  ;

  function ___default_74(target, element, actionName) {
    var actionOptions = target.options[actionName];
    var actionOrigin = actionOptions && actionOptions.origin;
    var origin = actionOrigin || target.options.origin;
    var originRect = (0, _$rect_83.resolveRectLike)(origin, target, element, [target && element]);
    return (0, _$rect_83.rectToXY)(originRect) || {
      x: 0,
      y: 0
    };
  }

  var _$normalizeListeners_79 = {};
  "use strict";

  Object.defineProperty(_$normalizeListeners_79, "__esModule", {
    value: true
  });
  _$normalizeListeners_79["default"] = normalize;
  /* removed: var _$extend_73 = require("./extend.js"); */

  ;
  /* removed: var _$is_76 = require("./is.js"); */

  ;

  function normalize(type, listeners, result) {
    result = result || {};

    if (_$is_76["default"].string(type) && type.search(' ') !== -1) {
      type = split(type);
    }

    if (_$is_76["default"].array(type)) {
      return type.reduce(function (acc, t) {
        return (0, _$extend_73["default"])(acc, normalize(t, listeners, result));
      }, result);
    } // ({ type: fn }) -> ('', { type: fn })


    if (_$is_76["default"].object(type)) {
      listeners = type;
      type = '';
    }

    if (_$is_76["default"].func(listeners)) {
      result[type] = result[type] || [];
      result[type].push(listeners);
    } else if (_$is_76["default"].array(listeners)) {
      for (var _i = 0; _i < listeners.length; _i++) {
        var _ref;

        _ref = listeners[_i];
        var l = _ref;
        normalize(type, l, result);
      }
    } else if (_$is_76["default"].object(listeners)) {
      for (var prefix in listeners) {
        var combinedTypes = split(prefix).map(function (p) {
          return "".concat(type).concat(p);
        });
        normalize(combinedTypes, listeners[prefix], result);
      }
    }

    return result;
  }

  function split(type) {
    return type.trim().split(/ +/);
  }

  var _$hypot_75 = {};
  "use strict";

  Object.defineProperty(_$hypot_75, "__esModule", {
    value: true
  });
  _$hypot_75["default"] = void 0;

  var ___default_75 = function _default(x, y) {
    return Math.sqrt(x * x + y * y);
  };

  _$hypot_75["default"] = ___default_75;
  var _$pointerExtend_80 = {};
  "use strict";

  Object.defineProperty(_$pointerExtend_80, "__esModule", {
    value: true
  });
  _$pointerExtend_80["default"] = void 0;

  function pointerExtend(dest, source) {
    for (var prop in source) {
      var prefixedPropREs = pointerExtend.prefixedPropREs;
      var deprecated = false; // skip deprecated prefixed properties

      for (var vendor in prefixedPropREs) {
        if (prop.indexOf(vendor) === 0 && prefixedPropREs[vendor].test(prop)) {
          deprecated = true;
          break;
        }
      }

      if (!deprecated && typeof source[prop] !== 'function') {
        dest[prop] = source[prop];
      }
    }

    return dest;
  }

  pointerExtend.prefixedPropREs = {
    webkit: /(Movement[XY]|Radius[XY]|RotationAngle|Force)$/,
    moz: /(Pressure)$/
  };
  var ___default_80 = pointerExtend;
  _$pointerExtend_80["default"] = ___default_80;
  var _$pointerUtils_81 = {};
  "use strict";

  Object.defineProperty(_$pointerUtils_81, "__esModule", {
    value: true
  });
  _$pointerUtils_81.copyCoords = copyCoords;
  _$pointerUtils_81.setCoordDeltas = setCoordDeltas;
  _$pointerUtils_81.setCoordVelocity = setCoordVelocity;
  _$pointerUtils_81.setZeroCoords = setZeroCoords;
  _$pointerUtils_81.isNativePointer = isNativePointer;
  _$pointerUtils_81.getXY = getXY;
  _$pointerUtils_81.getPageXY = getPageXY;
  _$pointerUtils_81.getClientXY = getClientXY;
  _$pointerUtils_81.getPointerId = getPointerId;
  _$pointerUtils_81.setCoords = setCoords;
  _$pointerUtils_81.getTouchPair = getTouchPair;
  _$pointerUtils_81.pointerAverage = pointerAverage;
  _$pointerUtils_81.touchBBox = touchBBox;
  _$pointerUtils_81.touchDistance = touchDistance;
  _$pointerUtils_81.touchAngle = touchAngle;
  _$pointerUtils_81.getPointerType = getPointerType;
  _$pointerUtils_81.getEventTargets = getEventTargets;
  _$pointerUtils_81.newCoords = newCoords;
  _$pointerUtils_81.coordsToEvent = coordsToEvent;
  Object.defineProperty(_$pointerUtils_81, "pointerExtend", {
    enumerable: true,
    get: function get() {
      return _$pointerExtend_80["default"];
    }
  });
  /* removed: var _$browser_67 = require("./browser.js"); */

  ;
  /* removed: var _$domObjects_70 = require("./domObjects.js"); */

  ;
  /* removed: var _$domUtils_71 = require("./domUtils.js"); */

  ;
  /* removed: var _$hypot_75 = require("./hypot.js"); */

  ;
  /* removed: var _$is_76 = require("./is.js"); */

  ;
  /* removed: var _$pointerExtend_80 = require("./pointerExtend.js"); */

  ;

  function copyCoords(dest, src) {
    dest.page = dest.page || {};
    dest.page.x = src.page.x;
    dest.page.y = src.page.y;
    dest.client = dest.client || {};
    dest.client.x = src.client.x;
    dest.client.y = src.client.y;
    dest.timeStamp = src.timeStamp;
  }

  function setCoordDeltas(targetObj, prev, cur) {
    targetObj.page.x = cur.page.x - prev.page.x;
    targetObj.page.y = cur.page.y - prev.page.y;
    targetObj.client.x = cur.client.x - prev.client.x;
    targetObj.client.y = cur.client.y - prev.client.y;
    targetObj.timeStamp = cur.timeStamp - prev.timeStamp;
  }

  function setCoordVelocity(targetObj, delta) {
    var dt = Math.max(delta.timeStamp / 1000, 0.001);
    targetObj.page.x = delta.page.x / dt;
    targetObj.page.y = delta.page.y / dt;
    targetObj.client.x = delta.client.x / dt;
    targetObj.client.y = delta.client.y / dt;
    targetObj.timeStamp = dt;
  }

  function setZeroCoords(targetObj) {
    targetObj.page.x = 0;
    targetObj.page.y = 0;
    targetObj.client.x = 0;
    targetObj.client.y = 0;
  }

  function isNativePointer(pointer) {
    return pointer instanceof _$domObjects_70["default"].Event || pointer instanceof _$domObjects_70["default"].Touch;
  } // Get specified X/Y coords for mouse or event.touches[0]


  function getXY(type, pointer, xy) {
    xy = xy || {};
    type = type || 'page';
    xy.x = pointer[type + 'X'];
    xy.y = pointer[type + 'Y'];
    return xy;
  }

  function getPageXY(pointer, page) {
    page = page || {
      x: 0,
      y: 0
    }; // Opera Mobile handles the viewport and scrolling oddly

    if (_$browser_67["default"].isOperaMobile && isNativePointer(pointer)) {
      getXY('screen', pointer, page);
      page.x += window.scrollX;
      page.y += window.scrollY;
    } else {
      getXY('page', pointer, page);
    }

    return page;
  }

  function getClientXY(pointer, client) {
    client = client || {};

    if (_$browser_67["default"].isOperaMobile && isNativePointer(pointer)) {
      // Opera Mobile handles the viewport and scrolling oddly
      getXY('screen', pointer, client);
    } else {
      getXY('client', pointer, client);
    }

    return client;
  }

  function getPointerId(pointer) {
    return _$is_76["default"].number(pointer.pointerId) ? pointer.pointerId : pointer.identifier;
  }

  function setCoords(targetObj, pointers, timeStamp) {
    var pointer = pointers.length > 1 ? pointerAverage(pointers) : pointers[0];
    var tmpXY = {};
    getPageXY(pointer, tmpXY);
    targetObj.page.x = tmpXY.x;
    targetObj.page.y = tmpXY.y;
    getClientXY(pointer, tmpXY);
    targetObj.client.x = tmpXY.x;
    targetObj.client.y = tmpXY.y;
    targetObj.timeStamp = timeStamp;
  }

  function getTouchPair(event) {
    var touches = []; // array of touches is supplied

    if (_$is_76["default"].array(event)) {
      touches[0] = event[0];
      touches[1] = event[1];
    } // an event
    else {
        if (event.type === 'touchend') {
          if (event.touches.length === 1) {
            touches[0] = event.touches[0];
            touches[1] = event.changedTouches[0];
          } else if (event.touches.length === 0) {
            touches[0] = event.changedTouches[0];
            touches[1] = event.changedTouches[1];
          }
        } else {
          touches[0] = event.touches[0];
          touches[1] = event.touches[1];
        }
      }

    return touches;
  }

  function pointerAverage(pointers) {
    var average = {
      pageX: 0,
      pageY: 0,
      clientX: 0,
      clientY: 0,
      screenX: 0,
      screenY: 0
    };

    for (var _i = 0; _i < pointers.length; _i++) {
      var _ref;

      _ref = pointers[_i];
      var pointer = _ref;

      for (var _prop in average) {
        average[_prop] += pointer[_prop];
      }
    }

    for (var prop in average) {
      average[prop] /= pointers.length;
    }

    return average;
  }

  function touchBBox(event) {
    if (!event.length && !(event.touches && event.touches.length > 1)) {
      return null;
    }

    var touches = getTouchPair(event);
    var minX = Math.min(touches[0].pageX, touches[1].pageX);
    var minY = Math.min(touches[0].pageY, touches[1].pageY);
    var maxX = Math.max(touches[0].pageX, touches[1].pageX);
    var maxY = Math.max(touches[0].pageY, touches[1].pageY);
    return {
      x: minX,
      y: minY,
      left: minX,
      top: minY,
      right: maxX,
      bottom: maxY,
      width: maxX - minX,
      height: maxY - minY
    };
  }

  function touchDistance(event, deltaSource) {
    var sourceX = deltaSource + 'X';
    var sourceY = deltaSource + 'Y';
    var touches = getTouchPair(event);
    var dx = touches[0][sourceX] - touches[1][sourceX];
    var dy = touches[0][sourceY] - touches[1][sourceY];
    return (0, _$hypot_75["default"])(dx, dy);
  }

  function touchAngle(event, deltaSource) {
    var sourceX = deltaSource + 'X';
    var sourceY = deltaSource + 'Y';
    var touches = getTouchPair(event);
    var dx = touches[1][sourceX] - touches[0][sourceX];
    var dy = touches[1][sourceY] - touches[0][sourceY];
    var angle = 180 * Math.atan2(dy, dx) / Math.PI;
    return angle;
  }

  function getPointerType(pointer) {
    return _$is_76["default"].string(pointer.pointerType) ? pointer.pointerType : _$is_76["default"].number(pointer.pointerType) ? [undefined, undefined, 'touch', 'pen', 'mouse'][pointer.pointerType] // if the PointerEvent API isn't available, then the "pointer" must
    // be either a MouseEvent, TouchEvent, or Touch object
    : /touch/.test(pointer.type) || pointer instanceof _$domObjects_70["default"].Touch ? 'touch' : 'mouse';
  } // [ event.target, event.currentTarget ]


  function getEventTargets(event) {
    var path = _$is_76["default"].func(event.composedPath) ? event.composedPath() : event.path;
    return [_$domUtils_71.getActualElement(path ? path[0] : event.target), _$domUtils_71.getActualElement(event.currentTarget)];
  }

  function newCoords() {
    return {
      page: {
        x: 0,
        y: 0
      },
      client: {
        x: 0,
        y: 0
      },
      timeStamp: 0
    };
  }

  function coordsToEvent(coords) {
    var event = {
      coords: coords,

      get page() {
        return this.coords.page;
      },

      get client() {
        return this.coords.client;
      },

      get timeStamp() {
        return this.coords.timeStamp;
      },

      get pageX() {
        return this.coords.page.x;
      },

      get pageY() {
        return this.coords.page.y;
      },

      get clientX() {
        return this.coords.client.x;
      },

      get clientY() {
        return this.coords.client.y;
      },

      get pointerId() {
        return this.coords.pointerId;
      },

      get target() {
        return this.coords.target;
      },

      get type() {
        return this.coords.type;
      },

      get pointerType() {
        return this.coords.pointerType;
      },

      get buttons() {
        return this.coords.buttons;
      },

      preventDefault: function preventDefault() {}
    };
    return event;
  }

  var _$BaseEvent_15 = {};
  "use strict";

  Object.defineProperty(_$BaseEvent_15, "__esModule", {
    value: true
  });
  _$BaseEvent_15["default"] = _$BaseEvent_15.BaseEvent = void 0;

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  var BaseEvent = /*#__PURE__*/function () {
    function BaseEvent(interaction) {
      _classCallCheck(this, BaseEvent);

      this.type = void 0;
      this.target = void 0;
      this.currentTarget = void 0;
      this.interactable = void 0;
      this._interaction = void 0;
      this.timeStamp = void 0;
      this.immediatePropagationStopped = false;
      this.propagationStopped = false;
      this._interaction = interaction;
    }

    _createClass(BaseEvent, [{
      key: "preventDefault",
      value: function preventDefault() {}
      /**
       * Don't call any other listeners (even on the current target)
       */

    }, {
      key: "stopPropagation",
      value: function stopPropagation() {
        this.propagationStopped = true;
      }
      /**
       * Don't call listeners on the remaining targets
       */

    }, {
      key: "stopImmediatePropagation",
      value: function stopImmediatePropagation() {
        this.immediatePropagationStopped = this.propagationStopped = true;
      }
    }]);

    return BaseEvent;
  }(); // defined outside of class definition to avoid assignment of undefined during
  // construction
  // getters and setters defined here to support typescript 3.6 and below which
  // don't support getter and setters in .d.ts files


  _$BaseEvent_15.BaseEvent = BaseEvent;
  Object.defineProperty(BaseEvent.prototype, 'interaction', {
    get: function get() {
      return this._interaction._proxy;
    },
    set: function set() {}
  });
  var ___default_15 = BaseEvent;
  _$BaseEvent_15["default"] = ___default_15;
  var _$arr_66 = {};
  "use strict";

  Object.defineProperty(_$arr_66, "__esModule", {
    value: true
  });
  _$arr_66.find = _$arr_66.findIndex = _$arr_66.from = _$arr_66.merge = _$arr_66.remove = _$arr_66.contains = void 0;

  var contains = function contains(array, target) {
    return array.indexOf(target) !== -1;
  };

  _$arr_66.contains = contains;

  var remove = function remove(array, target) {
    return array.splice(array.indexOf(target), 1);
  };

  _$arr_66.remove = remove;

  var merge = function merge(target, source) {
    for (var _i = 0; _i < source.length; _i++) {
      var _ref;

      _ref = source[_i];
      var item = _ref;
      target.push(item);
    }

    return target;
  };

  _$arr_66.merge = merge;

  var from = function from(source) {
    return merge([], source);
  };

  _$arr_66.from = from;

  var findIndex = function findIndex(array, func) {
    for (var i = 0; i < array.length; i++) {
      if (func(array[i], i, array)) {
        return i;
      }
    }

    return -1;
  };

  _$arr_66.findIndex = findIndex;

  var find = function find(array, func) {
    return array[findIndex(array, func)];
  };

  _$arr_66.find = find;
  var _$DropEvent_2 = {};
  "use strict";

  Object.defineProperty(_$DropEvent_2, "__esModule", {
    value: true
  });
  _$DropEvent_2.DropEvent = void 0;
  /* removed: var _$BaseEvent_15 = require("../../core/BaseEvent.js"); */

  ;
  /* removed: var _$arr_66 = require("../../utils/arr.js"); */

  ;

  function ___typeof_2(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_2 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_2 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_2(obj);
  }

  function ___classCallCheck_2(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_2(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_2(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_2(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_2(Constructor, staticProps);
    return Constructor;
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _createSuper(Derived) {
    var hasNativeReflectConstruct = _isNativeReflectConstruct();

    return function () {
      var Super = _getPrototypeOf(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = _getPrototypeOf(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return _possibleConstructorReturn(this, result);
    };
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (___typeof_2(call) === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  var DropEvent = /*#__PURE__*/function (_BaseEvent) {
    _inherits(DropEvent, _BaseEvent);

    var _super = _createSuper(DropEvent);
    /**
     * Class of events fired on dropzones during drags with acceptable targets.
     */


    function DropEvent(dropState, dragEvent, type) {
      var _this;

      ___classCallCheck_2(this, DropEvent);

      _this = _super.call(this, dragEvent._interaction);
      _this.target = void 0;
      _this.dropzone = void 0;
      _this.dragEvent = void 0;
      _this.relatedTarget = void 0;
      _this.draggable = void 0;
      _this.timeStamp = void 0;
      _this.propagationStopped = false;
      _this.immediatePropagationStopped = false;

      var _ref = type === 'dragleave' ? dropState.prev : dropState.cur,
          element = _ref.element,
          dropzone = _ref.dropzone;

      _this.type = type;
      _this.target = element;
      _this.currentTarget = element;
      _this.dropzone = dropzone;
      _this.dragEvent = dragEvent;
      _this.relatedTarget = dragEvent.target;
      _this.draggable = dragEvent.interactable;
      _this.timeStamp = dragEvent.timeStamp;
      return _this;
    }
    /**
     * If this is a `dropactivate` event, the dropzone element will be
     * deactivated.
     *
     * If this is a `dragmove` or `dragenter`, a `dragleave` will be fired on the
     * dropzone element and more.
     */


    ___createClass_2(DropEvent, [{
      key: "reject",
      value: function reject() {
        var _this2 = this;

        var dropState = this._interaction.dropState;

        if (this.type !== 'dropactivate' && (!this.dropzone || dropState.cur.dropzone !== this.dropzone || dropState.cur.element !== this.target)) {
          return;
        }

        dropState.prev.dropzone = this.dropzone;
        dropState.prev.element = this.target;
        dropState.rejected = true;
        dropState.events.enter = null;
        this.stopImmediatePropagation();

        if (this.type === 'dropactivate') {
          var activeDrops = dropState.activeDrops;

          var index = _$arr_66.findIndex(activeDrops, function (_ref2) {
            var dropzone = _ref2.dropzone,
                element = _ref2.element;
            return dropzone === _this2.dropzone && element === _this2.target;
          });

          dropState.activeDrops.splice(index, 1);
          var deactivateEvent = new DropEvent(dropState, this.dragEvent, 'dropdeactivate');
          deactivateEvent.dropzone = this.dropzone;
          deactivateEvent.target = this.target;
          this.dropzone.fire(deactivateEvent);
        } else {
          this.dropzone.fire(new DropEvent(dropState, this.dragEvent, 'dragleave'));
        }
      }
    }, {
      key: "preventDefault",
      value: function preventDefault() {}
    }, {
      key: "stopPropagation",
      value: function stopPropagation() {
        this.propagationStopped = true;
      }
    }, {
      key: "stopImmediatePropagation",
      value: function stopImmediatePropagation() {
        this.immediatePropagationStopped = this.propagationStopped = true;
      }
    }]);

    return DropEvent;
  }(_$BaseEvent_15.BaseEvent);

  _$DropEvent_2.DropEvent = DropEvent;
  var _$plugin_3 = {};
  "use strict";

  Object.defineProperty(_$plugin_3, "__esModule", {
    value: true
  });
  _$plugin_3["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$getOriginXY_74 = require("../../utils/getOriginXY.js"); */

  ;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;
  /* removed: var _$normalizeListeners_79 = require("../../utils/normalizeListeners.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../../utils/pointerUtils.js"); */

  ;
  /* removed: var _$plugin_1 = require("../drag/plugin.js"); */

  ;
  /* removed: var _$DropEvent_2 = require("./DropEvent.js"); */

  ;

  function __install_3(scope) {
    var actions = scope.actions,
        interact = scope.interactStatic,
        Interactable = scope.Interactable,
        defaults = scope.defaults;
    scope.usePlugin(_$plugin_1["default"]);
    /**
     *
     * ```js
     * interact('.drop').dropzone({
     *   accept: '.can-drop' || document.getElementById('single-drop'),
     *   overlap: 'pointer' || 'center' || zeroToOne
     * }
     * ```
     *
     * Returns or sets whether draggables can be dropped onto this target to
     * trigger drop events
     *
     * Dropzones can receive the following events:
     *  - `dropactivate` and `dropdeactivate` when an acceptable drag starts and ends
     *  - `dragenter` and `dragleave` when a draggable enters and leaves the dropzone
     *  - `dragmove` when a draggable that has entered the dropzone is moved
     *  - `drop` when a draggable is dropped into this dropzone
     *
     * Use the `accept` option to allow only elements that match the given CSS
     * selector or element. The value can be:
     *
     *  - **an Element** - only that element can be dropped into this dropzone.
     *  - **a string**, - the element being dragged must match it as a CSS selector.
     *  - **`null`** - accept options is cleared - it accepts any element.
     *
     * Use the `overlap` option to set how drops are checked for. The allowed
     * values are:
     *
     *   - `'pointer'`, the pointer must be over the dropzone (default)
     *   - `'center'`, the draggable element's center must be over the dropzone
     *   - a number from 0-1 which is the `(intersection area) / (draggable area)`.
     *   e.g. `0.5` for drop to happen when half of the area of the draggable is
     *   over the dropzone
     *
     * Use the `checker` option to specify a function to check if a dragged element
     * is over this Interactable.
     *
     * @param {boolean | object | null} [options] The new options to be set.
     * @return {boolean | Interactable} The current setting or this Interactable
     */

    Interactable.prototype.dropzone = function (options) {
      return dropzoneMethod(this, options);
    };
    /**
     * ```js
     * interact(target)
     * .dropChecker(function(dragEvent,         // related dragmove or dragend event
     *                       event,             // TouchEvent/PointerEvent/MouseEvent
     *                       dropped,           // bool result of the default checker
     *                       dropzone,          // dropzone Interactable
     *                       dropElement,       // dropzone elemnt
     *                       draggable,         // draggable Interactable
     *                       draggableElement) {// draggable element
     *
     *   return dropped && event.target.hasAttribute('allow-drop')
     * }
     * ```
     */


    Interactable.prototype.dropCheck = function (dragEvent, event, draggable, draggableElement, dropElement, rect) {
      return dropCheckMethod(this, dragEvent, event, draggable, draggableElement, dropElement, rect);
    };
    /**
     * Returns or sets whether the dimensions of dropzone elements are calculated
     * on every dragmove or only on dragstart for the default dropChecker
     *
     * @param {boolean} [newValue] True to check on each move. False to check only
     * before start
     * @return {boolean | interact} The current setting or interact
     */


    interact.dynamicDrop = function (newValue) {
      if (_$is_76["default"].bool(newValue)) {
        // if (dragging && scope.dynamicDrop !== newValue && !newValue) {
        //  calcRects(dropzones)
        // }
        scope.dynamicDrop = newValue;
        return interact;
      }

      return scope.dynamicDrop;
    };

    (0, _$extend_73["default"])(actions.phaselessTypes, {
      dragenter: true,
      dragleave: true,
      dropactivate: true,
      dropdeactivate: true,
      dropmove: true,
      drop: true
    });
    actions.methodDict.drop = 'dropzone';
    scope.dynamicDrop = false;
    defaults.actions.drop = drop.defaults;
  }

  function collectDrops(_ref, draggableElement) {
    var interactables = _ref.interactables;
    var drops = []; // collect all dropzones and their elements which qualify for a drop

    for (var _i = 0; _i < interactables.list.length; _i++) {
      var _ref2;

      _ref2 = interactables.list[_i];
      var dropzone = _ref2;

      if (!dropzone.options.drop.enabled) {
        continue;
      }

      var accept = dropzone.options.drop.accept; // test the draggable draggableElement against the dropzone's accept setting

      if (_$is_76["default"].element(accept) && accept !== draggableElement || _$is_76["default"].string(accept) && !_$domUtils_71.matchesSelector(draggableElement, accept) || _$is_76["default"].func(accept) && !accept({
        dropzone: dropzone,
        draggableElement: draggableElement
      })) {
        continue;
      } // query for new elements if necessary


      var dropElements = _$is_76["default"].string(dropzone.target) ? dropzone._context.querySelectorAll(dropzone.target) : _$is_76["default"].array(dropzone.target) ? dropzone.target : [dropzone.target];

      for (var _i2 = 0; _i2 < dropElements.length; _i2++) {
        var _ref3;

        _ref3 = dropElements[_i2];
        var dropzoneElement = _ref3;

        if (dropzoneElement !== draggableElement) {
          drops.push({
            dropzone: dropzone,
            element: dropzoneElement
          });
        }
      }
    }

    return drops;
  }

  function fireActivationEvents(activeDrops, event) {
    // loop through all active dropzones and trigger event
    for (var _i3 = 0; _i3 < activeDrops.slice().length; _i3++) {
      var _ref4;

      _ref4 = activeDrops.slice()[_i3];
      var _ref5 = _ref4,
          dropzone = _ref5.dropzone,
          element = _ref5.element;
      event.dropzone = dropzone; // set current element as event target

      event.target = element;
      dropzone.fire(event);
      event.propagationStopped = event.immediatePropagationStopped = false;
    }
  } // return a new array of possible drops. getActiveDrops should always be
  // called when a drag has just started or a drag event happens while
  // dynamicDrop is true


  function getActiveDrops(scope, dragElement) {
    // get dropzones and their elements that could receive the draggable
    var activeDrops = collectDrops(scope, dragElement);

    for (var _i4 = 0; _i4 < activeDrops.length; _i4++) {
      var _ref6;

      _ref6 = activeDrops[_i4];
      var activeDrop = _ref6;
      activeDrop.rect = activeDrop.dropzone.getRect(activeDrop.element);
    }

    return activeDrops;
  }

  function getDrop(_ref7, dragEvent, pointerEvent) {
    var dropState = _ref7.dropState,
        draggable = _ref7.interactable,
        dragElement = _ref7.element;
    var validDrops = []; // collect all dropzones and their elements which qualify for a drop

    for (var _i5 = 0; _i5 < dropState.activeDrops.length; _i5++) {
      var _ref8;

      _ref8 = dropState.activeDrops[_i5];
      var _ref9 = _ref8,
          dropzone = _ref9.dropzone,
          dropzoneElement = _ref9.element,
          rect = _ref9.rect;
      validDrops.push(dropzone.dropCheck(dragEvent, pointerEvent, draggable, dragElement, dropzoneElement, rect) ? dropzoneElement : null);
    } // get the most appropriate dropzone based on DOM depth and order


    var dropIndex = _$domUtils_71.indexOfDeepestElement(validDrops);

    return dropState.activeDrops[dropIndex] || null;
  }

  function getDropEvents(interaction, _pointerEvent, dragEvent) {
    var dropState = interaction.dropState;
    var dropEvents = {
      enter: null,
      leave: null,
      activate: null,
      deactivate: null,
      move: null,
      drop: null
    };

    if (dragEvent.type === 'dragstart') {
      dropEvents.activate = new _$DropEvent_2.DropEvent(dropState, dragEvent, 'dropactivate');
      dropEvents.activate.target = null;
      dropEvents.activate.dropzone = null;
    }

    if (dragEvent.type === 'dragend') {
      dropEvents.deactivate = new _$DropEvent_2.DropEvent(dropState, dragEvent, 'dropdeactivate');
      dropEvents.deactivate.target = null;
      dropEvents.deactivate.dropzone = null;
    }

    if (dropState.rejected) {
      return dropEvents;
    }

    if (dropState.cur.element !== dropState.prev.element) {
      // if there was a previous dropzone, create a dragleave event
      if (dropState.prev.dropzone) {
        dropEvents.leave = new _$DropEvent_2.DropEvent(dropState, dragEvent, 'dragleave');
        dragEvent.dragLeave = dropEvents.leave.target = dropState.prev.element;
        dragEvent.prevDropzone = dropEvents.leave.dropzone = dropState.prev.dropzone;
      } // if dropzone is not null, create a dragenter event


      if (dropState.cur.dropzone) {
        dropEvents.enter = new _$DropEvent_2.DropEvent(dropState, dragEvent, 'dragenter');
        dragEvent.dragEnter = dropState.cur.element;
        dragEvent.dropzone = dropState.cur.dropzone;
      }
    }

    if (dragEvent.type === 'dragend' && dropState.cur.dropzone) {
      dropEvents.drop = new _$DropEvent_2.DropEvent(dropState, dragEvent, 'drop');
      dragEvent.dropzone = dropState.cur.dropzone;
      dragEvent.relatedTarget = dropState.cur.element;
    }

    if (dragEvent.type === 'dragmove' && dropState.cur.dropzone) {
      dropEvents.move = new _$DropEvent_2.DropEvent(dropState, dragEvent, 'dropmove');
      dropEvents.move.dragmove = dragEvent;
      dragEvent.dropzone = dropState.cur.dropzone;
    }

    return dropEvents;
  }

  function fireDropEvents(interaction, events) {
    var dropState = interaction.dropState;
    var activeDrops = dropState.activeDrops,
        cur = dropState.cur,
        prev = dropState.prev;

    if (events.leave) {
      prev.dropzone.fire(events.leave);
    }

    if (events.move) {
      cur.dropzone.fire(events.move);
    }

    if (events.enter) {
      cur.dropzone.fire(events.enter);
    }

    if (events.drop) {
      cur.dropzone.fire(events.drop);
    }

    if (events.deactivate) {
      fireActivationEvents(activeDrops, events.deactivate);
    }

    dropState.prev.dropzone = cur.dropzone;
    dropState.prev.element = cur.element;
  }

  function onEventCreated(_ref10, scope) {
    var interaction = _ref10.interaction,
        iEvent = _ref10.iEvent,
        event = _ref10.event;

    if (iEvent.type !== 'dragmove' && iEvent.type !== 'dragend') {
      return;
    }

    var dropState = interaction.dropState;

    if (scope.dynamicDrop) {
      dropState.activeDrops = getActiveDrops(scope, interaction.element);
    }

    var dragEvent = iEvent;
    var dropResult = getDrop(interaction, dragEvent, event); // update rejected status

    dropState.rejected = dropState.rejected && !!dropResult && dropResult.dropzone === dropState.cur.dropzone && dropResult.element === dropState.cur.element;
    dropState.cur.dropzone = dropResult && dropResult.dropzone;
    dropState.cur.element = dropResult && dropResult.element;
    dropState.events = getDropEvents(interaction, event, dragEvent);
  }

  function dropzoneMethod(interactable, options) {
    if (_$is_76["default"].object(options)) {
      interactable.options.drop.enabled = options.enabled !== false;

      if (options.listeners) {
        var normalized = (0, _$normalizeListeners_79["default"])(options.listeners); // rename 'drop' to '' as it will be prefixed with 'drop'

        var corrected = Object.keys(normalized).reduce(function (acc, type) {
          var correctedType = /^(enter|leave)/.test(type) ? "drag".concat(type) : /^(activate|deactivate|move)/.test(type) ? "drop".concat(type) : type;
          acc[correctedType] = normalized[type];
          return acc;
        }, {});
        interactable.off(interactable.options.drop.listeners);
        interactable.on(corrected);
        interactable.options.drop.listeners = corrected;
      }

      if (_$is_76["default"].func(options.ondrop)) {
        interactable.on('drop', options.ondrop);
      }

      if (_$is_76["default"].func(options.ondropactivate)) {
        interactable.on('dropactivate', options.ondropactivate);
      }

      if (_$is_76["default"].func(options.ondropdeactivate)) {
        interactable.on('dropdeactivate', options.ondropdeactivate);
      }

      if (_$is_76["default"].func(options.ondragenter)) {
        interactable.on('dragenter', options.ondragenter);
      }

      if (_$is_76["default"].func(options.ondragleave)) {
        interactable.on('dragleave', options.ondragleave);
      }

      if (_$is_76["default"].func(options.ondropmove)) {
        interactable.on('dropmove', options.ondropmove);
      }

      if (/^(pointer|center)$/.test(options.overlap)) {
        interactable.options.drop.overlap = options.overlap;
      } else if (_$is_76["default"].number(options.overlap)) {
        interactable.options.drop.overlap = Math.max(Math.min(1, options.overlap), 0);
      }

      if ('accept' in options) {
        interactable.options.drop.accept = options.accept;
      }

      if ('checker' in options) {
        interactable.options.drop.checker = options.checker;
      }

      return interactable;
    }

    if (_$is_76["default"].bool(options)) {
      interactable.options.drop.enabled = options;
      return interactable;
    }

    return interactable.options.drop;
  }

  function dropCheckMethod(interactable, dragEvent, event, draggable, draggableElement, dropElement, rect) {
    var dropped = false; // if the dropzone has no rect (eg. display: none)
    // call the custom dropChecker or just return false

    if (!(rect = rect || interactable.getRect(dropElement))) {
      return interactable.options.drop.checker ? interactable.options.drop.checker(dragEvent, event, dropped, interactable, dropElement, draggable, draggableElement) : false;
    }

    var dropOverlap = interactable.options.drop.overlap;

    if (dropOverlap === 'pointer') {
      var origin = (0, _$getOriginXY_74["default"])(draggable, draggableElement, 'drag');

      var page = _$pointerUtils_81.getPageXY(dragEvent);

      page.x += origin.x;
      page.y += origin.y;
      var horizontal = page.x > rect.left && page.x < rect.right;
      var vertical = page.y > rect.top && page.y < rect.bottom;
      dropped = horizontal && vertical;
    }

    var dragRect = draggable.getRect(draggableElement);

    if (dragRect && dropOverlap === 'center') {
      var cx = dragRect.left + dragRect.width / 2;
      var cy = dragRect.top + dragRect.height / 2;
      dropped = cx >= rect.left && cx <= rect.right && cy >= rect.top && cy <= rect.bottom;
    }

    if (dragRect && _$is_76["default"].number(dropOverlap)) {
      var overlapArea = Math.max(0, Math.min(rect.right, dragRect.right) - Math.max(rect.left, dragRect.left)) * Math.max(0, Math.min(rect.bottom, dragRect.bottom) - Math.max(rect.top, dragRect.top));
      var overlapRatio = overlapArea / (dragRect.width * dragRect.height);
      dropped = overlapRatio >= dropOverlap;
    }

    if (interactable.options.drop.checker) {
      dropped = interactable.options.drop.checker(dragEvent, event, dropped, interactable, dropElement, draggable, draggableElement);
    }

    return dropped;
  }

  var drop = {
    id: 'actions/drop',
    install: __install_3,
    listeners: {
      'interactions:before-action-start': function interactionsBeforeActionStart(_ref11) {
        var interaction = _ref11.interaction;

        if (interaction.prepared.name !== 'drag') {
          return;
        }

        interaction.dropState = {
          cur: {
            dropzone: null,
            element: null
          },
          prev: {
            dropzone: null,
            element: null
          },
          rejected: null,
          events: null,
          activeDrops: []
        };
      },
      'interactions:after-action-start': function interactionsAfterActionStart(_ref12, scope) {
        var interaction = _ref12.interaction,
            event = _ref12.event,
            dragEvent = _ref12.iEvent;

        if (interaction.prepared.name !== 'drag') {
          return;
        }

        var dropState = interaction.dropState; // reset active dropzones

        dropState.activeDrops = null;
        dropState.events = null;
        dropState.activeDrops = getActiveDrops(scope, interaction.element);
        dropState.events = getDropEvents(interaction, event, dragEvent);

        if (dropState.events.activate) {
          fireActivationEvents(dropState.activeDrops, dropState.events.activate);
          scope.fire('actions/drop:start', {
            interaction: interaction,
            dragEvent: dragEvent
          });
        }
      },
      // FIXME proper signal types
      'interactions:action-move': onEventCreated,
      'interactions:action-end': onEventCreated,
      'interactions:after-action-move': function fireDropAfterMove(_ref13, scope) {
        var interaction = _ref13.interaction,
            dragEvent = _ref13.iEvent;

        if (interaction.prepared.name !== 'drag') {
          return;
        }

        fireDropEvents(interaction, interaction.dropState.events);
        scope.fire('actions/drop:move', {
          interaction: interaction,
          dragEvent: dragEvent
        });
        interaction.dropState.events = {};
      },
      'interactions:after-action-end': function interactionsAfterActionEnd(_ref14, scope) {
        var interaction = _ref14.interaction,
            dragEvent = _ref14.iEvent;

        if (interaction.prepared.name !== 'drag') {
          return;
        }

        fireDropEvents(interaction, interaction.dropState.events);
        scope.fire('actions/drop:end', {
          interaction: interaction,
          dragEvent: dragEvent
        });
      },
      'interactions:stop': function interactionsStop(_ref15) {
        var interaction = _ref15.interaction;

        if (interaction.prepared.name !== 'drag') {
          return;
        }

        var dropState = interaction.dropState;

        if (dropState) {
          dropState.activeDrops = null;
          dropState.events = null;
          dropState.cur.dropzone = null;
          dropState.cur.element = null;
          dropState.prev.dropzone = null;
          dropState.prev.element = null;
          dropState.rejected = false;
        }
      }
    },
    getActiveDrops: getActiveDrops,
    getDrop: getDrop,
    getDropEvents: getDropEvents,
    fireDropEvents: fireDropEvents,
    defaults: {
      enabled: false,
      accept: null,
      overlap: 'pointer'
    }
  };
  var ___default_3 = drop;
  _$plugin_3["default"] = ___default_3;
  var _$plugin_4 = {};
  "use strict";

  Object.defineProperty(_$plugin_4, "__esModule", {
    value: true
  });
  _$plugin_4["default"] = void 0;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../../utils/pointerUtils.js"); */

  ;

  function __install_4(scope) {
    var actions = scope.actions,
        Interactable = scope.Interactable,
        defaults = scope.defaults;
    /**
     * ```js
     * interact(element).gesturable({
     *     onstart: function (event) {},
     *     onmove : function (event) {},
     *     onend  : function (event) {},
     *
     *     // limit multiple gestures.
     *     // See the explanation in {@link Interactable.draggable} example
     *     max: Infinity,
     *     maxPerElement: 1,
     * })
     *
     * var isGestureable = interact(element).gesturable()
     * ```
     *
     * Gets or sets whether multitouch gestures can be performed on the target
     *
     * @param {boolean | object} [options] true/false or An object with event
     * listeners to be fired on gesture events (makes the Interactable gesturable)
     * @return {boolean | Interactable} A boolean indicating if this can be the
     * target of gesture events, or this Interactable
     */

    Interactable.prototype.gesturable = function (options) {
      if (_$is_76["default"].object(options)) {
        this.options.gesture.enabled = options.enabled !== false;
        this.setPerAction('gesture', options);
        this.setOnEvents('gesture', options);
        return this;
      }

      if (_$is_76["default"].bool(options)) {
        this.options.gesture.enabled = options;
        return this;
      }

      return this.options.gesture;
    };

    actions.map.gesture = gesture;
    actions.methodDict.gesture = 'gesturable';
    defaults.actions.gesture = gesture.defaults;
  }

  function updateGestureProps(_ref) {
    var interaction = _ref.interaction,
        iEvent = _ref.iEvent,
        phase = _ref.phase;

    if (interaction.prepared.name !== 'gesture') {
      return;
    }

    var pointers = interaction.pointers.map(function (p) {
      return p.pointer;
    });
    var starting = phase === 'start';
    var ending = phase === 'end';
    var deltaSource = interaction.interactable.options.deltaSource;
    iEvent.touches = [pointers[0], pointers[1]];

    if (starting) {
      iEvent.distance = _$pointerUtils_81.touchDistance(pointers, deltaSource);
      iEvent.box = _$pointerUtils_81.touchBBox(pointers);
      iEvent.scale = 1;
      iEvent.ds = 0;
      iEvent.angle = _$pointerUtils_81.touchAngle(pointers, deltaSource);
      iEvent.da = 0;
      interaction.gesture.startDistance = iEvent.distance;
      interaction.gesture.startAngle = iEvent.angle;
    } else if (ending) {
      var prevEvent = interaction.prevEvent;
      iEvent.distance = prevEvent.distance;
      iEvent.box = prevEvent.box;
      iEvent.scale = prevEvent.scale;
      iEvent.ds = 0;
      iEvent.angle = prevEvent.angle;
      iEvent.da = 0;
    } else {
      iEvent.distance = _$pointerUtils_81.touchDistance(pointers, deltaSource);
      iEvent.box = _$pointerUtils_81.touchBBox(pointers);
      iEvent.scale = iEvent.distance / interaction.gesture.startDistance;
      iEvent.angle = _$pointerUtils_81.touchAngle(pointers, deltaSource);
      iEvent.ds = iEvent.scale - interaction.gesture.scale;
      iEvent.da = iEvent.angle - interaction.gesture.angle;
    }

    interaction.gesture.distance = iEvent.distance;
    interaction.gesture.angle = iEvent.angle;

    if (_$is_76["default"].number(iEvent.scale) && iEvent.scale !== Infinity && !isNaN(iEvent.scale)) {
      interaction.gesture.scale = iEvent.scale;
    }
  }

  var gesture = {
    id: 'actions/gesture',
    before: ['actions/drag', 'actions/resize'],
    install: __install_4,
    listeners: {
      'interactions:action-start': updateGestureProps,
      'interactions:action-move': updateGestureProps,
      'interactions:action-end': updateGestureProps,
      'interactions:new': function interactionsNew(_ref2) {
        var interaction = _ref2.interaction;
        interaction.gesture = {
          angle: 0,
          distance: 0,
          scale: 1,
          startAngle: 0,
          startDistance: 0
        };
      },
      'auto-start:check': function autoStartCheck(arg) {
        if (arg.interaction.pointers.length < 2) {
          return undefined;
        }

        var gestureOptions = arg.interactable.options.gesture;

        if (!(gestureOptions && gestureOptions.enabled)) {
          return undefined;
        }

        arg.action = {
          name: 'gesture'
        };
        return false;
      }
    },
    defaults: {},
    getCursor: function getCursor() {
      return '';
    }
  };
  var ___default_4 = gesture;
  _$plugin_4["default"] = ___default_4;
  var _$plugin_6 = {};
  "use strict";

  Object.defineProperty(_$plugin_6, "__esModule", {
    value: true
  });
  _$plugin_6["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;

  function __install_6(scope) {
    var actions = scope.actions,
        browser = scope.browser,
        Interactable = scope.Interactable,
        defaults = scope.defaults; // Less Precision with touch input

    resize.cursors = initCursors(browser);
    resize.defaultMargin = browser.supportsTouch || browser.supportsPointerEvent ? 20 : 10;
    /**
     * ```js
     * interact(element).resizable({
     *   onstart: function (event) {},
     *   onmove : function (event) {},
     *   onend  : function (event) {},
     *
     *   edges: {
     *     top   : true,       // Use pointer coords to check for resize.
     *     left  : false,      // Disable resizing from left edge.
     *     bottom: '.resize-s',// Resize if pointer target matches selector
     *     right : handleEl    // Resize if pointer target is the given Element
     *   },
     *
     *     // Width and height can be adjusted independently. When `true`, width and
     *     // height are adjusted at a 1:1 ratio.
     *     square: false,
     *
     *     // Width and height can be adjusted independently. When `true`, width and
     *     // height maintain the aspect ratio they had when resizing started.
     *     preserveAspectRatio: false,
     *
     *   // a value of 'none' will limit the resize rect to a minimum of 0x0
     *   // 'negate' will allow the rect to have negative width/height
     *   // 'reposition' will keep the width/height positive by swapping
     *   // the top and bottom edges and/or swapping the left and right edges
     *   invert: 'none' || 'negate' || 'reposition'
     *
     *   // limit multiple resizes.
     *   // See the explanation in the {@link Interactable.draggable} example
     *   max: Infinity,
     *   maxPerElement: 1,
     * })
     *
     * var isResizeable = interact(element).resizable()
     * ```
     *
     * Gets or sets whether resize actions can be performed on the target
     *
     * @param {boolean | object} [options] true/false or An object with event
     * listeners to be fired on resize events (object makes the Interactable
     * resizable)
     * @return {boolean | Interactable} A boolean indicating if this can be the
     * target of resize elements, or this Interactable
     */

    Interactable.prototype.resizable = function (options) {
      return resizable(this, options, scope);
    };

    actions.map.resize = resize;
    actions.methodDict.resize = 'resizable';
    defaults.actions.resize = resize.defaults;
  }

  function resizeChecker(arg) {
    var interaction = arg.interaction,
        interactable = arg.interactable,
        element = arg.element,
        rect = arg.rect,
        buttons = arg.buttons;

    if (!rect) {
      return undefined;
    }

    var page = (0, _$extend_73["default"])({}, interaction.coords.cur.page);
    var resizeOptions = interactable.options.resize;

    if (!(resizeOptions && resizeOptions.enabled) || // check mouseButton setting if the pointer is down
    interaction.pointerIsDown && /mouse|pointer/.test(interaction.pointerType) && (buttons & resizeOptions.mouseButtons) === 0) {
      return undefined;
    } // if using resize.edges


    if (_$is_76["default"].object(resizeOptions.edges)) {
      var resizeEdges = {
        left: false,
        right: false,
        top: false,
        bottom: false
      };

      for (var edge in resizeEdges) {
        resizeEdges[edge] = checkResizeEdge(edge, resizeOptions.edges[edge], page, interaction._latestPointer.eventTarget, element, rect, resizeOptions.margin || resize.defaultMargin);
      }

      resizeEdges.left = resizeEdges.left && !resizeEdges.right;
      resizeEdges.top = resizeEdges.top && !resizeEdges.bottom;

      if (resizeEdges.left || resizeEdges.right || resizeEdges.top || resizeEdges.bottom) {
        arg.action = {
          name: 'resize',
          edges: resizeEdges
        };
      }
    } else {
      var right = resizeOptions.axis !== 'y' && page.x > rect.right - resize.defaultMargin;
      var bottom = resizeOptions.axis !== 'x' && page.y > rect.bottom - resize.defaultMargin;

      if (right || bottom) {
        arg.action = {
          name: 'resize',
          axes: (right ? 'x' : '') + (bottom ? 'y' : '')
        };
      }
    }

    return arg.action ? false : undefined;
  }

  function resizable(interactable, options, scope) {
    if (_$is_76["default"].object(options)) {
      interactable.options.resize.enabled = options.enabled !== false;
      interactable.setPerAction('resize', options);
      interactable.setOnEvents('resize', options);

      if (_$is_76["default"].string(options.axis) && /^x$|^y$|^xy$/.test(options.axis)) {
        interactable.options.resize.axis = options.axis;
      } else if (options.axis === null) {
        interactable.options.resize.axis = scope.defaults.actions.resize.axis;
      }

      if (_$is_76["default"].bool(options.preserveAspectRatio)) {
        interactable.options.resize.preserveAspectRatio = options.preserveAspectRatio;
      } else if (_$is_76["default"].bool(options.square)) {
        interactable.options.resize.square = options.square;
      }

      return interactable;
    }

    if (_$is_76["default"].bool(options)) {
      interactable.options.resize.enabled = options;
      return interactable;
    }

    return interactable.options.resize;
  }

  function checkResizeEdge(name, value, page, element, interactableElement, rect, margin) {
    // false, '', undefined, null
    if (!value) {
      return false;
    } // true value, use pointer coords and element rect


    if (value === true) {
      // if dimensions are negative, "switch" edges
      var width = _$is_76["default"].number(rect.width) ? rect.width : rect.right - rect.left;
      var height = _$is_76["default"].number(rect.height) ? rect.height : rect.bottom - rect.top; // don't use margin greater than half the relevent dimension

      margin = Math.min(margin, Math.abs((name === 'left' || name === 'right' ? width : height) / 2));

      if (width < 0) {
        if (name === 'left') {
          name = 'right';
        } else if (name === 'right') {
          name = 'left';
        }
      }

      if (height < 0) {
        if (name === 'top') {
          name = 'bottom';
        } else if (name === 'bottom') {
          name = 'top';
        }
      }

      if (name === 'left') {
        return page.x < (width >= 0 ? rect.left : rect.right) + margin;
      }

      if (name === 'top') {
        return page.y < (height >= 0 ? rect.top : rect.bottom) + margin;
      }

      if (name === 'right') {
        return page.x > (width >= 0 ? rect.right : rect.left) - margin;
      }

      if (name === 'bottom') {
        return page.y > (height >= 0 ? rect.bottom : rect.top) - margin;
      }
    } // the remaining checks require an element


    if (!_$is_76["default"].element(element)) {
      return false;
    }

    return _$is_76["default"].element(value) // the value is an element to use as a resize handle
    ? value === element // otherwise check if element matches value as selector
    : _$domUtils_71.matchesUpTo(element, value, interactableElement);
  }

  function initCursors(browser) {
    return browser.isIe9 ? {
      x: 'e-resize',
      y: 's-resize',
      xy: 'se-resize',
      top: 'n-resize',
      left: 'w-resize',
      bottom: 's-resize',
      right: 'e-resize',
      topleft: 'se-resize',
      bottomright: 'se-resize',
      topright: 'ne-resize',
      bottomleft: 'ne-resize'
    } : {
      x: 'ew-resize',
      y: 'ns-resize',
      xy: 'nwse-resize',
      top: 'ns-resize',
      left: 'ew-resize',
      bottom: 'ns-resize',
      right: 'ew-resize',
      topleft: 'nwse-resize',
      bottomright: 'nwse-resize',
      topright: 'nesw-resize',
      bottomleft: 'nesw-resize'
    };
  }

  function start(_ref) {
    var iEvent = _ref.iEvent,
        interaction = _ref.interaction;

    if (interaction.prepared.name !== 'resize' || !interaction.prepared.edges) {
      return;
    }

    var resizeEvent = iEvent;
    var rect = interaction.rect;
    interaction._rects = {
      start: (0, _$extend_73["default"])({}, rect),
      corrected: (0, _$extend_73["default"])({}, rect),
      previous: (0, _$extend_73["default"])({}, rect),
      delta: {
        left: 0,
        right: 0,
        width: 0,
        top: 0,
        bottom: 0,
        height: 0
      }
    };
    resizeEvent.edges = interaction.prepared.edges;
    resizeEvent.rect = interaction._rects.corrected;
    resizeEvent.deltaRect = interaction._rects.delta;
  }

  function __move_6(_ref2) {
    var iEvent = _ref2.iEvent,
        interaction = _ref2.interaction;

    if (interaction.prepared.name !== 'resize' || !interaction.prepared.edges) {
      return;
    }

    var resizeEvent = iEvent;
    var resizeOptions = interaction.interactable.options.resize;
    var invert = resizeOptions.invert;
    var invertible = invert === 'reposition' || invert === 'negate'; // eslint-disable-next-line no-shadow

    var current = interaction.rect;
    var _interaction$_rects = interaction._rects,
        startRect = _interaction$_rects.start,
        corrected = _interaction$_rects.corrected,
        deltaRect = _interaction$_rects.delta,
        previous = _interaction$_rects.previous;
    (0, _$extend_73["default"])(previous, corrected);

    if (invertible) {
      // if invertible, copy the current rect
      (0, _$extend_73["default"])(corrected, current);

      if (invert === 'reposition') {
        // swap edge values if necessary to keep width/height positive
        if (corrected.top > corrected.bottom) {
          var swap = corrected.top;
          corrected.top = corrected.bottom;
          corrected.bottom = swap;
        }

        if (corrected.left > corrected.right) {
          var _swap = corrected.left;
          corrected.left = corrected.right;
          corrected.right = _swap;
        }
      }
    } else {
      // if not invertible, restrict to minimum of 0x0 rect
      corrected.top = Math.min(current.top, startRect.bottom);
      corrected.bottom = Math.max(current.bottom, startRect.top);
      corrected.left = Math.min(current.left, startRect.right);
      corrected.right = Math.max(current.right, startRect.left);
    }

    corrected.width = corrected.right - corrected.left;
    corrected.height = corrected.bottom - corrected.top;

    for (var edge in corrected) {
      deltaRect[edge] = corrected[edge] - previous[edge];
    }

    resizeEvent.edges = interaction.prepared.edges;
    resizeEvent.rect = corrected;
    resizeEvent.deltaRect = deltaRect;
  }

  function end(_ref3) {
    var iEvent = _ref3.iEvent,
        interaction = _ref3.interaction;

    if (interaction.prepared.name !== 'resize' || !interaction.prepared.edges) {
      return;
    }

    var resizeEvent = iEvent;
    resizeEvent.edges = interaction.prepared.edges;
    resizeEvent.rect = interaction._rects.corrected;
    resizeEvent.deltaRect = interaction._rects.delta;
  }

  function updateEventAxes(_ref4) {
    var iEvent = _ref4.iEvent,
        interaction = _ref4.interaction;

    if (interaction.prepared.name !== 'resize' || !interaction.resizeAxes) {
      return;
    }

    var options = interaction.interactable.options;
    var resizeEvent = iEvent;

    if (options.resize.square) {
      if (interaction.resizeAxes === 'y') {
        resizeEvent.delta.x = resizeEvent.delta.y;
      } else {
        resizeEvent.delta.y = resizeEvent.delta.x;
      }

      resizeEvent.axes = 'xy';
    } else {
      resizeEvent.axes = interaction.resizeAxes;

      if (interaction.resizeAxes === 'x') {
        resizeEvent.delta.y = 0;
      } else if (interaction.resizeAxes === 'y') {
        resizeEvent.delta.x = 0;
      }
    }
  }

  var resize = {
    id: 'actions/resize',
    before: ['actions/drag'],
    install: __install_6,
    listeners: {
      'interactions:new': function interactionsNew(_ref5) {
        var interaction = _ref5.interaction;
        interaction.resizeAxes = 'xy';
      },
      'interactions:action-start': function interactionsActionStart(arg) {
        start(arg);
        updateEventAxes(arg);
      },
      'interactions:action-move': function interactionsActionMove(arg) {
        __move_6(arg);

        updateEventAxes(arg);
      },
      'interactions:action-end': end,
      'auto-start:check': resizeChecker
    },
    defaults: {
      square: false,
      preserveAspectRatio: false,
      axis: 'xy',
      // use default margin
      margin: NaN,
      // object with props left, right, top, bottom which are
      // true/false values to resize when the pointer is over that edge,
      // CSS selectors to match the handles for each direction
      // or the Elements for each handle
      edges: null,
      // a value of 'none' will limit the resize rect to a minimum of 0x0
      // 'negate' will alow the rect to have negative width/height
      // 'reposition' will keep the width/height positive by swapping
      // the top and bottom edges and/or swapping the left and right edges
      invert: 'none'
    },
    cursors: null,
    getCursor: function getCursor(_ref6) {
      var edges = _ref6.edges,
          axis = _ref6.axis,
          name = _ref6.name;
      var cursors = resize.cursors;
      var result = null;

      if (axis) {
        result = cursors[name + axis];
      } else if (edges) {
        var cursorKey = '';
        var _arr = ['top', 'bottom', 'left', 'right'];

        for (var _i = 0; _i < _arr.length; _i++) {
          var edge = _arr[_i];

          if (edges[edge]) {
            cursorKey += edge;
          }
        }

        result = cursors[cursorKey];
      }

      return result;
    },
    defaultMargin: null
  };
  var ___default_6 = resize;
  _$plugin_6["default"] = ___default_6;
  var _$plugin_5 = {};
  "use strict";

  Object.defineProperty(_$plugin_5, "__esModule", {
    value: true
  });
  _$plugin_5["default"] = void 0;
  /* removed: var _$plugin_1 = require("./drag/plugin.js"); */

  ;
  /* removed: var _$plugin_3 = require("./drop/plugin.js"); */

  ;
  /* removed: var _$plugin_4 = require("./gesture/plugin.js"); */

  ;
  /* removed: var _$plugin_6 = require("./resize/plugin.js"); */

  ;
  var ___default_5 = {
    id: 'actions',
    install: function install(scope) {
      scope.usePlugin(_$plugin_4["default"]);
      scope.usePlugin(_$plugin_6["default"]);
      scope.usePlugin(_$plugin_1["default"]);
      scope.usePlugin(_$plugin_3["default"]);
    }
  };
  _$plugin_5["default"] = ___default_5;
  var _$plugin_7 = {};
  "use strict";

  Object.defineProperty(_$plugin_7, "__esModule", {
    value: true
  });
  _$plugin_7["default"] = void 0;
  var ___default_7 = {};
  _$plugin_7["default"] = ___default_7;
  var _$raf_82 = {};
  "use strict";

  Object.defineProperty(_$raf_82, "__esModule", {
    value: true
  });
  _$raf_82["default"] = void 0;
  var lastTime = 0;

  var _request;

  var _cancel;

  function __init_82(window) {
    _request = window.requestAnimationFrame;
    _cancel = window.cancelAnimationFrame;

    if (!_request) {
      var vendors = ['ms', 'moz', 'webkit', 'o'];

      for (var _i = 0; _i < vendors.length; _i++) {
        var vendor = vendors[_i];
        _request = window["".concat(vendor, "RequestAnimationFrame")];
        _cancel = window["".concat(vendor, "CancelAnimationFrame")] || window["".concat(vendor, "CancelRequestAnimationFrame")];
      }
    }

    if (!_request) {
      _request = function request(callback) {
        var currTime = Date.now();
        var timeToCall = Math.max(0, 16 - (currTime - lastTime)); // eslint-disable-next-line standard/no-callback-literal

        var token = setTimeout(function () {
          callback(currTime + timeToCall);
        }, timeToCall);
        lastTime = currTime + timeToCall;
        return token;
      };

      _cancel = function cancel(token) {
        return clearTimeout(token);
      };
    }
  }

  var ___default_82 = {
    request: function request(callback) {
      return _request(callback);
    },
    cancel: function cancel(token) {
      return _cancel(token);
    },
    init: __init_82
  };
  _$raf_82["default"] = ___default_82;
  var _$plugin_8 = {};
  "use strict";

  Object.defineProperty(_$plugin_8, "__esModule", {
    value: true
  });
  _$plugin_8.getContainer = getContainer;
  _$plugin_8.getScroll = getScroll;
  _$plugin_8.getScrollSize = getScrollSize;
  _$plugin_8.getScrollSizeDelta = getScrollSizeDelta;
  _$plugin_8["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$raf_82 = require("../utils/raf.js"); */

  ;
  /* removed: var _$rect_83 = require("../utils/rect.js"); */

  ;
  /* removed: var _$window_84 = require("../utils/window.js"); */

  ;

  function __install_8(scope) {
    var defaults = scope.defaults,
        actions = scope.actions;
    scope.autoScroll = autoScroll;

    autoScroll.now = function () {
      return scope.now();
    };

    actions.phaselessTypes.autoscroll = true;
    defaults.perAction.autoScroll = autoScroll.defaults;
  }

  var autoScroll = {
    defaults: {
      enabled: false,
      margin: 60,
      // the item that is scrolled (Window or HTMLElement)
      container: null,
      // the scroll speed in pixels per second
      speed: 300
    },
    now: Date.now,
    interaction: null,
    i: 0,
    // the handle returned by window.setInterval
    // Direction each pulse is to scroll in
    x: 0,
    y: 0,
    isScrolling: false,
    prevTime: 0,
    margin: 0,
    speed: 0,
    start: function start(interaction) {
      autoScroll.isScrolling = true;

      _$raf_82["default"].cancel(autoScroll.i);

      interaction.autoScroll = autoScroll;
      autoScroll.interaction = interaction;
      autoScroll.prevTime = autoScroll.now();
      autoScroll.i = _$raf_82["default"].request(autoScroll.scroll);
    },
    stop: function stop() {
      autoScroll.isScrolling = false;

      if (autoScroll.interaction) {
        autoScroll.interaction.autoScroll = null;
      }

      _$raf_82["default"].cancel(autoScroll.i);
    },
    // scroll the window by the values in scroll.x/y
    scroll: function scroll() {
      var interaction = autoScroll.interaction;
      var interactable = interaction.interactable,
          element = interaction.element;
      var actionName = interaction.prepared.name;
      var options = interactable.options[actionName].autoScroll;
      var container = getContainer(options.container, interactable, element);
      var now = autoScroll.now(); // change in time in seconds

      var dt = (now - autoScroll.prevTime) / 1000; // displacement

      var s = options.speed * dt;

      if (s >= 1) {
        var scrollBy = {
          x: autoScroll.x * s,
          y: autoScroll.y * s
        };

        if (scrollBy.x || scrollBy.y) {
          var prevScroll = getScroll(container);

          if (_$is_76["default"].window(container)) {
            container.scrollBy(scrollBy.x, scrollBy.y);
          } else if (container) {
            container.scrollLeft += scrollBy.x;
            container.scrollTop += scrollBy.y;
          }

          var curScroll = getScroll(container);
          var delta = {
            x: curScroll.x - prevScroll.x,
            y: curScroll.y - prevScroll.y
          };

          if (delta.x || delta.y) {
            interactable.fire({
              type: 'autoscroll',
              target: element,
              interactable: interactable,
              delta: delta,
              interaction: interaction,
              container: container
            });
          }
        }

        autoScroll.prevTime = now;
      }

      if (autoScroll.isScrolling) {
        _$raf_82["default"].cancel(autoScroll.i);

        autoScroll.i = _$raf_82["default"].request(autoScroll.scroll);
      }
    },
    check: function check(interactable, actionName) {
      var options = interactable.options;
      return options[actionName].autoScroll && options[actionName].autoScroll.enabled;
    },
    onInteractionMove: function onInteractionMove(_ref) {
      var interaction = _ref.interaction,
          pointer = _ref.pointer;

      if (!(interaction.interacting() && autoScroll.check(interaction.interactable, interaction.prepared.name))) {
        return;
      }

      if (interaction.simulation) {
        autoScroll.x = autoScroll.y = 0;
        return;
      }

      var top;
      var right;
      var bottom;
      var left;
      var interactable = interaction.interactable,
          element = interaction.element;
      var actionName = interaction.prepared.name;
      var options = interactable.options[actionName].autoScroll;
      var container = getContainer(options.container, interactable, element);

      if (_$is_76["default"].window(container)) {
        left = pointer.clientX < autoScroll.margin;
        top = pointer.clientY < autoScroll.margin;
        right = pointer.clientX > container.innerWidth - autoScroll.margin;
        bottom = pointer.clientY > container.innerHeight - autoScroll.margin;
      } else {
        var rect = _$domUtils_71.getElementClientRect(container);

        left = pointer.clientX < rect.left + autoScroll.margin;
        top = pointer.clientY < rect.top + autoScroll.margin;
        right = pointer.clientX > rect.right - autoScroll.margin;
        bottom = pointer.clientY > rect.bottom - autoScroll.margin;
      }

      autoScroll.x = right ? 1 : left ? -1 : 0;
      autoScroll.y = bottom ? 1 : top ? -1 : 0;

      if (!autoScroll.isScrolling) {
        // set the autoScroll properties to those of the target
        autoScroll.margin = options.margin;
        autoScroll.speed = options.speed;
        autoScroll.start(interaction);
      }
    }
  };

  function getContainer(value, interactable, element) {
    return (_$is_76["default"].string(value) ? (0, _$rect_83.getStringOptionResult)(value, interactable, element) : value) || (0, _$window_84.getWindow)(element);
  }

  function getScroll(container) {
    if (_$is_76["default"].window(container)) {
      container = window.document.body;
    }

    return {
      x: container.scrollLeft,
      y: container.scrollTop
    };
  }

  function getScrollSize(container) {
    if (_$is_76["default"].window(container)) {
      container = window.document.body;
    }

    return {
      x: container.scrollWidth,
      y: container.scrollHeight
    };
  }

  function getScrollSizeDelta(_ref2, func) {
    var interaction = _ref2.interaction,
        element = _ref2.element;
    var scrollOptions = interaction && interaction.interactable.options[interaction.prepared.name].autoScroll;

    if (!scrollOptions || !scrollOptions.enabled) {
      func();
      return {
        x: 0,
        y: 0
      };
    }

    var scrollContainer = getContainer(scrollOptions.container, interaction.interactable, element);
    var prevSize = getScroll(scrollContainer);
    func();
    var curSize = getScroll(scrollContainer);
    return {
      x: curSize.x - prevSize.x,
      y: curSize.y - prevSize.y
    };
  }

  var autoScrollPlugin = {
    id: 'auto-scroll',
    install: __install_8,
    listeners: {
      'interactions:new': function interactionsNew(_ref3) {
        var interaction = _ref3.interaction;
        interaction.autoScroll = null;
      },
      'interactions:destroy': function interactionsDestroy(_ref4) {
        var interaction = _ref4.interaction;
        interaction.autoScroll = null;
        autoScroll.stop();

        if (autoScroll.interaction) {
          autoScroll.interaction = null;
        }
      },
      'interactions:stop': autoScroll.stop,
      'interactions:action-move': function interactionsActionMove(arg) {
        return autoScroll.onInteractionMove(arg);
      }
    }
  };
  var ___default_8 = autoScrollPlugin;
  _$plugin_8["default"] = ___default_8;
  var _$misc_78 = {};
  "use strict";

  Object.defineProperty(_$misc_78, "__esModule", {
    value: true
  });
  _$misc_78.warnOnce = warnOnce;
  _$misc_78.copyAction = copyAction;
  /* removed: var _$window_84 = require("./window.js"); */

  ;

  function warnOnce(method, message) {
    var warned = false;
    return function () {
      if (!warned) {
        _$window_84["default"].window.console.warn(message);

        warned = true;
      }

      return method.apply(this, arguments);
    };
  }

  function copyAction(dest, src) {
    dest.name = src.name;
    dest.axis = src.axis;
    dest.edges = src.edges;
    return dest;
  }

  var _$InteractableMethods_9 = {};
  "use strict";

  Object.defineProperty(_$InteractableMethods_9, "__esModule", {
    value: true
  });
  _$InteractableMethods_9["default"] = void 0;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$misc_78 = require("../utils/misc.js"); */

  ;

  function __install_9(scope) {
    var Interactable = scope.Interactable;

    Interactable.prototype.getAction = function getAction(pointer, event, interaction, element) {
      var action = defaultActionChecker(this, event, interaction, element, scope);

      if (this.options.actionChecker) {
        return this.options.actionChecker(pointer, event, action, this, element, interaction);
      }

      return action;
    };
    /**
     * ```js
     * interact(element, { ignoreFrom: document.getElementById('no-action') })
     * // or
     * interact(element).ignoreFrom('input, textarea, a')
     * ```
     * @deprecated
     * If the target of the `mousedown`, `pointerdown` or `touchstart` event or any
     * of it's parents match the given CSS selector or Element, no
     * drag/resize/gesture is started.
     *
     * Don't use this method. Instead set the `ignoreFrom` option for each action
     * or for `pointerEvents`
     *
     * @example
     * interact(targett)
     *   .draggable({
     *     ignoreFrom: 'input, textarea, a[href]'',
     *   })
     *   .pointerEvents({
     *     ignoreFrom: '[no-pointer]',
     *   })
     *
     * @param {string | Element | null} [newValue] a CSS selector string, an
     * Element or `null` to not ignore any elements
     * @return {string | Element | object} The current ignoreFrom value or this
     * Interactable
     */


    Interactable.prototype.ignoreFrom = (0, _$misc_78.warnOnce)(function (newValue) {
      return this._backCompatOption('ignoreFrom', newValue);
    }, 'Interactable.ignoreFrom() has been deprecated. Use Interactble.draggable({ignoreFrom: newValue}).');
    /**
     * @deprecated
     *
     * A drag/resize/gesture is started only If the target of the `mousedown`,
     * `pointerdown` or `touchstart` event or any of it's parents match the given
     * CSS selector or Element.
     *
     * Don't use this method. Instead set the `allowFrom` option for each action
     * or for `pointerEvents`
     *
     * @example
     * interact(targett)
     *   .resizable({
     *     allowFrom: '.resize-handle',
     *   .pointerEvents({
     *     allowFrom: '.handle',,
     *   })
     *
     * @param {string | Element | null} [newValue] a CSS selector string, an
     * Element or `null` to allow from any element
     * @return {string | Element | object} The current allowFrom value or this
     * Interactable
     */

    Interactable.prototype.allowFrom = (0, _$misc_78.warnOnce)(function (newValue) {
      return this._backCompatOption('allowFrom', newValue);
    }, 'Interactable.allowFrom() has been deprecated. Use Interactble.draggable({allowFrom: newValue}).');
    /**
     * ```js
     * interact('.resize-drag')
     *   .resizable(true)
     *   .draggable(true)
     *   .actionChecker(function (pointer, event, action, interactable, element, interaction) {
     *
     *   if (interact.matchesSelector(event.target, '.drag-handle')) {
     *     // force drag with handle target
     *     action.name = drag
     *   }
     *   else {
     *     // resize from the top and right edges
     *     action.name  = 'resize'
     *     action.edges = { top: true, right: true }
     *   }
     *
     *   return action
     * })
     * ```
     *
     * Returns or sets the function used to check action to be performed on
     * pointerDown
     *
     * @param {function | null} [checker] A function which takes a pointer event,
     * defaultAction string, interactable, element and interaction as parameters
     * and returns an object with name property 'drag' 'resize' or 'gesture' and
     * optionally an `edges` object with boolean 'top', 'left', 'bottom' and right
     * props.
     * @return {Function | Interactable} The checker function or this Interactable
     */

    Interactable.prototype.actionChecker = actionChecker;
    /**
     * Returns or sets whether the the cursor should be changed depending on the
     * action that would be performed if the mouse were pressed and dragged.
     *
     * @param {boolean} [newValue]
     * @return {boolean | Interactable} The current setting or this Interactable
     */

    Interactable.prototype.styleCursor = styleCursor;
  }

  function defaultActionChecker(interactable, event, interaction, element, scope) {
    var rect = interactable.getRect(element);
    var buttons = event.buttons || {
      0: 1,
      1: 4,
      3: 8,
      4: 16
    }[event.button];
    var arg = {
      action: null,
      interactable: interactable,
      interaction: interaction,
      element: element,
      rect: rect,
      buttons: buttons
    };
    scope.fire('auto-start:check', arg);
    return arg.action;
  }

  function styleCursor(newValue) {
    if (_$is_76["default"].bool(newValue)) {
      this.options.styleCursor = newValue;
      return this;
    }

    if (newValue === null) {
      delete this.options.styleCursor;
      return this;
    }

    return this.options.styleCursor;
  }

  function actionChecker(checker) {
    if (_$is_76["default"].func(checker)) {
      this.options.actionChecker = checker;
      return this;
    }

    if (checker === null) {
      delete this.options.actionChecker;
      return this;
    }

    return this.options.actionChecker;
  }

  var ___default_9 = {
    id: 'auto-start/interactableMethods',
    install: __install_9
  };
  _$InteractableMethods_9["default"] = ___default_9;
  var _$base_10 = {};
  "use strict";

  Object.defineProperty(_$base_10, "__esModule", {
    value: true
  });
  _$base_10["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$misc_78 = require("../utils/misc.js"); */

  ;
  /* removed: var _$InteractableMethods_9 = require("./InteractableMethods.js"); */

  ;

  function __install_10(scope) {
    var interact = scope.interactStatic,
        defaults = scope.defaults;
    scope.usePlugin(_$InteractableMethods_9["default"]);
    defaults.base.actionChecker = null;
    defaults.base.styleCursor = true;
    (0, _$extend_73["default"])(defaults.perAction, {
      manualStart: false,
      max: Infinity,
      maxPerElement: 1,
      allowFrom: null,
      ignoreFrom: null,
      // only allow left button by default
      // see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons#Return_value
      mouseButtons: 1
    });
    /**
     * Returns or sets the maximum number of concurrent interactions allowed.  By
     * default only 1 interaction is allowed at a time (for backwards
     * compatibility). To allow multiple interactions on the same Interactables and
     * elements, you need to enable it in the draggable, resizable and gesturable
     * `'max'` and `'maxPerElement'` options.
     *
     * @alias module:interact.maxInteractions
     *
     * @param {number} [newValue] Any number. newValue <= 0 means no interactions.
     */

    interact.maxInteractions = function (newValue) {
      return maxInteractions(newValue, scope);
    };

    scope.autoStart = {
      // Allow this many interactions to happen simultaneously
      maxInteractions: Infinity,
      withinInteractionLimit: withinInteractionLimit,
      cursorElement: null
    };
  }

  function prepareOnDown(_ref, scope) {
    var interaction = _ref.interaction,
        pointer = _ref.pointer,
        event = _ref.event,
        eventTarget = _ref.eventTarget;

    if (interaction.interacting()) {
      return;
    }

    var actionInfo = getActionInfo(interaction, pointer, event, eventTarget, scope);
    prepare(interaction, actionInfo, scope);
  }

  function prepareOnMove(_ref2, scope) {
    var interaction = _ref2.interaction,
        pointer = _ref2.pointer,
        event = _ref2.event,
        eventTarget = _ref2.eventTarget;

    if (interaction.pointerType !== 'mouse' || interaction.pointerIsDown || interaction.interacting()) {
      return;
    }

    var actionInfo = getActionInfo(interaction, pointer, event, eventTarget, scope);
    prepare(interaction, actionInfo, scope);
  }

  function startOnMove(arg, scope) {
    var interaction = arg.interaction;

    if (!interaction.pointerIsDown || interaction.interacting() || !interaction.pointerWasMoved || !interaction.prepared.name) {
      return;
    }

    scope.fire('autoStart:before-start', arg);
    var interactable = interaction.interactable;
    var actionName = interaction.prepared.name;

    if (actionName && interactable) {
      // check manualStart and interaction limit
      if (interactable.options[actionName].manualStart || !withinInteractionLimit(interactable, interaction.element, interaction.prepared, scope)) {
        interaction.stop();
      } else {
        interaction.start(interaction.prepared, interactable, interaction.element);
        setInteractionCursor(interaction, scope);
      }
    }
  }

  function clearCursorOnStop(_ref3, scope) {
    var interaction = _ref3.interaction;
    var interactable = interaction.interactable;

    if (interactable && interactable.options.styleCursor) {
      setCursor(interaction.element, '', scope);
    }
  } // Check if the current interactable supports the action.
  // If so, return the validated action. Otherwise, return null


  function validateAction(action, interactable, element, eventTarget, scope) {
    if (interactable.testIgnoreAllow(interactable.options[action.name], element, eventTarget) && interactable.options[action.name].enabled && withinInteractionLimit(interactable, element, action, scope)) {
      return action;
    }

    return null;
  }

  function validateMatches(interaction, pointer, event, matches, matchElements, eventTarget, scope) {
    for (var i = 0, len = matches.length; i < len; i++) {
      var match = matches[i];
      var matchElement = matchElements[i];
      var matchAction = match.getAction(pointer, event, interaction, matchElement);

      if (!matchAction) {
        continue;
      }

      var action = validateAction(matchAction, match, matchElement, eventTarget, scope);

      if (action) {
        return {
          action: action,
          interactable: match,
          element: matchElement
        };
      }
    }

    return {
      action: null,
      interactable: null,
      element: null
    };
  }

  function getActionInfo(interaction, pointer, event, eventTarget, scope) {
    var matches = [];
    var matchElements = [];
    var element = eventTarget;

    function pushMatches(interactable) {
      matches.push(interactable);
      matchElements.push(element);
    }

    while (_$is_76["default"].element(element)) {
      matches = [];
      matchElements = [];
      scope.interactables.forEachMatch(element, pushMatches);
      var actionInfo = validateMatches(interaction, pointer, event, matches, matchElements, eventTarget, scope);

      if (actionInfo.action && !actionInfo.interactable.options[actionInfo.action.name].manualStart) {
        return actionInfo;
      }

      element = _$domUtils_71.parentNode(element);
    }

    return {
      action: null,
      interactable: null,
      element: null
    };
  }

  function prepare(interaction, _ref4, scope) {
    var action = _ref4.action,
        interactable = _ref4.interactable,
        element = _ref4.element;
    action = action || {
      name: null
    };
    interaction.interactable = interactable;
    interaction.element = element;
    (0, _$misc_78.copyAction)(interaction.prepared, action);
    interaction.rect = interactable && action.name ? interactable.getRect(element) : null;
    setInteractionCursor(interaction, scope);
    scope.fire('autoStart:prepared', {
      interaction: interaction
    });
  }

  function withinInteractionLimit(interactable, element, action, scope) {
    var options = interactable.options;
    var maxActions = options[action.name].max;
    var maxPerElement = options[action.name].maxPerElement;
    var autoStartMax = scope.autoStart.maxInteractions;
    var activeInteractions = 0;
    var interactableCount = 0;
    var elementCount = 0; // no actions if any of these values == 0

    if (!(maxActions && maxPerElement && autoStartMax)) {
      return false;
    }

    for (var _i = 0; _i < scope.interactions.list.length; _i++) {
      var _ref5;

      _ref5 = scope.interactions.list[_i];
      var interaction = _ref5;
      var otherAction = interaction.prepared.name;

      if (!interaction.interacting()) {
        continue;
      }

      activeInteractions++;

      if (activeInteractions >= autoStartMax) {
        return false;
      }

      if (interaction.interactable !== interactable) {
        continue;
      }

      interactableCount += otherAction === action.name ? 1 : 0;

      if (interactableCount >= maxActions) {
        return false;
      }

      if (interaction.element === element) {
        elementCount++;

        if (otherAction === action.name && elementCount >= maxPerElement) {
          return false;
        }
      }
    }

    return autoStartMax > 0;
  }

  function maxInteractions(newValue, scope) {
    if (_$is_76["default"].number(newValue)) {
      scope.autoStart.maxInteractions = newValue;
      return this;
    }

    return scope.autoStart.maxInteractions;
  }

  function setCursor(element, cursor, scope) {
    var prevCursorElement = scope.autoStart.cursorElement;

    if (prevCursorElement && prevCursorElement !== element) {
      prevCursorElement.style.cursor = '';
    }

    element.ownerDocument.documentElement.style.cursor = cursor;
    element.style.cursor = cursor;
    scope.autoStart.cursorElement = cursor ? element : null;
  }

  function setInteractionCursor(interaction, scope) {
    var interactable = interaction.interactable,
        element = interaction.element,
        prepared = interaction.prepared;

    if (!(interaction.pointerType === 'mouse' && interactable && interactable.options.styleCursor)) {
      // clear previous target element cursor
      if (scope.autoStart.cursorElement) {
        setCursor(scope.autoStart.cursorElement, '', scope);
      }

      return;
    }

    var cursor = '';

    if (prepared.name) {
      var cursorChecker = interactable.options[prepared.name].cursorChecker;

      if (_$is_76["default"].func(cursorChecker)) {
        cursor = cursorChecker(prepared, interactable, element, interaction._interacting);
      } else {
        cursor = scope.actions.map[prepared.name].getCursor(prepared);
      }
    }

    setCursor(interaction.element, cursor || '', scope);
  }

  var autoStart = {
    id: 'auto-start/base',
    before: ['actions'],
    install: __install_10,
    listeners: {
      'interactions:down': prepareOnDown,
      'interactions:move': function interactionsMove(arg, scope) {
        prepareOnMove(arg, scope);
        startOnMove(arg, scope);
      },
      'interactions:stop': clearCursorOnStop
    },
    maxInteractions: maxInteractions,
    withinInteractionLimit: withinInteractionLimit,
    validateAction: validateAction
  };
  var ___default_10 = autoStart;
  _$base_10["default"] = ___default_10;
  var _$dragAxis_11 = {};
  "use strict";

  Object.defineProperty(_$dragAxis_11, "__esModule", {
    value: true
  });
  _$dragAxis_11["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$base_10 = require("./base.js"); */

  ;

  function beforeStart(_ref, scope) {
    var interaction = _ref.interaction,
        eventTarget = _ref.eventTarget,
        dx = _ref.dx,
        dy = _ref.dy;

    if (interaction.prepared.name !== 'drag') {
      return;
    } // check if a drag is in the correct axis


    var absX = Math.abs(dx);
    var absY = Math.abs(dy);
    var targetOptions = interaction.interactable.options.drag;
    var startAxis = targetOptions.startAxis;
    var currentAxis = absX > absY ? 'x' : absX < absY ? 'y' : 'xy';
    interaction.prepared.axis = targetOptions.lockAxis === 'start' ? currentAxis[0] // always lock to one axis even if currentAxis === 'xy'
    : targetOptions.lockAxis; // if the movement isn't in the startAxis of the interactable

    if (currentAxis !== 'xy' && startAxis !== 'xy' && startAxis !== currentAxis) {
      // cancel the prepared action
      interaction.prepared.name = null; // then try to get a drag from another ineractable

      var element = eventTarget;

      var getDraggable = function getDraggable(interactable) {
        if (interactable === interaction.interactable) {
          return;
        }

        var options = interaction.interactable.options.drag;

        if (!options.manualStart && interactable.testIgnoreAllow(options, element, eventTarget)) {
          var action = interactable.getAction(interaction.downPointer, interaction.downEvent, interaction, element);

          if (action && action.name === 'drag' && checkStartAxis(currentAxis, interactable) && _$base_10["default"].validateAction(action, interactable, element, eventTarget, scope)) {
            return interactable;
          }
        }
      }; // check all interactables


      while (_$is_76["default"].element(element)) {
        var interactable = scope.interactables.forEachMatch(element, getDraggable);

        if (interactable) {
          interaction.prepared.name = 'drag';
          interaction.interactable = interactable;
          interaction.element = element;
          break;
        }

        element = (0, _$domUtils_71.parentNode)(element);
      }
    }
  }

  function checkStartAxis(startAxis, interactable) {
    if (!interactable) {
      return false;
    }

    var thisAxis = interactable.options.drag.startAxis;
    return startAxis === 'xy' || thisAxis === 'xy' || thisAxis === startAxis;
  }

  var ___default_11 = {
    id: 'auto-start/dragAxis',
    listeners: {
      'autoStart:before-start': beforeStart
    }
  };
  _$dragAxis_11["default"] = ___default_11;
  var _$hold_12 = {};
  "use strict";

  Object.defineProperty(_$hold_12, "__esModule", {
    value: true
  });
  _$hold_12["default"] = void 0;
  /* removed: var _$base_10 = require("./base.js"); */

  ;

  function __install_12(scope) {
    var defaults = scope.defaults;
    scope.usePlugin(_$base_10["default"]);
    defaults.perAction.hold = 0;
    defaults.perAction.delay = 0;
  }

  function getHoldDuration(interaction) {
    var actionName = interaction.prepared && interaction.prepared.name;

    if (!actionName) {
      return null;
    }

    var options = interaction.interactable.options;
    return options[actionName].hold || options[actionName].delay;
  }

  var ___default_12 = {
    id: 'auto-start/hold',
    install: __install_12,
    listeners: {
      'interactions:new': function interactionsNew(_ref) {
        var interaction = _ref.interaction;
        interaction.autoStartHoldTimer = null;
      },
      'autoStart:prepared': function autoStartPrepared(_ref2) {
        var interaction = _ref2.interaction;
        var hold = getHoldDuration(interaction);

        if (hold > 0) {
          interaction.autoStartHoldTimer = setTimeout(function () {
            interaction.start(interaction.prepared, interaction.interactable, interaction.element);
          }, hold);
        }
      },
      'interactions:move': function interactionsMove(_ref3) {
        var interaction = _ref3.interaction,
            duplicate = _ref3.duplicate;

        if (interaction.pointerWasMoved && !duplicate) {
          clearTimeout(interaction.autoStartHoldTimer);
        }
      },
      // prevent regular down->move autoStart
      'autoStart:before-start': function autoStartBeforeStart(_ref4) {
        var interaction = _ref4.interaction;
        var hold = getHoldDuration(interaction);

        if (hold > 0) {
          interaction.prepared.name = null;
        }
      }
    },
    getHoldDuration: getHoldDuration
  };
  _$hold_12["default"] = ___default_12;
  var _$plugin_13 = {};
  "use strict";

  Object.defineProperty(_$plugin_13, "__esModule", {
    value: true
  });
  _$plugin_13["default"] = void 0;
  /* removed: var _$base_10 = require("./base.js"); */

  ;
  /* removed: var _$dragAxis_11 = require("./dragAxis.js"); */

  ;
  /* removed: var _$hold_12 = require("./hold.js"); */

  ;
  var ___default_13 = {
    id: 'auto-start',
    install: function install(scope) {
      scope.usePlugin(_$base_10["default"]);
      scope.usePlugin(_$hold_12["default"]);
      scope.usePlugin(_$dragAxis_11["default"]);
    }
  };
  _$plugin_13["default"] = ___default_13;
  var _$plugin_14 = {};
  "use strict";

  Object.defineProperty(_$plugin_14, "__esModule", {
    value: true
  });
  _$plugin_14["default"] = void 0;
  var ___default_14 = {};
  _$plugin_14["default"] = ___default_14;
  var _$interactablePreventDefault_25 = {};
  "use strict";

  Object.defineProperty(_$interactablePreventDefault_25, "__esModule", {
    value: true
  });
  _$interactablePreventDefault_25.install = __install_25;
  _$interactablePreventDefault_25["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$window_84 = require("../utils/window.js"); */

  ;

  function preventDefault(newValue) {
    if (/^(always|never|auto)$/.test(newValue)) {
      this.options.preventDefault = newValue;
      return this;
    }

    if (_$is_76["default"].bool(newValue)) {
      this.options.preventDefault = newValue ? 'always' : 'never';
      return this;
    }

    return this.options.preventDefault;
  }

  function checkAndPreventDefault(interactable, scope, event) {
    var setting = interactable.options.preventDefault;

    if (setting === 'never') {
      return;
    }

    if (setting === 'always') {
      event.preventDefault();
      return;
    } // setting === 'auto'
    // if the browser supports passive event listeners and isn't running on iOS,
    // don't preventDefault of touch{start,move} events. CSS touch-action and
    // user-select should be used instead of calling event.preventDefault().


    if (scope.events.supportsPassive && /^touch(start|move)$/.test(event.type)) {
      var doc = (0, _$window_84.getWindow)(event.target).document;
      var docOptions = scope.getDocOptions(doc);

      if (!(docOptions && docOptions.events) || docOptions.events.passive !== false) {
        return;
      }
    } // don't preventDefault of pointerdown events


    if (/^(mouse|pointer|touch)*(down|start)/i.test(event.type)) {
      return;
    } // don't preventDefault on editable elements


    if (_$is_76["default"].element(event.target) && (0, _$domUtils_71.matchesSelector)(event.target, 'input,select,textarea,[contenteditable=true],[contenteditable=true] *')) {
      return;
    }

    event.preventDefault();
  }

  function onInteractionEvent(_ref) {
    var interaction = _ref.interaction,
        event = _ref.event;

    if (interaction.interactable) {
      interaction.interactable.checkAndPreventDefault(event);
    }
  }

  function __install_25(scope) {
    /** @lends Interactable */
    var Interactable = scope.Interactable;
    /**
     * Returns or sets whether to prevent the browser's default behaviour in
     * response to pointer events. Can be set to:
     *  - `'always'` to always prevent
     *  - `'never'` to never prevent
     *  - `'auto'` to let interact.js try to determine what would be best
     *
     * @param {string} [newValue] `'always'`, `'never'` or `'auto'`
     * @return {string | Interactable} The current setting or this Interactable
     */

    Interactable.prototype.preventDefault = preventDefault;

    Interactable.prototype.checkAndPreventDefault = function (event) {
      return checkAndPreventDefault(this, scope, event);
    }; // prevent native HTML5 drag on interact.js target elements


    scope.interactions.docEvents.push({
      type: 'dragstart',
      listener: function listener(event) {
        for (var _i = 0; _i < scope.interactions.list.length; _i++) {
          var _ref2;

          _ref2 = scope.interactions.list[_i];
          var interaction = _ref2;

          if (interaction.element && (interaction.element === event.target || (0, _$domUtils_71.nodeContains)(interaction.element, event.target))) {
            interaction.interactable.checkAndPreventDefault(event);
            return;
          }
        }
      }
    });
  }

  var ___default_25 = {
    id: 'core/interactablePreventDefault',
    install: __install_25,
    listeners: ['down', 'move', 'up', 'cancel'].reduce(function (acc, eventType) {
      acc["interactions:".concat(eventType)] = onInteractionEvent;
      return acc;
    }, {})
  };
  _$interactablePreventDefault_25["default"] = ___default_25;
  var _$plugin_30 = {};
  "use strict";

  Object.defineProperty(_$plugin_30, "__esModule", {
    value: true
  });
  _$plugin_30["default"] = void 0;
  /* removed: var _$domObjects_70 = require("../utils/domObjects.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$window_84 = require("../utils/window.js"); */

  ;

  function ___toConsumableArray_30(arr) {
    return ___arrayWithoutHoles_30(arr) || ___iterableToArray_30(arr) || ___unsupportedIterableToArray_30(arr) || ___nonIterableSpread_30();
  }

  function ___nonIterableSpread_30() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function ___unsupportedIterableToArray_30(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return ___arrayLikeToArray_30(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return ___arrayLikeToArray_30(o, minLen);
  }

  function ___iterableToArray_30(iter) {
    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
  }

  function ___arrayWithoutHoles_30(arr) {
    if (Array.isArray(arr)) return ___arrayLikeToArray_30(arr);
  }

  function ___arrayLikeToArray_30(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  var CheckName;

  (function (CheckName) {
    CheckName["touchAction"] = "touchAction";
    CheckName["boxSizing"] = "boxSizing";
    CheckName["noListeners"] = "noListeners";
  })(CheckName || (CheckName = {}));

  var prefix = '[interact.js] ';
  var links = {
    touchAction: 'https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action',
    boxSizing: 'https://developer.mozilla.org/en-US/docs/Web/CSS/box-sizing'
  }; // eslint-disable-next-line no-undef

  var isProduction = "development" === 'production'; // eslint-disable-next-line no-restricted-syntax

  function __install_30(scope) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        logger = _ref.logger;

    var Interactable = scope.Interactable,
        defaults = scope.defaults;
    scope.logger = logger || console;
    defaults.base.devTools = {
      ignore: {}
    };

    Interactable.prototype.devTools = function (options) {
      if (options) {
        (0, _$extend_73["default"])(this.options.devTools, options);
        return this;
      }

      return this.options.devTools;
    };
  }

  var checks = [{
    name: CheckName.touchAction,
    perform: function perform(_ref2) {
      var element = _ref2.element;
      return !parentHasStyle(element, 'touchAction', /pan-|pinch|none/);
    },
    getInfo: function getInfo(_ref3) {
      var element = _ref3.element;
      return [element, links.touchAction];
    },
    text: 'Consider adding CSS "touch-action: none" to this element\n'
  }, {
    name: CheckName.boxSizing,
    perform: function perform(interaction) {
      var element = interaction.element;
      return interaction.prepared.name === 'resize' && element instanceof _$domObjects_70["default"].HTMLElement && !hasStyle(element, 'boxSizing', /border-box/);
    },
    text: 'Consider adding CSS "box-sizing: border-box" to this resizable element',
    getInfo: function getInfo(_ref4) {
      var element = _ref4.element;
      return [element, links.boxSizing];
    }
  }, {
    name: CheckName.noListeners,
    perform: function perform(interaction) {
      var actionName = interaction.prepared.name;
      var moveListeners = interaction.interactable.events.types["".concat(actionName, "move")] || [];
      return !moveListeners.length;
    },
    getInfo: function getInfo(interaction) {
      return [interaction.prepared.name, interaction.interactable];
    },
    text: 'There are no listeners set for this action'
  }];

  function hasStyle(element, prop, styleRe) {
    var value = element.style[prop] || _$window_84["default"].window.getComputedStyle(element)[prop];

    return styleRe.test((value || '').toString());
  }

  function parentHasStyle(element, prop, styleRe) {
    var parent = element;

    while (_$is_76["default"].element(parent)) {
      if (hasStyle(parent, prop, styleRe)) {
        return true;
      }

      parent = (0, _$domUtils_71.parentNode)(parent);
    }

    return false;
  }

  var id = 'dev-tools';
  var defaultExport = isProduction ? {
    id: id,
    install: function install() {}
  } : {
    id: id,
    install: __install_30,
    listeners: {
      'interactions:action-start': function interactionsActionStart(_ref5, scope) {
        var interaction = _ref5.interaction;

        for (var _i = 0; _i < checks.length; _i++) {
          var _ref6;

          _ref6 = checks[_i];
          var check = _ref6;
          var options = interaction.interactable && interaction.interactable.options;

          if (!(options && options.devTools && options.devTools.ignore[check.name]) && check.perform(interaction)) {
            var _scope$logger;

            (_scope$logger = scope.logger).warn.apply(_scope$logger, [prefix + check.text].concat(___toConsumableArray_30(check.getInfo(interaction))));
          }
        }
      }
    },
    checks: checks,
    CheckName: CheckName,
    links: links,
    prefix: prefix
  };
  var ___default_30 = defaultExport;
  _$plugin_30["default"] = ___default_30;
  var _$plugin_31 = {};
  "use strict";

  Object.defineProperty(_$plugin_31, "__esModule", {
    value: true
  });
  _$plugin_31["default"] = void 0;
  var ___default_31 = {};
  _$plugin_31["default"] = ___default_31;
  var _$clone_68 = {};
  "use strict";

  Object.defineProperty(_$clone_68, "__esModule", {
    value: true
  });
  _$clone_68["default"] = clone;
  /* removed: var _$arr_66 = require("./arr.js"); */

  ;
  /* removed: var _$is_76 = require("./is.js"); */

  ; // tslint:disable-next-line ban-types

  function clone(source) {
    var dest = {};

    for (var prop in source) {
      var value = source[prop];

      if (_$is_76["default"].plainObject(value)) {
        dest[prop] = clone(value);
      } else if (_$is_76["default"].array(value)) {
        dest[prop] = _$arr_66.from(value);
      } else {
        dest[prop] = value;
      }
    }

    return dest;
  }

  var _$Modification_35 = {};
  "use strict";

  Object.defineProperty(_$Modification_35, "__esModule", {
    value: true
  });
  _$Modification_35.getRectOffset = getRectOffset;
  _$Modification_35["default"] = void 0;
  /* removed: var _$clone_68 = require("../utils/clone.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$rect_83 = require("../utils/rect.js"); */

  ;

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || ___unsupportedIterableToArray_35(arr, i) || _nonIterableRest();
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function ___unsupportedIterableToArray_35(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return ___arrayLikeToArray_35(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return ___arrayLikeToArray_35(o, minLen);
  }

  function ___arrayLikeToArray_35(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function _iterableToArrayLimit(arr, i) {
    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function ___classCallCheck_35(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_35(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_35(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_35(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_35(Constructor, staticProps);
    return Constructor;
  }

  var Modification = /*#__PURE__*/function () {
    function Modification(interaction) {
      ___classCallCheck_35(this, Modification);

      this.states = [];
      this.startOffset = {
        left: 0,
        right: 0,
        top: 0,
        bottom: 0
      };
      this.startDelta = null;
      this.result = null;
      this.endResult = null;
      this.edges = void 0;
      this.interaction = void 0;
      this.interaction = interaction;
      this.result = createResult();
    }

    ___createClass_35(Modification, [{
      key: "start",
      value: function start(_ref, pageCoords) {
        var phase = _ref.phase;
        var interaction = this.interaction;
        var modifierList = getModifierList(interaction);
        this.prepareStates(modifierList);
        this.edges = (0, _$extend_73["default"])({}, interaction.edges);
        this.startOffset = getRectOffset(interaction.rect, pageCoords);
        this.startDelta = {
          x: 0,
          y: 0
        };
        var arg = {
          phase: phase,
          pageCoords: pageCoords,
          preEnd: false
        };
        this.result = createResult();
        this.startAll(arg);
        var result = this.result = this.setAll(arg);
        return result;
      }
    }, {
      key: "fillArg",
      value: function fillArg(arg) {
        var interaction = this.interaction;
        arg.interaction = interaction;
        arg.interactable = interaction.interactable;
        arg.element = interaction.element;
        arg.rect = arg.rect || interaction.rect;
        arg.edges = this.edges;
        arg.startOffset = this.startOffset;
      }
    }, {
      key: "startAll",
      value: function startAll(arg) {
        this.fillArg(arg);

        for (var _i = 0; _i < this.states.length; _i++) {
          var _ref2;

          _ref2 = this.states[_i];
          var state = _ref2;

          if (state.methods.start) {
            arg.state = state;
            state.methods.start(arg);
          }
        }
      }
    }, {
      key: "setAll",
      value: function setAll(arg) {
        this.fillArg(arg);
        var phase = arg.phase,
            preEnd = arg.preEnd,
            skipModifiers = arg.skipModifiers,
            unmodifiedRect = arg.rect;
        arg.coords = (0, _$extend_73["default"])({}, arg.pageCoords);
        arg.rect = (0, _$extend_73["default"])({}, unmodifiedRect);
        var states = skipModifiers ? this.states.slice(skipModifiers) : this.states;
        var newResult = createResult(arg.coords, arg.rect);

        for (var _i2 = 0; _i2 < states.length; _i2++) {
          var _ref3;

          _ref3 = states[_i2];
          var state = _ref3;
          var options = state.options;
          var lastModifierCoords = (0, _$extend_73["default"])({}, arg.coords);
          var returnValue = null;

          if (state.methods.set && this.shouldDo(options, preEnd, phase)) {
            arg.state = state;
            returnValue = state.methods.set(arg);

            _$rect_83.addEdges(this.interaction.edges, arg.rect, {
              x: arg.coords.x - lastModifierCoords.x,
              y: arg.coords.y - lastModifierCoords.y
            });
          }

          newResult.eventProps.push(returnValue);
        }

        newResult.delta.x = arg.coords.x - arg.pageCoords.x;
        newResult.delta.y = arg.coords.y - arg.pageCoords.y;
        newResult.rectDelta.left = arg.rect.left - unmodifiedRect.left;
        newResult.rectDelta.right = arg.rect.right - unmodifiedRect.right;
        newResult.rectDelta.top = arg.rect.top - unmodifiedRect.top;
        newResult.rectDelta.bottom = arg.rect.bottom - unmodifiedRect.bottom;
        var prevCoords = this.result.coords;
        var prevRect = this.result.rect;

        if (prevCoords && prevRect) {
          var rectChanged = newResult.rect.left !== prevRect.left || newResult.rect.right !== prevRect.right || newResult.rect.top !== prevRect.top || newResult.rect.bottom !== prevRect.bottom;
          newResult.changed = rectChanged || prevCoords.x !== newResult.coords.x || prevCoords.y !== newResult.coords.y;
        }

        return newResult;
      }
    }, {
      key: "applyToInteraction",
      value: function applyToInteraction(arg) {
        var interaction = this.interaction;
        var phase = arg.phase;
        var curCoords = interaction.coords.cur;
        var startCoords = interaction.coords.start;
        var result = this.result,
            startDelta = this.startDelta;
        var curDelta = result.delta;

        if (phase === 'start') {
          (0, _$extend_73["default"])(this.startDelta, result.delta);
        }

        var _arr = [[startCoords, startDelta], [curCoords, curDelta]];

        for (var _i3 = 0; _i3 < _arr.length; _i3++) {
          var _arr$_i = _slicedToArray(_arr[_i3], 2),
              coordsSet = _arr$_i[0],
              delta = _arr$_i[1];

          coordsSet.page.x += delta.x;
          coordsSet.page.y += delta.y;
          coordsSet.client.x += delta.x;
          coordsSet.client.y += delta.y;
        }

        var rectDelta = this.result.rectDelta;
        var rect = arg.rect || interaction.rect;
        rect.left += rectDelta.left;
        rect.right += rectDelta.right;
        rect.top += rectDelta.top;
        rect.bottom += rectDelta.bottom;
        rect.width = rect.right - rect.left;
        rect.height = rect.bottom - rect.top;
      }
    }, {
      key: "setAndApply",
      value: function setAndApply(arg) {
        var interaction = this.interaction;
        var phase = arg.phase,
            preEnd = arg.preEnd,
            skipModifiers = arg.skipModifiers;
        var result = this.setAll({
          preEnd: preEnd,
          phase: phase,
          pageCoords: arg.modifiedCoords || interaction.coords.cur.page
        });
        this.result = result; // don't fire an action move if a modifier would keep the event in the same
        // cordinates as before

        if (!result.changed && (!skipModifiers || skipModifiers < this.states.length) && interaction.interacting()) {
          return false;
        }

        if (arg.modifiedCoords) {
          var page = interaction.coords.cur.page;
          var adjustment = {
            x: arg.modifiedCoords.x - page.x,
            y: arg.modifiedCoords.y - page.y
          };
          result.coords.x += adjustment.x;
          result.coords.y += adjustment.y;
          result.delta.x += adjustment.x;
          result.delta.y += adjustment.y;
        }

        this.applyToInteraction(arg);
      }
    }, {
      key: "beforeEnd",
      value: function beforeEnd(arg) {
        var interaction = arg.interaction,
            event = arg.event;
        var states = this.states;

        if (!states || !states.length) {
          return;
        }

        var doPreend = false;

        for (var _i4 = 0; _i4 < states.length; _i4++) {
          var _ref4;

          _ref4 = states[_i4];
          var state = _ref4;
          arg.state = state;
          var options = state.options,
              methods = state.methods;
          var endPosition = methods.beforeEnd && methods.beforeEnd(arg);

          if (endPosition) {
            this.endResult = endPosition;
            return false;
          }

          doPreend = doPreend || !doPreend && this.shouldDo(options, true, arg.phase, true);
        }

        if (doPreend) {
          // trigger a final modified move before ending
          interaction.move({
            event: event,
            preEnd: true
          });
        }
      }
    }, {
      key: "stop",
      value: function stop(arg) {
        var interaction = arg.interaction;

        if (!this.states || !this.states.length) {
          return;
        }

        var modifierArg = (0, _$extend_73["default"])({
          states: this.states,
          interactable: interaction.interactable,
          element: interaction.element,
          rect: null
        }, arg);
        this.fillArg(modifierArg);

        for (var _i5 = 0; _i5 < this.states.length; _i5++) {
          var _ref5;

          _ref5 = this.states[_i5];
          var state = _ref5;
          modifierArg.state = state;

          if (state.methods.stop) {
            state.methods.stop(modifierArg);
          }
        }

        this.states = null;
        this.endResult = null;
      }
    }, {
      key: "prepareStates",
      value: function prepareStates(modifierList) {
        this.states = [];

        for (var index = 0; index < modifierList.length; index++) {
          var _modifierList$index = modifierList[index],
              options = _modifierList$index.options,
              methods = _modifierList$index.methods,
              name = _modifierList$index.name;
          this.states.push({
            options: options,
            methods: methods,
            index: index,
            name: name
          });
        }

        return this.states;
      }
    }, {
      key: "restoreInteractionCoords",
      value: function restoreInteractionCoords(_ref6) {
        var _ref6$interaction = _ref6.interaction,
            coords = _ref6$interaction.coords,
            rect = _ref6$interaction.rect,
            modification = _ref6$interaction.modification;

        if (!modification.result) {
          return;
        }

        var startDelta = modification.startDelta;
        var _modification$result = modification.result,
            curDelta = _modification$result.delta,
            rectDelta = _modification$result.rectDelta;
        var coordsAndDeltas = [[coords.start, startDelta], [coords.cur, curDelta]];

        for (var _i6 = 0; _i6 < coordsAndDeltas.length; _i6++) {
          var _coordsAndDeltas$_i = _slicedToArray(coordsAndDeltas[_i6], 2),
              coordsSet = _coordsAndDeltas$_i[0],
              delta = _coordsAndDeltas$_i[1];

          coordsSet.page.x -= delta.x;
          coordsSet.page.y -= delta.y;
          coordsSet.client.x -= delta.x;
          coordsSet.client.y -= delta.y;
        }

        rect.left -= rectDelta.left;
        rect.right -= rectDelta.right;
        rect.top -= rectDelta.top;
        rect.bottom -= rectDelta.bottom;
      }
    }, {
      key: "shouldDo",
      value: function shouldDo(options, preEnd, phase, requireEndOnly) {
        if ( // ignore disabled modifiers
        !options || options.enabled === false || // check if we require endOnly option to fire move before end
        requireEndOnly && !options.endOnly || // don't apply endOnly modifiers when not ending
        options.endOnly && !preEnd || // check if modifier should run be applied on start
        phase === 'start' && !options.setStart) {
          return false;
        }

        return true;
      }
    }, {
      key: "copyFrom",
      value: function copyFrom(other) {
        this.startOffset = other.startOffset;
        this.startDelta = other.startDelta;
        this.edges = other.edges;
        this.states = other.states.map(function (s) {
          return (0, _$clone_68["default"])(s);
        });
        this.result = createResult((0, _$extend_73["default"])({}, other.result.coords), (0, _$extend_73["default"])({}, other.result.rect));
      }
    }, {
      key: "destroy",
      value: function destroy() {
        for (var prop in this) {
          this[prop] = null;
        }
      }
    }]);

    return Modification;
  }();

  _$Modification_35["default"] = Modification;

  function createResult(coords, rect) {
    return {
      rect: rect,
      coords: coords,
      delta: {
        x: 0,
        y: 0
      },
      rectDelta: {
        left: 0,
        right: 0,
        top: 0,
        bottom: 0
      },
      eventProps: [],
      changed: true
    };
  }

  function getModifierList(interaction) {
    var actionOptions = interaction.interactable.options[interaction.prepared.name];
    var actionModifiers = actionOptions.modifiers;

    if (actionModifiers && actionModifiers.length) {
      return actionModifiers;
    }

    return ['snap', 'snapSize', 'snapEdges', 'restrict', 'restrictEdges', 'restrictSize'].map(function (type) {
      var options = actionOptions[type];
      return options && options.enabled && {
        options: options,
        methods: options._methods
      };
    }).filter(function (m) {
      return !!m;
    });
  }

  function getRectOffset(rect, coords) {
    return rect ? {
      left: coords.x - rect.left,
      top: coords.y - rect.top,
      right: rect.right - coords.x,
      bottom: rect.bottom - coords.y
    } : {
      left: 0,
      top: 0,
      right: 0,
      bottom: 0
    };
  }

  var _$base_39 = {};
  "use strict";

  Object.defineProperty(_$base_39, "__esModule", {
    value: true
  });
  _$base_39.makeModifier = makeModifier;
  _$base_39.addEventModifiers = addEventModifiers;
  _$base_39["default"] = void 0;
  /* removed: var _$Modification_35 = require("./Modification.js"); */

  ;

  function makeModifier(module, name) {
    var defaults = module.defaults;
    var methods = {
      start: module.start,
      set: module.set,
      beforeEnd: module.beforeEnd,
      stop: module.stop
    };

    var modifier = function modifier(_options) {
      var options = _options || {};
      options.enabled = options.enabled !== false; // add missing defaults to options

      for (var prop in defaults) {
        if (!(prop in options)) {
          options[prop] = defaults[prop];
        }
      }

      var m = {
        options: options,
        methods: methods,
        name: name,
        enable: function enable() {
          options.enabled = true;
          return m;
        },
        disable: function disable() {
          options.enabled = false;
          return m;
        }
      };
      return m;
    };

    if (name && typeof name === 'string') {
      // for backwrads compatibility
      modifier._defaults = defaults;
      modifier._methods = methods;
    }

    return modifier;
  }

  function addEventModifiers(_ref) {
    var iEvent = _ref.iEvent,
        result = _ref.interaction.modification.result;

    if (result) {
      iEvent.modifiers = result.eventProps;
    }
  }

  var modifiersBase = {
    id: 'modifiers/base',
    install: function install(scope) {
      scope.defaults.perAction.modifiers = [];
    },
    listeners: {
      'interactions:new': function interactionsNew(_ref2) {
        var interaction = _ref2.interaction;
        interaction.modification = new _$Modification_35["default"](interaction);
      },
      'interactions:before-action-start': function interactionsBeforeActionStart(arg) {
        var modification = arg.interaction.modification;
        modification.start(arg, arg.interaction.coords.start.page);
        arg.interaction.edges = modification.edges;
        modification.applyToInteraction(arg);
      },
      'interactions:before-action-move': function interactionsBeforeActionMove(arg) {
        return arg.interaction.modification.setAndApply(arg);
      },
      'interactions:before-action-end': function interactionsBeforeActionEnd(arg) {
        return arg.interaction.modification.beforeEnd(arg);
      },
      'interactions:action-start': addEventModifiers,
      'interactions:action-move': addEventModifiers,
      'interactions:action-end': addEventModifiers,
      'interactions:after-action-start': function interactionsAfterActionStart(arg) {
        return arg.interaction.modification.restoreInteractionCoords(arg);
      },
      'interactions:after-action-move': function interactionsAfterActionMove(arg) {
        return arg.interaction.modification.restoreInteractionCoords(arg);
      },
      'interactions:stop': function interactionsStop(arg) {
        return arg.interaction.modification.stop(arg);
      }
    },
    before: ['actions']
  };
  var ___default_39 = modifiersBase;
  _$base_39["default"] = ___default_39;
  var _$defaultOptions_22 = {};
  "use strict";

  Object.defineProperty(_$defaultOptions_22, "__esModule", {
    value: true
  });
  _$defaultOptions_22.defaults = void 0; // eslint-disable-next-line @typescript-eslint/no-empty-interface
  // export interface Options extends BaseDefaults, PerActionDefaults {}

  var defaults = {
    base: {
      preventDefault: 'auto',
      deltaSource: 'page'
    },
    perAction: {
      enabled: false,
      origin: {
        x: 0,
        y: 0
      }
    },
    actions: {}
  };
  _$defaultOptions_22.defaults = defaults;
  var _$InteractEvent_17 = {};
  "use strict";

  Object.defineProperty(_$InteractEvent_17, "__esModule", {
    value: true
  });
  _$InteractEvent_17.InteractEvent = void 0;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$getOriginXY_74 = require("../utils/getOriginXY.js"); */

  ;
  /* removed: var _$hypot_75 = require("../utils/hypot.js"); */

  ;
  /* removed: var _$BaseEvent_15 = require("./BaseEvent.js"); */

  ;
  /* removed: var _$defaultOptions_22 = require("./defaultOptions.js"); */

  ;

  function ___typeof_17(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_17 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_17 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_17(obj);
  }

  function ___classCallCheck_17(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_17(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_17(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_17(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_17(Constructor, staticProps);
    return Constructor;
  }

  function ___inherits_17(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) ___setPrototypeOf_17(subClass, superClass);
  }

  function ___setPrototypeOf_17(o, p) {
    ___setPrototypeOf_17 = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return ___setPrototypeOf_17(o, p);
  }

  function ___createSuper_17(Derived) {
    var hasNativeReflectConstruct = ___isNativeReflectConstruct_17();

    return function () {
      var Super = ___getPrototypeOf_17(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = ___getPrototypeOf_17(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return ___possibleConstructorReturn_17(this, result);
    };
  }

  function ___possibleConstructorReturn_17(self, call) {
    if (call && (___typeof_17(call) === "object" || typeof call === "function")) {
      return call;
    }

    return ___assertThisInitialized_17(self);
  }

  function ___assertThisInitialized_17(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function ___isNativeReflectConstruct_17() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function ___getPrototypeOf_17(o) {
    ___getPrototypeOf_17 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return ___getPrototypeOf_17(o);
  }

  var InteractEvent = /*#__PURE__*/function (_BaseEvent) {
    ___inherits_17(InteractEvent, _BaseEvent);

    var _super = ___createSuper_17(InteractEvent); // drag
    // resize

    /** */


    function InteractEvent(interaction, event, actionName, phase, element, preEnd, type) {
      var _this;

      ___classCallCheck_17(this, InteractEvent);

      _this = _super.call(this, interaction);
      _this.target = void 0;
      _this.currentTarget = void 0;
      _this.relatedTarget = null;
      _this.screenX = void 0;
      _this.screenY = void 0;
      _this.button = void 0;
      _this.buttons = void 0;
      _this.ctrlKey = void 0;
      _this.shiftKey = void 0;
      _this.altKey = void 0;
      _this.metaKey = void 0;
      _this.page = void 0;
      _this.client = void 0;
      _this.delta = void 0;
      _this.rect = void 0;
      _this.x0 = void 0;
      _this.y0 = void 0;
      _this.t0 = void 0;
      _this.dt = void 0;
      _this.duration = void 0;
      _this.clientX0 = void 0;
      _this.clientY0 = void 0;
      _this.velocity = void 0;
      _this.speed = void 0;
      _this.swipe = void 0;
      _this.timeStamp = void 0;
      _this.dragEnter = void 0;
      _this.dragLeave = void 0;
      _this.axes = void 0;
      _this.preEnd = void 0;
      element = element || interaction.element;
      var target = interaction.interactable;
      var deltaSource = (target && target.options || _$defaultOptions_22.defaults).deltaSource;
      var origin = (0, _$getOriginXY_74["default"])(target, element, actionName);
      var starting = phase === 'start';
      var ending = phase === 'end';
      var prevEvent = starting ? ___assertThisInitialized_17(_this) : interaction.prevEvent;
      var coords = starting ? interaction.coords.start : ending ? {
        page: prevEvent.page,
        client: prevEvent.client,
        timeStamp: interaction.coords.cur.timeStamp
      } : interaction.coords.cur;
      _this.page = (0, _$extend_73["default"])({}, coords.page);
      _this.client = (0, _$extend_73["default"])({}, coords.client);
      _this.rect = (0, _$extend_73["default"])({}, interaction.rect);
      _this.timeStamp = coords.timeStamp;

      if (!ending) {
        _this.page.x -= origin.x;
        _this.page.y -= origin.y;
        _this.client.x -= origin.x;
        _this.client.y -= origin.y;
      }

      _this.ctrlKey = event.ctrlKey;
      _this.altKey = event.altKey;
      _this.shiftKey = event.shiftKey;
      _this.metaKey = event.metaKey;
      _this.button = event.button;
      _this.buttons = event.buttons;
      _this.target = element;
      _this.currentTarget = element;
      _this.preEnd = preEnd;
      _this.type = type || actionName + (phase || '');
      _this.interactable = target;
      _this.t0 = starting ? interaction.pointers[interaction.pointers.length - 1].downTime : prevEvent.t0;
      _this.x0 = interaction.coords.start.page.x - origin.x;
      _this.y0 = interaction.coords.start.page.y - origin.y;
      _this.clientX0 = interaction.coords.start.client.x - origin.x;
      _this.clientY0 = interaction.coords.start.client.y - origin.y;

      if (starting || ending) {
        _this.delta = {
          x: 0,
          y: 0
        };
      } else {
        _this.delta = {
          x: _this[deltaSource].x - prevEvent[deltaSource].x,
          y: _this[deltaSource].y - prevEvent[deltaSource].y
        };
      }

      _this.dt = interaction.coords.delta.timeStamp;
      _this.duration = _this.timeStamp - _this.t0; // velocity and speed in pixels per second

      _this.velocity = (0, _$extend_73["default"])({}, interaction.coords.velocity[deltaSource]);
      _this.speed = (0, _$hypot_75["default"])(_this.velocity.x, _this.velocity.y);
      _this.swipe = ending || phase === 'inertiastart' ? _this.getSwipe() : null;
      return _this;
    }

    ___createClass_17(InteractEvent, [{
      key: "getSwipe",
      value: function getSwipe() {
        var interaction = this._interaction;

        if (interaction.prevEvent.speed < 600 || this.timeStamp - interaction.prevEvent.timeStamp > 150) {
          return null;
        }

        var angle = 180 * Math.atan2(interaction.prevEvent.velocityY, interaction.prevEvent.velocityX) / Math.PI;
        var overlap = 22.5;

        if (angle < 0) {
          angle += 360;
        }

        var left = 135 - overlap <= angle && angle < 225 + overlap;
        var up = 225 - overlap <= angle && angle < 315 + overlap;
        var right = !left && (315 - overlap <= angle || angle < 45 + overlap);
        var down = !up && 45 - overlap <= angle && angle < 135 + overlap;
        return {
          up: up,
          down: down,
          left: left,
          right: right,
          angle: angle,
          speed: interaction.prevEvent.speed,
          velocity: {
            x: interaction.prevEvent.velocityX,
            y: interaction.prevEvent.velocityY
          }
        };
      }
    }, {
      key: "preventDefault",
      value: function preventDefault() {}
      /**
       * Don't call listeners on the remaining targets
       */

    }, {
      key: "stopImmediatePropagation",
      value: function stopImmediatePropagation() {
        this.immediatePropagationStopped = this.propagationStopped = true;
      }
      /**
       * Don't call any other listeners (even on the current target)
       */

    }, {
      key: "stopPropagation",
      value: function stopPropagation() {
        this.propagationStopped = true;
      }
    }]);

    return InteractEvent;
  }(_$BaseEvent_15.BaseEvent); // getters and setters defined here to support typescript 3.6 and below which
  // don't support getter and setters in .d.ts files


  _$InteractEvent_17.InteractEvent = InteractEvent;
  Object.defineProperties(InteractEvent.prototype, {
    pageX: {
      get: function get() {
        return this.page.x;
      },
      set: function set(value) {
        this.page.x = value;
      }
    },
    pageY: {
      get: function get() {
        return this.page.y;
      },
      set: function set(value) {
        this.page.y = value;
      }
    },
    clientX: {
      get: function get() {
        return this.client.x;
      },
      set: function set(value) {
        this.client.x = value;
      }
    },
    clientY: {
      get: function get() {
        return this.client.y;
      },
      set: function set(value) {
        this.client.y = value;
      }
    },
    dx: {
      get: function get() {
        return this.delta.x;
      },
      set: function set(value) {
        this.delta.x = value;
      }
    },
    dy: {
      get: function get() {
        return this.delta.y;
      },
      set: function set(value) {
        this.delta.y = value;
      }
    },
    velocityX: {
      get: function get() {
        return this.velocity.x;
      },
      set: function set(value) {
        this.velocity.x = value;
      }
    },
    velocityY: {
      get: function get() {
        return this.velocity.y;
      },
      set: function set(value) {
        this.velocity.y = value;
      }
    }
  });
  var _$PointerInfo_21 = {};
  "use strict";

  Object.defineProperty(_$PointerInfo_21, "__esModule", {
    value: true
  });
  _$PointerInfo_21.PointerInfo = void 0;

  function ___classCallCheck_21(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  var PointerInfo = function PointerInfo(id, pointer, event, downTime, downTarget) {
    ___classCallCheck_21(this, PointerInfo);

    this.id = void 0;
    this.pointer = void 0;
    this.event = void 0;
    this.downTime = void 0;
    this.downTarget = void 0;
    this.id = id;
    this.pointer = pointer;
    this.event = event;
    this.downTime = downTime;
    this.downTarget = downTarget;
  };

  _$PointerInfo_21.PointerInfo = PointerInfo;
  var _$Interaction_20 = {};
  "use strict";

  Object.defineProperty(_$Interaction_20, "__esModule", {
    value: true
  });
  Object.defineProperty(_$Interaction_20, "PointerInfo", {
    enumerable: true,
    get: function get() {
      return _$PointerInfo_21.PointerInfo;
    }
  });
  _$Interaction_20["default"] = _$Interaction_20.Interaction = _$Interaction_20._ProxyMethods = _$Interaction_20._ProxyValues = void 0;
  /* removed: var _$arr_66 = require("../utils/arr.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$hypot_75 = require("../utils/hypot.js"); */

  ;
  /* removed: var _$misc_78 = require("../utils/misc.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$rect_83 = require("../utils/rect.js"); */

  ;
  /* removed: var _$InteractEvent_17 = require("./InteractEvent.js"); */

  ;
  /* removed: var _$PointerInfo_21 = require("./PointerInfo.js"); */

  ;

  function ___classCallCheck_20(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_20(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_20(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_20(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_20(Constructor, staticProps);
    return Constructor;
  }

  var _ProxyValues;

  _$Interaction_20._ProxyValues = _ProxyValues;

  (function (_ProxyValues) {
    _ProxyValues["interactable"] = "";
    _ProxyValues["element"] = "";
    _ProxyValues["prepared"] = "";
    _ProxyValues["pointerIsDown"] = "";
    _ProxyValues["pointerWasMoved"] = "";
    _ProxyValues["_proxy"] = "";
  })(_ProxyValues || (_$Interaction_20._ProxyValues = _ProxyValues = {}));

  var _ProxyMethods;

  _$Interaction_20._ProxyMethods = _ProxyMethods;

  (function (_ProxyMethods) {
    _ProxyMethods["start"] = "";
    _ProxyMethods["move"] = "";
    _ProxyMethods["end"] = "";
    _ProxyMethods["stop"] = "";
    _ProxyMethods["interacting"] = "";
  })(_ProxyMethods || (_$Interaction_20._ProxyMethods = _ProxyMethods = {}));

  var idCounter = 0;

  var Interaction = /*#__PURE__*/function () {
    ___createClass_20(Interaction, [{
      key: "pointerMoveTolerance",
      // current interactable being interacted with
      // the target element of the interactable
      // action that's ready to be fired on next move event
      // keep track of added pointers
      // pointerdown/mousedown/touchstart event
      // previous action event

      /** @internal */
      get: function get() {
        return 1;
      }
      /**
       * @alias Interaction.prototype.move
       */

      /** */

    }]);

    function Interaction(_ref) {
      var _this = this;

      var pointerType = _ref.pointerType,
          scopeFire = _ref.scopeFire;

      ___classCallCheck_20(this, Interaction);

      this.interactable = null;
      this.element = null;
      this.rect = void 0;
      this._rects = void 0;
      this.edges = void 0;
      this._scopeFire = void 0;
      this.prepared = {
        name: null,
        axis: null,
        edges: null
      };
      this.pointerType = void 0;
      this.pointers = [];
      this.downEvent = null;
      this.downPointer = {};
      this._latestPointer = {
        pointer: null,
        event: null,
        eventTarget: null
      };
      this.prevEvent = null;
      this.pointerIsDown = false;
      this.pointerWasMoved = false;
      this._interacting = false;
      this._ending = false;
      this._stopped = true;
      this._proxy = null;
      this.simulation = null;
      this.doMove = (0, _$misc_78.warnOnce)(function (signalArg) {
        this.move(signalArg);
      }, 'The interaction.doMove() method has been renamed to interaction.move()');
      this.coords = {
        // Starting InteractEvent pointer coordinates
        start: _$pointerUtils_81.newCoords(),
        // Previous native pointer move event coordinates
        prev: _$pointerUtils_81.newCoords(),
        // current native pointer move event coordinates
        cur: _$pointerUtils_81.newCoords(),
        // Change in coordinates and time of the pointer
        delta: _$pointerUtils_81.newCoords(),
        // pointer velocity
        velocity: _$pointerUtils_81.newCoords()
      };
      this._id = idCounter++;
      this._scopeFire = scopeFire;
      this.pointerType = pointerType;
      var that = this;
      this._proxy = {};

      var _loop = function _loop(key) {
        Object.defineProperty(_this._proxy, key, {
          get: function get() {
            return that[key];
          }
        });
      };

      for (var key in _ProxyValues) {
        _loop(key);
      }

      var _loop2 = function _loop2(_key) {
        Object.defineProperty(_this._proxy, _key, {
          value: function value() {
            return that[_key].apply(that, arguments);
          }
        });
      };

      for (var _key in _ProxyMethods) {
        _loop2(_key);
      }

      this._scopeFire('interactions:new', {
        interaction: this
      });
    }

    ___createClass_20(Interaction, [{
      key: "pointerDown",
      value: function pointerDown(pointer, event, eventTarget) {
        var pointerIndex = this.updatePointer(pointer, event, eventTarget, true);
        var pointerInfo = this.pointers[pointerIndex];

        this._scopeFire('interactions:down', {
          pointer: pointer,
          event: event,
          eventTarget: eventTarget,
          pointerIndex: pointerIndex,
          pointerInfo: pointerInfo,
          type: 'down',
          interaction: this
        });
      }
      /**
       * ```js
       * interact(target)
       *   .draggable({
       *     // disable the default drag start by down->move
       *     manualStart: true
       *   })
       *   // start dragging after the user holds the pointer down
       *   .on('hold', function (event) {
       *     var interaction = event.interaction
       *
       *     if (!interaction.interacting()) {
       *       interaction.start({ name: 'drag' },
       *                         event.interactable,
       *                         event.currentTarget)
       *     }
       * })
       * ```
       *
       * Start an action with the given Interactable and Element as tartgets. The
       * action must be enabled for the target Interactable and an appropriate
       * number of pointers must be held down - 1 for drag/resize, 2 for gesture.
       *
       * Use it with `interactable.<action>able({ manualStart: false })` to always
       * [start actions manually](https://github.com/taye/interact.js/issues/114)
       *
       * @param {object} action   The action to be performed - drag, resize, etc.
       * @param {Interactable} target  The Interactable to target
       * @param {Element} element The DOM Element to target
       * @return {object} interact
       */

    }, {
      key: "start",
      value: function start(action, interactable, element) {
        if (this.interacting() || !this.pointerIsDown || this.pointers.length < (action.name === 'gesture' ? 2 : 1) || !interactable.options[action.name].enabled) {
          return false;
        }

        (0, _$misc_78.copyAction)(this.prepared, action);
        this.interactable = interactable;
        this.element = element;
        this.rect = interactable.getRect(element);
        this.edges = this.prepared.edges ? (0, _$extend_73["default"])({}, this.prepared.edges) : {
          left: true,
          right: true,
          top: true,
          bottom: true
        };
        this._stopped = false;
        this._interacting = this._doPhase({
          interaction: this,
          event: this.downEvent,
          phase: 'start'
        }) && !this._stopped;
        return this._interacting;
      }
    }, {
      key: "pointerMove",
      value: function pointerMove(pointer, event, eventTarget) {
        if (!this.simulation && !(this.modification && this.modification.endResult)) {
          this.updatePointer(pointer, event, eventTarget, false);
        }

        var duplicateMove = this.coords.cur.page.x === this.coords.prev.page.x && this.coords.cur.page.y === this.coords.prev.page.y && this.coords.cur.client.x === this.coords.prev.client.x && this.coords.cur.client.y === this.coords.prev.client.y;
        var dx;
        var dy; // register movement greater than pointerMoveTolerance

        if (this.pointerIsDown && !this.pointerWasMoved) {
          dx = this.coords.cur.client.x - this.coords.start.client.x;
          dy = this.coords.cur.client.y - this.coords.start.client.y;
          this.pointerWasMoved = (0, _$hypot_75["default"])(dx, dy) > this.pointerMoveTolerance;
        }

        var pointerIndex = this.getPointerIndex(pointer);
        var signalArg = {
          pointer: pointer,
          pointerIndex: pointerIndex,
          pointerInfo: this.pointers[pointerIndex],
          event: event,
          type: 'move',
          eventTarget: eventTarget,
          dx: dx,
          dy: dy,
          duplicate: duplicateMove,
          interaction: this
        };

        if (!duplicateMove) {
          // set pointer coordinate, time changes and velocity
          _$pointerUtils_81.setCoordVelocity(this.coords.velocity, this.coords.delta);
        }

        this._scopeFire('interactions:move', signalArg);

        if (!duplicateMove && !this.simulation) {
          // if interacting, fire an 'action-move' signal etc
          if (this.interacting()) {
            signalArg.type = null;
            this.move(signalArg);
          }

          if (this.pointerWasMoved) {
            _$pointerUtils_81.copyCoords(this.coords.prev, this.coords.cur);
          }
        }
      }
      /**
       * ```js
       * interact(target)
       *   .draggable(true)
       *   .on('dragmove', function (event) {
       *     if (someCondition) {
       *       // change the snap settings
       *       event.interactable.draggable({ snap: { targets: [] }})
       *       // fire another move event with re-calculated snap
       *       event.interaction.move()
       *     }
       *   })
       * ```
       *
       * Force a move of the current action at the same coordinates. Useful if
       * snap/restrict has been changed and you want a movement with the new
       * settings.
       */

    }, {
      key: "move",
      value: function move(signalArg) {
        if (!signalArg || !signalArg.event) {
          _$pointerUtils_81.setZeroCoords(this.coords.delta);
        }

        signalArg = (0, _$extend_73["default"])({
          pointer: this._latestPointer.pointer,
          event: this._latestPointer.event,
          eventTarget: this._latestPointer.eventTarget,
          interaction: this
        }, signalArg || {});
        signalArg.phase = 'move';

        this._doPhase(signalArg);
      } // End interact move events and stop auto-scroll unless simulation is running

    }, {
      key: "pointerUp",
      value: function pointerUp(pointer, event, eventTarget, curEventTarget) {
        var pointerIndex = this.getPointerIndex(pointer);

        if (pointerIndex === -1) {
          pointerIndex = this.updatePointer(pointer, event, eventTarget, false);
        }

        var type = /cancel$/i.test(event.type) ? 'cancel' : 'up';

        this._scopeFire("interactions:".concat(type), {
          pointer: pointer,
          pointerIndex: pointerIndex,
          pointerInfo: this.pointers[pointerIndex],
          event: event,
          eventTarget: eventTarget,
          type: type,
          curEventTarget: curEventTarget,
          interaction: this
        });

        if (!this.simulation) {
          this.end(event);
        }

        this.pointerIsDown = false;
        this.removePointer(pointer, event);
      }
    }, {
      key: "documentBlur",
      value: function documentBlur(event) {
        this.end(event);

        this._scopeFire('interactions:blur', {
          event: event,
          type: 'blur',
          interaction: this
        });
      }
      /**
       * ```js
       * interact(target)
       *   .draggable(true)
       *   .on('move', function (event) {
       *     if (event.pageX > 1000) {
       *       // end the current action
       *       event.interaction.end()
       *       // stop all further listeners from being called
       *       event.stopImmediatePropagation()
       *     }
       *   })
       * ```
       *
       * @param {PointerEvent} [event]
       */

    }, {
      key: "end",
      value: function end(event) {
        this._ending = true;
        event = event || this._latestPointer.event;
        var endPhaseResult;

        if (this.interacting()) {
          endPhaseResult = this._doPhase({
            event: event,
            interaction: this,
            phase: 'end'
          });
        }

        this._ending = false;

        if (endPhaseResult === true) {
          this.stop();
        }
      }
    }, {
      key: "currentAction",
      value: function currentAction() {
        return this._interacting ? this.prepared.name : null;
      }
    }, {
      key: "interacting",
      value: function interacting() {
        return this._interacting;
      }
      /** */

    }, {
      key: "stop",
      value: function stop() {
        this._scopeFire('interactions:stop', {
          interaction: this
        });

        this.interactable = this.element = null;
        this._interacting = false;
        this._stopped = true;
        this.prepared.name = this.prevEvent = null;
      }
    }, {
      key: "getPointerIndex",
      value: function getPointerIndex(pointer) {
        var pointerId = _$pointerUtils_81.getPointerId(pointer); // mouse and pen interactions may have only one pointer


        return this.pointerType === 'mouse' || this.pointerType === 'pen' ? this.pointers.length - 1 : _$arr_66.findIndex(this.pointers, function (curPointer) {
          return curPointer.id === pointerId;
        });
      }
    }, {
      key: "getPointerInfo",
      value: function getPointerInfo(pointer) {
        return this.pointers[this.getPointerIndex(pointer)];
      }
    }, {
      key: "updatePointer",
      value: function updatePointer(pointer, event, eventTarget, down) {
        var id = _$pointerUtils_81.getPointerId(pointer);

        var pointerIndex = this.getPointerIndex(pointer);
        var pointerInfo = this.pointers[pointerIndex];
        down = down === false ? false : down || /(down|start)$/i.test(event.type);

        if (!pointerInfo) {
          pointerInfo = new _$PointerInfo_21.PointerInfo(id, pointer, event, null, null);
          pointerIndex = this.pointers.length;
          this.pointers.push(pointerInfo);
        } else {
          pointerInfo.pointer = pointer;
        }

        _$pointerUtils_81.setCoords(this.coords.cur, this.pointers.map(function (p) {
          return p.pointer;
        }), this._now());

        _$pointerUtils_81.setCoordDeltas(this.coords.delta, this.coords.prev, this.coords.cur);

        if (down) {
          this.pointerIsDown = true;
          pointerInfo.downTime = this.coords.cur.timeStamp;
          pointerInfo.downTarget = eventTarget;

          _$pointerUtils_81.pointerExtend(this.downPointer, pointer);

          if (!this.interacting()) {
            _$pointerUtils_81.copyCoords(this.coords.start, this.coords.cur);

            _$pointerUtils_81.copyCoords(this.coords.prev, this.coords.cur);

            this.downEvent = event;
            this.pointerWasMoved = false;
          }
        }

        this._updateLatestPointer(pointer, event, eventTarget);

        this._scopeFire('interactions:update-pointer', {
          pointer: pointer,
          event: event,
          eventTarget: eventTarget,
          down: down,
          pointerInfo: pointerInfo,
          pointerIndex: pointerIndex,
          interaction: this
        });

        return pointerIndex;
      }
    }, {
      key: "removePointer",
      value: function removePointer(pointer, event) {
        var pointerIndex = this.getPointerIndex(pointer);

        if (pointerIndex === -1) {
          return;
        }

        var pointerInfo = this.pointers[pointerIndex];

        this._scopeFire('interactions:remove-pointer', {
          pointer: pointer,
          event: event,
          eventTarget: null,
          pointerIndex: pointerIndex,
          pointerInfo: pointerInfo,
          interaction: this
        });

        this.pointers.splice(pointerIndex, 1);
      }
    }, {
      key: "_updateLatestPointer",
      value: function _updateLatestPointer(pointer, event, eventTarget) {
        this._latestPointer.pointer = pointer;
        this._latestPointer.event = event;
        this._latestPointer.eventTarget = eventTarget;
      }
    }, {
      key: "destroy",
      value: function destroy() {
        this._latestPointer.pointer = null;
        this._latestPointer.event = null;
        this._latestPointer.eventTarget = null;
      }
    }, {
      key: "_createPreparedEvent",
      value: function _createPreparedEvent(event, phase, preEnd, type) {
        return new _$InteractEvent_17.InteractEvent(this, event, this.prepared.name, phase, this.element, preEnd, type);
      }
    }, {
      key: "_fireEvent",
      value: function _fireEvent(iEvent) {
        this.interactable.fire(iEvent);

        if (!this.prevEvent || iEvent.timeStamp >= this.prevEvent.timeStamp) {
          this.prevEvent = iEvent;
        }
      }
    }, {
      key: "_doPhase",
      value: function _doPhase(signalArg) {
        var event = signalArg.event,
            phase = signalArg.phase,
            preEnd = signalArg.preEnd,
            type = signalArg.type;
        var rect = this.rect;

        if (rect && phase === 'move') {
          // update the rect changes due to pointer move
          _$rect_83.addEdges(this.edges, rect, this.coords.delta[this.interactable.options.deltaSource]);

          rect.width = rect.right - rect.left;
          rect.height = rect.bottom - rect.top;
        }

        var beforeResult = this._scopeFire("interactions:before-action-".concat(phase), signalArg);

        if (beforeResult === false) {
          return false;
        }

        var iEvent = signalArg.iEvent = this._createPreparedEvent(event, phase, preEnd, type);

        this._scopeFire("interactions:action-".concat(phase), signalArg);

        if (phase === 'start') {
          this.prevEvent = iEvent;
        }

        this._fireEvent(iEvent);

        this._scopeFire("interactions:after-action-".concat(phase), signalArg);

        return true;
      }
    }, {
      key: "_now",
      value: function _now() {
        return Date.now();
      }
    }]);

    return Interaction;
  }();

  _$Interaction_20.Interaction = Interaction;
  var ___default_20 = Interaction;
  _$Interaction_20["default"] = ___default_20;
  var _$plugin_53 = {};
  "use strict";

  Object.defineProperty(_$plugin_53, "__esModule", {
    value: true
  });
  _$plugin_53.addTotal = addTotal;
  _$plugin_53.applyPending = applyPending;
  _$plugin_53["default"] = void 0;
  /* removed: var _$Interaction_20 = require("../core/Interaction.js"); */

  ;
  /* removed: var _$rect_83 = require("../utils/rect.js"); */

  ;
  _$Interaction_20._ProxyMethods.offsetBy = '';

  function addTotal(interaction) {
    if (!interaction.pointerIsDown) {
      return;
    }

    addToCoords(interaction.coords.cur, interaction.offset.total);
    interaction.offset.pending.x = 0;
    interaction.offset.pending.y = 0;
  }

  function beforeAction(_ref) {
    var interaction = _ref.interaction;
    applyPending(interaction);
  }

  function beforeEnd(_ref2) {
    var interaction = _ref2.interaction;
    var hadPending = applyPending(interaction);

    if (!hadPending) {
      return;
    }

    interaction.move({
      offset: true
    });
    interaction.end();
    return false;
  }

  function __end_53(_ref3) {
    var interaction = _ref3.interaction;
    interaction.offset.total.x = 0;
    interaction.offset.total.y = 0;
    interaction.offset.pending.x = 0;
    interaction.offset.pending.y = 0;
  }

  function applyPending(interaction) {
    if (!hasPending(interaction)) {
      return false;
    }

    var pending = interaction.offset.pending;
    addToCoords(interaction.coords.cur, pending);
    addToCoords(interaction.coords.delta, pending);

    _$rect_83.addEdges(interaction.edges, interaction.rect, pending);

    pending.x = 0;
    pending.y = 0;
    return true;
  }

  function offsetBy(_ref4) {
    var x = _ref4.x,
        y = _ref4.y;
    this.offset.pending.x += x;
    this.offset.pending.y += y;
    this.offset.total.x += x;
    this.offset.total.y += y;
  }

  function addToCoords(_ref5, _ref6) {
    var page = _ref5.page,
        client = _ref5.client;
    var x = _ref6.x,
        y = _ref6.y;
    page.x += x;
    page.y += y;
    client.x += x;
    client.y += y;
  }

  function hasPending(interaction) {
    return !!(interaction.offset.pending.x || interaction.offset.pending.y);
  }

  var offset = {
    id: 'offset',
    before: ['modifiers'],
    install: function install(scope) {
      scope.Interaction.prototype.offsetBy = offsetBy;
    },
    listeners: {
      'interactions:new': function interactionsNew(_ref7) {
        var interaction = _ref7.interaction;
        interaction.offset = {
          total: {
            x: 0,
            y: 0
          },
          pending: {
            x: 0,
            y: 0
          }
        };
      },
      'interactions:update-pointer': function interactionsUpdatePointer(_ref8) {
        var interaction = _ref8.interaction;
        return addTotal(interaction);
      },
      'interactions:before-action-start': beforeAction,
      'interactions:before-action-move': beforeAction,
      'interactions:before-action-end': beforeEnd,
      'interactions:stop': __end_53
    }
  };
  var ___default_53 = offset;
  _$plugin_53["default"] = ___default_53;
  var _$plugin_32 = {};
  "use strict";

  Object.defineProperty(_$plugin_32, "__esModule", {
    value: true
  });
  _$plugin_32["default"] = _$plugin_32.InertiaState = void 0;
  /* removed: var _$Modification_35 = require("../modifiers/Modification.js"); */

  ;
  /* removed: var _$base_39 = require("../modifiers/base.js"); */

  ;
  /* removed: var _$plugin_53 = require("../offset/plugin.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$hypot_75 = require("../utils/hypot.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$raf_82 = require("../utils/raf.js"); */

  ;

  function ___classCallCheck_32(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_32(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_32(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_32(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_32(Constructor, staticProps);
    return Constructor;
  }

  function __install_32(scope) {
    var defaults = scope.defaults;
    scope.usePlugin(_$plugin_53["default"]);
    scope.usePlugin(_$base_39["default"]);
    scope.actions.phases.inertiastart = true;
    scope.actions.phases.resume = true;
    defaults.perAction.inertia = {
      enabled: false,
      resistance: 10,
      // the lambda in exponential decay
      minSpeed: 100,
      // target speed must be above this for inertia to start
      endSpeed: 10,
      // the speed at which inertia is slow enough to stop
      allowResume: true,
      // allow resuming an action in inertia phase
      smoothEndDuration: 300 // animate to snap/restrict endOnly if there's no inertia

    };
  }

  var InertiaState = /*#__PURE__*/function () {
    // eslint-disable-line camelcase
    // eslint-disable-line camelcase
    function InertiaState(interaction) {
      ___classCallCheck_32(this, InertiaState);

      this.active = false;
      this.isModified = false;
      this.smoothEnd = false;
      this.allowResume = false;
      this.modification = null;
      this.modifierCount = 0;
      this.modifierArg = null;
      this.startCoords = null;
      this.t0 = 0;
      this.v0 = 0;
      this.te = 0;
      this.targetOffset = null;
      this.modifiedOffset = null;
      this.currentOffset = null;
      this.lambda_v0 = 0;
      this.one_ve_v0 = 0;
      this.timeout = null;
      this.interaction = void 0;
      this.interaction = interaction;
    }

    ___createClass_32(InertiaState, [{
      key: "start",
      value: function start(event) {
        var interaction = this.interaction;
        var options = getOptions(interaction);

        if (!options || !options.enabled) {
          return false;
        }

        var velocityClient = interaction.coords.velocity.client;
        var pointerSpeed = (0, _$hypot_75["default"])(velocityClient.x, velocityClient.y);
        var modification = this.modification || (this.modification = new _$Modification_35["default"](interaction));
        modification.copyFrom(interaction.modification);
        this.t0 = interaction._now();
        this.allowResume = options.allowResume;
        this.v0 = pointerSpeed;
        this.currentOffset = {
          x: 0,
          y: 0
        };
        this.startCoords = interaction.coords.cur.page;
        this.modifierArg = {
          interaction: interaction,
          interactable: interaction.interactable,
          element: interaction.element,
          rect: interaction.rect,
          edges: interaction.edges,
          pageCoords: this.startCoords,
          preEnd: true,
          phase: 'inertiastart'
        };
        var thrown = this.t0 - interaction.coords.cur.timeStamp < 50 && pointerSpeed > options.minSpeed && pointerSpeed > options.endSpeed;

        if (thrown) {
          this.startInertia();
        } else {
          modification.result = modification.setAll(this.modifierArg);

          if (!modification.result.changed) {
            return false;
          }

          this.startSmoothEnd();
        } // force modification change


        interaction.modification.result.rect = null; // bring inertiastart event to the target coords

        interaction.offsetBy(this.targetOffset);

        interaction._doPhase({
          interaction: interaction,
          event: event,
          phase: 'inertiastart'
        });

        interaction.offsetBy({
          x: -this.targetOffset.x,
          y: -this.targetOffset.y
        }); // force modification change

        interaction.modification.result.rect = null;
        this.active = true;
        interaction.simulation = this;
        return true;
      }
    }, {
      key: "startInertia",
      value: function startInertia() {
        var _this = this;

        var startVelocity = this.interaction.coords.velocity.client;
        var options = getOptions(this.interaction);
        var lambda = options.resistance;
        var inertiaDur = -Math.log(options.endSpeed / this.v0) / lambda;
        this.targetOffset = {
          x: (startVelocity.x - inertiaDur) / lambda,
          y: (startVelocity.y - inertiaDur) / lambda
        };
        this.te = inertiaDur;
        this.lambda_v0 = lambda / this.v0;
        this.one_ve_v0 = 1 - options.endSpeed / this.v0;
        var modification = this.modification,
            modifierArg = this.modifierArg;
        modifierArg.pageCoords = {
          x: this.startCoords.x + this.targetOffset.x,
          y: this.startCoords.y + this.targetOffset.y
        };
        modification.result = modification.setAll(modifierArg);

        if (modification.result.changed) {
          this.isModified = true;
          this.modifiedOffset = {
            x: this.targetOffset.x + modification.result.delta.x,
            y: this.targetOffset.y + modification.result.delta.y
          };
        }

        this.timeout = _$raf_82["default"].request(function () {
          return _this.inertiaTick();
        });
      }
    }, {
      key: "startSmoothEnd",
      value: function startSmoothEnd() {
        var _this2 = this;

        this.smoothEnd = true;
        this.isModified = true;
        this.targetOffset = {
          x: this.modification.result.delta.x,
          y: this.modification.result.delta.y
        };
        this.timeout = _$raf_82["default"].request(function () {
          return _this2.smoothEndTick();
        });
      }
    }, {
      key: "inertiaTick",
      value: function inertiaTick() {
        var _this3 = this;

        var interaction = this.interaction;
        var options = getOptions(interaction);
        var lambda = options.resistance;
        var t = (interaction._now() - this.t0) / 1000;

        if (t < this.te) {
          var progress = 1 - (Math.exp(-lambda * t) - this.lambda_v0) / this.one_ve_v0;
          var newOffset;

          if (this.isModified) {
            newOffset = getQuadraticCurvePoint(0, 0, this.targetOffset.x, this.targetOffset.y, this.modifiedOffset.x, this.modifiedOffset.y, progress);
          } else {
            newOffset = {
              x: this.targetOffset.x * progress,
              y: this.targetOffset.y * progress
            };
          }

          var delta = {
            x: newOffset.x - this.currentOffset.x,
            y: newOffset.y - this.currentOffset.y
          };
          this.currentOffset.x += delta.x;
          this.currentOffset.y += delta.y;
          interaction.offsetBy(delta);
          interaction.move();
          this.timeout = _$raf_82["default"].request(function () {
            return _this3.inertiaTick();
          });
        } else {
          interaction.offsetBy({
            x: this.modifiedOffset.x - this.currentOffset.x,
            y: this.modifiedOffset.y - this.currentOffset.y
          });
          this.end();
        }
      }
    }, {
      key: "smoothEndTick",
      value: function smoothEndTick() {
        var _this4 = this;

        var interaction = this.interaction;
        var t = interaction._now() - this.t0;

        var _getOptions = getOptions(interaction),
            duration = _getOptions.smoothEndDuration;

        if (t < duration) {
          var newOffset = {
            x: easeOutQuad(t, 0, this.targetOffset.x, duration),
            y: easeOutQuad(t, 0, this.targetOffset.y, duration)
          };
          var delta = {
            x: newOffset.x - this.currentOffset.x,
            y: newOffset.y - this.currentOffset.y
          };
          this.currentOffset.x += delta.x;
          this.currentOffset.y += delta.y;
          interaction.offsetBy(delta);
          interaction.move({
            skipModifiers: this.modifierCount
          });
          this.timeout = _$raf_82["default"].request(function () {
            return _this4.smoothEndTick();
          });
        } else {
          interaction.offsetBy({
            x: this.targetOffset.x - this.currentOffset.x,
            y: this.targetOffset.y - this.currentOffset.y
          });
          this.end();
        }
      }
    }, {
      key: "resume",
      value: function resume(_ref) {
        var pointer = _ref.pointer,
            event = _ref.event,
            eventTarget = _ref.eventTarget;
        var interaction = this.interaction; // undo inertia changes to interaction coords

        interaction.offsetBy({
          x: -this.currentOffset.x,
          y: -this.currentOffset.y
        }); // update pointer at pointer down position

        interaction.updatePointer(pointer, event, eventTarget, true); // fire resume signals and event

        interaction._doPhase({
          interaction: interaction,
          event: event,
          phase: 'resume'
        });

        (0, _$pointerUtils_81.copyCoords)(interaction.coords.prev, interaction.coords.cur);
        this.stop();
      }
    }, {
      key: "end",
      value: function end() {
        this.interaction.move();
        this.interaction.end();
        this.stop();
      }
    }, {
      key: "stop",
      value: function stop() {
        this.active = this.smoothEnd = false;
        this.interaction.simulation = null;

        _$raf_82["default"].cancel(this.timeout);
      }
    }]);

    return InertiaState;
  }();

  _$plugin_32.InertiaState = InertiaState;

  function __start_32(_ref2) {
    var interaction = _ref2.interaction,
        event = _ref2.event;

    if (!interaction._interacting || interaction.simulation) {
      return null;
    }

    var started = interaction.inertia.start(event); // prevent action end if inertia or smoothEnd

    return started ? false : null;
  } // Check if the down event hits the current inertia target
  // control should be return to the user


  function resume(arg) {
    var interaction = arg.interaction,
        eventTarget = arg.eventTarget;
    var state = interaction.inertia;

    if (!state.active) {
      return;
    }

    var element = eventTarget; // climb up the DOM tree from the event target

    while (_$is_76["default"].element(element)) {
      // if interaction element is the current inertia target element
      if (element === interaction.element) {
        state.resume(arg);
        break;
      }

      element = _$domUtils_71.parentNode(element);
    }
  }

  function stop(_ref3) {
    var interaction = _ref3.interaction;
    var state = interaction.inertia;

    if (state.active) {
      state.stop();
    }
  }

  function getOptions(_ref4) {
    var interactable = _ref4.interactable,
        prepared = _ref4.prepared;
    return interactable && interactable.options && prepared.name && interactable.options[prepared.name].inertia;
  }

  var inertia = {
    id: 'inertia',
    before: ['modifiers'],
    install: __install_32,
    listeners: {
      'interactions:new': function interactionsNew(_ref5) {
        var interaction = _ref5.interaction;
        interaction.inertia = new InertiaState(interaction);
      },
      'interactions:before-action-end': __start_32,
      'interactions:down': resume,
      'interactions:stop': stop,
      'interactions:before-action-resume': function interactionsBeforeActionResume(arg) {
        var modification = arg.interaction.modification;
        modification.stop(arg);
        modification.start(arg, arg.interaction.coords.cur.page);
        modification.applyToInteraction(arg);
      },
      'interactions:before-action-inertiastart': function interactionsBeforeActionInertiastart(arg) {
        return arg.interaction.modification.setAndApply(arg);
      },
      'interactions:action-resume': _$base_39.addEventModifiers,
      'interactions:action-inertiastart': _$base_39.addEventModifiers,
      'interactions:after-action-inertiastart': function interactionsAfterActionInertiastart(arg) {
        return arg.interaction.modification.restoreInteractionCoords(arg);
      },
      'interactions:after-action-resume': function interactionsAfterActionResume(arg) {
        return arg.interaction.modification.restoreInteractionCoords(arg);
      }
    }
  }; // http://stackoverflow.com/a/5634528/2280888

  function _getQBezierValue(t, p1, p2, p3) {
    var iT = 1 - t;
    return iT * iT * p1 + 2 * iT * t * p2 + t * t * p3;
  }

  function getQuadraticCurvePoint(startX, startY, cpX, cpY, endX, endY, position) {
    return {
      x: _getQBezierValue(position, startX, cpX, endX),
      y: _getQBezierValue(position, startY, cpY, endY)
    };
  } // http://gizma.com/easing/


  function easeOutQuad(t, b, c, d) {
    t /= d;
    return -c * t * (t - 2) + b;
  }

  var ___default_32 = inertia;
  _$plugin_32["default"] = ___default_32;
  var _$Eventable_16 = {};
  "use strict";

  Object.defineProperty(_$Eventable_16, "__esModule", {
    value: true
  });
  _$Eventable_16.Eventable = void 0;
  /* removed: var _$arr_66 = require("../utils/arr.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$normalizeListeners_79 = require("../utils/normalizeListeners.js"); */

  ;

  function ___classCallCheck_16(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_16(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_16(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_16(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_16(Constructor, staticProps);
    return Constructor;
  }

  function fireUntilImmediateStopped(event, listeners) {
    for (var _i = 0; _i < listeners.length; _i++) {
      var _ref;

      _ref = listeners[_i];
      var listener = _ref;

      if (event.immediatePropagationStopped) {
        break;
      }

      listener(event);
    }
  }

  var Eventable = /*#__PURE__*/function () {
    function Eventable(options) {
      ___classCallCheck_16(this, Eventable);

      this.options = void 0;
      this.types = {};
      this.propagationStopped = false;
      this.immediatePropagationStopped = false;
      this.global = void 0;
      this.options = (0, _$extend_73["default"])({}, options || {});
    }

    ___createClass_16(Eventable, [{
      key: "fire",
      value: function fire(event) {
        var listeners;
        var global = this.global; // Interactable#on() listeners
        // tslint:disable no-conditional-assignment

        if (listeners = this.types[event.type]) {
          fireUntilImmediateStopped(event, listeners);
        } // interact.on() listeners


        if (!event.propagationStopped && global && (listeners = global[event.type])) {
          fireUntilImmediateStopped(event, listeners);
        }
      }
    }, {
      key: "on",
      value: function on(type, listener) {
        var listeners = (0, _$normalizeListeners_79["default"])(type, listener);

        for (type in listeners) {
          this.types[type] = _$arr_66.merge(this.types[type] || [], listeners[type]);
        }
      }
    }, {
      key: "off",
      value: function off(type, listener) {
        var listeners = (0, _$normalizeListeners_79["default"])(type, listener);

        for (type in listeners) {
          var eventList = this.types[type];

          if (!eventList || !eventList.length) {
            continue;
          }

          for (var _i2 = 0; _i2 < listeners[type].length; _i2++) {
            var _ref2;

            _ref2 = listeners[type][_i2];
            var subListener = _ref2;
            var index = eventList.indexOf(subListener);

            if (index !== -1) {
              eventList.splice(index, 1);
            }
          }
        }
      }
    }, {
      key: "getRect",
      value: function getRect(_element) {
        return null;
      }
    }]);

    return Eventable;
  }();

  _$Eventable_16.Eventable = Eventable;
  var _$isNonNativeEvent_28 = {};
  "use strict";

  Object.defineProperty(_$isNonNativeEvent_28, "__esModule", {
    value: true
  });
  _$isNonNativeEvent_28["default"] = isNonNativeEvent;

  function isNonNativeEvent(type, actions) {
    if (actions.phaselessTypes[type]) {
      return true;
    }

    for (var name in actions.map) {
      if (type.indexOf(name) === 0 && type.substr(name.length) in actions.phases) {
        return true;
      }
    }

    return false;
  }

  var _$Interactable_18 = {};
  "use strict";

  Object.defineProperty(_$Interactable_18, "__esModule", {
    value: true
  });
  _$Interactable_18.Interactable = void 0;
  /* removed: var _$arr_66 = require("../utils/arr.js"); */

  ;
  /* removed: var _$browser_67 = require("../utils/browser.js"); */

  ;
  /* removed: var _$clone_68 = require("../utils/clone.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$normalizeListeners_79 = require("../utils/normalizeListeners.js"); */

  ;
  /* removed: var _$window_84 = require("../utils/window.js"); */

  ;
  /* removed: var _$Eventable_16 = require("./Eventable.js"); */

  ;
  /* removed: var _$isNonNativeEvent_28 = require("./isNonNativeEvent.js"); */

  ;

  function ___classCallCheck_18(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_18(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_18(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_18(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_18(Constructor, staticProps);
    return Constructor;
  }
  /** */


  var Interactable = /*#__PURE__*/function () {
    ___createClass_18(Interactable, [{
      key: "_defaults",

      /** @internal */
      get: function get() {
        return {
          base: {},
          perAction: {},
          actions: {}
        };
      }
      /** */

    }]);

    function Interactable(target, options, defaultContext, scopeEvents) {
      ___classCallCheck_18(this, Interactable);

      this.options = void 0;
      this._actions = void 0;
      this.target = void 0;
      this.events = new _$Eventable_16.Eventable();
      this._context = void 0;
      this._win = void 0;
      this._doc = void 0;
      this._scopeEvents = void 0;
      this._rectChecker = void 0;
      this._actions = options.actions;
      this.target = target;
      this._context = options.context || defaultContext;
      this._win = (0, _$window_84.getWindow)((0, _$domUtils_71.trySelector)(target) ? this._context : target);
      this._doc = this._win.document;
      this._scopeEvents = scopeEvents;
      this.set(options);
    }

    ___createClass_18(Interactable, [{
      key: "setOnEvents",
      value: function setOnEvents(actionName, phases) {
        if (_$is_76["default"].func(phases.onstart)) {
          this.on("".concat(actionName, "start"), phases.onstart);
        }

        if (_$is_76["default"].func(phases.onmove)) {
          this.on("".concat(actionName, "move"), phases.onmove);
        }

        if (_$is_76["default"].func(phases.onend)) {
          this.on("".concat(actionName, "end"), phases.onend);
        }

        if (_$is_76["default"].func(phases.oninertiastart)) {
          this.on("".concat(actionName, "inertiastart"), phases.oninertiastart);
        }

        return this;
      }
    }, {
      key: "updatePerActionListeners",
      value: function updatePerActionListeners(actionName, prev, cur) {
        if (_$is_76["default"].array(prev) || _$is_76["default"].object(prev)) {
          this.off(actionName, prev);
        }

        if (_$is_76["default"].array(cur) || _$is_76["default"].object(cur)) {
          this.on(actionName, cur);
        }
      }
    }, {
      key: "setPerAction",
      value: function setPerAction(actionName, options) {
        var defaults = this._defaults; // for all the default per-action options

        for (var optionName_ in options) {
          var optionName = optionName_;
          var actionOptions = this.options[actionName];
          var optionValue = options[optionName]; // remove old event listeners and add new ones

          if (optionName === 'listeners') {
            this.updatePerActionListeners(actionName, actionOptions.listeners, optionValue);
          } // if the option value is an array


          if (_$is_76["default"].array(optionValue)) {
            actionOptions[optionName] = _$arr_66.from(optionValue);
          } // if the option value is an object
          else if (_$is_76["default"].plainObject(optionValue)) {
              // copy the object
              actionOptions[optionName] = (0, _$extend_73["default"])(actionOptions[optionName] || {}, (0, _$clone_68["default"])(optionValue)); // set anabled field to true if it exists in the defaults

              if (_$is_76["default"].object(defaults.perAction[optionName]) && 'enabled' in defaults.perAction[optionName]) {
                actionOptions[optionName].enabled = optionValue.enabled !== false;
              }
            } // if the option value is a boolean and the default is an object
            else if (_$is_76["default"].bool(optionValue) && _$is_76["default"].object(defaults.perAction[optionName])) {
                actionOptions[optionName].enabled = optionValue;
              } // if it's anything else, do a plain assignment
              else {
                  actionOptions[optionName] = optionValue;
                }
        }
      }
      /**
       * The default function to get an Interactables bounding rect. Can be
       * overridden using {@link Interactable.rectChecker}.
       *
       * @param {Element} [element] The element to measure.
       * @return {Interact.Rect} The object's bounding rectangle.
       */

    }, {
      key: "getRect",
      value: function getRect(element) {
        element = element || (_$is_76["default"].element(this.target) ? this.target : null);

        if (_$is_76["default"].string(this.target)) {
          element = element || this._context.querySelector(this.target);
        }

        return (0, _$domUtils_71.getElementRect)(element);
      }
      /**
       * Returns or sets the function used to calculate the interactable's
       * element's rectangle
       *
       * @param {function} [checker] A function which returns this Interactable's
       * bounding rectangle. See {@link Interactable.getRect}
       * @return {function | object} The checker function or this Interactable
       */

    }, {
      key: "rectChecker",
      value: function rectChecker(checker) {
        var _this = this;

        if (_$is_76["default"].func(checker)) {
          this._rectChecker = checker;

          this.getRect = function (element) {
            var rect = (0, _$extend_73["default"])({}, _this._rectChecker(element));

            if (!('width' in rect)) {
              rect.width = rect.right - rect.left;
              rect.height = rect.bottom - rect.top;
            }

            return rect;
          };

          return this;
        }

        if (checker === null) {
          delete this.getRect;
          delete this._rectChecker;
          return this;
        }

        return this.getRect;
      }
    }, {
      key: "_backCompatOption",
      value: function _backCompatOption(optionName, newValue) {
        if ((0, _$domUtils_71.trySelector)(newValue) || _$is_76["default"].object(newValue)) {
          this.options[optionName] = newValue;

          for (var action in this._actions.map) {
            this.options[action][optionName] = newValue;
          }

          return this;
        }

        return this.options[optionName];
      }
      /**
       * Gets or sets the origin of the Interactable's element.  The x and y
       * of the origin will be subtracted from action event coordinates.
       *
       * @param {Element | object | string} [origin] An HTML or SVG Element whose
       * rect will be used, an object eg. { x: 0, y: 0 } or string 'parent', 'self'
       * or any CSS selector
       *
       * @return {object} The current origin or this Interactable
       */

    }, {
      key: "origin",
      value: function origin(newValue) {
        return this._backCompatOption('origin', newValue);
      }
      /**
       * Returns or sets the mouse coordinate types used to calculate the
       * movement of the pointer.
       *
       * @param {string} [newValue] Use 'client' if you will be scrolling while
       * interacting; Use 'page' if you want autoScroll to work
       * @return {string | object} The current deltaSource or this Interactable
       */

    }, {
      key: "deltaSource",
      value: function deltaSource(newValue) {
        if (newValue === 'page' || newValue === 'client') {
          this.options.deltaSource = newValue;
          return this;
        }

        return this.options.deltaSource;
      }
      /**
       * Gets the selector context Node of the Interactable. The default is
       * `window.document`.
       *
       * @return {Node} The context Node of this Interactable
       */

    }, {
      key: "context",
      value: function context() {
        return this._context;
      }
    }, {
      key: "inContext",
      value: function inContext(element) {
        return this._context === element.ownerDocument || (0, _$domUtils_71.nodeContains)(this._context, element);
      }
    }, {
      key: "testIgnoreAllow",
      value: function testIgnoreAllow(options, targetNode, eventTarget) {
        return !this.testIgnore(options.ignoreFrom, targetNode, eventTarget) && this.testAllow(options.allowFrom, targetNode, eventTarget);
      }
    }, {
      key: "testAllow",
      value: function testAllow(allowFrom, targetNode, element) {
        if (!allowFrom) {
          return true;
        }

        if (!_$is_76["default"].element(element)) {
          return false;
        }

        if (_$is_76["default"].string(allowFrom)) {
          return (0, _$domUtils_71.matchesUpTo)(element, allowFrom, targetNode);
        } else if (_$is_76["default"].element(allowFrom)) {
          return (0, _$domUtils_71.nodeContains)(allowFrom, element);
        }

        return false;
      }
    }, {
      key: "testIgnore",
      value: function testIgnore(ignoreFrom, targetNode, element) {
        if (!ignoreFrom || !_$is_76["default"].element(element)) {
          return false;
        }

        if (_$is_76["default"].string(ignoreFrom)) {
          return (0, _$domUtils_71.matchesUpTo)(element, ignoreFrom, targetNode);
        } else if (_$is_76["default"].element(ignoreFrom)) {
          return (0, _$domUtils_71.nodeContains)(ignoreFrom, element);
        }

        return false;
      }
      /**
       * Calls listeners for the given InteractEvent type bound globally
       * and directly to this Interactable
       *
       * @param {InteractEvent} iEvent The InteractEvent object to be fired on this
       * Interactable
       * @return {Interactable} this Interactable
       */

    }, {
      key: "fire",
      value: function fire(iEvent) {
        this.events.fire(iEvent);
        return this;
      }
    }, {
      key: "_onOff",
      value: function _onOff(method, typeArg, listenerArg, options) {
        if (_$is_76["default"].object(typeArg) && !_$is_76["default"].array(typeArg)) {
          options = listenerArg;
          listenerArg = null;
        }

        var addRemove = method === 'on' ? 'add' : 'remove';
        var listeners = (0, _$normalizeListeners_79["default"])(typeArg, listenerArg);

        for (var type in listeners) {
          if (type === 'wheel') {
            type = _$browser_67["default"].wheelEvent;
          }

          for (var _i = 0; _i < listeners[type].length; _i++) {
            var _ref;

            _ref = listeners[type][_i];
            var listener = _ref; // if it is an action event type

            if ((0, _$isNonNativeEvent_28["default"])(type, this._actions)) {
              this.events[method](type, listener);
            } // delegated event
            else if (_$is_76["default"].string(this.target)) {
                this._scopeEvents["".concat(addRemove, "Delegate")](this.target, this._context, type, listener, options);
              } // remove listener from this Interactable's element
              else {
                  this._scopeEvents[addRemove](this.target, type, listener, options);
                }
          }
        }

        return this;
      }
      /**
       * Binds a listener for an InteractEvent, pointerEvent or DOM event.
       *
       * @param {string | array | object} types The types of events to listen
       * for
       * @param {function | array | object} [listener] The event listener function(s)
       * @param {object | boolean} [options] options object or useCapture flag for
       * addEventListener
       * @return {Interactable} This Interactable
       */

    }, {
      key: "on",
      value: function on(types, listener, options) {
        return this._onOff('on', types, listener, options);
      }
      /**
       * Removes an InteractEvent, pointerEvent or DOM event listener.
       *
       * @param {string | array | object} types The types of events that were
       * listened for
       * @param {function | array | object} [listener] The event listener function(s)
       * @param {object | boolean} [options] options object or useCapture flag for
       * removeEventListener
       * @return {Interactable} This Interactable
       */

    }, {
      key: "off",
      value: function off(types, listener, options) {
        return this._onOff('off', types, listener, options);
      }
      /**
       * Reset the options of this Interactable
       *
       * @param {object} options The new settings to apply
       * @return {object} This Interactable
       */

    }, {
      key: "set",
      value: function set(options) {
        var defaults = this._defaults;

        if (!_$is_76["default"].object(options)) {
          options = {};
        }

        this.options = (0, _$clone_68["default"])(defaults.base);

        for (var actionName_ in this._actions.methodDict) {
          var actionName = actionName_;
          var methodName = this._actions.methodDict[actionName];
          this.options[actionName] = {};
          this.setPerAction(actionName, (0, _$extend_73["default"])((0, _$extend_73["default"])({}, defaults.perAction), defaults.actions[actionName]));
          this[methodName](options[actionName]);
        }

        for (var setting in options) {
          if (_$is_76["default"].func(this[setting])) {
            this[setting](options[setting]);
          }
        }

        return this;
      }
      /**
       * Remove this interactable from the list of interactables and remove it's
       * action capabilities and event listeners
       */

    }, {
      key: "unset",
      value: function unset() {
        if (_$is_76["default"].string(this.target)) {
          // remove delegated events
          for (var type in this._scopeEvents.delegatedEvents) {
            var delegated = this._scopeEvents.delegatedEvents[type];

            for (var i = delegated.length - 1; i >= 0; i--) {
              var _delegated$i = delegated[i],
                  selector = _delegated$i.selector,
                  context = _delegated$i.context,
                  listeners = _delegated$i.listeners;

              if (selector === this.target && context === this._context) {
                delegated.splice(i, 1);
              }

              for (var l = listeners.length - 1; l >= 0; l--) {
                this._scopeEvents.removeDelegate(this.target, this._context, type, listeners[l][0], listeners[l][1]);
              }
            }
          }
        } else {
          this._scopeEvents.remove(this.target, 'all');
        }
      }
    }]);

    return Interactable;
  }();

  _$Interactable_18.Interactable = Interactable;
  var _$InteractableSet_19 = {};
  "use strict";

  Object.defineProperty(_$InteractableSet_19, "__esModule", {
    value: true
  });
  _$InteractableSet_19.InteractableSet = void 0;
  /* removed: var _$arr_66 = require("../utils/arr.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;

  function ___classCallCheck_19(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_19(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_19(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_19(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_19(Constructor, staticProps);
    return Constructor;
  }

  var InteractableSet = /*#__PURE__*/function () {
    // all set interactables
    function InteractableSet(scope) {
      var _this = this;

      ___classCallCheck_19(this, InteractableSet);

      this.list = [];
      this.selectorMap = {};
      this.scope = void 0;
      this.scope = scope;
      scope.addListeners({
        'interactable:unset': function interactableUnset(_ref) {
          var interactable = _ref.interactable;
          var target = interactable.target,
              context = interactable._context;
          var targetMappings = _$is_76["default"].string(target) ? _this.selectorMap[target] : target[_this.scope.id];
          var targetIndex = targetMappings.findIndex(function (m) {
            return m.context === context;
          });

          if (targetMappings[targetIndex]) {
            // Destroying mappingInfo's context and interactable
            targetMappings[targetIndex].context = null;
            targetMappings[targetIndex].interactable = null;
          }

          targetMappings.splice(targetIndex, 1);
        }
      });
    }

    ___createClass_19(InteractableSet, [{
      key: "new",
      value: function _new(target, options) {
        options = (0, _$extend_73["default"])(options || {}, {
          actions: this.scope.actions
        });
        var interactable = new this.scope.Interactable(target, options, this.scope.document, this.scope.events);
        var mappingInfo = {
          context: interactable._context,
          interactable: interactable
        };
        this.scope.addDocument(interactable._doc);
        this.list.push(interactable);

        if (_$is_76["default"].string(target)) {
          if (!this.selectorMap[target]) {
            this.selectorMap[target] = [];
          }

          this.selectorMap[target].push(mappingInfo);
        } else {
          if (!interactable.target[this.scope.id]) {
            Object.defineProperty(target, this.scope.id, {
              value: [],
              configurable: true
            });
          }

          target[this.scope.id].push(mappingInfo);
        }

        this.scope.fire('interactable:new', {
          target: target,
          options: options,
          interactable: interactable,
          win: this.scope._win
        });
        return interactable;
      }
    }, {
      key: "get",
      value: function get(target, options) {
        var context = options && options.context || this.scope.document;

        var isSelector = _$is_76["default"].string(target);

        var targetMappings = isSelector ? this.selectorMap[target] : target[this.scope.id];

        if (!targetMappings) {
          return null;
        }

        var found = _$arr_66.find(targetMappings, function (m) {
          return m.context === context && (isSelector || m.interactable.inContext(target));
        });

        return found && found.interactable;
      }
    }, {
      key: "forEachMatch",
      value: function forEachMatch(node, callback) {
        for (var _i = 0; _i < this.list.length; _i++) {
          var _ref2;

          _ref2 = this.list[_i];
          var interactable = _ref2;
          var ret = void 0;

          if ((_$is_76["default"].string(interactable.target) // target is a selector and the element matches
          ? _$is_76["default"].element(node) && _$domUtils_71.matchesSelector(node, interactable.target) : // target is the element
          node === interactable.target) && // the element is in context
          interactable.inContext(node)) {
            ret = callback(interactable);
          }

          if (ret !== undefined) {
            return ret;
          }
        }
      }
    }]);

    return InteractableSet;
  }();

  _$InteractableSet_19.InteractableSet = InteractableSet;
  var _$events_23 = {};
  "use strict";

  Object.defineProperty(_$events_23, "__esModule", {
    value: true
  });
  _$events_23["default"] = _$events_23.FakeEvent = void 0;
  /* removed: var _$arr_66 = require("../utils/arr.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$pointerExtend_80 = require("../utils/pointerExtend.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;

  function ___classCallCheck_23(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_23(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_23(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_23(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_23(Constructor, staticProps);
    return Constructor;
  }

  function ___slicedToArray_23(arr, i) {
    return ___arrayWithHoles_23(arr) || ___iterableToArrayLimit_23(arr, i) || ___unsupportedIterableToArray_23(arr, i) || ___nonIterableRest_23();
  }

  function ___nonIterableRest_23() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function ___unsupportedIterableToArray_23(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return ___arrayLikeToArray_23(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return ___arrayLikeToArray_23(o, minLen);
  }

  function ___arrayLikeToArray_23(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function ___iterableToArrayLimit_23(arr, i) {
    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function ___arrayWithHoles_23(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function __install_23(scope) {
    var targets = [];
    var delegatedEvents = {};
    var documents = [];
    var eventsMethods = {
      add: add,
      remove: remove,
      addDelegate: addDelegate,
      removeDelegate: removeDelegate,
      delegateListener: delegateListener,
      delegateUseCapture: delegateUseCapture,
      delegatedEvents: delegatedEvents,
      documents: documents,
      targets: targets,
      supportsOptions: false,
      supportsPassive: false
    }; // check if browser supports passive events and options arg

    scope.document.createElement('div').addEventListener('test', null, {
      get capture() {
        return eventsMethods.supportsOptions = true;
      },

      get passive() {
        return eventsMethods.supportsPassive = true;
      }

    });
    scope.events = eventsMethods;

    function add(eventTarget, type, listener, optionalArg) {
      var options = __getOptions_23(optionalArg);

      var target = _$arr_66.find(targets, function (t) {
        return t.eventTarget === eventTarget;
      });

      if (!target) {
        target = {
          eventTarget: eventTarget,
          events: {}
        };
        targets.push(target);
      }

      if (!target.events[type]) {
        target.events[type] = [];
      }

      if (eventTarget.addEventListener && !_$arr_66.contains(target.events[type], listener)) {
        eventTarget.addEventListener(type, listener, eventsMethods.supportsOptions ? options : options.capture);
        target.events[type].push(listener);
      }
    }

    function remove(eventTarget, type, listener, optionalArg) {
      var options = __getOptions_23(optionalArg);

      var targetIndex = _$arr_66.findIndex(targets, function (t) {
        return t.eventTarget === eventTarget;
      });

      var target = targets[targetIndex];

      if (!target || !target.events) {
        return;
      }

      if (type === 'all') {
        for (type in target.events) {
          if (target.events.hasOwnProperty(type)) {
            remove(eventTarget, type, 'all');
          }
        }

        return;
      }

      var typeIsEmpty = false;
      var typeListeners = target.events[type];

      if (typeListeners) {
        if (listener === 'all') {
          for (var i = typeListeners.length - 1; i >= 0; i--) {
            remove(eventTarget, type, typeListeners[i], options);
          }

          return;
        } else {
          for (var _i = 0; _i < typeListeners.length; _i++) {
            if (typeListeners[_i] === listener) {
              eventTarget.removeEventListener(type, listener, eventsMethods.supportsOptions ? options : options.capture);
              typeListeners.splice(_i, 1);

              if (typeListeners.length === 0) {
                delete target.events[type];
                typeIsEmpty = true;
              }

              break;
            }
          }
        }
      }

      if (typeIsEmpty && !Object.keys(target.events).length) {
        targets.splice(targetIndex, 1);
      }
    }

    function addDelegate(selector, context, type, listener, optionalArg) {
      var options = __getOptions_23(optionalArg);

      if (!delegatedEvents[type]) {
        delegatedEvents[type] = []; // add delegate listener functions

        for (var _i2 = 0; _i2 < documents.length; _i2++) {
          var _ref;

          _ref = documents[_i2];
          var doc = _ref;
          add(doc, type, delegateListener);
          add(doc, type, delegateUseCapture, true);
        }
      }

      var delegates = delegatedEvents[type];

      var delegate = _$arr_66.find(delegates, function (d) {
        return d.selector === selector && d.context === context;
      });

      if (!delegate) {
        delegate = {
          selector: selector,
          context: context,
          listeners: []
        };
        delegates.push(delegate);
      }

      delegate.listeners.push([listener, options]);
    }

    function removeDelegate(selector, context, type, listener, optionalArg) {
      var options = __getOptions_23(optionalArg);

      var delegates = delegatedEvents[type];
      var matchFound = false;
      var index;

      if (!delegates) {
        return;
      } // count from last index of delegated to 0


      for (index = delegates.length - 1; index >= 0; index--) {
        var cur = delegates[index]; // look for matching selector and context Node

        if (cur.selector === selector && cur.context === context) {
          var listeners = cur.listeners; // each item of the listeners array is an array: [function, capture, passive]

          for (var i = listeners.length - 1; i >= 0; i--) {
            var _listeners$i = ___slicedToArray_23(listeners[i], 2),
                fn = _listeners$i[0],
                _listeners$i$ = _listeners$i[1],
                capture = _listeners$i$.capture,
                passive = _listeners$i$.passive; // check if the listener functions and capture and passive flags match


            if (fn === listener && capture === options.capture && passive === options.passive) {
              // remove the listener from the array of listeners
              listeners.splice(i, 1); // if all listeners for this target have been removed
              // remove the target from the delegates array

              if (!listeners.length) {
                delegates.splice(index, 1); // remove delegate function from context

                remove(context, type, delegateListener);
                remove(context, type, delegateUseCapture, true);
              } // only remove one listener


              matchFound = true;
              break;
            }
          }

          if (matchFound) {
            break;
          }
        }
      }
    } // bound to the interactable context when a DOM event
    // listener is added to a selector interactable


    function delegateListener(event, optionalArg) {
      var options = __getOptions_23(optionalArg);

      var fakeEvent = new FakeEvent(event);
      var delegates = delegatedEvents[event.type];

      var _pointerUtils$getEven = _$pointerUtils_81.getEventTargets(event),
          _pointerUtils$getEven2 = ___slicedToArray_23(_pointerUtils$getEven, 1),
          eventTarget = _pointerUtils$getEven2[0];

      var element = eventTarget; // climb up document tree looking for selector matches

      while (_$is_76["default"].element(element)) {
        for (var i = 0; i < delegates.length; i++) {
          var cur = delegates[i];
          var selector = cur.selector,
              context = cur.context;

          if (_$domUtils_71.matchesSelector(element, selector) && _$domUtils_71.nodeContains(context, eventTarget) && _$domUtils_71.nodeContains(context, element)) {
            var listeners = cur.listeners;
            fakeEvent.currentTarget = element;

            for (var _i3 = 0; _i3 < listeners.length; _i3++) {
              var _ref2;

              _ref2 = listeners[_i3];

              var _ref3 = _ref2,
                  _ref4 = ___slicedToArray_23(_ref3, 2),
                  fn = _ref4[0],
                  _ref4$ = _ref4[1],
                  capture = _ref4$.capture,
                  passive = _ref4$.passive;

              if (capture === options.capture && passive === options.passive) {
                fn(fakeEvent);
              }
            }
          }
        }

        element = _$domUtils_71.parentNode(element);
      }
    }

    function delegateUseCapture(event) {
      return delegateListener.call(this, event, true);
    } // for type inferrence


    return eventsMethods;
  }

  var FakeEvent = /*#__PURE__*/function () {
    function FakeEvent(originalEvent) {
      ___classCallCheck_23(this, FakeEvent);

      this.currentTarget = void 0;
      this.originalEvent = void 0;
      this.originalEvent = originalEvent; // duplicate the event so that currentTarget can be changed

      (0, _$pointerExtend_80["default"])(this, originalEvent);
    }

    ___createClass_23(FakeEvent, [{
      key: "preventOriginalDefault",
      value: function preventOriginalDefault() {
        this.originalEvent.preventDefault();
      }
    }, {
      key: "stopPropagation",
      value: function stopPropagation() {
        this.originalEvent.stopPropagation();
      }
    }, {
      key: "stopImmediatePropagation",
      value: function stopImmediatePropagation() {
        this.originalEvent.stopImmediatePropagation();
      }
    }]);

    return FakeEvent;
  }();

  _$events_23.FakeEvent = FakeEvent;

  function __getOptions_23(param) {
    if (!_$is_76["default"].object(param)) {
      return {
        capture: !!param,
        passive: false
      };
    }

    var options = (0, _$extend_73["default"])({}, param);
    options.capture = !!param.capture;
    options.passive = !!param.passive;
    return options;
  }

  var ___default_23 = {
    id: 'events',
    install: __install_23
  };
  _$events_23["default"] = ___default_23;
  var _$interactStatic_24 = {};
  "use strict";

  Object.defineProperty(_$interactStatic_24, "__esModule", {
    value: true
  });
  _$interactStatic_24.createInteractStatic = createInteractStatic;
  /* removed: var _$browser_67 = require("../utils/browser.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$isNonNativeEvent_28 = require("./isNonNativeEvent.js"); */

  ;
  /** @module interact */

  function createInteractStatic(scope) {
    /**
     * ```js
     * interact('#draggable').draggable(true)
     *
     * var rectables = interact('rect')
     * rectables
     *   .gesturable(true)
     *   .on('gesturemove', function (event) {
     *       // ...
     *   })
     * ```
     *
     * The methods of this variable can be used to set elements as interactables
     * and also to change various default settings.
     *
     * Calling it as a function and passing an element or a valid CSS selector
     * string returns an Interactable object which has various methods to configure
     * it.
     *
     * @global
     *
     * @param {Element | string} target The HTML or SVG Element to interact with
     * or CSS selector
     * @return {Interactable}
     */
    var interact = function interact(target, options) {
      var interactable = scope.interactables.get(target, options);

      if (!interactable) {
        interactable = scope.interactables["new"](target, options);
        interactable.events.global = interact.globalEvents;
      }

      return interactable;
    }; // expose the functions used to calculate multi-touch properties


    interact.getPointerAverage = _$pointerUtils_81.pointerAverage;
    interact.getTouchBBox = _$pointerUtils_81.touchBBox;
    interact.getTouchDistance = _$pointerUtils_81.touchDistance;
    interact.getTouchAngle = _$pointerUtils_81.touchAngle;
    interact.getElementRect = _$domUtils_71.getElementRect;
    interact.getElementClientRect = _$domUtils_71.getElementClientRect;
    interact.matchesSelector = _$domUtils_71.matchesSelector;
    interact.closest = _$domUtils_71.closest;
    interact.globalEvents = {}; // eslint-disable-next-line no-undef

    interact.version = undefined;
    interact.scope = scope;
    /**
    * Use a plugin
    *
    * @alias module:interact.use
    *
    * @param {Object} plugin
    * @param {function} plugin.install
    * @return {Interact.InteractStatic}
     */

    interact.use = function (plugin, options) {
      this.scope.usePlugin(plugin, options);
      return this;
    };
    /**
     * Check if an element or selector has been set with the {@link interact}
     * function
     *
     * @alias module:interact.isSet
     *
     * @param {Element} element The Element being searched for
     * @return {boolean} Indicates if the element or CSS selector was previously
     * passed to interact
     */


    interact.isSet = function (target, options) {
      return !!this.scope.interactables.get(target, options && options.context);
    };
    /**
     * Add a global listener for an InteractEvent or adds a DOM event to `document`
     *
     * @alias module:interact.on
     *
     * @param {string | array | object} type The types of events to listen for
     * @param {function} listener The function event (s)
     * @param {object | boolean} [options] object or useCapture flag for
     * addEventListener
     * @return {object} interact
     */


    interact.on = function (type, listener, options) {
      if (_$is_76["default"].string(type) && type.search(' ') !== -1) {
        type = type.trim().split(/ +/);
      }

      if (_$is_76["default"].array(type)) {
        for (var _i = 0; _i < type.length; _i++) {
          var _ref;

          _ref = type[_i];
          var eventType = _ref;
          this.on(eventType, listener, options);
        }

        return this;
      }

      if (_$is_76["default"].object(type)) {
        for (var prop in type) {
          this.on(prop, type[prop], listener);
        }

        return this;
      } // if it is an InteractEvent type, add listener to globalEvents


      if ((0, _$isNonNativeEvent_28["default"])(type, this.scope.actions)) {
        // if this type of event was never bound
        if (!this.globalEvents[type]) {
          this.globalEvents[type] = [listener];
        } else {
          this.globalEvents[type].push(listener);
        }
      } // If non InteractEvent type, addEventListener to document
      else {
          this.scope.events.add(this.scope.document, type, listener, {
            options: options
          });
        }

      return this;
    };
    /**
     * Removes a global InteractEvent listener or DOM event from `document`
     *
     * @alias module:interact.off
     *
     * @param {string | array | object} type The types of events that were listened
     * for
     * @param {function} listener The listener function to be removed
     * @param {object | boolean} options [options] object or useCapture flag for
     * removeEventListener
     * @return {object} interact
     */


    interact.off = function (type, listener, options) {
      if (_$is_76["default"].string(type) && type.search(' ') !== -1) {
        type = type.trim().split(/ +/);
      }

      if (_$is_76["default"].array(type)) {
        for (var _i2 = 0; _i2 < type.length; _i2++) {
          var _ref2;

          _ref2 = type[_i2];
          var eventType = _ref2;
          this.off(eventType, listener, options);
        }

        return this;
      }

      if (_$is_76["default"].object(type)) {
        for (var prop in type) {
          this.off(prop, type[prop], listener);
        }

        return this;
      }

      if ((0, _$isNonNativeEvent_28["default"])(type, this.scope.actions)) {
        var index;

        if (type in this.globalEvents && (index = this.globalEvents[type].indexOf(listener)) !== -1) {
          this.globalEvents[type].splice(index, 1);
        }
      } else {
        this.scope.events.remove(this.scope.document, type, listener, options);
      }

      return this;
    };

    interact.debug = function () {
      return this.scope;
    };
    /**
     * @alias module:interact.supportsTouch
     *
     * @return {boolean} Whether or not the browser supports touch input
     */


    interact.supportsTouch = function () {
      return _$browser_67["default"].supportsTouch;
    };
    /**
     * @alias module:interact.supportsPointerEvent
     *
     * @return {boolean} Whether or not the browser supports PointerEvents
     */


    interact.supportsPointerEvent = function () {
      return _$browser_67["default"].supportsPointerEvent;
    };
    /**
     * Cancels all interactions (end events are not fired)
     *
     * @alias module:interact.stop
     *
     * @return {object} interact
     */


    interact.stop = function () {
      for (var _i3 = 0; _i3 < this.scope.interactions.list.length; _i3++) {
        var _ref3;

        _ref3 = this.scope.interactions.list[_i3];
        var interaction = _ref3;
        interaction.stop();
      }

      return this;
    };
    /**
     * Returns or sets the distance the pointer must be moved before an action
     * sequence occurs. This also affects tolerance for tap events.
     *
     * @alias module:interact.pointerMoveTolerance
     *
     * @param {number} [newValue] The movement from the start position must be greater than this value
     * @return {interact | number}
     */


    interact.pointerMoveTolerance = function (newValue) {
      if (_$is_76["default"].number(newValue)) {
        this.scope.interactions.pointerMoveTolerance = newValue;
        return this;
      }

      return this.scope.interactions.pointerMoveTolerance;
    };

    interact.addDocument = function (doc, options) {
      this.scope.addDocument(doc, options);
    };

    interact.removeDocument = function (doc) {
      this.scope.removeDocument(doc);
    };

    return interact;
  }

  var _$interactionFinder_26 = {};
  "use strict";

  Object.defineProperty(_$interactionFinder_26, "__esModule", {
    value: true
  });
  _$interactionFinder_26["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  var finder = {
    methodOrder: ['simulationResume', 'mouseOrPen', 'hasPointer', 'idle'],
    search: function search(details) {
      for (var _i = 0; _i < finder.methodOrder.length; _i++) {
        var _ref;

        _ref = finder.methodOrder[_i];
        var method = _ref;
        var interaction = finder[method](details);

        if (interaction) {
          return interaction;
        }
      }

      return null;
    },
    // try to resume simulation with a new pointer
    simulationResume: function simulationResume(_ref2) {
      var pointerType = _ref2.pointerType,
          eventType = _ref2.eventType,
          eventTarget = _ref2.eventTarget,
          scope = _ref2.scope;

      if (!/down|start/i.test(eventType)) {
        return null;
      }

      for (var _i2 = 0; _i2 < scope.interactions.list.length; _i2++) {
        var _ref3;

        _ref3 = scope.interactions.list[_i2];
        var interaction = _ref3;
        var element = eventTarget;

        if (interaction.simulation && interaction.simulation.allowResume && interaction.pointerType === pointerType) {
          while (element) {
            // if the element is the interaction element
            if (element === interaction.element) {
              return interaction;
            }

            element = _$domUtils_71.parentNode(element);
          }
        }
      }

      return null;
    },
    // if it's a mouse or pen interaction
    mouseOrPen: function mouseOrPen(_ref4) {
      var pointerId = _ref4.pointerId,
          pointerType = _ref4.pointerType,
          eventType = _ref4.eventType,
          scope = _ref4.scope;

      if (pointerType !== 'mouse' && pointerType !== 'pen') {
        return null;
      }

      var firstNonActive;

      for (var _i3 = 0; _i3 < scope.interactions.list.length; _i3++) {
        var _ref5;

        _ref5 = scope.interactions.list[_i3];
        var interaction = _ref5;

        if (interaction.pointerType === pointerType) {
          // if it's a down event, skip interactions with running simulations
          if (interaction.simulation && !hasPointerId(interaction, pointerId)) {
            continue;
          } // if the interaction is active, return it immediately


          if (interaction.interacting()) {
            return interaction;
          } // otherwise save it and look for another active interaction
          else if (!firstNonActive) {
              firstNonActive = interaction;
            }
        }
      } // if no active mouse interaction was found use the first inactive mouse
      // interaction


      if (firstNonActive) {
        return firstNonActive;
      } // find any mouse or pen interaction.
      // ignore the interaction if the eventType is a *down, and a simulation
      // is active


      for (var _i4 = 0; _i4 < scope.interactions.list.length; _i4++) {
        var _ref6;

        _ref6 = scope.interactions.list[_i4];
        var _interaction = _ref6;

        if (_interaction.pointerType === pointerType && !(/down/i.test(eventType) && _interaction.simulation)) {
          return _interaction;
        }
      }

      return null;
    },
    // get interaction that has this pointer
    hasPointer: function hasPointer(_ref7) {
      var pointerId = _ref7.pointerId,
          scope = _ref7.scope;

      for (var _i5 = 0; _i5 < scope.interactions.list.length; _i5++) {
        var _ref8;

        _ref8 = scope.interactions.list[_i5];
        var interaction = _ref8;

        if (hasPointerId(interaction, pointerId)) {
          return interaction;
        }
      }

      return null;
    },
    // get first idle interaction with a matching pointerType
    idle: function idle(_ref9) {
      var pointerType = _ref9.pointerType,
          scope = _ref9.scope;

      for (var _i6 = 0; _i6 < scope.interactions.list.length; _i6++) {
        var _ref10;

        _ref10 = scope.interactions.list[_i6];
        var interaction = _ref10; // if there's already a pointer held down

        if (interaction.pointers.length === 1) {
          var target = interaction.interactable; // don't add this pointer if there is a target interactable and it
          // isn't gesturable

          if (target && !(target.options.gesture && target.options.gesture.enabled)) {
            continue;
          }
        } // maximum of 2 pointers per interaction
        else if (interaction.pointers.length >= 2) {
            continue;
          }

        if (!interaction.interacting() && pointerType === interaction.pointerType) {
          return interaction;
        }
      }

      return null;
    }
  };

  function hasPointerId(interaction, pointerId) {
    return interaction.pointers.some(function (_ref11) {
      var id = _ref11.id;
      return id === pointerId;
    });
  }

  var ___default_26 = finder;
  _$interactionFinder_26["default"] = ___default_26;
  var _$interactions_27 = {};
  "use strict";

  Object.defineProperty(_$interactions_27, "__esModule", {
    value: true
  });
  _$interactions_27["default"] = void 0;
  /* removed: var _$browser_67 = require("../utils/browser.js"); */

  ;
  /* removed: var _$domObjects_70 = require("../utils/domObjects.js"); */

  ;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$Interaction_20 = require("./Interaction.js"); */

  ;
  /* removed: var _$interactablePreventDefault_25 = require("./interactablePreventDefault.js"); */

  ;
  /* removed: var _$interactionFinder_26 = require("./interactionFinder.js"); */

  ;

  function ___typeof_27(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_27 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_27 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_27(obj);
  }

  function ___slicedToArray_27(arr, i) {
    return ___arrayWithHoles_27(arr) || ___iterableToArrayLimit_27(arr, i) || ___unsupportedIterableToArray_27(arr, i) || ___nonIterableRest_27();
  }

  function ___nonIterableRest_27() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function ___unsupportedIterableToArray_27(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return ___arrayLikeToArray_27(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return ___arrayLikeToArray_27(o, minLen);
  }

  function ___arrayLikeToArray_27(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function ___iterableToArrayLimit_27(arr, i) {
    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function ___arrayWithHoles_27(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function ___classCallCheck_27(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_27(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_27(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_27(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_27(Constructor, staticProps);
    return Constructor;
  }

  function ___inherits_27(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) ___setPrototypeOf_27(subClass, superClass);
  }

  function ___setPrototypeOf_27(o, p) {
    ___setPrototypeOf_27 = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return ___setPrototypeOf_27(o, p);
  }

  function ___createSuper_27(Derived) {
    var hasNativeReflectConstruct = ___isNativeReflectConstruct_27();

    return function () {
      var Super = ___getPrototypeOf_27(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = ___getPrototypeOf_27(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return ___possibleConstructorReturn_27(this, result);
    };
  }

  function ___possibleConstructorReturn_27(self, call) {
    if (call && (___typeof_27(call) === "object" || typeof call === "function")) {
      return call;
    }

    return ___assertThisInitialized_27(self);
  }

  function ___assertThisInitialized_27(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function ___isNativeReflectConstruct_27() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function ___getPrototypeOf_27(o) {
    ___getPrototypeOf_27 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return ___getPrototypeOf_27(o);
  }

  var methodNames = ['pointerDown', 'pointerMove', 'pointerUp', 'updatePointer', 'removePointer', 'windowBlur'];

  function __install_27(scope) {
    var listeners = {};

    for (var _i = 0; _i < methodNames.length; _i++) {
      var _ref;

      _ref = methodNames[_i];
      var method = _ref;
      listeners[method] = doOnInteractions(method, scope);
    }

    var pEventTypes = _$browser_67["default"].pEventTypes;
    var docEvents;

    if (_$domObjects_70["default"].PointerEvent) {
      docEvents = [{
        type: pEventTypes.down,
        listener: releasePointersOnRemovedEls
      }, {
        type: pEventTypes.down,
        listener: listeners.pointerDown
      }, {
        type: pEventTypes.move,
        listener: listeners.pointerMove
      }, {
        type: pEventTypes.up,
        listener: listeners.pointerUp
      }, {
        type: pEventTypes.cancel,
        listener: listeners.pointerUp
      }];
    } else {
      docEvents = [{
        type: 'mousedown',
        listener: listeners.pointerDown
      }, {
        type: 'mousemove',
        listener: listeners.pointerMove
      }, {
        type: 'mouseup',
        listener: listeners.pointerUp
      }, {
        type: 'touchstart',
        listener: releasePointersOnRemovedEls
      }, {
        type: 'touchstart',
        listener: listeners.pointerDown
      }, {
        type: 'touchmove',
        listener: listeners.pointerMove
      }, {
        type: 'touchend',
        listener: listeners.pointerUp
      }, {
        type: 'touchcancel',
        listener: listeners.pointerUp
      }];
    }

    docEvents.push({
      type: 'blur',
      listener: function listener(event) {
        for (var _i2 = 0; _i2 < scope.interactions.list.length; _i2++) {
          var _ref2;

          _ref2 = scope.interactions.list[_i2];
          var interaction = _ref2;
          interaction.documentBlur(event);
        }
      }
    }); // for ignoring browser's simulated mouse events

    scope.prevTouchTime = 0;

    scope.Interaction = /*#__PURE__*/function (_InteractionBase) {
      ___inherits_27(_class, _InteractionBase);

      var _super = ___createSuper_27(_class);

      function _class() {
        ___classCallCheck_27(this, _class);

        return _super.apply(this, arguments);
      }

      ___createClass_27(_class, [{
        key: "_now",
        value: function _now() {
          return scope.now();
        }
      }, {
        key: "pointerMoveTolerance",
        get: function get() {
          return scope.interactions.pointerMoveTolerance;
        },
        set: function set(value) {
          scope.interactions.pointerMoveTolerance = value;
        }
      }]);

      return _class;
    }(_$Interaction_20["default"]);

    scope.interactions = {
      // all active and idle interactions
      list: [],
      "new": function _new(options) {
        options.scopeFire = function (name, arg) {
          return scope.fire(name, arg);
        };

        var interaction = new scope.Interaction(options);
        scope.interactions.list.push(interaction);
        return interaction;
      },
      listeners: listeners,
      docEvents: docEvents,
      pointerMoveTolerance: 1
    };

    function releasePointersOnRemovedEls() {
      // for all inactive touch interactions with pointers down
      for (var _i3 = 0; _i3 < scope.interactions.list.length; _i3++) {
        var _ref3;

        _ref3 = scope.interactions.list[_i3];
        var interaction = _ref3;

        if (!interaction.pointerIsDown || interaction.pointerType !== 'touch' || interaction._interacting) {
          continue;
        } // if a pointer is down on an element that is no longer in the DOM tree


        var _loop = function _loop() {
          _ref4 = interaction.pointers[_i4];
          var pointer = _ref4;

          if (!scope.documents.some(function (_ref5) {
            var doc = _ref5.doc;
            return (0, _$domUtils_71.nodeContains)(doc, pointer.downTarget);
          })) {
            // remove the pointer from the interaction
            interaction.removePointer(pointer.pointer, pointer.event);
          }
        };

        for (var _i4 = 0; _i4 < interaction.pointers.length; _i4++) {
          var _ref4;

          _loop();
        }
      }
    }

    scope.usePlugin(_$interactablePreventDefault_25["default"]);
  }

  function doOnInteractions(method, scope) {
    return function (event) {
      var interactions = scope.interactions.list;

      var pointerType = _$pointerUtils_81.getPointerType(event);

      var _pointerUtils$getEven = _$pointerUtils_81.getEventTargets(event),
          _pointerUtils$getEven2 = ___slicedToArray_27(_pointerUtils$getEven, 2),
          eventTarget = _pointerUtils$getEven2[0],
          curEventTarget = _pointerUtils$getEven2[1];

      var matches = []; // [ [pointer, interaction], ...]

      if (/^touch/.test(event.type)) {
        scope.prevTouchTime = scope.now();

        for (var _i5 = 0; _i5 < event.changedTouches.length; _i5++) {
          var _ref6;

          _ref6 = event.changedTouches[_i5];
          var changedTouch = _ref6;
          var pointer = changedTouch;

          var pointerId = _$pointerUtils_81.getPointerId(pointer);

          var searchDetails = {
            pointer: pointer,
            pointerId: pointerId,
            pointerType: pointerType,
            eventType: event.type,
            eventTarget: eventTarget,
            curEventTarget: curEventTarget,
            scope: scope
          };
          var interaction = getInteraction(searchDetails);
          matches.push([searchDetails.pointer, searchDetails.eventTarget, searchDetails.curEventTarget, interaction]);
        }
      } else {
        var invalidPointer = false;

        if (!_$browser_67["default"].supportsPointerEvent && /mouse/.test(event.type)) {
          // ignore mouse events while touch interactions are active
          for (var i = 0; i < interactions.length && !invalidPointer; i++) {
            invalidPointer = interactions[i].pointerType !== 'mouse' && interactions[i].pointerIsDown;
          } // try to ignore mouse events that are simulated by the browser
          // after a touch event


          invalidPointer = invalidPointer || scope.now() - scope.prevTouchTime < 500 || // on iOS and Firefox Mobile, MouseEvent.timeStamp is zero if simulated
          event.timeStamp === 0;
        }

        if (!invalidPointer) {
          var _searchDetails = {
            pointer: event,
            pointerId: _$pointerUtils_81.getPointerId(event),
            pointerType: pointerType,
            eventType: event.type,
            curEventTarget: curEventTarget,
            eventTarget: eventTarget,
            scope: scope
          };

          var _interaction = getInteraction(_searchDetails);

          matches.push([_searchDetails.pointer, _searchDetails.eventTarget, _searchDetails.curEventTarget, _interaction]);
        }
      } // eslint-disable-next-line no-shadow


      for (var _i6 = 0; _i6 < matches.length; _i6++) {
        var _matches$_i = ___slicedToArray_27(matches[_i6], 4),
            _pointer = _matches$_i[0],
            _eventTarget = _matches$_i[1],
            _curEventTarget = _matches$_i[2],
            _interaction2 = _matches$_i[3];

        _interaction2[method](_pointer, event, _eventTarget, _curEventTarget);
      }
    };
  }

  function getInteraction(searchDetails) {
    var pointerType = searchDetails.pointerType,
        scope = searchDetails.scope;

    var foundInteraction = _$interactionFinder_26["default"].search(searchDetails);

    var signalArg = {
      interaction: foundInteraction,
      searchDetails: searchDetails
    };
    scope.fire('interactions:find', signalArg);
    return signalArg.interaction || scope.interactions["new"]({
      pointerType: pointerType
    });
  }

  function onDocSignal(_ref7, eventMethodName) {
    var doc = _ref7.doc,
        scope = _ref7.scope,
        options = _ref7.options;
    var docEvents = scope.interactions.docEvents,
        events = scope.events;
    var eventMethod = events[eventMethodName];

    if (scope.browser.isIOS && !options.events) {
      options.events = {
        passive: false
      };
    } // delegate event listener


    for (var eventType in events.delegatedEvents) {
      eventMethod(doc, eventType, events.delegateListener);
      eventMethod(doc, eventType, events.delegateUseCapture, true);
    }

    var eventOptions = options && options.events;

    for (var _i7 = 0; _i7 < docEvents.length; _i7++) {
      var _ref8;

      _ref8 = docEvents[_i7];
      var _ref9 = _ref8,
          type = _ref9.type,
          listener = _ref9.listener;
      eventMethod(doc, type, listener, eventOptions);
    }
  }

  var interactions = {
    id: 'core/interactions',
    install: __install_27,
    listeners: {
      'scope:add-document': function scopeAddDocument(arg) {
        return onDocSignal(arg, 'add');
      },
      'scope:remove-document': function scopeRemoveDocument(arg) {
        return onDocSignal(arg, 'remove');
      },
      'interactable:unset': function interactableUnset(_ref10, scope) {
        var interactable = _ref10.interactable; // Stop and destroy related interactions when an Interactable is unset

        for (var i = scope.interactions.list.length - 1; i >= 0; i--) {
          var interaction = scope.interactions.list[i];

          if (interaction.interactable !== interactable) {
            continue;
          }

          interaction.stop();
          scope.fire('interactions:destroy', {
            interaction: interaction
          });
          interaction.destroy();

          if (scope.interactions.list.length > 2) {
            scope.interactions.list.splice(i, 1);
          }
        }
      }
    },
    onDocSignal: onDocSignal,
    doOnInteractions: doOnInteractions,
    methodNames: methodNames
  };
  var ___default_27 = interactions;
  _$interactions_27["default"] = ___default_27;
  var _$scope_29 = {};
  "use strict";

  Object.defineProperty(_$scope_29, "__esModule", {
    value: true
  });
  _$scope_29.initScope = initScope;
  _$scope_29.Scope = void 0;
  /* removed: var _$browser_67 = require("../utils/browser.js"); */

  ;
  /* removed: var _$clone_68 = require("../utils/clone.js"); */

  ;
  /* removed: var _$domObjects_70 = require("../utils/domObjects.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$raf_82 = require("../utils/raf.js"); */

  ;
  /* removed: var _$window_84 = require("../utils/window.js"); */

  ;
  /* removed: var _$Eventable_16 = require("./Eventable.js"); */

  ;
  /* removed: var _$InteractEvent_17 = require("./InteractEvent.js"); */

  ;
  /* removed: var _$Interactable_18 = require("./Interactable.js"); */

  ;
  /* removed: var _$InteractableSet_19 = require("./InteractableSet.js"); */

  ;
  /* removed: var _$defaultOptions_22 = require("./defaultOptions.js"); */

  ;
  /* removed: var _$events_23 = require("./events.js"); */

  ;
  /* removed: var _$interactStatic_24 = require("./interactStatic.js"); */

  ;
  /* removed: var _$interactions_27 = require("./interactions.js"); */

  ;

  function ___typeof_29(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_29 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_29 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_29(obj);
  }

  function _get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
      _get = Reflect.get;
    } else {
      _get = function _get(target, property, receiver) {
        var base = _superPropBase(target, property);

        if (!base) return;
        var desc = Object.getOwnPropertyDescriptor(base, property);

        if (desc.get) {
          return desc.get.call(receiver);
        }

        return desc.value;
      };
    }

    return _get(target, property, receiver || target);
  }

  function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = ___getPrototypeOf_29(object);
      if (object === null) break;
    }

    return object;
  }

  function ___inherits_29(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) ___setPrototypeOf_29(subClass, superClass);
  }

  function ___setPrototypeOf_29(o, p) {
    ___setPrototypeOf_29 = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return ___setPrototypeOf_29(o, p);
  }

  function ___createSuper_29(Derived) {
    var hasNativeReflectConstruct = ___isNativeReflectConstruct_29();

    return function () {
      var Super = ___getPrototypeOf_29(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = ___getPrototypeOf_29(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return ___possibleConstructorReturn_29(this, result);
    };
  }

  function ___possibleConstructorReturn_29(self, call) {
    if (call && (___typeof_29(call) === "object" || typeof call === "function")) {
      return call;
    }

    return ___assertThisInitialized_29(self);
  }

  function ___assertThisInitialized_29(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function ___isNativeReflectConstruct_29() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function ___getPrototypeOf_29(o) {
    ___getPrototypeOf_29 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return ___getPrototypeOf_29(o);
  }

  function ___classCallCheck_29(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_29(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_29(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_29(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_29(Constructor, staticProps);
    return Constructor;
  }

  var Scope = /*#__PURE__*/function () {
    // main window
    // main document
    // main window
    // all documents being listened to
    function Scope() {
      var _this = this;

      ___classCallCheck_29(this, Scope);

      this.id = "__interact_scope_".concat(Math.floor(Math.random() * 100));
      this.isInitialized = false;
      this.listenerMaps = [];
      this.browser = _$browser_67["default"];
      this.defaults = (0, _$clone_68["default"])(_$defaultOptions_22.defaults);
      this.Eventable = _$Eventable_16.Eventable;
      this.actions = {
        map: {},
        phases: {
          start: true,
          move: true,
          end: true
        },
        methodDict: {},
        phaselessTypes: {}
      };
      this.interactStatic = (0, _$interactStatic_24.createInteractStatic)(this);
      this.InteractEvent = _$InteractEvent_17.InteractEvent;
      this.Interactable = void 0;
      this.interactables = new _$InteractableSet_19.InteractableSet(this);
      this._win = void 0;
      this.document = void 0;
      this.window = void 0;
      this.documents = [];
      this._plugins = {
        list: [],
        map: {}
      };

      this.onWindowUnload = function (event) {
        return _this.removeDocument(event.target);
      };

      var scope = this;

      this.Interactable = /*#__PURE__*/function (_InteractableBase) {
        ___inherits_29(_class, _InteractableBase);

        var _super = ___createSuper_29(_class);

        function _class() {
          ___classCallCheck_29(this, _class);

          return _super.apply(this, arguments);
        }

        ___createClass_29(_class, [{
          key: "set",
          value: function set(options) {
            _get(___getPrototypeOf_29(_class.prototype), "set", this).call(this, options);

            scope.fire('interactable:set', {
              options: options,
              interactable: this
            });
            return this;
          }
        }, {
          key: "unset",
          value: function unset() {
            _get(___getPrototypeOf_29(_class.prototype), "unset", this).call(this);

            scope.interactables.list.splice(scope.interactables.list.indexOf(this), 1);
            scope.fire('interactable:unset', {
              interactable: this
            });
          }
        }, {
          key: "_defaults",
          get: function get() {
            return scope.defaults;
          }
        }]);

        return _class;
      }(_$Interactable_18.Interactable);
    }

    ___createClass_29(Scope, [{
      key: "addListeners",
      value: function addListeners(map, id) {
        this.listenerMaps.push({
          id: id,
          map: map
        });
      }
    }, {
      key: "fire",
      value: function fire(name, arg) {
        for (var _i = 0; _i < this.listenerMaps.length; _i++) {
          var _ref;

          _ref = this.listenerMaps[_i];
          var _ref2 = _ref,
              listener = _ref2.map[name];

          if (!!listener && listener(arg, this, name) === false) {
            return false;
          }
        }
      }
    }, {
      key: "init",
      value: function init(window) {
        return this.isInitialized ? this : initScope(this, window);
      }
    }, {
      key: "pluginIsInstalled",
      value: function pluginIsInstalled(plugin) {
        return this._plugins.map[plugin.id] || this._plugins.list.indexOf(plugin) !== -1;
      }
    }, {
      key: "usePlugin",
      value: function usePlugin(plugin, options) {
        if (!this.isInitialized) {
          return this;
        }

        if (this.pluginIsInstalled(plugin)) {
          return this;
        }

        if (plugin.id) {
          this._plugins.map[plugin.id] = plugin;
        }

        this._plugins.list.push(plugin);

        if (plugin.install) {
          plugin.install(this, options);
        }

        if (plugin.listeners && plugin.before) {
          var index = 0;
          var len = this.listenerMaps.length;
          var before = plugin.before.reduce(function (acc, id) {
            acc[id] = true;
            acc[pluginIdRoot(id)] = true;
            return acc;
          }, {});

          for (; index < len; index++) {
            var otherId = this.listenerMaps[index].id;

            if (before[otherId] || before[pluginIdRoot(otherId)]) {
              break;
            }
          }

          this.listenerMaps.splice(index, 0, {
            id: plugin.id,
            map: plugin.listeners
          });
        } else if (plugin.listeners) {
          this.listenerMaps.push({
            id: plugin.id,
            map: plugin.listeners
          });
        }

        return this;
      }
    }, {
      key: "addDocument",
      value: function addDocument(doc, options) {
        // do nothing if document is already known
        if (this.getDocIndex(doc) !== -1) {
          return false;
        }

        var window = _$window_84["default"].getWindow(doc);

        options = options ? (0, _$extend_73["default"])({}, options) : {};
        this.documents.push({
          doc: doc,
          options: options
        });
        this.events.documents.push(doc); // don't add an unload event for the main document
        // so that the page may be cached in browser history

        if (doc !== this.document) {
          this.events.add(window, 'unload', this.onWindowUnload);
        }

        this.fire('scope:add-document', {
          doc: doc,
          window: window,
          scope: this,
          options: options
        });
      }
    }, {
      key: "removeDocument",
      value: function removeDocument(doc) {
        var index = this.getDocIndex(doc);

        var window = _$window_84["default"].getWindow(doc);

        var options = this.documents[index].options;
        this.events.remove(window, 'unload', this.onWindowUnload);
        this.documents.splice(index, 1);
        this.events.documents.splice(index, 1);
        this.fire('scope:remove-document', {
          doc: doc,
          window: window,
          scope: this,
          options: options
        });
      }
    }, {
      key: "getDocIndex",
      value: function getDocIndex(doc) {
        for (var i = 0; i < this.documents.length; i++) {
          if (this.documents[i].doc === doc) {
            return i;
          }
        }

        return -1;
      }
    }, {
      key: "getDocOptions",
      value: function getDocOptions(doc) {
        var docIndex = this.getDocIndex(doc);
        return docIndex === -1 ? null : this.documents[docIndex].options;
      }
    }, {
      key: "now",
      value: function now() {
        return (this.window.Date || Date).now();
      }
    }]);

    return Scope;
  }();

  _$scope_29.Scope = Scope;

  function initScope(scope, window) {
    scope.isInitialized = true;

    _$window_84["default"].init(window);

    _$domObjects_70["default"].init(window);

    _$browser_67["default"].init(window);

    _$raf_82["default"].init(window);

    scope.window = window;
    scope.document = window.document;
    scope.usePlugin(_$interactions_27["default"]);
    scope.usePlugin(_$events_23["default"]);
    return scope;
  }

  function pluginIdRoot(id) {
    return id && id.replace(/\/.*$/, '');
  }

  var _$interact_33 = {};
  "use strict";

  Object.defineProperty(_$interact_33, "__esModule", {
    value: true
  });
  _$interact_33.init = _$interact_33["default"] = void 0;
  /* removed: var _$scope_29 = require("../core/scope.js"); */

  ;

  function ___typeof_33(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_33 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_33 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_33(obj);
  }

  var scope = new _$scope_29.Scope();
  var interact = scope.interactStatic;
  var ___default_33 = interact;
  _$interact_33["default"] = ___default_33;

  var __init_33 = function init(win) {
    return scope.init(win);
  };

  _$interact_33.init = __init_33;

  if ((typeof window === "undefined" ? "undefined" : ___typeof_33(window)) === 'object' && !!window) {
    __init_33(window);
  }

  var _$edgeTarget_62 = {};
  "use strict";

  Object.defineProperty(_$edgeTarget_62, "__esModule", {
    value: true
  });
  _$edgeTarget_62["default"] = void 0;

  var ___default_62 = function _default() {};

  _$edgeTarget_62["default"] = ___default_62;
  var _$elements_63 = {};
  "use strict";

  Object.defineProperty(_$elements_63, "__esModule", {
    value: true
  });
  _$elements_63["default"] = void 0;

  var ___default_63 = function _default() {};

  _$elements_63["default"] = ___default_63;
  var _$grid_64 = {};
  "use strict";

  Object.defineProperty(_$grid_64, "__esModule", {
    value: true
  });
  _$grid_64["default"] = void 0;

  function ___slicedToArray_64(arr, i) {
    return ___arrayWithHoles_64(arr) || ___iterableToArrayLimit_64(arr, i) || ___unsupportedIterableToArray_64(arr, i) || ___nonIterableRest_64();
  }

  function ___nonIterableRest_64() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function ___unsupportedIterableToArray_64(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return ___arrayLikeToArray_64(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return ___arrayLikeToArray_64(o, minLen);
  }

  function ___arrayLikeToArray_64(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function ___iterableToArrayLimit_64(arr, i) {
    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function ___arrayWithHoles_64(arr) {
    if (Array.isArray(arr)) return arr;
  }

  var ___default_64 = function _default(grid) {
    var coordFields = [['x', 'y'], ['left', 'top'], ['right', 'bottom'], ['width', 'height']].filter(function (_ref) {
      var _ref2 = ___slicedToArray_64(_ref, 2),
          xField = _ref2[0],
          yField = _ref2[1];

      return xField in grid || yField in grid;
    });

    var gridFunc = function gridFunc(x, y) {
      var range = grid.range,
          _grid$limits = grid.limits,
          limits = _grid$limits === void 0 ? {
        left: -Infinity,
        right: Infinity,
        top: -Infinity,
        bottom: Infinity
      } : _grid$limits,
          _grid$offset = grid.offset,
          offset = _grid$offset === void 0 ? {
        x: 0,
        y: 0
      } : _grid$offset;
      var result = {
        range: range,
        grid: grid,
        x: null,
        y: null
      };

      for (var _i2 = 0; _i2 < coordFields.length; _i2++) {
        var _ref3;

        _ref3 = coordFields[_i2];

        var _ref4 = _ref3,
            _ref5 = ___slicedToArray_64(_ref4, 2),
            xField = _ref5[0],
            yField = _ref5[1];

        var gridx = Math.round((x - offset.x) / grid[xField]);
        var gridy = Math.round((y - offset.y) / grid[yField]);
        result[xField] = Math.max(limits.left, Math.min(limits.right, gridx * grid[xField] + offset.x));
        result[yField] = Math.max(limits.top, Math.min(limits.bottom, gridy * grid[yField] + offset.y));
      }

      return result;
    };

    gridFunc.grid = grid;
    gridFunc.coordFields = coordFields;
    return gridFunc;
  };

  _$grid_64["default"] = ___default_64;
  var _$all_61 = {};
  "use strict";

  Object.defineProperty(_$all_61, "__esModule", {
    value: true
  });
  Object.defineProperty(_$all_61, "edgeTarget", {
    enumerable: true,
    get: function get() {
      return _$edgeTarget_62["default"];
    }
  });
  Object.defineProperty(_$all_61, "elements", {
    enumerable: true,
    get: function get() {
      return _$elements_63["default"];
    }
  });
  Object.defineProperty(_$all_61, "grid", {
    enumerable: true,
    get: function get() {
      return _$grid_64["default"];
    }
  });
  /* removed: var _$edgeTarget_62 = require("./edgeTarget.js"); */

  ;
  /* removed: var _$elements_63 = require("./elements.js"); */

  ;
  /* removed: var _$grid_64 = require("./grid.js"); */

  ;
  var _$plugin_65 = {};
  "use strict";

  Object.defineProperty(_$plugin_65, "__esModule", {
    value: true
  });
  _$plugin_65["default"] = void 0;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$all_61 = require("./all.js"); */

  ;
  var snappersPlugin = {
    id: 'snappers',
    install: function install(scope) {
      var interact = scope.interactStatic;
      interact.snappers = (0, _$extend_73["default"])(interact.snappers || {}, _$all_61);
      interact.createSnapGrid = interact.snappers.grid;
    }
  };
  var ___default_65 = snappersPlugin;
  _$plugin_65["default"] = ___default_65;
  var _$aspectRatio_37 = {};
  "use strict";

  Object.defineProperty(_$aspectRatio_37, "__esModule", {
    value: true
  });
  _$aspectRatio_37.aspectRatio = _$aspectRatio_37["default"] = void 0;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$rect_83 = require("../utils/rect.js"); */

  ;
  /* removed: var _$Modification_35 = require("./Modification.js"); */

  ;
  /* removed: var _$base_39 = require("./base.js"); */

  ;

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  var aspectRatio = {
    start: function start(arg) {
      var state = arg.state,
          rect = arg.rect,
          originalEdges = arg.edges,
          coords = arg.pageCoords;
      var ratio = state.options.ratio;
      var _state$options = state.options,
          equalDelta = _state$options.equalDelta,
          modifiers = _state$options.modifiers;

      if (ratio === 'preserve') {
        ratio = rect.width / rect.height;
      }

      state.startCoords = (0, _$extend_73["default"])({}, coords);
      state.startRect = (0, _$extend_73["default"])({}, rect);
      state.ratio = ratio;
      state.equalDelta = equalDelta;
      var linkedEdges = state.linkedEdges = {
        top: originalEdges.top || originalEdges.left && !originalEdges.bottom,
        left: originalEdges.left || originalEdges.top && !originalEdges.right,
        bottom: originalEdges.bottom || originalEdges.right && !originalEdges.top,
        right: originalEdges.right || originalEdges.bottom && !originalEdges.left
      };
      state.xIsPrimaryAxis = !!(originalEdges.left || originalEdges.right);

      if (state.equalDelta) {
        state.edgeSign = (linkedEdges.left ? 1 : -1) * (linkedEdges.top ? 1 : -1);
      } else {
        var negativeSecondaryEdge = state.xIsPrimaryAxis ? linkedEdges.top : linkedEdges.left;
        state.edgeSign = negativeSecondaryEdge ? -1 : 1;
      }

      (0, _$extend_73["default"])(arg.edges, linkedEdges);

      if (!modifiers || !modifiers.length) {
        return;
      }

      var subModification = new _$Modification_35["default"](arg.interaction);
      subModification.copyFrom(arg.interaction.modification);
      subModification.prepareStates(modifiers);
      state.subModification = subModification;
      subModification.startAll(_objectSpread({}, arg));
    },
    set: function set(arg) {
      var state = arg.state,
          rect = arg.rect,
          coords = arg.coords;
      var initialCoords = (0, _$extend_73["default"])({}, coords);
      var aspectMethod = state.equalDelta ? setEqualDelta : setRatio;
      aspectMethod(state, state.xIsPrimaryAxis, coords, rect);

      if (!state.subModification) {
        return null;
      }

      var correctedRect = (0, _$extend_73["default"])({}, rect);
      (0, _$rect_83.addEdges)(state.linkedEdges, correctedRect, {
        x: coords.x - initialCoords.x,
        y: coords.y - initialCoords.y
      });
      var result = state.subModification.setAll(_objectSpread(_objectSpread({}, arg), {}, {
        rect: correctedRect,
        edges: state.linkedEdges,
        pageCoords: coords,
        prevCoords: coords,
        prevRect: correctedRect
      }));
      var delta = result.delta;

      if (result.changed) {
        var xIsCriticalAxis = Math.abs(delta.x) > Math.abs(delta.y); // do aspect modification again with critical edge axis as primary

        aspectMethod(state, xIsCriticalAxis, result.coords, result.rect);
        (0, _$extend_73["default"])(coords, result.coords);
      }

      return result.eventProps;
    },
    defaults: {
      ratio: 'preserve',
      equalDelta: false,
      modifiers: [],
      enabled: false
    }
  };
  _$aspectRatio_37.aspectRatio = aspectRatio;

  function setEqualDelta(_ref, xIsPrimaryAxis, coords) {
    var startCoords = _ref.startCoords,
        edgeSign = _ref.edgeSign;

    if (xIsPrimaryAxis) {
      coords.y = startCoords.y + (coords.x - startCoords.x) * edgeSign;
    } else {
      coords.x = startCoords.x + (coords.y - startCoords.y) * edgeSign;
    }
  }

  function setRatio(_ref2, xIsPrimaryAxis, coords, rect) {
    var startRect = _ref2.startRect,
        startCoords = _ref2.startCoords,
        ratio = _ref2.ratio,
        edgeSign = _ref2.edgeSign;

    if (xIsPrimaryAxis) {
      var newHeight = rect.width / ratio;
      coords.y = startCoords.y + (newHeight - startRect.height) * edgeSign;
    } else {
      var newWidth = rect.height * ratio;
      coords.x = startCoords.x + (newWidth - startRect.width) * edgeSign;
    }
  }

  var ___default_37 = (0, _$base_39.makeModifier)(aspectRatio, 'aspectRatio');

  _$aspectRatio_37["default"] = ___default_37;
  var _$noop_40 = {};
  "use strict";

  Object.defineProperty(_$noop_40, "__esModule", {
    value: true
  });
  _$noop_40["default"] = void 0;

  var noop = function noop() {};

  noop._defaults = {};
  var ___default_40 = noop;
  _$noop_40["default"] = ___default_40;
  var _$avoid_38 = {};
  "use strict";

  Object.defineProperty(_$avoid_38, "__esModule", {
    value: true
  });
  Object.defineProperty(_$avoid_38, "default", {
    enumerable: true,
    get: function get() {
      return _$noop_40["default"];
    }
  });
  /* removed: var _$noop_40 = require("./noop.js"); */

  ;
  var _$pointer_43 = {};
  "use strict";

  Object.defineProperty(_$pointer_43, "__esModule", {
    value: true
  });
  _$pointer_43.getRestrictionRect = getRestrictionRect;
  _$pointer_43.restrict = _$pointer_43["default"] = void 0;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;
  /* removed: var _$rect_83 = require("../../utils/rect.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;

  function __start_43(_ref) {
    var rect = _ref.rect,
        startOffset = _ref.startOffset,
        state = _ref.state,
        interaction = _ref.interaction,
        pageCoords = _ref.pageCoords;
    var options = state.options;
    var elementRect = options.elementRect;
    var offset = (0, _$extend_73["default"])({
      left: 0,
      top: 0,
      right: 0,
      bottom: 0
    }, options.offset || {});

    if (rect && elementRect) {
      var restriction = getRestrictionRect(options.restriction, interaction, pageCoords);

      if (restriction) {
        var widthDiff = restriction.right - restriction.left - rect.width;
        var heightDiff = restriction.bottom - restriction.top - rect.height;

        if (widthDiff < 0) {
          offset.left += widthDiff;
          offset.right += widthDiff;
        }

        if (heightDiff < 0) {
          offset.top += heightDiff;
          offset.bottom += heightDiff;
        }
      }

      offset.left += startOffset.left - rect.width * elementRect.left;
      offset.top += startOffset.top - rect.height * elementRect.top;
      offset.right += startOffset.right - rect.width * (1 - elementRect.right);
      offset.bottom += startOffset.bottom - rect.height * (1 - elementRect.bottom);
    }

    state.offset = offset;
  }

  function set(_ref2) {
    var coords = _ref2.coords,
        interaction = _ref2.interaction,
        state = _ref2.state;
    var options = state.options,
        offset = state.offset;
    var restriction = getRestrictionRect(options.restriction, interaction, coords);

    if (!restriction) {
      return;
    }

    var rect = _$rect_83.xywhToTlbr(restriction);

    coords.x = Math.max(Math.min(rect.right - offset.right, coords.x), rect.left + offset.left);
    coords.y = Math.max(Math.min(rect.bottom - offset.bottom, coords.y), rect.top + offset.top);
  }

  function getRestrictionRect(value, interaction, coords) {
    if (_$is_76["default"].func(value)) {
      return _$rect_83.resolveRectLike(value, interaction.interactable, interaction.element, [coords.x, coords.y, interaction]);
    } else {
      return _$rect_83.resolveRectLike(value, interaction.interactable, interaction.element);
    }
  }

  var __defaults_43 = {
    restriction: null,
    elementRect: null,
    offset: null,
    endOnly: false,
    enabled: false
  };
  var restrict = {
    start: __start_43,
    set: set,
    defaults: __defaults_43
  };
  _$pointer_43.restrict = restrict;

  var ___default_43 = (0, _$base_39.makeModifier)(restrict, 'restrict');

  _$pointer_43["default"] = ___default_43;
  var _$edges_42 = {};
  "use strict";

  Object.defineProperty(_$edges_42, "__esModule", {
    value: true
  });
  _$edges_42.restrictEdges = _$edges_42["default"] = void 0;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$rect_83 = require("../../utils/rect.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;
  /* removed: var _$pointer_43 = require("./pointer.js"); */

  ; // This module adds the options.resize.restrictEdges setting which sets min and
  // max for the top, left, bottom and right edges of the target being resized.
  //
  // interact(target).resize({
  //   edges: { top: true, left: true },
  //   restrictEdges: {
  //     inner: { top: 200, left: 200, right: 400, bottom: 400 },
  //     outer: { top:   0, left:   0, right: 600, bottom: 600 },
  //   },
  // })

  var noInner = {
    top: +Infinity,
    left: +Infinity,
    bottom: -Infinity,
    right: -Infinity
  };
  var noOuter = {
    top: -Infinity,
    left: -Infinity,
    bottom: +Infinity,
    right: +Infinity
  };

  function __start_42(_ref) {
    var interaction = _ref.interaction,
        startOffset = _ref.startOffset,
        state = _ref.state;
    var options = state.options;
    var offset;

    if (options) {
      var offsetRect = (0, _$pointer_43.getRestrictionRect)(options.offset, interaction, interaction.coords.start.page);
      offset = _$rect_83.rectToXY(offsetRect);
    }

    offset = offset || {
      x: 0,
      y: 0
    };
    state.offset = {
      top: offset.y + startOffset.top,
      left: offset.x + startOffset.left,
      bottom: offset.y - startOffset.bottom,
      right: offset.x - startOffset.right
    };
  }

  function __set_42(_ref2) {
    var coords = _ref2.coords,
        edges = _ref2.edges,
        interaction = _ref2.interaction,
        state = _ref2.state;
    var offset = state.offset,
        options = state.options;

    if (!edges) {
      return;
    }

    var page = (0, _$extend_73["default"])({}, coords);
    var inner = (0, _$pointer_43.getRestrictionRect)(options.inner, interaction, page) || {};
    var outer = (0, _$pointer_43.getRestrictionRect)(options.outer, interaction, page) || {};
    fixRect(inner, noInner);
    fixRect(outer, noOuter);

    if (edges.top) {
      coords.y = Math.min(Math.max(outer.top + offset.top, page.y), inner.top + offset.top);
    } else if (edges.bottom) {
      coords.y = Math.max(Math.min(outer.bottom + offset.bottom, page.y), inner.bottom + offset.bottom);
    }

    if (edges.left) {
      coords.x = Math.min(Math.max(outer.left + offset.left, page.x), inner.left + offset.left);
    } else if (edges.right) {
      coords.x = Math.max(Math.min(outer.right + offset.right, page.x), inner.right + offset.right);
    }
  }

  function fixRect(rect, defaults) {
    var _arr = ['top', 'left', 'bottom', 'right'];

    for (var _i = 0; _i < _arr.length; _i++) {
      var edge = _arr[_i];

      if (!(edge in rect)) {
        rect[edge] = defaults[edge];
      }
    }

    return rect;
  }

  var __defaults_42 = {
    inner: null,
    outer: null,
    offset: null,
    endOnly: false,
    enabled: false
  };
  var restrictEdges = {
    noInner: noInner,
    noOuter: noOuter,
    start: __start_42,
    set: __set_42,
    defaults: __defaults_42
  };
  _$edges_42.restrictEdges = restrictEdges;

  var ___default_42 = (0, _$base_39.makeModifier)(restrictEdges, 'restrictEdges');

  _$edges_42["default"] = ___default_42;
  var _$rect_44 = {};
  "use strict";

  Object.defineProperty(_$rect_44, "__esModule", {
    value: true
  });
  _$rect_44.restrictRect = _$rect_44["default"] = void 0;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;
  /* removed: var _$pointer_43 = require("./pointer.js"); */

  ;

  var __defaults_44 = (0, _$extend_73["default"])({
    get elementRect() {
      return {
        top: 0,
        left: 0,
        bottom: 1,
        right: 1
      };
    },

    set elementRect(_) {}

  }, _$pointer_43.restrict.defaults);

  var restrictRect = {
    start: _$pointer_43.restrict.start,
    set: _$pointer_43.restrict.set,
    defaults: __defaults_44
  };
  _$rect_44.restrictRect = restrictRect;

  var ___default_44 = (0, _$base_39.makeModifier)(restrictRect, 'restrictRect');

  _$rect_44["default"] = ___default_44;
  var _$size_45 = {};
  "use strict";

  Object.defineProperty(_$size_45, "__esModule", {
    value: true
  });
  _$size_45.restrictSize = _$size_45["default"] = void 0;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$rect_83 = require("../../utils/rect.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;
  /* removed: var _$edges_42 = require("./edges.js"); */

  ;
  /* removed: var _$pointer_43 = require("./pointer.js"); */

  ;
  var noMin = {
    width: -Infinity,
    height: -Infinity
  };
  var noMax = {
    width: +Infinity,
    height: +Infinity
  };

  function __start_45(arg) {
    return _$edges_42.restrictEdges.start(arg);
  }

  function __set_45(arg) {
    var interaction = arg.interaction,
        state = arg.state,
        rect = arg.rect,
        edges = arg.edges;
    var options = state.options;

    if (!edges) {
      return;
    }

    var minSize = _$rect_83.tlbrToXywh((0, _$pointer_43.getRestrictionRect)(options.min, interaction, arg.coords)) || noMin;
    var maxSize = _$rect_83.tlbrToXywh((0, _$pointer_43.getRestrictionRect)(options.max, interaction, arg.coords)) || noMax;
    state.options = {
      endOnly: options.endOnly,
      inner: (0, _$extend_73["default"])({}, _$edges_42.restrictEdges.noInner),
      outer: (0, _$extend_73["default"])({}, _$edges_42.restrictEdges.noOuter)
    };

    if (edges.top) {
      state.options.inner.top = rect.bottom - minSize.height;
      state.options.outer.top = rect.bottom - maxSize.height;
    } else if (edges.bottom) {
      state.options.inner.bottom = rect.top + minSize.height;
      state.options.outer.bottom = rect.top + maxSize.height;
    }

    if (edges.left) {
      state.options.inner.left = rect.right - minSize.width;
      state.options.outer.left = rect.right - maxSize.width;
    } else if (edges.right) {
      state.options.inner.right = rect.left + minSize.width;
      state.options.outer.right = rect.left + maxSize.width;
    }

    _$edges_42.restrictEdges.set(arg);

    state.options = options;
  }

  var __defaults_45 = {
    min: null,
    max: null,
    endOnly: false,
    enabled: false
  };
  var restrictSize = {
    start: __start_45,
    set: __set_45,
    defaults: __defaults_45
  };
  _$size_45.restrictSize = restrictSize;

  var ___default_45 = (0, _$base_39.makeModifier)(restrictSize, 'restrictSize');

  _$size_45["default"] = ___default_45;
  var _$rubberband_46 = {};
  "use strict";

  Object.defineProperty(_$rubberband_46, "__esModule", {
    value: true
  });
  Object.defineProperty(_$rubberband_46, "default", {
    enumerable: true,
    get: function get() {
      return _$noop_40["default"];
    }
  });
  /* removed: var _$noop_40 = require("./noop.js"); */

  ;
  var _$pointer_48 = {};
  "use strict";

  Object.defineProperty(_$pointer_48, "__esModule", {
    value: true
  });
  _$pointer_48.snap = _$pointer_48["default"] = void 0;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$getOriginXY_74 = require("../../utils/getOriginXY.js"); */

  ;
  /* removed: var _$hypot_75 = require("../../utils/hypot.js"); */

  ;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;
  /* removed: var _$rect_83 = require("../../utils/rect.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;

  function __start_48(arg) {
    var interaction = arg.interaction,
        interactable = arg.interactable,
        element = arg.element,
        rect = arg.rect,
        state = arg.state,
        startOffset = arg.startOffset;
    var options = state.options;
    var origin = options.offsetWithOrigin ? getOrigin(arg) : {
      x: 0,
      y: 0
    };
    var snapOffset;

    if (options.offset === 'startCoords') {
      snapOffset = {
        x: interaction.coords.start.page.x,
        y: interaction.coords.start.page.y
      };
    } else {
      var offsetRect = (0, _$rect_83.resolveRectLike)(options.offset, interactable, element, [interaction]);
      snapOffset = (0, _$rect_83.rectToXY)(offsetRect) || {
        x: 0,
        y: 0
      };
      snapOffset.x += origin.x;
      snapOffset.y += origin.y;
    }

    var relativePoints = options.relativePoints;
    state.offsets = rect && relativePoints && relativePoints.length ? relativePoints.map(function (relativePoint, index) {
      return {
        index: index,
        relativePoint: relativePoint,
        x: startOffset.left - rect.width * relativePoint.x + snapOffset.x,
        y: startOffset.top - rect.height * relativePoint.y + snapOffset.y
      };
    }) : [(0, _$extend_73["default"])({
      index: 0,
      relativePoint: null
    }, snapOffset)];
  }

  function __set_48(arg) {
    var interaction = arg.interaction,
        coords = arg.coords,
        state = arg.state;
    var options = state.options,
        offsets = state.offsets;
    var origin = (0, _$getOriginXY_74["default"])(interaction.interactable, interaction.element, interaction.prepared.name);
    var page = (0, _$extend_73["default"])({}, coords);
    var targets = [];

    if (!options.offsetWithOrigin) {
      page.x -= origin.x;
      page.y -= origin.y;
    }

    for (var _i = 0; _i < offsets.length; _i++) {
      var _ref;

      _ref = offsets[_i];
      var offset = _ref;
      var relativeX = page.x - offset.x;
      var relativeY = page.y - offset.y;

      for (var index = 0, len = options.targets.length; index < len; index++) {
        var snapTarget = options.targets[index];
        var target = void 0;

        if (_$is_76["default"].func(snapTarget)) {
          target = snapTarget(relativeX, relativeY, interaction._proxy, offset, index);
        } else {
          target = snapTarget;
        }

        if (!target) {
          continue;
        }

        targets.push({
          x: (_$is_76["default"].number(target.x) ? target.x : relativeX) + offset.x,
          y: (_$is_76["default"].number(target.y) ? target.y : relativeY) + offset.y,
          range: _$is_76["default"].number(target.range) ? target.range : options.range,
          source: snapTarget,
          index: index,
          offset: offset
        });
      }
    }

    var closest = {
      target: null,
      inRange: false,
      distance: 0,
      range: 0,
      delta: {
        x: 0,
        y: 0
      }
    };

    for (var _i2 = 0; _i2 < targets.length; _i2++) {
      var _target = targets[_i2];
      var range = _target.range;
      var dx = _target.x - page.x;
      var dy = _target.y - page.y;
      var distance = (0, _$hypot_75["default"])(dx, dy);
      var inRange = distance <= range; // Infinite targets count as being out of range
      // compared to non infinite ones that are in range

      if (range === Infinity && closest.inRange && closest.range !== Infinity) {
        inRange = false;
      }

      if (!closest.target || (inRange // is the closest target in range?
      ? closest.inRange && range !== Infinity // the pointer is relatively deeper in this target
      ? distance / range < closest.distance / closest.range // this target has Infinite range and the closest doesn't
      : range === Infinity && closest.range !== Infinity || // OR this target is closer that the previous closest
      distance < closest.distance : // The other is not in range and the pointer is closer to this target
      !closest.inRange && distance < closest.distance)) {
        closest.target = _target;
        closest.distance = distance;
        closest.range = range;
        closest.inRange = inRange;
        closest.delta.x = dx;
        closest.delta.y = dy;
      }
    }

    if (closest.inRange) {
      coords.x = closest.target.x;
      coords.y = closest.target.y;
    }

    state.closest = closest;
    return closest;
  }

  function getOrigin(arg) {
    var element = arg.interaction.element;
    var optionsOrigin = (0, _$rect_83.rectToXY)((0, _$rect_83.resolveRectLike)(arg.state.options.origin, null, null, [element]));
    var origin = optionsOrigin || (0, _$getOriginXY_74["default"])(arg.interactable, element, arg.interaction.prepared.name);
    return origin;
  }

  var __defaults_48 = {
    range: Infinity,
    targets: null,
    offset: null,
    offsetWithOrigin: true,
    origin: null,
    relativePoints: null,
    endOnly: false,
    enabled: false
  };
  var snap = {
    start: __start_48,
    set: __set_48,
    defaults: __defaults_48
  };
  _$pointer_48.snap = snap;

  var ___default_48 = (0, _$base_39.makeModifier)(snap, 'snap');

  _$pointer_48["default"] = ___default_48;
  var _$size_49 = {};
  "use strict";

  Object.defineProperty(_$size_49, "__esModule", {
    value: true
  });
  _$size_49.snapSize = _$size_49["default"] = void 0;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../../utils/is.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;
  /* removed: var _$pointer_48 = require("./pointer.js"); */

  ;

  function ___slicedToArray_49(arr, i) {
    return ___arrayWithHoles_49(arr) || ___iterableToArrayLimit_49(arr, i) || ___unsupportedIterableToArray_49(arr, i) || ___nonIterableRest_49();
  }

  function ___nonIterableRest_49() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function ___unsupportedIterableToArray_49(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return ___arrayLikeToArray_49(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return ___arrayLikeToArray_49(o, minLen);
  }

  function ___arrayLikeToArray_49(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function ___iterableToArrayLimit_49(arr, i) {
    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function ___arrayWithHoles_49(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function __start_49(arg) {
    var state = arg.state,
        edges = arg.edges;
    var options = state.options;

    if (!edges) {
      return null;
    }

    arg.state = {
      options: {
        targets: null,
        relativePoints: [{
          x: edges.left ? 0 : 1,
          y: edges.top ? 0 : 1
        }],
        offset: options.offset || 'self',
        origin: {
          x: 0,
          y: 0
        },
        range: options.range
      }
    };
    state.targetFields = state.targetFields || [['width', 'height'], ['x', 'y']];

    _$pointer_48.snap.start(arg);

    state.offsets = arg.state.offsets;
    arg.state = state;
  }

  function __set_49(arg) {
    var interaction = arg.interaction,
        state = arg.state,
        coords = arg.coords;
    var options = state.options,
        offsets = state.offsets;
    var relative = {
      x: coords.x - offsets[0].x,
      y: coords.y - offsets[0].y
    };
    state.options = (0, _$extend_73["default"])({}, options);
    state.options.targets = [];

    for (var _i = 0; _i < (options.targets || []).length; _i++) {
      var _ref;

      _ref = (options.targets || [])[_i];
      var snapTarget = _ref;
      var target = void 0;

      if (_$is_76["default"].func(snapTarget)) {
        target = snapTarget(relative.x, relative.y, interaction);
      } else {
        target = snapTarget;
      }

      if (!target) {
        continue;
      }

      for (var _i2 = 0; _i2 < state.targetFields.length; _i2++) {
        var _ref2;

        _ref2 = state.targetFields[_i2];

        var _ref3 = _ref2,
            _ref4 = ___slicedToArray_49(_ref3, 2),
            xField = _ref4[0],
            yField = _ref4[1];

        if (xField in target || yField in target) {
          target.x = target[xField];
          target.y = target[yField];
          break;
        }
      }

      state.options.targets.push(target);
    }

    var returnValue = _$pointer_48.snap.set(arg);

    state.options = options;
    return returnValue;
  }

  var __defaults_49 = {
    range: Infinity,
    targets: null,
    offset: null,
    endOnly: false,
    enabled: false
  };
  var snapSize = {
    start: __start_49,
    set: __set_49,
    defaults: __defaults_49
  };
  _$size_49.snapSize = snapSize;

  var ___default_49 = (0, _$base_39.makeModifier)(snapSize, 'snapSize');

  _$size_49["default"] = ___default_49;
  var _$edges_47 = {};
  "use strict";

  Object.defineProperty(_$edges_47, "__esModule", {
    value: true
  });
  _$edges_47.snapEdges = _$edges_47["default"] = void 0;
  /* removed: var _$clone_68 = require("../../utils/clone.js"); */

  ;
  /* removed: var _$extend_73 = require("../../utils/extend.js"); */

  ;
  /* removed: var _$base_39 = require("../base.js"); */

  ;
  /* removed: var _$size_49 = require("./size.js"); */

  ;
  /**
   * @module modifiers/snapEdges
   *
   * @description
   * This module allows snapping of the edges of targets during resize
   * interactions.
   *
   * @example
   * interact(target).resizable({
   *   snapEdges: {
   *     targets: [interact.snappers.grid({ x: 100, y: 50 })],
   *   },
   * })
   *
   * interact(target).resizable({
   *   snapEdges: {
   *     targets: [
   *       interact.snappers.grid({
   *        top: 50,
   *        left: 50,
   *        bottom: 100,
   *        right: 100,
   *       }),
   *     ],
   *   },
   * })
   */

  function __start_47(arg) {
    var edges = arg.edges;

    if (!edges) {
      return null;
    }

    arg.state.targetFields = arg.state.targetFields || [[edges.left ? 'left' : 'right', edges.top ? 'top' : 'bottom']];
    return _$size_49.snapSize.start(arg);
  }

  var snapEdges = {
    start: __start_47,
    set: _$size_49.snapSize.set,
    defaults: (0, _$extend_73["default"])((0, _$clone_68["default"])(_$size_49.snapSize.defaults), {
      targets: null,
      range: null,
      offset: {
        x: 0,
        y: 0
      }
    })
  };
  _$edges_47.snapEdges = snapEdges;

  var ___default_47 = (0, _$base_39.makeModifier)(snapEdges, 'snapEdges');

  _$edges_47["default"] = ___default_47;
  var _$spring_50 = {};
  "use strict";

  Object.defineProperty(_$spring_50, "__esModule", {
    value: true
  });
  Object.defineProperty(_$spring_50, "default", {
    enumerable: true,
    get: function get() {
      return _$noop_40["default"];
    }
  });
  /* removed: var _$noop_40 = require("./noop.js"); */

  ;
  var _$transform_51 = {};
  "use strict";

  Object.defineProperty(_$transform_51, "__esModule", {
    value: true
  });
  Object.defineProperty(_$transform_51, "default", {
    enumerable: true,
    get: function get() {
      return _$noop_40["default"];
    }
  });
  /* removed: var _$noop_40 = require("./noop.js"); */

  ;
  var _$all_36 = {};
  "use strict";

  Object.defineProperty(_$all_36, "__esModule", {
    value: true
  });
  _$all_36["default"] = void 0;
  /* removed: var _$aspectRatio_37 = require("./aspectRatio.js"); */

  ;
  /* removed: var _$avoid_38 = require("./avoid.js"); */

  ;
  /* removed: var _$edges_42 = require("./restrict/edges.js"); */

  ;
  /* removed: var _$pointer_43 = require("./restrict/pointer.js"); */

  ;
  /* removed: var _$rect_44 = require("./restrict/rect.js"); */

  ;
  /* removed: var _$size_45 = require("./restrict/size.js"); */

  ;
  /* removed: var _$rubberband_46 = require("./rubberband.js"); */

  ;
  /* removed: var _$edges_47 = require("./snap/edges.js"); */

  ;
  /* removed: var _$pointer_48 = require("./snap/pointer.js"); */

  ;
  /* removed: var _$size_49 = require("./snap/size.js"); */

  ;
  /* removed: var _$spring_50 = require("./spring.js"); */

  ;
  /* removed: var _$transform_51 = require("./transform.js"); */

  ;
  /* eslint-disable node/no-extraneous-import */

  var ___default_36 = {
    aspectRatio: _$aspectRatio_37["default"],
    restrictEdges: _$edges_42["default"],
    restrict: _$pointer_43["default"],
    restrictRect: _$rect_44["default"],
    restrictSize: _$size_45["default"],
    snapEdges: _$edges_47["default"],
    snap: _$pointer_48["default"],
    snapSize: _$size_49["default"],
    spring: _$spring_50["default"],
    avoid: _$avoid_38["default"],
    transform: _$transform_51["default"],
    rubberband: _$rubberband_46["default"]
  };
  _$all_36["default"] = ___default_36;
  var _$plugin_41 = {};
  "use strict";

  Object.defineProperty(_$plugin_41, "__esModule", {
    value: true
  });
  _$plugin_41["default"] = void 0;
  /* removed: var _$plugin_65 = require("../snappers/plugin.js"); */

  ;
  /* removed: var _$all_36 = require("./all.js"); */

  ;
  /* removed: var _$base_39 = require("./base.js"); */

  ;
  var __modifiers_41 = {
    id: 'modifiers',
    install: function install(scope) {
      var interact = scope.interactStatic;
      scope.usePlugin(_$base_39["default"]);
      scope.usePlugin(_$plugin_65["default"]);
      interact.modifiers = _$all_36["default"]; // for backwrads compatibility

      for (var type in _$all_36["default"]) {
        var _all$type = _$all_36["default"][type],
            _defaults = _all$type._defaults,
            _methods = _all$type._methods;
        _defaults._methods = _methods;
        scope.defaults.perAction[type] = _defaults;
      }
    }
  };
  var ___default_41 = __modifiers_41;
  _$plugin_41["default"] = ___default_41;
  var _$plugin_52 = {};
  "use strict";

  Object.defineProperty(_$plugin_52, "__esModule", {
    value: true
  });
  _$plugin_52["default"] = void 0;
  var ___default_52 = {};
  _$plugin_52["default"] = ___default_52;
  var _$PointerEvent_54 = {};
  "use strict";

  Object.defineProperty(_$PointerEvent_54, "__esModule", {
    value: true
  });
  _$PointerEvent_54.PointerEvent = _$PointerEvent_54["default"] = void 0;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$BaseEvent_15 = require("../core/BaseEvent.js"); */

  ;

  function ___typeof_54(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_54 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_54 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_54(obj);
  }

  function ___classCallCheck_54(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function ___defineProperties_54(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function ___createClass_54(Constructor, protoProps, staticProps) {
    if (protoProps) ___defineProperties_54(Constructor.prototype, protoProps);
    if (staticProps) ___defineProperties_54(Constructor, staticProps);
    return Constructor;
  }

  function ___inherits_54(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) ___setPrototypeOf_54(subClass, superClass);
  }

  function ___setPrototypeOf_54(o, p) {
    ___setPrototypeOf_54 = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return ___setPrototypeOf_54(o, p);
  }

  function ___createSuper_54(Derived) {
    var hasNativeReflectConstruct = ___isNativeReflectConstruct_54();

    return function () {
      var Super = ___getPrototypeOf_54(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = ___getPrototypeOf_54(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return ___possibleConstructorReturn_54(this, result);
    };
  }

  function ___possibleConstructorReturn_54(self, call) {
    if (call && (___typeof_54(call) === "object" || typeof call === "function")) {
      return call;
    }

    return ___assertThisInitialized_54(self);
  }

  function ___assertThisInitialized_54(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function ___isNativeReflectConstruct_54() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function ___getPrototypeOf_54(o) {
    ___getPrototypeOf_54 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return ___getPrototypeOf_54(o);
  }

  var PointerEvent = /*#__PURE__*/function (_BaseEvent) {
    ___inherits_54(PointerEvent, _BaseEvent);

    var _super = ___createSuper_54(PointerEvent);
    /** */


    function PointerEvent(type, pointer, event, eventTarget, interaction, timeStamp) {
      var _this;

      ___classCallCheck_54(this, PointerEvent);

      _this = _super.call(this, interaction);
      _this.type = void 0;
      _this.originalEvent = void 0;
      _this.pointerId = void 0;
      _this.pointerType = void 0;
      _this["double"] = void 0;
      _this.pageX = void 0;
      _this.pageY = void 0;
      _this.clientX = void 0;
      _this.clientY = void 0;
      _this.dt = void 0;
      _this.eventable = void 0;

      _$pointerUtils_81.pointerExtend(___assertThisInitialized_54(_this), event);

      if (event !== pointer) {
        _$pointerUtils_81.pointerExtend(___assertThisInitialized_54(_this), pointer);
      }

      _this.timeStamp = timeStamp;
      _this.originalEvent = event;
      _this.type = type;
      _this.pointerId = _$pointerUtils_81.getPointerId(pointer);
      _this.pointerType = _$pointerUtils_81.getPointerType(pointer);
      _this.target = eventTarget;
      _this.currentTarget = null;

      if (type === 'tap') {
        var pointerIndex = interaction.getPointerIndex(pointer);
        _this.dt = _this.timeStamp - interaction.pointers[pointerIndex].downTime;
        var interval = _this.timeStamp - interaction.tapTime;
        _this["double"] = !!(interaction.prevTap && interaction.prevTap.type !== 'doubletap' && interaction.prevTap.target === _this.target && interval < 500);
      } else if (type === 'doubletap') {
        _this.dt = pointer.timeStamp - interaction.tapTime;
      }

      return _this;
    }

    ___createClass_54(PointerEvent, [{
      key: "_subtractOrigin",
      value: function _subtractOrigin(_ref) {
        var originX = _ref.x,
            originY = _ref.y;
        this.pageX -= originX;
        this.pageY -= originY;
        this.clientX -= originX;
        this.clientY -= originY;
        return this;
      }
    }, {
      key: "_addOrigin",
      value: function _addOrigin(_ref2) {
        var originX = _ref2.x,
            originY = _ref2.y;
        this.pageX += originX;
        this.pageY += originY;
        this.clientX += originX;
        this.clientY += originY;
        return this;
      }
      /**
       * Prevent the default behaviour of the original Event
       */

    }, {
      key: "preventDefault",
      value: function preventDefault() {
        this.originalEvent.preventDefault();
      }
    }]);

    return PointerEvent;
  }(_$BaseEvent_15["default"]);

  _$PointerEvent_54.PointerEvent = _$PointerEvent_54["default"] = PointerEvent;
  var _$base_55 = {};
  "use strict";

  Object.defineProperty(_$base_55, "__esModule", {
    value: true
  });
  _$base_55["default"] = void 0;
  /* removed: var _$domUtils_71 = require("../utils/domUtils.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$getOriginXY_74 = require("../utils/getOriginXY.js"); */

  ;
  /* removed: var _$PointerEvent_54 = require("./PointerEvent.js"); */

  ;
  var __defaults_55 = {
    holdDuration: 600,
    ignoreFrom: null,
    allowFrom: null,
    origin: {
      x: 0,
      y: 0
    }
  };
  var pointerEvents = {
    id: 'pointer-events/base',
    before: ['inertia', 'modifiers', 'auto-start', 'actions'],
    install: __install_55,
    listeners: {
      'interactions:new': addInteractionProps,
      'interactions:update-pointer': addHoldInfo,
      'interactions:move': moveAndClearHold,
      'interactions:down': function interactionsDown(arg, scope) {
        downAndStartHold(arg, scope);
        fire(arg, scope);
      },
      'interactions:up': function interactionsUp(arg, scope) {
        clearHold(arg);
        fire(arg, scope);
        tapAfterUp(arg, scope);
      },
      'interactions:cancel': function interactionsCancel(arg, scope) {
        clearHold(arg);
        fire(arg, scope);
      }
    },
    PointerEvent: _$PointerEvent_54.PointerEvent,
    fire: fire,
    collectEventTargets: collectEventTargets,
    defaults: __defaults_55,
    types: {
      down: true,
      move: true,
      up: true,
      cancel: true,
      tap: true,
      doubletap: true,
      hold: true
    }
  };

  function fire(arg, scope) {
    var interaction = arg.interaction,
        pointer = arg.pointer,
        event = arg.event,
        eventTarget = arg.eventTarget,
        type = arg.type,
        _arg$targets = arg.targets,
        targets = _arg$targets === void 0 ? collectEventTargets(arg, scope) : _arg$targets;
    var pointerEvent = new _$PointerEvent_54.PointerEvent(type, pointer, event, eventTarget, interaction, scope.now());
    scope.fire('pointerEvents:new', {
      pointerEvent: pointerEvent
    });
    var signalArg = {
      interaction: interaction,
      pointer: pointer,
      event: event,
      eventTarget: eventTarget,
      targets: targets,
      type: type,
      pointerEvent: pointerEvent
    };

    for (var i = 0; i < targets.length; i++) {
      var target = targets[i];

      for (var prop in target.props || {}) {
        pointerEvent[prop] = target.props[prop];
      }

      var origin = (0, _$getOriginXY_74["default"])(target.eventable, target.node);

      pointerEvent._subtractOrigin(origin);

      pointerEvent.eventable = target.eventable;
      pointerEvent.currentTarget = target.node;
      target.eventable.fire(pointerEvent);

      pointerEvent._addOrigin(origin);

      if (pointerEvent.immediatePropagationStopped || pointerEvent.propagationStopped && i + 1 < targets.length && targets[i + 1].node !== pointerEvent.currentTarget) {
        break;
      }
    }

    scope.fire('pointerEvents:fired', signalArg);

    if (type === 'tap') {
      // if pointerEvent should make a double tap, create and fire a doubletap
      // PointerEvent and use that as the prevTap
      var prevTap = pointerEvent["double"] ? fire({
        interaction: interaction,
        pointer: pointer,
        event: event,
        eventTarget: eventTarget,
        type: 'doubletap'
      }, scope) : pointerEvent;
      interaction.prevTap = prevTap;
      interaction.tapTime = prevTap.timeStamp;
    }

    return pointerEvent;
  }

  function collectEventTargets(_ref, scope) {
    var interaction = _ref.interaction,
        pointer = _ref.pointer,
        event = _ref.event,
        eventTarget = _ref.eventTarget,
        type = _ref.type;
    var pointerIndex = interaction.getPointerIndex(pointer);
    var pointerInfo = interaction.pointers[pointerIndex]; // do not fire a tap event if the pointer was moved before being lifted

    if (type === 'tap' && (interaction.pointerWasMoved || // or if the pointerup target is different to the pointerdown target
    !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
      return [];
    }

    var path = _$domUtils_71.getPath(eventTarget);

    var signalArg = {
      interaction: interaction,
      pointer: pointer,
      event: event,
      eventTarget: eventTarget,
      type: type,
      path: path,
      targets: [],
      node: null
    };

    for (var _i = 0; _i < path.length; _i++) {
      var _ref2;

      _ref2 = path[_i];
      var node = _ref2;
      signalArg.node = node;
      scope.fire('pointerEvents:collect-targets', signalArg);
    }

    if (type === 'hold') {
      signalArg.targets = signalArg.targets.filter(function (target) {
        return target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration;
      });
    }

    return signalArg.targets;
  }

  function addInteractionProps(_ref3) {
    var interaction = _ref3.interaction;
    interaction.prevTap = null; // the most recent tap event on this interaction

    interaction.tapTime = 0; // time of the most recent tap event
  }

  function addHoldInfo(_ref4) {
    var down = _ref4.down,
        pointerInfo = _ref4.pointerInfo;

    if (!down && pointerInfo.hold) {
      return;
    }

    pointerInfo.hold = {
      duration: Infinity,
      timeout: null
    };
  }

  function clearHold(_ref5) {
    var interaction = _ref5.interaction,
        pointerIndex = _ref5.pointerIndex;

    if (interaction.pointers[pointerIndex].hold) {
      clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
    }
  }

  function moveAndClearHold(_ref6, scope) {
    var interaction = _ref6.interaction,
        pointer = _ref6.pointer,
        event = _ref6.event,
        eventTarget = _ref6.eventTarget,
        duplicate = _ref6.duplicate;
    var pointerIndex = interaction.getPointerIndex(pointer);

    if (!duplicate && (!interaction.pointerIsDown || interaction.pointerWasMoved)) {
      if (interaction.pointerIsDown) {
        clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
      }

      fire({
        interaction: interaction,
        pointer: pointer,
        event: event,
        eventTarget: eventTarget,
        type: 'move'
      }, scope);
    }
  }

  function downAndStartHold(_ref7, scope) {
    var interaction = _ref7.interaction,
        pointer = _ref7.pointer,
        event = _ref7.event,
        eventTarget = _ref7.eventTarget,
        pointerIndex = _ref7.pointerIndex;
    var timer = interaction.pointers[pointerIndex].hold;

    var path = _$domUtils_71.getPath(eventTarget);

    var signalArg = {
      interaction: interaction,
      pointer: pointer,
      event: event,
      eventTarget: eventTarget,
      type: 'hold',
      targets: [],
      path: path,
      node: null
    };

    for (var _i2 = 0; _i2 < path.length; _i2++) {
      var _ref8;

      _ref8 = path[_i2];
      var node = _ref8;
      signalArg.node = node;
      scope.fire('pointerEvents:collect-targets', signalArg);
    }

    if (!signalArg.targets.length) {
      return;
    }

    var minDuration = Infinity;

    for (var _i3 = 0; _i3 < signalArg.targets.length; _i3++) {
      var _ref9;

      _ref9 = signalArg.targets[_i3];
      var target = _ref9;
      var holdDuration = target.eventable.options.holdDuration;

      if (holdDuration < minDuration) {
        minDuration = holdDuration;
      }
    }

    timer.duration = minDuration;
    timer.timeout = setTimeout(function () {
      fire({
        interaction: interaction,
        eventTarget: eventTarget,
        pointer: pointer,
        event: event,
        type: 'hold'
      }, scope);
    }, minDuration);
  }

  function tapAfterUp(_ref10, scope) {
    var interaction = _ref10.interaction,
        pointer = _ref10.pointer,
        event = _ref10.event,
        eventTarget = _ref10.eventTarget;

    if (!interaction.pointerWasMoved) {
      fire({
        interaction: interaction,
        eventTarget: eventTarget,
        pointer: pointer,
        event: event,
        type: 'tap'
      }, scope);
    }
  }

  function __install_55(scope) {
    scope.pointerEvents = pointerEvents;
    scope.defaults.actions.pointerEvents = pointerEvents.defaults;
    (0, _$extend_73["default"])(scope.actions.phaselessTypes, pointerEvents.types);
  }

  var ___default_55 = pointerEvents;
  _$base_55["default"] = ___default_55;
  var _$holdRepeat_56 = {};
  "use strict";

  Object.defineProperty(_$holdRepeat_56, "__esModule", {
    value: true
  });
  _$holdRepeat_56["default"] = void 0;
  /* removed: var _$base_55 = require("./base.js"); */

  ;

  function __install_56(scope) {
    scope.usePlugin(_$base_55["default"]);
    var pointerEvents = scope.pointerEvents; // don't repeat by default

    pointerEvents.defaults.holdRepeatInterval = 0;
    pointerEvents.types.holdrepeat = scope.actions.phaselessTypes.holdrepeat = true;
  }

  function onNew(_ref) {
    var pointerEvent = _ref.pointerEvent;

    if (pointerEvent.type !== 'hold') {
      return;
    }

    pointerEvent.count = (pointerEvent.count || 0) + 1;
  }

  function onFired(_ref2, scope) {
    var interaction = _ref2.interaction,
        pointerEvent = _ref2.pointerEvent,
        eventTarget = _ref2.eventTarget,
        targets = _ref2.targets;

    if (pointerEvent.type !== 'hold' || !targets.length) {
      return;
    } // get the repeat interval from the first eventable


    var interval = targets[0].eventable.options.holdRepeatInterval; // don't repeat if the interval is 0 or less

    if (interval <= 0) {
      return;
    } // set a timeout to fire the holdrepeat event


    interaction.holdIntervalHandle = setTimeout(function () {
      scope.pointerEvents.fire({
        interaction: interaction,
        eventTarget: eventTarget,
        type: 'hold',
        pointer: pointerEvent,
        event: pointerEvent
      }, scope);
    }, interval);
  }

  function endHoldRepeat(_ref3) {
    var interaction = _ref3.interaction; // set the interaction's holdStopTime property
    // to stop further holdRepeat events

    if (interaction.holdIntervalHandle) {
      clearInterval(interaction.holdIntervalHandle);
      interaction.holdIntervalHandle = null;
    }
  }

  var holdRepeat = {
    id: 'pointer-events/holdRepeat',
    install: __install_56,
    listeners: ['move', 'up', 'cancel', 'endall'].reduce(function (acc, enderTypes) {
      acc["pointerEvents:".concat(enderTypes)] = endHoldRepeat;
      return acc;
    }, {
      'pointerEvents:new': onNew,
      'pointerEvents:fired': onFired
    })
  };
  var ___default_56 = holdRepeat;
  _$holdRepeat_56["default"] = ___default_56;
  var _$interactableTargets_57 = {};
  "use strict";

  Object.defineProperty(_$interactableTargets_57, "__esModule", {
    value: true
  });
  _$interactableTargets_57["default"] = void 0;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;

  function __install_57(scope) {
    var Interactable = scope.Interactable;
    Interactable.prototype.pointerEvents = pointerEventsMethod;
    var __backCompatOption = Interactable.prototype._backCompatOption;

    Interactable.prototype._backCompatOption = function (optionName, newValue) {
      var ret = __backCompatOption.call(this, optionName, newValue);

      if (ret === this) {
        this.events.options[optionName] = newValue;
      }

      return ret;
    };
  }

  function pointerEventsMethod(options) {
    (0, _$extend_73["default"])(this.events.options, options);
    return this;
  }

  var plugin = {
    id: 'pointer-events/interactableTargets',
    install: __install_57,
    listeners: {
      'pointerEvents:collect-targets': function pointerEventsCollectTargets(_ref, scope) {
        var targets = _ref.targets,
            node = _ref.node,
            type = _ref.type,
            eventTarget = _ref.eventTarget;
        scope.interactables.forEachMatch(node, function (interactable) {
          var eventable = interactable.events;
          var options = eventable.options;

          if (eventable.types[type] && eventable.types[type].length && interactable.testIgnoreAllow(options, node, eventTarget)) {
            targets.push({
              node: node,
              eventable: eventable,
              props: {
                interactable: interactable
              }
            });
          }
        });
      },
      'interactable:new': function interactableNew(_ref2) {
        var interactable = _ref2.interactable;

        interactable.events.getRect = function (element) {
          return interactable.getRect(element);
        };
      },
      'interactable:set': function interactableSet(_ref3, scope) {
        var interactable = _ref3.interactable,
            options = _ref3.options;
        (0, _$extend_73["default"])(interactable.events.options, scope.pointerEvents.defaults);
        (0, _$extend_73["default"])(interactable.events.options, options.pointerEvents || {});
      }
    }
  };
  var ___default_57 = plugin;
  _$interactableTargets_57["default"] = ___default_57;
  var _$plugin_58 = {};
  "use strict";

  Object.defineProperty(_$plugin_58, "__esModule", {
    value: true
  });
  Object.defineProperty(_$plugin_58, "holdRepeat", {
    enumerable: true,
    get: function get() {
      return _$holdRepeat_56["default"];
    }
  });
  Object.defineProperty(_$plugin_58, "interactableTargets", {
    enumerable: true,
    get: function get() {
      return _$interactableTargets_57["default"];
    }
  });
  _$plugin_58.pointerEvents = _$plugin_58["default"] = void 0;
  /* removed: var _$base_55 = require("./base.js"); */

  ;
  _$plugin_58.pointerEvents = _$base_55;
  /* removed: var _$holdRepeat_56 = require("./holdRepeat.js"); */

  ;
  /* removed: var _$interactableTargets_57 = require("./interactableTargets.js"); */

  ;
  var __plugin_58 = {
    id: 'pointer-events',
    install: function install(scope) {
      scope.usePlugin(_$base_55);
      scope.usePlugin(_$holdRepeat_56["default"]);
      scope.usePlugin(_$interactableTargets_57["default"]);
    }
  };
  var ___default_58 = __plugin_58;
  _$plugin_58["default"] = ___default_58;
  var _$plugin_59 = {};
  "use strict";

  Object.defineProperty(_$plugin_59, "__esModule", {
    value: true
  });
  _$plugin_59["default"] = void 0;
  var ___default_59 = {};
  _$plugin_59["default"] = ___default_59;
  var _$plugin_60 = {};
  "use strict";

  Object.defineProperty(_$plugin_60, "__esModule", {
    value: true
  });
  _$plugin_60.install = __install_60;
  _$plugin_60["default"] = void 0;
  /* removed: var _$arr_66 = require("../utils/arr.js"); */

  ;
  /* removed: var _$extend_73 = require("../utils/extend.js"); */

  ;
  /* removed: var _$is_76 = require("../utils/is.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$rect_83 = require("../utils/rect.js"); */

  ;

  function __install_60(scope) {
    var Interactable = scope.Interactable;
    scope.actions.phases.reflow = true;
    /**
     * ```js
     * const interactable = interact(target)
     * const drag = { name: drag, axis: 'x' }
     * const resize = { name: resize, edges: { left: true, bottom: true }
     *
     * interactable.reflow(drag)
     * interactable.reflow(resize)
     * ```
     *
     * Start an action sequence to re-apply modifiers, check drops, etc.
     *
     * @param { Object } action The action to begin
     * @param { string } action.name The name of the action
     * @returns { Promise } A promise that resolves to the `Interactable` when actions on all targets have ended
     */

    Interactable.prototype.reflow = function (action) {
      return reflow(this, action, scope);
    };
  }

  function reflow(interactable, action, scope) {
    var elements = _$is_76["default"].string(interactable.target) ? _$arr_66.from(interactable._context.querySelectorAll(interactable.target)) : [interactable.target]; // tslint:disable-next-line variable-name

    var Promise = scope.window.Promise;
    var promises = Promise ? [] : null;

    var _loop = function _loop() {
      _ref = elements[_i];
      var element = _ref;
      var rect = interactable.getRect(element);

      if (!rect) {
        return "break";
      }

      var runningInteraction = _$arr_66.find(scope.interactions.list, function (interaction) {
        return interaction.interacting() && interaction.interactable === interactable && interaction.element === element && interaction.prepared.name === action.name;
      });

      var reflowPromise = void 0;

      if (runningInteraction) {
        runningInteraction.move();

        if (promises) {
          reflowPromise = runningInteraction._reflowPromise || new Promise(function (resolve) {
            runningInteraction._reflowResolve = resolve;
          });
        }
      } else {
        var xywh = (0, _$rect_83.tlbrToXywh)(rect);
        var coords = {
          page: {
            x: xywh.x,
            y: xywh.y
          },
          client: {
            x: xywh.x,
            y: xywh.y
          },
          timeStamp: scope.now()
        };

        var event = _$pointerUtils_81.coordsToEvent(coords);

        reflowPromise = startReflow(scope, interactable, element, action, event);
      }

      if (promises) {
        promises.push(reflowPromise);
      }
    };

    for (var _i = 0; _i < elements.length; _i++) {
      var _ref;

      var _ret = _loop();

      if (_ret === "break") break;
    }

    return promises && Promise.all(promises).then(function () {
      return interactable;
    });
  }

  function startReflow(scope, interactable, element, action, event) {
    var interaction = scope.interactions["new"]({
      pointerType: 'reflow'
    });
    var signalArg = {
      interaction: interaction,
      event: event,
      pointer: event,
      eventTarget: element,
      phase: 'reflow'
    };
    interaction.interactable = interactable;
    interaction.element = element;
    interaction.prepared = (0, _$extend_73["default"])({}, action);
    interaction.prevEvent = event;
    interaction.updatePointer(event, event, element, true);

    interaction._doPhase(signalArg);

    var Promise = scope.window.Promise;
    var reflowPromise = Promise ? new Promise(function (resolve) {
      interaction._reflowResolve = resolve;
    }) : null;
    interaction._reflowPromise = reflowPromise;
    interaction.start(action, interactable, element);

    if (interaction._interacting) {
      interaction.move(signalArg);
      interaction.end(event);
    } else {
      interaction.stop();
    }

    interaction.removePointer(event, event);
    interaction.pointerIsDown = false;
    return reflowPromise;
  }

  var ___default_60 = {
    id: 'reflow',
    install: __install_60,
    listeners: {
      // remove completed reflow interactions
      'interactions:stop': function interactionsStop(_ref2, scope) {
        var interaction = _ref2.interaction;

        if (interaction.pointerType === 'reflow') {
          if (interaction._reflowResolve) {
            interaction._reflowResolve();
          }

          _$arr_66.remove(scope.interactions.list, interaction);
        }
      }
    }
  };
  _$plugin_60["default"] = ___default_60;
  var _$displace_69 = {};
  "use strict";

  Object.defineProperty(_$displace_69, "__esModule", {
    value: true
  });
  _$displace_69["default"] = void 0;
  var ___default_69 = {};
  _$displace_69["default"] = ___default_69;
  var _$exchange_72 = {};
  "use strict";

  Object.defineProperty(_$exchange_72, "__esModule", {
    value: true
  });
  _$exchange_72.exchange = void 0;
  var exchange = {};
  _$exchange_72.exchange = exchange;
  var _$plugin_85 = {};
  "use strict";

  Object.defineProperty(_$plugin_85, "__esModule", {
    value: true
  });
  _$plugin_85["default"] = void 0;
  var ___default_85 = {};
  _$plugin_85["default"] = ___default_85;
  var _$interactjs_34 = {
    exports: {}
  };
  "use strict";

  Object.defineProperty(_$interactjs_34.exports, "__esModule", {
    value: true
  });
  _$interactjs_34.exports["default"] = void 0;
  /* removed: var _$plugin_5 = require("../actions/plugin.js"); */

  ;
  /* removed: var _$plugin_7 = require("../arrange/plugin.js"); */

  ;
  /* removed: var _$plugin_8 = require("../auto-scroll/plugin.js"); */

  ;
  /* removed: var _$plugin_13 = require("../auto-start/plugin.js"); */

  ;
  /* removed: var _$plugin_14 = require("../clone/plugin.js"); */

  ;
  /* removed: var _$interactablePreventDefault_25 = require("../core/interactablePreventDefault.js"); */

  ;
  /* removed: var _$plugin_30 = require("../dev-tools/plugin.js"); */

  ;
  /* removed: var _$plugin_31 = require("../feedback/plugin.js"); */

  ;
  /* removed: var _$plugin_32 = require("../inertia/plugin.js"); */

  ;
  /* removed: var _$interact_33 = require("../interact/index.js"); */

  ;
  /* removed: var _$plugin_41 = require("../modifiers/plugin.js"); */

  ;
  /* removed: var _$plugin_52 = require("../multi-target/plugin.js"); */

  ;
  /* removed: var _$plugin_53 = require("../offset/plugin.js"); */

  ;
  /* removed: var _$plugin_58 = require("../pointer-events/plugin.js"); */

  ;
  /* removed: var _$plugin_59 = require("../react/plugin.js"); */

  ;
  /* removed: var _$plugin_60 = require("../reflow/plugin.js"); */

  ;
  /* removed: var _$displace_69 = require("../utils/displace.js"); */

  ;
  /* removed: var _$exchange_72 = require("../utils/exchange.js"); */

  ;
  /* removed: var _$pointerUtils_81 = require("../utils/pointerUtils.js"); */

  ;
  /* removed: var _$plugin_85 = require("../vue/plugin.js"); */

  ;

  function ___typeof_34(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_34 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_34 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_34(obj);
  }

  _$interact_33["default"].use(_$plugin_52["default"]);

  _$interact_33["default"].use(_$interactablePreventDefault_25["default"]);

  _$interact_33["default"].use(_$plugin_53["default"]); // interaction element cloning


  _$interact_33["default"].use(_$plugin_14["default"]); // sortable and swappable


  _$interact_33["default"].use(_$plugin_7["default"]); // pointerEvents


  _$interact_33["default"].use(_$plugin_58["default"]); // inertia


  _$interact_33["default"].use(_$plugin_32["default"]); // snap, resize, etc.


  _$interact_33["default"].use(_$plugin_41["default"]); // autoStart, hold


  _$interact_33["default"].use(_$plugin_13["default"]); // drag and drop, resize, gesture


  _$interact_33["default"].use(_$plugin_5["default"]); // autoScroll


  _$interact_33["default"].use(_$plugin_8["default"]); // reflow


  _$interact_33["default"].use(_$plugin_60["default"]);

  _$interact_33["default"].use(_$plugin_31["default"]);

  _$interact_33["default"].use(_$plugin_85["default"]);

  _$interact_33["default"].use(_$plugin_59["default"]);

  _$interact_33["default"].__utils = {
    exchange: _$exchange_72.exchange,
    displace: _$displace_69,
    pointer: _$pointerUtils_81
  }; // eslint-disable-next-line no-undef

  if ("development" !== 'production') {
    _$interact_33["default"].use(_$plugin_30["default"]);
  }

  var ___default_34 = _$interact_33["default"];
  _$interactjs_34.exports["default"] = ___default_34;

  if (("object" === "undefined" ? "undefined" : ___typeof_34(_$interactjs_34)) === 'object' && !!_$interactjs_34) {
    try {
      _$interactjs_34.exports = _$interact_33["default"];
    } catch (_unused) {}
  }

  _$interact_33["default"]["default"] = _$interact_33["default"];
  _$interactjs_34 = _$interactjs_34.exports;
  var _$index_86 = {
    exports: {}
  };
  "use strict";

  Object.defineProperty(_$index_86.exports, "__esModule", {
    value: true
  });
  _$index_86.exports["default"] = void 0;
  /* removed: var _$interactjs_34 = require("@interactjs/interactjs/index"); */

  ;

  function ___typeof_86(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      ___typeof_86 = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      ___typeof_86 = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return ___typeof_86(obj);
  }

  var ___default_86 = _$interactjs_34["default"];
  _$index_86.exports["default"] = ___default_86;

  if (("object" === "undefined" ? "undefined" : ___typeof_86(_$index_86)) === 'object' && !!_$index_86) {
    try {
      _$index_86.exports = _$interactjs_34["default"];
    } catch (_unused) {}
  }

  _$interactjs_34["default"]["default"] = _$interactjs_34["default"];
  _$index_86 = _$index_86.exports;
  return _$index_86;
}); //# sourceMappingURL=interact.js.map