{"version":3,"sources":["webpack:///app-0570f0c22e2788730def.js","webpack:///webpack/bootstrap e9656664e1aa4c5c2276","webpack:///./app/javascript/constants/settings.js","webpack:///./app/javascript/global/subnav.js","webpack:///./app/javascript/global/flag.js","webpack:///./app/javascript/constants/copy.js","webpack:///./app/javascript/utils/slider.js","webpack:///./app/javascript/packs/app.js","webpack:///./app/javascript/global/nav.js","webpack:///./app/javascript/utils/helpers.js","webpack:///./app/javascript/global/popup.js","webpack:///./app/javascript/global/pagination.js","webpack:///./app/javascript/global/fader.js","webpack:///./app/javascript/global/recirculation.js","webpack:///./app/javascript/homepage/index.js","webpack:///./node_modules/interact.js/interact.js","webpack:///./app/javascript/utils/interact.js","webpack:///./app/javascript/articles/index.js","webpack:///./app/javascript/articles/galleries/index.js","webpack:///./app/javascript/articles/lightbox/index.js","webpack:///./app/javascript/articles/museboard/index.js","webpack:///./app/javascript/disciplines/index.js","webpack:///./app/javascript/musts/index.js","webpack:///./app/javascript/creators/index.js","webpack:///./app/javascript/terms/index.js","webpack:///./app/javascript/about/index.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__webpack_exports__","GLOBALS","LIGHTBOX_SLIDER","MUSTS_SLIDER_HOMEPAGE","MERCH_SLIDER_HOMEPAGE","RECIRCULATION_SLIDER","breakpoints","small","tablet","desktop","transition","infinite","slidesToShow","slidesToScroll","adaptiveHeight","prevArrow","$","nextArrow","speed","responsive","breakpoint","settings","dots","arrows","_classCallCheck","instance","Constructor","TypeError","__WEBPACK_IMPORTED_MODULE_0_constants_settings__","_createClass","defineProperties","target","props","length","descriptor","writable","key","protoProps","staticProps","Subnav","elems","_this","this","options","slice","document","getElementsByClassName","map","option","addEventListener","e","showSection","first","trigger","deepLink","value","hash","window","location","replace","_this2","active","dataset","removeClass","addClass","fadeOut","fadeIn","__WEBPACK_IMPORTED_MODULE_0__utils_helpers__","Flag","slug","activator","activeClass","closer","getElementById","activators","classList","contains","MM","User","isLoggedIn","toggleFlag","Login","openFlag","closers","close","closeFlag","$site","remove","add","LOADER","loadMore","loading","initSlider","targetEl","not","slick","__WEBPACK_IMPORTED_MODULE_0_global_nav__","__WEBPACK_IMPORTED_MODULE_1_global_flag__","__WEBPACK_IMPORTED_MODULE_2_global_popup__","__WEBPACK_IMPORTED_MODULE_3_global_pagination__","__WEBPACK_IMPORTED_MODULE_4_global_fader__","__WEBPACK_IMPORTED_MODULE_5_global_recirculation__","__WEBPACK_IMPORTED_MODULE_6_homepage__","__WEBPACK_IMPORTED_MODULE_7_articles__","__WEBPACK_IMPORTED_MODULE_8_articles_museboard__","__WEBPACK_IMPORTED_MODULE_9_disciplines__","__WEBPACK_IMPORTED_MODULE_10_musts__","__WEBPACK_IMPORTED_MODULE_11_creators__","__WEBPACK_IMPORTED_MODULE_12_terms__","__WEBPACK_IMPORTED_MODULE_13_about__","App","$home","$article","Nav","Search","Popup","Pagination","Fader","Recirculation","Homepage","Articles","Disciplines","Musts","Terms","Creators","About","Museboard","type","__WEBPACK_IMPORTED_MODULE_0__constants_settings__","nav","$top","$logout","$header","$overlay","$sidenav","top","menu","forEach","f","checkMenu","checkSidenav","menuInterval","setInterval","clearInterval","openMenu","closeMenu","override","arguments","undefined","update","lastPos","pageYOffset","currentPos","direction","menuOpen","updateMenu","isMenuOpen","scrollDirection","stop","hide","scrollTop","documentElement","body","parentNode","docHeight","scrollHeight","footerAd","clientHeight","footer","winHeight","innerHeight","footerTop","style","transform","animate","slugify","text","toLowerCase","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","superClass","create","constructor","setPrototypeOf","__proto__","__WEBPACK_IMPORTED_MODULE_0_global_flag__","_get","receiver","Function","desc","getOwnPropertyDescriptor","parent","getPrototypeOf","_Flag","popup","$newsletter","delay","check","localStorage","getItem","setTimeout","scrollCheck","setItem","__WEBPACK_IMPORTED_MODULE_1_constants_copy__","on","preventDefault","lastTarget","paginate","loadGrid","data","btn","page","console","warn","query","exclude","tags","terms","creators","must_type","mtype","mlocation","prop","href","ajax","url","dataType","done","parseInt","history","pushState","each","$that","eq","Math","max","selector","$targets","querySelectorAll","fadeElements","threshold","$target","offset","jsFaderDelay","__WEBPACK_IMPORTED_MODULE_0_utils_slider__","__WEBPACK_IMPORTED_MODULE_1_constants_settings__","gallery","g","__WEBPACK_IMPORTED_MODULE_0_interact_js__","__WEBPACK_IMPORTED_MODULE_0_interact_js___default","__WEBPACK_IMPORTED_MODULE_1__utils_slider__","__WEBPACK_IMPORTED_MODULE_2__constants_settings__","__WEBPACK_IMPORTED_MODULE_3__utils_interact__","__WEBPACK_IMPORTED_MODULE_4_global_subnav__","home","wrapper","mustsSlider","setupMustsSlider","merchSlider","setupMerchSlider","activeMuseboard","setupMuseboardInteract","museboardsSubnav","$slickEl","find","draggable","onstart","onmove","inertia","restrict","restriction","elementRect","left","bottom","right","resizable","preserveAspectRatio","invert","edges","resize","originalEvent","changedTouches","realWindow","blank","isElement","_window","getWindow","test","Element","nodeType","nodeName","isWindow","thing","Window","isDocFrag","DocumentFragment","isArray","isObject","isFunction","splice","isNumber","isBool","isString","trySelector","querySelector","extend","dest","source","pointerExtend","deprecated","vendor","prefixedPropREs","indexOf","copyCoords","src","x","y","client","timeStamp","setEventXY","targetObj","pointers","interaction","pointer","pointerAverage","getPageXY","tmpXY","getClientXY","Date","getTime","setEventDeltas","prev","cur","dt","hypot","vx","vy","isNativePointer","Event","supportsTouch","Touch","getXY","xy","isOperaMobile","scrollX","scrollY","getScrollXY","win","scrollLeft","getPointerId","pointerId","identifier","getActualElement","element","SVGElementInstance","correspondingUseElement","node","rootNode","ownerDocument","defaultView","parentWindow","getElementClientRect","clientRect","SVGElement","getBoundingClientRect","getClientRects","width","height","getElementRect","isIOS7","scroll","getTouchPair","event","touches","average","pageX","pageY","clientX","clientY","screenX","screenY","touchBBox","minX","min","minY","touchDistance","deltaSource","defaultOptions","sourceX","sourceY","dx","dy","touchAngle","prevAngle","angle","atan","PI","dr","drClamped","getOriginXY","interactable","origin","parentElement","getRect","closest","_getQBezierValue","t","p1","p2","p3","iT","getQuadraticCurvePoint","startX","startY","cpX","cpY","endX","endY","position","easeOutQuad","b","nodeContains","child","matchesSelector","host","inContext","_context","testIgnore","interactableElement","ignoreFrom","matchesUpTo","testAllow","allowFrom","checkAxis","axis","thisAxis","drag","checkSnap","action","snap","enabled","checkRestrict","checkAutoScroll","autoScroll","withinInteractionLimit","maxActions","maxPerElement","activeInteractions","targetCount","targetElementCount","len","interactions","otherAction","prepared","interacting","maxInteractions","indexOfDeepestElement","elements","dropzone","deepestZone","index","deepestZoneParents","dropzoneParents","unshift","HTMLElement","SVGSVGElement","ownerSVGElement","parents","lastChild","previousSibling","Interaction","dropTarget","dropElement","prevDropTarget","prevDropElement","matches","matchElements","inertiaStatus","smoothEnd","ending","startEvent","upCoords","xe","ye","sx","sy","t0","vx0","vys","duration","resumeDx","resumeDy","lambda_v0","one_ve_v0","bind","boundInertiaFrame","inertiaFrame","boundSmoothEndFrame","smoothEndFrame","that","activeDrops","dropzones","rects","pointerIds","downTargets","downTimes","holdTimers","prevCoords","curCoords","startCoords","pointerDelta","downEvent","downPointer","_eventTarget","_curEventTarget","prevEvent","tapTime","prevTap","startOffset","restrictOffset","snapOffsets","gesture","start","startDistance","prevDistance","distance","scale","startAngle","snapStatus","realX","realY","snappedX","snappedY","targets","locked","changed","restrictStatus","restrictedX","restrictedY","restricted","pointerIsDown","pointerWasMoved","gesturing","dragging","resizing","resizeAxes","mouse","push","getInteractionFromPointer","eventType","eventTarget","mouseEvent","pointerType","id","allowResume","supportsPointerEvent","doOnInteractions","method","path","curEventTarget","currentTarget","prevTouchTime","_updateEventTargets","InteractEvent","phase","related","starting","coords","relativePoints","range","x0","y0","clientX0","clientY0","ctrlKey","altKey","shiftKey","metaKey","button","buttons","detail","relatedTarget","zeroResumeDelta","square","axes","box","ds","da","prevScale","velocityX","velocityY","atan2","up","down","swipe","velocity","preventOriginalDefault","getActionCursor","cursor","actionCursors","cursorKey","edgeNames","checkResizeEdge","rect","margin","defaultActionChecker","resizeEdges","shouldResize","actionIsEnabled","resizeOptions","edge","validateAction","actionName","delegateListener","useCapture","fakeEvent","delegated","delegatedEvents","selectors","context","contexts","listeners","j","delegateUseCapture","interact","interactables","Interactable","_element","_iEvents","Node","events","pEventTypes","pointerDown","move","pointerHover","_doc","documents","listenToDocument","set","warnOnce","message","warned","apply","endAllInteractions","pointerEnd","doc","PointerEvent","MSPointerEvent","over","out","cancel","selectorDown","pointerMove","pointerOver","pointerOut","pointerUp","pointerCancel","autoScrollMove","frameElement","parentDoc","error","windowParentError","checkAndPreventDefault","useAttachEvent","currentAction","array","nodeList","ie8MatchesSelector","prefixedMatchesSelector","limit","el","createTextNode","wrap","sqrt","dynamicDrop","base","accept","actionChecker","styleCursor","dropChecker","manualStart","Infinity","drop","overlap","NaN","perAction","endOnly","offsets","container","resistance","minSpeed","endSpeed","smoothEndDuration","_holdDuration","now","dtx","prevTimeX","dty","prevTimeY","scrollBy","isScrolling","cancelFrame","reqFrame","DocumentTouch","navigator","userAgent","pointerMoveTolerance","all","atob","resizex","resizey","resizexy","resizetop","resizeleft","resizebottom","resizeright","resizetopleft","resizebottomright","resizetopright","resizebottomleft","wheelEvent","eventTypes","globalEvents","appName","match","platform","appVersion","requestAnimationFrame","cancelAnimationFrame","listener","elementIndex","typeCount","attachedListeners","supplied","wrapped","useCount","ret","listenerIndex","immediatePropagationStopped","srcElement","preventDef","stopPropagation","stopProp","stopImmediatePropagation","stopImmProp","addEvent","Boolean","removeEvent","returnValue","cancelBubble","_elements","_targets","_attachedListeners","webkit","ptr","pushCurMatches","curMatches","curMatchElements","prevTargetElement","addPointer","elementInteractable","elementAction","getAction","forEachSelector","validateSelector","pushMatches","eventCopy","pointerIndex","pointerHold","collectEventTargets","forceAction","newAction","setModifications","preEnd","shouldMove","shouldSnap","shouldRestrict","setSnapping","setRestriction","setStartOffsets","snapOffset","pageUp","clientUp","inertiaPosition","recordPointer","duplicateMove","clearTimeout","absX","abs","absY","targetAxis","thisInteraction","getDraggable","selectorInteractable","dragStart","dragEvent","fire","setActiveDrops","dropEvents","getDropEvents","activate","fireActiveDrops","dragMove","draggableElement","getDrop","leave","enter","resizeStart","resizeEvent","startRect","linkedEdges","_linkedEdges","resizeStartAspectRatio","resizeRects","current","previous","delta","deltaRect","resizeMove","invertible","originalEdges","swap","gestureStart","gestureEvent","gestureMove","isNaN","removePointer","ie8Dblclick","endEvent","inertiaOptions","pointerSpeed","inertiaPossible","endSnap","endRestrict","snapRestrict","vy0","v0","calcInertia","statusObject","useStatusXY","modifiedXe","modifiedYe","deactivate","collectDrops","drops","dropElements","currentElement","prevElement","dragElement","possibleDrops","validDrops","dropCheck","dropIndex","pointerEvent","dragLeave","prevDropzone","dragEnter","dragmove","clearTargets","lambda","te","progress","exp","quadPoint","collectSelectors","els","isSet","firePointers","interval","createNewDoubleTap","originalPointer","double","propagationStopped","doubleTap","matchElement","pageCoords","status","relIndex","relative","inRange","snapChanged","prevent","inertiaDur","log","innerWidth","interactionListeners","indexOfElement","callback","setOnEvents","phases","ondrop","ondropactivate","ondropdeactivate","ondragenter","ondragleave","ondropmove","onend","oninertiastart","setPerAction","checker","dropped","dropOverlap","horizontal","vertical","dragRect","cx","cy","newValue","squareResize","gesturable","actions","setOptions","thisOption","mode","createSnapGrid","gridOffset","grid","anchors","paths","elementOrigin","allActions","rectChecker","iEvent","onEvent","search","trim","split","off","eventList","matchFound","fn","useCap","methods","perActions","setting","unset","enableDragging","enableResizing","enableGesturing","debug","downTime","getPointerAverage","getTouchBBox","getTouchDistance","getTouchAngle","newvalue","offsetX","offsetY","gridx","round","gridy","lastTime","vendors","currTime","timeToCall","manageZIndex","lastZ","zIndex","dragHandler","newX","newY","children","parseFloat","getAttribute","webkitTransform","setAttribute","resizeHandler","__WEBPACK_IMPORTED_MODULE_1_articles_galleries__","__WEBPACK_IMPORTED_MODULE_2_articles_lightbox__","articles","$articles","$discipline","$galleryEls","Galleries","Lightbox","initProgressBar","$progress","updateProgressBar","viewHeight","docLength","totalDistance","percentage","galleries","initGallery","$this","$center","siblings","appendDots","click","hasClass","$focusSlider","slickIndex","initializers","destroyers","lightboxEl","lightboxGalleryEl","slickGallery","isActive","widthRequirement","buildInitializers","initializer","buildGallery","openLightbox","destroyer","destroyGallery","closeLightbox","$lightboxGalleryEl","lightboxGallery","cloneNode","replaceChild","_this3","siblingNodeList","galleryEls","filter","hasAttribute","targetIndex","lightboxGalleryEls","concat","hideArrows","showArrows","childEls","slide","createElement","imgWrapper","imgEl","imageUrl","appendChild","imgCaption","captionClone","buildDestroyers","findTargetImage","refIndex","imgBaseClass","removeClassName","className","paginators","refBlocks","references","refsToggle","toggle","refsList","paginator","refBlockIndex","targetBlock","block","ref","targetRef","targetImage","hoverImageOn","hoverImageOff","deselectReference","selectReference","img","disciplines","$disciplines","musts","$musts","__WEBPACK_IMPORTED_MODULE_0_global_subnav__","$nav","$letters","$name","$results","$creators","$letter","offsetTop","$creator","innerHTML","MobileSubnav","$def","$terms","$term","definition"],"mappings":"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","file":"app-0570f0c22e2788730def.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"/packs/\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 5);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return GLOBALS; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return LIGHTBOX_SLIDER; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"d\", function() { return MUSTS_SLIDER_HOMEPAGE; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return MERCH_SLIDER_HOMEPAGE; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"e\", function() { return RECIRCULATION_SLIDER; });\nvar GLOBALS = {\n  breakpoints: {\n    small: 746,\n    tablet: 1024,\n    desktop: 1440\n  },\n  transition: 400\n};\n\n//Lightbox Slider Settings\nvar LIGHTBOX_SLIDER = {\n  infinite: true,\n  slidesToShow: 1,\n  slidesToScroll: 1,\n  adaptiveHeight: false,\n  prevArrow: $('.lightbox-prev-arrow'),\n  nextArrow: $('.lightbox-next-arrow')\n};\n\n//Musts Slider Homepage Settings\nvar MUSTS_SLIDER_HOMEPAGE = {\n  infinite: true,\n  speed: 600,\n  slidesToShow: 3,\n  slidesToScroll: 1,\n  prevArrow: $('.musts-prev-arrow'),\n  nextArrow: $('.musts-next-arrow'),\n  responsive: [{\n    breakpoint: 832,\n    settings: {\n      slidesToShow: 1,\n      slidesToScroll: 1\n    }\n  }]\n};\n\nvar MERCH_SLIDER_HOMEPAGE = {\n  infinite: true,\n  speed: 600,\n  slidesToShow: 3,\n  slidesToScroll: 1,\n  prevArrow: $('.merch-prev-arrow'),\n  nextArrow: $('.merch-next-arrow'),\n  responsive: [{\n    breakpoint: 832,\n    settings: {\n      slidesToShow: 1,\n      slidesToScroll: 1\n    }\n  }]\n};\n\n// export const CONTRIBUTIONS_SLIDER = {\n//   infinite: true,\n//   dots: true,\n//   arrows: false,\n// };\n\nvar RECIRCULATION_SLIDER = {\n  slidesToShow: 4,\n  dots: false,\n  arrows: false,\n  responsive: [{\n    breakpoint: GLOBALS.breakpoints.small,\n    settings: {\n      slidesToShow: 1,\n      dots: true,\n      infinite: true\n    }\n  }]\n};\n\n/***/ }),\n/* 1 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_constants_settings__ = __webpack_require__(0);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\nvar Subnav = function () {\n  function Subnav(name, elems) {\n    var _this = this;\n\n    _classCallCheck(this, Subnav);\n\n    this.elems = elems;\n    this.name = name;\n\n    this.options = [].slice.call(document.getElementsByClassName(this.name + '-subnav-option'));\n\n    this.options.map(function (option, i) {\n      option.addEventListener('click', function (e) {\n        _this.showSection(e.target);\n      });\n    });\n\n    if (!$('.' + this.name + '-subnav-option.active').length) $('.' + this.name + '-subnav-option').first().trigger('click');\n\n    this.deepLink();\n  }\n\n  _createClass(Subnav, [{\n    key: 'deepLink',\n    value: function deepLink() {\n      var hash = window.location.hash ? window.location.hash.replace('#', '') : null;\n      if (hash) $('.' + this.name + '-subnav-option[data-option=\"' + hash + '\"').trigger('click');\n    }\n  }, {\n    key: 'showSection',\n    value: function showSection(target) {\n      var _this2 = this;\n\n      var active = target.dataset.option;\n\n      $('.' + this.name + '-subnav-option').removeClass('active');\n      $(target).addClass('active');\n\n      if ($('.' + this.name + '-section:visible').length) {\n        $('.' + this.name + '-section:visible').fadeOut(__WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition, 'swing', function () {\n          $('.' + _this2.name + '-' + active).fadeIn(__WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition);\n        });\n      } else $('.' + this.name + '-' + active).fadeIn(__WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition);\n    }\n  }]);\n\n  return Subnav;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Subnav);\n\n/***/ }),\n/* 2 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__utils_helpers__ = __webpack_require__(7);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\nvar Flag = function () {\n  function Flag(name, elems) {\n    var _this = this;\n\n    _classCallCheck(this, Flag);\n\n    this.name = name;\n    this.slug = Object(__WEBPACK_IMPORTED_MODULE_0__utils_helpers__[\"a\" /* slugify */])(name);\n\n    this.activator = this.slug + '-activate';\n    this.activeClass = this.slug + '-flag-active';\n    this.closer = this.slug + '-close';\n\n    this.elems = elems;\n    this.elems[this.slug] = document.getElementById(this.slug + '-flag');\n\n    this.activators = [].slice.call(document.getElementsByClassName(this.activator));\n\n    this.activators.map(function (activator, i) {\n      activator.addEventListener('click', function (e) {\n        if (!activator.classList.contains('js-user-required') || activator.classList.contains('js-user-required') && MM.User.isLoggedIn()) {\n          _this.toggleFlag();\n        } else {\n          MM.Login.openFlag();\n        }\n      });\n    });\n\n    this.closers = [].slice.call(document.getElementsByClassName(this.closer));\n\n    this.closers.map(function (close, i) {\n      close.addEventListener('click', function (e) {\n        _this.closeFlag();\n      });\n    });\n  }\n\n  _createClass(Flag, [{\n    key: 'closeFlag',\n    value: function closeFlag() {\n      this.elems.$site.classList.remove(this.activeClass);\n      this.elems[this.slug].classList.remove('active');\n    }\n  }, {\n    key: 'openFlag',\n    value: function openFlag() {\n      this.elems.$site.classList.add(this.activeClass);\n      this.elems[this.slug].classList.add('active');\n    }\n  }, {\n    key: 'toggleFlag',\n    value: function toggleFlag() {\n      if (this.elems.$site.classList.contains(this.activeClass)) {\n        this.closeFlag();\n      } else {\n        this.openFlag();\n      }\n    }\n  }]);\n\n  return Flag;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Flag);\n\n/***/ }),\n/* 3 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return LOADER; });\nvar LOADER = {\n  loadMore: 'Load More',\n  loading: 'Loading...'\n};\n\n/***/ }),\n/* 4 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = initSlider;\nfunction initSlider(targetEl, settings) {\n  var $this = $(targetEl);\n  $this.not('.slick-initialized').slick(settings);\n}\n\n/***/ }),\n/* 5 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_global_nav__ = __webpack_require__(6);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_global_flag__ = __webpack_require__(2);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_global_popup__ = __webpack_require__(8);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_global_pagination__ = __webpack_require__(9);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_global_fader__ = __webpack_require__(10);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_global_recirculation__ = __webpack_require__(11);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_homepage__ = __webpack_require__(12);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_articles__ = __webpack_require__(15);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_articles_museboard__ = __webpack_require__(18);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_disciplines__ = __webpack_require__(19);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_musts__ = __webpack_require__(20);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11_creators__ = __webpack_require__(21);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_terms__ = __webpack_require__(22);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13_about__ = __webpack_require__(23);\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/* eslint no-console:0 */\n// This file is automatically compiled by Webpack, along with any other files\n// present in this directory. You're encouraged to place your actual application logic in\n// a relevant structure within app/javascript and only use these pack files to reference\n// that code so it'll be compiled.\n//\n// To reference this file, add <%= javascript_pack_tag 'application' %> to the appropriate\n// layout file, like app/views/layouts/application.html.erb\n\n// import User from 'global/user';\n\n\n\n\n\n\n// import Account from 'account';\n\n\n\n\n\n\n\n\n\nvar App = function App() {\n  _classCallCheck(this, App);\n\n  this.elems = {};\n  this.elems.$site = document.getElementById('site');\n  this.elems.$home = document.getElementById('home');\n  this.elems.$article = document.getElementById('article-show');\n\n  /**\n    * Sitewide\n    */\n  // this.User          = new User(this.elems);\n  this.Nav = new __WEBPACK_IMPORTED_MODULE_0_global_nav__[\"a\" /* default */](this.elems);\n  // this.Login         = new Flag('Login', this.elems);\n  // this.Flash         = (document.getElementById('flash')) ? new Flag('Flash', this.elems) : null;\n  // this.Reset         = new Flag('Reset Password', this.elems);\n  // this.Signup        = new Flag('Signup', this.elems);\n  this.Search = new __WEBPACK_IMPORTED_MODULE_1_global_flag__[\"a\" /* default */]('Search', this.elems);\n  this.Popup = new __WEBPACK_IMPORTED_MODULE_2_global_popup__[\"a\" /* default */](this.elems);\n  this.Pagination = new __WEBPACK_IMPORTED_MODULE_3_global_pagination__[\"a\" /* default */](this.elems);\n  this.Fader = new __WEBPACK_IMPORTED_MODULE_4_global_fader__[\"a\" /* default */]();\n  this.Recirculation = document.getElementsByClassName('recirculation-slider') ? new __WEBPACK_IMPORTED_MODULE_5_global_recirculation__[\"a\" /* default */]() : null;\n\n  /**\n    * Routes\n    */\n  // this.Account      = (document.getElementById('account')) ? new Account(this.elems) : null;\n  this.Homepage = document.getElementById('home') ? new __WEBPACK_IMPORTED_MODULE_6_homepage__[\"a\" /* default */](this.elems.$home) : null;\n  this.Articles = document.getElementById('articles') || document.getElementById('article-show') || document.getElementById('styleguide') || document.getElementById('must-show') ? new __WEBPACK_IMPORTED_MODULE_7_articles__[\"a\" /* default */](this.elems) : null;\n  this.Disciplines = document.getElementById('disciplines') ? new __WEBPACK_IMPORTED_MODULE_9_disciplines__[\"a\" /* default */](this.elems) : null;\n  this.Musts = document.getElementById('musts') ? new __WEBPACK_IMPORTED_MODULE_10_musts__[\"a\" /* default */](this.elems) : null;\n  this.Terms = document.getElementById('terms') ? new __WEBPACK_IMPORTED_MODULE_12_terms__[\"a\" /* default */](this.elems) : null;\n  this.Creators = document.getElementById('creators') ? new __WEBPACK_IMPORTED_MODULE_11_creators__[\"a\" /* default */](this.elems) : null;\n  this.About = document.getElementById('about') ? new __WEBPACK_IMPORTED_MODULE_13_about__[\"a\" /* default */](this.elems) : null;\n  this.Museboard = document.getElementById('article-show') && document.getElementById('article-show').dataset.type == 'muse_boards' ? new __WEBPACK_IMPORTED_MODULE_8_articles_museboard__[\"a\" /* default */]() : null;\n};\n\nvar MM = new App();\nwindow.MM = MM;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__constants_settings__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_global_flag__ = __webpack_require__(2);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\n\nvar Nav = function () {\n  function Nav(elems) {\n    var _this = this;\n\n    _classCallCheck(this, Nav);\n\n    this.elems = elems;\n\n    this.elems.nav = {\n      $top: document.getElementById('back-to-top'),\n      $logout: document.getElementsByClassName('logout-activate'),\n      $header: document.getElementById('header'),\n      $overlay: document.getElementById('navigation-overlay'),\n      $sidenav: document.getElementById('sidenav')\n    };\n\n    this.elems.nav.$top.addEventListener('click', function (e) {\n      _this.top(e);\n    });\n\n    // refreshes menu state on scroll and resize\n    this.menu = {};\n    ['scroll', 'resize'].forEach(function (e) {\n      window.addEventListener(e, function (f) {\n        _this.menu = _this.checkMenu();\n        _this.checkSidenav();\n      });\n    });\n    this.menuInterval = setInterval(function () {\n      _this.checkMenu();\n    }, __WEBPACK_IMPORTED_MODULE_0__constants_settings__[\"a\" /* GLOBALS */].transition);\n\n    this.activators = [].slice.call(document.getElementsByClassName('mobile-menu-activate'));\n\n    this.activators.map(function (activator, i) {\n      activator.addEventListener('click', function (e) {\n        clearInterval(_this.menuInterval);\n        _this.openMenu(true);\n      });\n    });\n\n    this.closers = [].slice.call(document.getElementsByClassName('mobile-menu-close'));\n\n    this.closers.map(function (close, i) {\n      close.addEventListener('click', function (e) {\n        _this.closeMenu();\n        _this.menuInterval = setInterval(function () {\n          _this.checkMenu();\n        }, __WEBPACK_IMPORTED_MODULE_0__constants_settings__[\"a\" /* GLOBALS */].transition);\n      });\n    });\n  }\n\n  _createClass(Nav, [{\n    key: 'checkMenu',\n    value: function checkMenu() {\n      var override = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n      var update = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n      var lastPos = typeof this.menu.lastPos !== 'undefined' && this.menu.lastPos ? this.menu.lastPos : window.pageYOffset;\n      var currentPos = window.pageYOffset;\n      var direction = currentPos > lastPos ? 'down' : 'up';\n      var menuOpen = direction == 'up' || override ? true : false;\n\n      if (update) this.updateMenu();\n\n      return {\n        isMenuOpen: menuOpen,\n        scrollDirection: direction,\n        lastPos: currentPos\n      };\n    }\n  }, {\n    key: 'updateMenu',\n    value: function updateMenu() {\n      if (this.menu.lastPos < 20 || !this.menu.lastPos) {\n        this.openMenu();\n        this.elems.nav.$header.classList.add('at-top');\n      } else {\n        this.elems.nav.$header.classList.remove('at-top');\n        if (this.menu.isMenuOpen) {\n          this.openMenu();\n        } else {\n          this.closeMenu();\n        }\n      }\n    }\n  }, {\n    key: 'openMenu',\n    value: function openMenu() {\n      var mobile = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n      if (mobile) {\n        this.elems.nav.$header.classList.add('mobile-menu-open');\n        $(this.elems.nav.$overlay).stop(true).fadeIn(__WEBPACK_IMPORTED_MODULE_0__constants_settings__[\"a\" /* GLOBALS */].transition);\n      } else {\n        this.elems.nav.$header.classList.remove('mobile-menu-open');\n        $(this.elems.nav.$overlay).hide();\n      }\n      this.elems.nav.$header.classList.add('menu-open');\n    }\n  }, {\n    key: 'closeMenu',\n    value: function closeMenu() {\n      $(this.elems.nav.$overlay).stop(true).fadeOut(__WEBPACK_IMPORTED_MODULE_0__constants_settings__[\"a\" /* GLOBALS */].transition);\n      this.elems.nav.$header.classList.remove('menu-open');\n      this.elems.nav.$header.classList.remove('mobile-menu-open');\n    }\n  }, {\n    key: 'checkSidenav',\n    value: function checkSidenav() {\n      var scrollTop = window.pageYOffset !== undefined ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n      var docHeight = document.body.scrollHeight;\n      var footerAd = document.getElementById('footer-ad') ? document.getElementById('footer-ad').clientHeight : 0;\n      var footer = document.getElementById('footer').clientHeight;\n      var winHeight = window.innerHeight;\n\n      var footerTop = docHeight - footer - footerAd;\n      scrollTop >= footerTop - winHeight / 2 - 400 ? this.elems.$site.classList.add('sidenav-inactive') : this.elems.$site.classList.remove('sidenav-inactive');\n\n      // back to top\n      if (scrollTop >= footerTop - winHeight) {\n        this.elems.nav.$top.style.transform = 'translate3d(0,-' + (scrollTop - (footerTop - winHeight)) + 'px, 0)';\n      } else {\n        this.elems.nav.$top.style.transform = 'translate3d(0,0,0)';\n      }\n    }\n  }, {\n    key: 'top',\n    value: function top(e) {\n      $('html, body').animate({\n        scrollTop: 0\n      }, __WEBPACK_IMPORTED_MODULE_0__constants_settings__[\"a\" /* GLOBALS */].transition * 2);\n    }\n  }]);\n\n  return Nav;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Nav);\n\n/***/ }),\n/* 7 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = slugify;\n/* unused harmony export validate */\nfunction slugify(text) {\n  return text.toLowerCase().replace(/[^\\w ]+/g, '').replace(/ +/g, '-');\n}\n\nfunction validate(input, type) {\n  var patterns = {\n    'string': /^[a-zA-Z0-9-_ \\\\,\\\\'\\\\\"\\\\:\\\\.\\\\!\\\\?\\\\$\\\\%\\\\(\\\\)\\\\@]+$/,\n    'email': /^[A-Z0-9._%+-]+@([A-Z0-9-]+\\.)+[A-Z]{2,12}$/i,\n    'integer': /^[0-9]+$/\n  };\n\n  return patterns[type].test(input);\n}\n\n/***/ }),\n/* 8 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_global_flag__ = __webpack_require__(2);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if (\"value\" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n\n\nvar Popup = function (_Flag) {\n  _inherits(Popup, _Flag);\n\n  function Popup(elems) {\n    _classCallCheck(this, Popup);\n\n    var _this = _possibleConstructorReturn(this, (Popup.__proto__ || Object.getPrototypeOf(Popup)).call(this, 'Newsletter Popup', elems));\n\n    _this.elems = elems;\n\n    _this.elems.popup = {\n      $newsletter: document.getElementById('newsletter-popup-flag')\n    };\n\n    _this.delay = 3000; // displays popup 3 seconds after landing\n    _this.check = false;\n\n    if (!localStorage.getItem('mmNewsletterPopupSeen') && _this.elems.popup.$newsletter) {\n\n      _this.check = true;\n      setTimeout(function (e) {\n        _get(Popup.prototype.__proto__ || Object.getPrototypeOf(Popup.prototype), 'openFlag', _this).call(_this);\n      }, _this.delay);\n\n      ['scroll', 'resize'].forEach(function (e) {\n        window.addEventListener(e, function (f) {\n          if (!_this.check) return;\n          _this.scrollCheck();\n        });\n      });\n    }\n    return _this;\n  }\n\n  _createClass(Popup, [{\n    key: 'closeFlag',\n    value: function closeFlag() {\n      _get(Popup.prototype.__proto__ || Object.getPrototypeOf(Popup.prototype), 'closeFlag', this).call(this);\n\n      localStorage.setItem('mmNewsletterPopupSeen', true);\n      this.check = false;\n    }\n  }, {\n    key: 'scrollCheck',\n    value: function scrollCheck() {\n      var scrollTop = window.pageYOffset !== undefined ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n      var docHeight = document.body.scrollHeight;\n      var footer = document.getElementById('footer').clientHeight;\n      var winHeight = window.innerHeight;\n\n      var footerTop = docHeight - footer - winHeight;\n\n      scrollTop >= footerTop ? this.elems.popup.$newsletter.classList.add('inactive') : this.elems.popup.$newsletter.classList.remove('inactive');\n    }\n  }]);\n\n  return Popup;\n}(__WEBPACK_IMPORTED_MODULE_0_global_flag__[\"a\" /* default */]);\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Popup);\n\n/***/ }),\n/* 9 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_constants_settings__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_constants_copy__ = __webpack_require__(3);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\n\nvar Pagination = function () {\n  function Pagination(elems) {\n    var _this = this;\n\n    _classCallCheck(this, Pagination);\n\n    this.elems = elems;\n\n    $(document).on('click', '.js-pagination-get', function (e) {\n      e.preventDefault();\n      _this.lastTarget = e.target;\n      _this.paginate(e.target.dataset, _this.lastTarget.classList.contains('btn'));\n    });\n\n    this.loadGrid();\n  }\n\n  _createClass(Pagination, [{\n    key: 'paginate',\n    value: function paginate(data, btn) {\n      if (!data || !data.page) {\n        console.warn('Pagination::paginate Error: Requires data.');\n        return;\n      }\n\n      var query = {\n        page: data.page !== undefined ? data.page : null,\n        type: data.type !== undefined ? data.type : null,\n        exclude: data.exclude !== undefined ? data.exclude : null,\n        tags: data.tags !== undefined ? data.tags : null,\n        terms: data.terms !== undefined ? data.terms : null,\n        creators: data.creators !== undefined ? data.creators : null,\n        must_type: data.mtype !== undefined ? data.mtype : null,\n        location: data.mlocation !== undefined ? data.mlocation : null\n      };\n\n      var target = this.lastTarget;\n      if (btn) {\n        $(this.lastTarget).prop('disabled', true).text(__WEBPACK_IMPORTED_MODULE_1_constants_copy__[\"a\" /* LOADER */].loading);\n      } else {\n        if (query.type === 'Musts' && query.location === '' && query.must_type === '') {\n          window.location.href = \"/musts\";\n          return;\n        }\n      }\n\n      $.ajax({\n        url: '/articles/paginate',\n        dataType: 'script',\n        data: query\n      }).done(function () {\n        if (parseInt(query.page)) window.history.pushState(null, null, '?page=' + (parseInt(query.page) + 1));\n        if (btn) $(target).prop('disabled', false).text(__WEBPACK_IMPORTED_MODULE_1_constants_copy__[\"a\" /* LOADER */].loadMore);\n      });\n    }\n  }, {\n    key: 'loadGrid',\n    value: function loadGrid() {\n      $('.article-grid-item.inactive').each(function (i) {\n        var $that = $('.article-grid-item.inactive').eq(i);\n        setTimeout(function (i) {\n          $that.removeClass('inactive');\n        }, Math.max(__WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition, (i + 2) / 2 * __WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition));\n      });\n    }\n  }]);\n\n  return Pagination;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Pagination);\n\n/***/ }),\n/* 10 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_constants_settings__ = __webpack_require__(0);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\nvar Fader = function () {\n  function Fader() {\n    var _this = this;\n\n    var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '.js-fader.js-fader-inactive';\n\n    _classCallCheck(this, Fader);\n\n    this.selector = selector;\n    this.$targets = document.querySelectorAll(this.selector);\n\n    ['scroll', 'resize'].forEach(function (e) {\n      window.addEventListener(e, function (f) {\n        _this.fadeElements();\n      });\n    });\n\n    this.fadeElements();\n    setTimeout(function (e) {\n      _this.fadeElements();\n    }, __WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition);\n  }\n\n  _createClass(Fader, [{\n    key: 'fadeElements',\n    value: function fadeElements() {\n      var scrollTop = window.pageYOffset !== undefined ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n      var winHeight = window.innerHeight;\n\n      var threshold = scrollTop + winHeight;\n      this.$targets.forEach(function ($target) {\n        if ($($target).offset().top < threshold) {\n          var delay = $target.dataset.jsFaderDelay ? parseInt($target.dataset.jsFaderDelay) : 0;\n          setTimeout(function () {\n            $target.classList.remove('js-fader-inactive');\n          }, delay / 2.5 * __WEBPACK_IMPORTED_MODULE_0_constants_settings__[\"a\" /* GLOBALS */].transition);\n        }\n      });\n\n      this.$targets = document.querySelectorAll(this.selector);\n    }\n  }]);\n\n  return Fader;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Fader);\n\n/***/ }),\n/* 11 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_utils_slider__ = __webpack_require__(4);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_constants_settings__ = __webpack_require__(0);\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\n\nvar Recirculation = function Recirculation() {\n  _classCallCheck(this, Recirculation);\n\n  this.gallery = [].slice.call(document.getElementsByClassName('recirculation-slider'));\n\n  //Initialize recirculaion slider\n  this.gallery.map(function (g, i) {\n    return Object(__WEBPACK_IMPORTED_MODULE_0_utils_slider__[\"a\" /* default */])(g, __WEBPACK_IMPORTED_MODULE_1_constants_settings__[\"e\" /* RECIRCULATION_SLIDER */]);\n  });\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Recirculation);\n\n/***/ }),\n/* 12 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_interact_js__ = __webpack_require__(13);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_interact_js___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_interact_js__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__utils_slider__ = __webpack_require__(4);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__constants_settings__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__utils_interact__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_global_subnav__ = __webpack_require__(1);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\n\n\n\n\nvar Homepage = function () {\n  function Homepage(home) {\n    _classCallCheck(this, Homepage);\n\n    this.wrapper = home;\n    this.mustsSlider = this.setupMustsSlider();\n    this.merchSlider = this.setupMerchSlider();\n    this.activeMuseboard = this.setupMuseboardInteract();\n\n    this.museboardsSubnav = new __WEBPACK_IMPORTED_MODULE_4_global_subnav__[\"a\" /* default */]('museboards', this.elems);\n  }\n\n  _createClass(Homepage, [{\n    key: 'setupMustsSlider',\n    value: function setupMustsSlider() {\n      var $slickEl = $(this.wrapper).find('.slick-musts');\n      Object(__WEBPACK_IMPORTED_MODULE_1__utils_slider__[\"a\" /* default */])($slickEl, __WEBPACK_IMPORTED_MODULE_2__constants_settings__[\"d\" /* MUSTS_SLIDER_HOMEPAGE */]);\n    }\n  }, {\n    key: 'setupMerchSlider',\n    value: function setupMerchSlider() {\n      var $slickEl = $(this.wrapper).find('.slick-merch');\n      Object(__WEBPACK_IMPORTED_MODULE_1__utils_slider__[\"a\" /* default */])($slickEl, __WEBPACK_IMPORTED_MODULE_2__constants_settings__[\"c\" /* MERCH_SLIDER_HOMEPAGE */]);\n    }\n  }, {\n    key: 'setupMuseboardInteract',\n    value: function setupMuseboardInteract() {\n      __WEBPACK_IMPORTED_MODULE_0_interact_js___default()('.js-mb-light-interactable').draggable({\n        onstart: __WEBPACK_IMPORTED_MODULE_3__utils_interact__[\"b\" /* manageZIndex */],\n        onmove: __WEBPACK_IMPORTED_MODULE_3__utils_interact__[\"a\" /* dragHandler */],\n        inertia: true,\n        restrict: {\n          restriction: 'parent',\n          elementRect: {\n            top: 0,\n            left: 0,\n            bottom: 1,\n            right: 1\n          }\n        }\n      }).resizable({\n        onmove: __WEBPACK_IMPORTED_MODULE_3__utils_interact__[\"c\" /* resizeHandler */],\n        preserveAspectRatio: true,\n        inertia: true,\n        invert: 'none',\n        edges: { top: true, right: true, bottom: true, left: true },\n        restrict: {\n          resize: 'parent'\n        }\n      });\n\n      $('.js-mb-light-interactable').on('touchstart', function (e) {\n        if (e.originalEvent.changedTouches.length > 1) e.preventDefault();\n      });\n    }\n  }]);\n\n  return Homepage;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Homepage);\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * interact.js v1.2.8\n *\n * Copyright (c) 2012-2015 Taye Adeyemi <dev@taye.me>\n * Open source under the MIT License.\n * https://raw.github.com/taye/interact.js/master/LICENSE\n */\n(function (realWindow) {\n    'use strict';\n\n    // return early if there's no window to work with (eg. Node.js)\n    if (!realWindow) { return; }\n\n    var // get wrapped window if using Shadow DOM polyfill\n        window = (function () {\n            // create a TextNode\n            var el = realWindow.document.createTextNode('');\n\n            // check if it's wrapped by a polyfill\n            if (el.ownerDocument !== realWindow.document\n                && typeof realWindow.wrap === 'function'\n                && realWindow.wrap(el) === el) {\n                // return wrapped window\n                return realWindow.wrap(realWindow);\n            }\n\n            // no Shadow DOM polyfil or native implementation\n            return realWindow;\n        }()),\n\n        document           = window.document,\n        DocumentFragment   = window.DocumentFragment   || blank,\n        SVGElement         = window.SVGElement         || blank,\n        SVGSVGElement      = window.SVGSVGElement      || blank,\n        SVGElementInstance = window.SVGElementInstance || blank,\n        HTMLElement        = window.HTMLElement        || window.Element,\n\n        PointerEvent = (window.PointerEvent || window.MSPointerEvent),\n        pEventTypes,\n\n        hypot = Math.hypot || function (x, y) { return Math.sqrt(x * x + y * y); },\n\n        tmpXY = {},     // reduce object creation in getXY()\n\n        documents       = [],   // all documents being listened to\n\n        interactables   = [],   // all set interactables\n        interactions    = [],   // all interactions\n\n        dynamicDrop     = false,\n\n        // {\n        //      type: {\n        //          selectors: ['selector', ...],\n        //          contexts : [document, ...],\n        //          listeners: [[listener, useCapture], ...]\n        //      }\n        //  }\n        delegatedEvents = {},\n\n        defaultOptions = {\n            base: {\n                accept        : null,\n                actionChecker : null,\n                styleCursor   : true,\n                preventDefault: 'auto',\n                origin        : { x: 0, y: 0 },\n                deltaSource   : 'page',\n                allowFrom     : null,\n                ignoreFrom    : null,\n                _context      : document,\n                dropChecker   : null\n            },\n\n            drag: {\n                enabled: false,\n                manualStart: true,\n                max: Infinity,\n                maxPerElement: 1,\n\n                snap: null,\n                restrict: null,\n                inertia: null,\n                autoScroll: null,\n\n                axis: 'xy'\n            },\n\n            drop: {\n                enabled: false,\n                accept: null,\n                overlap: 'pointer'\n            },\n\n            resize: {\n                enabled: false,\n                manualStart: false,\n                max: Infinity,\n                maxPerElement: 1,\n\n                snap: null,\n                restrict: null,\n                inertia: null,\n                autoScroll: null,\n\n                square: false,\n                preserveAspectRatio: false,\n                axis: 'xy',\n\n                // use default margin\n                margin: NaN,\n\n                // object with props left, right, top, bottom which are\n                // true/false values to resize when the pointer is over that edge,\n                // CSS selectors to match the handles for each direction\n                // or the Elements for each handle\n                edges: null,\n\n                // a value of 'none' will limit the resize rect to a minimum of 0x0\n                // 'negate' will alow the rect to have negative width/height\n                // 'reposition' will keep the width/height positive by swapping\n                // the top and bottom edges and/or swapping the left and right edges\n                invert: 'none'\n            },\n\n            gesture: {\n                manualStart: false,\n                enabled: false,\n                max: Infinity,\n                maxPerElement: 1,\n\n                restrict: null\n            },\n\n            perAction: {\n                manualStart: false,\n                max: Infinity,\n                maxPerElement: 1,\n\n                snap: {\n                    enabled     : false,\n                    endOnly     : false,\n                    range       : Infinity,\n                    targets     : null,\n                    offsets     : null,\n\n                    relativePoints: null\n                },\n\n                restrict: {\n                    enabled: false,\n                    endOnly: false\n                },\n\n                autoScroll: {\n                    enabled     : false,\n                    container   : null,     // the item that is scrolled (Window or HTMLElement)\n                    margin      : 60,\n                    speed       : 300       // the scroll speed in pixels per second\n                },\n\n                inertia: {\n                    enabled          : false,\n                    resistance       : 10,    // the lambda in exponential decay\n                    minSpeed         : 100,   // target speed must be above this for inertia to start\n                    endSpeed         : 10,    // the speed at which inertia is slow enough to stop\n                    allowResume      : true,  // allow resuming an action in inertia phase\n                    zeroResumeDelta  : true,  // if an action is resumed after launch, set dx/dy to 0\n                    smoothEndDuration: 300    // animate to snap/restrict endOnly if there's no inertia\n                }\n            },\n\n            _holdDuration: 600\n        },\n\n        // Things related to autoScroll\n        autoScroll = {\n            interaction: null,\n            i: null,    // the handle returned by window.setInterval\n            x: 0, y: 0, // Direction each pulse is to scroll in\n\n            // scroll the window by the values in scroll.x/y\n            scroll: function () {\n                var options = autoScroll.interaction.target.options[autoScroll.interaction.prepared.name].autoScroll,\n                    container = options.container || getWindow(autoScroll.interaction.element),\n                    now = new Date().getTime(),\n                    // change in time in seconds\n                    dtx = (now - autoScroll.prevTimeX) / 1000,\n                    dty = (now - autoScroll.prevTimeY) / 1000,\n                    vx, vy, sx, sy;\n\n                // displacement\n                if (options.velocity) {\n                  vx = options.velocity.x;\n                  vy = options.velocity.y;\n                }\n                else {\n                  vx = vy = options.speed\n                }\n \n                sx = vx * dtx;\n                sy = vy * dty;\n\n                if (sx >= 1 || sy >= 1) {\n                    if (isWindow(container)) {\n                        container.scrollBy(autoScroll.x * sx, autoScroll.y * sy);\n                    }\n                    else if (container) {\n                        container.scrollLeft += autoScroll.x * sx;\n                        container.scrollTop  += autoScroll.y * sy;\n                    }\n\n                    if (sx >=1) autoScroll.prevTimeX = now;\n                    if (sy >= 1) autoScroll.prevTimeY = now;\n                }\n\n                if (autoScroll.isScrolling) {\n                    cancelFrame(autoScroll.i);\n                    autoScroll.i = reqFrame(autoScroll.scroll);\n                }\n            },\n\n            isScrolling: false,\n            prevTimeX: 0,\n            prevTimeY: 0,\n\n            start: function (interaction) {\n                autoScroll.isScrolling = true;\n                cancelFrame(autoScroll.i);\n\n                autoScroll.interaction = interaction;\n                autoScroll.prevTimeX = new Date().getTime();\n                autoScroll.prevTimeY = new Date().getTime();\n                autoScroll.i = reqFrame(autoScroll.scroll);\n            },\n\n            stop: function () {\n                autoScroll.isScrolling = false;\n                cancelFrame(autoScroll.i);\n            }\n        },\n\n        // Does the browser support touch input?\n        supportsTouch = (('ontouchstart' in window) || window.DocumentTouch && document instanceof window.DocumentTouch),\n\n        // Does the browser support PointerEvents\n        // Avoid PointerEvent bugs introduced in Chrome 55\n        supportsPointerEvent = PointerEvent && !/Chrome/.test(navigator.userAgent),\n\n        // Less Precision with touch input\n        margin = supportsTouch || supportsPointerEvent? 20: 10,\n\n        pointerMoveTolerance = 1,\n\n        // for ignoring browser's simulated mouse events\n        prevTouchTime = 0,\n\n        // Allow this many interactions to happen simultaneously\n        maxInteractions = Infinity,\n\n        // Check if is IE9 or older\n        actionCursors = (document.all && !window.atob) ? {\n            drag    : 'move',\n            resizex : 'e-resize',\n            resizey : 's-resize',\n            resizexy: 'se-resize',\n\n            resizetop        : 'n-resize',\n            resizeleft       : 'w-resize',\n            resizebottom     : 's-resize',\n            resizeright      : 'e-resize',\n            resizetopleft    : 'se-resize',\n            resizebottomright: 'se-resize',\n            resizetopright   : 'ne-resize',\n            resizebottomleft : 'ne-resize',\n\n            gesture : ''\n        } : {\n            drag    : 'move',\n            resizex : 'ew-resize',\n            resizey : 'ns-resize',\n            resizexy: 'nwse-resize',\n\n            resizetop        : 'ns-resize',\n            resizeleft       : 'ew-resize',\n            resizebottom     : 'ns-resize',\n            resizeright      : 'ew-resize',\n            resizetopleft    : 'nwse-resize',\n            resizebottomright: 'nwse-resize',\n            resizetopright   : 'nesw-resize',\n            resizebottomleft : 'nesw-resize',\n\n            gesture : ''\n        },\n\n        actionIsEnabled = {\n            drag   : true,\n            resize : true,\n            gesture: true\n        },\n\n        // because Webkit and Opera still use 'mousewheel' event type\n        wheelEvent = 'onmousewheel' in document? 'mousewheel': 'wheel',\n\n        eventTypes = [\n            'dragstart',\n            'dragmove',\n            'draginertiastart',\n            'dragend',\n            'dragenter',\n            'dragleave',\n            'dropactivate',\n            'dropdeactivate',\n            'dropmove',\n            'drop',\n            'resizestart',\n            'resizemove',\n            'resizeinertiastart',\n            'resizeend',\n            'gesturestart',\n            'gesturemove',\n            'gestureinertiastart',\n            'gestureend',\n\n            'down',\n            'move',\n            'up',\n            'cancel',\n            'tap',\n            'doubletap',\n            'hold'\n        ],\n\n        globalEvents = {},\n\n        // Opera Mobile must be handled differently\n        isOperaMobile = navigator.appName == 'Opera' &&\n            supportsTouch &&\n            navigator.userAgent.match('Presto'),\n\n        // scrolling doesn't change the result of getClientRects on iOS 7\n        isIOS7 = (/iP(hone|od|ad)/.test(navigator.platform)\n                         && /OS 7[^\\d]/.test(navigator.appVersion)),\n\n        // prefix matchesSelector\n        prefixedMatchesSelector = 'matches' in Element.prototype?\n                'matches': 'webkitMatchesSelector' in Element.prototype?\n                    'webkitMatchesSelector': 'mozMatchesSelector' in Element.prototype?\n                        'mozMatchesSelector': 'oMatchesSelector' in Element.prototype?\n                            'oMatchesSelector': 'msMatchesSelector',\n\n        // will be polyfill function if browser is IE8\n        ie8MatchesSelector,\n\n        // native requestAnimationFrame or polyfill\n        reqFrame = realWindow.requestAnimationFrame,\n        cancelFrame = realWindow.cancelAnimationFrame,\n\n        // Events wrapper\n        events = (function () {\n            var useAttachEvent = ('attachEvent' in window) && !('addEventListener' in window),\n                addEvent       = useAttachEvent?  'attachEvent': 'addEventListener',\n                removeEvent    = useAttachEvent?  'detachEvent': 'removeEventListener',\n                on             = useAttachEvent? 'on': '',\n\n                elements          = [],\n                targets           = [],\n                attachedListeners = [];\n\n            function add (element, type, listener, useCapture) {\n                var elementIndex = indexOf(elements, element),\n                    target = targets[elementIndex];\n\n                if (!target) {\n                    target = {\n                        events: {},\n                        typeCount: 0\n                    };\n\n                    elementIndex = elements.push(element) - 1;\n                    targets.push(target);\n\n                    attachedListeners.push((useAttachEvent ? {\n                            supplied: [],\n                            wrapped : [],\n                            useCount: []\n                        } : null));\n                }\n\n                if (!target.events[type]) {\n                    target.events[type] = [];\n                    target.typeCount++;\n                }\n\n                if (!contains(target.events[type], listener)) {\n                    var ret;\n\n                    if (useAttachEvent) {\n                        var listeners = attachedListeners[elementIndex],\n                            listenerIndex = indexOf(listeners.supplied, listener);\n\n                        var wrapped = listeners.wrapped[listenerIndex] || function (event) {\n                            if (!event.immediatePropagationStopped) {\n                                event.target = event.srcElement;\n                                event.currentTarget = element;\n\n                                event.preventDefault = event.preventDefault || preventDef;\n                                event.stopPropagation = event.stopPropagation || stopProp;\n                                event.stopImmediatePropagation = event.stopImmediatePropagation || stopImmProp;\n\n                                if (/mouse|click/.test(event.type)) {\n                                    event.pageX = event.clientX + getWindow(element).document.documentElement.scrollLeft;\n                                    event.pageY = event.clientY + getWindow(element).document.documentElement.scrollTop;\n                                }\n\n                                listener(event);\n                            }\n                        };\n\n                        ret = element[addEvent](on + type, wrapped, Boolean(useCapture));\n\n                        if (listenerIndex === -1) {\n                            listeners.supplied.push(listener);\n                            listeners.wrapped.push(wrapped);\n                            listeners.useCount.push(1);\n                        }\n                        else {\n                            listeners.useCount[listenerIndex]++;\n                        }\n                    }\n                    else {\n                        ret = element[addEvent](type, listener, useCapture || false);\n                    }\n                    target.events[type].push(listener);\n\n                    return ret;\n                }\n            }\n\n            function remove (element, type, listener, useCapture) {\n                var i,\n                    elementIndex = indexOf(elements, element),\n                    target = targets[elementIndex],\n                    listeners,\n                    listenerIndex,\n                    wrapped = listener;\n\n                if (!target || !target.events) {\n                    return;\n                }\n\n                if (useAttachEvent) {\n                    listeners = attachedListeners[elementIndex];\n                    listenerIndex = indexOf(listeners.supplied, listener);\n                    wrapped = listeners.wrapped[listenerIndex];\n                }\n\n                if (type === 'all') {\n                    for (type in target.events) {\n                        if (target.events.hasOwnProperty(type)) {\n                            remove(element, type, 'all');\n                        }\n                    }\n                    return;\n                }\n\n                if (target.events[type]) {\n                    var len = target.events[type].length;\n\n                    if (listener === 'all') {\n                        for (i = 0; i < len; i++) {\n                            remove(element, type, target.events[type][i], Boolean(useCapture));\n                        }\n                        return;\n                    } else {\n                        for (i = 0; i < len; i++) {\n                            if (target.events[type][i] === listener) {\n                                element[removeEvent](on + type, wrapped, useCapture || false);\n                                target.events[type].splice(i, 1);\n\n                                if (useAttachEvent && listeners) {\n                                    listeners.useCount[listenerIndex]--;\n                                    if (listeners.useCount[listenerIndex] === 0) {\n                                        listeners.supplied.splice(listenerIndex, 1);\n                                        listeners.wrapped.splice(listenerIndex, 1);\n                                        listeners.useCount.splice(listenerIndex, 1);\n                                    }\n                                }\n\n                                break;\n                            }\n                        }\n                    }\n\n                    if (target.events[type] && target.events[type].length === 0) {\n                        target.events[type] = null;\n                        target.typeCount--;\n                    }\n                }\n\n                if (!target.typeCount) {\n                    targets.splice(elementIndex, 1);\n                    elements.splice(elementIndex, 1);\n                    attachedListeners.splice(elementIndex, 1);\n                }\n            }\n\n            function preventDef () {\n                this.returnValue = false;\n            }\n\n            function stopProp () {\n                this.cancelBubble = true;\n            }\n\n            function stopImmProp () {\n                this.cancelBubble = true;\n                this.immediatePropagationStopped = true;\n            }\n\n            return {\n                add: add,\n                remove: remove,\n                useAttachEvent: useAttachEvent,\n\n                _elements: elements,\n                _targets: targets,\n                _attachedListeners: attachedListeners\n            };\n        }());\n\n    function blank () {}\n\n    function isElement (o) {\n        if (!o || (typeof o !== 'object')) { return false; }\n\n        var _window = getWindow(o) || window;\n\n        return (/object|function/.test(typeof _window.Element)\n            ? o instanceof _window.Element //DOM2\n            : o.nodeType === 1 && typeof o.nodeName === \"string\");\n    }\n    function isWindow (thing) { return thing === window || !!(thing && thing.Window) && (thing instanceof thing.Window); }\n    function isDocFrag (thing) { return !!thing && thing instanceof DocumentFragment; }\n    function isArray (thing) {\n        return isObject(thing)\n                && (typeof thing.length !== undefined)\n                && isFunction(thing.splice);\n    }\n    function isObject   (thing) { return !!thing && (typeof thing === 'object'); }\n    function isFunction (thing) { return typeof thing === 'function'; }\n    function isNumber   (thing) { return typeof thing === 'number'  ; }\n    function isBool     (thing) { return typeof thing === 'boolean' ; }\n    function isString   (thing) { return typeof thing === 'string'  ; }\n\n    function trySelector (value) {\n        if (!isString(value)) { return false; }\n\n        // an exception will be raised if it is invalid\n        document.querySelector(value);\n        return true;\n    }\n\n    function extend (dest, source) {\n        for (var prop in source) {\n            dest[prop] = source[prop];\n        }\n        return dest;\n    }\n\n    var prefixedPropREs = {\n      webkit: /(Movement[XY]|Radius[XY]|RotationAngle|Force)$/\n    };\n\n    function pointerExtend (dest, source) {\n        for (var prop in source) {\n          var deprecated = false;\n\n          // skip deprecated prefixed properties\n          for (var vendor in prefixedPropREs) {\n            if (prop.indexOf(vendor) === 0 && prefixedPropREs[vendor].test(prop)) {\n              deprecated = true;\n              break;\n            }\n          }\n\n          if (!deprecated) {\n            dest[prop] = source[prop];\n          }\n        }\n        return dest;\n    }\n\n    function copyCoords (dest, src) {\n        dest.page = dest.page || {};\n        dest.page.x = src.page.x;\n        dest.page.y = src.page.y;\n\n        dest.client = dest.client || {};\n        dest.client.x = src.client.x;\n        dest.client.y = src.client.y;\n\n        dest.timeStamp = src.timeStamp;\n    }\n\n    function setEventXY (targetObj, pointers, interaction) {\n        var pointer = (pointers.length > 1\n                       ? pointerAverage(pointers)\n                       : pointers[0]);\n\n        getPageXY(pointer, tmpXY, interaction);\n        targetObj.page.x = tmpXY.x;\n        targetObj.page.y = tmpXY.y;\n\n        getClientXY(pointer, tmpXY, interaction);\n        targetObj.client.x = tmpXY.x;\n        targetObj.client.y = tmpXY.y;\n\n        targetObj.timeStamp = new Date().getTime();\n    }\n\n    function setEventDeltas (targetObj, prev, cur) {\n        targetObj.page.x     = cur.page.x      - prev.page.x;\n        targetObj.page.y     = cur.page.y      - prev.page.y;\n        targetObj.client.x   = cur.client.x    - prev.client.x;\n        targetObj.client.y   = cur.client.y    - prev.client.y;\n        targetObj.timeStamp = new Date().getTime() - prev.timeStamp;\n\n        // set pointer velocity\n        var dt = Math.max(targetObj.timeStamp / 1000, 0.001);\n        targetObj.page.speed   = hypot(targetObj.page.x, targetObj.page.y) / dt;\n        targetObj.page.vx      = targetObj.page.x / dt;\n        targetObj.page.vy      = targetObj.page.y / dt;\n\n        targetObj.client.speed = hypot(targetObj.client.x, targetObj.page.y) / dt;\n        targetObj.client.vx    = targetObj.client.x / dt;\n        targetObj.client.vy    = targetObj.client.y / dt;\n    }\n\n    function isNativePointer (pointer) {\n        return (pointer instanceof window.Event\n            || (supportsTouch && window.Touch && pointer instanceof window.Touch));\n    }\n\n    // Get specified X/Y coords for mouse or event.touches[0]\n    function getXY (type, pointer, xy) {\n        xy = xy || {};\n        type = type || 'page';\n\n        xy.x = pointer[type + 'X'];\n        xy.y = pointer[type + 'Y'];\n\n        return xy;\n    }\n\n    function getPageXY (pointer, page) {\n        page = page || {};\n\n        // Opera Mobile handles the viewport and scrolling oddly\n        if (isOperaMobile && isNativePointer(pointer)) {\n            getXY('screen', pointer, page);\n\n            page.x += window.scrollX;\n            page.y += window.scrollY;\n        }\n        else {\n            getXY('page', pointer, page);\n        }\n\n        return page;\n    }\n\n    function getClientXY (pointer, client) {\n        client = client || {};\n\n        if (isOperaMobile && isNativePointer(pointer)) {\n            // Opera Mobile handles the viewport and scrolling oddly\n            getXY('screen', pointer, client);\n        }\n        else {\n          getXY('client', pointer, client);\n        }\n\n        return client;\n    }\n\n    function getScrollXY (win) {\n        win = win || window;\n        return {\n            x: win.scrollX || win.document.documentElement.scrollLeft,\n            y: win.scrollY || win.document.documentElement.scrollTop\n        };\n    }\n\n    function getPointerId (pointer) {\n        return isNumber(pointer.pointerId)? pointer.pointerId : pointer.identifier;\n    }\n\n    function getActualElement (element) {\n        return (element instanceof SVGElementInstance\n            ? element.correspondingUseElement\n            : element);\n    }\n\n    function getWindow (node) {\n        if (isWindow(node)) {\n            return node;\n        }\n\n        var rootNode = (node.ownerDocument || node);\n\n        return rootNode.defaultView || rootNode.parentWindow || window;\n    }\n\n    function getElementClientRect (element) {\n        var clientRect = (element instanceof SVGElement\n                            ? element.getBoundingClientRect()\n                            : element.getClientRects()[0]);\n\n        return clientRect && {\n            left  : clientRect.left,\n            right : clientRect.right,\n            top   : clientRect.top,\n            bottom: clientRect.bottom,\n            width : clientRect.width || clientRect.right - clientRect.left,\n            height: clientRect.height || clientRect.bottom - clientRect.top\n        };\n    }\n\n    function getElementRect (element) {\n        var clientRect = getElementClientRect(element);\n\n        if (!isIOS7 && clientRect) {\n            var scroll = getScrollXY(getWindow(element));\n\n            clientRect.left   += scroll.x;\n            clientRect.right  += scroll.x;\n            clientRect.top    += scroll.y;\n            clientRect.bottom += scroll.y;\n        }\n\n        return clientRect;\n    }\n\n    function getTouchPair (event) {\n        var touches = [];\n\n        // array of touches is supplied\n        if (isArray(event)) {\n            touches[0] = event[0];\n            touches[1] = event[1];\n        }\n        // an event\n        else {\n            if (event.type === 'touchend') {\n                if (event.touches.length === 1) {\n                    touches[0] = event.touches[0];\n                    touches[1] = event.changedTouches[0];\n                }\n                else if (event.touches.length === 0) {\n                    touches[0] = event.changedTouches[0];\n                    touches[1] = event.changedTouches[1];\n                }\n            }\n            else {\n                touches[0] = event.touches[0];\n                touches[1] = event.touches[1];\n            }\n        }\n\n        return touches;\n    }\n\n    function pointerAverage (pointers) {\n        var average = {\n            pageX  : 0,\n            pageY  : 0,\n            clientX: 0,\n            clientY: 0,\n            screenX: 0,\n            screenY: 0\n        };\n        var prop;\n\n        for (var i = 0; i < pointers.length; i++) {\n            for (prop in average) {\n                average[prop] += pointers[i][prop];\n            }\n        }\n        for (prop in average) {\n            average[prop] /= pointers.length;\n        }\n\n        return average;\n    }\n\n    function touchBBox (event) {\n        if (!event.length && !(event.touches && event.touches.length > 1)) {\n            return;\n        }\n\n        var touches = getTouchPair(event),\n            minX = Math.min(touches[0].pageX, touches[1].pageX),\n            minY = Math.min(touches[0].pageY, touches[1].pageY),\n            maxX = Math.max(touches[0].pageX, touches[1].pageX),\n            maxY = Math.max(touches[0].pageY, touches[1].pageY);\n\n        return {\n            x: minX,\n            y: minY,\n            left: minX,\n            top: minY,\n            width: maxX - minX,\n            height: maxY - minY\n        };\n    }\n\n    function touchDistance (event, deltaSource) {\n        deltaSource = deltaSource || defaultOptions.deltaSource;\n\n        var sourceX = deltaSource + 'X',\n            sourceY = deltaSource + 'Y',\n            touches = getTouchPair(event);\n\n\n        var dx = touches[0][sourceX] - touches[1][sourceX],\n            dy = touches[0][sourceY] - touches[1][sourceY];\n\n        return hypot(dx, dy);\n    }\n\n    function touchAngle (event, prevAngle, deltaSource) {\n        deltaSource = deltaSource || defaultOptions.deltaSource;\n\n        var sourceX = deltaSource + 'X',\n            sourceY = deltaSource + 'Y',\n            touches = getTouchPair(event),\n            dx = touches[0][sourceX] - touches[1][sourceX],\n            dy = touches[0][sourceY] - touches[1][sourceY],\n            angle = 180 * Math.atan(dy / dx) / Math.PI;\n\n        if (isNumber(prevAngle)) {\n            var dr = angle - prevAngle,\n                drClamped = dr % 360;\n\n            if (drClamped > 315) {\n                angle -= 360 + (angle / 360)|0 * 360;\n            }\n            else if (drClamped > 135) {\n                angle -= 180 + (angle / 360)|0 * 360;\n            }\n            else if (drClamped < -315) {\n                angle += 360 + (angle / 360)|0 * 360;\n            }\n            else if (drClamped < -135) {\n                angle += 180 + (angle / 360)|0 * 360;\n            }\n        }\n\n        return  angle;\n    }\n\n    function getOriginXY (interactable, element) {\n        var origin = interactable\n                ? interactable.options.origin\n                : defaultOptions.origin;\n\n        if (origin === 'parent') {\n            origin = parentElement(element);\n        }\n        else if (origin === 'self') {\n            origin = interactable.getRect(element);\n        }\n        else if (trySelector(origin)) {\n            origin = closest(element, origin) || { x: 0, y: 0 };\n        }\n\n        if (isFunction(origin)) {\n            origin = origin(interactable && element);\n        }\n\n        if (isElement(origin))  {\n            origin = getElementRect(origin);\n        }\n\n        origin.x = ('x' in origin)? origin.x : origin.left;\n        origin.y = ('y' in origin)? origin.y : origin.top;\n\n        return origin;\n    }\n\n    // http://stackoverflow.com/a/5634528/2280888\n    function _getQBezierValue(t, p1, p2, p3) {\n        var iT = 1 - t;\n        return iT * iT * p1 + 2 * iT * t * p2 + t * t * p3;\n    }\n\n    function getQuadraticCurvePoint(startX, startY, cpX, cpY, endX, endY, position) {\n        return {\n            x:  _getQBezierValue(position, startX, cpX, endX),\n            y:  _getQBezierValue(position, startY, cpY, endY)\n        };\n    }\n\n    // http://gizma.com/easing/\n    function easeOutQuad (t, b, c, d) {\n        t /= d;\n        return -c * t*(t-2) + b;\n    }\n\n    function nodeContains (parent, child) {\n        while (child) {\n            if (child === parent) {\n                return true;\n            }\n\n            child = child.parentNode;\n        }\n\n        return false;\n    }\n\n    function closest (child, selector) {\n        var parent = parentElement(child);\n\n        while (isElement(parent)) {\n            if (matchesSelector(parent, selector)) { return parent; }\n\n            parent = parentElement(parent);\n        }\n\n        return null;\n    }\n\n    function parentElement (node) {\n        var parent = node.parentNode;\n\n        if (isDocFrag(parent)) {\n            // skip past #shado-root fragments\n            while ((parent = parent.host) && isDocFrag(parent)) {}\n\n            return parent;\n        }\n\n        return parent;\n    }\n\n    function inContext (interactable, element) {\n        return interactable._context === element.ownerDocument\n                || nodeContains(interactable._context, element);\n    }\n\n    function testIgnore (interactable, interactableElement, element) {\n        var ignoreFrom = interactable.options.ignoreFrom;\n\n        if (!ignoreFrom || !isElement(element)) { return false; }\n\n        if (isString(ignoreFrom)) {\n            return matchesUpTo(element, ignoreFrom, interactableElement);\n        }\n        else if (isElement(ignoreFrom)) {\n            return nodeContains(ignoreFrom, element);\n        }\n\n        return false;\n    }\n\n    function testAllow (interactable, interactableElement, element) {\n        var allowFrom = interactable.options.allowFrom;\n\n        if (!allowFrom) { return true; }\n\n        if (!isElement(element)) { return false; }\n\n        if (isString(allowFrom)) {\n            return matchesUpTo(element, allowFrom, interactableElement);\n        }\n        else if (isElement(allowFrom)) {\n            return nodeContains(allowFrom, element);\n        }\n\n        return false;\n    }\n\n    function checkAxis (axis, interactable) {\n        if (!interactable) { return false; }\n\n        var thisAxis = interactable.options.drag.axis;\n\n        return (axis === 'xy' || thisAxis === 'xy' || thisAxis === axis);\n    }\n\n    function checkSnap (interactable, action) {\n        var options = interactable.options;\n\n        if (/^resize/.test(action)) {\n            action = 'resize';\n        }\n\n        return options[action].snap && options[action].snap.enabled;\n    }\n\n    function checkRestrict (interactable, action) {\n        var options = interactable.options;\n\n        if (/^resize/.test(action)) {\n            action = 'resize';\n        }\n\n        return  options[action].restrict && options[action].restrict.enabled;\n    }\n\n    function checkAutoScroll (interactable, action) {\n        var options = interactable.options;\n\n        if (/^resize/.test(action)) {\n            action = 'resize';\n        }\n\n        return  options[action].autoScroll && options[action].autoScroll.enabled;\n    }\n\n    function withinInteractionLimit (interactable, element, action) {\n        var options = interactable.options,\n            maxActions = options[action.name].max,\n            maxPerElement = options[action.name].maxPerElement,\n            activeInteractions = 0,\n            targetCount = 0,\n            targetElementCount = 0;\n\n        for (var i = 0, len = interactions.length; i < len; i++) {\n            var interaction = interactions[i],\n                otherAction = interaction.prepared.name,\n                active = interaction.interacting();\n\n            if (!active) { continue; }\n\n            activeInteractions++;\n\n            if (activeInteractions >= maxInteractions) {\n                return false;\n            }\n\n            if (interaction.target !== interactable) { continue; }\n\n            targetCount += (otherAction === action.name)|0;\n\n            if (targetCount >= maxActions) {\n                return false;\n            }\n\n            if (interaction.element === element) {\n                targetElementCount++;\n\n                if (otherAction !== action.name || targetElementCount >= maxPerElement) {\n                    return false;\n                }\n            }\n        }\n\n        return maxInteractions > 0;\n    }\n\n    // Test for the element that's \"above\" all other qualifiers\n    function indexOfDeepestElement (elements) {\n        var dropzone,\n            deepestZone = elements[0],\n            index = deepestZone? 0: -1,\n            parent,\n            deepestZoneParents = [],\n            dropzoneParents = [],\n            child,\n            i,\n            n;\n\n        for (i = 1; i < elements.length; i++) {\n            dropzone = elements[i];\n\n            // an element might belong to multiple selector dropzones\n            if (!dropzone || dropzone === deepestZone) {\n                continue;\n            }\n\n            if (!deepestZone) {\n                deepestZone = dropzone;\n                index = i;\n                continue;\n            }\n\n            // check if the deepest or current are document.documentElement or document.rootElement\n            // - if the current dropzone is, do nothing and continue\n            if (dropzone.parentNode === dropzone.ownerDocument) {\n                continue;\n            }\n            // - if deepest is, update with the current dropzone and continue to next\n            else if (deepestZone.parentNode === dropzone.ownerDocument) {\n                deepestZone = dropzone;\n                index = i;\n                continue;\n            }\n\n            if (!deepestZoneParents.length) {\n                parent = deepestZone;\n                while (parent.parentNode && parent.parentNode !== parent.ownerDocument) {\n                    deepestZoneParents.unshift(parent);\n                    parent = parent.parentNode;\n                }\n            }\n\n            // if this element is an svg element and the current deepest is\n            // an HTMLElement\n            if (deepestZone instanceof HTMLElement\n                && dropzone instanceof SVGElement\n                && !(dropzone instanceof SVGSVGElement)) {\n\n                if (dropzone === deepestZone.parentNode) {\n                    continue;\n                }\n\n                parent = dropzone.ownerSVGElement;\n            }\n            else {\n                parent = dropzone;\n            }\n\n            dropzoneParents = [];\n\n            while (parent.parentNode !== parent.ownerDocument) {\n                dropzoneParents.unshift(parent);\n                parent = parent.parentNode;\n            }\n\n            n = 0;\n\n            // get (position of last common ancestor) + 1\n            while (dropzoneParents[n] && dropzoneParents[n] === deepestZoneParents[n]) {\n                n++;\n            }\n\n            var parents = [\n                dropzoneParents[n - 1],\n                dropzoneParents[n],\n                deepestZoneParents[n]\n            ];\n\n            child = parents[0].lastChild;\n\n            while (child) {\n                if (child === parents[1]) {\n                    deepestZone = dropzone;\n                    index = i;\n                    deepestZoneParents = [];\n\n                    break;\n                }\n                else if (child === parents[2]) {\n                    break;\n                }\n\n                child = child.previousSibling;\n            }\n        }\n\n        return index;\n    }\n\n    function Interaction () {\n        this.target          = null; // current interactable being interacted with\n        this.element         = null; // the target element of the interactable\n        this.dropTarget      = null; // the dropzone a drag target might be dropped into\n        this.dropElement     = null; // the element at the time of checking\n        this.prevDropTarget  = null; // the dropzone that was recently dragged away from\n        this.prevDropElement = null; // the element at the time of checking\n\n        this.prepared        = {     // action that's ready to be fired on next move event\n            name : null,\n            axis : null,\n            edges: null\n        };\n\n        this.matches         = [];   // all selectors that are matched by target element\n        this.matchElements   = [];   // corresponding elements\n\n        this.inertiaStatus = {\n            active       : false,\n            smoothEnd    : false,\n            ending       : false,\n\n            startEvent: null,\n            upCoords: {},\n\n            xe: 0, ye: 0,\n            sx: 0, sy: 0,\n\n            t0: 0,\n            vx0: 0, vys: 0,\n            duration: 0,\n\n            resumeDx: 0,\n            resumeDy: 0,\n\n            lambda_v0: 0,\n            one_ve_v0: 0,\n            i  : null\n        };\n\n        if (isFunction(Function.prototype.bind)) {\n            this.boundInertiaFrame = this.inertiaFrame.bind(this);\n            this.boundSmoothEndFrame = this.smoothEndFrame.bind(this);\n        }\n        else {\n            var that = this;\n\n            this.boundInertiaFrame = function () { return that.inertiaFrame(); };\n            this.boundSmoothEndFrame = function () { return that.smoothEndFrame(); };\n        }\n\n        this.activeDrops = {\n            dropzones: [],      // the dropzones that are mentioned below\n            elements : [],      // elements of dropzones that accept the target draggable\n            rects    : []       // the rects of the elements mentioned above\n        };\n\n        // keep track of added pointers\n        this.pointers    = [];\n        this.pointerIds  = [];\n        this.downTargets = [];\n        this.downTimes   = [];\n        this.holdTimers  = [];\n\n        // Previous native pointer move event coordinates\n        this.prevCoords = {\n            page     : { x: 0, y: 0 },\n            client   : { x: 0, y: 0 },\n            timeStamp: 0\n        };\n        // current native pointer move event coordinates\n        this.curCoords = {\n            page     : { x: 0, y: 0 },\n            client   : { x: 0, y: 0 },\n            timeStamp: 0\n        };\n\n        // Starting InteractEvent pointer coordinates\n        this.startCoords = {\n            page     : { x: 0, y: 0 },\n            client   : { x: 0, y: 0 },\n            timeStamp: 0\n        };\n\n        // Change in coordinates and time of the pointer\n        this.pointerDelta = {\n            page     : { x: 0, y: 0, vx: 0, vy: 0, speed: 0 },\n            client   : { x: 0, y: 0, vx: 0, vy: 0, speed: 0 },\n            timeStamp: 0\n        };\n\n        this.downEvent   = null;    // pointerdown/mousedown/touchstart event\n        this.downPointer = {};\n\n        this._eventTarget    = null;\n        this._curEventTarget = null;\n\n        this.prevEvent = null;      // previous action event\n        this.tapTime   = 0;         // time of the most recent tap event\n        this.prevTap   = null;\n\n        this.startOffset    = { left: 0, right: 0, top: 0, bottom: 0 };\n        this.restrictOffset = { left: 0, right: 0, top: 0, bottom: 0 };\n        this.snapOffsets    = [];\n\n        this.gesture = {\n            start: { x: 0, y: 0 },\n\n            startDistance: 0,   // distance between two touches of touchStart\n            prevDistance : 0,\n            distance     : 0,\n\n            scale: 1,           // gesture.distance / gesture.startDistance\n\n            startAngle: 0,      // angle of line joining two touches\n            prevAngle : 0       // angle of the previous gesture event\n        };\n\n        this.snapStatus = {\n            x       : 0, y       : 0,\n            dx      : 0, dy      : 0,\n            realX   : 0, realY   : 0,\n            snappedX: 0, snappedY: 0,\n            targets : [],\n            locked  : false,\n            changed : false\n        };\n\n        this.restrictStatus = {\n            dx         : 0, dy         : 0,\n            restrictedX: 0, restrictedY: 0,\n            snap       : null,\n            restricted : false,\n            changed    : false\n        };\n\n        this.restrictStatus.snap = this.snapStatus;\n\n        this.pointerIsDown   = false;\n        this.pointerWasMoved = false;\n        this.gesturing       = false;\n        this.dragging        = false;\n        this.resizing        = false;\n        this.resizeAxes      = 'xy';\n\n        this.mouse = false;\n\n        interactions.push(this);\n    }\n\n    Interaction.prototype = {\n        getPageXY  : function (pointer, xy) { return   getPageXY(pointer, xy, this); },\n        getClientXY: function (pointer, xy) { return getClientXY(pointer, xy, this); },\n        setEventXY : function (target, ptr) { return  setEventXY(target, ptr, this); },\n\n        pointerOver: function (pointer, event, eventTarget) {\n            if (this.prepared.name || !this.mouse) { return; }\n\n            var curMatches = [],\n                curMatchElements = [],\n                prevTargetElement = this.element;\n\n            this.addPointer(pointer);\n\n            if (this.target\n                && (testIgnore(this.target, this.element, eventTarget)\n                    || !testAllow(this.target, this.element, eventTarget))) {\n                // if the eventTarget should be ignored or shouldn't be allowed\n                // clear the previous target\n                this.target = null;\n                this.element = null;\n                this.matches = [];\n                this.matchElements = [];\n            }\n\n            var elementInteractable = interactables.get(eventTarget),\n                elementAction = (elementInteractable\n                                 && !testIgnore(elementInteractable, eventTarget, eventTarget)\n                                 && testAllow(elementInteractable, eventTarget, eventTarget)\n                                 && validateAction(\n                                     elementInteractable.getAction(pointer, event, this, eventTarget),\n                                     elementInteractable));\n\n            if (elementAction && !withinInteractionLimit(elementInteractable, eventTarget, elementAction)) {\n                 elementAction = null;\n            }\n\n            function pushCurMatches (interactable, selector) {\n                if (interactable\n                    && inContext(interactable, eventTarget)\n                    && !testIgnore(interactable, eventTarget, eventTarget)\n                    && testAllow(interactable, eventTarget, eventTarget)\n                    && matchesSelector(eventTarget, selector)) {\n\n                    curMatches.push(interactable);\n                    curMatchElements.push(eventTarget);\n                }\n            }\n\n            if (elementAction) {\n                this.target = elementInteractable;\n                this.element = eventTarget;\n                this.matches = [];\n                this.matchElements = [];\n            }\n            else {\n                interactables.forEachSelector(pushCurMatches);\n\n                if (this.validateSelector(pointer, event, curMatches, curMatchElements)) {\n                    this.matches = curMatches;\n                    this.matchElements = curMatchElements;\n\n                    this.pointerHover(pointer, event, this.matches, this.matchElements);\n                    events.add(eventTarget,\n                                        supportsPointerEvent? pEventTypes.move : 'mousemove',\n                                        listeners.pointerHover);\n                }\n                else if (this.target) {\n                    if (nodeContains(prevTargetElement, eventTarget)) {\n                        this.pointerHover(pointer, event, this.matches, this.matchElements);\n                        events.add(this.element,\n                                            supportsPointerEvent? pEventTypes.move : 'mousemove',\n                                            listeners.pointerHover);\n                    }\n                    else {\n                        this.target = null;\n                        this.element = null;\n                        this.matches = [];\n                        this.matchElements = [];\n                    }\n                }\n            }\n        },\n\n        // Check what action would be performed on pointerMove target if a mouse\n        // button were pressed and change the cursor accordingly\n        pointerHover: function (pointer, event, eventTarget, curEventTarget, matches, matchElements) {\n            var target = this.target;\n\n            if (!this.prepared.name && this.mouse) {\n\n                var action;\n\n                // update pointer coords for defaultActionChecker to use\n                this.setEventXY(this.curCoords, [pointer]);\n\n                if (matches) {\n                    action = this.validateSelector(pointer, event, matches, matchElements);\n                }\n                else if (target) {\n                    action = validateAction(target.getAction(this.pointers[0], event, this, this.element), this.target);\n                }\n\n                if (target && target.options.styleCursor) {\n                    if (action) {\n                        target._doc.documentElement.style.cursor = getActionCursor(action);\n                    }\n                    else {\n                        target._doc.documentElement.style.cursor = '';\n                    }\n                }\n            }\n            else if (this.prepared.name) {\n                this.checkAndPreventDefault(event, target, this.element);\n            }\n        },\n\n        pointerOut: function (pointer, event, eventTarget) {\n            if (this.prepared.name) { return; }\n\n            // Remove temporary event listeners for selector Interactables\n            if (!interactables.get(eventTarget)) {\n                events.remove(eventTarget,\n                                       supportsPointerEvent? pEventTypes.move : 'mousemove',\n                                       listeners.pointerHover);\n            }\n\n            if (this.target && this.target.options.styleCursor && !this.interacting()) {\n                this.target._doc.documentElement.style.cursor = '';\n            }\n        },\n\n        selectorDown: function (pointer, event, eventTarget, curEventTarget) {\n            var that = this,\n                // copy event to be used in timeout for IE8\n                eventCopy = events.useAttachEvent? extend({}, event) : event,\n                element = eventTarget,\n                pointerIndex = this.addPointer(pointer),\n                action;\n\n            this.holdTimers[pointerIndex] = setTimeout(function () {\n                that.pointerHold(events.useAttachEvent? eventCopy : pointer, eventCopy, eventTarget, curEventTarget);\n            }, defaultOptions._holdDuration);\n\n            this.pointerIsDown = true;\n\n            // Check if the down event hits the current inertia target\n            if (this.inertiaStatus.active && this.target.selector) {\n                // climb up the DOM tree from the event target\n                while (isElement(element)) {\n\n                    // if this element is the current inertia target element\n                    if (element === this.element\n                        // and the prospective action is the same as the ongoing one\n                        && validateAction(this.target.getAction(pointer, event, this, this.element), this.target).name === this.prepared.name) {\n\n                        // stop inertia so that the next move will be a normal one\n                        cancelFrame(this.inertiaStatus.i);\n                        this.inertiaStatus.active = false;\n\n                        this.collectEventTargets(pointer, event, eventTarget, 'down');\n                        return;\n                    }\n                    element = parentElement(element);\n                }\n            }\n\n            // do nothing if interacting\n            if (this.interacting()) {\n                this.collectEventTargets(pointer, event, eventTarget, 'down');\n                return;\n            }\n\n            function pushMatches (interactable, selector, context) {\n                var elements = ie8MatchesSelector\n                    ? context.querySelectorAll(selector)\n                    : undefined;\n\n                if (inContext(interactable, element)\n                    && !testIgnore(interactable, element, eventTarget)\n                    && testAllow(interactable, element, eventTarget)\n                    && matchesSelector(element, selector, elements)) {\n\n                    that.matches.push(interactable);\n                    that.matchElements.push(element);\n                }\n            }\n\n            // update pointer coords for defaultActionChecker to use\n            this.setEventXY(this.curCoords, [pointer]);\n            this.downEvent = event;\n\n            while (isElement(element) && !action) {\n                this.matches = [];\n                this.matchElements = [];\n\n                interactables.forEachSelector(pushMatches);\n\n                action = this.validateSelector(pointer, event, this.matches, this.matchElements);\n                element = parentElement(element);\n            }\n\n            if (action) {\n                this.prepared.name  = action.name;\n                this.prepared.axis  = action.axis;\n                this.prepared.edges = action.edges;\n\n                this.collectEventTargets(pointer, event, eventTarget, 'down');\n\n                return this.pointerDown(pointer, event, eventTarget, curEventTarget, action);\n            }\n            else {\n                // do these now since pointerDown isn't being called from here\n                this.downTimes[pointerIndex] = new Date().getTime();\n                this.downTargets[pointerIndex] = eventTarget;\n                pointerExtend(this.downPointer, pointer);\n\n                copyCoords(this.prevCoords, this.curCoords);\n                this.pointerWasMoved = false;\n            }\n\n            this.collectEventTargets(pointer, event, eventTarget, 'down');\n        },\n\n        // Determine action to be performed on next pointerMove and add appropriate\n        // style and event Listeners\n        pointerDown: function (pointer, event, eventTarget, curEventTarget, forceAction) {\n            if (!forceAction && !this.inertiaStatus.active && this.pointerWasMoved && this.prepared.name) {\n                this.checkAndPreventDefault(event, this.target, this.element);\n\n                return;\n            }\n\n            this.pointerIsDown = true;\n            this.downEvent = event;\n\n            var pointerIndex = this.addPointer(pointer),\n                action;\n\n            // If it is the second touch of a multi-touch gesture, keep the\n            // target the same and get a new action if a target was set by the\n            // first touch\n            if (this.pointerIds.length > 1 && this.target._element === this.element) {\n                var newAction = validateAction(forceAction || this.target.getAction(pointer, event, this, this.element), this.target);\n\n                if (withinInteractionLimit(this.target, this.element, newAction)) {\n                    action = newAction;\n                }\n\n                this.prepared.name = null;\n            }\n            // Otherwise, set the target if there is no action prepared\n            else if (!this.prepared.name) {\n                var interactable = interactables.get(curEventTarget);\n\n                if (interactable\n                    && !testIgnore(interactable, curEventTarget, eventTarget)\n                    && testAllow(interactable, curEventTarget, eventTarget)\n                    && (action = validateAction(forceAction || interactable.getAction(pointer, event, this, curEventTarget), interactable, eventTarget))\n                    && withinInteractionLimit(interactable, curEventTarget, action)) {\n                    this.target = interactable;\n                    this.element = curEventTarget;\n                }\n            }\n\n            var target = this.target,\n                options = target && target.options;\n\n            if (target && (forceAction || !this.prepared.name)) {\n                action = action || validateAction(forceAction || target.getAction(pointer, event, this, curEventTarget), target, this.element);\n\n                this.setEventXY(this.startCoords, this.pointers);\n\n                if (!action) { return; }\n\n                if (options.styleCursor) {\n                    target._doc.documentElement.style.cursor = getActionCursor(action);\n                }\n\n                this.resizeAxes = action.name === 'resize'? action.axis : null;\n\n                if (action === 'gesture' && this.pointerIds.length < 2) {\n                    action = null;\n                }\n\n                this.prepared.name  = action.name;\n                this.prepared.axis  = action.axis;\n                this.prepared.edges = action.edges;\n\n                this.snapStatus.snappedX = this.snapStatus.snappedY =\n                    this.restrictStatus.restrictedX = this.restrictStatus.restrictedY = NaN;\n\n                this.downTimes[pointerIndex] = new Date().getTime();\n                this.downTargets[pointerIndex] = eventTarget;\n                pointerExtend(this.downPointer, pointer);\n\n                copyCoords(this.prevCoords, this.startCoords);\n                this.pointerWasMoved = false;\n\n                this.checkAndPreventDefault(event, target, this.element);\n            }\n            // if inertia is active try to resume action\n            else if (this.inertiaStatus.active\n                && curEventTarget === this.element\n                && validateAction(target.getAction(pointer, event, this, this.element), target).name === this.prepared.name) {\n\n                cancelFrame(this.inertiaStatus.i);\n                this.inertiaStatus.active = false;\n\n                this.checkAndPreventDefault(event, target, this.element);\n            }\n        },\n\n        setModifications: function (coords, preEnd) {\n            var target         = this.target,\n                shouldMove     = true,\n                shouldSnap     = checkSnap(target, this.prepared.name)     && (!target.options[this.prepared.name].snap.endOnly     || preEnd),\n                shouldRestrict = checkRestrict(target, this.prepared.name) && (!target.options[this.prepared.name].restrict.endOnly || preEnd);\n\n            if (shouldSnap    ) { this.setSnapping   (coords); } else { this.snapStatus    .locked     = false; }\n            if (shouldRestrict) { this.setRestriction(coords); } else { this.restrictStatus.restricted = false; }\n\n            if (shouldSnap && this.snapStatus.locked && !this.snapStatus.changed) {\n                shouldMove = shouldRestrict && this.restrictStatus.restricted && this.restrictStatus.changed;\n            }\n            else if (shouldRestrict && this.restrictStatus.restricted && !this.restrictStatus.changed) {\n                shouldMove = false;\n            }\n\n            return shouldMove;\n        },\n\n        setStartOffsets: function (action, interactable, element) {\n            var rect = interactable.getRect(element),\n                origin = getOriginXY(interactable, element),\n                snap = interactable.options[this.prepared.name].snap,\n                restrict = interactable.options[this.prepared.name].restrict,\n                width, height;\n\n            if (rect) {\n                this.startOffset.left = this.startCoords.page.x - rect.left;\n                this.startOffset.top  = this.startCoords.page.y - rect.top;\n\n                this.startOffset.right  = rect.right  - this.startCoords.page.x;\n                this.startOffset.bottom = rect.bottom - this.startCoords.page.y;\n\n                if ('width' in rect) { width = rect.width; }\n                else { width = rect.right - rect.left; }\n                if ('height' in rect) { height = rect.height; }\n                else { height = rect.bottom - rect.top; }\n            }\n            else {\n                this.startOffset.left = this.startOffset.top = this.startOffset.right = this.startOffset.bottom = 0;\n            }\n\n            this.snapOffsets.splice(0);\n\n            var snapOffset = snap && snap.offset === 'startCoords'\n                                ? {\n                                    x: this.startCoords.page.x - origin.x,\n                                    y: this.startCoords.page.y - origin.y\n                                }\n                                : snap && snap.offset || { x: 0, y: 0 };\n\n            if (rect && snap && snap.relativePoints && snap.relativePoints.length) {\n                for (var i = 0; i < snap.relativePoints.length; i++) {\n                    this.snapOffsets.push({\n                        x: this.startOffset.left - (width  * snap.relativePoints[i].x) + snapOffset.x,\n                        y: this.startOffset.top  - (height * snap.relativePoints[i].y) + snapOffset.y\n                    });\n                }\n            }\n            else {\n                this.snapOffsets.push(snapOffset);\n            }\n\n            if (rect && restrict.elementRect) {\n                this.restrictOffset.left = this.startOffset.left - (width  * restrict.elementRect.left);\n                this.restrictOffset.top  = this.startOffset.top  - (height * restrict.elementRect.top);\n\n                this.restrictOffset.right  = this.startOffset.right  - (width  * (1 - restrict.elementRect.right));\n                this.restrictOffset.bottom = this.startOffset.bottom - (height * (1 - restrict.elementRect.bottom));\n            }\n            else {\n                this.restrictOffset.left = this.restrictOffset.top = this.restrictOffset.right = this.restrictOffset.bottom = 0;\n            }\n        },\n\n        /*\\\n         * Interaction.start\n         [ method ]\n         *\n         * Start an action with the given Interactable and Element as tartgets. The\n         * action must be enabled for the target Interactable and an appropriate number\n         * of pointers must be held down – 1 for drag/resize, 2 for gesture.\n         *\n         * Use it with `interactable.<action>able({ manualStart: false })` to always\n         * [start actions manually](https://github.com/taye/interact.js/issues/114)\n         *\n         - action       (object)  The action to be performed - drag, resize, etc.\n         - interactable (Interactable) The Interactable to target\n         - element      (Element) The DOM Element to target\n         = (object) interact\n         **\n         | interact(target)\n         |   .draggable({\n         |     // disable the default drag start by down->move\n         |     manualStart: true\n         |   })\n         |   // start dragging after the user holds the pointer down\n         |   .on('hold', function (event) {\n         |     var interaction = event.interaction;\n         |\n         |     if (!interaction.interacting()) {\n         |       interaction.start({ name: 'drag' },\n         |                         event.interactable,\n         |                         event.currentTarget);\n         |     }\n         | });\n        \\*/\n        start: function (action, interactable, element) {\n            if (this.interacting()\n                || !this.pointerIsDown\n                || this.pointerIds.length < (action.name === 'gesture'? 2 : 1)) {\n                return;\n            }\n\n            // if this interaction had been removed after stopping\n            // add it back\n            if (indexOf(interactions, this) === -1) {\n                interactions.push(this);\n            }\n\n            // set the startCoords if there was no prepared action\n            if (!this.prepared.name) {\n                this.setEventXY(this.startCoords, this.pointers);\n            }\n\n            this.prepared.name  = action.name;\n            this.prepared.axis  = action.axis;\n            this.prepared.edges = action.edges;\n            this.target         = interactable;\n            this.element        = element;\n\n            this.setStartOffsets(action.name, interactable, element);\n            this.setModifications(this.startCoords.page);\n\n            this.prevEvent = this[this.prepared.name + 'Start'](this.downEvent);\n        },\n\n        pointerMove: function (pointer, event, eventTarget, curEventTarget, preEnd) {\n            if (this.inertiaStatus.active) {\n                var pageUp   = this.inertiaStatus.upCoords.page;\n                var clientUp = this.inertiaStatus.upCoords.client;\n\n                var inertiaPosition = {\n                    pageX  : pageUp.x   + this.inertiaStatus.sx,\n                    pageY  : pageUp.y   + this.inertiaStatus.sy,\n                    clientX: clientUp.x + this.inertiaStatus.sx,\n                    clientY: clientUp.y + this.inertiaStatus.sy\n                };\n\n                this.setEventXY(this.curCoords, [inertiaPosition]);\n            }\n            else {\n                this.recordPointer(pointer);\n                this.setEventXY(this.curCoords, this.pointers);\n            }\n\n            var duplicateMove = (this.curCoords.page.x === this.prevCoords.page.x\n                                 && this.curCoords.page.y === this.prevCoords.page.y\n                                 && this.curCoords.client.x === this.prevCoords.client.x\n                                 && this.curCoords.client.y === this.prevCoords.client.y);\n\n            var dx, dy,\n                pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            // register movement greater than pointerMoveTolerance\n            if (this.pointerIsDown && !this.pointerWasMoved) {\n                dx = this.curCoords.client.x - this.startCoords.client.x;\n                dy = this.curCoords.client.y - this.startCoords.client.y;\n\n                this.pointerWasMoved = hypot(dx, dy) > pointerMoveTolerance;\n            }\n\n            if (!duplicateMove && (!this.pointerIsDown || this.pointerWasMoved)) {\n                if (this.pointerIsDown) {\n                    clearTimeout(this.holdTimers[pointerIndex]);\n                }\n\n                this.collectEventTargets(pointer, event, eventTarget, 'move');\n            }\n\n            if (!this.pointerIsDown) { return; }\n\n            if (duplicateMove && this.pointerWasMoved && !preEnd) {\n                this.checkAndPreventDefault(event, this.target, this.element);\n                return;\n            }\n\n            // set pointer coordinate, time changes and speeds\n            setEventDeltas(this.pointerDelta, this.prevCoords, this.curCoords);\n\n            if (!this.prepared.name) { return; }\n\n            if (this.pointerWasMoved\n                // ignore movement while inertia is active\n                && (!this.inertiaStatus.active || (pointer instanceof InteractEvent && /inertiastart/.test(pointer.type)))) {\n\n                // if just starting an action, calculate the pointer speed now\n                if (!this.interacting()) {\n                    setEventDeltas(this.pointerDelta, this.prevCoords, this.curCoords);\n\n                    // check if a drag is in the correct axis\n                    if (this.prepared.name === 'drag') {\n                        var absX = Math.abs(dx),\n                            absY = Math.abs(dy),\n                            targetAxis = this.target.options.drag.axis,\n                            axis = (absX > absY ? 'x' : absX < absY ? 'y' : 'xy');\n\n                        // if the movement isn't in the axis of the interactable\n                        if (axis !== 'xy' && targetAxis !== 'xy' && targetAxis !== axis) {\n                            // cancel the prepared action\n                            this.prepared.name = null;\n\n                            // then try to get a drag from another ineractable\n\n                            var element = eventTarget;\n\n                            // check element interactables\n                            while (isElement(element)) {\n                                var elementInteractable = interactables.get(element);\n\n                                if (elementInteractable\n                                    && elementInteractable !== this.target\n                                    && !elementInteractable.options.drag.manualStart\n                                    && elementInteractable.getAction(this.downPointer, this.downEvent, this, element).name === 'drag'\n                                    && checkAxis(axis, elementInteractable)) {\n\n                                    this.prepared.name = 'drag';\n                                    this.target = elementInteractable;\n                                    this.element = element;\n                                    break;\n                                }\n\n                                element = parentElement(element);\n                            }\n\n                            // if there's no drag from element interactables,\n                            // check the selector interactables\n                            if (!this.prepared.name) {\n                                var thisInteraction = this;\n\n                                var getDraggable = function (interactable, selector, context) {\n                                    var elements = ie8MatchesSelector\n                                        ? context.querySelectorAll(selector)\n                                        : undefined;\n\n                                    if (interactable === thisInteraction.target) { return; }\n\n                                    if (inContext(interactable, eventTarget)\n                                        && !interactable.options.drag.manualStart\n                                        && !testIgnore(interactable, element, eventTarget)\n                                        && testAllow(interactable, element, eventTarget)\n                                        && matchesSelector(element, selector, elements)\n                                        && interactable.getAction(thisInteraction.downPointer, thisInteraction.downEvent, thisInteraction, element).name === 'drag'\n                                        && checkAxis(axis, interactable)\n                                        && withinInteractionLimit(interactable, element, 'drag')) {\n\n                                        return interactable;\n                                    }\n                                };\n\n                                element = eventTarget;\n\n                                while (isElement(element)) {\n                                    var selectorInteractable = interactables.forEachSelector(getDraggable);\n\n                                    if (selectorInteractable) {\n                                        this.prepared.name = 'drag';\n                                        this.target = selectorInteractable;\n                                        this.element = element;\n                                        break;\n                                    }\n\n                                    element = parentElement(element);\n                                }\n                            }\n                        }\n                    }\n                }\n\n                var starting = !!this.prepared.name && !this.interacting();\n\n                if (starting\n                    && (this.target.options[this.prepared.name].manualStart\n                        || !withinInteractionLimit(this.target, this.element, this.prepared))) {\n                    this.stop(event);\n                    return;\n                }\n\n                if (this.prepared.name && this.target) {\n                    if (starting) {\n                        this.start(this.prepared, this.target, this.element);\n                    }\n\n                    var shouldMove = this.setModifications(this.curCoords.page, preEnd);\n\n                    // move if snapping or restriction doesn't prevent it\n                    if (shouldMove || starting) {\n                        this.prevEvent = this[this.prepared.name + 'Move'](event);\n                    }\n\n                    this.checkAndPreventDefault(event, this.target, this.element);\n                }\n            }\n\n            copyCoords(this.prevCoords, this.curCoords);\n\n            if (this.dragging || this.resizing) {\n                this.autoScrollMove(pointer);\n            }\n        },\n\n        dragStart: function (event) {\n            var dragEvent = new InteractEvent(this, event, 'drag', 'start', this.element);\n\n            this.dragging = true;\n            this.target.fire(dragEvent);\n\n            // reset active dropzones\n            this.activeDrops.dropzones = [];\n            this.activeDrops.elements  = [];\n            this.activeDrops.rects     = [];\n\n            if (!this.dynamicDrop) {\n                this.setActiveDrops(this.element);\n            }\n\n            var dropEvents = this.getDropEvents(event, dragEvent);\n\n            if (dropEvents.activate) {\n                this.fireActiveDrops(dropEvents.activate);\n            }\n\n            return dragEvent;\n        },\n\n        dragMove: function (event) {\n            var target = this.target,\n                dragEvent  = new InteractEvent(this, event, 'drag', 'move', this.element),\n                draggableElement = this.element,\n                drop = this.getDrop(dragEvent, event, draggableElement);\n\n            this.dropTarget = drop.dropzone;\n            this.dropElement = drop.element;\n\n            var dropEvents = this.getDropEvents(event, dragEvent);\n\n            target.fire(dragEvent);\n\n            if (dropEvents.leave) { this.prevDropTarget.fire(dropEvents.leave); }\n            if (dropEvents.enter) {     this.dropTarget.fire(dropEvents.enter); }\n            if (dropEvents.move ) {     this.dropTarget.fire(dropEvents.move ); }\n\n            this.prevDropTarget  = this.dropTarget;\n            this.prevDropElement = this.dropElement;\n\n            return dragEvent;\n        },\n\n        resizeStart: function (event) {\n            var resizeEvent = new InteractEvent(this, event, 'resize', 'start', this.element);\n\n            if (this.prepared.edges) {\n                var startRect = this.target.getRect(this.element);\n\n                /*\n                 * When using the `resizable.square` or `resizable.preserveAspectRatio` options, resizing from one edge\n                 * will affect another. E.g. with `resizable.square`, resizing to make the right edge larger will make\n                 * the bottom edge larger by the same amount. We call these 'linked' edges. Any linked edges will depend\n                 * on the active edges and the edge being interacted with.\n                 */\n                if (this.target.options.resize.square || this.target.options.resize.preserveAspectRatio) {\n                    var linkedEdges = extend({}, this.prepared.edges);\n\n                    linkedEdges.top    = linkedEdges.top    || (linkedEdges.left   && !linkedEdges.bottom);\n                    linkedEdges.left   = linkedEdges.left   || (linkedEdges.top    && !linkedEdges.right );\n                    linkedEdges.bottom = linkedEdges.bottom || (linkedEdges.right  && !linkedEdges.top   );\n                    linkedEdges.right  = linkedEdges.right  || (linkedEdges.bottom && !linkedEdges.left  );\n\n                    this.prepared._linkedEdges = linkedEdges;\n                }\n                else {\n                    this.prepared._linkedEdges = null;\n                }\n\n                // if using `resizable.preserveAspectRatio` option, record aspect ratio at the start of the resize\n                if (this.target.options.resize.preserveAspectRatio) {\n                    this.resizeStartAspectRatio = startRect.width / startRect.height;\n                }\n\n                this.resizeRects = {\n                    start     : startRect,\n                    current   : extend({}, startRect),\n                    restricted: extend({}, startRect),\n                    previous  : extend({}, startRect),\n                    delta     : {\n                        left: 0, right : 0, width : 0,\n                        top : 0, bottom: 0, height: 0\n                    }\n                };\n\n                resizeEvent.rect = this.resizeRects.restricted;\n                resizeEvent.deltaRect = this.resizeRects.delta;\n            }\n\n            this.target.fire(resizeEvent);\n\n            this.resizing = true;\n\n            return resizeEvent;\n        },\n\n        resizeMove: function (event) {\n            var resizeEvent = new InteractEvent(this, event, 'resize', 'move', this.element);\n\n            var edges = this.prepared.edges,\n                invert = this.target.options.resize.invert,\n                invertible = invert === 'reposition' || invert === 'negate';\n\n            if (edges) {\n                var dx = resizeEvent.dx,\n                    dy = resizeEvent.dy,\n\n                    start      = this.resizeRects.start,\n                    current    = this.resizeRects.current,\n                    restricted = this.resizeRects.restricted,\n                    delta      = this.resizeRects.delta,\n                    previous   = extend(this.resizeRects.previous, restricted),\n\n                    originalEdges = edges;\n\n                // `resize.preserveAspectRatio` takes precedence over `resize.square`\n                if (this.target.options.resize.preserveAspectRatio) {\n                    var resizeStartAspectRatio = this.resizeStartAspectRatio;\n\n                    edges = this.prepared._linkedEdges;\n\n                    if ((originalEdges.left && originalEdges.bottom)\n                        || (originalEdges.right && originalEdges.top)) {\n                        dy = -dx / resizeStartAspectRatio;\n                    }\n                    else if (originalEdges.left || originalEdges.right) { dy = dx / resizeStartAspectRatio; }\n                    else if (originalEdges.top || originalEdges.bottom) { dx = dy * resizeStartAspectRatio; }\n                }\n                else if (this.target.options.resize.square) {\n                    edges = this.prepared._linkedEdges;\n\n                    if ((originalEdges.left && originalEdges.bottom)\n                        || (originalEdges.right && originalEdges.top)) {\n                        dy = -dx;\n                    }\n                    else if (originalEdges.left || originalEdges.right) { dy = dx; }\n                    else if (originalEdges.top || originalEdges.bottom) { dx = dy; }\n                }\n\n                // update the 'current' rect without modifications\n                if (edges.top   ) { current.top    += dy; }\n                if (edges.bottom) { current.bottom += dy; }\n                if (edges.left  ) { current.left   += dx; }\n                if (edges.right ) { current.right  += dx; }\n\n                if (invertible) {\n                    // if invertible, copy the current rect\n                    extend(restricted, current);\n\n                    if (invert === 'reposition') {\n                        // swap edge values if necessary to keep width/height positive\n                        var swap;\n\n                        if (restricted.top > restricted.bottom) {\n                            swap = restricted.top;\n\n                            restricted.top = restricted.bottom;\n                            restricted.bottom = swap;\n                        }\n                        if (restricted.left > restricted.right) {\n                            swap = restricted.left;\n\n                            restricted.left = restricted.right;\n                            restricted.right = swap;\n                        }\n                    }\n                }\n                else {\n                    // if not invertible, restrict to minimum of 0x0 rect\n                    restricted.top    = Math.min(current.top, start.bottom);\n                    restricted.bottom = Math.max(current.bottom, start.top);\n                    restricted.left   = Math.min(current.left, start.right);\n                    restricted.right  = Math.max(current.right, start.left);\n                }\n\n                restricted.width  = restricted.right  - restricted.left;\n                restricted.height = restricted.bottom - restricted.top ;\n\n                for (var edge in restricted) {\n                    delta[edge] = restricted[edge] - previous[edge];\n                }\n\n                resizeEvent.edges = this.prepared.edges;\n                resizeEvent.rect = restricted;\n                resizeEvent.deltaRect = delta;\n            }\n\n            this.target.fire(resizeEvent);\n\n            return resizeEvent;\n        },\n\n        gestureStart: function (event) {\n            var gestureEvent = new InteractEvent(this, event, 'gesture', 'start', this.element);\n\n            gestureEvent.ds = 0;\n\n            this.gesture.startDistance = this.gesture.prevDistance = gestureEvent.distance;\n            this.gesture.startAngle = this.gesture.prevAngle = gestureEvent.angle;\n            this.gesture.scale = 1;\n\n            this.gesturing = true;\n\n            this.target.fire(gestureEvent);\n\n            return gestureEvent;\n        },\n\n        gestureMove: function (event) {\n            if (!this.pointerIds.length) {\n                return this.prevEvent;\n            }\n\n            var gestureEvent;\n\n            gestureEvent = new InteractEvent(this, event, 'gesture', 'move', this.element);\n            gestureEvent.ds = gestureEvent.scale - this.gesture.scale;\n\n            this.target.fire(gestureEvent);\n\n            this.gesture.prevAngle = gestureEvent.angle;\n            this.gesture.prevDistance = gestureEvent.distance;\n\n            if (gestureEvent.scale !== Infinity &&\n                gestureEvent.scale !== null &&\n                gestureEvent.scale !== undefined  &&\n                !isNaN(gestureEvent.scale)) {\n\n                this.gesture.scale = gestureEvent.scale;\n            }\n\n            return gestureEvent;\n        },\n\n        pointerHold: function (pointer, event, eventTarget) {\n            this.collectEventTargets(pointer, event, eventTarget, 'hold');\n        },\n\n        pointerUp: function (pointer, event, eventTarget, curEventTarget) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            clearTimeout(this.holdTimers[pointerIndex]);\n\n            this.collectEventTargets(pointer, event, eventTarget, 'up' );\n            this.collectEventTargets(pointer, event, eventTarget, 'tap');\n\n            this.pointerEnd(pointer, event, eventTarget, curEventTarget);\n\n            this.removePointer(pointer);\n        },\n\n        pointerCancel: function (pointer, event, eventTarget, curEventTarget) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            clearTimeout(this.holdTimers[pointerIndex]);\n\n            this.collectEventTargets(pointer, event, eventTarget, 'cancel');\n            this.pointerEnd(pointer, event, eventTarget, curEventTarget);\n\n            this.removePointer(pointer);\n        },\n\n        // http://www.quirksmode.org/dom/events/click.html\n        // >Events leading to dblclick\n        //\n        // IE8 doesn't fire down event before dblclick.\n        // This workaround tries to fire a tap and doubletap after dblclick\n        ie8Dblclick: function (pointer, event, eventTarget) {\n            if (this.prevTap\n                && event.clientX === this.prevTap.clientX\n                && event.clientY === this.prevTap.clientY\n                && eventTarget   === this.prevTap.target) {\n\n                this.downTargets[0] = eventTarget;\n                this.downTimes[0] = new Date().getTime();\n                this.collectEventTargets(pointer, event, eventTarget, 'tap');\n            }\n        },\n\n        // End interact move events and stop auto-scroll unless inertia is enabled\n        pointerEnd: function (pointer, event, eventTarget, curEventTarget) {\n            var endEvent,\n                target = this.target,\n                options = target && target.options,\n                inertiaOptions = options && this.prepared.name && options[this.prepared.name].inertia,\n                inertiaStatus = this.inertiaStatus;\n\n            if (this.interacting()) {\n\n                if (inertiaStatus.active && !inertiaStatus.ending) { return; }\n\n                var pointerSpeed,\n                    now = new Date().getTime(),\n                    inertiaPossible = false,\n                    inertia = false,\n                    smoothEnd = false,\n                    endSnap = checkSnap(target, this.prepared.name) && options[this.prepared.name].snap.endOnly,\n                    endRestrict = checkRestrict(target, this.prepared.name) && options[this.prepared.name].restrict.endOnly,\n                    dx = 0,\n                    dy = 0,\n                    startEvent;\n\n                if (this.dragging) {\n                    if      (options.drag.axis === 'x' ) { pointerSpeed = Math.abs(this.pointerDelta.client.vx); }\n                    else if (options.drag.axis === 'y' ) { pointerSpeed = Math.abs(this.pointerDelta.client.vy); }\n                    else   /*options.drag.axis === 'xy'*/{ pointerSpeed = this.pointerDelta.client.speed; }\n                }\n                else {\n                    pointerSpeed = this.pointerDelta.client.speed;\n                }\n\n                // check if inertia should be started\n                inertiaPossible = (inertiaOptions && inertiaOptions.enabled\n                                   && this.prepared.name !== 'gesture'\n                                   && event !== inertiaStatus.startEvent);\n\n                inertia = (inertiaPossible\n                           && (now - this.curCoords.timeStamp) < 50\n                           && pointerSpeed > inertiaOptions.minSpeed\n                           && pointerSpeed > inertiaOptions.endSpeed);\n\n                if (inertiaPossible && !inertia && (endSnap || endRestrict)) {\n\n                    var snapRestrict = {};\n\n                    snapRestrict.snap = snapRestrict.restrict = snapRestrict;\n\n                    if (endSnap) {\n                        this.setSnapping(this.curCoords.page, snapRestrict);\n                        if (snapRestrict.locked) {\n                            dx += snapRestrict.dx;\n                            dy += snapRestrict.dy;\n                        }\n                    }\n\n                    if (endRestrict) {\n                        this.setRestriction(this.curCoords.page, snapRestrict);\n                        if (snapRestrict.restricted) {\n                            dx += snapRestrict.dx;\n                            dy += snapRestrict.dy;\n                        }\n                    }\n\n                    if (dx || dy) {\n                        smoothEnd = true;\n                    }\n                }\n\n                if (inertia || smoothEnd) {\n                    copyCoords(inertiaStatus.upCoords, this.curCoords);\n\n                    this.pointers[0] = inertiaStatus.startEvent = startEvent =\n                        new InteractEvent(this, event, this.prepared.name, 'inertiastart', this.element);\n\n                    inertiaStatus.t0 = now;\n\n                    target.fire(inertiaStatus.startEvent);\n\n                    if (inertia) {\n                        inertiaStatus.vx0 = this.pointerDelta.client.vx;\n                        inertiaStatus.vy0 = this.pointerDelta.client.vy;\n                        inertiaStatus.v0 = pointerSpeed;\n\n                        this.calcInertia(inertiaStatus);\n\n                        var page = extend({}, this.curCoords.page),\n                            origin = getOriginXY(target, this.element),\n                            statusObject;\n\n                        page.x = page.x + inertiaStatus.xe - origin.x;\n                        page.y = page.y + inertiaStatus.ye - origin.y;\n\n                        statusObject = {\n                            useStatusXY: true,\n                            x: page.x,\n                            y: page.y,\n                            dx: 0,\n                            dy: 0,\n                            snap: null\n                        };\n\n                        statusObject.snap = statusObject;\n\n                        dx = dy = 0;\n\n                        if (endSnap) {\n                            var snap = this.setSnapping(this.curCoords.page, statusObject);\n\n                            if (snap.locked) {\n                                dx += snap.dx;\n                                dy += snap.dy;\n                            }\n                        }\n\n                        if (endRestrict) {\n                            var restrict = this.setRestriction(this.curCoords.page, statusObject);\n\n                            if (restrict.restricted) {\n                                dx += restrict.dx;\n                                dy += restrict.dy;\n                            }\n                        }\n\n                        inertiaStatus.modifiedXe += dx;\n                        inertiaStatus.modifiedYe += dy;\n\n                        inertiaStatus.i = reqFrame(this.boundInertiaFrame);\n                    }\n                    else {\n                        inertiaStatus.smoothEnd = true;\n                        inertiaStatus.xe = dx;\n                        inertiaStatus.ye = dy;\n\n                        inertiaStatus.sx = inertiaStatus.sy = 0;\n\n                        inertiaStatus.i = reqFrame(this.boundSmoothEndFrame);\n                    }\n\n                    inertiaStatus.active = true;\n                    return;\n                }\n\n                if (endSnap || endRestrict) {\n                    // fire a move event at the snapped coordinates\n                    this.pointerMove(pointer, event, eventTarget, curEventTarget, true);\n                }\n            }\n\n            if (this.dragging) {\n                endEvent = new InteractEvent(this, event, 'drag', 'end', this.element);\n\n                var draggableElement = this.element,\n                    drop = this.getDrop(endEvent, event, draggableElement);\n\n                this.dropTarget = drop.dropzone;\n                this.dropElement = drop.element;\n\n                var dropEvents = this.getDropEvents(event, endEvent);\n\n                if (dropEvents.leave) { this.prevDropTarget.fire(dropEvents.leave); }\n                if (dropEvents.enter) {     this.dropTarget.fire(dropEvents.enter); }\n                if (dropEvents.drop ) {     this.dropTarget.fire(dropEvents.drop ); }\n                if (dropEvents.deactivate) {\n                    this.fireActiveDrops(dropEvents.deactivate);\n                }\n\n                target.fire(endEvent);\n            }\n            else if (this.resizing) {\n                endEvent = new InteractEvent(this, event, 'resize', 'end', this.element);\n                target.fire(endEvent);\n            }\n            else if (this.gesturing) {\n                endEvent = new InteractEvent(this, event, 'gesture', 'end', this.element);\n                target.fire(endEvent);\n            }\n\n            this.stop(event);\n        },\n\n        collectDrops: function (element) {\n            var drops = [],\n                elements = [],\n                i;\n\n            element = element || this.element;\n\n            // collect all dropzones and their elements which qualify for a drop\n            for (i = 0; i < interactables.length; i++) {\n                if (!interactables[i].options.drop.enabled) { continue; }\n\n                var current = interactables[i],\n                    accept = current.options.drop.accept;\n\n                // test the draggable element against the dropzone's accept setting\n                if ((isElement(accept) && accept !== element)\n                    || (isString(accept)\n                        && !matchesSelector(element, accept))) {\n\n                    continue;\n                }\n\n                // query for new elements if necessary\n                var dropElements = current.selector? current._context.querySelectorAll(current.selector) : [current._element];\n\n                for (var j = 0, len = dropElements.length; j < len; j++) {\n                    var currentElement = dropElements[j];\n\n                    if (currentElement === element) {\n                        continue;\n                    }\n\n                    drops.push(current);\n                    elements.push(currentElement);\n                }\n            }\n\n            return {\n                dropzones: drops,\n                elements: elements\n            };\n        },\n\n        fireActiveDrops: function (event) {\n            var i,\n                current,\n                currentElement,\n                prevElement;\n\n            // loop through all active dropzones and trigger event\n            for (i = 0; i < this.activeDrops.dropzones.length; i++) {\n                current = this.activeDrops.dropzones[i];\n                currentElement = this.activeDrops.elements [i];\n\n                // prevent trigger of duplicate events on same element\n                if (currentElement !== prevElement) {\n                    // set current element as event target\n                    event.target = currentElement;\n                    current.fire(event);\n                }\n                prevElement = currentElement;\n            }\n        },\n\n        // Collect a new set of possible drops and save them in activeDrops.\n        // setActiveDrops should always be called when a drag has just started or a\n        // drag event happens while dynamicDrop is true\n        setActiveDrops: function (dragElement) {\n            // get dropzones and their elements that could receive the draggable\n            var possibleDrops = this.collectDrops(dragElement, true);\n\n            this.activeDrops.dropzones = possibleDrops.dropzones;\n            this.activeDrops.elements  = possibleDrops.elements;\n            this.activeDrops.rects     = [];\n\n            for (var i = 0; i < this.activeDrops.dropzones.length; i++) {\n                this.activeDrops.rects[i] = this.activeDrops.dropzones[i].getRect(this.activeDrops.elements[i]);\n            }\n        },\n\n        getDrop: function (dragEvent, event, dragElement) {\n            var validDrops = [];\n\n            if (dynamicDrop) {\n                this.setActiveDrops(dragElement);\n            }\n\n            // collect all dropzones and their elements which qualify for a drop\n            for (var j = 0; j < this.activeDrops.dropzones.length; j++) {\n                var current        = this.activeDrops.dropzones[j],\n                    currentElement = this.activeDrops.elements [j],\n                    rect           = this.activeDrops.rects    [j];\n\n                validDrops.push(current.dropCheck(dragEvent, event, this.target, dragElement, currentElement, rect)\n                                ? currentElement\n                                : null);\n            }\n\n            // get the most appropriate dropzone based on DOM depth and order\n            var dropIndex = indexOfDeepestElement(validDrops),\n                dropzone  = this.activeDrops.dropzones[dropIndex] || null,\n                element   = this.activeDrops.elements [dropIndex] || null;\n\n            return {\n                dropzone: dropzone,\n                element: element\n            };\n        },\n\n        getDropEvents: function (pointerEvent, dragEvent) {\n            var dropEvents = {\n                enter     : null,\n                leave     : null,\n                activate  : null,\n                deactivate: null,\n                move      : null,\n                drop      : null\n            };\n\n            if (this.dropElement !== this.prevDropElement) {\n                // if there was a prevDropTarget, create a dragleave event\n                if (this.prevDropTarget) {\n                    dropEvents.leave = {\n                        target       : this.prevDropElement,\n                        dropzone     : this.prevDropTarget,\n                        relatedTarget: dragEvent.target,\n                        draggable    : dragEvent.interactable,\n                        dragEvent    : dragEvent,\n                        interaction  : this,\n                        timeStamp    : dragEvent.timeStamp,\n                        type         : 'dragleave'\n                    };\n\n                    dragEvent.dragLeave = this.prevDropElement;\n                    dragEvent.prevDropzone = this.prevDropTarget;\n                }\n                // if the dropTarget is not null, create a dragenter event\n                if (this.dropTarget) {\n                    dropEvents.enter = {\n                        target       : this.dropElement,\n                        dropzone     : this.dropTarget,\n                        relatedTarget: dragEvent.target,\n                        draggable    : dragEvent.interactable,\n                        dragEvent    : dragEvent,\n                        interaction  : this,\n                        timeStamp    : dragEvent.timeStamp,\n                        type         : 'dragenter'\n                    };\n\n                    dragEvent.dragEnter = this.dropElement;\n                    dragEvent.dropzone = this.dropTarget;\n                }\n            }\n\n            if (dragEvent.type === 'dragend' && this.dropTarget) {\n                dropEvents.drop = {\n                    target       : this.dropElement,\n                    dropzone     : this.dropTarget,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'drop'\n                };\n\n                dragEvent.dropzone = this.dropTarget;\n            }\n            if (dragEvent.type === 'dragstart') {\n                dropEvents.activate = {\n                    target       : null,\n                    dropzone     : null,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'dropactivate'\n                };\n            }\n            if (dragEvent.type === 'dragend') {\n                dropEvents.deactivate = {\n                    target       : null,\n                    dropzone     : null,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'dropdeactivate'\n                };\n            }\n            if (dragEvent.type === 'dragmove' && this.dropTarget) {\n                dropEvents.move = {\n                    target       : this.dropElement,\n                    dropzone     : this.dropTarget,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    dragmove     : dragEvent,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'dropmove'\n                };\n                dragEvent.dropzone = this.dropTarget;\n            }\n\n            return dropEvents;\n        },\n\n        currentAction: function () {\n            return (this.dragging && 'drag') || (this.resizing && 'resize') || (this.gesturing && 'gesture') || null;\n        },\n\n        interacting: function () {\n            return this.dragging || this.resizing || this.gesturing;\n        },\n\n        clearTargets: function () {\n            this.target = this.element = null;\n\n            this.dropTarget = this.dropElement = this.prevDropTarget = this.prevDropElement = null;\n        },\n\n        stop: function (event) {\n            if (this.interacting()) {\n                autoScroll.stop();\n                this.matches = [];\n                this.matchElements = [];\n\n                var target = this.target;\n\n                if (target.options.styleCursor) {\n                    target._doc.documentElement.style.cursor = '';\n                }\n\n                // prevent Default only if were previously interacting\n                if (event && isFunction(event.preventDefault)) {\n                    this.checkAndPreventDefault(event, target, this.element);\n                }\n\n                if (this.dragging) {\n                    this.activeDrops.dropzones = this.activeDrops.elements = this.activeDrops.rects = null;\n                }\n            }\n\n            this.clearTargets();\n\n            this.pointerIsDown = this.snapStatus.locked = this.dragging = this.resizing = this.gesturing = false;\n            this.prepared.name = this.prevEvent = null;\n            this.inertiaStatus.resumeDx = this.inertiaStatus.resumeDy = 0;\n\n            // remove pointers if their ID isn't in this.pointerIds\n            for (var i = 0; i < this.pointers.length; i++) {\n                if (indexOf(this.pointerIds, getPointerId(this.pointers[i])) === -1) {\n                    this.pointers.splice(i, 1);\n                }\n            }\n        },\n\n        inertiaFrame: function () {\n            var inertiaStatus = this.inertiaStatus,\n                options = this.target.options[this.prepared.name].inertia,\n                lambda = options.resistance,\n                t = new Date().getTime() / 1000 - inertiaStatus.t0;\n\n            if (t < inertiaStatus.te) {\n\n                var progress =  1 - (Math.exp(-lambda * t) - inertiaStatus.lambda_v0) / inertiaStatus.one_ve_v0;\n\n                if (inertiaStatus.modifiedXe === inertiaStatus.xe && inertiaStatus.modifiedYe === inertiaStatus.ye) {\n                    inertiaStatus.sx = inertiaStatus.xe * progress;\n                    inertiaStatus.sy = inertiaStatus.ye * progress;\n                }\n                else {\n                    var quadPoint = getQuadraticCurvePoint(\n                            0, 0,\n                            inertiaStatus.xe, inertiaStatus.ye,\n                            inertiaStatus.modifiedXe, inertiaStatus.modifiedYe,\n                            progress);\n\n                    inertiaStatus.sx = quadPoint.x;\n                    inertiaStatus.sy = quadPoint.y;\n                }\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.i = reqFrame(this.boundInertiaFrame);\n            }\n            else {\n                inertiaStatus.ending = true;\n\n                inertiaStatus.sx = inertiaStatus.modifiedXe;\n                inertiaStatus.sy = inertiaStatus.modifiedYe;\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n                this.pointerEnd(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.active = inertiaStatus.ending = false;\n            }\n        },\n\n        smoothEndFrame: function () {\n            var inertiaStatus = this.inertiaStatus,\n                t = new Date().getTime() - inertiaStatus.t0,\n                duration = this.target.options[this.prepared.name].inertia.smoothEndDuration;\n\n            if (t < duration) {\n                inertiaStatus.sx = easeOutQuad(t, 0, inertiaStatus.xe, duration);\n                inertiaStatus.sy = easeOutQuad(t, 0, inertiaStatus.ye, duration);\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.i = reqFrame(this.boundSmoothEndFrame);\n            }\n            else {\n                inertiaStatus.ending = true;\n\n                inertiaStatus.sx = inertiaStatus.xe;\n                inertiaStatus.sy = inertiaStatus.ye;\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n                this.pointerEnd(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.smoothEnd =\n                  inertiaStatus.active = inertiaStatus.ending = false;\n            }\n        },\n\n        addPointer: function (pointer) {\n            var id = getPointerId(pointer),\n                index = this.mouse? 0 : indexOf(this.pointerIds, id);\n\n            if (index === -1) {\n                index = this.pointerIds.length;\n            }\n\n            this.pointerIds[index] = id;\n            this.pointers[index] = pointer;\n\n            return index;\n        },\n\n        removePointer: function (pointer) {\n            var id = getPointerId(pointer),\n                index = this.mouse? 0 : indexOf(this.pointerIds, id);\n\n            if (index === -1) { return; }\n\n            this.pointers   .splice(index, 1);\n            this.pointerIds .splice(index, 1);\n            this.downTargets.splice(index, 1);\n            this.downTimes  .splice(index, 1);\n            this.holdTimers .splice(index, 1);\n        },\n\n        recordPointer: function (pointer) {\n            var index = this.mouse? 0: indexOf(this.pointerIds, getPointerId(pointer));\n\n            if (index === -1) { return; }\n\n            this.pointers[index] = pointer;\n        },\n\n        collectEventTargets: function (pointer, event, eventTarget, eventType) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            // do not fire a tap event if the pointer was moved before being lifted\n            if (eventType === 'tap' && (this.pointerWasMoved\n                // or if the pointerup target is different to the pointerdown target\n                || !(this.downTargets[pointerIndex] && this.downTargets[pointerIndex] === eventTarget))) {\n                return;\n            }\n\n            var targets = [],\n                elements = [],\n                element = eventTarget;\n\n            function collectSelectors (interactable, selector, context) {\n                var els = ie8MatchesSelector\n                        ? context.querySelectorAll(selector)\n                        : undefined;\n\n                if (interactable._iEvents[eventType]\n                    && isElement(element)\n                    && inContext(interactable, element)\n                    && !testIgnore(interactable, element, eventTarget)\n                    && testAllow(interactable, element, eventTarget)\n                    && matchesSelector(element, selector, els)) {\n\n                    targets.push(interactable);\n                    elements.push(element);\n                }\n            }\n\n            while (element) {\n                if (interact.isSet(element) && interact(element)._iEvents[eventType]) {\n                    targets.push(interact(element));\n                    elements.push(element);\n                }\n\n                interactables.forEachSelector(collectSelectors);\n\n                element = parentElement(element);\n            }\n\n            // create the tap event even if there are no listeners so that\n            // doubletap can still be created and fired\n            if (targets.length || eventType === 'tap') {\n                this.firePointers(pointer, event, eventTarget, targets, elements, eventType);\n            }\n        },\n\n        firePointers: function (pointer, event, eventTarget, targets, elements, eventType) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer)),\n                pointerEvent = {},\n                i,\n                // for tap events\n                interval, createNewDoubleTap;\n\n            // if it's a doubletap then the event properties would have been\n            // copied from the tap event and provided as the pointer argument\n            if (eventType === 'doubletap') {\n                pointerEvent = pointer;\n            }\n            else {\n                pointerExtend(pointerEvent, event);\n                if (event !== pointer) {\n                    pointerExtend(pointerEvent, pointer);\n                }\n\n                pointerEvent.preventDefault           = preventOriginalDefault;\n                pointerEvent.stopPropagation          = InteractEvent.prototype.stopPropagation;\n                pointerEvent.stopImmediatePropagation = InteractEvent.prototype.stopImmediatePropagation;\n                pointerEvent.interaction              = this;\n\n                pointerEvent.timeStamp       = new Date().getTime();\n                pointerEvent.originalEvent   = event;\n                pointerEvent.originalPointer = pointer;\n                pointerEvent.type            = eventType;\n                pointerEvent.pointerId       = getPointerId(pointer);\n                pointerEvent.pointerType     = this.mouse? 'mouse' : !supportsPointerEvent? 'touch'\n                                                    : isString(pointer.pointerType)\n                                                        ? pointer.pointerType\n                                                        : [,,'touch', 'pen', 'mouse'][pointer.pointerType];\n            }\n\n            if (eventType === 'tap') {\n                pointerEvent.dt = pointerEvent.timeStamp - this.downTimes[pointerIndex];\n\n                interval = pointerEvent.timeStamp - this.tapTime;\n                createNewDoubleTap = !!(this.prevTap && this.prevTap.type !== 'doubletap'\n                       && this.prevTap.target === pointerEvent.target\n                       && interval < 500);\n\n                pointerEvent.double = createNewDoubleTap;\n\n                this.tapTime = pointerEvent.timeStamp;\n            }\n\n            for (i = 0; i < targets.length; i++) {\n                pointerEvent.currentTarget = elements[i];\n                pointerEvent.interactable = targets[i];\n                targets[i].fire(pointerEvent);\n\n                if (pointerEvent.immediatePropagationStopped\n                    ||(pointerEvent.propagationStopped && elements[i + 1] !== pointerEvent.currentTarget)) {\n                    break;\n                }\n            }\n\n            if (createNewDoubleTap) {\n                var doubleTap = {};\n\n                extend(doubleTap, pointerEvent);\n\n                doubleTap.dt   = interval;\n                doubleTap.type = 'doubletap';\n\n                this.collectEventTargets(doubleTap, event, eventTarget, 'doubletap');\n\n                this.prevTap = doubleTap;\n            }\n            else if (eventType === 'tap') {\n                this.prevTap = pointerEvent;\n            }\n        },\n\n        validateSelector: function (pointer, event, matches, matchElements) {\n            for (var i = 0, len = matches.length; i < len; i++) {\n                var match = matches[i],\n                    matchElement = matchElements[i],\n                    action = validateAction(match.getAction(pointer, event, this, matchElement), match);\n\n                if (action && withinInteractionLimit(match, matchElement, action)) {\n                    this.target = match;\n                    this.element = matchElement;\n\n                    return action;\n                }\n            }\n        },\n\n        setSnapping: function (pageCoords, status) {\n            var snap = this.target.options[this.prepared.name].snap,\n                targets = [],\n                target,\n                page,\n                i;\n\n            status = status || this.snapStatus;\n\n            if (status.useStatusXY) {\n                page = { x: status.x, y: status.y };\n            }\n            else {\n                var origin = getOriginXY(this.target, this.element);\n\n                page = extend({}, pageCoords);\n\n                page.x -= origin.x;\n                page.y -= origin.y;\n            }\n\n            status.realX = page.x;\n            status.realY = page.y;\n\n            page.x = page.x - this.inertiaStatus.resumeDx;\n            page.y = page.y - this.inertiaStatus.resumeDy;\n\n            var len = snap.targets? snap.targets.length : 0;\n\n            for (var relIndex = 0; relIndex < this.snapOffsets.length; relIndex++) {\n                var relative = {\n                    x: page.x - this.snapOffsets[relIndex].x,\n                    y: page.y - this.snapOffsets[relIndex].y\n                };\n\n                for (i = 0; i < len; i++) {\n                    if (isFunction(snap.targets[i])) {\n                        target = snap.targets[i](relative.x, relative.y, this);\n                    }\n                    else {\n                        target = snap.targets[i];\n                    }\n\n                    if (!target) { continue; }\n\n                    targets.push({\n                        x: isNumber(target.x) ? (target.x + this.snapOffsets[relIndex].x) : relative.x,\n                        y: isNumber(target.y) ? (target.y + this.snapOffsets[relIndex].y) : relative.y,\n\n                        range: isNumber(target.range)? target.range: snap.range\n                    });\n                }\n            }\n\n            var closest = {\n                    target: null,\n                    inRange: false,\n                    distance: 0,\n                    range: 0,\n                    dx: 0,\n                    dy: 0\n                };\n\n            for (i = 0, len = targets.length; i < len; i++) {\n                target = targets[i];\n\n                var range = target.range,\n                    dx = target.x - page.x,\n                    dy = target.y - page.y,\n                    distance = hypot(dx, dy),\n                    inRange = distance <= range;\n\n                // Infinite targets count as being out of range\n                // compared to non infinite ones that are in range\n                if (range === Infinity && closest.inRange && closest.range !== Infinity) {\n                    inRange = false;\n                }\n\n                if (!closest.target || (inRange\n                    // is the closest target in range?\n                    ? (closest.inRange && range !== Infinity\n                        // the pointer is relatively deeper in this target\n                        ? distance / range < closest.distance / closest.range\n                        // this target has Infinite range and the closest doesn't\n                        : (range === Infinity && closest.range !== Infinity)\n                            // OR this target is closer that the previous closest\n                            || distance < closest.distance)\n                    // The other is not in range and the pointer is closer to this target\n                    : (!closest.inRange && distance < closest.distance))) {\n\n                    if (range === Infinity) {\n                        inRange = true;\n                    }\n\n                    closest.target = target;\n                    closest.distance = distance;\n                    closest.range = range;\n                    closest.inRange = inRange;\n                    closest.dx = dx;\n                    closest.dy = dy;\n\n                    status.range = range;\n                }\n            }\n\n            var snapChanged;\n\n            if (closest.target) {\n                snapChanged = (status.snappedX !== closest.target.x || status.snappedY !== closest.target.y);\n\n                status.snappedX = closest.target.x;\n                status.snappedY = closest.target.y;\n            }\n            else {\n                snapChanged = true;\n\n                status.snappedX = NaN;\n                status.snappedY = NaN;\n            }\n\n            status.dx = closest.dx;\n            status.dy = closest.dy;\n\n            status.changed = (snapChanged || (closest.inRange && !status.locked));\n            status.locked = closest.inRange;\n\n            return status;\n        },\n\n        setRestriction: function (pageCoords, status) {\n            var target = this.target,\n                restrict = target && target.options[this.prepared.name].restrict,\n                restriction = restrict && restrict.restriction,\n                page;\n\n            if (!restriction) {\n                return status;\n            }\n\n            status = status || this.restrictStatus;\n\n            page = status.useStatusXY\n                    ? page = { x: status.x, y: status.y }\n                    : page = extend({}, pageCoords);\n\n            if (status.snap && status.snap.locked) {\n                page.x += status.snap.dx || 0;\n                page.y += status.snap.dy || 0;\n            }\n\n            page.x -= this.inertiaStatus.resumeDx;\n            page.y -= this.inertiaStatus.resumeDy;\n\n            status.dx = 0;\n            status.dy = 0;\n            status.restricted = false;\n\n            var rect, restrictedX, restrictedY;\n\n            if (isString(restriction)) {\n                if (restriction === 'parent') {\n                    restriction = parentElement(this.element);\n                }\n                else if (restriction === 'self') {\n                    restriction = target.getRect(this.element);\n                }\n                else {\n                    restriction = closest(this.element, restriction);\n                }\n\n                if (!restriction) { return status; }\n            }\n\n            if (isFunction(restriction)) {\n                restriction = restriction(page.x, page.y, this.element);\n            }\n\n            if (isElement(restriction)) {\n                restriction = getElementRect(restriction);\n            }\n\n            rect = restriction;\n\n            if (!restriction) {\n                restrictedX = page.x;\n                restrictedY = page.y;\n            }\n            // object is assumed to have\n            // x, y, width, height or\n            // left, top, right, bottom\n            else if ('x' in restriction && 'y' in restriction) {\n                restrictedX = Math.max(Math.min(rect.x + rect.width  - this.restrictOffset.right , page.x), rect.x + this.restrictOffset.left);\n                restrictedY = Math.max(Math.min(rect.y + rect.height - this.restrictOffset.bottom, page.y), rect.y + this.restrictOffset.top );\n            }\n            else {\n                restrictedX = Math.max(Math.min(rect.right  - this.restrictOffset.right , page.x), rect.left + this.restrictOffset.left);\n                restrictedY = Math.max(Math.min(rect.bottom - this.restrictOffset.bottom, page.y), rect.top  + this.restrictOffset.top );\n            }\n\n            status.dx = restrictedX - page.x;\n            status.dy = restrictedY - page.y;\n\n            status.changed = status.restrictedX !== restrictedX || status.restrictedY !== restrictedY;\n            status.restricted = !!(status.dx || status.dy);\n\n            status.restrictedX = restrictedX;\n            status.restrictedY = restrictedY;\n\n            return status;\n        },\n\n        checkAndPreventDefault: function (event, interactable, element) {\n            if (!(interactable = interactable || this.target)) { return; }\n\n            var options = interactable.options,\n                prevent = options.preventDefault;\n\n            if (prevent === 'auto' && element && !/^(input|select|textarea)$/i.test(event.target.nodeName)) {\n                // do not preventDefault on pointerdown if the prepared action is a drag\n                // and dragging can only start from a certain direction - this allows\n                // a touch to pan the viewport if a drag isn't in the right direction\n                if (/down|start/i.test(event.type)\n                    && this.prepared.name === 'drag' && options.drag.axis !== 'xy') {\n\n                    return;\n                }\n\n                // with manualStart, only preventDefault while interacting\n                if (options[this.prepared.name] && options[this.prepared.name].manualStart\n                    && !this.interacting()) {\n                    return;\n                }\n\n                event.preventDefault();\n                return;\n            }\n\n            if (prevent === 'always') {\n                event.preventDefault();\n                return;\n            }\n        },\n\n        calcInertia: function (status) {\n            var inertiaOptions = this.target.options[this.prepared.name].inertia,\n                lambda = inertiaOptions.resistance,\n                inertiaDur = -Math.log(inertiaOptions.endSpeed / status.v0) / lambda;\n\n            status.x0 = this.prevEvent.pageX;\n            status.y0 = this.prevEvent.pageY;\n            status.t0 = status.startEvent.timeStamp / 1000;\n            status.sx = status.sy = 0;\n\n            status.modifiedXe = status.xe = (status.vx0 - inertiaDur) / lambda;\n            status.modifiedYe = status.ye = (status.vy0 - inertiaDur) / lambda;\n            status.te = inertiaDur;\n\n            status.lambda_v0 = lambda / status.v0;\n            status.one_ve_v0 = 1 - inertiaOptions.endSpeed / status.v0;\n        },\n\n        autoScrollMove: function (pointer) {\n            if (!(this.interacting()\n                && checkAutoScroll(this.target, this.prepared.name))) {\n                return;\n            }\n\n            if (this.inertiaStatus.active) {\n                autoScroll.x = autoScroll.y = 0;\n                return;\n            }\n\n            var top,\n                right,\n                bottom,\n                left,\n                options = this.target.options[this.prepared.name].autoScroll,\n                container = options.container || getWindow(this.element);\n\n            if (isWindow(container)) {\n                left   = pointer.clientX < autoScroll.margin;\n                top    = pointer.clientY < autoScroll.margin;\n                right  = pointer.clientX > container.innerWidth  - autoScroll.margin;\n                bottom = pointer.clientY > container.innerHeight - autoScroll.margin;\n            }\n            else {\n                var rect = getElementClientRect(container);\n\n                left   = pointer.clientX < rect.left   + autoScroll.margin;\n                top    = pointer.clientY < rect.top    + autoScroll.margin;\n                right  = pointer.clientX > rect.right  - autoScroll.margin;\n                bottom = pointer.clientY > rect.bottom - autoScroll.margin;\n            }\n\n            autoScroll.x = (right ? 1: left? -1: 0);\n            autoScroll.y = (bottom? 1:  top? -1: 0);\n\n            if (!autoScroll.isScrolling) {\n                // set the autoScroll properties to those of the target\n                autoScroll.margin = options.margin;\n                autoScroll.speed  = options.speed;\n\n                autoScroll.start(this);\n            }\n        },\n\n        _updateEventTargets: function (target, currentTarget) {\n            this._eventTarget    = target;\n            this._curEventTarget = currentTarget;\n        }\n\n    };\n\n    function getInteractionFromPointer (pointer, eventType, eventTarget) {\n        var i = 0, len = interactions.length,\n            mouseEvent = (/mouse/i.test(pointer.pointerType || eventType)\n                          // MSPointerEvent.MSPOINTER_TYPE_MOUSE\n                          || pointer.pointerType === 4),\n            interaction;\n\n        var id = getPointerId(pointer);\n\n        // try to resume inertia with a new pointer\n        if (/down|start/i.test(eventType)) {\n            for (i = 0; i < len; i++) {\n                interaction = interactions[i];\n\n                var element = eventTarget;\n\n                if (interaction.inertiaStatus.active && interaction.target.options[interaction.prepared.name].inertia.allowResume\n                    && (interaction.mouse === mouseEvent)) {\n                    while (element) {\n                        // if the element is the interaction element\n                        if (element === interaction.element) {\n                            return interaction;\n                        }\n                        element = parentElement(element);\n                    }\n                }\n            }\n        }\n\n        // if it's a mouse interaction\n        if (mouseEvent || !(supportsTouch || supportsPointerEvent)) {\n\n            // find a mouse interaction that's not in inertia phase\n            for (i = 0; i < len; i++) {\n                if (interactions[i].mouse && !interactions[i].inertiaStatus.active) {\n                    return interactions[i];\n                }\n            }\n\n            // find any interaction specifically for mouse.\n            // if the eventType is a mousedown, and inertia is active\n            // ignore the interaction\n            for (i = 0; i < len; i++) {\n                if (interactions[i].mouse && !(/down/.test(eventType) && interactions[i].inertiaStatus.active)) {\n                    return interaction;\n                }\n            }\n\n            // create a new interaction for mouse\n            interaction = new Interaction();\n            interaction.mouse = true;\n\n            return interaction;\n        }\n\n        // get interaction that has this pointer\n        for (i = 0; i < len; i++) {\n            if (contains(interactions[i].pointerIds, id)) {\n                return interactions[i];\n            }\n        }\n\n        // at this stage, a pointerUp should not return an interaction\n        if (/up|end|out/i.test(eventType)) {\n            return null;\n        }\n\n        // get first idle interaction\n        for (i = 0; i < len; i++) {\n            interaction = interactions[i];\n\n            if ((!interaction.prepared.name || (interaction.target.options.gesture.enabled))\n                && !interaction.interacting()\n                && !(!mouseEvent && interaction.mouse)) {\n\n                return interaction;\n            }\n        }\n\n        return new Interaction();\n    }\n\n    function doOnInteractions (method) {\n        return (function (event) {\n            var interaction,\n                eventTarget = getActualElement(event.path\n                                               ? event.path[0]\n                                               : event.target),\n                curEventTarget = getActualElement(event.currentTarget),\n                i;\n\n            if (supportsTouch && /touch/.test(event.type)) {\n                prevTouchTime = new Date().getTime();\n\n                for (i = 0; i < event.changedTouches.length; i++) {\n                    var pointer = event.changedTouches[i];\n\n                    interaction = getInteractionFromPointer(pointer, event.type, eventTarget);\n\n                    if (!interaction) { continue; }\n\n                    interaction._updateEventTargets(eventTarget, curEventTarget);\n\n                    interaction[method](pointer, event, eventTarget, curEventTarget);\n                }\n            }\n            else {\n                if (!supportsPointerEvent && /mouse/.test(event.type)) {\n                    // ignore mouse events while touch interactions are active\n                    for (i = 0; i < interactions.length; i++) {\n                        if (!interactions[i].mouse && interactions[i].pointerIsDown) {\n                            return;\n                        }\n                    }\n\n                    // try to ignore mouse events that are simulated by the browser\n                    // after a touch event\n                    if (new Date().getTime() - prevTouchTime < 500) {\n                        return;\n                    }\n                }\n\n                interaction = getInteractionFromPointer(event, event.type, eventTarget);\n\n                if (!interaction) { return; }\n\n                interaction._updateEventTargets(eventTarget, curEventTarget);\n\n                interaction[method](event, event, eventTarget, curEventTarget);\n            }\n        });\n    }\n\n    function InteractEvent (interaction, event, action, phase, element, related) {\n        var client,\n            page,\n            target      = interaction.target,\n            snapStatus  = interaction.snapStatus,\n            restrictStatus  = interaction.restrictStatus,\n            pointers    = interaction.pointers,\n            deltaSource = (target && target.options || defaultOptions).deltaSource,\n            sourceX     = deltaSource + 'X',\n            sourceY     = deltaSource + 'Y',\n            options     = target? target.options: defaultOptions,\n            origin      = getOriginXY(target, element),\n            starting    = phase === 'start',\n            ending      = phase === 'end',\n            coords      = starting? interaction.startCoords : interaction.curCoords;\n\n        element = element || interaction.element;\n\n        page   = extend({}, coords.page);\n        client = extend({}, coords.client);\n\n        page.x -= origin.x;\n        page.y -= origin.y;\n\n        client.x -= origin.x;\n        client.y -= origin.y;\n\n        var relativePoints = options[action].snap && options[action].snap.relativePoints ;\n\n        if (checkSnap(target, action) && !(starting && relativePoints && relativePoints.length)) {\n            this.snap = {\n                range  : snapStatus.range,\n                locked : snapStatus.locked,\n                x      : snapStatus.snappedX,\n                y      : snapStatus.snappedY,\n                realX  : snapStatus.realX,\n                realY  : snapStatus.realY,\n                dx     : snapStatus.dx,\n                dy     : snapStatus.dy\n            };\n\n            if (snapStatus.locked) {\n                page.x += snapStatus.dx;\n                page.y += snapStatus.dy;\n                client.x += snapStatus.dx;\n                client.y += snapStatus.dy;\n            }\n        }\n\n        if (checkRestrict(target, action) && !(starting && options[action].restrict.elementRect) && restrictStatus.restricted) {\n            page.x += restrictStatus.dx;\n            page.y += restrictStatus.dy;\n            client.x += restrictStatus.dx;\n            client.y += restrictStatus.dy;\n\n            this.restrict = {\n                dx: restrictStatus.dx,\n                dy: restrictStatus.dy\n            };\n        }\n\n        this.pageX     = page.x;\n        this.pageY     = page.y;\n        this.clientX   = client.x;\n        this.clientY   = client.y;\n\n        this.x0        = interaction.startCoords.page.x - origin.x;\n        this.y0        = interaction.startCoords.page.y - origin.y;\n        this.clientX0  = interaction.startCoords.client.x - origin.x;\n        this.clientY0  = interaction.startCoords.client.y - origin.y;\n        this.ctrlKey   = event.ctrlKey;\n        this.altKey    = event.altKey;\n        this.shiftKey  = event.shiftKey;\n        this.metaKey   = event.metaKey;\n        this.button    = event.button;\n        this.buttons   = event.buttons;\n        this.target    = element;\n        this.t0        = interaction.downTimes[0];\n        this.type      = action + (phase || '');\n\n        this.interaction = interaction;\n        this.interactable = target;\n\n        var inertiaStatus = interaction.inertiaStatus;\n\n        if (inertiaStatus.active) {\n            this.detail = 'inertia';\n        }\n\n        if (related) {\n            this.relatedTarget = related;\n        }\n\n        // end event dx, dy is difference between start and end points\n        if (ending) {\n            if (deltaSource === 'client') {\n                this.dx = client.x - interaction.startCoords.client.x;\n                this.dy = client.y - interaction.startCoords.client.y;\n            }\n            else {\n                this.dx = page.x - interaction.startCoords.page.x;\n                this.dy = page.y - interaction.startCoords.page.y;\n            }\n        }\n        else if (starting) {\n            this.dx = 0;\n            this.dy = 0;\n        }\n        // copy properties from previousmove if starting inertia\n        else if (phase === 'inertiastart') {\n            this.dx = interaction.prevEvent.dx;\n            this.dy = interaction.prevEvent.dy;\n        }\n        else {\n            if (deltaSource === 'client') {\n                this.dx = client.x - interaction.prevEvent.clientX;\n                this.dy = client.y - interaction.prevEvent.clientY;\n            }\n            else {\n                this.dx = page.x - interaction.prevEvent.pageX;\n                this.dy = page.y - interaction.prevEvent.pageY;\n            }\n        }\n        if (interaction.prevEvent && interaction.prevEvent.detail === 'inertia'\n            && !inertiaStatus.active\n            && options[action].inertia && options[action].inertia.zeroResumeDelta) {\n\n            inertiaStatus.resumeDx += this.dx;\n            inertiaStatus.resumeDy += this.dy;\n\n            this.dx = this.dy = 0;\n        }\n\n        if (action === 'resize' && interaction.resizeAxes) {\n            if (options.resize.square) {\n                if (interaction.resizeAxes === 'y') {\n                    this.dx = this.dy;\n                }\n                else {\n                    this.dy = this.dx;\n                }\n                this.axes = 'xy';\n            }\n            else {\n                this.axes = interaction.resizeAxes;\n\n                if (interaction.resizeAxes === 'x') {\n                    this.dy = 0;\n                }\n                else if (interaction.resizeAxes === 'y') {\n                    this.dx = 0;\n                }\n            }\n        }\n        else if (action === 'gesture') {\n            this.touches = [pointers[0], pointers[1]];\n\n            if (starting) {\n                this.distance = touchDistance(pointers, deltaSource);\n                this.box      = touchBBox(pointers);\n                this.scale    = 1;\n                this.ds       = 0;\n                this.angle    = touchAngle(pointers, undefined, deltaSource);\n                this.da       = 0;\n            }\n            else if (ending || event instanceof InteractEvent) {\n                this.distance = interaction.prevEvent.distance;\n                this.box      = interaction.prevEvent.box;\n                this.scale    = interaction.prevEvent.scale;\n                this.ds       = this.scale - 1;\n                this.angle    = interaction.prevEvent.angle;\n                this.da       = this.angle - interaction.gesture.startAngle;\n            }\n            else {\n                this.distance = touchDistance(pointers, deltaSource);\n                this.box      = touchBBox(pointers);\n                this.scale    = this.distance / interaction.gesture.startDistance;\n                this.angle    = touchAngle(pointers, interaction.gesture.prevAngle, deltaSource);\n\n                this.ds = this.scale - interaction.gesture.prevScale;\n                this.da = this.angle - interaction.gesture.prevAngle;\n            }\n        }\n\n        if (starting) {\n            this.timeStamp = interaction.downTimes[0];\n            this.dt        = 0;\n            this.duration  = 0;\n            this.speed     = 0;\n            this.velocityX = 0;\n            this.velocityY = 0;\n        }\n        else if (phase === 'inertiastart') {\n            this.timeStamp = interaction.prevEvent.timeStamp;\n            this.dt        = interaction.prevEvent.dt;\n            this.duration  = interaction.prevEvent.duration;\n            this.speed     = interaction.prevEvent.speed;\n            this.velocityX = interaction.prevEvent.velocityX;\n            this.velocityY = interaction.prevEvent.velocityY;\n        }\n        else {\n            this.timeStamp = new Date().getTime();\n            this.dt        = this.timeStamp - interaction.prevEvent.timeStamp;\n            this.duration  = this.timeStamp - interaction.downTimes[0];\n\n            if (event instanceof InteractEvent) {\n                var dx = this[sourceX] - interaction.prevEvent[sourceX],\n                    dy = this[sourceY] - interaction.prevEvent[sourceY],\n                    dt = this.dt / 1000;\n\n                this.speed = hypot(dx, dy) / dt;\n                this.velocityX = dx / dt;\n                this.velocityY = dy / dt;\n            }\n            // if normal move or end event, use previous user event coords\n            else {\n                // speed and velocity in pixels per second\n                this.speed = interaction.pointerDelta[deltaSource].speed;\n                this.velocityX = interaction.pointerDelta[deltaSource].vx;\n                this.velocityY = interaction.pointerDelta[deltaSource].vy;\n            }\n        }\n\n        if ((ending || phase === 'inertiastart')\n            && interaction.prevEvent.speed > 600 && this.timeStamp - interaction.prevEvent.timeStamp < 150) {\n\n            var angle = 180 * Math.atan2(interaction.prevEvent.velocityY, interaction.prevEvent.velocityX) / Math.PI,\n                overlap = 22.5;\n\n            if (angle < 0) {\n                angle += 360;\n            }\n\n            var left = 135 - overlap <= angle && angle < 225 + overlap,\n                up   = 225 - overlap <= angle && angle < 315 + overlap,\n\n                right = !left && (315 - overlap <= angle || angle <  45 + overlap),\n                down  = !up   &&   45 - overlap <= angle && angle < 135 + overlap;\n\n            this.swipe = {\n                up   : up,\n                down : down,\n                left : left,\n                right: right,\n                angle: angle,\n                speed: interaction.prevEvent.speed,\n                velocity: {\n                    x: interaction.prevEvent.velocityX,\n                    y: interaction.prevEvent.velocityY\n                }\n            };\n        }\n    }\n\n    InteractEvent.prototype = {\n        preventDefault: blank,\n        stopImmediatePropagation: function () {\n            this.immediatePropagationStopped = this.propagationStopped = true;\n        },\n        stopPropagation: function () {\n            this.propagationStopped = true;\n        }\n    };\n\n    function preventOriginalDefault () {\n        this.originalEvent.preventDefault();\n    }\n\n    function getActionCursor (action) {\n        var cursor = '';\n\n        if (action.name === 'drag') {\n            cursor =  actionCursors.drag;\n        }\n        if (action.name === 'resize') {\n            if (action.axis) {\n                cursor =  actionCursors[action.name + action.axis];\n            }\n            else if (action.edges) {\n                var cursorKey = 'resize',\n                    edgeNames = ['top', 'bottom', 'left', 'right'];\n\n                for (var i = 0; i < 4; i++) {\n                    if (action.edges[edgeNames[i]]) {\n                        cursorKey += edgeNames[i];\n                    }\n                }\n\n                cursor = actionCursors[cursorKey];\n            }\n        }\n\n        return cursor;\n    }\n\n    function checkResizeEdge (name, value, page, element, interactableElement, rect, margin) {\n        // false, '', undefined, null\n        if (!value) { return false; }\n\n        // true value, use pointer coords and element rect\n        if (value === true) {\n            // if dimensions are negative, \"switch\" edges\n            var width = isNumber(rect.width)? rect.width : rect.right - rect.left,\n                height = isNumber(rect.height)? rect.height : rect.bottom - rect.top;\n\n            if (width < 0) {\n                if      (name === 'left' ) { name = 'right'; }\n                else if (name === 'right') { name = 'left' ; }\n            }\n            if (height < 0) {\n                if      (name === 'top'   ) { name = 'bottom'; }\n                else if (name === 'bottom') { name = 'top'   ; }\n            }\n\n            if (name === 'left'  ) { return page.x < ((width  >= 0? rect.left: rect.right ) + margin); }\n            if (name === 'top'   ) { return page.y < ((height >= 0? rect.top : rect.bottom) + margin); }\n\n            if (name === 'right' ) { return page.x > ((width  >= 0? rect.right : rect.left) - margin); }\n            if (name === 'bottom') { return page.y > ((height >= 0? rect.bottom: rect.top ) - margin); }\n        }\n\n        // the remaining checks require an element\n        if (!isElement(element)) { return false; }\n\n        return isElement(value)\n                    // the value is an element to use as a resize handle\n                    ? value === element\n                    // otherwise check if element matches value as selector\n                    : matchesUpTo(element, value, interactableElement);\n    }\n\n    function defaultActionChecker (pointer, interaction, element) {\n        var rect = this.getRect(element),\n            shouldResize = false,\n            action = null,\n            resizeAxes = null,\n            resizeEdges,\n            page = extend({}, interaction.curCoords.page),\n            options = this.options;\n\n        if (!rect) { return null; }\n\n        if (actionIsEnabled.resize && options.resize.enabled) {\n            var resizeOptions = options.resize;\n\n            resizeEdges = {\n                left: false, right: false, top: false, bottom: false\n            };\n\n            // if using resize.edges\n            if (isObject(resizeOptions.edges)) {\n                for (var edge in resizeEdges) {\n                    resizeEdges[edge] = checkResizeEdge(edge,\n                                                        resizeOptions.edges[edge],\n                                                        page,\n                                                        interaction._eventTarget,\n                                                        element,\n                                                        rect,\n                                                        resizeOptions.margin || margin);\n                }\n\n                resizeEdges.left = resizeEdges.left && !resizeEdges.right;\n                resizeEdges.top  = resizeEdges.top  && !resizeEdges.bottom;\n\n                shouldResize = resizeEdges.left || resizeEdges.right || resizeEdges.top || resizeEdges.bottom;\n            }\n            else {\n                var right  = options.resize.axis !== 'y' && page.x > (rect.right  - margin),\n                    bottom = options.resize.axis !== 'x' && page.y > (rect.bottom - margin);\n\n                shouldResize = right || bottom;\n                resizeAxes = (right? 'x' : '') + (bottom? 'y' : '');\n            }\n        }\n\n        action = shouldResize\n            ? 'resize'\n            : actionIsEnabled.drag && options.drag.enabled\n                ? 'drag'\n                : null;\n\n        if (actionIsEnabled.gesture\n            && interaction.pointerIds.length >=2\n            && !(interaction.dragging || interaction.resizing)) {\n            action = 'gesture';\n        }\n\n        if (action) {\n            return {\n                name: action,\n                axis: resizeAxes,\n                edges: resizeEdges\n            };\n        }\n\n        return null;\n    }\n\n    // Check if action is enabled globally and the current target supports it\n    // If so, return the validated action. Otherwise, return null\n    function validateAction (action, interactable) {\n        if (!isObject(action)) { return null; }\n\n        var actionName = action.name,\n            options = interactable.options;\n\n        if ((  (actionName  === 'resize'   && options.resize.enabled )\n            || (actionName      === 'drag'     && options.drag.enabled  )\n            || (actionName      === 'gesture'  && options.gesture.enabled))\n            && actionIsEnabled[actionName]) {\n\n            if (actionName === 'resize' || actionName === 'resizeyx') {\n                actionName = 'resizexy';\n            }\n\n            return action;\n        }\n        return null;\n    }\n\n    var listeners = {},\n        interactionListeners = [\n            'dragStart', 'dragMove', 'resizeStart', 'resizeMove', 'gestureStart', 'gestureMove',\n            'pointerOver', 'pointerOut', 'pointerHover', 'selectorDown',\n            'pointerDown', 'pointerMove', 'pointerUp', 'pointerCancel', 'pointerEnd',\n            'addPointer', 'removePointer', 'recordPointer', 'autoScrollMove'\n        ];\n\n    for (var i = 0, len = interactionListeners.length; i < len; i++) {\n        var name = interactionListeners[i];\n\n        listeners[name] = doOnInteractions(name);\n    }\n\n    // bound to the interactable context when a DOM event\n    // listener is added to a selector interactable\n    function delegateListener (event, useCapture) {\n        var fakeEvent = {},\n            delegated = delegatedEvents[event.type],\n            eventTarget = getActualElement(event.path\n                                           ? event.path[0]\n                                           : event.target),\n            element = eventTarget;\n\n        useCapture = useCapture? true: false;\n\n        // duplicate the event so that currentTarget can be changed\n        for (var prop in event) {\n            fakeEvent[prop] = event[prop];\n        }\n\n        fakeEvent.originalEvent = event;\n        fakeEvent.preventDefault = preventOriginalDefault;\n\n        // climb up document tree looking for selector matches\n        while (isElement(element)) {\n            for (var i = 0; i < delegated.selectors.length; i++) {\n                var selector = delegated.selectors[i],\n                    context = delegated.contexts[i];\n\n                if (matchesSelector(element, selector)\n                    && nodeContains(context, eventTarget)\n                    && nodeContains(context, element)) {\n\n                    var listeners = delegated.listeners[i];\n\n                    fakeEvent.currentTarget = element;\n\n                    for (var j = 0; j < listeners.length; j++) {\n                        if (listeners[j][1] === useCapture) {\n                            listeners[j][0](fakeEvent);\n                        }\n                    }\n                }\n            }\n\n            element = parentElement(element);\n        }\n    }\n\n    function delegateUseCapture (event) {\n        return delegateListener.call(this, event, true);\n    }\n\n    interactables.indexOfElement = function indexOfElement (element, context) {\n        context = context || document;\n\n        for (var i = 0; i < this.length; i++) {\n            var interactable = this[i];\n\n            if ((interactable.selector === element\n                && (interactable._context === context))\n                || (!interactable.selector && interactable._element === element)) {\n\n                return i;\n            }\n        }\n        return -1;\n    };\n\n    interactables.get = function interactableGet (element, options) {\n        return this[this.indexOfElement(element, options && options.context)];\n    };\n\n    interactables.forEachSelector = function (callback) {\n        for (var i = 0; i < this.length; i++) {\n            var interactable = this[i];\n\n            if (!interactable.selector) {\n                continue;\n            }\n\n            var ret = callback(interactable, interactable.selector, interactable._context, i, this);\n\n            if (ret !== undefined) {\n                return ret;\n            }\n        }\n    };\n\n    /*\\\n     * interact\n     [ method ]\n     *\n     * The methods of this variable can be used to set elements as\n     * interactables and also to change various default settings.\n     *\n     * Calling it as a function and passing an element or a valid CSS selector\n     * string returns an Interactable object which has various methods to\n     * configure it.\n     *\n     - element (Element | string) The HTML or SVG Element to interact with or CSS selector\n     = (object) An @Interactable\n     *\n     > Usage\n     | interact(document.getElementById('draggable')).draggable(true);\n     |\n     | var rectables = interact('rect');\n     | rectables\n     |     .gesturable(true)\n     |     .on('gesturemove', function (event) {\n     |         // something cool...\n     |     })\n     |     .autoScroll(true);\n    \\*/\n    function interact (element, options) {\n        return interactables.get(element, options) || new Interactable(element, options);\n    }\n\n    /*\\\n     * Interactable\n     [ property ]\n     **\n     * Object type returned by @interact\n    \\*/\n    function Interactable (element, options) {\n        this._element = element;\n        this._iEvents = this._iEvents || {};\n\n        var _window;\n\n        if (trySelector(element)) {\n            this.selector = element;\n\n            var context = options && options.context;\n\n            _window = context? getWindow(context) : window;\n\n            if (context && (_window.Node\n                    ? context instanceof _window.Node\n                    : (isElement(context) || context === _window.document))) {\n\n                this._context = context;\n            }\n        }\n        else {\n            _window = getWindow(element);\n\n            if (isElement(element, _window)) {\n\n                if (supportsPointerEvent) {\n                    events.add(this._element, pEventTypes.down, listeners.pointerDown );\n                    events.add(this._element, pEventTypes.move, listeners.pointerHover);\n                }\n                else {\n                    events.add(this._element, 'mousedown' , listeners.pointerDown );\n                    events.add(this._element, 'mousemove' , listeners.pointerHover);\n                    events.add(this._element, 'touchstart', listeners.pointerDown );\n                    events.add(this._element, 'touchmove' , listeners.pointerHover);\n                }\n            }\n        }\n\n        this._doc = _window.document;\n\n        if (!contains(documents, this._doc)) {\n            listenToDocument(this._doc);\n        }\n\n        interactables.push(this);\n\n        this.set(options);\n    }\n\n    Interactable.prototype = {\n        setOnEvents: function (action, phases) {\n            if (action === 'drop') {\n                if (isFunction(phases.ondrop)          ) { this.ondrop           = phases.ondrop          ; }\n                if (isFunction(phases.ondropactivate)  ) { this.ondropactivate   = phases.ondropactivate  ; }\n                if (isFunction(phases.ondropdeactivate)) { this.ondropdeactivate = phases.ondropdeactivate; }\n                if (isFunction(phases.ondragenter)     ) { this.ondragenter      = phases.ondragenter     ; }\n                if (isFunction(phases.ondragleave)     ) { this.ondragleave      = phases.ondragleave     ; }\n                if (isFunction(phases.ondropmove)      ) { this.ondropmove       = phases.ondropmove      ; }\n            }\n            else {\n                action = 'on' + action;\n\n                if (isFunction(phases.onstart)       ) { this[action + 'start'         ] = phases.onstart         ; }\n                if (isFunction(phases.onmove)        ) { this[action + 'move'          ] = phases.onmove          ; }\n                if (isFunction(phases.onend)         ) { this[action + 'end'           ] = phases.onend           ; }\n                if (isFunction(phases.oninertiastart)) { this[action + 'inertiastart'  ] = phases.oninertiastart  ; }\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.draggable\n         [ method ]\n         *\n         * Gets or sets whether drag actions can be performed on the\n         * Interactable\n         *\n         = (boolean) Indicates if this can be the target of drag events\n         | var isDraggable = interact('ul li').draggable();\n         * or\n         - options (boolean | object) #optional true/false or An object with event listeners to be fired on drag events (object makes the Interactable draggable)\n         = (object) This Interactable\n         | interact(element).draggable({\n         |     onstart: function (event) {},\n         |     onmove : function (event) {},\n         |     onend  : function (event) {},\n         |\n         |     // the axis in which the first movement must be\n         |     // for the drag sequence to start\n         |     // 'xy' by default - any direction\n         |     axis: 'x' || 'y' || 'xy',\n         |\n         |     // max number of drags that can happen concurrently\n         |     // with elements of this Interactable. Infinity by default\n         |     max: Infinity,\n         |\n         |     // max number of drags that can target the same element+Interactable\n         |     // 1 by default\n         |     maxPerElement: 2\n         | });\n        \\*/\n        draggable: function (options) {\n            if (isObject(options)) {\n                this.options.drag.enabled = options.enabled === false? false: true;\n                this.setPerAction('drag', options);\n                this.setOnEvents('drag', options);\n\n                if (/^x$|^y$|^xy$/.test(options.axis)) {\n                    this.options.drag.axis = options.axis;\n                }\n                else if (options.axis === null) {\n                    delete this.options.drag.axis;\n                }\n\n                return this;\n            }\n\n            if (isBool(options)) {\n                this.options.drag.enabled = options;\n\n                return this;\n            }\n\n            return this.options.drag;\n        },\n\n        setPerAction: function (action, options) {\n            // for all the default per-action options\n            for (var option in options) {\n                // if this option exists for this action\n                if (option in defaultOptions[action]) {\n                    // if the option in the options arg is an object value\n                    if (isObject(options[option])) {\n                        // duplicate the object\n                        this.options[action][option] = extend(this.options[action][option] || {}, options[option]);\n\n                        if (isObject(defaultOptions.perAction[option]) && 'enabled' in defaultOptions.perAction[option]) {\n                            this.options[action][option].enabled = options[option].enabled === false? false : true;\n                        }\n                    }\n                    else if (isBool(options[option]) && isObject(defaultOptions.perAction[option])) {\n                        this.options[action][option].enabled = options[option];\n                    }\n                    else if (options[option] !== undefined) {\n                        // or if it's not undefined, do a plain assignment\n                        this.options[action][option] = options[option];\n                    }\n                }\n            }\n        },\n\n        /*\\\n         * Interactable.dropzone\n         [ method ]\n         *\n         * Returns or sets whether elements can be dropped onto this\n         * Interactable to trigger drop events\n         *\n         * Dropzones can receive the following events:\n         *  - `dropactivate` and `dropdeactivate` when an acceptable drag starts and ends\n         *  - `dragenter` and `dragleave` when a draggable enters and leaves the dropzone\n         *  - `dragmove` when a draggable that has entered the dropzone is moved\n         *  - `drop` when a draggable is dropped into this dropzone\n         *\n         *  Use the `accept` option to allow only elements that match the given CSS selector or element.\n         *\n         *  Use the `overlap` option to set how drops are checked for. The allowed values are:\n         *   - `'pointer'`, the pointer must be over the dropzone (default)\n         *   - `'center'`, the draggable element's center must be over the dropzone\n         *   - a number from 0-1 which is the `(intersection area) / (draggable area)`.\n         *       e.g. `0.5` for drop to happen when half of the area of the\n         *       draggable is over the dropzone\n         *\n         - options (boolean | object | null) #optional The new value to be set.\n         | interact('.drop').dropzone({\n         |   accept: '.can-drop' || document.getElementById('single-drop'),\n         |   overlap: 'pointer' || 'center' || zeroToOne\n         | }\n         = (boolean | object) The current setting or this Interactable\n        \\*/\n        dropzone: function (options) {\n            if (isObject(options)) {\n                this.options.drop.enabled = options.enabled === false? false: true;\n                this.setOnEvents('drop', options);\n\n                if (/^(pointer|center)$/.test(options.overlap)) {\n                    this.options.drop.overlap = options.overlap;\n                }\n                else if (isNumber(options.overlap)) {\n                    this.options.drop.overlap = Math.max(Math.min(1, options.overlap), 0);\n                }\n                if ('accept' in options) {\n                  this.options.drop.accept = options.accept;\n                }\n                if ('checker' in options) {\n                  this.options.drop.checker = options.checker;\n                }\n\n                return this;\n            }\n\n            if (isBool(options)) {\n                this.options.drop.enabled = options;\n\n                return this;\n            }\n\n            return this.options.drop;\n        },\n\n        dropCheck: function (dragEvent, event, draggable, draggableElement, dropElement, rect) {\n            var dropped = false;\n\n            // if the dropzone has no rect (eg. display: none)\n            // call the custom dropChecker or just return false\n            if (!(rect = rect || this.getRect(dropElement))) {\n                return (this.options.drop.checker\n                    ? this.options.drop.checker(dragEvent, event, dropped, this, dropElement, draggable, draggableElement)\n                    : false);\n            }\n\n            var dropOverlap = this.options.drop.overlap;\n\n            if (dropOverlap === 'pointer') {\n                var page = getPageXY(dragEvent),\n                    origin = getOriginXY(draggable, draggableElement),\n                    horizontal,\n                    vertical;\n\n                page.x += origin.x;\n                page.y += origin.y;\n\n                horizontal = (page.x > rect.left) && (page.x < rect.right);\n                vertical   = (page.y > rect.top ) && (page.y < rect.bottom);\n\n                dropped = horizontal && vertical;\n            }\n\n            var dragRect = draggable.getRect(draggableElement);\n\n            if (dropOverlap === 'center') {\n                var cx = dragRect.left + dragRect.width  / 2,\n                    cy = dragRect.top  + dragRect.height / 2;\n\n                dropped = cx >= rect.left && cx <= rect.right && cy >= rect.top && cy <= rect.bottom;\n            }\n\n            if (isNumber(dropOverlap)) {\n                var overlapArea  = (Math.max(0, Math.min(rect.right , dragRect.right ) - Math.max(rect.left, dragRect.left))\n                                  * Math.max(0, Math.min(rect.bottom, dragRect.bottom) - Math.max(rect.top , dragRect.top ))),\n                    overlapRatio = overlapArea / (dragRect.width * dragRect.height);\n\n                dropped = overlapRatio >= dropOverlap;\n            }\n\n            if (this.options.drop.checker) {\n                dropped = this.options.drop.checker(dragEvent, event, dropped, this, dropElement, draggable, draggableElement);\n            }\n\n            return dropped;\n        },\n\n        /*\\\n         * Interactable.dropChecker\n         [ method ]\n         *\n         * DEPRECATED. Use interactable.dropzone({ checker: function... }) instead.\n         *\n         * Gets or sets the function used to check if a dragged element is\n         * over this Interactable.\n         *\n         - checker (function) #optional The function that will be called when checking for a drop\n         = (Function | Interactable) The checker function or this Interactable\n         *\n         * The checker function takes the following arguments:\n         *\n         - dragEvent (InteractEvent) The related dragmove or dragend event\n         - event (TouchEvent | PointerEvent | MouseEvent) The user move/up/end Event related to the dragEvent\n         - dropped (boolean) The value from the default drop checker\n         - dropzone (Interactable) The dropzone interactable\n         - dropElement (Element) The dropzone element\n         - draggable (Interactable) The Interactable being dragged\n         - draggableElement (Element) The actual element that's being dragged\n         *\n         > Usage:\n         | interact(target)\n         | .dropChecker(function(dragEvent,         // related dragmove or dragend event\n         |                       event,             // TouchEvent/PointerEvent/MouseEvent\n         |                       dropped,           // bool result of the default checker\n         |                       dropzone,          // dropzone Interactable\n         |                       dropElement,       // dropzone elemnt\n         |                       draggable,         // draggable Interactable\n         |                       draggableElement) {// draggable element\n         |\n         |   return dropped && event.target.hasAttribute('allow-drop');\n         | }\n        \\*/\n        dropChecker: function (checker) {\n            if (isFunction(checker)) {\n                this.options.drop.checker = checker;\n\n                return this;\n            }\n            if (checker === null) {\n                delete this.options.getRect;\n\n                return this;\n            }\n\n            return this.options.drop.checker;\n        },\n\n        /*\\\n         * Interactable.accept\n         [ method ]\n         *\n         * Deprecated. add an `accept` property to the options object passed to\n         * @Interactable.dropzone instead.\n         *\n         * Gets or sets the Element or CSS selector match that this\n         * Interactable accepts if it is a dropzone.\n         *\n         - newValue (Element | string | null) #optional\n         * If it is an Element, then only that element can be dropped into this dropzone.\n         * If it is a string, the element being dragged must match it as a selector.\n         * If it is null, the accept options is cleared - it accepts any element.\n         *\n         = (string | Element | null | Interactable) The current accept option if given `undefined` or this Interactable\n        \\*/\n        accept: function (newValue) {\n            if (isElement(newValue)) {\n                this.options.drop.accept = newValue;\n\n                return this;\n            }\n\n            // test if it is a valid CSS selector\n            if (trySelector(newValue)) {\n                this.options.drop.accept = newValue;\n\n                return this;\n            }\n\n            if (newValue === null) {\n                delete this.options.drop.accept;\n\n                return this;\n            }\n\n            return this.options.drop.accept;\n        },\n\n        /*\\\n         * Interactable.resizable\n         [ method ]\n         *\n         * Gets or sets whether resize actions can be performed on the\n         * Interactable\n         *\n         = (boolean) Indicates if this can be the target of resize elements\n         | var isResizeable = interact('input[type=text]').resizable();\n         * or\n         - options (boolean | object) #optional true/false or An object with event listeners to be fired on resize events (object makes the Interactable resizable)\n         = (object) This Interactable\n         | interact(element).resizable({\n         |     onstart: function (event) {},\n         |     onmove : function (event) {},\n         |     onend  : function (event) {},\n         |\n         |     edges: {\n         |       top   : true,       // Use pointer coords to check for resize.\n         |       left  : false,      // Disable resizing from left edge.\n         |       bottom: '.resize-s',// Resize if pointer target matches selector\n         |       right : handleEl    // Resize if pointer target is the given Element\n         |     },\n         |\n         |     // Width and height can be adjusted independently. When `true`, width and\n         |     // height are adjusted at a 1:1 ratio.\n         |     square: false,\n         |\n         |     // Width and height can be adjusted independently. When `true`, width and\n         |     // height maintain the aspect ratio they had when resizing started.\n         |     preserveAspectRatio: false,\n         |\n         |     // a value of 'none' will limit the resize rect to a minimum of 0x0\n         |     // 'negate' will allow the rect to have negative width/height\n         |     // 'reposition' will keep the width/height positive by swapping\n         |     // the top and bottom edges and/or swapping the left and right edges\n         |     invert: 'none' || 'negate' || 'reposition'\n         |\n         |     // limit multiple resizes.\n         |     // See the explanation in the @Interactable.draggable example\n         |     max: Infinity,\n         |     maxPerElement: 1,\n         | });\n        \\*/\n        resizable: function (options) {\n            if (isObject(options)) {\n                this.options.resize.enabled = options.enabled === false? false: true;\n                this.setPerAction('resize', options);\n                this.setOnEvents('resize', options);\n\n                if (/^x$|^y$|^xy$/.test(options.axis)) {\n                    this.options.resize.axis = options.axis;\n                }\n                else if (options.axis === null) {\n                    this.options.resize.axis = defaultOptions.resize.axis;\n                }\n\n                if (isBool(options.preserveAspectRatio)) {\n                    this.options.resize.preserveAspectRatio = options.preserveAspectRatio;\n                }\n                else if (isBool(options.square)) {\n                    this.options.resize.square = options.square;\n                }\n\n                return this;\n            }\n            if (isBool(options)) {\n                this.options.resize.enabled = options;\n\n                return this;\n            }\n            return this.options.resize;\n        },\n\n        /*\\\n         * Interactable.squareResize\n         [ method ]\n         *\n         * Deprecated. Add a `square: true || false` property to @Interactable.resizable instead\n         *\n         * Gets or sets whether resizing is forced 1:1 aspect\n         *\n         = (boolean) Current setting\n         *\n         * or\n         *\n         - newValue (boolean) #optional\n         = (object) this Interactable\n        \\*/\n        squareResize: function (newValue) {\n            if (isBool(newValue)) {\n                this.options.resize.square = newValue;\n\n                return this;\n            }\n\n            if (newValue === null) {\n                delete this.options.resize.square;\n\n                return this;\n            }\n\n            return this.options.resize.square;\n        },\n\n        /*\\\n         * Interactable.gesturable\n         [ method ]\n         *\n         * Gets or sets whether multitouch gestures can be performed on the\n         * Interactable's element\n         *\n         = (boolean) Indicates if this can be the target of gesture events\n         | var isGestureable = interact(element).gesturable();\n         * or\n         - options (boolean | object) #optional true/false or An object with event listeners to be fired on gesture events (makes the Interactable gesturable)\n         = (object) this Interactable\n         | interact(element).gesturable({\n         |     onstart: function (event) {},\n         |     onmove : function (event) {},\n         |     onend  : function (event) {},\n         |\n         |     // limit multiple gestures.\n         |     // See the explanation in @Interactable.draggable example\n         |     max: Infinity,\n         |     maxPerElement: 1,\n         | });\n        \\*/\n        gesturable: function (options) {\n            if (isObject(options)) {\n                this.options.gesture.enabled = options.enabled === false? false: true;\n                this.setPerAction('gesture', options);\n                this.setOnEvents('gesture', options);\n\n                return this;\n            }\n\n            if (isBool(options)) {\n                this.options.gesture.enabled = options;\n\n                return this;\n            }\n\n            return this.options.gesture;\n        },\n\n        /*\\\n         * Interactable.autoScroll\n         [ method ]\n         **\n         * Deprecated. Add an `autoscroll` property to the options object\n         * passed to @Interactable.draggable or @Interactable.resizable instead.\n         *\n         * Returns or sets whether dragging and resizing near the edges of the\n         * window/container trigger autoScroll for this Interactable\n         *\n         = (object) Object with autoScroll properties\n         *\n         * or\n         *\n         - options (object | boolean) #optional\n         * options can be:\n         * - an object with margin, distance and interval properties,\n         * - true or false to enable or disable autoScroll or\n         = (Interactable) this Interactable\n        \\*/\n        autoScroll: function (options) {\n            if (isObject(options)) {\n                options = extend({ actions: ['drag', 'resize']}, options);\n            }\n            else if (isBool(options)) {\n                options = { actions: ['drag', 'resize'], enabled: options };\n            }\n\n            return this.setOptions('autoScroll', options);\n        },\n\n        /*\\\n         * Interactable.snap\n         [ method ]\n         **\n         * Deprecated. Add a `snap` property to the options object passed\n         * to @Interactable.draggable or @Interactable.resizable instead.\n         *\n         * Returns or sets if and how action coordinates are snapped. By\n         * default, snapping is relative to the pointer coordinates. You can\n         * change this by setting the\n         * [`elementOrigin`](https://github.com/taye/interact.js/pull/72).\n         **\n         = (boolean | object) `false` if snap is disabled; object with snap properties if snap is enabled\n         **\n         * or\n         **\n         - options (object | boolean | null) #optional\n         = (Interactable) this Interactable\n         > Usage\n         | interact(document.querySelector('#thing')).snap({\n         |     targets: [\n         |         // snap to this specific point\n         |         {\n         |             x: 100,\n         |             y: 100,\n         |             range: 25\n         |         },\n         |         // give this function the x and y page coords and snap to the object returned\n         |         function (x, y) {\n         |             return {\n         |                 x: x,\n         |                 y: (75 + 50 * Math.sin(x * 0.04)),\n         |                 range: 40\n         |             };\n         |         },\n         |         // create a function that snaps to a grid\n         |         interact.createSnapGrid({\n         |             x: 50,\n         |             y: 50,\n         |             range: 10,              // optional\n         |             offset: { x: 5, y: 10 } // optional\n         |         })\n         |     ],\n         |     // do not snap during normal movement.\n         |     // Instead, trigger only one snapped move event\n         |     // immediately before the end event.\n         |     endOnly: true,\n         |\n         |     relativePoints: [\n         |         { x: 0, y: 0 },  // snap relative to the top left of the element\n         |         { x: 1, y: 1 },  // and also to the bottom right\n         |     ],  \n         |\n         |     // offset the snap target coordinates\n         |     // can be an object with x/y or 'startCoords'\n         |     offset: { x: 50, y: 50 }\n         |   }\n         | });\n        \\*/\n        snap: function (options) {\n            var ret = this.setOptions('snap', options);\n\n            if (ret === this) { return this; }\n\n            return ret.drag;\n        },\n\n        setOptions: function (option, options) {\n            var actions = options && isArray(options.actions)\n                    ? options.actions\n                    : ['drag'];\n\n            var i;\n\n            if (isObject(options) || isBool(options)) {\n                for (i = 0; i < actions.length; i++) {\n                    var action = /resize/.test(actions[i])? 'resize' : actions[i];\n\n                    if (!isObject(this.options[action])) { continue; }\n\n                    var thisOption = this.options[action][option];\n\n                    if (isObject(options)) {\n                        extend(thisOption, options);\n                        thisOption.enabled = options.enabled === false? false: true;\n\n                        if (option === 'snap') {\n                            if (thisOption.mode === 'grid') {\n                                thisOption.targets = [\n                                    interact.createSnapGrid(extend({\n                                        offset: thisOption.gridOffset || { x: 0, y: 0 }\n                                    }, thisOption.grid || {}))\n                                ];\n                            }\n                            else if (thisOption.mode === 'anchor') {\n                                thisOption.targets = thisOption.anchors;\n                            }\n                            else if (thisOption.mode === 'path') {\n                                thisOption.targets = thisOption.paths;\n                            }\n\n                            if ('elementOrigin' in options) {\n                                thisOption.relativePoints = [options.elementOrigin];\n                            }\n                        }\n                    }\n                    else if (isBool(options)) {\n                        thisOption.enabled = options;\n                    }\n                }\n\n                return this;\n            }\n\n            var ret = {},\n                allActions = ['drag', 'resize', 'gesture'];\n\n            for (i = 0; i < allActions.length; i++) {\n                if (option in defaultOptions[allActions[i]]) {\n                    ret[allActions[i]] = this.options[allActions[i]][option];\n                }\n            }\n\n            return ret;\n        },\n\n\n        /*\\\n         * Interactable.inertia\n         [ method ]\n         **\n         * Deprecated. Add an `inertia` property to the options object passed\n         * to @Interactable.draggable or @Interactable.resizable instead.\n         *\n         * Returns or sets if and how events continue to run after the pointer is released\n         **\n         = (boolean | object) `false` if inertia is disabled; `object` with inertia properties if inertia is enabled\n         **\n         * or\n         **\n         - options (object | boolean | null) #optional\n         = (Interactable) this Interactable\n         > Usage\n         | // enable and use default settings\n         | interact(element).inertia(true);\n         |\n         | // enable and use custom settings\n         | interact(element).inertia({\n         |     // value greater than 0\n         |     // high values slow the object down more quickly\n         |     resistance     : 16,\n         |\n         |     // the minimum launch speed (pixels per second) that results in inertia start\n         |     minSpeed       : 200,\n         |\n         |     // inertia will stop when the object slows down to this speed\n         |     endSpeed       : 20,\n         |\n         |     // boolean; should actions be resumed when the pointer goes down during inertia\n         |     allowResume    : true,\n         |\n         |     // boolean; should the jump when resuming from inertia be ignored in event.dx/dy\n         |     zeroResumeDelta: false,\n         |\n         |     // if snap/restrict are set to be endOnly and inertia is enabled, releasing\n         |     // the pointer without triggering inertia will animate from the release\n         |     // point to the snaped/restricted point in the given amount of time (ms)\n         |     smoothEndDuration: 300,\n         |\n         |     // an array of action types that can have inertia (no gesture)\n         |     actions        : ['drag', 'resize']\n         | });\n         |\n         | // reset custom settings and use all defaults\n         | interact(element).inertia(null);\n        \\*/\n        inertia: function (options) {\n            var ret = this.setOptions('inertia', options);\n\n            if (ret === this) { return this; }\n\n            return ret.drag;\n        },\n\n        getAction: function (pointer, event, interaction, element) {\n            var action = this.defaultActionChecker(pointer, interaction, element);\n\n            if (this.options.actionChecker) {\n                return this.options.actionChecker(pointer, event, action, this, element, interaction);\n            }\n\n            return action;\n        },\n\n        defaultActionChecker: defaultActionChecker,\n\n        /*\\\n         * Interactable.actionChecker\n         [ method ]\n         *\n         * Gets or sets the function used to check action to be performed on\n         * pointerDown\n         *\n         - checker (function | null) #optional 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.\n         = (Function | Interactable) The checker function or this Interactable\n         *\n         | interact('.resize-drag')\n         |   .resizable(true)\n         |   .draggable(true)\n         |   .actionChecker(function (pointer, event, action, interactable, element, interaction) {\n         |\n         |   if (interact.matchesSelector(event.target, '.drag-handle') {\n         |     // force drag with handle target\n         |     action.name = drag;\n         |   }\n         |   else {\n         |     // resize from the top and right edges\n         |     action.name  = 'resize';\n         |     action.edges = { top: true, right: true };\n         |   }\n         |\n         |   return action;\n         | });\n        \\*/\n        actionChecker: function (checker) {\n            if (isFunction(checker)) {\n                this.options.actionChecker = checker;\n\n                return this;\n            }\n\n            if (checker === null) {\n                delete this.options.actionChecker;\n\n                return this;\n            }\n\n            return this.options.actionChecker;\n        },\n\n        /*\\\n         * Interactable.getRect\n         [ method ]\n         *\n         * The default function to get an Interactables bounding rect. Can be\n         * overridden using @Interactable.rectChecker.\n         *\n         - element (Element) #optional The element to measure.\n         = (object) The object's bounding rectangle.\n         o {\n         o     top   : 0,\n         o     left  : 0,\n         o     bottom: 0,\n         o     right : 0,\n         o     width : 0,\n         o     height: 0\n         o }\n        \\*/\n        getRect: function rectCheck (element) {\n            element = element || this._element;\n\n            if (this.selector && !(isElement(element))) {\n                element = this._context.querySelector(this.selector);\n            }\n\n            return getElementRect(element);\n        },\n\n        /*\\\n         * Interactable.rectChecker\n         [ method ]\n         *\n         * Returns or sets the function used to calculate the interactable's\n         * element's rectangle\n         *\n         - checker (function) #optional A function which returns this Interactable's bounding rectangle. See @Interactable.getRect\n         = (function | object) The checker function or this Interactable\n        \\*/\n        rectChecker: function (checker) {\n            if (isFunction(checker)) {\n                this.getRect = checker;\n\n                return this;\n            }\n\n            if (checker === null) {\n                delete this.options.getRect;\n\n                return this;\n            }\n\n            return this.getRect;\n        },\n\n        /*\\\n         * Interactable.styleCursor\n         [ method ]\n         *\n         * Returns or sets whether the action that would be performed when the\n         * mouse on the element are checked on `mousemove` so that the cursor\n         * may be styled appropriately\n         *\n         - newValue (boolean) #optional\n         = (boolean | Interactable) The current setting or this Interactable\n        \\*/\n        styleCursor: function (newValue) {\n            if (isBool(newValue)) {\n                this.options.styleCursor = newValue;\n\n                return this;\n            }\n\n            if (newValue === null) {\n                delete this.options.styleCursor;\n\n                return this;\n            }\n\n            return this.options.styleCursor;\n        },\n\n        /*\\\n         * Interactable.preventDefault\n         [ method ]\n         *\n         * Returns or sets whether to prevent the browser's default behaviour\n         * in response to pointer events. Can be set to:\n         *  - `'always'` to always prevent\n         *  - `'never'` to never prevent\n         *  - `'auto'` to let interact.js try to determine what would be best\n         *\n         - newValue (string) #optional `true`, `false` or `'auto'`\n         = (string | Interactable) The current setting or this Interactable\n        \\*/\n        preventDefault: function (newValue) {\n            if (/^(always|never|auto)$/.test(newValue)) {\n                this.options.preventDefault = newValue;\n                return this;\n            }\n\n            if (isBool(newValue)) {\n                this.options.preventDefault = newValue? 'always' : 'never';\n                return this;\n            }\n\n            return this.options.preventDefault;\n        },\n\n        /*\\\n         * Interactable.origin\n         [ method ]\n         *\n         * Gets or sets the origin of the Interactable's element.  The x and y\n         * of the origin will be subtracted from action event coordinates.\n         *\n         - origin (object | string) #optional An object eg. { x: 0, y: 0 } or string 'parent', 'self' or any CSS selector\n         * OR\n         - origin (Element) #optional An HTML or SVG Element whose rect will be used\n         **\n         = (object) The current origin or this Interactable\n        \\*/\n        origin: function (newValue) {\n            if (trySelector(newValue)) {\n                this.options.origin = newValue;\n                return this;\n            }\n            else if (isObject(newValue)) {\n                this.options.origin = newValue;\n                return this;\n            }\n\n            return this.options.origin;\n        },\n\n        /*\\\n         * Interactable.deltaSource\n         [ method ]\n         *\n         * Returns or sets the mouse coordinate types used to calculate the\n         * movement of the pointer.\n         *\n         - newValue (string) #optional Use 'client' if you will be scrolling while interacting; Use 'page' if you want autoScroll to work\n         = (string | object) The current deltaSource or this Interactable\n        \\*/\n        deltaSource: function (newValue) {\n            if (newValue === 'page' || newValue === 'client') {\n                this.options.deltaSource = newValue;\n\n                return this;\n            }\n\n            return this.options.deltaSource;\n        },\n\n        /*\\\n         * Interactable.restrict\n         [ method ]\n         **\n         * Deprecated. Add a `restrict` property to the options object passed to\n         * @Interactable.draggable, @Interactable.resizable or @Interactable.gesturable instead.\n         *\n         * Returns or sets the rectangles within which actions on this\n         * interactable (after snap calculations) are restricted. By default,\n         * restricting is relative to the pointer coordinates. You can change\n         * this by setting the\n         * [`elementRect`](https://github.com/taye/interact.js/pull/72).\n         **\n         - options (object) #optional an object with keys drag, resize, and/or gesture whose values are rects, Elements, CSS selectors, or 'parent' or 'self'\n         = (object) The current restrictions object or this Interactable\n         **\n         | interact(element).restrict({\n         |     // the rect will be `interact.getElementRect(element.parentNode)`\n         |     drag: element.parentNode,\n         |\n         |     // x and y are relative to the the interactable's origin\n         |     resize: { x: 100, y: 100, width: 200, height: 200 }\n         | })\n         |\n         | interact('.draggable').restrict({\n         |     // the rect will be the selected element's parent\n         |     drag: 'parent',\n         |\n         |     // do not restrict during normal movement.\n         |     // Instead, trigger only one restricted move event\n         |     // immediately before the end event.\n         |     endOnly: true,\n         |\n         |     // https://github.com/taye/interact.js/pull/72#issue-41813493\n         |     elementRect: { top: 0, left: 0, bottom: 1, right: 1 }\n         | });\n        \\*/\n        restrict: function (options) {\n            if (!isObject(options)) {\n                return this.setOptions('restrict', options);\n            }\n\n            var actions = ['drag', 'resize', 'gesture'],\n                ret;\n\n            for (var i = 0; i < actions.length; i++) {\n                var action = actions[i];\n\n                if (action in options) {\n                    var perAction = extend({\n                            actions: [action],\n                            restriction: options[action]\n                        }, options);\n\n                    ret = this.setOptions('restrict', perAction);\n                }\n            }\n\n            return ret;\n        },\n\n        /*\\\n         * Interactable.context\n         [ method ]\n         *\n         * Gets the selector context Node of the Interactable. The default is `window.document`.\n         *\n         = (Node) The context Node of this Interactable\n         **\n        \\*/\n        context: function () {\n            return this._context;\n        },\n\n        _context: document,\n\n        /*\\\n         * Interactable.ignoreFrom\n         [ method ]\n         *\n         * If the target of the `mousedown`, `pointerdown` or `touchstart`\n         * event or any of it's parents match the given CSS selector or\n         * Element, no drag/resize/gesture is started.\n         *\n         - newValue (string | Element | null) #optional a CSS selector string, an Element or `null` to not ignore any elements\n         = (string | Element | object) The current ignoreFrom value or this Interactable\n         **\n         | interact(element, { ignoreFrom: document.getElementById('no-action') });\n         | // or\n         | interact(element).ignoreFrom('input, textarea, a');\n        \\*/\n        ignoreFrom: function (newValue) {\n            if (trySelector(newValue)) {            // CSS selector to match event.target\n                this.options.ignoreFrom = newValue;\n                return this;\n            }\n\n            if (isElement(newValue)) {              // specific element\n                this.options.ignoreFrom = newValue;\n                return this;\n            }\n\n            return this.options.ignoreFrom;\n        },\n\n        /*\\\n         * Interactable.allowFrom\n         [ method ]\n         *\n         * A drag/resize/gesture is started only If the target of the\n         * `mousedown`, `pointerdown` or `touchstart` event or any of it's\n         * parents match the given CSS selector or Element.\n         *\n         - newValue (string | Element | null) #optional a CSS selector string, an Element or `null` to allow from any element\n         = (string | Element | object) The current allowFrom value or this Interactable\n         **\n         | interact(element, { allowFrom: document.getElementById('drag-handle') });\n         | // or\n         | interact(element).allowFrom('.handle');\n        \\*/\n        allowFrom: function (newValue) {\n            if (trySelector(newValue)) {            // CSS selector to match event.target\n                this.options.allowFrom = newValue;\n                return this;\n            }\n\n            if (isElement(newValue)) {              // specific element\n                this.options.allowFrom = newValue;\n                return this;\n            }\n\n            return this.options.allowFrom;\n        },\n\n        /*\\\n         * Interactable.element\n         [ method ]\n         *\n         * If this is not a selector Interactable, it returns the element this\n         * interactable represents\n         *\n         = (Element) HTML / SVG Element\n        \\*/\n        element: function () {\n            return this._element;\n        },\n\n        /*\\\n         * Interactable.fire\n         [ method ]\n         *\n         * Calls listeners for the given InteractEvent type bound globally\n         * and directly to this Interactable\n         *\n         - iEvent (InteractEvent) The InteractEvent object to be fired on this Interactable\n         = (Interactable) this Interactable\n        \\*/\n        fire: function (iEvent) {\n            if (!(iEvent && iEvent.type) || !contains(eventTypes, iEvent.type)) {\n                return this;\n            }\n\n            var listeners,\n                i,\n                len,\n                onEvent = 'on' + iEvent.type,\n                funcName = '';\n\n            // Interactable#on() listeners\n            if (iEvent.type in this._iEvents) {\n                listeners = this._iEvents[iEvent.type];\n\n                for (i = 0, len = listeners.length; i < len && !iEvent.immediatePropagationStopped; i++) {\n                    funcName = listeners[i].name;\n                    listeners[i](iEvent);\n                }\n            }\n\n            // interactable.onevent listener\n            if (isFunction(this[onEvent])) {\n                funcName = this[onEvent].name;\n                this[onEvent](iEvent);\n            }\n\n            // interact.on() listeners\n            if (iEvent.type in globalEvents && (listeners = globalEvents[iEvent.type]))  {\n\n                for (i = 0, len = listeners.length; i < len && !iEvent.immediatePropagationStopped; i++) {\n                    funcName = listeners[i].name;\n                    listeners[i](iEvent);\n                }\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.on\n         [ method ]\n         *\n         * Binds a listener for an InteractEvent or DOM event.\n         *\n         - eventType  (string | array | object) The types of events to listen for\n         - listener   (function) The function to be called on the given event(s)\n         - useCapture (boolean) #optional useCapture flag for addEventListener\n         = (object) This Interactable\n        \\*/\n        on: function (eventType, listener, useCapture) {\n            var i;\n\n            if (isString(eventType) && eventType.search(' ') !== -1) {\n                eventType = eventType.trim().split(/ +/);\n            }\n\n            if (isArray(eventType)) {\n                for (i = 0; i < eventType.length; i++) {\n                    this.on(eventType[i], listener, useCapture);\n                }\n\n                return this;\n            }\n\n            if (isObject(eventType)) {\n                for (var prop in eventType) {\n                    this.on(prop, eventType[prop], listener);\n                }\n\n                return this;\n            }\n\n            if (eventType === 'wheel') {\n                eventType = wheelEvent;\n            }\n\n            // convert to boolean\n            useCapture = useCapture? true: false;\n\n            if (contains(eventTypes, eventType)) {\n                // if this type of event was never bound to this Interactable\n                if (!(eventType in this._iEvents)) {\n                    this._iEvents[eventType] = [listener];\n                }\n                else {\n                    this._iEvents[eventType].push(listener);\n                }\n            }\n            // delegated event for selector\n            else if (this.selector) {\n                if (!delegatedEvents[eventType]) {\n                    delegatedEvents[eventType] = {\n                        selectors: [],\n                        contexts : [],\n                        listeners: []\n                    };\n\n                    // add delegate listener functions\n                    for (i = 0; i < documents.length; i++) {\n                        events.add(documents[i], eventType, delegateListener);\n                        events.add(documents[i], eventType, delegateUseCapture, true);\n                    }\n                }\n\n                var delegated = delegatedEvents[eventType],\n                    index;\n\n                for (index = delegated.selectors.length - 1; index >= 0; index--) {\n                    if (delegated.selectors[index] === this.selector\n                        && delegated.contexts[index] === this._context) {\n                        break;\n                    }\n                }\n\n                if (index === -1) {\n                    index = delegated.selectors.length;\n\n                    delegated.selectors.push(this.selector);\n                    delegated.contexts .push(this._context);\n                    delegated.listeners.push([]);\n                }\n\n                // keep listener and useCapture flag\n                delegated.listeners[index].push([listener, useCapture]);\n            }\n            else {\n                events.add(this._element, eventType, listener, useCapture);\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.off\n         [ method ]\n         *\n         * Removes an InteractEvent or DOM event listener\n         *\n         - eventType  (string | array | object) The types of events that were listened for\n         - listener   (function) The listener function to be removed\n         - useCapture (boolean) #optional useCapture flag for removeEventListener\n         = (object) This Interactable\n        \\*/\n        off: function (eventType, listener, useCapture) {\n            var i;\n\n            if (isString(eventType) && eventType.search(' ') !== -1) {\n                eventType = eventType.trim().split(/ +/);\n            }\n\n            if (isArray(eventType)) {\n                for (i = 0; i < eventType.length; i++) {\n                    this.off(eventType[i], listener, useCapture);\n                }\n\n                return this;\n            }\n\n            if (isObject(eventType)) {\n                for (var prop in eventType) {\n                    this.off(prop, eventType[prop], listener);\n                }\n\n                return this;\n            }\n\n            var eventList,\n                index = -1;\n\n            // convert to boolean\n            useCapture = useCapture? true: false;\n\n            if (eventType === 'wheel') {\n                eventType = wheelEvent;\n            }\n\n            // if it is an action event type\n            if (contains(eventTypes, eventType)) {\n                eventList = this._iEvents[eventType];\n\n                if (eventList && (index = indexOf(eventList, listener)) !== -1) {\n                    this._iEvents[eventType].splice(index, 1);\n                }\n            }\n            // delegated event\n            else if (this.selector) {\n                var delegated = delegatedEvents[eventType],\n                    matchFound = false;\n\n                if (!delegated) { return this; }\n\n                // count from last index of delegated to 0\n                for (index = delegated.selectors.length - 1; index >= 0; index--) {\n                    // look for matching selector and context Node\n                    if (delegated.selectors[index] === this.selector\n                        && delegated.contexts[index] === this._context) {\n\n                        var listeners = delegated.listeners[index];\n\n                        // each item of the listeners array is an array: [function, useCaptureFlag]\n                        for (i = listeners.length - 1; i >= 0; i--) {\n                            var fn = listeners[i][0],\n                                useCap = listeners[i][1];\n\n                            // check if the listener functions and useCapture flags match\n                            if (fn === listener && useCap === useCapture) {\n                                // remove the listener from the array of listeners\n                                listeners.splice(i, 1);\n\n                                // if all listeners for this interactable have been removed\n                                // remove the interactable from the delegated arrays\n                                if (!listeners.length) {\n                                    delegated.selectors.splice(index, 1);\n                                    delegated.contexts .splice(index, 1);\n                                    delegated.listeners.splice(index, 1);\n\n                                    // remove delegate function from context\n                                    events.remove(this._context, eventType, delegateListener);\n                                    events.remove(this._context, eventType, delegateUseCapture, true);\n\n                                    // remove the arrays if they are empty\n                                    if (!delegated.selectors.length) {\n                                        delegatedEvents[eventType] = null;\n                                    }\n                                }\n\n                                // only remove one listener\n                                matchFound = true;\n                                break;\n                            }\n                        }\n\n                        if (matchFound) { break; }\n                    }\n                }\n            }\n            // remove listener from this Interatable's element\n            else {\n                events.remove(this._element, eventType, listener, useCapture);\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.set\n         [ method ]\n         *\n         * Reset the options of this Interactable\n         - options (object) The new settings to apply\n         = (object) This Interactable\n        \\*/\n        set: function (options) {\n            if (!isObject(options)) {\n                options = {};\n            }\n\n            this.options = extend({}, defaultOptions.base);\n\n            var i,\n                actions = ['drag', 'drop', 'resize', 'gesture'],\n                methods = ['draggable', 'dropzone', 'resizable', 'gesturable'],\n                perActions = extend(extend({}, defaultOptions.perAction), options[action] || {});\n\n            for (i = 0; i < actions.length; i++) {\n                var action = actions[i];\n\n                this.options[action] = extend({}, defaultOptions[action]);\n\n                this.setPerAction(action, perActions);\n\n                this[methods[i]](options[action]);\n            }\n\n            var settings = [\n                    'accept', 'actionChecker', 'allowFrom', 'deltaSource',\n                    'dropChecker', 'ignoreFrom', 'origin', 'preventDefault',\n                    'rectChecker', 'styleCursor'\n                ];\n\n            for (i = 0, len = settings.length; i < len; i++) {\n                var setting = settings[i];\n\n                this.options[setting] = defaultOptions.base[setting];\n\n                if (setting in options) {\n                    this[setting](options[setting]);\n                }\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.unset\n         [ method ]\n         *\n         * Remove this interactable from the list of interactables and remove\n         * it's drag, drop, resize and gesture capabilities\n         *\n         = (object) @interact\n        \\*/\n        unset: function () {\n            events.remove(this._element, 'all');\n\n            if (!isString(this.selector)) {\n                events.remove(this, 'all');\n                if (this.options.styleCursor) {\n                    this._element.style.cursor = '';\n                }\n            }\n            else {\n                // remove delegated events\n                for (var type in delegatedEvents) {\n                    var delegated = delegatedEvents[type];\n\n                    for (var i = 0; i < delegated.selectors.length; i++) {\n                        if (delegated.selectors[i] === this.selector\n                            && delegated.contexts[i] === this._context) {\n\n                            delegated.selectors.splice(i, 1);\n                            delegated.contexts .splice(i, 1);\n                            delegated.listeners.splice(i, 1);\n\n                            // remove the arrays if they are empty\n                            if (!delegated.selectors.length) {\n                                delegatedEvents[type] = null;\n                            }\n                        }\n\n                        events.remove(this._context, type, delegateListener);\n                        events.remove(this._context, type, delegateUseCapture, true);\n\n                        break;\n                    }\n                }\n            }\n\n            this.dropzone(false);\n\n            interactables.splice(indexOf(interactables, this), 1);\n\n            return interact;\n        }\n    };\n\n    function warnOnce (method, message) {\n        var warned = false;\n\n        return function () {\n            if (!warned) {\n                window.console.warn(message);\n                warned = true;\n            }\n\n            return method.apply(this, arguments);\n        };\n    }\n\n    Interactable.prototype.snap = warnOnce(Interactable.prototype.snap,\n         'Interactable#snap is deprecated. See the new documentation for snapping at http://interactjs.io/docs/snapping');\n    Interactable.prototype.restrict = warnOnce(Interactable.prototype.restrict,\n         'Interactable#restrict is deprecated. See the new documentation for resticting at http://interactjs.io/docs/restriction');\n    Interactable.prototype.inertia = warnOnce(Interactable.prototype.inertia,\n         'Interactable#inertia is deprecated. See the new documentation for inertia at http://interactjs.io/docs/inertia');\n    Interactable.prototype.autoScroll = warnOnce(Interactable.prototype.autoScroll,\n         'Interactable#autoScroll is deprecated. See the new documentation for autoScroll at http://interactjs.io/docs/#autoscroll');\n    Interactable.prototype.squareResize = warnOnce(Interactable.prototype.squareResize,\n         'Interactable#squareResize is deprecated. See http://interactjs.io/docs/#resize-square');\n\n    Interactable.prototype.accept = warnOnce(Interactable.prototype.accept,\n         'Interactable#accept is deprecated. use Interactable#dropzone({ accept: target }) instead');\n    Interactable.prototype.dropChecker = warnOnce(Interactable.prototype.dropChecker,\n         'Interactable#dropChecker is deprecated. use Interactable#dropzone({ dropChecker: checkerFunction }) instead');\n    Interactable.prototype.context = warnOnce(Interactable.prototype.context,\n         'Interactable#context as a method is deprecated. It will soon be a DOM Node instead');\n\n    /*\\\n     * interact.isSet\n     [ method ]\n     *\n     * Check if an element has been set\n     - element (Element) The Element being searched for\n     = (boolean) Indicates if the element or CSS selector was previously passed to interact\n    \\*/\n    interact.isSet = function(element, options) {\n        return interactables.indexOfElement(element, options && options.context) !== -1;\n    };\n\n    /*\\\n     * interact.on\n     [ method ]\n     *\n     * Adds a global listener for an InteractEvent or adds a DOM event to\n     * `document`\n     *\n     - type       (string | array | object) The types of events to listen for\n     - listener   (function) The function to be called on the given event(s)\n     - useCapture (boolean) #optional useCapture flag for addEventListener\n     = (object) interact\n    \\*/\n    interact.on = function (type, listener, useCapture) {\n        if (isString(type) && type.search(' ') !== -1) {\n            type = type.trim().split(/ +/);\n        }\n\n        if (isArray(type)) {\n            for (var i = 0; i < type.length; i++) {\n                interact.on(type[i], listener, useCapture);\n            }\n\n            return interact;\n        }\n\n        if (isObject(type)) {\n            for (var prop in type) {\n                interact.on(prop, type[prop], listener);\n            }\n\n            return interact;\n        }\n\n        // if it is an InteractEvent type, add listener to globalEvents\n        if (contains(eventTypes, type)) {\n            // if this type of event was never bound\n            if (!globalEvents[type]) {\n                globalEvents[type] = [listener];\n            }\n            else {\n                globalEvents[type].push(listener);\n            }\n        }\n        // If non InteractEvent type, addEventListener to document\n        else {\n            events.add(document, type, listener, useCapture);\n        }\n\n        return interact;\n    };\n\n    /*\\\n     * interact.off\n     [ method ]\n     *\n     * Removes a global InteractEvent listener or DOM event from `document`\n     *\n     - type       (string | array | object) The types of events that were listened for\n     - listener   (function) The listener function to be removed\n     - useCapture (boolean) #optional useCapture flag for removeEventListener\n     = (object) interact\n     \\*/\n    interact.off = function (type, listener, useCapture) {\n        if (isString(type) && type.search(' ') !== -1) {\n            type = type.trim().split(/ +/);\n        }\n\n        if (isArray(type)) {\n            for (var i = 0; i < type.length; i++) {\n                interact.off(type[i], listener, useCapture);\n            }\n\n            return interact;\n        }\n\n        if (isObject(type)) {\n            for (var prop in type) {\n                interact.off(prop, type[prop], listener);\n            }\n\n            return interact;\n        }\n\n        if (!contains(eventTypes, type)) {\n            events.remove(document, type, listener, useCapture);\n        }\n        else {\n            var index;\n\n            if (type in globalEvents\n                && (index = indexOf(globalEvents[type], listener)) !== -1) {\n                globalEvents[type].splice(index, 1);\n            }\n        }\n\n        return interact;\n    };\n\n    /*\\\n     * interact.enableDragging\n     [ method ]\n     *\n     * Deprecated.\n     *\n     * Returns or sets whether dragging is enabled for any Interactables\n     *\n     - newValue (boolean) #optional `true` to allow the action; `false` to disable action for all Interactables\n     = (boolean | object) The current setting or interact\n    \\*/\n    interact.enableDragging = warnOnce(function (newValue) {\n        if (newValue !== null && newValue !== undefined) {\n            actionIsEnabled.drag = newValue;\n\n            return interact;\n        }\n        return actionIsEnabled.drag;\n    }, 'interact.enableDragging is deprecated and will soon be removed.');\n\n    /*\\\n     * interact.enableResizing\n     [ method ]\n     *\n     * Deprecated.\n     *\n     * Returns or sets whether resizing is enabled for any Interactables\n     *\n     - newValue (boolean) #optional `true` to allow the action; `false` to disable action for all Interactables\n     = (boolean | object) The current setting or interact\n    \\*/\n    interact.enableResizing = warnOnce(function (newValue) {\n        if (newValue !== null && newValue !== undefined) {\n            actionIsEnabled.resize = newValue;\n\n            return interact;\n        }\n        return actionIsEnabled.resize;\n    }, 'interact.enableResizing is deprecated and will soon be removed.');\n\n    /*\\\n     * interact.enableGesturing\n     [ method ]\n     *\n     * Deprecated.\n     *\n     * Returns or sets whether gesturing is enabled for any Interactables\n     *\n     - newValue (boolean) #optional `true` to allow the action; `false` to disable action for all Interactables\n     = (boolean | object) The current setting or interact\n    \\*/\n    interact.enableGesturing = warnOnce(function (newValue) {\n        if (newValue !== null && newValue !== undefined) {\n            actionIsEnabled.gesture = newValue;\n\n            return interact;\n        }\n        return actionIsEnabled.gesture;\n    }, 'interact.enableGesturing is deprecated and will soon be removed.');\n\n    interact.eventTypes = eventTypes;\n\n    /*\\\n     * interact.debug\n     [ method ]\n     *\n     * Returns debugging data\n     = (object) An object with properties that outline the current state and expose internal functions and variables\n    \\*/\n    interact.debug = function () {\n        var interaction = interactions[0] || new Interaction();\n\n        return {\n            interactions          : interactions,\n            target                : interaction.target,\n            dragging              : interaction.dragging,\n            resizing              : interaction.resizing,\n            gesturing             : interaction.gesturing,\n            prepared              : interaction.prepared,\n            matches               : interaction.matches,\n            matchElements         : interaction.matchElements,\n\n            prevCoords            : interaction.prevCoords,\n            startCoords           : interaction.startCoords,\n\n            pointerIds            : interaction.pointerIds,\n            pointers              : interaction.pointers,\n            addPointer            : listeners.addPointer,\n            removePointer         : listeners.removePointer,\n            recordPointer        : listeners.recordPointer,\n\n            snap                  : interaction.snapStatus,\n            restrict              : interaction.restrictStatus,\n            inertia               : interaction.inertiaStatus,\n\n            downTime              : interaction.downTimes[0],\n            downEvent             : interaction.downEvent,\n            downPointer           : interaction.downPointer,\n            prevEvent             : interaction.prevEvent,\n\n            Interactable          : Interactable,\n            interactables         : interactables,\n            pointerIsDown         : interaction.pointerIsDown,\n            defaultOptions        : defaultOptions,\n            defaultActionChecker  : defaultActionChecker,\n\n            actionCursors         : actionCursors,\n            dragMove              : listeners.dragMove,\n            resizeMove            : listeners.resizeMove,\n            gestureMove           : listeners.gestureMove,\n            pointerUp             : listeners.pointerUp,\n            pointerDown           : listeners.pointerDown,\n            pointerMove           : listeners.pointerMove,\n            pointerHover          : listeners.pointerHover,\n\n            eventTypes            : eventTypes,\n\n            events                : events,\n            globalEvents          : globalEvents,\n            delegatedEvents       : delegatedEvents,\n\n            prefixedPropREs       : prefixedPropREs\n        };\n    };\n\n    // expose the functions used to calculate multi-touch properties\n    interact.getPointerAverage = pointerAverage;\n    interact.getTouchBBox     = touchBBox;\n    interact.getTouchDistance = touchDistance;\n    interact.getTouchAngle    = touchAngle;\n\n    interact.getElementRect         = getElementRect;\n    interact.getElementClientRect   = getElementClientRect;\n    interact.matchesSelector        = matchesSelector;\n    interact.closest                = closest;\n\n    /*\\\n     * interact.margin\n     [ method ]\n     *\n     * Deprecated. Use `interact(target).resizable({ margin: number });` instead.\n     * Returns or sets the margin for autocheck resizing used in\n     * @Interactable.getAction. That is the distance from the bottom and right\n     * edges of an element clicking in which will start resizing\n     *\n     - newValue (number) #optional\n     = (number | interact) The current margin value or interact\n    \\*/\n    interact.margin = warnOnce(function (newvalue) {\n        if (isNumber(newvalue)) {\n            margin = newvalue;\n\n            return interact;\n        }\n        return margin;\n    },\n    'interact.margin is deprecated. Use interact(target).resizable({ margin: number }); instead.') ;\n\n    /*\\\n     * interact.supportsTouch\n     [ method ]\n     *\n     = (boolean) Whether or not the browser supports touch input\n    \\*/\n    interact.supportsTouch = function () {\n        return supportsTouch;\n    };\n\n    /*\\\n     * interact.supportsPointerEvent\n     [ method ]\n     *\n     = (boolean) Whether or not the browser supports PointerEvents\n    \\*/\n    interact.supportsPointerEvent = function () {\n        return supportsPointerEvent;\n    };\n\n    /*\\\n     * interact.stop\n     [ method ]\n     *\n     * Cancels all interactions (end events are not fired)\n     *\n     - event (Event) An event on which to call preventDefault()\n     = (object) interact\n    \\*/\n    interact.stop = function (event) {\n        for (var i = interactions.length - 1; i >= 0; i--) {\n            interactions[i].stop(event);\n        }\n\n        return interact;\n    };\n\n    /*\\\n     * interact.dynamicDrop\n     [ method ]\n     *\n     * Returns or sets whether the dimensions of dropzone elements are\n     * calculated on every dragmove or only on dragstart for the default\n     * dropChecker\n     *\n     - newValue (boolean) #optional True to check on each move. False to check only before start\n     = (boolean | interact) The current setting or interact\n    \\*/\n    interact.dynamicDrop = function (newValue) {\n        if (isBool(newValue)) {\n            //if (dragging && dynamicDrop !== newValue && !newValue) {\n                //calcRects(dropzones);\n            //}\n\n            dynamicDrop = newValue;\n\n            return interact;\n        }\n        return dynamicDrop;\n    };\n\n    /*\\\n     * interact.pointerMoveTolerance\n     [ method ]\n     * Returns or sets the distance the pointer must be moved before an action\n     * sequence occurs. This also affects tolerance for tap events.\n     *\n     - newValue (number) #optional The movement from the start position must be greater than this value\n     = (number | Interactable) The current setting or interact\n    \\*/\n    interact.pointerMoveTolerance = function (newValue) {\n        if (isNumber(newValue)) {\n            pointerMoveTolerance = newValue;\n\n            return this;\n        }\n\n        return pointerMoveTolerance;\n    };\n\n    /*\\\n     * interact.maxInteractions\n     [ method ]\n     **\n     * Returns or sets the maximum number of concurrent interactions allowed.\n     * By default only 1 interaction is allowed at a time (for backwards\n     * compatibility). To allow multiple interactions on the same Interactables\n     * and elements, you need to enable it in the draggable, resizable and\n     * gesturable `'max'` and `'maxPerElement'` options.\n     **\n     - newValue (number) #optional Any number. newValue <= 0 means no interactions.\n    \\*/\n    interact.maxInteractions = function (newValue) {\n        if (isNumber(newValue)) {\n            maxInteractions = newValue;\n\n            return this;\n        }\n\n        return maxInteractions;\n    };\n\n    interact.createSnapGrid = function (grid) {\n        return function (x, y) {\n            var offsetX = 0,\n                offsetY = 0;\n\n            if (isObject(grid.offset)) {\n                offsetX = grid.offset.x;\n                offsetY = grid.offset.y;\n            }\n\n            var gridx = Math.round((x - offsetX) / grid.x),\n                gridy = Math.round((y - offsetY) / grid.y),\n\n                newX = gridx * grid.x + offsetX,\n                newY = gridy * grid.y + offsetY;\n\n            return {\n                x: newX,\n                y: newY,\n                range: grid.range\n            };\n        };\n    };\n\n    function endAllInteractions (event) {\n        for (var i = 0; i < interactions.length; i++) {\n            interactions[i].pointerEnd(event, event);\n        }\n    }\n\n    function listenToDocument (doc) {\n        if (contains(documents, doc)) { return; }\n\n        var win = doc.defaultView || doc.parentWindow;\n\n        // add delegate event listener\n        for (var eventType in delegatedEvents) {\n            events.add(doc, eventType, delegateListener);\n            events.add(doc, eventType, delegateUseCapture, true);\n        }\n\n        if (supportsPointerEvent) {\n            if (PointerEvent === win.MSPointerEvent) {\n                pEventTypes = {\n                    up: 'MSPointerUp', down: 'MSPointerDown', over: 'mouseover',\n                    out: 'mouseout', move: 'MSPointerMove', cancel: 'MSPointerCancel' };\n            }\n            else {\n                pEventTypes = {\n                    up: 'pointerup', down: 'pointerdown', over: 'pointerover',\n                    out: 'pointerout', move: 'pointermove', cancel: 'pointercancel' };\n            }\n\n            events.add(doc, pEventTypes.down  , listeners.selectorDown );\n            events.add(doc, pEventTypes.move  , listeners.pointerMove  );\n            events.add(doc, pEventTypes.over  , listeners.pointerOver  );\n            events.add(doc, pEventTypes.out   , listeners.pointerOut   );\n            events.add(doc, pEventTypes.up    , listeners.pointerUp    );\n            events.add(doc, pEventTypes.cancel, listeners.pointerCancel);\n\n            // autoscroll\n            events.add(doc, pEventTypes.move, listeners.autoScrollMove);\n        }\n        else {\n            events.add(doc, 'mousedown', listeners.selectorDown);\n            events.add(doc, 'mousemove', listeners.pointerMove );\n            events.add(doc, 'mouseup'  , listeners.pointerUp   );\n            events.add(doc, 'mouseover', listeners.pointerOver );\n            events.add(doc, 'mouseout' , listeners.pointerOut  );\n\n            events.add(doc, 'touchstart' , listeners.selectorDown );\n            events.add(doc, 'touchmove'  , listeners.pointerMove  );\n            events.add(doc, 'touchend'   , listeners.pointerUp    );\n            events.add(doc, 'touchcancel', listeners.pointerCancel);\n\n            // autoscroll\n            events.add(doc, 'mousemove', listeners.autoScrollMove);\n            events.add(doc, 'touchmove', listeners.autoScrollMove);\n        }\n\n        events.add(win, 'blur', endAllInteractions);\n\n        try {\n            if (win.frameElement) {\n                var parentDoc = win.frameElement.ownerDocument,\n                    parentWindow = parentDoc.defaultView;\n\n                events.add(parentDoc   , 'mouseup'      , listeners.pointerEnd);\n                events.add(parentDoc   , 'touchend'     , listeners.pointerEnd);\n                events.add(parentDoc   , 'touchcancel'  , listeners.pointerEnd);\n                events.add(parentDoc   , 'pointerup'    , listeners.pointerEnd);\n                events.add(parentDoc   , 'MSPointerUp'  , listeners.pointerEnd);\n                events.add(parentWindow, 'blur'         , endAllInteractions );\n            }\n        }\n        catch (error) {\n            interact.windowParentError = error;\n        }\n\n        // prevent native HTML5 drag on interact.js target elements\n        events.add(doc, 'dragstart', function (event) {\n            for (var i = 0; i < interactions.length; i++) {\n                var interaction = interactions[i];\n\n                if (interaction.element\n                    && (interaction.element === event.target\n                        || nodeContains(interaction.element, event.target))) {\n\n                    interaction.checkAndPreventDefault(event, interaction.target, interaction.element);\n                    return;\n                }\n            }\n        });\n\n        if (events.useAttachEvent) {\n            // For IE's lack of Event#preventDefault\n            events.add(doc, 'selectstart', function (event) {\n                var interaction = interactions[0];\n\n                if (interaction.currentAction()) {\n                    interaction.checkAndPreventDefault(event);\n                }\n            });\n\n            // For IE's bad dblclick event sequence\n            events.add(doc, 'dblclick', doOnInteractions('ie8Dblclick'));\n        }\n\n        documents.push(doc);\n    }\n\n    listenToDocument(document);\n\n    function indexOf (array, target) {\n        for (var i = 0, len = array.length; i < len; i++) {\n            if (array[i] === target) {\n                return i;\n            }\n        }\n\n        return -1;\n    }\n\n    function contains (array, target) {\n        return indexOf(array, target) !== -1;\n    }\n\n    function matchesSelector (element, selector, nodeList) {\n        if (ie8MatchesSelector) {\n            return ie8MatchesSelector(element, selector, nodeList);\n        }\n\n        // remove /deep/ from selectors if shadowDOM polyfill is used\n        if (window !== realWindow) {\n            selector = selector.replace(/\\/deep\\//g, ' ');\n        }\n\n        return element[prefixedMatchesSelector](selector);\n    }\n\n    function matchesUpTo (element, selector, limit) {\n        while (isElement(element)) {\n            if (matchesSelector(element, selector)) {\n                return true;\n            }\n\n            element = parentElement(element);\n\n            if (element === limit) {\n                return matchesSelector(element, selector);\n            }\n        }\n\n        return false;\n    }\n\n    // For IE8's lack of an Element#matchesSelector\n    // taken from http://tanalin.com/en/blog/2012/12/matches-selector-ie8/ and modified\n    if (!(prefixedMatchesSelector in Element.prototype) || !isFunction(Element.prototype[prefixedMatchesSelector])) {\n        ie8MatchesSelector = function (element, selector, elems) {\n            elems = elems || element.parentNode.querySelectorAll(selector);\n\n            for (var i = 0, len = elems.length; i < len; i++) {\n                if (elems[i] === element) {\n                    return true;\n                }\n            }\n\n            return false;\n        };\n    }\n\n    // requestAnimationFrame polyfill\n    (function() {\n        var lastTime = 0,\n            vendors = ['ms', 'moz', 'webkit', 'o'];\n\n        for(var x = 0; x < vendors.length && !realWindow.requestAnimationFrame; ++x) {\n            reqFrame = realWindow[vendors[x]+'RequestAnimationFrame'];\n            cancelFrame = realWindow[vendors[x]+'CancelAnimationFrame'] || realWindow[vendors[x]+'CancelRequestAnimationFrame'];\n        }\n\n        if (!reqFrame) {\n            reqFrame = function(callback) {\n                var currTime = new Date().getTime(),\n                    timeToCall = Math.max(0, 16 - (currTime - lastTime)),\n                    id = setTimeout(function() { callback(currTime + timeToCall); },\n                  timeToCall);\n                lastTime = currTime + timeToCall;\n                return id;\n            };\n        }\n\n        if (!cancelFrame) {\n            cancelFrame = function(id) {\n                clearTimeout(id);\n            };\n        }\n    }());\n\n    /* global exports: true, module, define */\n\n    // http://documentcloud.github.io/underscore/docs/underscore.html#section-11\n    if (true) {\n        if (typeof module !== 'undefined' && module.exports) {\n            exports = module.exports = interact;\n        }\n        exports.interact = interact;\n    }\n    // AMD\n    else if (typeof define === 'function' && define.amd) {\n        define('interact', function() {\n            return interact;\n        });\n    }\n    else {\n        realWindow.interact = interact;\n    }\n\n} (typeof window === 'undefined'? undefined : window));\n\n\n/***/ }),\n/* 14 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = manageZIndex;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = dragHandler;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = resizeHandler;\nfunction manageZIndex(event) {\n  var target = event.target;\n\n\n  this.lastZ = this.lastZ ? this.lastZ += 1 : 1;\n  target.style.zIndex = this.lastZ;\n}\n\nfunction dragHandler(event) {\n  var newX = void 0,\n      newY = void 0;\n  var target = event.target,\n      dx = event.dx,\n      dy = event.dy;\n\n  // Ensure target always has higher z-index than siblings\n\n  var siblingNodes = target.parentElement.children;\n\n  newX = (parseFloat(target.getAttribute('data-x')) || 0) + dx;\n  newY = (parseFloat(target.getAttribute('data-y')) || 0) + dy;\n  target.style.webkitTransform = target.style.transform = 'translate(' + newX + 'px, ' + newY + 'px)';\n  target.setAttribute('data-x', newX);\n  target.setAttribute('data-y', newY);\n}\n\nfunction resizeHandler(event) {\n  var x = void 0,\n      y = void 0;\n  var target = event.target,\n      dx = event.dx,\n      dy = event.dy;\n\n  x = parseFloat(target.getAttribute('data-x')) || 0;\n  y = parseFloat(target.getAttribute('data-y')) || 0;\n\n  if (event.rect.height <= 400 && event.rect.height >= 100) {\n    // update the element's style\n    target.style.width = event.rect.width + 'px';\n    target.style.height = event.rect.height + 'px';\n\n    // translate when resizing from top or left edges\n    x += event.deltaRect.left;\n    y += event.deltaRect.top;\n\n    target.style.webkitTransform = target.style.transform = 'translate(' + x + 'px,' + y + 'px)';\n  }\n\n  target.setAttribute('data-x', x);\n  target.setAttribute('data-y', y);\n}\n\n/***/ }),\n/* 15 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__constants_copy__ = __webpack_require__(3);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_articles_galleries__ = __webpack_require__(16);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_articles_lightbox__ = __webpack_require__(17);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n// import Contributions from 'articles/contributions';\n\n\n\nvar Articles = function () {\n  function Articles(elems) {\n    _classCallCheck(this, Articles);\n\n    this.elems = elems;\n\n    this.elems.articles = {\n      $articles: [].slice.call(document.getElementsByClassName('articles-category'))\n    };\n\n    this.elems.articles.$articles.map(function ($discipline, i) {\n      $discipline.addEventListener('click', function (e) {\n        $('.articles-category').removeClass('darkgray');\n        e.target.classList.add('darkgray');\n        window.history.pushState(null, null, e.target.getAttribute('href'));\n      });\n    });\n\n    if (document.getElementsByClassName('slick-gallery')) {\n      var $galleryEls = $('.slick-gallery');\n      this.Galleries = new __WEBPACK_IMPORTED_MODULE_1_articles_galleries__[\"a\" /* default */]($galleryEls);\n    }\n\n    if (document.getElementsByClassName('lightbox-trigger')) {\n      this.Lightbox = new __WEBPACK_IMPORTED_MODULE_2_articles_lightbox__[\"a\" /* default */]();\n    }\n\n    if (document.getElementById('article-show')) {\n      // Sub-components\n      // this.Contributions  = new Contributions('Contributions', this.elems);\n      // Effects\n      this.progress = this.initProgressBar();\n    }\n  }\n\n  _createClass(Articles, [{\n    key: 'initProgressBar',\n    value: function initProgressBar() {\n      var _this = this;\n\n      this.elems.$progress = document.getElementById('progress');\n\n      // refreshes progress with each window scroll and resize event fired\n      ['scroll', 'resize'].forEach(function (e) {\n        window.addEventListener(e, function (f) {\n          _this.progress = _this.updateProgressBar();\n        });\n      });\n\n      return this.updateProgressBar();\n    }\n  }, {\n    key: 'updateProgressBar',\n    value: function updateProgressBar() {\n\n      var viewHeight = window.innerHeight;\n      var docLength = document.body.scrollHeight;\n      var totalDistance = docLength - viewHeight;\n      var scrollTop = window.pageYOffset !== undefined ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n\n      var percentage = scrollTop / totalDistance * 100;\n\n      this.elems.$progress.style.width = percentage + '%';\n\n      return {\n        $progress: this.elems.$progress,\n        docLength: docLength,\n        totalDistance: totalDistance,\n        scrollTop: scrollTop,\n        percentage: percentage\n      };\n    }\n  }]);\n\n  return Articles;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Articles);\n\n/***/ }),\n/* 16 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Galleries = function () {\n  function Galleries(elems) {\n    var _this = this;\n\n    _classCallCheck(this, Galleries);\n\n    this.elems = elems;\n    this.galleries = this.elems.map(function (index, gallery) {\n      return _this.initGallery(gallery);\n    });\n  }\n\n  _createClass(Galleries, [{\n    key: 'initGallery',\n    value: function initGallery(gallery) {\n      var $this = $(gallery);\n      var $center = $this.siblings('.center');\n      $(gallery).slick({\n        appendDots: $center.find('.dots-parent')\n      });\n\n      $center.find('.slider-next-arrow').click(function () {\n        $this.slick('slickNext');\n      });\n\n      $center.find('.slider-prev-arrow').click(function () {\n        $this.slick('slickPrev');\n      });\n\n      if ($this.hasClass('focus-mode')) {\n        var $focusSlider = $this;\n        $this.find('.slick-slide').on('click', function (e) {\n          e.stopPropagation();\n          var $this = $(this);\n          var index = $(this).data().slickIndex;\n\n          if ($focusSlider.slick('slickCurrentSlide') !== index) {\n            $focusSlider.slick('slickCurrentSlide') > index ? $focusSlider.slick('slickPrev') : $focusSlider.slick('slickNext');\n          }\n        });\n      }\n    }\n  }]);\n\n  return Galleries;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Galleries);\n\n/***/ }),\n/* 17 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__constants_settings__ = __webpack_require__(0);\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\nvar Lightbox = function () {\n  function Lightbox() {\n    _classCallCheck(this, Lightbox);\n\n    Object.defineProperty(this, 'selectors', {\n      enumerable: true,\n      writable: true,\n      value: {\n        prevArrow: '[data-prev-arrow]',\n        nextArrow: '[data-next-arrow]'\n      }\n    });\n\n    this.initializers = [].slice.call(document.getElementsByClassName('lightbox-trigger'));\n    this.destroyers = null;\n    this.lightboxEl = document.getElementById('lightbox');\n    this.lightboxGalleryEl = document.getElementsByClassName('lightbox-gallery')[0];\n    this.slickGallery = null;\n    this.isActive = false;\n    this.prevArrow = document.querySelector(this.selectors.prevArrow);\n    this.nextArrow = document.querySelector(this.selectors.nextArrow);\n    this.widthRequirement = 1024;\n    this.buildInitializers();\n  }\n\n  _createClass(Lightbox, [{\n    key: 'buildInitializers',\n    value: function buildInitializers() {\n      var _this = this;\n\n      this.initializers.map(function (initializer, i) {\n        initializer.addEventListener('click', function (e) {\n          if (parseInt($(window).width()) >= _this.widthRequirement) {\n            if (!_this.isActive) {\n              _this.isActive = true;\n              _this.buildGallery(initializer);\n              return _this.openLightbox();\n            }\n          }\n        });\n      });\n    }\n  }, {\n    key: 'buildDestroyers',\n    value: function buildDestroyers() {\n      var _this2 = this;\n\n      this.destroyers.map(function (destroyer, i) {\n        destroyer.addEventListener('click', function (e) {\n          if (_this2.isActive) {\n            _this2.isActive = false;\n            _this2.destroyGallery();\n            return _this2.closeLightbox();\n          }\n        });\n      });\n    }\n  }, {\n    key: 'initGallery',\n    value: function initGallery() {\n      var $lightboxGalleryEl = $(this.lightboxGalleryEl);\n      $lightboxGalleryEl.slick(__WEBPACK_IMPORTED_MODULE_0__constants_settings__[\"b\" /* LIGHTBOX_SLIDER */]);\n      this.slickGallery = $lightboxGalleryEl;\n    }\n  }, {\n    key: 'destroyGallery',\n    value: function destroyGallery() {\n      this.slickGallery.slick('unslick');\n      this.slickGallery = null;\n      var lightboxGallery = this.lightboxGalleryEl.cloneNode(false);\n      this.lightboxEl.replaceChild(lightboxGallery, this.lightboxGalleryEl);\n      this.lightboxGalleryEl = lightboxGallery;\n    }\n  }, {\n    key: 'buildGallery',\n    value: function buildGallery(targetEl) {\n      var _this3 = this;\n\n      // Get Lightbox Els\n      var siblingNodeList = targetEl.parentNode.children;\n      var galleryEls = [].slice.call(siblingNodeList).filter(function (el) {\n        return el.hasAttribute('data-image-url');\n      });\n      var targetIndex = galleryEls.indexOf(targetEl);\n      var lightboxGalleryEls = galleryEls.slice(targetIndex).concat(galleryEls.slice(0, targetIndex));\n\n      if (galleryEls.length === 1) {\n        this.hideArrows();\n      } else {\n        this.showArrows();\n      }\n\n      lightboxGalleryEls.map(function (el, i) {\n        // Build Nodes\n        var childEls = [].slice.call(el.children);\n        var slide = document.createElement('div');\n        var imgWrapper = document.createElement('div');\n        var imgEl = document.createElement('img');\n        imgEl.src = el.dataset.imageUrl;\n\n        // Build Slide\n        imgWrapper.classList.add('lightbox-destroy');\n        imgWrapper.appendChild(imgEl);\n\n        // Add Caption if it exists\n        var imgCaption = childEls.find(function (el) {\n          return el.classList.contains('img-caption-container');\n        });\n        if (imgCaption) {\n          var captionClone = imgCaption.cloneNode(true);\n          imgWrapper.appendChild(captionClone);\n        }\n        slide.appendChild(imgWrapper);\n\n        // Append Els\n        _this3.lightboxGalleryEl.appendChild(slide);\n\n        // Setup Destroyers\n        _this3.destroyers = [].slice.call(document.querySelectorAll('.lightbox-gallery'));\n        _this3.buildDestroyers();\n      });\n    }\n  }, {\n    key: 'hideArrows',\n    value: function hideArrows() {\n      this.prevArrow.classList.add('hide');\n      this.nextArrow.classList.add('hide');\n    }\n  }, {\n    key: 'showArrows',\n    value: function showArrows() {\n      this.prevArrow.classList.remove('hide');\n      this.nextArrow.classList.remove('hide');\n    }\n  }, {\n    key: 'openLightbox',\n    value: function openLightbox() {\n      this.initGallery();\n      this.lightboxEl.classList.add('active');\n    }\n  }, {\n    key: 'closeLightbox',\n    value: function closeLightbox() {\n      this.lightboxEl.classList.remove('active');\n    }\n  }]);\n\n  return Lightbox;\n}();\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Lightbox);\n\n/***/ }),\n/* 18 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Museboard = function () {\n  function Museboard(elems) {\n    var _this = this;\n\n    _classCallCheck(this, Museboard);\n\n    this.paginators = [].slice.call(document.getElementsByClassName('reference-paginator'));\n    this.refBlocks = [].slice.call(document.getElementsByClassName('reference-block'));\n    this.references = [].slice.call(document.getElementsByClassName('mb-reference'));\n    this.refsToggle = [].slice.call(document.getElementsByClassName('ref-toggle'));\n\n    this.refsToggle.map(function (toggle, i) {\n      toggle.addEventListener('click', function (e) {\n        var target = e.target;\n        var refsToggle = _this.refsToggle[0];\n        var refsList = [].slice.call(document.getElementsByClassName('ref-list-mobile'))[0];\n\n        if (refsList.classList.contains('showing')) {\n          return refsList.classList.remove('showing');\n        }\n        return refsList.classList.add('showing');\n      });\n    });\n\n    //Pagination\n    if (this.paginators.length) {\n      this.paginators.map(function (paginator, i) {\n        paginator.addEventListener('click', function (e) {\n          var target = e.target;\n          var targetIndex = parseInt(target.dataset.refBlockIndex);\n          var targetBlock = document.getElementsByClassName('ref-block-' + targetIndex)[0];\n\n          if (target.classList.contains('active') && targetBlock.classList.contains('active')) {\n            return;\n          }\n\n          _this.paginators.map(function (paginator) {\n            return removeClassName(paginator, 'active');\n          });\n          _this.refBlocks.map(function (block) {\n            return removeClassName(block, 'active');\n          });\n\n          target.classList.add('active');\n          targetBlock.classList.add('active');\n        });\n      });\n    }\n\n    //Hover On/Off\n    this.references.map(function (ref, i) {\n      ref.addEventListener('mouseenter', function (e) {\n        var targetRef = e.target;\n        var refBlockIndex = parseInt(targetRef.parentElement.dataset.refBlockIndex);\n        var targetImage = findTargetImage(targetRef, refBlockIndex);\n\n        if (targetImage.classList.contains('active-select') && targetRef.classList.contains('active-select')) {\n          return;\n        }\n        _this.hoverImageOn(targetImage);\n      });\n\n      ref.addEventListener('mouseleave', function (e) {\n        var targetRef = e.target;\n        var refBlockIndex = parseInt(targetRef.parentElement.dataset.refBlockIndex);\n        var targetImage = findTargetImage(targetRef, refBlockIndex);\n\n        if (targetImage.classList.contains('active-select') && targetRef.classList.contains('active-select')) {\n          return;\n        }\n        _this.hoverImageOff(targetImage);\n      });\n\n      // Click\n      ref.addEventListener('click', function (e) {\n        var targetRef = e.currentTarget;\n        var refBlockIndex = parseInt(targetRef.parentElement.dataset.refBlockIndex);\n        var targetImage = findTargetImage(targetRef, refBlockIndex);\n\n        if (targetImage.classList.contains('active-select') && targetRef.classList.contains('active-select')) {\n          return _this.deselectReference(targetImage, targetRef);\n        }\n\n        return _this.selectReference(targetImage, targetRef);\n      });\n    });\n  }\n\n  _createClass(Museboard, [{\n    key: 'hoverImageOn',\n    value: function hoverImageOn(img) {\n      img.classList.add('active-hover');\n    }\n  }, {\n    key: 'hoverImageOff',\n    value: function hoverImageOff(img) {\n      img.classList.remove('active-hover');\n    }\n  }, {\n    key: 'selectReference',\n    value: function selectReference(img, ref) {\n      ref.classList.add('active-select');\n      img.classList.add('active-select');\n    }\n  }, {\n    key: 'deselectReference',\n    value: function deselectReference(img, ref) {\n      ref.classList.remove('active-select');\n      img.classList.remove('active-select');\n    }\n  }]);\n\n  return Museboard;\n}();\n\nfunction findTargetImage(target) {\n  var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  var imgBaseClass = 'ref-img';\n  var targetIndex = target.dataset.refIndex;\n\n  return document.getElementsByClassName(imgBaseClass + '-' + targetIndex)[index] || null;\n}\n\nfunction removeClassName(el, className) {\n  if (el.classList.contains(className)) {\n    return el.classList.remove(className);\n  }\n  return el;\n}\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Museboard);\n\n/***/ }),\n/* 19 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Disciplines = function Disciplines(elems) {\n  _classCallCheck(this, Disciplines);\n\n  this.elems = elems;\n\n  this.elems.disciplines = {\n    $disciplines: [].slice.call(document.getElementsByClassName('disciplines-category'))\n  };\n\n  this.elems.disciplines.$disciplines.map(function ($discipline, i) {\n    $discipline.addEventListener('click', function (e) {\n      $('.disciplines-category').removeClass('darkgray');\n      e.target.classList.add('darkgray');\n      window.history.pushState(null, null, e.target.getAttribute('href'));\n    });\n  });\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Disciplines);\n\n/***/ }),\n/* 20 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Musts = function Musts(elems) {\n  _classCallCheck(this, Musts);\n\n  this.elems = elems;\n\n  this.elems.musts = {\n    $musts: [].slice.call(document.getElementsByClassName('musts-category'))\n  };\n\n  this.elems.musts.$musts.map(function ($discipline, i) {\n    $discipline.addEventListener('click', function (e) {\n      $('.musts-category').removeClass('darkgray');\n      e.target.classList.add('darkgray');\n      window.history.pushState(null, null, e.target.getAttribute('href'));\n    });\n  });\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Musts);\n\n/***/ }),\n/* 21 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_global_subnav__ = __webpack_require__(1);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_constants_settings__ = __webpack_require__(0);\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\n\nvar Creators = function Creators(elems) {\n  var _this = this;\n\n  _classCallCheck(this, Creators);\n\n  this.elems = elems;\n\n  this.elems.creators = {\n    $nav: document.getElementById('creators-navigation'),\n    $letters: [].slice.call(document.getElementsByClassName('creators-mobile-subnav-option')),\n    $name: document.getElementById('creator-name'),\n    $results: document.getElementById('creator-results'),\n    $creators: [].slice.call(document.getElementsByClassName('creators-list-entry'))\n  };\n\n  this.elems.creators.$letters.map(function ($letter, i) {\n    $letter.addEventListener('click', function (e) {\n      $('html, body').animate({\n        scrollTop: _this.elems.creators.$nav.offsetTop - 100\n      }, __WEBPACK_IMPORTED_MODULE_1_constants_settings__[\"a\" /* GLOBALS */].transition * 2);\n    });\n  });\n\n  this.elems.creators.$creators.map(function ($creator, i) {\n    $creator.addEventListener('click', function (e) {\n      $('.creators-list-entry').removeClass('active');\n      $creator.classList.add('active');\n      _this.elems.creators.$name.innerHTML = e.target.innerHTML;\n      window.history.pushState(null, null, e.target.getAttribute('href'));\n    });\n  });\n\n  this.Subnav = new __WEBPACK_IMPORTED_MODULE_0_global_subnav__[\"a\" /* default */]('creators', this.elems);\n  this.MobileSubnav = new __WEBPACK_IMPORTED_MODULE_0_global_subnav__[\"a\" /* default */]('creators-mobile', this.elems);\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Creators);\n\n/***/ }),\n/* 22 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_global_subnav__ = __webpack_require__(1);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_constants_settings__ = __webpack_require__(0);\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\n\nvar Terms = function Terms(elems) {\n  var _this = this;\n\n  _classCallCheck(this, Terms);\n\n  this.elems = elems;\n\n  this.elems.terms = {\n    $nav: document.getElementById('terms-navigation'),\n    $name: document.getElementById('term-name'),\n    $results: document.getElementById('term-results-name'),\n    $def: document.getElementById('term-definition'),\n    $letters: [].slice.call(document.getElementsByClassName('terms-mobile-subnav-option')),\n    $terms: [].slice.call(document.getElementsByClassName('terms-list-entry'))\n  };\n\n  this.elems.terms.$letters.map(function ($letter, i) {\n    $letter.addEventListener('click', function (e) {\n      $('html, body').animate({\n        scrollTop: _this.elems.terms.$nav.offsetTop - 100\n      }, __WEBPACK_IMPORTED_MODULE_1_constants_settings__[\"a\" /* GLOBALS */].transition * 2);\n    });\n  });\n\n  this.elems.terms.$terms.map(function ($term, i) {\n    $term.addEventListener('click', function (e) {\n      $('.terms-list-entry').removeClass('active');\n      $term.classList.add('active');\n      _this.elems.terms.$name.innerHTML = e.target.innerHTML;\n      _this.elems.terms.$results.innerHTML = e.target.innerHTML;\n      _this.elems.terms.$def.innerHTML = e.target.dataset.definition;\n      window.history.pushState(null, null, e.target.getAttribute('href'));\n    });\n  });\n\n  this.Subnav = new __WEBPACK_IMPORTED_MODULE_0_global_subnav__[\"a\" /* default */]('terms', this.elems);\n  this.MobileSubnav = new __WEBPACK_IMPORTED_MODULE_0_global_subnav__[\"a\" /* default */]('terms-mobile', this.elems);\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Terms);\n\n/***/ }),\n/* 23 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_global_subnav__ = __webpack_require__(1);\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\n\nvar About = function About(elems) {\n  _classCallCheck(this, About);\n\n  this.elems = elems;\n\n  this.Subnav = new __WEBPACK_IMPORTED_MODULE_0_global_subnav__[\"a\" /* default */]('about', this.elems);\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (About);\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// app-0570f0c22e2788730def.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 5);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap e9656664e1aa4c5c2276","export const GLOBALS = {\n  breakpoints: {\n    small: 746,\n    tablet: 1024,\n    desktop: 1440\n  },\n  transition: 400,\n};\n\n//Lightbox Slider Settings\nexport const LIGHTBOX_SLIDER = {\n  infinite: true,\n  slidesToShow: 1,\n  slidesToScroll: 1,\n  adaptiveHeight: false,\n  prevArrow: $('.lightbox-prev-arrow'),\n  nextArrow: $('.lightbox-next-arrow'),\n};\n\n//Musts Slider Homepage Settings\nexport const MUSTS_SLIDER_HOMEPAGE = {\n  infinite: true,\n  speed: 600,\n  slidesToShow: 3,\n  slidesToScroll: 1,\n  prevArrow: $('.musts-prev-arrow'),\n  nextArrow: $('.musts-next-arrow'),\n  responsive: [\n    {\n      breakpoint: 832,\n      settings: {\n        slidesToShow: 1,\n        slidesToScroll: 1,\n      }\n    }\n  ]\n};\n\nexport const MERCH_SLIDER_HOMEPAGE = {\n  infinite: true,\n  speed: 600,\n  slidesToShow: 3,\n  slidesToScroll: 1,\n  prevArrow: $('.merch-prev-arrow'),\n  nextArrow: $('.merch-next-arrow'),\n  responsive: [\n    {\n      breakpoint: 832,\n      settings: {\n        slidesToShow: 1,\n        slidesToScroll: 1,\n      }\n    }\n  ]\n};\n\n// export const CONTRIBUTIONS_SLIDER = {\n//   infinite: true,\n//   dots: true,\n//   arrows: false,\n// };\n\nexport const RECIRCULATION_SLIDER = {\n  slidesToShow: 4,\n  dots: false,\n  arrows: false,\n  responsive: [\n    {\n      breakpoint: GLOBALS.breakpoints.small,\n      settings: {\n        slidesToShow: 1,\n        dots: true,\n        infinite: true,\n      }\n    },\n  ]\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/constants/settings.js","import { GLOBALS } from 'constants/settings';\n\nclass Subnav {\n  constructor(name, elems) {\n\n    this.elems  = elems;\n    this.name   = name;\n\n\n    this.options = [].slice.call(document.getElementsByClassName(`${this.name}-subnav-option`));\n\n    this.options.map((option, i) => {\n      option.addEventListener('click', (e) => {\n        this.showSection(e.target);\n      });\n    });\n\n    if (!$(`.${this.name}-subnav-option.active`).length) $(`.${this.name}-subnav-option`).first().trigger('click');\n\n    this.deepLink();\n  }\n\n  deepLink() {\n    let hash = (window.location.hash) ? window.location.hash.replace('#', '') : null;\n    if (hash) $(`.${this.name}-subnav-option[data-option=\"${hash}\"`).trigger('click');\n  }\n\n  showSection(target) {\n    let active  = target.dataset.option;\n    \n    $(`.${this.name}-subnav-option`).removeClass('active');\n    $(target).addClass('active');\n\n    if ($(`.${this.name}-section:visible`).length) {\n      $(`.${this.name}-section:visible`).fadeOut(GLOBALS.transition, 'swing', () => {\n        $(`.${this.name}-${active}`).fadeIn(GLOBALS.transition);\n      }); \n    } else $(`.${this.name}-${active}`).fadeIn(GLOBALS.transition);\n  }\n}\n\nexport default Subnav;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/subnav.js","import { slugify } from '../utils/helpers';\n\nclass Flag {\n  constructor(name, elems) {\n    this.name = name;\n    this.slug = slugify(name);\n\n    this.activator    = this.slug + '-activate';\n    this.activeClass  = this.slug + '-flag-active';\n    this.closer       = this.slug + '-close';\n\n    this.elems = elems;\n    this.elems[this.slug] = document.getElementById(this.slug + '-flag');\n\n    this.activators = [].slice.call(document.getElementsByClassName(this.activator));\n\n    this.activators.map((activator, i) => {\n      activator.addEventListener('click', (e) => {\n        if (!activator.classList.contains('js-user-required') ||\n            (activator.classList.contains('js-user-required') && MM.User.isLoggedIn())) {\n          this.toggleFlag();\n        } else {\n          MM.Login.openFlag();\n        }\n      });\n    });\n\n    this.closers    = [].slice.call(document.getElementsByClassName(this.closer));\n\n    this.closers.map((close, i) => {\n      close.addEventListener('click', (e) => {\n        this.closeFlag();\n      });\n    });\n  }\n\n  closeFlag() {\n    this.elems.$site.classList.remove(this.activeClass);\n    this.elems[this.slug].classList.remove('active');\n  }\n\n  openFlag() {\n    this.elems.$site.classList.add(this.activeClass);\n    this.elems[this.slug].classList.add('active');\n  }\n\n  toggleFlag() {\n    if (this.elems.$site.classList.contains(this.activeClass)) {\n      this.closeFlag();\n    } else {\n      this.openFlag();\n    }\n  }\n}\n\nexport default Flag;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/flag.js","export const LOADER = {\n  loadMore: 'Load More',\n  loading: 'Loading...',\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/constants/copy.js","export default function initSlider(targetEl, settings) {\n  let $this = $(targetEl);\n  $this.not('.slick-initialized').slick(settings)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/utils/slider.js","/* eslint no-console:0 */\n// This file is automatically compiled by Webpack, along with any other files\n// present in this directory. You're encouraged to place your actual application logic in\n// a relevant structure within app/javascript and only use these pack files to reference\n// that code so it'll be compiled.\n//\n// To reference this file, add <%= javascript_pack_tag 'application' %> to the appropriate\n// layout file, like app/views/layouts/application.html.erb\n\n// import User from 'global/user';\nimport Nav from 'global/nav';\nimport Flag from 'global/flag';\nimport Popup from 'global/popup';\nimport Pagination from 'global/pagination';\nimport Fader from 'global/fader';\nimport Recirculation from 'global/recirculation';\n// import Account from 'account';\nimport Homepage from 'homepage';\nimport Articles from 'articles';\nimport Museboard from 'articles/museboard';\nimport Disciplines from 'disciplines';\nimport Musts from 'musts';\nimport Creators from 'creators';\nimport Terms from 'terms';\nimport About from 'about';\n\nclass App {\n  constructor() {\n\n    this.elems = {};\n    this.elems.$site = document.getElementById('site');\n    this.elems.$home = document.getElementById('home');\n    this.elems.$article = document.getElementById('article-show');\n\n    /**\n      * Sitewide\n      */\n    // this.User          = new User(this.elems);\n    this.Nav           = new Nav(this.elems);\n    // this.Login         = new Flag('Login', this.elems);\n    // this.Flash         = (document.getElementById('flash')) ? new Flag('Flash', this.elems) : null;\n    // this.Reset         = new Flag('Reset Password', this.elems);\n    // this.Signup        = new Flag('Signup', this.elems);\n    this.Search        = new Flag('Search', this.elems);\n    this.Popup         = new Popup(this.elems); \n    this.Pagination    = new Pagination(this.elems);\n    this.Fader         = new Fader();\n    this.Recirculation = (document.getElementsByClassName('recirculation-slider')) ? new Recirculation() : null;\n\n    /**\n      * Routes\n      */\n    // this.Account      = (document.getElementById('account')) ? new Account(this.elems) : null;\n    this.Homepage     = (document.getElementById('home')) ? new Homepage(this.elems.$home) : null;\n    this.Articles     = (document.getElementById('articles') || document.getElementById('article-show') || document.getElementById('styleguide') || document.getElementById('must-show')) ? new Articles(this.elems) : null;\n    this.Disciplines  = (document.getElementById('disciplines')) ? new Disciplines(this.elems) : null;\n    this.Musts        = (document.getElementById('musts')) ? new Musts(this.elems) : null;\n    this.Terms        = (document.getElementById('terms')) ? new Terms(this.elems) : null;\n    this.Creators     = (document.getElementById('creators')) ? new Creators(this.elems) : null;\n    this.About        = (document.getElementById('about')) ? new About(this.elems) : null;\n    this.Museboard    = (document.getElementById('article-show') && document.getElementById('article-show').dataset.type == 'muse_boards') ? new Museboard() : null;\n  }\n}\n\nconst MM  = new App();\nwindow.MM = MM;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/packs/app.js","import { GLOBALS } from '../constants/settings';\nimport Flag from 'global/flag';\n\nclass Nav {\n  constructor(elems) {\n    this.elems = elems;\n\n    this.elems.nav = {\n      $top      : document.getElementById('back-to-top'),\n      $logout   : document.getElementsByClassName('logout-activate'),\n      $header   : document.getElementById('header'),\n      $overlay  : document.getElementById('navigation-overlay'),\n      $sidenav  : document.getElementById('sidenav'),\n    };\n\n    this.elems.nav.$top.addEventListener('click', (e) => {\n      this.top(e);\n    });\n\n\n    // refreshes menu state on scroll and resize\n    this.menu = {};\n    ['scroll', 'resize'].forEach((e) => {\n      window.addEventListener(e, (f) => {\n        this.menu = this.checkMenu();\n        this.checkSidenav();\n      });\n    });\n    this.menuInterval = setInterval(() => {\n      this.checkMenu();\n    }, GLOBALS.transition);\n\n    this.activators = [].slice.call(document.getElementsByClassName('mobile-menu-activate'));\n\n    this.activators.map((activator, i) => {\n      activator.addEventListener('click', (e) => {\n        clearInterval(this.menuInterval);\n        this.openMenu(true);\n      });\n    });\n\n    this.closers = [].slice.call(document.getElementsByClassName('mobile-menu-close'));\n\n    this.closers.map((close, i) => {\n      close.addEventListener('click', (e) => {\n        this.closeMenu();\n        this.menuInterval = setInterval(() => {\n          this.checkMenu();\n        }, GLOBALS.transition);\n      });\n    });\n  }\n\n  checkMenu(override = false, update = true) {\n    let lastPos     = (typeof this.menu.lastPos !== 'undefined' && this.menu.lastPos) ? this.menu.lastPos : window.pageYOffset;\n    let currentPos  = window.pageYOffset;\n    let direction   = (currentPos > lastPos) ? 'down' : 'up';\n    let menuOpen    = (direction == 'up' || override) ? true : false;\n\n    if (update) this.updateMenu();\n\n    return {\n      isMenuOpen: menuOpen,\n      scrollDirection: direction,\n      lastPos: currentPos\n    }\n  }\n\n  updateMenu() {\n    if (this.menu.lastPos < 20 || !this.menu.lastPos) {\n      this.openMenu();\n      this.elems.nav.$header.classList.add('at-top');\n    } else {\n      this.elems.nav.$header.classList.remove('at-top');\n      if (this.menu.isMenuOpen) {\n        this.openMenu();\n      } else {\n        this.closeMenu();\n      }\n    }\n  }\n\n  openMenu(mobile = false) {\n    if (mobile) {\n      this.elems.nav.$header.classList.add('mobile-menu-open');\n      $(this.elems.nav.$overlay).stop(true).fadeIn(GLOBALS.transition);\n    } else {\n      this.elems.nav.$header.classList.remove('mobile-menu-open');\n      $(this.elems.nav.$overlay).hide();\n    }\n    this.elems.nav.$header.classList.add('menu-open');\n  }\n\n  closeMenu() {\n    $(this.elems.nav.$overlay).stop(true).fadeOut(GLOBALS.transition);\n    this.elems.nav.$header.classList.remove('menu-open');\n    this.elems.nav.$header.classList.remove('mobile-menu-open');\n  }\n\n  checkSidenav() {\n    let scrollTop = (window.pageYOffset !== undefined) ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n    let docHeight = document.body.scrollHeight;\n    let footerAd  = (document.getElementById('footer-ad')) ? document.getElementById('footer-ad').clientHeight : 0;\n    let footer    = document.getElementById('footer').clientHeight;\n    let winHeight = window.innerHeight;\n\n    let footerTop = docHeight - footer - footerAd;\n    scrollTop >= footerTop - (winHeight / 2) - 400 ? this.elems.$site.classList.add('sidenav-inactive') : this.elems.$site.classList.remove('sidenav-inactive');\n\n    // back to top\n    if (scrollTop >= footerTop - winHeight) {\n      this.elems.nav.$top.style.transform    = `translate3d(0,-${scrollTop - (footerTop - winHeight)}px, 0)`;\n    } else {\n      this.elems.nav.$top.style.transform    = 'translate3d(0,0,0)';\n    }\n  }\n\n  top(e) {\n    $('html, body').animate({\n      scrollTop: 0\n    }, GLOBALS.transition * 2);\n  }\n}\n\nexport default Nav;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/nav.js","export function slugify(text) {\n  return text\n    .toLowerCase()\n    .replace(/[^\\w ]+/g,'')\n    .replace(/ +/g,'-')\n    ;\n}\n\nexport function validate(input, type) {\n  let patterns = {\n    'string': /^[a-zA-Z0-9-_ \\\\,\\\\'\\\\\"\\\\:\\\\.\\\\!\\\\?\\\\$\\\\%\\\\(\\\\)\\\\@]+$/,\n    'email': /^[A-Z0-9._%+-]+@([A-Z0-9-]+\\.)+[A-Z]{2,12}$/i,\n    'integer': /^[0-9]+$/,\n  };\n\n  return patterns[type].test(input);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/utils/helpers.js","import Flag from 'global/flag';\n\nclass Popup extends Flag {\n  constructor(elems) {\n    super('Newsletter Popup', elems);\n\n    this.elems = elems;\n\n    this.elems.popup = {\n      $newsletter : document.getElementById('newsletter-popup-flag'),\n    };\n\n    this.delay  = 3000; // displays popup 3 seconds after landing\n    this.check  = false;\n    \n    if (!localStorage.getItem('mmNewsletterPopupSeen') &&\n        this.elems.popup.$newsletter) {\n\n      this.check = true;\n      setTimeout((e) => {\n        super.openFlag();\n      }, this.delay);\n\n      ['scroll', 'resize'].forEach((e) => {\n        window.addEventListener(e, (f) => {\n          if (!this.check) return;\n          this.scrollCheck();\n        });\n      });\n    }\n  }\n\n  closeFlag() {\n    super.closeFlag();\n\n    localStorage.setItem('mmNewsletterPopupSeen', true);\n    this.check = false;\n  }\n\n  scrollCheck() {\n    let scrollTop = (window.pageYOffset !== undefined) ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n    let docHeight = document.body.scrollHeight;\n    let footer    = document.getElementById('footer').clientHeight;\n    let winHeight = window.innerHeight;\n\n    let footerTop = docHeight - footer - winHeight;\n\n    scrollTop >= footerTop ? this.elems.popup.$newsletter.classList.add('inactive') : this.elems.popup.$newsletter.classList.remove('inactive');\n  }\n}\n\nexport default Popup;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/popup.js","import { GLOBALS } from 'constants/settings';\nimport { LOADER } from 'constants/copy';\n\nclass Pagination {\n  constructor(elems) {\n    this.elems = elems;\n\n    $(document).on('click', '.js-pagination-get', (e) => {\n      e.preventDefault();\n      this.lastTarget = e.target;\n      this.paginate(e.target.dataset, this.lastTarget.classList.contains('btn'));\n    });\n\n    this.loadGrid();\n  }\n\n  paginate(data, btn) {\n    if (!data || !data.page) {\n      console.warn('Pagination::paginate Error: Requires data.')\n      return;\n    }\n\n    let query = {\n      page     : (data.page !== undefined) ? data.page : null,\n      type     : (data.type !== undefined) ? data.type : null,\n      exclude  : (data.exclude !== undefined) ? data.exclude : null,\n      tags     : (data.tags !== undefined) ? data.tags : null,\n      terms    : (data.terms !== undefined) ? data.terms : null,\n      creators : (data.creators !== undefined) ? data.creators : null,\n      must_type: (data.mtype !== undefined) ? data.mtype : null,\n      location : (data.mlocation !== undefined) ? data.mlocation : null,\n    };\n\n    let target = this.lastTarget;\n    if (btn) {\n      $(this.lastTarget).prop('disabled', true).text(LOADER.loading);\n    } else {\n      if (query.type === 'Musts' && query.location === '' && query.must_type === '') {\n        window.location.href = \"/musts\";\n        return;\n      }\n    }\n\n    $.ajax({\n      url: '/articles/paginate',\n      dataType: 'script',\n      data: query,\n    })\n    .done(function() {\n      if (parseInt(query.page)) window.history.pushState(null, null, '?page=' + (parseInt(query.page) + 1))\n      if (btn) $(target).prop('disabled', false).text(LOADER.loadMore);\n    });\n  }\n\n  loadGrid() {\n    $('.article-grid-item.inactive').each((i) => {\n      let $that = $('.article-grid-item.inactive').eq(i);\n      setTimeout((i) => {\n        $that.removeClass('inactive');\n      }, Math.max(GLOBALS.transition, (i + 2) / 2 * GLOBALS.transition));\n    });\n  }\n}\n\nexport default Pagination;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/pagination.js","import { GLOBALS } from 'constants/settings';\n\nclass Fader {\n  constructor(selector = '.js-fader.js-fader-inactive') {\n\n    this.selector = selector;\n    this.$targets = document.querySelectorAll(this.selector);\n\n    ['scroll', 'resize'].forEach((e) => {\n      window.addEventListener(e, (f) => {\n        this.fadeElements();\n      });\n    });\n\n    this.fadeElements();\n    setTimeout((e) => {\n      this.fadeElements();\n    }, GLOBALS.transition);\n  }\n\n  fadeElements() {\n    let scrollTop = (window.pageYOffset !== undefined) ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n    let winHeight = window.innerHeight;\n\n    let threshold = scrollTop + winHeight;\n    this.$targets.forEach(($target) => {\n      if ($($target).offset().top < threshold) {\n        let delay = ($target.dataset.jsFaderDelay) ? parseInt($target.dataset.jsFaderDelay) : 0;\n        setTimeout(() => {\n          $target.classList.remove('js-fader-inactive');\n        }, (delay / 2.5) * GLOBALS.transition);\n      }\n    });\n\n    this.$targets = document.querySelectorAll(this.selector);\n  }\n}\n\nexport default Fader;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/fader.js","import initSlider from 'utils/slider';\nimport { RECIRCULATION_SLIDER } from 'constants/settings';\n\nclass Recirculation {\n  constructor() {\n    this.gallery = [].slice.call(document.getElementsByClassName('recirculation-slider'));\n\n    //Initialize recirculaion slider\n    this.gallery.map((g, i) => initSlider(g, RECIRCULATION_SLIDER));\n  }\n}\n\nexport default Recirculation;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/global/recirculation.js","import interact from 'interact.js';\nimport initSlider from '../utils/slider';\nimport { MUSTS_SLIDER_HOMEPAGE, MERCH_SLIDER_HOMEPAGE } from '../constants/settings';\nimport { manageZIndex, dragHandler, resizeHandler } from '../utils/interact';\nimport Subnav from 'global/subnav';\n\nclass Homepage {\n  constructor(home) {\n    this.wrapper          = home;\n    this.mustsSlider      = this.setupMustsSlider();\n    this.merchSlider      = this.setupMerchSlider();\n    this.activeMuseboard  = this.setupMuseboardInteract();\n\n    this.museboardsSubnav = new Subnav('museboards', this.elems);\n  }\n\n  setupMustsSlider() {\n    let $slickEl = $(this.wrapper).find('.slick-musts');\n    initSlider($slickEl, MUSTS_SLIDER_HOMEPAGE)\n  }\n\n  setupMerchSlider() {\n    let $slickEl = $(this.wrapper).find('.slick-merch');\n    initSlider($slickEl, MERCH_SLIDER_HOMEPAGE)\n  }\n\n  setupMuseboardInteract() {\n    interact('.js-mb-light-interactable')\n    .draggable({\n      onstart: manageZIndex,\n      onmove: dragHandler,\n      inertia: true,\n      restrict: {\n        restriction: 'parent',\n        elementRect: {\n          top: 0,\n          left: 0,\n          bottom: 1,\n          right: 1,\n        }\n      },\n    })\n    .resizable({\n      onmove: resizeHandler,\n      preserveAspectRatio: true,\n      inertia: true,\n      invert: 'none',\n      edges: { top: true, right: true, bottom: true, left: true },\n      restrict: {\n        resize: 'parent',\n      }\n    });\n\n    $('.js-mb-light-interactable').on('touchstart', (e) => {\n      if (e.originalEvent.changedTouches.length > 1) e.preventDefault();\n    });\n  }\n\n}\n\nexport default Homepage;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/homepage/index.js","/**\n * interact.js v1.2.8\n *\n * Copyright (c) 2012-2015 Taye Adeyemi <dev@taye.me>\n * Open source under the MIT License.\n * https://raw.github.com/taye/interact.js/master/LICENSE\n */\n(function (realWindow) {\n    'use strict';\n\n    // return early if there's no window to work with (eg. Node.js)\n    if (!realWindow) { return; }\n\n    var // get wrapped window if using Shadow DOM polyfill\n        window = (function () {\n            // create a TextNode\n            var el = realWindow.document.createTextNode('');\n\n            // check if it's wrapped by a polyfill\n            if (el.ownerDocument !== realWindow.document\n                && typeof realWindow.wrap === 'function'\n                && realWindow.wrap(el) === el) {\n                // return wrapped window\n                return realWindow.wrap(realWindow);\n            }\n\n            // no Shadow DOM polyfil or native implementation\n            return realWindow;\n        }()),\n\n        document           = window.document,\n        DocumentFragment   = window.DocumentFragment   || blank,\n        SVGElement         = window.SVGElement         || blank,\n        SVGSVGElement      = window.SVGSVGElement      || blank,\n        SVGElementInstance = window.SVGElementInstance || blank,\n        HTMLElement        = window.HTMLElement        || window.Element,\n\n        PointerEvent = (window.PointerEvent || window.MSPointerEvent),\n        pEventTypes,\n\n        hypot = Math.hypot || function (x, y) { return Math.sqrt(x * x + y * y); },\n\n        tmpXY = {},     // reduce object creation in getXY()\n\n        documents       = [],   // all documents being listened to\n\n        interactables   = [],   // all set interactables\n        interactions    = [],   // all interactions\n\n        dynamicDrop     = false,\n\n        // {\n        //      type: {\n        //          selectors: ['selector', ...],\n        //          contexts : [document, ...],\n        //          listeners: [[listener, useCapture], ...]\n        //      }\n        //  }\n        delegatedEvents = {},\n\n        defaultOptions = {\n            base: {\n                accept        : null,\n                actionChecker : null,\n                styleCursor   : true,\n                preventDefault: 'auto',\n                origin        : { x: 0, y: 0 },\n                deltaSource   : 'page',\n                allowFrom     : null,\n                ignoreFrom    : null,\n                _context      : document,\n                dropChecker   : null\n            },\n\n            drag: {\n                enabled: false,\n                manualStart: true,\n                max: Infinity,\n                maxPerElement: 1,\n\n                snap: null,\n                restrict: null,\n                inertia: null,\n                autoScroll: null,\n\n                axis: 'xy'\n            },\n\n            drop: {\n                enabled: false,\n                accept: null,\n                overlap: 'pointer'\n            },\n\n            resize: {\n                enabled: false,\n                manualStart: false,\n                max: Infinity,\n                maxPerElement: 1,\n\n                snap: null,\n                restrict: null,\n                inertia: null,\n                autoScroll: null,\n\n                square: false,\n                preserveAspectRatio: false,\n                axis: 'xy',\n\n                // use default margin\n                margin: NaN,\n\n                // object with props left, right, top, bottom which are\n                // true/false values to resize when the pointer is over that edge,\n                // CSS selectors to match the handles for each direction\n                // or the Elements for each handle\n                edges: null,\n\n                // a value of 'none' will limit the resize rect to a minimum of 0x0\n                // 'negate' will alow the rect to have negative width/height\n                // 'reposition' will keep the width/height positive by swapping\n                // the top and bottom edges and/or swapping the left and right edges\n                invert: 'none'\n            },\n\n            gesture: {\n                manualStart: false,\n                enabled: false,\n                max: Infinity,\n                maxPerElement: 1,\n\n                restrict: null\n            },\n\n            perAction: {\n                manualStart: false,\n                max: Infinity,\n                maxPerElement: 1,\n\n                snap: {\n                    enabled     : false,\n                    endOnly     : false,\n                    range       : Infinity,\n                    targets     : null,\n                    offsets     : null,\n\n                    relativePoints: null\n                },\n\n                restrict: {\n                    enabled: false,\n                    endOnly: false\n                },\n\n                autoScroll: {\n                    enabled     : false,\n                    container   : null,     // the item that is scrolled (Window or HTMLElement)\n                    margin      : 60,\n                    speed       : 300       // the scroll speed in pixels per second\n                },\n\n                inertia: {\n                    enabled          : false,\n                    resistance       : 10,    // the lambda in exponential decay\n                    minSpeed         : 100,   // target speed must be above this for inertia to start\n                    endSpeed         : 10,    // the speed at which inertia is slow enough to stop\n                    allowResume      : true,  // allow resuming an action in inertia phase\n                    zeroResumeDelta  : true,  // if an action is resumed after launch, set dx/dy to 0\n                    smoothEndDuration: 300    // animate to snap/restrict endOnly if there's no inertia\n                }\n            },\n\n            _holdDuration: 600\n        },\n\n        // Things related to autoScroll\n        autoScroll = {\n            interaction: null,\n            i: null,    // the handle returned by window.setInterval\n            x: 0, y: 0, // Direction each pulse is to scroll in\n\n            // scroll the window by the values in scroll.x/y\n            scroll: function () {\n                var options = autoScroll.interaction.target.options[autoScroll.interaction.prepared.name].autoScroll,\n                    container = options.container || getWindow(autoScroll.interaction.element),\n                    now = new Date().getTime(),\n                    // change in time in seconds\n                    dtx = (now - autoScroll.prevTimeX) / 1000,\n                    dty = (now - autoScroll.prevTimeY) / 1000,\n                    vx, vy, sx, sy;\n\n                // displacement\n                if (options.velocity) {\n                  vx = options.velocity.x;\n                  vy = options.velocity.y;\n                }\n                else {\n                  vx = vy = options.speed\n                }\n \n                sx = vx * dtx;\n                sy = vy * dty;\n\n                if (sx >= 1 || sy >= 1) {\n                    if (isWindow(container)) {\n                        container.scrollBy(autoScroll.x * sx, autoScroll.y * sy);\n                    }\n                    else if (container) {\n                        container.scrollLeft += autoScroll.x * sx;\n                        container.scrollTop  += autoScroll.y * sy;\n                    }\n\n                    if (sx >=1) autoScroll.prevTimeX = now;\n                    if (sy >= 1) autoScroll.prevTimeY = now;\n                }\n\n                if (autoScroll.isScrolling) {\n                    cancelFrame(autoScroll.i);\n                    autoScroll.i = reqFrame(autoScroll.scroll);\n                }\n            },\n\n            isScrolling: false,\n            prevTimeX: 0,\n            prevTimeY: 0,\n\n            start: function (interaction) {\n                autoScroll.isScrolling = true;\n                cancelFrame(autoScroll.i);\n\n                autoScroll.interaction = interaction;\n                autoScroll.prevTimeX = new Date().getTime();\n                autoScroll.prevTimeY = new Date().getTime();\n                autoScroll.i = reqFrame(autoScroll.scroll);\n            },\n\n            stop: function () {\n                autoScroll.isScrolling = false;\n                cancelFrame(autoScroll.i);\n            }\n        },\n\n        // Does the browser support touch input?\n        supportsTouch = (('ontouchstart' in window) || window.DocumentTouch && document instanceof window.DocumentTouch),\n\n        // Does the browser support PointerEvents\n        // Avoid PointerEvent bugs introduced in Chrome 55\n        supportsPointerEvent = PointerEvent && !/Chrome/.test(navigator.userAgent),\n\n        // Less Precision with touch input\n        margin = supportsTouch || supportsPointerEvent? 20: 10,\n\n        pointerMoveTolerance = 1,\n\n        // for ignoring browser's simulated mouse events\n        prevTouchTime = 0,\n\n        // Allow this many interactions to happen simultaneously\n        maxInteractions = Infinity,\n\n        // Check if is IE9 or older\n        actionCursors = (document.all && !window.atob) ? {\n            drag    : 'move',\n            resizex : 'e-resize',\n            resizey : 's-resize',\n            resizexy: 'se-resize',\n\n            resizetop        : 'n-resize',\n            resizeleft       : 'w-resize',\n            resizebottom     : 's-resize',\n            resizeright      : 'e-resize',\n            resizetopleft    : 'se-resize',\n            resizebottomright: 'se-resize',\n            resizetopright   : 'ne-resize',\n            resizebottomleft : 'ne-resize',\n\n            gesture : ''\n        } : {\n            drag    : 'move',\n            resizex : 'ew-resize',\n            resizey : 'ns-resize',\n            resizexy: 'nwse-resize',\n\n            resizetop        : 'ns-resize',\n            resizeleft       : 'ew-resize',\n            resizebottom     : 'ns-resize',\n            resizeright      : 'ew-resize',\n            resizetopleft    : 'nwse-resize',\n            resizebottomright: 'nwse-resize',\n            resizetopright   : 'nesw-resize',\n            resizebottomleft : 'nesw-resize',\n\n            gesture : ''\n        },\n\n        actionIsEnabled = {\n            drag   : true,\n            resize : true,\n            gesture: true\n        },\n\n        // because Webkit and Opera still use 'mousewheel' event type\n        wheelEvent = 'onmousewheel' in document? 'mousewheel': 'wheel',\n\n        eventTypes = [\n            'dragstart',\n            'dragmove',\n            'draginertiastart',\n            'dragend',\n            'dragenter',\n            'dragleave',\n            'dropactivate',\n            'dropdeactivate',\n            'dropmove',\n            'drop',\n            'resizestart',\n            'resizemove',\n            'resizeinertiastart',\n            'resizeend',\n            'gesturestart',\n            'gesturemove',\n            'gestureinertiastart',\n            'gestureend',\n\n            'down',\n            'move',\n            'up',\n            'cancel',\n            'tap',\n            'doubletap',\n            'hold'\n        ],\n\n        globalEvents = {},\n\n        // Opera Mobile must be handled differently\n        isOperaMobile = navigator.appName == 'Opera' &&\n            supportsTouch &&\n            navigator.userAgent.match('Presto'),\n\n        // scrolling doesn't change the result of getClientRects on iOS 7\n        isIOS7 = (/iP(hone|od|ad)/.test(navigator.platform)\n                         && /OS 7[^\\d]/.test(navigator.appVersion)),\n\n        // prefix matchesSelector\n        prefixedMatchesSelector = 'matches' in Element.prototype?\n                'matches': 'webkitMatchesSelector' in Element.prototype?\n                    'webkitMatchesSelector': 'mozMatchesSelector' in Element.prototype?\n                        'mozMatchesSelector': 'oMatchesSelector' in Element.prototype?\n                            'oMatchesSelector': 'msMatchesSelector',\n\n        // will be polyfill function if browser is IE8\n        ie8MatchesSelector,\n\n        // native requestAnimationFrame or polyfill\n        reqFrame = realWindow.requestAnimationFrame,\n        cancelFrame = realWindow.cancelAnimationFrame,\n\n        // Events wrapper\n        events = (function () {\n            var useAttachEvent = ('attachEvent' in window) && !('addEventListener' in window),\n                addEvent       = useAttachEvent?  'attachEvent': 'addEventListener',\n                removeEvent    = useAttachEvent?  'detachEvent': 'removeEventListener',\n                on             = useAttachEvent? 'on': '',\n\n                elements          = [],\n                targets           = [],\n                attachedListeners = [];\n\n            function add (element, type, listener, useCapture) {\n                var elementIndex = indexOf(elements, element),\n                    target = targets[elementIndex];\n\n                if (!target) {\n                    target = {\n                        events: {},\n                        typeCount: 0\n                    };\n\n                    elementIndex = elements.push(element) - 1;\n                    targets.push(target);\n\n                    attachedListeners.push((useAttachEvent ? {\n                            supplied: [],\n                            wrapped : [],\n                            useCount: []\n                        } : null));\n                }\n\n                if (!target.events[type]) {\n                    target.events[type] = [];\n                    target.typeCount++;\n                }\n\n                if (!contains(target.events[type], listener)) {\n                    var ret;\n\n                    if (useAttachEvent) {\n                        var listeners = attachedListeners[elementIndex],\n                            listenerIndex = indexOf(listeners.supplied, listener);\n\n                        var wrapped = listeners.wrapped[listenerIndex] || function (event) {\n                            if (!event.immediatePropagationStopped) {\n                                event.target = event.srcElement;\n                                event.currentTarget = element;\n\n                                event.preventDefault = event.preventDefault || preventDef;\n                                event.stopPropagation = event.stopPropagation || stopProp;\n                                event.stopImmediatePropagation = event.stopImmediatePropagation || stopImmProp;\n\n                                if (/mouse|click/.test(event.type)) {\n                                    event.pageX = event.clientX + getWindow(element).document.documentElement.scrollLeft;\n                                    event.pageY = event.clientY + getWindow(element).document.documentElement.scrollTop;\n                                }\n\n                                listener(event);\n                            }\n                        };\n\n                        ret = element[addEvent](on + type, wrapped, Boolean(useCapture));\n\n                        if (listenerIndex === -1) {\n                            listeners.supplied.push(listener);\n                            listeners.wrapped.push(wrapped);\n                            listeners.useCount.push(1);\n                        }\n                        else {\n                            listeners.useCount[listenerIndex]++;\n                        }\n                    }\n                    else {\n                        ret = element[addEvent](type, listener, useCapture || false);\n                    }\n                    target.events[type].push(listener);\n\n                    return ret;\n                }\n            }\n\n            function remove (element, type, listener, useCapture) {\n                var i,\n                    elementIndex = indexOf(elements, element),\n                    target = targets[elementIndex],\n                    listeners,\n                    listenerIndex,\n                    wrapped = listener;\n\n                if (!target || !target.events) {\n                    return;\n                }\n\n                if (useAttachEvent) {\n                    listeners = attachedListeners[elementIndex];\n                    listenerIndex = indexOf(listeners.supplied, listener);\n                    wrapped = listeners.wrapped[listenerIndex];\n                }\n\n                if (type === 'all') {\n                    for (type in target.events) {\n                        if (target.events.hasOwnProperty(type)) {\n                            remove(element, type, 'all');\n                        }\n                    }\n                    return;\n                }\n\n                if (target.events[type]) {\n                    var len = target.events[type].length;\n\n                    if (listener === 'all') {\n                        for (i = 0; i < len; i++) {\n                            remove(element, type, target.events[type][i], Boolean(useCapture));\n                        }\n                        return;\n                    } else {\n                        for (i = 0; i < len; i++) {\n                            if (target.events[type][i] === listener) {\n                                element[removeEvent](on + type, wrapped, useCapture || false);\n                                target.events[type].splice(i, 1);\n\n                                if (useAttachEvent && listeners) {\n                                    listeners.useCount[listenerIndex]--;\n                                    if (listeners.useCount[listenerIndex] === 0) {\n                                        listeners.supplied.splice(listenerIndex, 1);\n                                        listeners.wrapped.splice(listenerIndex, 1);\n                                        listeners.useCount.splice(listenerIndex, 1);\n                                    }\n                                }\n\n                                break;\n                            }\n                        }\n                    }\n\n                    if (target.events[type] && target.events[type].length === 0) {\n                        target.events[type] = null;\n                        target.typeCount--;\n                    }\n                }\n\n                if (!target.typeCount) {\n                    targets.splice(elementIndex, 1);\n                    elements.splice(elementIndex, 1);\n                    attachedListeners.splice(elementIndex, 1);\n                }\n            }\n\n            function preventDef () {\n                this.returnValue = false;\n            }\n\n            function stopProp () {\n                this.cancelBubble = true;\n            }\n\n            function stopImmProp () {\n                this.cancelBubble = true;\n                this.immediatePropagationStopped = true;\n            }\n\n            return {\n                add: add,\n                remove: remove,\n                useAttachEvent: useAttachEvent,\n\n                _elements: elements,\n                _targets: targets,\n                _attachedListeners: attachedListeners\n            };\n        }());\n\n    function blank () {}\n\n    function isElement (o) {\n        if (!o || (typeof o !== 'object')) { return false; }\n\n        var _window = getWindow(o) || window;\n\n        return (/object|function/.test(typeof _window.Element)\n            ? o instanceof _window.Element //DOM2\n            : o.nodeType === 1 && typeof o.nodeName === \"string\");\n    }\n    function isWindow (thing) { return thing === window || !!(thing && thing.Window) && (thing instanceof thing.Window); }\n    function isDocFrag (thing) { return !!thing && thing instanceof DocumentFragment; }\n    function isArray (thing) {\n        return isObject(thing)\n                && (typeof thing.length !== undefined)\n                && isFunction(thing.splice);\n    }\n    function isObject   (thing) { return !!thing && (typeof thing === 'object'); }\n    function isFunction (thing) { return typeof thing === 'function'; }\n    function isNumber   (thing) { return typeof thing === 'number'  ; }\n    function isBool     (thing) { return typeof thing === 'boolean' ; }\n    function isString   (thing) { return typeof thing === 'string'  ; }\n\n    function trySelector (value) {\n        if (!isString(value)) { return false; }\n\n        // an exception will be raised if it is invalid\n        document.querySelector(value);\n        return true;\n    }\n\n    function extend (dest, source) {\n        for (var prop in source) {\n            dest[prop] = source[prop];\n        }\n        return dest;\n    }\n\n    var prefixedPropREs = {\n      webkit: /(Movement[XY]|Radius[XY]|RotationAngle|Force)$/\n    };\n\n    function pointerExtend (dest, source) {\n        for (var prop in source) {\n          var deprecated = false;\n\n          // skip deprecated prefixed properties\n          for (var vendor in prefixedPropREs) {\n            if (prop.indexOf(vendor) === 0 && prefixedPropREs[vendor].test(prop)) {\n              deprecated = true;\n              break;\n            }\n          }\n\n          if (!deprecated) {\n            dest[prop] = source[prop];\n          }\n        }\n        return dest;\n    }\n\n    function copyCoords (dest, src) {\n        dest.page = dest.page || {};\n        dest.page.x = src.page.x;\n        dest.page.y = src.page.y;\n\n        dest.client = dest.client || {};\n        dest.client.x = src.client.x;\n        dest.client.y = src.client.y;\n\n        dest.timeStamp = src.timeStamp;\n    }\n\n    function setEventXY (targetObj, pointers, interaction) {\n        var pointer = (pointers.length > 1\n                       ? pointerAverage(pointers)\n                       : pointers[0]);\n\n        getPageXY(pointer, tmpXY, interaction);\n        targetObj.page.x = tmpXY.x;\n        targetObj.page.y = tmpXY.y;\n\n        getClientXY(pointer, tmpXY, interaction);\n        targetObj.client.x = tmpXY.x;\n        targetObj.client.y = tmpXY.y;\n\n        targetObj.timeStamp = new Date().getTime();\n    }\n\n    function setEventDeltas (targetObj, prev, cur) {\n        targetObj.page.x     = cur.page.x      - prev.page.x;\n        targetObj.page.y     = cur.page.y      - prev.page.y;\n        targetObj.client.x   = cur.client.x    - prev.client.x;\n        targetObj.client.y   = cur.client.y    - prev.client.y;\n        targetObj.timeStamp = new Date().getTime() - prev.timeStamp;\n\n        // set pointer velocity\n        var dt = Math.max(targetObj.timeStamp / 1000, 0.001);\n        targetObj.page.speed   = hypot(targetObj.page.x, targetObj.page.y) / dt;\n        targetObj.page.vx      = targetObj.page.x / dt;\n        targetObj.page.vy      = targetObj.page.y / dt;\n\n        targetObj.client.speed = hypot(targetObj.client.x, targetObj.page.y) / dt;\n        targetObj.client.vx    = targetObj.client.x / dt;\n        targetObj.client.vy    = targetObj.client.y / dt;\n    }\n\n    function isNativePointer (pointer) {\n        return (pointer instanceof window.Event\n            || (supportsTouch && window.Touch && pointer instanceof window.Touch));\n    }\n\n    // Get specified X/Y coords for mouse or event.touches[0]\n    function getXY (type, pointer, xy) {\n        xy = xy || {};\n        type = type || 'page';\n\n        xy.x = pointer[type + 'X'];\n        xy.y = pointer[type + 'Y'];\n\n        return xy;\n    }\n\n    function getPageXY (pointer, page) {\n        page = page || {};\n\n        // Opera Mobile handles the viewport and scrolling oddly\n        if (isOperaMobile && isNativePointer(pointer)) {\n            getXY('screen', pointer, page);\n\n            page.x += window.scrollX;\n            page.y += window.scrollY;\n        }\n        else {\n            getXY('page', pointer, page);\n        }\n\n        return page;\n    }\n\n    function getClientXY (pointer, client) {\n        client = client || {};\n\n        if (isOperaMobile && isNativePointer(pointer)) {\n            // Opera Mobile handles the viewport and scrolling oddly\n            getXY('screen', pointer, client);\n        }\n        else {\n          getXY('client', pointer, client);\n        }\n\n        return client;\n    }\n\n    function getScrollXY (win) {\n        win = win || window;\n        return {\n            x: win.scrollX || win.document.documentElement.scrollLeft,\n            y: win.scrollY || win.document.documentElement.scrollTop\n        };\n    }\n\n    function getPointerId (pointer) {\n        return isNumber(pointer.pointerId)? pointer.pointerId : pointer.identifier;\n    }\n\n    function getActualElement (element) {\n        return (element instanceof SVGElementInstance\n            ? element.correspondingUseElement\n            : element);\n    }\n\n    function getWindow (node) {\n        if (isWindow(node)) {\n            return node;\n        }\n\n        var rootNode = (node.ownerDocument || node);\n\n        return rootNode.defaultView || rootNode.parentWindow || window;\n    }\n\n    function getElementClientRect (element) {\n        var clientRect = (element instanceof SVGElement\n                            ? element.getBoundingClientRect()\n                            : element.getClientRects()[0]);\n\n        return clientRect && {\n            left  : clientRect.left,\n            right : clientRect.right,\n            top   : clientRect.top,\n            bottom: clientRect.bottom,\n            width : clientRect.width || clientRect.right - clientRect.left,\n            height: clientRect.height || clientRect.bottom - clientRect.top\n        };\n    }\n\n    function getElementRect (element) {\n        var clientRect = getElementClientRect(element);\n\n        if (!isIOS7 && clientRect) {\n            var scroll = getScrollXY(getWindow(element));\n\n            clientRect.left   += scroll.x;\n            clientRect.right  += scroll.x;\n            clientRect.top    += scroll.y;\n            clientRect.bottom += scroll.y;\n        }\n\n        return clientRect;\n    }\n\n    function getTouchPair (event) {\n        var touches = [];\n\n        // array of touches is supplied\n        if (isArray(event)) {\n            touches[0] = event[0];\n            touches[1] = event[1];\n        }\n        // an event\n        else {\n            if (event.type === 'touchend') {\n                if (event.touches.length === 1) {\n                    touches[0] = event.touches[0];\n                    touches[1] = event.changedTouches[0];\n                }\n                else if (event.touches.length === 0) {\n                    touches[0] = event.changedTouches[0];\n                    touches[1] = event.changedTouches[1];\n                }\n            }\n            else {\n                touches[0] = event.touches[0];\n                touches[1] = event.touches[1];\n            }\n        }\n\n        return touches;\n    }\n\n    function pointerAverage (pointers) {\n        var average = {\n            pageX  : 0,\n            pageY  : 0,\n            clientX: 0,\n            clientY: 0,\n            screenX: 0,\n            screenY: 0\n        };\n        var prop;\n\n        for (var i = 0; i < pointers.length; i++) {\n            for (prop in average) {\n                average[prop] += pointers[i][prop];\n            }\n        }\n        for (prop in average) {\n            average[prop] /= pointers.length;\n        }\n\n        return average;\n    }\n\n    function touchBBox (event) {\n        if (!event.length && !(event.touches && event.touches.length > 1)) {\n            return;\n        }\n\n        var touches = getTouchPair(event),\n            minX = Math.min(touches[0].pageX, touches[1].pageX),\n            minY = Math.min(touches[0].pageY, touches[1].pageY),\n            maxX = Math.max(touches[0].pageX, touches[1].pageX),\n            maxY = Math.max(touches[0].pageY, touches[1].pageY);\n\n        return {\n            x: minX,\n            y: minY,\n            left: minX,\n            top: minY,\n            width: maxX - minX,\n            height: maxY - minY\n        };\n    }\n\n    function touchDistance (event, deltaSource) {\n        deltaSource = deltaSource || defaultOptions.deltaSource;\n\n        var sourceX = deltaSource + 'X',\n            sourceY = deltaSource + 'Y',\n            touches = getTouchPair(event);\n\n\n        var dx = touches[0][sourceX] - touches[1][sourceX],\n            dy = touches[0][sourceY] - touches[1][sourceY];\n\n        return hypot(dx, dy);\n    }\n\n    function touchAngle (event, prevAngle, deltaSource) {\n        deltaSource = deltaSource || defaultOptions.deltaSource;\n\n        var sourceX = deltaSource + 'X',\n            sourceY = deltaSource + 'Y',\n            touches = getTouchPair(event),\n            dx = touches[0][sourceX] - touches[1][sourceX],\n            dy = touches[0][sourceY] - touches[1][sourceY],\n            angle = 180 * Math.atan(dy / dx) / Math.PI;\n\n        if (isNumber(prevAngle)) {\n            var dr = angle - prevAngle,\n                drClamped = dr % 360;\n\n            if (drClamped > 315) {\n                angle -= 360 + (angle / 360)|0 * 360;\n            }\n            else if (drClamped > 135) {\n                angle -= 180 + (angle / 360)|0 * 360;\n            }\n            else if (drClamped < -315) {\n                angle += 360 + (angle / 360)|0 * 360;\n            }\n            else if (drClamped < -135) {\n                angle += 180 + (angle / 360)|0 * 360;\n            }\n        }\n\n        return  angle;\n    }\n\n    function getOriginXY (interactable, element) {\n        var origin = interactable\n                ? interactable.options.origin\n                : defaultOptions.origin;\n\n        if (origin === 'parent') {\n            origin = parentElement(element);\n        }\n        else if (origin === 'self') {\n            origin = interactable.getRect(element);\n        }\n        else if (trySelector(origin)) {\n            origin = closest(element, origin) || { x: 0, y: 0 };\n        }\n\n        if (isFunction(origin)) {\n            origin = origin(interactable && element);\n        }\n\n        if (isElement(origin))  {\n            origin = getElementRect(origin);\n        }\n\n        origin.x = ('x' in origin)? origin.x : origin.left;\n        origin.y = ('y' in origin)? origin.y : origin.top;\n\n        return origin;\n    }\n\n    // http://stackoverflow.com/a/5634528/2280888\n    function _getQBezierValue(t, p1, p2, p3) {\n        var iT = 1 - t;\n        return iT * iT * p1 + 2 * iT * t * p2 + t * t * p3;\n    }\n\n    function getQuadraticCurvePoint(startX, startY, cpX, cpY, endX, endY, position) {\n        return {\n            x:  _getQBezierValue(position, startX, cpX, endX),\n            y:  _getQBezierValue(position, startY, cpY, endY)\n        };\n    }\n\n    // http://gizma.com/easing/\n    function easeOutQuad (t, b, c, d) {\n        t /= d;\n        return -c * t*(t-2) + b;\n    }\n\n    function nodeContains (parent, child) {\n        while (child) {\n            if (child === parent) {\n                return true;\n            }\n\n            child = child.parentNode;\n        }\n\n        return false;\n    }\n\n    function closest (child, selector) {\n        var parent = parentElement(child);\n\n        while (isElement(parent)) {\n            if (matchesSelector(parent, selector)) { return parent; }\n\n            parent = parentElement(parent);\n        }\n\n        return null;\n    }\n\n    function parentElement (node) {\n        var parent = node.parentNode;\n\n        if (isDocFrag(parent)) {\n            // skip past #shado-root fragments\n            while ((parent = parent.host) && isDocFrag(parent)) {}\n\n            return parent;\n        }\n\n        return parent;\n    }\n\n    function inContext (interactable, element) {\n        return interactable._context === element.ownerDocument\n                || nodeContains(interactable._context, element);\n    }\n\n    function testIgnore (interactable, interactableElement, element) {\n        var ignoreFrom = interactable.options.ignoreFrom;\n\n        if (!ignoreFrom || !isElement(element)) { return false; }\n\n        if (isString(ignoreFrom)) {\n            return matchesUpTo(element, ignoreFrom, interactableElement);\n        }\n        else if (isElement(ignoreFrom)) {\n            return nodeContains(ignoreFrom, element);\n        }\n\n        return false;\n    }\n\n    function testAllow (interactable, interactableElement, element) {\n        var allowFrom = interactable.options.allowFrom;\n\n        if (!allowFrom) { return true; }\n\n        if (!isElement(element)) { return false; }\n\n        if (isString(allowFrom)) {\n            return matchesUpTo(element, allowFrom, interactableElement);\n        }\n        else if (isElement(allowFrom)) {\n            return nodeContains(allowFrom, element);\n        }\n\n        return false;\n    }\n\n    function checkAxis (axis, interactable) {\n        if (!interactable) { return false; }\n\n        var thisAxis = interactable.options.drag.axis;\n\n        return (axis === 'xy' || thisAxis === 'xy' || thisAxis === axis);\n    }\n\n    function checkSnap (interactable, action) {\n        var options = interactable.options;\n\n        if (/^resize/.test(action)) {\n            action = 'resize';\n        }\n\n        return options[action].snap && options[action].snap.enabled;\n    }\n\n    function checkRestrict (interactable, action) {\n        var options = interactable.options;\n\n        if (/^resize/.test(action)) {\n            action = 'resize';\n        }\n\n        return  options[action].restrict && options[action].restrict.enabled;\n    }\n\n    function checkAutoScroll (interactable, action) {\n        var options = interactable.options;\n\n        if (/^resize/.test(action)) {\n            action = 'resize';\n        }\n\n        return  options[action].autoScroll && options[action].autoScroll.enabled;\n    }\n\n    function withinInteractionLimit (interactable, element, action) {\n        var options = interactable.options,\n            maxActions = options[action.name].max,\n            maxPerElement = options[action.name].maxPerElement,\n            activeInteractions = 0,\n            targetCount = 0,\n            targetElementCount = 0;\n\n        for (var i = 0, len = interactions.length; i < len; i++) {\n            var interaction = interactions[i],\n                otherAction = interaction.prepared.name,\n                active = interaction.interacting();\n\n            if (!active) { continue; }\n\n            activeInteractions++;\n\n            if (activeInteractions >= maxInteractions) {\n                return false;\n            }\n\n            if (interaction.target !== interactable) { continue; }\n\n            targetCount += (otherAction === action.name)|0;\n\n            if (targetCount >= maxActions) {\n                return false;\n            }\n\n            if (interaction.element === element) {\n                targetElementCount++;\n\n                if (otherAction !== action.name || targetElementCount >= maxPerElement) {\n                    return false;\n                }\n            }\n        }\n\n        return maxInteractions > 0;\n    }\n\n    // Test for the element that's \"above\" all other qualifiers\n    function indexOfDeepestElement (elements) {\n        var dropzone,\n            deepestZone = elements[0],\n            index = deepestZone? 0: -1,\n            parent,\n            deepestZoneParents = [],\n            dropzoneParents = [],\n            child,\n            i,\n            n;\n\n        for (i = 1; i < elements.length; i++) {\n            dropzone = elements[i];\n\n            // an element might belong to multiple selector dropzones\n            if (!dropzone || dropzone === deepestZone) {\n                continue;\n            }\n\n            if (!deepestZone) {\n                deepestZone = dropzone;\n                index = i;\n                continue;\n            }\n\n            // check if the deepest or current are document.documentElement or document.rootElement\n            // - if the current dropzone is, do nothing and continue\n            if (dropzone.parentNode === dropzone.ownerDocument) {\n                continue;\n            }\n            // - if deepest is, update with the current dropzone and continue to next\n            else if (deepestZone.parentNode === dropzone.ownerDocument) {\n                deepestZone = dropzone;\n                index = i;\n                continue;\n            }\n\n            if (!deepestZoneParents.length) {\n                parent = deepestZone;\n                while (parent.parentNode && parent.parentNode !== parent.ownerDocument) {\n                    deepestZoneParents.unshift(parent);\n                    parent = parent.parentNode;\n                }\n            }\n\n            // if this element is an svg element and the current deepest is\n            // an HTMLElement\n            if (deepestZone instanceof HTMLElement\n                && dropzone instanceof SVGElement\n                && !(dropzone instanceof SVGSVGElement)) {\n\n                if (dropzone === deepestZone.parentNode) {\n                    continue;\n                }\n\n                parent = dropzone.ownerSVGElement;\n            }\n            else {\n                parent = dropzone;\n            }\n\n            dropzoneParents = [];\n\n            while (parent.parentNode !== parent.ownerDocument) {\n                dropzoneParents.unshift(parent);\n                parent = parent.parentNode;\n            }\n\n            n = 0;\n\n            // get (position of last common ancestor) + 1\n            while (dropzoneParents[n] && dropzoneParents[n] === deepestZoneParents[n]) {\n                n++;\n            }\n\n            var parents = [\n                dropzoneParents[n - 1],\n                dropzoneParents[n],\n                deepestZoneParents[n]\n            ];\n\n            child = parents[0].lastChild;\n\n            while (child) {\n                if (child === parents[1]) {\n                    deepestZone = dropzone;\n                    index = i;\n                    deepestZoneParents = [];\n\n                    break;\n                }\n                else if (child === parents[2]) {\n                    break;\n                }\n\n                child = child.previousSibling;\n            }\n        }\n\n        return index;\n    }\n\n    function Interaction () {\n        this.target          = null; // current interactable being interacted with\n        this.element         = null; // the target element of the interactable\n        this.dropTarget      = null; // the dropzone a drag target might be dropped into\n        this.dropElement     = null; // the element at the time of checking\n        this.prevDropTarget  = null; // the dropzone that was recently dragged away from\n        this.prevDropElement = null; // the element at the time of checking\n\n        this.prepared        = {     // action that's ready to be fired on next move event\n            name : null,\n            axis : null,\n            edges: null\n        };\n\n        this.matches         = [];   // all selectors that are matched by target element\n        this.matchElements   = [];   // corresponding elements\n\n        this.inertiaStatus = {\n            active       : false,\n            smoothEnd    : false,\n            ending       : false,\n\n            startEvent: null,\n            upCoords: {},\n\n            xe: 0, ye: 0,\n            sx: 0, sy: 0,\n\n            t0: 0,\n            vx0: 0, vys: 0,\n            duration: 0,\n\n            resumeDx: 0,\n            resumeDy: 0,\n\n            lambda_v0: 0,\n            one_ve_v0: 0,\n            i  : null\n        };\n\n        if (isFunction(Function.prototype.bind)) {\n            this.boundInertiaFrame = this.inertiaFrame.bind(this);\n            this.boundSmoothEndFrame = this.smoothEndFrame.bind(this);\n        }\n        else {\n            var that = this;\n\n            this.boundInertiaFrame = function () { return that.inertiaFrame(); };\n            this.boundSmoothEndFrame = function () { return that.smoothEndFrame(); };\n        }\n\n        this.activeDrops = {\n            dropzones: [],      // the dropzones that are mentioned below\n            elements : [],      // elements of dropzones that accept the target draggable\n            rects    : []       // the rects of the elements mentioned above\n        };\n\n        // keep track of added pointers\n        this.pointers    = [];\n        this.pointerIds  = [];\n        this.downTargets = [];\n        this.downTimes   = [];\n        this.holdTimers  = [];\n\n        // Previous native pointer move event coordinates\n        this.prevCoords = {\n            page     : { x: 0, y: 0 },\n            client   : { x: 0, y: 0 },\n            timeStamp: 0\n        };\n        // current native pointer move event coordinates\n        this.curCoords = {\n            page     : { x: 0, y: 0 },\n            client   : { x: 0, y: 0 },\n            timeStamp: 0\n        };\n\n        // Starting InteractEvent pointer coordinates\n        this.startCoords = {\n            page     : { x: 0, y: 0 },\n            client   : { x: 0, y: 0 },\n            timeStamp: 0\n        };\n\n        // Change in coordinates and time of the pointer\n        this.pointerDelta = {\n            page     : { x: 0, y: 0, vx: 0, vy: 0, speed: 0 },\n            client   : { x: 0, y: 0, vx: 0, vy: 0, speed: 0 },\n            timeStamp: 0\n        };\n\n        this.downEvent   = null;    // pointerdown/mousedown/touchstart event\n        this.downPointer = {};\n\n        this._eventTarget    = null;\n        this._curEventTarget = null;\n\n        this.prevEvent = null;      // previous action event\n        this.tapTime   = 0;         // time of the most recent tap event\n        this.prevTap   = null;\n\n        this.startOffset    = { left: 0, right: 0, top: 0, bottom: 0 };\n        this.restrictOffset = { left: 0, right: 0, top: 0, bottom: 0 };\n        this.snapOffsets    = [];\n\n        this.gesture = {\n            start: { x: 0, y: 0 },\n\n            startDistance: 0,   // distance between two touches of touchStart\n            prevDistance : 0,\n            distance     : 0,\n\n            scale: 1,           // gesture.distance / gesture.startDistance\n\n            startAngle: 0,      // angle of line joining two touches\n            prevAngle : 0       // angle of the previous gesture event\n        };\n\n        this.snapStatus = {\n            x       : 0, y       : 0,\n            dx      : 0, dy      : 0,\n            realX   : 0, realY   : 0,\n            snappedX: 0, snappedY: 0,\n            targets : [],\n            locked  : false,\n            changed : false\n        };\n\n        this.restrictStatus = {\n            dx         : 0, dy         : 0,\n            restrictedX: 0, restrictedY: 0,\n            snap       : null,\n            restricted : false,\n            changed    : false\n        };\n\n        this.restrictStatus.snap = this.snapStatus;\n\n        this.pointerIsDown   = false;\n        this.pointerWasMoved = false;\n        this.gesturing       = false;\n        this.dragging        = false;\n        this.resizing        = false;\n        this.resizeAxes      = 'xy';\n\n        this.mouse = false;\n\n        interactions.push(this);\n    }\n\n    Interaction.prototype = {\n        getPageXY  : function (pointer, xy) { return   getPageXY(pointer, xy, this); },\n        getClientXY: function (pointer, xy) { return getClientXY(pointer, xy, this); },\n        setEventXY : function (target, ptr) { return  setEventXY(target, ptr, this); },\n\n        pointerOver: function (pointer, event, eventTarget) {\n            if (this.prepared.name || !this.mouse) { return; }\n\n            var curMatches = [],\n                curMatchElements = [],\n                prevTargetElement = this.element;\n\n            this.addPointer(pointer);\n\n            if (this.target\n                && (testIgnore(this.target, this.element, eventTarget)\n                    || !testAllow(this.target, this.element, eventTarget))) {\n                // if the eventTarget should be ignored or shouldn't be allowed\n                // clear the previous target\n                this.target = null;\n                this.element = null;\n                this.matches = [];\n                this.matchElements = [];\n            }\n\n            var elementInteractable = interactables.get(eventTarget),\n                elementAction = (elementInteractable\n                                 && !testIgnore(elementInteractable, eventTarget, eventTarget)\n                                 && testAllow(elementInteractable, eventTarget, eventTarget)\n                                 && validateAction(\n                                     elementInteractable.getAction(pointer, event, this, eventTarget),\n                                     elementInteractable));\n\n            if (elementAction && !withinInteractionLimit(elementInteractable, eventTarget, elementAction)) {\n                 elementAction = null;\n            }\n\n            function pushCurMatches (interactable, selector) {\n                if (interactable\n                    && inContext(interactable, eventTarget)\n                    && !testIgnore(interactable, eventTarget, eventTarget)\n                    && testAllow(interactable, eventTarget, eventTarget)\n                    && matchesSelector(eventTarget, selector)) {\n\n                    curMatches.push(interactable);\n                    curMatchElements.push(eventTarget);\n                }\n            }\n\n            if (elementAction) {\n                this.target = elementInteractable;\n                this.element = eventTarget;\n                this.matches = [];\n                this.matchElements = [];\n            }\n            else {\n                interactables.forEachSelector(pushCurMatches);\n\n                if (this.validateSelector(pointer, event, curMatches, curMatchElements)) {\n                    this.matches = curMatches;\n                    this.matchElements = curMatchElements;\n\n                    this.pointerHover(pointer, event, this.matches, this.matchElements);\n                    events.add(eventTarget,\n                                        supportsPointerEvent? pEventTypes.move : 'mousemove',\n                                        listeners.pointerHover);\n                }\n                else if (this.target) {\n                    if (nodeContains(prevTargetElement, eventTarget)) {\n                        this.pointerHover(pointer, event, this.matches, this.matchElements);\n                        events.add(this.element,\n                                            supportsPointerEvent? pEventTypes.move : 'mousemove',\n                                            listeners.pointerHover);\n                    }\n                    else {\n                        this.target = null;\n                        this.element = null;\n                        this.matches = [];\n                        this.matchElements = [];\n                    }\n                }\n            }\n        },\n\n        // Check what action would be performed on pointerMove target if a mouse\n        // button were pressed and change the cursor accordingly\n        pointerHover: function (pointer, event, eventTarget, curEventTarget, matches, matchElements) {\n            var target = this.target;\n\n            if (!this.prepared.name && this.mouse) {\n\n                var action;\n\n                // update pointer coords for defaultActionChecker to use\n                this.setEventXY(this.curCoords, [pointer]);\n\n                if (matches) {\n                    action = this.validateSelector(pointer, event, matches, matchElements);\n                }\n                else if (target) {\n                    action = validateAction(target.getAction(this.pointers[0], event, this, this.element), this.target);\n                }\n\n                if (target && target.options.styleCursor) {\n                    if (action) {\n                        target._doc.documentElement.style.cursor = getActionCursor(action);\n                    }\n                    else {\n                        target._doc.documentElement.style.cursor = '';\n                    }\n                }\n            }\n            else if (this.prepared.name) {\n                this.checkAndPreventDefault(event, target, this.element);\n            }\n        },\n\n        pointerOut: function (pointer, event, eventTarget) {\n            if (this.prepared.name) { return; }\n\n            // Remove temporary event listeners for selector Interactables\n            if (!interactables.get(eventTarget)) {\n                events.remove(eventTarget,\n                                       supportsPointerEvent? pEventTypes.move : 'mousemove',\n                                       listeners.pointerHover);\n            }\n\n            if (this.target && this.target.options.styleCursor && !this.interacting()) {\n                this.target._doc.documentElement.style.cursor = '';\n            }\n        },\n\n        selectorDown: function (pointer, event, eventTarget, curEventTarget) {\n            var that = this,\n                // copy event to be used in timeout for IE8\n                eventCopy = events.useAttachEvent? extend({}, event) : event,\n                element = eventTarget,\n                pointerIndex = this.addPointer(pointer),\n                action;\n\n            this.holdTimers[pointerIndex] = setTimeout(function () {\n                that.pointerHold(events.useAttachEvent? eventCopy : pointer, eventCopy, eventTarget, curEventTarget);\n            }, defaultOptions._holdDuration);\n\n            this.pointerIsDown = true;\n\n            // Check if the down event hits the current inertia target\n            if (this.inertiaStatus.active && this.target.selector) {\n                // climb up the DOM tree from the event target\n                while (isElement(element)) {\n\n                    // if this element is the current inertia target element\n                    if (element === this.element\n                        // and the prospective action is the same as the ongoing one\n                        && validateAction(this.target.getAction(pointer, event, this, this.element), this.target).name === this.prepared.name) {\n\n                        // stop inertia so that the next move will be a normal one\n                        cancelFrame(this.inertiaStatus.i);\n                        this.inertiaStatus.active = false;\n\n                        this.collectEventTargets(pointer, event, eventTarget, 'down');\n                        return;\n                    }\n                    element = parentElement(element);\n                }\n            }\n\n            // do nothing if interacting\n            if (this.interacting()) {\n                this.collectEventTargets(pointer, event, eventTarget, 'down');\n                return;\n            }\n\n            function pushMatches (interactable, selector, context) {\n                var elements = ie8MatchesSelector\n                    ? context.querySelectorAll(selector)\n                    : undefined;\n\n                if (inContext(interactable, element)\n                    && !testIgnore(interactable, element, eventTarget)\n                    && testAllow(interactable, element, eventTarget)\n                    && matchesSelector(element, selector, elements)) {\n\n                    that.matches.push(interactable);\n                    that.matchElements.push(element);\n                }\n            }\n\n            // update pointer coords for defaultActionChecker to use\n            this.setEventXY(this.curCoords, [pointer]);\n            this.downEvent = event;\n\n            while (isElement(element) && !action) {\n                this.matches = [];\n                this.matchElements = [];\n\n                interactables.forEachSelector(pushMatches);\n\n                action = this.validateSelector(pointer, event, this.matches, this.matchElements);\n                element = parentElement(element);\n            }\n\n            if (action) {\n                this.prepared.name  = action.name;\n                this.prepared.axis  = action.axis;\n                this.prepared.edges = action.edges;\n\n                this.collectEventTargets(pointer, event, eventTarget, 'down');\n\n                return this.pointerDown(pointer, event, eventTarget, curEventTarget, action);\n            }\n            else {\n                // do these now since pointerDown isn't being called from here\n                this.downTimes[pointerIndex] = new Date().getTime();\n                this.downTargets[pointerIndex] = eventTarget;\n                pointerExtend(this.downPointer, pointer);\n\n                copyCoords(this.prevCoords, this.curCoords);\n                this.pointerWasMoved = false;\n            }\n\n            this.collectEventTargets(pointer, event, eventTarget, 'down');\n        },\n\n        // Determine action to be performed on next pointerMove and add appropriate\n        // style and event Listeners\n        pointerDown: function (pointer, event, eventTarget, curEventTarget, forceAction) {\n            if (!forceAction && !this.inertiaStatus.active && this.pointerWasMoved && this.prepared.name) {\n                this.checkAndPreventDefault(event, this.target, this.element);\n\n                return;\n            }\n\n            this.pointerIsDown = true;\n            this.downEvent = event;\n\n            var pointerIndex = this.addPointer(pointer),\n                action;\n\n            // If it is the second touch of a multi-touch gesture, keep the\n            // target the same and get a new action if a target was set by the\n            // first touch\n            if (this.pointerIds.length > 1 && this.target._element === this.element) {\n                var newAction = validateAction(forceAction || this.target.getAction(pointer, event, this, this.element), this.target);\n\n                if (withinInteractionLimit(this.target, this.element, newAction)) {\n                    action = newAction;\n                }\n\n                this.prepared.name = null;\n            }\n            // Otherwise, set the target if there is no action prepared\n            else if (!this.prepared.name) {\n                var interactable = interactables.get(curEventTarget);\n\n                if (interactable\n                    && !testIgnore(interactable, curEventTarget, eventTarget)\n                    && testAllow(interactable, curEventTarget, eventTarget)\n                    && (action = validateAction(forceAction || interactable.getAction(pointer, event, this, curEventTarget), interactable, eventTarget))\n                    && withinInteractionLimit(interactable, curEventTarget, action)) {\n                    this.target = interactable;\n                    this.element = curEventTarget;\n                }\n            }\n\n            var target = this.target,\n                options = target && target.options;\n\n            if (target && (forceAction || !this.prepared.name)) {\n                action = action || validateAction(forceAction || target.getAction(pointer, event, this, curEventTarget), target, this.element);\n\n                this.setEventXY(this.startCoords, this.pointers);\n\n                if (!action) { return; }\n\n                if (options.styleCursor) {\n                    target._doc.documentElement.style.cursor = getActionCursor(action);\n                }\n\n                this.resizeAxes = action.name === 'resize'? action.axis : null;\n\n                if (action === 'gesture' && this.pointerIds.length < 2) {\n                    action = null;\n                }\n\n                this.prepared.name  = action.name;\n                this.prepared.axis  = action.axis;\n                this.prepared.edges = action.edges;\n\n                this.snapStatus.snappedX = this.snapStatus.snappedY =\n                    this.restrictStatus.restrictedX = this.restrictStatus.restrictedY = NaN;\n\n                this.downTimes[pointerIndex] = new Date().getTime();\n                this.downTargets[pointerIndex] = eventTarget;\n                pointerExtend(this.downPointer, pointer);\n\n                copyCoords(this.prevCoords, this.startCoords);\n                this.pointerWasMoved = false;\n\n                this.checkAndPreventDefault(event, target, this.element);\n            }\n            // if inertia is active try to resume action\n            else if (this.inertiaStatus.active\n                && curEventTarget === this.element\n                && validateAction(target.getAction(pointer, event, this, this.element), target).name === this.prepared.name) {\n\n                cancelFrame(this.inertiaStatus.i);\n                this.inertiaStatus.active = false;\n\n                this.checkAndPreventDefault(event, target, this.element);\n            }\n        },\n\n        setModifications: function (coords, preEnd) {\n            var target         = this.target,\n                shouldMove     = true,\n                shouldSnap     = checkSnap(target, this.prepared.name)     && (!target.options[this.prepared.name].snap.endOnly     || preEnd),\n                shouldRestrict = checkRestrict(target, this.prepared.name) && (!target.options[this.prepared.name].restrict.endOnly || preEnd);\n\n            if (shouldSnap    ) { this.setSnapping   (coords); } else { this.snapStatus    .locked     = false; }\n            if (shouldRestrict) { this.setRestriction(coords); } else { this.restrictStatus.restricted = false; }\n\n            if (shouldSnap && this.snapStatus.locked && !this.snapStatus.changed) {\n                shouldMove = shouldRestrict && this.restrictStatus.restricted && this.restrictStatus.changed;\n            }\n            else if (shouldRestrict && this.restrictStatus.restricted && !this.restrictStatus.changed) {\n                shouldMove = false;\n            }\n\n            return shouldMove;\n        },\n\n        setStartOffsets: function (action, interactable, element) {\n            var rect = interactable.getRect(element),\n                origin = getOriginXY(interactable, element),\n                snap = interactable.options[this.prepared.name].snap,\n                restrict = interactable.options[this.prepared.name].restrict,\n                width, height;\n\n            if (rect) {\n                this.startOffset.left = this.startCoords.page.x - rect.left;\n                this.startOffset.top  = this.startCoords.page.y - rect.top;\n\n                this.startOffset.right  = rect.right  - this.startCoords.page.x;\n                this.startOffset.bottom = rect.bottom - this.startCoords.page.y;\n\n                if ('width' in rect) { width = rect.width; }\n                else { width = rect.right - rect.left; }\n                if ('height' in rect) { height = rect.height; }\n                else { height = rect.bottom - rect.top; }\n            }\n            else {\n                this.startOffset.left = this.startOffset.top = this.startOffset.right = this.startOffset.bottom = 0;\n            }\n\n            this.snapOffsets.splice(0);\n\n            var snapOffset = snap && snap.offset === 'startCoords'\n                                ? {\n                                    x: this.startCoords.page.x - origin.x,\n                                    y: this.startCoords.page.y - origin.y\n                                }\n                                : snap && snap.offset || { x: 0, y: 0 };\n\n            if (rect && snap && snap.relativePoints && snap.relativePoints.length) {\n                for (var i = 0; i < snap.relativePoints.length; i++) {\n                    this.snapOffsets.push({\n                        x: this.startOffset.left - (width  * snap.relativePoints[i].x) + snapOffset.x,\n                        y: this.startOffset.top  - (height * snap.relativePoints[i].y) + snapOffset.y\n                    });\n                }\n            }\n            else {\n                this.snapOffsets.push(snapOffset);\n            }\n\n            if (rect && restrict.elementRect) {\n                this.restrictOffset.left = this.startOffset.left - (width  * restrict.elementRect.left);\n                this.restrictOffset.top  = this.startOffset.top  - (height * restrict.elementRect.top);\n\n                this.restrictOffset.right  = this.startOffset.right  - (width  * (1 - restrict.elementRect.right));\n                this.restrictOffset.bottom = this.startOffset.bottom - (height * (1 - restrict.elementRect.bottom));\n            }\n            else {\n                this.restrictOffset.left = this.restrictOffset.top = this.restrictOffset.right = this.restrictOffset.bottom = 0;\n            }\n        },\n\n        /*\\\n         * Interaction.start\n         [ method ]\n         *\n         * Start an action with the given Interactable and Element as tartgets. The\n         * action must be enabled for the target Interactable and an appropriate number\n         * of pointers must be held down – 1 for drag/resize, 2 for gesture.\n         *\n         * Use it with `interactable.<action>able({ manualStart: false })` to always\n         * [start actions manually](https://github.com/taye/interact.js/issues/114)\n         *\n         - action       (object)  The action to be performed - drag, resize, etc.\n         - interactable (Interactable) The Interactable to target\n         - element      (Element) The DOM Element to target\n         = (object) interact\n         **\n         | interact(target)\n         |   .draggable({\n         |     // disable the default drag start by down->move\n         |     manualStart: true\n         |   })\n         |   // start dragging after the user holds the pointer down\n         |   .on('hold', function (event) {\n         |     var interaction = event.interaction;\n         |\n         |     if (!interaction.interacting()) {\n         |       interaction.start({ name: 'drag' },\n         |                         event.interactable,\n         |                         event.currentTarget);\n         |     }\n         | });\n        \\*/\n        start: function (action, interactable, element) {\n            if (this.interacting()\n                || !this.pointerIsDown\n                || this.pointerIds.length < (action.name === 'gesture'? 2 : 1)) {\n                return;\n            }\n\n            // if this interaction had been removed after stopping\n            // add it back\n            if (indexOf(interactions, this) === -1) {\n                interactions.push(this);\n            }\n\n            // set the startCoords if there was no prepared action\n            if (!this.prepared.name) {\n                this.setEventXY(this.startCoords, this.pointers);\n            }\n\n            this.prepared.name  = action.name;\n            this.prepared.axis  = action.axis;\n            this.prepared.edges = action.edges;\n            this.target         = interactable;\n            this.element        = element;\n\n            this.setStartOffsets(action.name, interactable, element);\n            this.setModifications(this.startCoords.page);\n\n            this.prevEvent = this[this.prepared.name + 'Start'](this.downEvent);\n        },\n\n        pointerMove: function (pointer, event, eventTarget, curEventTarget, preEnd) {\n            if (this.inertiaStatus.active) {\n                var pageUp   = this.inertiaStatus.upCoords.page;\n                var clientUp = this.inertiaStatus.upCoords.client;\n\n                var inertiaPosition = {\n                    pageX  : pageUp.x   + this.inertiaStatus.sx,\n                    pageY  : pageUp.y   + this.inertiaStatus.sy,\n                    clientX: clientUp.x + this.inertiaStatus.sx,\n                    clientY: clientUp.y + this.inertiaStatus.sy\n                };\n\n                this.setEventXY(this.curCoords, [inertiaPosition]);\n            }\n            else {\n                this.recordPointer(pointer);\n                this.setEventXY(this.curCoords, this.pointers);\n            }\n\n            var duplicateMove = (this.curCoords.page.x === this.prevCoords.page.x\n                                 && this.curCoords.page.y === this.prevCoords.page.y\n                                 && this.curCoords.client.x === this.prevCoords.client.x\n                                 && this.curCoords.client.y === this.prevCoords.client.y);\n\n            var dx, dy,\n                pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            // register movement greater than pointerMoveTolerance\n            if (this.pointerIsDown && !this.pointerWasMoved) {\n                dx = this.curCoords.client.x - this.startCoords.client.x;\n                dy = this.curCoords.client.y - this.startCoords.client.y;\n\n                this.pointerWasMoved = hypot(dx, dy) > pointerMoveTolerance;\n            }\n\n            if (!duplicateMove && (!this.pointerIsDown || this.pointerWasMoved)) {\n                if (this.pointerIsDown) {\n                    clearTimeout(this.holdTimers[pointerIndex]);\n                }\n\n                this.collectEventTargets(pointer, event, eventTarget, 'move');\n            }\n\n            if (!this.pointerIsDown) { return; }\n\n            if (duplicateMove && this.pointerWasMoved && !preEnd) {\n                this.checkAndPreventDefault(event, this.target, this.element);\n                return;\n            }\n\n            // set pointer coordinate, time changes and speeds\n            setEventDeltas(this.pointerDelta, this.prevCoords, this.curCoords);\n\n            if (!this.prepared.name) { return; }\n\n            if (this.pointerWasMoved\n                // ignore movement while inertia is active\n                && (!this.inertiaStatus.active || (pointer instanceof InteractEvent && /inertiastart/.test(pointer.type)))) {\n\n                // if just starting an action, calculate the pointer speed now\n                if (!this.interacting()) {\n                    setEventDeltas(this.pointerDelta, this.prevCoords, this.curCoords);\n\n                    // check if a drag is in the correct axis\n                    if (this.prepared.name === 'drag') {\n                        var absX = Math.abs(dx),\n                            absY = Math.abs(dy),\n                            targetAxis = this.target.options.drag.axis,\n                            axis = (absX > absY ? 'x' : absX < absY ? 'y' : 'xy');\n\n                        // if the movement isn't in the axis of the interactable\n                        if (axis !== 'xy' && targetAxis !== 'xy' && targetAxis !== axis) {\n                            // cancel the prepared action\n                            this.prepared.name = null;\n\n                            // then try to get a drag from another ineractable\n\n                            var element = eventTarget;\n\n                            // check element interactables\n                            while (isElement(element)) {\n                                var elementInteractable = interactables.get(element);\n\n                                if (elementInteractable\n                                    && elementInteractable !== this.target\n                                    && !elementInteractable.options.drag.manualStart\n                                    && elementInteractable.getAction(this.downPointer, this.downEvent, this, element).name === 'drag'\n                                    && checkAxis(axis, elementInteractable)) {\n\n                                    this.prepared.name = 'drag';\n                                    this.target = elementInteractable;\n                                    this.element = element;\n                                    break;\n                                }\n\n                                element = parentElement(element);\n                            }\n\n                            // if there's no drag from element interactables,\n                            // check the selector interactables\n                            if (!this.prepared.name) {\n                                var thisInteraction = this;\n\n                                var getDraggable = function (interactable, selector, context) {\n                                    var elements = ie8MatchesSelector\n                                        ? context.querySelectorAll(selector)\n                                        : undefined;\n\n                                    if (interactable === thisInteraction.target) { return; }\n\n                                    if (inContext(interactable, eventTarget)\n                                        && !interactable.options.drag.manualStart\n                                        && !testIgnore(interactable, element, eventTarget)\n                                        && testAllow(interactable, element, eventTarget)\n                                        && matchesSelector(element, selector, elements)\n                                        && interactable.getAction(thisInteraction.downPointer, thisInteraction.downEvent, thisInteraction, element).name === 'drag'\n                                        && checkAxis(axis, interactable)\n                                        && withinInteractionLimit(interactable, element, 'drag')) {\n\n                                        return interactable;\n                                    }\n                                };\n\n                                element = eventTarget;\n\n                                while (isElement(element)) {\n                                    var selectorInteractable = interactables.forEachSelector(getDraggable);\n\n                                    if (selectorInteractable) {\n                                        this.prepared.name = 'drag';\n                                        this.target = selectorInteractable;\n                                        this.element = element;\n                                        break;\n                                    }\n\n                                    element = parentElement(element);\n                                }\n                            }\n                        }\n                    }\n                }\n\n                var starting = !!this.prepared.name && !this.interacting();\n\n                if (starting\n                    && (this.target.options[this.prepared.name].manualStart\n                        || !withinInteractionLimit(this.target, this.element, this.prepared))) {\n                    this.stop(event);\n                    return;\n                }\n\n                if (this.prepared.name && this.target) {\n                    if (starting) {\n                        this.start(this.prepared, this.target, this.element);\n                    }\n\n                    var shouldMove = this.setModifications(this.curCoords.page, preEnd);\n\n                    // move if snapping or restriction doesn't prevent it\n                    if (shouldMove || starting) {\n                        this.prevEvent = this[this.prepared.name + 'Move'](event);\n                    }\n\n                    this.checkAndPreventDefault(event, this.target, this.element);\n                }\n            }\n\n            copyCoords(this.prevCoords, this.curCoords);\n\n            if (this.dragging || this.resizing) {\n                this.autoScrollMove(pointer);\n            }\n        },\n\n        dragStart: function (event) {\n            var dragEvent = new InteractEvent(this, event, 'drag', 'start', this.element);\n\n            this.dragging = true;\n            this.target.fire(dragEvent);\n\n            // reset active dropzones\n            this.activeDrops.dropzones = [];\n            this.activeDrops.elements  = [];\n            this.activeDrops.rects     = [];\n\n            if (!this.dynamicDrop) {\n                this.setActiveDrops(this.element);\n            }\n\n            var dropEvents = this.getDropEvents(event, dragEvent);\n\n            if (dropEvents.activate) {\n                this.fireActiveDrops(dropEvents.activate);\n            }\n\n            return dragEvent;\n        },\n\n        dragMove: function (event) {\n            var target = this.target,\n                dragEvent  = new InteractEvent(this, event, 'drag', 'move', this.element),\n                draggableElement = this.element,\n                drop = this.getDrop(dragEvent, event, draggableElement);\n\n            this.dropTarget = drop.dropzone;\n            this.dropElement = drop.element;\n\n            var dropEvents = this.getDropEvents(event, dragEvent);\n\n            target.fire(dragEvent);\n\n            if (dropEvents.leave) { this.prevDropTarget.fire(dropEvents.leave); }\n            if (dropEvents.enter) {     this.dropTarget.fire(dropEvents.enter); }\n            if (dropEvents.move ) {     this.dropTarget.fire(dropEvents.move ); }\n\n            this.prevDropTarget  = this.dropTarget;\n            this.prevDropElement = this.dropElement;\n\n            return dragEvent;\n        },\n\n        resizeStart: function (event) {\n            var resizeEvent = new InteractEvent(this, event, 'resize', 'start', this.element);\n\n            if (this.prepared.edges) {\n                var startRect = this.target.getRect(this.element);\n\n                /*\n                 * When using the `resizable.square` or `resizable.preserveAspectRatio` options, resizing from one edge\n                 * will affect another. E.g. with `resizable.square`, resizing to make the right edge larger will make\n                 * the bottom edge larger by the same amount. We call these 'linked' edges. Any linked edges will depend\n                 * on the active edges and the edge being interacted with.\n                 */\n                if (this.target.options.resize.square || this.target.options.resize.preserveAspectRatio) {\n                    var linkedEdges = extend({}, this.prepared.edges);\n\n                    linkedEdges.top    = linkedEdges.top    || (linkedEdges.left   && !linkedEdges.bottom);\n                    linkedEdges.left   = linkedEdges.left   || (linkedEdges.top    && !linkedEdges.right );\n                    linkedEdges.bottom = linkedEdges.bottom || (linkedEdges.right  && !linkedEdges.top   );\n                    linkedEdges.right  = linkedEdges.right  || (linkedEdges.bottom && !linkedEdges.left  );\n\n                    this.prepared._linkedEdges = linkedEdges;\n                }\n                else {\n                    this.prepared._linkedEdges = null;\n                }\n\n                // if using `resizable.preserveAspectRatio` option, record aspect ratio at the start of the resize\n                if (this.target.options.resize.preserveAspectRatio) {\n                    this.resizeStartAspectRatio = startRect.width / startRect.height;\n                }\n\n                this.resizeRects = {\n                    start     : startRect,\n                    current   : extend({}, startRect),\n                    restricted: extend({}, startRect),\n                    previous  : extend({}, startRect),\n                    delta     : {\n                        left: 0, right : 0, width : 0,\n                        top : 0, bottom: 0, height: 0\n                    }\n                };\n\n                resizeEvent.rect = this.resizeRects.restricted;\n                resizeEvent.deltaRect = this.resizeRects.delta;\n            }\n\n            this.target.fire(resizeEvent);\n\n            this.resizing = true;\n\n            return resizeEvent;\n        },\n\n        resizeMove: function (event) {\n            var resizeEvent = new InteractEvent(this, event, 'resize', 'move', this.element);\n\n            var edges = this.prepared.edges,\n                invert = this.target.options.resize.invert,\n                invertible = invert === 'reposition' || invert === 'negate';\n\n            if (edges) {\n                var dx = resizeEvent.dx,\n                    dy = resizeEvent.dy,\n\n                    start      = this.resizeRects.start,\n                    current    = this.resizeRects.current,\n                    restricted = this.resizeRects.restricted,\n                    delta      = this.resizeRects.delta,\n                    previous   = extend(this.resizeRects.previous, restricted),\n\n                    originalEdges = edges;\n\n                // `resize.preserveAspectRatio` takes precedence over `resize.square`\n                if (this.target.options.resize.preserveAspectRatio) {\n                    var resizeStartAspectRatio = this.resizeStartAspectRatio;\n\n                    edges = this.prepared._linkedEdges;\n\n                    if ((originalEdges.left && originalEdges.bottom)\n                        || (originalEdges.right && originalEdges.top)) {\n                        dy = -dx / resizeStartAspectRatio;\n                    }\n                    else if (originalEdges.left || originalEdges.right) { dy = dx / resizeStartAspectRatio; }\n                    else if (originalEdges.top || originalEdges.bottom) { dx = dy * resizeStartAspectRatio; }\n                }\n                else if (this.target.options.resize.square) {\n                    edges = this.prepared._linkedEdges;\n\n                    if ((originalEdges.left && originalEdges.bottom)\n                        || (originalEdges.right && originalEdges.top)) {\n                        dy = -dx;\n                    }\n                    else if (originalEdges.left || originalEdges.right) { dy = dx; }\n                    else if (originalEdges.top || originalEdges.bottom) { dx = dy; }\n                }\n\n                // update the 'current' rect without modifications\n                if (edges.top   ) { current.top    += dy; }\n                if (edges.bottom) { current.bottom += dy; }\n                if (edges.left  ) { current.left   += dx; }\n                if (edges.right ) { current.right  += dx; }\n\n                if (invertible) {\n                    // if invertible, copy the current rect\n                    extend(restricted, current);\n\n                    if (invert === 'reposition') {\n                        // swap edge values if necessary to keep width/height positive\n                        var swap;\n\n                        if (restricted.top > restricted.bottom) {\n                            swap = restricted.top;\n\n                            restricted.top = restricted.bottom;\n                            restricted.bottom = swap;\n                        }\n                        if (restricted.left > restricted.right) {\n                            swap = restricted.left;\n\n                            restricted.left = restricted.right;\n                            restricted.right = swap;\n                        }\n                    }\n                }\n                else {\n                    // if not invertible, restrict to minimum of 0x0 rect\n                    restricted.top    = Math.min(current.top, start.bottom);\n                    restricted.bottom = Math.max(current.bottom, start.top);\n                    restricted.left   = Math.min(current.left, start.right);\n                    restricted.right  = Math.max(current.right, start.left);\n                }\n\n                restricted.width  = restricted.right  - restricted.left;\n                restricted.height = restricted.bottom - restricted.top ;\n\n                for (var edge in restricted) {\n                    delta[edge] = restricted[edge] - previous[edge];\n                }\n\n                resizeEvent.edges = this.prepared.edges;\n                resizeEvent.rect = restricted;\n                resizeEvent.deltaRect = delta;\n            }\n\n            this.target.fire(resizeEvent);\n\n            return resizeEvent;\n        },\n\n        gestureStart: function (event) {\n            var gestureEvent = new InteractEvent(this, event, 'gesture', 'start', this.element);\n\n            gestureEvent.ds = 0;\n\n            this.gesture.startDistance = this.gesture.prevDistance = gestureEvent.distance;\n            this.gesture.startAngle = this.gesture.prevAngle = gestureEvent.angle;\n            this.gesture.scale = 1;\n\n            this.gesturing = true;\n\n            this.target.fire(gestureEvent);\n\n            return gestureEvent;\n        },\n\n        gestureMove: function (event) {\n            if (!this.pointerIds.length) {\n                return this.prevEvent;\n            }\n\n            var gestureEvent;\n\n            gestureEvent = new InteractEvent(this, event, 'gesture', 'move', this.element);\n            gestureEvent.ds = gestureEvent.scale - this.gesture.scale;\n\n            this.target.fire(gestureEvent);\n\n            this.gesture.prevAngle = gestureEvent.angle;\n            this.gesture.prevDistance = gestureEvent.distance;\n\n            if (gestureEvent.scale !== Infinity &&\n                gestureEvent.scale !== null &&\n                gestureEvent.scale !== undefined  &&\n                !isNaN(gestureEvent.scale)) {\n\n                this.gesture.scale = gestureEvent.scale;\n            }\n\n            return gestureEvent;\n        },\n\n        pointerHold: function (pointer, event, eventTarget) {\n            this.collectEventTargets(pointer, event, eventTarget, 'hold');\n        },\n\n        pointerUp: function (pointer, event, eventTarget, curEventTarget) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            clearTimeout(this.holdTimers[pointerIndex]);\n\n            this.collectEventTargets(pointer, event, eventTarget, 'up' );\n            this.collectEventTargets(pointer, event, eventTarget, 'tap');\n\n            this.pointerEnd(pointer, event, eventTarget, curEventTarget);\n\n            this.removePointer(pointer);\n        },\n\n        pointerCancel: function (pointer, event, eventTarget, curEventTarget) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            clearTimeout(this.holdTimers[pointerIndex]);\n\n            this.collectEventTargets(pointer, event, eventTarget, 'cancel');\n            this.pointerEnd(pointer, event, eventTarget, curEventTarget);\n\n            this.removePointer(pointer);\n        },\n\n        // http://www.quirksmode.org/dom/events/click.html\n        // >Events leading to dblclick\n        //\n        // IE8 doesn't fire down event before dblclick.\n        // This workaround tries to fire a tap and doubletap after dblclick\n        ie8Dblclick: function (pointer, event, eventTarget) {\n            if (this.prevTap\n                && event.clientX === this.prevTap.clientX\n                && event.clientY === this.prevTap.clientY\n                && eventTarget   === this.prevTap.target) {\n\n                this.downTargets[0] = eventTarget;\n                this.downTimes[0] = new Date().getTime();\n                this.collectEventTargets(pointer, event, eventTarget, 'tap');\n            }\n        },\n\n        // End interact move events and stop auto-scroll unless inertia is enabled\n        pointerEnd: function (pointer, event, eventTarget, curEventTarget) {\n            var endEvent,\n                target = this.target,\n                options = target && target.options,\n                inertiaOptions = options && this.prepared.name && options[this.prepared.name].inertia,\n                inertiaStatus = this.inertiaStatus;\n\n            if (this.interacting()) {\n\n                if (inertiaStatus.active && !inertiaStatus.ending) { return; }\n\n                var pointerSpeed,\n                    now = new Date().getTime(),\n                    inertiaPossible = false,\n                    inertia = false,\n                    smoothEnd = false,\n                    endSnap = checkSnap(target, this.prepared.name) && options[this.prepared.name].snap.endOnly,\n                    endRestrict = checkRestrict(target, this.prepared.name) && options[this.prepared.name].restrict.endOnly,\n                    dx = 0,\n                    dy = 0,\n                    startEvent;\n\n                if (this.dragging) {\n                    if      (options.drag.axis === 'x' ) { pointerSpeed = Math.abs(this.pointerDelta.client.vx); }\n                    else if (options.drag.axis === 'y' ) { pointerSpeed = Math.abs(this.pointerDelta.client.vy); }\n                    else   /*options.drag.axis === 'xy'*/{ pointerSpeed = this.pointerDelta.client.speed; }\n                }\n                else {\n                    pointerSpeed = this.pointerDelta.client.speed;\n                }\n\n                // check if inertia should be started\n                inertiaPossible = (inertiaOptions && inertiaOptions.enabled\n                                   && this.prepared.name !== 'gesture'\n                                   && event !== inertiaStatus.startEvent);\n\n                inertia = (inertiaPossible\n                           && (now - this.curCoords.timeStamp) < 50\n                           && pointerSpeed > inertiaOptions.minSpeed\n                           && pointerSpeed > inertiaOptions.endSpeed);\n\n                if (inertiaPossible && !inertia && (endSnap || endRestrict)) {\n\n                    var snapRestrict = {};\n\n                    snapRestrict.snap = snapRestrict.restrict = snapRestrict;\n\n                    if (endSnap) {\n                        this.setSnapping(this.curCoords.page, snapRestrict);\n                        if (snapRestrict.locked) {\n                            dx += snapRestrict.dx;\n                            dy += snapRestrict.dy;\n                        }\n                    }\n\n                    if (endRestrict) {\n                        this.setRestriction(this.curCoords.page, snapRestrict);\n                        if (snapRestrict.restricted) {\n                            dx += snapRestrict.dx;\n                            dy += snapRestrict.dy;\n                        }\n                    }\n\n                    if (dx || dy) {\n                        smoothEnd = true;\n                    }\n                }\n\n                if (inertia || smoothEnd) {\n                    copyCoords(inertiaStatus.upCoords, this.curCoords);\n\n                    this.pointers[0] = inertiaStatus.startEvent = startEvent =\n                        new InteractEvent(this, event, this.prepared.name, 'inertiastart', this.element);\n\n                    inertiaStatus.t0 = now;\n\n                    target.fire(inertiaStatus.startEvent);\n\n                    if (inertia) {\n                        inertiaStatus.vx0 = this.pointerDelta.client.vx;\n                        inertiaStatus.vy0 = this.pointerDelta.client.vy;\n                        inertiaStatus.v0 = pointerSpeed;\n\n                        this.calcInertia(inertiaStatus);\n\n                        var page = extend({}, this.curCoords.page),\n                            origin = getOriginXY(target, this.element),\n                            statusObject;\n\n                        page.x = page.x + inertiaStatus.xe - origin.x;\n                        page.y = page.y + inertiaStatus.ye - origin.y;\n\n                        statusObject = {\n                            useStatusXY: true,\n                            x: page.x,\n                            y: page.y,\n                            dx: 0,\n                            dy: 0,\n                            snap: null\n                        };\n\n                        statusObject.snap = statusObject;\n\n                        dx = dy = 0;\n\n                        if (endSnap) {\n                            var snap = this.setSnapping(this.curCoords.page, statusObject);\n\n                            if (snap.locked) {\n                                dx += snap.dx;\n                                dy += snap.dy;\n                            }\n                        }\n\n                        if (endRestrict) {\n                            var restrict = this.setRestriction(this.curCoords.page, statusObject);\n\n                            if (restrict.restricted) {\n                                dx += restrict.dx;\n                                dy += restrict.dy;\n                            }\n                        }\n\n                        inertiaStatus.modifiedXe += dx;\n                        inertiaStatus.modifiedYe += dy;\n\n                        inertiaStatus.i = reqFrame(this.boundInertiaFrame);\n                    }\n                    else {\n                        inertiaStatus.smoothEnd = true;\n                        inertiaStatus.xe = dx;\n                        inertiaStatus.ye = dy;\n\n                        inertiaStatus.sx = inertiaStatus.sy = 0;\n\n                        inertiaStatus.i = reqFrame(this.boundSmoothEndFrame);\n                    }\n\n                    inertiaStatus.active = true;\n                    return;\n                }\n\n                if (endSnap || endRestrict) {\n                    // fire a move event at the snapped coordinates\n                    this.pointerMove(pointer, event, eventTarget, curEventTarget, true);\n                }\n            }\n\n            if (this.dragging) {\n                endEvent = new InteractEvent(this, event, 'drag', 'end', this.element);\n\n                var draggableElement = this.element,\n                    drop = this.getDrop(endEvent, event, draggableElement);\n\n                this.dropTarget = drop.dropzone;\n                this.dropElement = drop.element;\n\n                var dropEvents = this.getDropEvents(event, endEvent);\n\n                if (dropEvents.leave) { this.prevDropTarget.fire(dropEvents.leave); }\n                if (dropEvents.enter) {     this.dropTarget.fire(dropEvents.enter); }\n                if (dropEvents.drop ) {     this.dropTarget.fire(dropEvents.drop ); }\n                if (dropEvents.deactivate) {\n                    this.fireActiveDrops(dropEvents.deactivate);\n                }\n\n                target.fire(endEvent);\n            }\n            else if (this.resizing) {\n                endEvent = new InteractEvent(this, event, 'resize', 'end', this.element);\n                target.fire(endEvent);\n            }\n            else if (this.gesturing) {\n                endEvent = new InteractEvent(this, event, 'gesture', 'end', this.element);\n                target.fire(endEvent);\n            }\n\n            this.stop(event);\n        },\n\n        collectDrops: function (element) {\n            var drops = [],\n                elements = [],\n                i;\n\n            element = element || this.element;\n\n            // collect all dropzones and their elements which qualify for a drop\n            for (i = 0; i < interactables.length; i++) {\n                if (!interactables[i].options.drop.enabled) { continue; }\n\n                var current = interactables[i],\n                    accept = current.options.drop.accept;\n\n                // test the draggable element against the dropzone's accept setting\n                if ((isElement(accept) && accept !== element)\n                    || (isString(accept)\n                        && !matchesSelector(element, accept))) {\n\n                    continue;\n                }\n\n                // query for new elements if necessary\n                var dropElements = current.selector? current._context.querySelectorAll(current.selector) : [current._element];\n\n                for (var j = 0, len = dropElements.length; j < len; j++) {\n                    var currentElement = dropElements[j];\n\n                    if (currentElement === element) {\n                        continue;\n                    }\n\n                    drops.push(current);\n                    elements.push(currentElement);\n                }\n            }\n\n            return {\n                dropzones: drops,\n                elements: elements\n            };\n        },\n\n        fireActiveDrops: function (event) {\n            var i,\n                current,\n                currentElement,\n                prevElement;\n\n            // loop through all active dropzones and trigger event\n            for (i = 0; i < this.activeDrops.dropzones.length; i++) {\n                current = this.activeDrops.dropzones[i];\n                currentElement = this.activeDrops.elements [i];\n\n                // prevent trigger of duplicate events on same element\n                if (currentElement !== prevElement) {\n                    // set current element as event target\n                    event.target = currentElement;\n                    current.fire(event);\n                }\n                prevElement = currentElement;\n            }\n        },\n\n        // Collect a new set of possible drops and save them in activeDrops.\n        // setActiveDrops should always be called when a drag has just started or a\n        // drag event happens while dynamicDrop is true\n        setActiveDrops: function (dragElement) {\n            // get dropzones and their elements that could receive the draggable\n            var possibleDrops = this.collectDrops(dragElement, true);\n\n            this.activeDrops.dropzones = possibleDrops.dropzones;\n            this.activeDrops.elements  = possibleDrops.elements;\n            this.activeDrops.rects     = [];\n\n            for (var i = 0; i < this.activeDrops.dropzones.length; i++) {\n                this.activeDrops.rects[i] = this.activeDrops.dropzones[i].getRect(this.activeDrops.elements[i]);\n            }\n        },\n\n        getDrop: function (dragEvent, event, dragElement) {\n            var validDrops = [];\n\n            if (dynamicDrop) {\n                this.setActiveDrops(dragElement);\n            }\n\n            // collect all dropzones and their elements which qualify for a drop\n            for (var j = 0; j < this.activeDrops.dropzones.length; j++) {\n                var current        = this.activeDrops.dropzones[j],\n                    currentElement = this.activeDrops.elements [j],\n                    rect           = this.activeDrops.rects    [j];\n\n                validDrops.push(current.dropCheck(dragEvent, event, this.target, dragElement, currentElement, rect)\n                                ? currentElement\n                                : null);\n            }\n\n            // get the most appropriate dropzone based on DOM depth and order\n            var dropIndex = indexOfDeepestElement(validDrops),\n                dropzone  = this.activeDrops.dropzones[dropIndex] || null,\n                element   = this.activeDrops.elements [dropIndex] || null;\n\n            return {\n                dropzone: dropzone,\n                element: element\n            };\n        },\n\n        getDropEvents: function (pointerEvent, dragEvent) {\n            var dropEvents = {\n                enter     : null,\n                leave     : null,\n                activate  : null,\n                deactivate: null,\n                move      : null,\n                drop      : null\n            };\n\n            if (this.dropElement !== this.prevDropElement) {\n                // if there was a prevDropTarget, create a dragleave event\n                if (this.prevDropTarget) {\n                    dropEvents.leave = {\n                        target       : this.prevDropElement,\n                        dropzone     : this.prevDropTarget,\n                        relatedTarget: dragEvent.target,\n                        draggable    : dragEvent.interactable,\n                        dragEvent    : dragEvent,\n                        interaction  : this,\n                        timeStamp    : dragEvent.timeStamp,\n                        type         : 'dragleave'\n                    };\n\n                    dragEvent.dragLeave = this.prevDropElement;\n                    dragEvent.prevDropzone = this.prevDropTarget;\n                }\n                // if the dropTarget is not null, create a dragenter event\n                if (this.dropTarget) {\n                    dropEvents.enter = {\n                        target       : this.dropElement,\n                        dropzone     : this.dropTarget,\n                        relatedTarget: dragEvent.target,\n                        draggable    : dragEvent.interactable,\n                        dragEvent    : dragEvent,\n                        interaction  : this,\n                        timeStamp    : dragEvent.timeStamp,\n                        type         : 'dragenter'\n                    };\n\n                    dragEvent.dragEnter = this.dropElement;\n                    dragEvent.dropzone = this.dropTarget;\n                }\n            }\n\n            if (dragEvent.type === 'dragend' && this.dropTarget) {\n                dropEvents.drop = {\n                    target       : this.dropElement,\n                    dropzone     : this.dropTarget,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'drop'\n                };\n\n                dragEvent.dropzone = this.dropTarget;\n            }\n            if (dragEvent.type === 'dragstart') {\n                dropEvents.activate = {\n                    target       : null,\n                    dropzone     : null,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'dropactivate'\n                };\n            }\n            if (dragEvent.type === 'dragend') {\n                dropEvents.deactivate = {\n                    target       : null,\n                    dropzone     : null,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'dropdeactivate'\n                };\n            }\n            if (dragEvent.type === 'dragmove' && this.dropTarget) {\n                dropEvents.move = {\n                    target       : this.dropElement,\n                    dropzone     : this.dropTarget,\n                    relatedTarget: dragEvent.target,\n                    draggable    : dragEvent.interactable,\n                    dragEvent    : dragEvent,\n                    interaction  : this,\n                    dragmove     : dragEvent,\n                    timeStamp    : dragEvent.timeStamp,\n                    type         : 'dropmove'\n                };\n                dragEvent.dropzone = this.dropTarget;\n            }\n\n            return dropEvents;\n        },\n\n        currentAction: function () {\n            return (this.dragging && 'drag') || (this.resizing && 'resize') || (this.gesturing && 'gesture') || null;\n        },\n\n        interacting: function () {\n            return this.dragging || this.resizing || this.gesturing;\n        },\n\n        clearTargets: function () {\n            this.target = this.element = null;\n\n            this.dropTarget = this.dropElement = this.prevDropTarget = this.prevDropElement = null;\n        },\n\n        stop: function (event) {\n            if (this.interacting()) {\n                autoScroll.stop();\n                this.matches = [];\n                this.matchElements = [];\n\n                var target = this.target;\n\n                if (target.options.styleCursor) {\n                    target._doc.documentElement.style.cursor = '';\n                }\n\n                // prevent Default only if were previously interacting\n                if (event && isFunction(event.preventDefault)) {\n                    this.checkAndPreventDefault(event, target, this.element);\n                }\n\n                if (this.dragging) {\n                    this.activeDrops.dropzones = this.activeDrops.elements = this.activeDrops.rects = null;\n                }\n            }\n\n            this.clearTargets();\n\n            this.pointerIsDown = this.snapStatus.locked = this.dragging = this.resizing = this.gesturing = false;\n            this.prepared.name = this.prevEvent = null;\n            this.inertiaStatus.resumeDx = this.inertiaStatus.resumeDy = 0;\n\n            // remove pointers if their ID isn't in this.pointerIds\n            for (var i = 0; i < this.pointers.length; i++) {\n                if (indexOf(this.pointerIds, getPointerId(this.pointers[i])) === -1) {\n                    this.pointers.splice(i, 1);\n                }\n            }\n        },\n\n        inertiaFrame: function () {\n            var inertiaStatus = this.inertiaStatus,\n                options = this.target.options[this.prepared.name].inertia,\n                lambda = options.resistance,\n                t = new Date().getTime() / 1000 - inertiaStatus.t0;\n\n            if (t < inertiaStatus.te) {\n\n                var progress =  1 - (Math.exp(-lambda * t) - inertiaStatus.lambda_v0) / inertiaStatus.one_ve_v0;\n\n                if (inertiaStatus.modifiedXe === inertiaStatus.xe && inertiaStatus.modifiedYe === inertiaStatus.ye) {\n                    inertiaStatus.sx = inertiaStatus.xe * progress;\n                    inertiaStatus.sy = inertiaStatus.ye * progress;\n                }\n                else {\n                    var quadPoint = getQuadraticCurvePoint(\n                            0, 0,\n                            inertiaStatus.xe, inertiaStatus.ye,\n                            inertiaStatus.modifiedXe, inertiaStatus.modifiedYe,\n                            progress);\n\n                    inertiaStatus.sx = quadPoint.x;\n                    inertiaStatus.sy = quadPoint.y;\n                }\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.i = reqFrame(this.boundInertiaFrame);\n            }\n            else {\n                inertiaStatus.ending = true;\n\n                inertiaStatus.sx = inertiaStatus.modifiedXe;\n                inertiaStatus.sy = inertiaStatus.modifiedYe;\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n                this.pointerEnd(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.active = inertiaStatus.ending = false;\n            }\n        },\n\n        smoothEndFrame: function () {\n            var inertiaStatus = this.inertiaStatus,\n                t = new Date().getTime() - inertiaStatus.t0,\n                duration = this.target.options[this.prepared.name].inertia.smoothEndDuration;\n\n            if (t < duration) {\n                inertiaStatus.sx = easeOutQuad(t, 0, inertiaStatus.xe, duration);\n                inertiaStatus.sy = easeOutQuad(t, 0, inertiaStatus.ye, duration);\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.i = reqFrame(this.boundSmoothEndFrame);\n            }\n            else {\n                inertiaStatus.ending = true;\n\n                inertiaStatus.sx = inertiaStatus.xe;\n                inertiaStatus.sy = inertiaStatus.ye;\n\n                this.pointerMove(inertiaStatus.startEvent, inertiaStatus.startEvent);\n                this.pointerEnd(inertiaStatus.startEvent, inertiaStatus.startEvent);\n\n                inertiaStatus.smoothEnd =\n                  inertiaStatus.active = inertiaStatus.ending = false;\n            }\n        },\n\n        addPointer: function (pointer) {\n            var id = getPointerId(pointer),\n                index = this.mouse? 0 : indexOf(this.pointerIds, id);\n\n            if (index === -1) {\n                index = this.pointerIds.length;\n            }\n\n            this.pointerIds[index] = id;\n            this.pointers[index] = pointer;\n\n            return index;\n        },\n\n        removePointer: function (pointer) {\n            var id = getPointerId(pointer),\n                index = this.mouse? 0 : indexOf(this.pointerIds, id);\n\n            if (index === -1) { return; }\n\n            this.pointers   .splice(index, 1);\n            this.pointerIds .splice(index, 1);\n            this.downTargets.splice(index, 1);\n            this.downTimes  .splice(index, 1);\n            this.holdTimers .splice(index, 1);\n        },\n\n        recordPointer: function (pointer) {\n            var index = this.mouse? 0: indexOf(this.pointerIds, getPointerId(pointer));\n\n            if (index === -1) { return; }\n\n            this.pointers[index] = pointer;\n        },\n\n        collectEventTargets: function (pointer, event, eventTarget, eventType) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer));\n\n            // do not fire a tap event if the pointer was moved before being lifted\n            if (eventType === 'tap' && (this.pointerWasMoved\n                // or if the pointerup target is different to the pointerdown target\n                || !(this.downTargets[pointerIndex] && this.downTargets[pointerIndex] === eventTarget))) {\n                return;\n            }\n\n            var targets = [],\n                elements = [],\n                element = eventTarget;\n\n            function collectSelectors (interactable, selector, context) {\n                var els = ie8MatchesSelector\n                        ? context.querySelectorAll(selector)\n                        : undefined;\n\n                if (interactable._iEvents[eventType]\n                    && isElement(element)\n                    && inContext(interactable, element)\n                    && !testIgnore(interactable, element, eventTarget)\n                    && testAllow(interactable, element, eventTarget)\n                    && matchesSelector(element, selector, els)) {\n\n                    targets.push(interactable);\n                    elements.push(element);\n                }\n            }\n\n            while (element) {\n                if (interact.isSet(element) && interact(element)._iEvents[eventType]) {\n                    targets.push(interact(element));\n                    elements.push(element);\n                }\n\n                interactables.forEachSelector(collectSelectors);\n\n                element = parentElement(element);\n            }\n\n            // create the tap event even if there are no listeners so that\n            // doubletap can still be created and fired\n            if (targets.length || eventType === 'tap') {\n                this.firePointers(pointer, event, eventTarget, targets, elements, eventType);\n            }\n        },\n\n        firePointers: function (pointer, event, eventTarget, targets, elements, eventType) {\n            var pointerIndex = this.mouse? 0 : indexOf(this.pointerIds, getPointerId(pointer)),\n                pointerEvent = {},\n                i,\n                // for tap events\n                interval, createNewDoubleTap;\n\n            // if it's a doubletap then the event properties would have been\n            // copied from the tap event and provided as the pointer argument\n            if (eventType === 'doubletap') {\n                pointerEvent = pointer;\n            }\n            else {\n                pointerExtend(pointerEvent, event);\n                if (event !== pointer) {\n                    pointerExtend(pointerEvent, pointer);\n                }\n\n                pointerEvent.preventDefault           = preventOriginalDefault;\n                pointerEvent.stopPropagation          = InteractEvent.prototype.stopPropagation;\n                pointerEvent.stopImmediatePropagation = InteractEvent.prototype.stopImmediatePropagation;\n                pointerEvent.interaction              = this;\n\n                pointerEvent.timeStamp       = new Date().getTime();\n                pointerEvent.originalEvent   = event;\n                pointerEvent.originalPointer = pointer;\n                pointerEvent.type            = eventType;\n                pointerEvent.pointerId       = getPointerId(pointer);\n                pointerEvent.pointerType     = this.mouse? 'mouse' : !supportsPointerEvent? 'touch'\n                                                    : isString(pointer.pointerType)\n                                                        ? pointer.pointerType\n                                                        : [,,'touch', 'pen', 'mouse'][pointer.pointerType];\n            }\n\n            if (eventType === 'tap') {\n                pointerEvent.dt = pointerEvent.timeStamp - this.downTimes[pointerIndex];\n\n                interval = pointerEvent.timeStamp - this.tapTime;\n                createNewDoubleTap = !!(this.prevTap && this.prevTap.type !== 'doubletap'\n                       && this.prevTap.target === pointerEvent.target\n                       && interval < 500);\n\n                pointerEvent.double = createNewDoubleTap;\n\n                this.tapTime = pointerEvent.timeStamp;\n            }\n\n            for (i = 0; i < targets.length; i++) {\n                pointerEvent.currentTarget = elements[i];\n                pointerEvent.interactable = targets[i];\n                targets[i].fire(pointerEvent);\n\n                if (pointerEvent.immediatePropagationStopped\n                    ||(pointerEvent.propagationStopped && elements[i + 1] !== pointerEvent.currentTarget)) {\n                    break;\n                }\n            }\n\n            if (createNewDoubleTap) {\n                var doubleTap = {};\n\n                extend(doubleTap, pointerEvent);\n\n                doubleTap.dt   = interval;\n                doubleTap.type = 'doubletap';\n\n                this.collectEventTargets(doubleTap, event, eventTarget, 'doubletap');\n\n                this.prevTap = doubleTap;\n            }\n            else if (eventType === 'tap') {\n                this.prevTap = pointerEvent;\n            }\n        },\n\n        validateSelector: function (pointer, event, matches, matchElements) {\n            for (var i = 0, len = matches.length; i < len; i++) {\n                var match = matches[i],\n                    matchElement = matchElements[i],\n                    action = validateAction(match.getAction(pointer, event, this, matchElement), match);\n\n                if (action && withinInteractionLimit(match, matchElement, action)) {\n                    this.target = match;\n                    this.element = matchElement;\n\n                    return action;\n                }\n            }\n        },\n\n        setSnapping: function (pageCoords, status) {\n            var snap = this.target.options[this.prepared.name].snap,\n                targets = [],\n                target,\n                page,\n                i;\n\n            status = status || this.snapStatus;\n\n            if (status.useStatusXY) {\n                page = { x: status.x, y: status.y };\n            }\n            else {\n                var origin = getOriginXY(this.target, this.element);\n\n                page = extend({}, pageCoords);\n\n                page.x -= origin.x;\n                page.y -= origin.y;\n            }\n\n            status.realX = page.x;\n            status.realY = page.y;\n\n            page.x = page.x - this.inertiaStatus.resumeDx;\n            page.y = page.y - this.inertiaStatus.resumeDy;\n\n            var len = snap.targets? snap.targets.length : 0;\n\n            for (var relIndex = 0; relIndex < this.snapOffsets.length; relIndex++) {\n                var relative = {\n                    x: page.x - this.snapOffsets[relIndex].x,\n                    y: page.y - this.snapOffsets[relIndex].y\n                };\n\n                for (i = 0; i < len; i++) {\n                    if (isFunction(snap.targets[i])) {\n                        target = snap.targets[i](relative.x, relative.y, this);\n                    }\n                    else {\n                        target = snap.targets[i];\n                    }\n\n                    if (!target) { continue; }\n\n                    targets.push({\n                        x: isNumber(target.x) ? (target.x + this.snapOffsets[relIndex].x) : relative.x,\n                        y: isNumber(target.y) ? (target.y + this.snapOffsets[relIndex].y) : relative.y,\n\n                        range: isNumber(target.range)? target.range: snap.range\n                    });\n                }\n            }\n\n            var closest = {\n                    target: null,\n                    inRange: false,\n                    distance: 0,\n                    range: 0,\n                    dx: 0,\n                    dy: 0\n                };\n\n            for (i = 0, len = targets.length; i < len; i++) {\n                target = targets[i];\n\n                var range = target.range,\n                    dx = target.x - page.x,\n                    dy = target.y - page.y,\n                    distance = hypot(dx, dy),\n                    inRange = distance <= range;\n\n                // Infinite targets count as being out of range\n                // compared to non infinite ones that are in range\n                if (range === Infinity && closest.inRange && closest.range !== Infinity) {\n                    inRange = false;\n                }\n\n                if (!closest.target || (inRange\n                    // is the closest target in range?\n                    ? (closest.inRange && range !== Infinity\n                        // the pointer is relatively deeper in this target\n                        ? distance / range < closest.distance / closest.range\n                        // this target has Infinite range and the closest doesn't\n                        : (range === Infinity && closest.range !== Infinity)\n                            // OR this target is closer that the previous closest\n                            || distance < closest.distance)\n                    // The other is not in range and the pointer is closer to this target\n                    : (!closest.inRange && distance < closest.distance))) {\n\n                    if (range === Infinity) {\n                        inRange = true;\n                    }\n\n                    closest.target = target;\n                    closest.distance = distance;\n                    closest.range = range;\n                    closest.inRange = inRange;\n                    closest.dx = dx;\n                    closest.dy = dy;\n\n                    status.range = range;\n                }\n            }\n\n            var snapChanged;\n\n            if (closest.target) {\n                snapChanged = (status.snappedX !== closest.target.x || status.snappedY !== closest.target.y);\n\n                status.snappedX = closest.target.x;\n                status.snappedY = closest.target.y;\n            }\n            else {\n                snapChanged = true;\n\n                status.snappedX = NaN;\n                status.snappedY = NaN;\n            }\n\n            status.dx = closest.dx;\n            status.dy = closest.dy;\n\n            status.changed = (snapChanged || (closest.inRange && !status.locked));\n            status.locked = closest.inRange;\n\n            return status;\n        },\n\n        setRestriction: function (pageCoords, status) {\n            var target = this.target,\n                restrict = target && target.options[this.prepared.name].restrict,\n                restriction = restrict && restrict.restriction,\n                page;\n\n            if (!restriction) {\n                return status;\n            }\n\n            status = status || this.restrictStatus;\n\n            page = status.useStatusXY\n                    ? page = { x: status.x, y: status.y }\n                    : page = extend({}, pageCoords);\n\n            if (status.snap && status.snap.locked) {\n                page.x += status.snap.dx || 0;\n                page.y += status.snap.dy || 0;\n            }\n\n            page.x -= this.inertiaStatus.resumeDx;\n            page.y -= this.inertiaStatus.resumeDy;\n\n            status.dx = 0;\n            status.dy = 0;\n            status.restricted = false;\n\n            var rect, restrictedX, restrictedY;\n\n            if (isString(restriction)) {\n                if (restriction === 'parent') {\n                    restriction = parentElement(this.element);\n                }\n                else if (restriction === 'self') {\n                    restriction = target.getRect(this.element);\n                }\n                else {\n                    restriction = closest(this.element, restriction);\n                }\n\n                if (!restriction) { return status; }\n            }\n\n            if (isFunction(restriction)) {\n                restriction = restriction(page.x, page.y, this.element);\n            }\n\n            if (isElement(restriction)) {\n                restriction = getElementRect(restriction);\n            }\n\n            rect = restriction;\n\n            if (!restriction) {\n                restrictedX = page.x;\n                restrictedY = page.y;\n            }\n            // object is assumed to have\n            // x, y, width, height or\n            // left, top, right, bottom\n            else if ('x' in restriction && 'y' in restriction) {\n                restrictedX = Math.max(Math.min(rect.x + rect.width  - this.restrictOffset.right , page.x), rect.x + this.restrictOffset.left);\n                restrictedY = Math.max(Math.min(rect.y + rect.height - this.restrictOffset.bottom, page.y), rect.y + this.restrictOffset.top );\n            }\n            else {\n                restrictedX = Math.max(Math.min(rect.right  - this.restrictOffset.right , page.x), rect.left + this.restrictOffset.left);\n                restrictedY = Math.max(Math.min(rect.bottom - this.restrictOffset.bottom, page.y), rect.top  + this.restrictOffset.top );\n            }\n\n            status.dx = restrictedX - page.x;\n            status.dy = restrictedY - page.y;\n\n            status.changed = status.restrictedX !== restrictedX || status.restrictedY !== restrictedY;\n            status.restricted = !!(status.dx || status.dy);\n\n            status.restrictedX = restrictedX;\n            status.restrictedY = restrictedY;\n\n            return status;\n        },\n\n        checkAndPreventDefault: function (event, interactable, element) {\n            if (!(interactable = interactable || this.target)) { return; }\n\n            var options = interactable.options,\n                prevent = options.preventDefault;\n\n            if (prevent === 'auto' && element && !/^(input|select|textarea)$/i.test(event.target.nodeName)) {\n                // do not preventDefault on pointerdown if the prepared action is a drag\n                // and dragging can only start from a certain direction - this allows\n                // a touch to pan the viewport if a drag isn't in the right direction\n                if (/down|start/i.test(event.type)\n                    && this.prepared.name === 'drag' && options.drag.axis !== 'xy') {\n\n                    return;\n                }\n\n                // with manualStart, only preventDefault while interacting\n                if (options[this.prepared.name] && options[this.prepared.name].manualStart\n                    && !this.interacting()) {\n                    return;\n                }\n\n                event.preventDefault();\n                return;\n            }\n\n            if (prevent === 'always') {\n                event.preventDefault();\n                return;\n            }\n        },\n\n        calcInertia: function (status) {\n            var inertiaOptions = this.target.options[this.prepared.name].inertia,\n                lambda = inertiaOptions.resistance,\n                inertiaDur = -Math.log(inertiaOptions.endSpeed / status.v0) / lambda;\n\n            status.x0 = this.prevEvent.pageX;\n            status.y0 = this.prevEvent.pageY;\n            status.t0 = status.startEvent.timeStamp / 1000;\n            status.sx = status.sy = 0;\n\n            status.modifiedXe = status.xe = (status.vx0 - inertiaDur) / lambda;\n            status.modifiedYe = status.ye = (status.vy0 - inertiaDur) / lambda;\n            status.te = inertiaDur;\n\n            status.lambda_v0 = lambda / status.v0;\n            status.one_ve_v0 = 1 - inertiaOptions.endSpeed / status.v0;\n        },\n\n        autoScrollMove: function (pointer) {\n            if (!(this.interacting()\n                && checkAutoScroll(this.target, this.prepared.name))) {\n                return;\n            }\n\n            if (this.inertiaStatus.active) {\n                autoScroll.x = autoScroll.y = 0;\n                return;\n            }\n\n            var top,\n                right,\n                bottom,\n                left,\n                options = this.target.options[this.prepared.name].autoScroll,\n                container = options.container || getWindow(this.element);\n\n            if (isWindow(container)) {\n                left   = pointer.clientX < autoScroll.margin;\n                top    = pointer.clientY < autoScroll.margin;\n                right  = pointer.clientX > container.innerWidth  - autoScroll.margin;\n                bottom = pointer.clientY > container.innerHeight - autoScroll.margin;\n            }\n            else {\n                var rect = getElementClientRect(container);\n\n                left   = pointer.clientX < rect.left   + autoScroll.margin;\n                top    = pointer.clientY < rect.top    + autoScroll.margin;\n                right  = pointer.clientX > rect.right  - autoScroll.margin;\n                bottom = pointer.clientY > rect.bottom - autoScroll.margin;\n            }\n\n            autoScroll.x = (right ? 1: left? -1: 0);\n            autoScroll.y = (bottom? 1:  top? -1: 0);\n\n            if (!autoScroll.isScrolling) {\n                // set the autoScroll properties to those of the target\n                autoScroll.margin = options.margin;\n                autoScroll.speed  = options.speed;\n\n                autoScroll.start(this);\n            }\n        },\n\n        _updateEventTargets: function (target, currentTarget) {\n            this._eventTarget    = target;\n            this._curEventTarget = currentTarget;\n        }\n\n    };\n\n    function getInteractionFromPointer (pointer, eventType, eventTarget) {\n        var i = 0, len = interactions.length,\n            mouseEvent = (/mouse/i.test(pointer.pointerType || eventType)\n                          // MSPointerEvent.MSPOINTER_TYPE_MOUSE\n                          || pointer.pointerType === 4),\n            interaction;\n\n        var id = getPointerId(pointer);\n\n        // try to resume inertia with a new pointer\n        if (/down|start/i.test(eventType)) {\n            for (i = 0; i < len; i++) {\n                interaction = interactions[i];\n\n                var element = eventTarget;\n\n                if (interaction.inertiaStatus.active && interaction.target.options[interaction.prepared.name].inertia.allowResume\n                    && (interaction.mouse === mouseEvent)) {\n                    while (element) {\n                        // if the element is the interaction element\n                        if (element === interaction.element) {\n                            return interaction;\n                        }\n                        element = parentElement(element);\n                    }\n                }\n            }\n        }\n\n        // if it's a mouse interaction\n        if (mouseEvent || !(supportsTouch || supportsPointerEvent)) {\n\n            // find a mouse interaction that's not in inertia phase\n            for (i = 0; i < len; i++) {\n                if (interactions[i].mouse && !interactions[i].inertiaStatus.active) {\n                    return interactions[i];\n                }\n            }\n\n            // find any interaction specifically for mouse.\n            // if the eventType is a mousedown, and inertia is active\n            // ignore the interaction\n            for (i = 0; i < len; i++) {\n                if (interactions[i].mouse && !(/down/.test(eventType) && interactions[i].inertiaStatus.active)) {\n                    return interaction;\n                }\n            }\n\n            // create a new interaction for mouse\n            interaction = new Interaction();\n            interaction.mouse = true;\n\n            return interaction;\n        }\n\n        // get interaction that has this pointer\n        for (i = 0; i < len; i++) {\n            if (contains(interactions[i].pointerIds, id)) {\n                return interactions[i];\n            }\n        }\n\n        // at this stage, a pointerUp should not return an interaction\n        if (/up|end|out/i.test(eventType)) {\n            return null;\n        }\n\n        // get first idle interaction\n        for (i = 0; i < len; i++) {\n            interaction = interactions[i];\n\n            if ((!interaction.prepared.name || (interaction.target.options.gesture.enabled))\n                && !interaction.interacting()\n                && !(!mouseEvent && interaction.mouse)) {\n\n                return interaction;\n            }\n        }\n\n        return new Interaction();\n    }\n\n    function doOnInteractions (method) {\n        return (function (event) {\n            var interaction,\n                eventTarget = getActualElement(event.path\n                                               ? event.path[0]\n                                               : event.target),\n                curEventTarget = getActualElement(event.currentTarget),\n                i;\n\n            if (supportsTouch && /touch/.test(event.type)) {\n                prevTouchTime = new Date().getTime();\n\n                for (i = 0; i < event.changedTouches.length; i++) {\n                    var pointer = event.changedTouches[i];\n\n                    interaction = getInteractionFromPointer(pointer, event.type, eventTarget);\n\n                    if (!interaction) { continue; }\n\n                    interaction._updateEventTargets(eventTarget, curEventTarget);\n\n                    interaction[method](pointer, event, eventTarget, curEventTarget);\n                }\n            }\n            else {\n                if (!supportsPointerEvent && /mouse/.test(event.type)) {\n                    // ignore mouse events while touch interactions are active\n                    for (i = 0; i < interactions.length; i++) {\n                        if (!interactions[i].mouse && interactions[i].pointerIsDown) {\n                            return;\n                        }\n                    }\n\n                    // try to ignore mouse events that are simulated by the browser\n                    // after a touch event\n                    if (new Date().getTime() - prevTouchTime < 500) {\n                        return;\n                    }\n                }\n\n                interaction = getInteractionFromPointer(event, event.type, eventTarget);\n\n                if (!interaction) { return; }\n\n                interaction._updateEventTargets(eventTarget, curEventTarget);\n\n                interaction[method](event, event, eventTarget, curEventTarget);\n            }\n        });\n    }\n\n    function InteractEvent (interaction, event, action, phase, element, related) {\n        var client,\n            page,\n            target      = interaction.target,\n            snapStatus  = interaction.snapStatus,\n            restrictStatus  = interaction.restrictStatus,\n            pointers    = interaction.pointers,\n            deltaSource = (target && target.options || defaultOptions).deltaSource,\n            sourceX     = deltaSource + 'X',\n            sourceY     = deltaSource + 'Y',\n            options     = target? target.options: defaultOptions,\n            origin      = getOriginXY(target, element),\n            starting    = phase === 'start',\n            ending      = phase === 'end',\n            coords      = starting? interaction.startCoords : interaction.curCoords;\n\n        element = element || interaction.element;\n\n        page   = extend({}, coords.page);\n        client = extend({}, coords.client);\n\n        page.x -= origin.x;\n        page.y -= origin.y;\n\n        client.x -= origin.x;\n        client.y -= origin.y;\n\n        var relativePoints = options[action].snap && options[action].snap.relativePoints ;\n\n        if (checkSnap(target, action) && !(starting && relativePoints && relativePoints.length)) {\n            this.snap = {\n                range  : snapStatus.range,\n                locked : snapStatus.locked,\n                x      : snapStatus.snappedX,\n                y      : snapStatus.snappedY,\n                realX  : snapStatus.realX,\n                realY  : snapStatus.realY,\n                dx     : snapStatus.dx,\n                dy     : snapStatus.dy\n            };\n\n            if (snapStatus.locked) {\n                page.x += snapStatus.dx;\n                page.y += snapStatus.dy;\n                client.x += snapStatus.dx;\n                client.y += snapStatus.dy;\n            }\n        }\n\n        if (checkRestrict(target, action) && !(starting && options[action].restrict.elementRect) && restrictStatus.restricted) {\n            page.x += restrictStatus.dx;\n            page.y += restrictStatus.dy;\n            client.x += restrictStatus.dx;\n            client.y += restrictStatus.dy;\n\n            this.restrict = {\n                dx: restrictStatus.dx,\n                dy: restrictStatus.dy\n            };\n        }\n\n        this.pageX     = page.x;\n        this.pageY     = page.y;\n        this.clientX   = client.x;\n        this.clientY   = client.y;\n\n        this.x0        = interaction.startCoords.page.x - origin.x;\n        this.y0        = interaction.startCoords.page.y - origin.y;\n        this.clientX0  = interaction.startCoords.client.x - origin.x;\n        this.clientY0  = interaction.startCoords.client.y - origin.y;\n        this.ctrlKey   = event.ctrlKey;\n        this.altKey    = event.altKey;\n        this.shiftKey  = event.shiftKey;\n        this.metaKey   = event.metaKey;\n        this.button    = event.button;\n        this.buttons   = event.buttons;\n        this.target    = element;\n        this.t0        = interaction.downTimes[0];\n        this.type      = action + (phase || '');\n\n        this.interaction = interaction;\n        this.interactable = target;\n\n        var inertiaStatus = interaction.inertiaStatus;\n\n        if (inertiaStatus.active) {\n            this.detail = 'inertia';\n        }\n\n        if (related) {\n            this.relatedTarget = related;\n        }\n\n        // end event dx, dy is difference between start and end points\n        if (ending) {\n            if (deltaSource === 'client') {\n                this.dx = client.x - interaction.startCoords.client.x;\n                this.dy = client.y - interaction.startCoords.client.y;\n            }\n            else {\n                this.dx = page.x - interaction.startCoords.page.x;\n                this.dy = page.y - interaction.startCoords.page.y;\n            }\n        }\n        else if (starting) {\n            this.dx = 0;\n            this.dy = 0;\n        }\n        // copy properties from previousmove if starting inertia\n        else if (phase === 'inertiastart') {\n            this.dx = interaction.prevEvent.dx;\n            this.dy = interaction.prevEvent.dy;\n        }\n        else {\n            if (deltaSource === 'client') {\n                this.dx = client.x - interaction.prevEvent.clientX;\n                this.dy = client.y - interaction.prevEvent.clientY;\n            }\n            else {\n                this.dx = page.x - interaction.prevEvent.pageX;\n                this.dy = page.y - interaction.prevEvent.pageY;\n            }\n        }\n        if (interaction.prevEvent && interaction.prevEvent.detail === 'inertia'\n            && !inertiaStatus.active\n            && options[action].inertia && options[action].inertia.zeroResumeDelta) {\n\n            inertiaStatus.resumeDx += this.dx;\n            inertiaStatus.resumeDy += this.dy;\n\n            this.dx = this.dy = 0;\n        }\n\n        if (action === 'resize' && interaction.resizeAxes) {\n            if (options.resize.square) {\n                if (interaction.resizeAxes === 'y') {\n                    this.dx = this.dy;\n                }\n                else {\n                    this.dy = this.dx;\n                }\n                this.axes = 'xy';\n            }\n            else {\n                this.axes = interaction.resizeAxes;\n\n                if (interaction.resizeAxes === 'x') {\n                    this.dy = 0;\n                }\n                else if (interaction.resizeAxes === 'y') {\n                    this.dx = 0;\n                }\n            }\n        }\n        else if (action === 'gesture') {\n            this.touches = [pointers[0], pointers[1]];\n\n            if (starting) {\n                this.distance = touchDistance(pointers, deltaSource);\n                this.box      = touchBBox(pointers);\n                this.scale    = 1;\n                this.ds       = 0;\n                this.angle    = touchAngle(pointers, undefined, deltaSource);\n                this.da       = 0;\n            }\n            else if (ending || event instanceof InteractEvent) {\n                this.distance = interaction.prevEvent.distance;\n                this.box      = interaction.prevEvent.box;\n                this.scale    = interaction.prevEvent.scale;\n                this.ds       = this.scale - 1;\n                this.angle    = interaction.prevEvent.angle;\n                this.da       = this.angle - interaction.gesture.startAngle;\n            }\n            else {\n                this.distance = touchDistance(pointers, deltaSource);\n                this.box      = touchBBox(pointers);\n                this.scale    = this.distance / interaction.gesture.startDistance;\n                this.angle    = touchAngle(pointers, interaction.gesture.prevAngle, deltaSource);\n\n                this.ds = this.scale - interaction.gesture.prevScale;\n                this.da = this.angle - interaction.gesture.prevAngle;\n            }\n        }\n\n        if (starting) {\n            this.timeStamp = interaction.downTimes[0];\n            this.dt        = 0;\n            this.duration  = 0;\n            this.speed     = 0;\n            this.velocityX = 0;\n            this.velocityY = 0;\n        }\n        else if (phase === 'inertiastart') {\n            this.timeStamp = interaction.prevEvent.timeStamp;\n            this.dt        = interaction.prevEvent.dt;\n            this.duration  = interaction.prevEvent.duration;\n            this.speed     = interaction.prevEvent.speed;\n            this.velocityX = interaction.prevEvent.velocityX;\n            this.velocityY = interaction.prevEvent.velocityY;\n        }\n        else {\n            this.timeStamp = new Date().getTime();\n            this.dt        = this.timeStamp - interaction.prevEvent.timeStamp;\n            this.duration  = this.timeStamp - interaction.downTimes[0];\n\n            if (event instanceof InteractEvent) {\n                var dx = this[sourceX] - interaction.prevEvent[sourceX],\n                    dy = this[sourceY] - interaction.prevEvent[sourceY],\n                    dt = this.dt / 1000;\n\n                this.speed = hypot(dx, dy) / dt;\n                this.velocityX = dx / dt;\n                this.velocityY = dy / dt;\n            }\n            // if normal move or end event, use previous user event coords\n            else {\n                // speed and velocity in pixels per second\n                this.speed = interaction.pointerDelta[deltaSource].speed;\n                this.velocityX = interaction.pointerDelta[deltaSource].vx;\n                this.velocityY = interaction.pointerDelta[deltaSource].vy;\n            }\n        }\n\n        if ((ending || phase === 'inertiastart')\n            && interaction.prevEvent.speed > 600 && this.timeStamp - interaction.prevEvent.timeStamp < 150) {\n\n            var angle = 180 * Math.atan2(interaction.prevEvent.velocityY, interaction.prevEvent.velocityX) / Math.PI,\n                overlap = 22.5;\n\n            if (angle < 0) {\n                angle += 360;\n            }\n\n            var left = 135 - overlap <= angle && angle < 225 + overlap,\n                up   = 225 - overlap <= angle && angle < 315 + overlap,\n\n                right = !left && (315 - overlap <= angle || angle <  45 + overlap),\n                down  = !up   &&   45 - overlap <= angle && angle < 135 + overlap;\n\n            this.swipe = {\n                up   : up,\n                down : down,\n                left : left,\n                right: right,\n                angle: angle,\n                speed: interaction.prevEvent.speed,\n                velocity: {\n                    x: interaction.prevEvent.velocityX,\n                    y: interaction.prevEvent.velocityY\n                }\n            };\n        }\n    }\n\n    InteractEvent.prototype = {\n        preventDefault: blank,\n        stopImmediatePropagation: function () {\n            this.immediatePropagationStopped = this.propagationStopped = true;\n        },\n        stopPropagation: function () {\n            this.propagationStopped = true;\n        }\n    };\n\n    function preventOriginalDefault () {\n        this.originalEvent.preventDefault();\n    }\n\n    function getActionCursor (action) {\n        var cursor = '';\n\n        if (action.name === 'drag') {\n            cursor =  actionCursors.drag;\n        }\n        if (action.name === 'resize') {\n            if (action.axis) {\n                cursor =  actionCursors[action.name + action.axis];\n            }\n            else if (action.edges) {\n                var cursorKey = 'resize',\n                    edgeNames = ['top', 'bottom', 'left', 'right'];\n\n                for (var i = 0; i < 4; i++) {\n                    if (action.edges[edgeNames[i]]) {\n                        cursorKey += edgeNames[i];\n                    }\n                }\n\n                cursor = actionCursors[cursorKey];\n            }\n        }\n\n        return cursor;\n    }\n\n    function checkResizeEdge (name, value, page, element, interactableElement, rect, margin) {\n        // false, '', undefined, null\n        if (!value) { return false; }\n\n        // true value, use pointer coords and element rect\n        if (value === true) {\n            // if dimensions are negative, \"switch\" edges\n            var width = isNumber(rect.width)? rect.width : rect.right - rect.left,\n                height = isNumber(rect.height)? rect.height : rect.bottom - rect.top;\n\n            if (width < 0) {\n                if      (name === 'left' ) { name = 'right'; }\n                else if (name === 'right') { name = 'left' ; }\n            }\n            if (height < 0) {\n                if      (name === 'top'   ) { name = 'bottom'; }\n                else if (name === 'bottom') { name = 'top'   ; }\n            }\n\n            if (name === 'left'  ) { return page.x < ((width  >= 0? rect.left: rect.right ) + margin); }\n            if (name === 'top'   ) { return page.y < ((height >= 0? rect.top : rect.bottom) + margin); }\n\n            if (name === 'right' ) { return page.x > ((width  >= 0? rect.right : rect.left) - margin); }\n            if (name === 'bottom') { return page.y > ((height >= 0? rect.bottom: rect.top ) - margin); }\n        }\n\n        // the remaining checks require an element\n        if (!isElement(element)) { return false; }\n\n        return isElement(value)\n                    // the value is an element to use as a resize handle\n                    ? value === element\n                    // otherwise check if element matches value as selector\n                    : matchesUpTo(element, value, interactableElement);\n    }\n\n    function defaultActionChecker (pointer, interaction, element) {\n        var rect = this.getRect(element),\n            shouldResize = false,\n            action = null,\n            resizeAxes = null,\n            resizeEdges,\n            page = extend({}, interaction.curCoords.page),\n            options = this.options;\n\n        if (!rect) { return null; }\n\n        if (actionIsEnabled.resize && options.resize.enabled) {\n            var resizeOptions = options.resize;\n\n            resizeEdges = {\n                left: false, right: false, top: false, bottom: false\n            };\n\n            // if using resize.edges\n            if (isObject(resizeOptions.edges)) {\n                for (var edge in resizeEdges) {\n                    resizeEdges[edge] = checkResizeEdge(edge,\n                                                        resizeOptions.edges[edge],\n                                                        page,\n                                                        interaction._eventTarget,\n                                                        element,\n                                                        rect,\n                                                        resizeOptions.margin || margin);\n                }\n\n                resizeEdges.left = resizeEdges.left && !resizeEdges.right;\n                resizeEdges.top  = resizeEdges.top  && !resizeEdges.bottom;\n\n                shouldResize = resizeEdges.left || resizeEdges.right || resizeEdges.top || resizeEdges.bottom;\n            }\n            else {\n                var right  = options.resize.axis !== 'y' && page.x > (rect.right  - margin),\n                    bottom = options.resize.axis !== 'x' && page.y > (rect.bottom - margin);\n\n                shouldResize = right || bottom;\n                resizeAxes = (right? 'x' : '') + (bottom? 'y' : '');\n            }\n        }\n\n        action = shouldResize\n            ? 'resize'\n            : actionIsEnabled.drag && options.drag.enabled\n                ? 'drag'\n                : null;\n\n        if (actionIsEnabled.gesture\n            && interaction.pointerIds.length >=2\n            && !(interaction.dragging || interaction.resizing)) {\n            action = 'gesture';\n        }\n\n        if (action) {\n            return {\n                name: action,\n                axis: resizeAxes,\n                edges: resizeEdges\n            };\n        }\n\n        return null;\n    }\n\n    // Check if action is enabled globally and the current target supports it\n    // If so, return the validated action. Otherwise, return null\n    function validateAction (action, interactable) {\n        if (!isObject(action)) { return null; }\n\n        var actionName = action.name,\n            options = interactable.options;\n\n        if ((  (actionName  === 'resize'   && options.resize.enabled )\n            || (actionName      === 'drag'     && options.drag.enabled  )\n            || (actionName      === 'gesture'  && options.gesture.enabled))\n            && actionIsEnabled[actionName]) {\n\n            if (actionName === 'resize' || actionName === 'resizeyx') {\n                actionName = 'resizexy';\n            }\n\n            return action;\n        }\n        return null;\n    }\n\n    var listeners = {},\n        interactionListeners = [\n            'dragStart', 'dragMove', 'resizeStart', 'resizeMove', 'gestureStart', 'gestureMove',\n            'pointerOver', 'pointerOut', 'pointerHover', 'selectorDown',\n            'pointerDown', 'pointerMove', 'pointerUp', 'pointerCancel', 'pointerEnd',\n            'addPointer', 'removePointer', 'recordPointer', 'autoScrollMove'\n        ];\n\n    for (var i = 0, len = interactionListeners.length; i < len; i++) {\n        var name = interactionListeners[i];\n\n        listeners[name] = doOnInteractions(name);\n    }\n\n    // bound to the interactable context when a DOM event\n    // listener is added to a selector interactable\n    function delegateListener (event, useCapture) {\n        var fakeEvent = {},\n            delegated = delegatedEvents[event.type],\n            eventTarget = getActualElement(event.path\n                                           ? event.path[0]\n                                           : event.target),\n            element = eventTarget;\n\n        useCapture = useCapture? true: false;\n\n        // duplicate the event so that currentTarget can be changed\n        for (var prop in event) {\n            fakeEvent[prop] = event[prop];\n        }\n\n        fakeEvent.originalEvent = event;\n        fakeEvent.preventDefault = preventOriginalDefault;\n\n        // climb up document tree looking for selector matches\n        while (isElement(element)) {\n            for (var i = 0; i < delegated.selectors.length; i++) {\n                var selector = delegated.selectors[i],\n                    context = delegated.contexts[i];\n\n                if (matchesSelector(element, selector)\n                    && nodeContains(context, eventTarget)\n                    && nodeContains(context, element)) {\n\n                    var listeners = delegated.listeners[i];\n\n                    fakeEvent.currentTarget = element;\n\n                    for (var j = 0; j < listeners.length; j++) {\n                        if (listeners[j][1] === useCapture) {\n                            listeners[j][0](fakeEvent);\n                        }\n                    }\n                }\n            }\n\n            element = parentElement(element);\n        }\n    }\n\n    function delegateUseCapture (event) {\n        return delegateListener.call(this, event, true);\n    }\n\n    interactables.indexOfElement = function indexOfElement (element, context) {\n        context = context || document;\n\n        for (var i = 0; i < this.length; i++) {\n            var interactable = this[i];\n\n            if ((interactable.selector === element\n                && (interactable._context === context))\n                || (!interactable.selector && interactable._element === element)) {\n\n                return i;\n            }\n        }\n        return -1;\n    };\n\n    interactables.get = function interactableGet (element, options) {\n        return this[this.indexOfElement(element, options && options.context)];\n    };\n\n    interactables.forEachSelector = function (callback) {\n        for (var i = 0; i < this.length; i++) {\n            var interactable = this[i];\n\n            if (!interactable.selector) {\n                continue;\n            }\n\n            var ret = callback(interactable, interactable.selector, interactable._context, i, this);\n\n            if (ret !== undefined) {\n                return ret;\n            }\n        }\n    };\n\n    /*\\\n     * interact\n     [ method ]\n     *\n     * The methods of this variable can be used to set elements as\n     * interactables and also to change various default settings.\n     *\n     * Calling it as a function and passing an element or a valid CSS selector\n     * string returns an Interactable object which has various methods to\n     * configure it.\n     *\n     - element (Element | string) The HTML or SVG Element to interact with or CSS selector\n     = (object) An @Interactable\n     *\n     > Usage\n     | interact(document.getElementById('draggable')).draggable(true);\n     |\n     | var rectables = interact('rect');\n     | rectables\n     |     .gesturable(true)\n     |     .on('gesturemove', function (event) {\n     |         // something cool...\n     |     })\n     |     .autoScroll(true);\n    \\*/\n    function interact (element, options) {\n        return interactables.get(element, options) || new Interactable(element, options);\n    }\n\n    /*\\\n     * Interactable\n     [ property ]\n     **\n     * Object type returned by @interact\n    \\*/\n    function Interactable (element, options) {\n        this._element = element;\n        this._iEvents = this._iEvents || {};\n\n        var _window;\n\n        if (trySelector(element)) {\n            this.selector = element;\n\n            var context = options && options.context;\n\n            _window = context? getWindow(context) : window;\n\n            if (context && (_window.Node\n                    ? context instanceof _window.Node\n                    : (isElement(context) || context === _window.document))) {\n\n                this._context = context;\n            }\n        }\n        else {\n            _window = getWindow(element);\n\n            if (isElement(element, _window)) {\n\n                if (supportsPointerEvent) {\n                    events.add(this._element, pEventTypes.down, listeners.pointerDown );\n                    events.add(this._element, pEventTypes.move, listeners.pointerHover);\n                }\n                else {\n                    events.add(this._element, 'mousedown' , listeners.pointerDown );\n                    events.add(this._element, 'mousemove' , listeners.pointerHover);\n                    events.add(this._element, 'touchstart', listeners.pointerDown );\n                    events.add(this._element, 'touchmove' , listeners.pointerHover);\n                }\n            }\n        }\n\n        this._doc = _window.document;\n\n        if (!contains(documents, this._doc)) {\n            listenToDocument(this._doc);\n        }\n\n        interactables.push(this);\n\n        this.set(options);\n    }\n\n    Interactable.prototype = {\n        setOnEvents: function (action, phases) {\n            if (action === 'drop') {\n                if (isFunction(phases.ondrop)          ) { this.ondrop           = phases.ondrop          ; }\n                if (isFunction(phases.ondropactivate)  ) { this.ondropactivate   = phases.ondropactivate  ; }\n                if (isFunction(phases.ondropdeactivate)) { this.ondropdeactivate = phases.ondropdeactivate; }\n                if (isFunction(phases.ondragenter)     ) { this.ondragenter      = phases.ondragenter     ; }\n                if (isFunction(phases.ondragleave)     ) { this.ondragleave      = phases.ondragleave     ; }\n                if (isFunction(phases.ondropmove)      ) { this.ondropmove       = phases.ondropmove      ; }\n            }\n            else {\n                action = 'on' + action;\n\n                if (isFunction(phases.onstart)       ) { this[action + 'start'         ] = phases.onstart         ; }\n                if (isFunction(phases.onmove)        ) { this[action + 'move'          ] = phases.onmove          ; }\n                if (isFunction(phases.onend)         ) { this[action + 'end'           ] = phases.onend           ; }\n                if (isFunction(phases.oninertiastart)) { this[action + 'inertiastart'  ] = phases.oninertiastart  ; }\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.draggable\n         [ method ]\n         *\n         * Gets or sets whether drag actions can be performed on the\n         * Interactable\n         *\n         = (boolean) Indicates if this can be the target of drag events\n         | var isDraggable = interact('ul li').draggable();\n         * or\n         - options (boolean | object) #optional true/false or An object with event listeners to be fired on drag events (object makes the Interactable draggable)\n         = (object) This Interactable\n         | interact(element).draggable({\n         |     onstart: function (event) {},\n         |     onmove : function (event) {},\n         |     onend  : function (event) {},\n         |\n         |     // the axis in which the first movement must be\n         |     // for the drag sequence to start\n         |     // 'xy' by default - any direction\n         |     axis: 'x' || 'y' || 'xy',\n         |\n         |     // max number of drags that can happen concurrently\n         |     // with elements of this Interactable. Infinity by default\n         |     max: Infinity,\n         |\n         |     // max number of drags that can target the same element+Interactable\n         |     // 1 by default\n         |     maxPerElement: 2\n         | });\n        \\*/\n        draggable: function (options) {\n            if (isObject(options)) {\n                this.options.drag.enabled = options.enabled === false? false: true;\n                this.setPerAction('drag', options);\n                this.setOnEvents('drag', options);\n\n                if (/^x$|^y$|^xy$/.test(options.axis)) {\n                    this.options.drag.axis = options.axis;\n                }\n                else if (options.axis === null) {\n                    delete this.options.drag.axis;\n                }\n\n                return this;\n            }\n\n            if (isBool(options)) {\n                this.options.drag.enabled = options;\n\n                return this;\n            }\n\n            return this.options.drag;\n        },\n\n        setPerAction: function (action, options) {\n            // for all the default per-action options\n            for (var option in options) {\n                // if this option exists for this action\n                if (option in defaultOptions[action]) {\n                    // if the option in the options arg is an object value\n                    if (isObject(options[option])) {\n                        // duplicate the object\n                        this.options[action][option] = extend(this.options[action][option] || {}, options[option]);\n\n                        if (isObject(defaultOptions.perAction[option]) && 'enabled' in defaultOptions.perAction[option]) {\n                            this.options[action][option].enabled = options[option].enabled === false? false : true;\n                        }\n                    }\n                    else if (isBool(options[option]) && isObject(defaultOptions.perAction[option])) {\n                        this.options[action][option].enabled = options[option];\n                    }\n                    else if (options[option] !== undefined) {\n                        // or if it's not undefined, do a plain assignment\n                        this.options[action][option] = options[option];\n                    }\n                }\n            }\n        },\n\n        /*\\\n         * Interactable.dropzone\n         [ method ]\n         *\n         * Returns or sets whether elements can be dropped onto this\n         * Interactable to trigger drop events\n         *\n         * Dropzones can receive the following events:\n         *  - `dropactivate` and `dropdeactivate` when an acceptable drag starts and ends\n         *  - `dragenter` and `dragleave` when a draggable enters and leaves the dropzone\n         *  - `dragmove` when a draggable that has entered the dropzone is moved\n         *  - `drop` when a draggable is dropped into this dropzone\n         *\n         *  Use the `accept` option to allow only elements that match the given CSS selector or element.\n         *\n         *  Use the `overlap` option to set how drops are checked for. The allowed values are:\n         *   - `'pointer'`, the pointer must be over the dropzone (default)\n         *   - `'center'`, the draggable element's center must be over the dropzone\n         *   - a number from 0-1 which is the `(intersection area) / (draggable area)`.\n         *       e.g. `0.5` for drop to happen when half of the area of the\n         *       draggable is over the dropzone\n         *\n         - options (boolean | object | null) #optional The new value to be set.\n         | interact('.drop').dropzone({\n         |   accept: '.can-drop' || document.getElementById('single-drop'),\n         |   overlap: 'pointer' || 'center' || zeroToOne\n         | }\n         = (boolean | object) The current setting or this Interactable\n        \\*/\n        dropzone: function (options) {\n            if (isObject(options)) {\n                this.options.drop.enabled = options.enabled === false? false: true;\n                this.setOnEvents('drop', options);\n\n                if (/^(pointer|center)$/.test(options.overlap)) {\n                    this.options.drop.overlap = options.overlap;\n                }\n                else if (isNumber(options.overlap)) {\n                    this.options.drop.overlap = Math.max(Math.min(1, options.overlap), 0);\n                }\n                if ('accept' in options) {\n                  this.options.drop.accept = options.accept;\n                }\n                if ('checker' in options) {\n                  this.options.drop.checker = options.checker;\n                }\n\n                return this;\n            }\n\n            if (isBool(options)) {\n                this.options.drop.enabled = options;\n\n                return this;\n            }\n\n            return this.options.drop;\n        },\n\n        dropCheck: function (dragEvent, event, draggable, draggableElement, dropElement, rect) {\n            var dropped = false;\n\n            // if the dropzone has no rect (eg. display: none)\n            // call the custom dropChecker or just return false\n            if (!(rect = rect || this.getRect(dropElement))) {\n                return (this.options.drop.checker\n                    ? this.options.drop.checker(dragEvent, event, dropped, this, dropElement, draggable, draggableElement)\n                    : false);\n            }\n\n            var dropOverlap = this.options.drop.overlap;\n\n            if (dropOverlap === 'pointer') {\n                var page = getPageXY(dragEvent),\n                    origin = getOriginXY(draggable, draggableElement),\n                    horizontal,\n                    vertical;\n\n                page.x += origin.x;\n                page.y += origin.y;\n\n                horizontal = (page.x > rect.left) && (page.x < rect.right);\n                vertical   = (page.y > rect.top ) && (page.y < rect.bottom);\n\n                dropped = horizontal && vertical;\n            }\n\n            var dragRect = draggable.getRect(draggableElement);\n\n            if (dropOverlap === 'center') {\n                var cx = dragRect.left + dragRect.width  / 2,\n                    cy = dragRect.top  + dragRect.height / 2;\n\n                dropped = cx >= rect.left && cx <= rect.right && cy >= rect.top && cy <= rect.bottom;\n            }\n\n            if (isNumber(dropOverlap)) {\n                var overlapArea  = (Math.max(0, Math.min(rect.right , dragRect.right ) - Math.max(rect.left, dragRect.left))\n                                  * Math.max(0, Math.min(rect.bottom, dragRect.bottom) - Math.max(rect.top , dragRect.top ))),\n                    overlapRatio = overlapArea / (dragRect.width * dragRect.height);\n\n                dropped = overlapRatio >= dropOverlap;\n            }\n\n            if (this.options.drop.checker) {\n                dropped = this.options.drop.checker(dragEvent, event, dropped, this, dropElement, draggable, draggableElement);\n            }\n\n            return dropped;\n        },\n\n        /*\\\n         * Interactable.dropChecker\n         [ method ]\n         *\n         * DEPRECATED. Use interactable.dropzone({ checker: function... }) instead.\n         *\n         * Gets or sets the function used to check if a dragged element is\n         * over this Interactable.\n         *\n         - checker (function) #optional The function that will be called when checking for a drop\n         = (Function | Interactable) The checker function or this Interactable\n         *\n         * The checker function takes the following arguments:\n         *\n         - dragEvent (InteractEvent) The related dragmove or dragend event\n         - event (TouchEvent | PointerEvent | MouseEvent) The user move/up/end Event related to the dragEvent\n         - dropped (boolean) The value from the default drop checker\n         - dropzone (Interactable) The dropzone interactable\n         - dropElement (Element) The dropzone element\n         - draggable (Interactable) The Interactable being dragged\n         - draggableElement (Element) The actual element that's being dragged\n         *\n         > Usage:\n         | interact(target)\n         | .dropChecker(function(dragEvent,         // related dragmove or dragend event\n         |                       event,             // TouchEvent/PointerEvent/MouseEvent\n         |                       dropped,           // bool result of the default checker\n         |                       dropzone,          // dropzone Interactable\n         |                       dropElement,       // dropzone elemnt\n         |                       draggable,         // draggable Interactable\n         |                       draggableElement) {// draggable element\n         |\n         |   return dropped && event.target.hasAttribute('allow-drop');\n         | }\n        \\*/\n        dropChecker: function (checker) {\n            if (isFunction(checker)) {\n                this.options.drop.checker = checker;\n\n                return this;\n            }\n            if (checker === null) {\n                delete this.options.getRect;\n\n                return this;\n            }\n\n            return this.options.drop.checker;\n        },\n\n        /*\\\n         * Interactable.accept\n         [ method ]\n         *\n         * Deprecated. add an `accept` property to the options object passed to\n         * @Interactable.dropzone instead.\n         *\n         * Gets or sets the Element or CSS selector match that this\n         * Interactable accepts if it is a dropzone.\n         *\n         - newValue (Element | string | null) #optional\n         * If it is an Element, then only that element can be dropped into this dropzone.\n         * If it is a string, the element being dragged must match it as a selector.\n         * If it is null, the accept options is cleared - it accepts any element.\n         *\n         = (string | Element | null | Interactable) The current accept option if given `undefined` or this Interactable\n        \\*/\n        accept: function (newValue) {\n            if (isElement(newValue)) {\n                this.options.drop.accept = newValue;\n\n                return this;\n            }\n\n            // test if it is a valid CSS selector\n            if (trySelector(newValue)) {\n                this.options.drop.accept = newValue;\n\n                return this;\n            }\n\n            if (newValue === null) {\n                delete this.options.drop.accept;\n\n                return this;\n            }\n\n            return this.options.drop.accept;\n        },\n\n        /*\\\n         * Interactable.resizable\n         [ method ]\n         *\n         * Gets or sets whether resize actions can be performed on the\n         * Interactable\n         *\n         = (boolean) Indicates if this can be the target of resize elements\n         | var isResizeable = interact('input[type=text]').resizable();\n         * or\n         - options (boolean | object) #optional true/false or An object with event listeners to be fired on resize events (object makes the Interactable resizable)\n         = (object) This Interactable\n         | interact(element).resizable({\n         |     onstart: function (event) {},\n         |     onmove : function (event) {},\n         |     onend  : function (event) {},\n         |\n         |     edges: {\n         |       top   : true,       // Use pointer coords to check for resize.\n         |       left  : false,      // Disable resizing from left edge.\n         |       bottom: '.resize-s',// Resize if pointer target matches selector\n         |       right : handleEl    // Resize if pointer target is the given Element\n         |     },\n         |\n         |     // Width and height can be adjusted independently. When `true`, width and\n         |     // height are adjusted at a 1:1 ratio.\n         |     square: false,\n         |\n         |     // Width and height can be adjusted independently. When `true`, width and\n         |     // height maintain the aspect ratio they had when resizing started.\n         |     preserveAspectRatio: false,\n         |\n         |     // a value of 'none' will limit the resize rect to a minimum of 0x0\n         |     // 'negate' will allow the rect to have negative width/height\n         |     // 'reposition' will keep the width/height positive by swapping\n         |     // the top and bottom edges and/or swapping the left and right edges\n         |     invert: 'none' || 'negate' || 'reposition'\n         |\n         |     // limit multiple resizes.\n         |     // See the explanation in the @Interactable.draggable example\n         |     max: Infinity,\n         |     maxPerElement: 1,\n         | });\n        \\*/\n        resizable: function (options) {\n            if (isObject(options)) {\n                this.options.resize.enabled = options.enabled === false? false: true;\n                this.setPerAction('resize', options);\n                this.setOnEvents('resize', options);\n\n                if (/^x$|^y$|^xy$/.test(options.axis)) {\n                    this.options.resize.axis = options.axis;\n                }\n                else if (options.axis === null) {\n                    this.options.resize.axis = defaultOptions.resize.axis;\n                }\n\n                if (isBool(options.preserveAspectRatio)) {\n                    this.options.resize.preserveAspectRatio = options.preserveAspectRatio;\n                }\n                else if (isBool(options.square)) {\n                    this.options.resize.square = options.square;\n                }\n\n                return this;\n            }\n            if (isBool(options)) {\n                this.options.resize.enabled = options;\n\n                return this;\n            }\n            return this.options.resize;\n        },\n\n        /*\\\n         * Interactable.squareResize\n         [ method ]\n         *\n         * Deprecated. Add a `square: true || false` property to @Interactable.resizable instead\n         *\n         * Gets or sets whether resizing is forced 1:1 aspect\n         *\n         = (boolean) Current setting\n         *\n         * or\n         *\n         - newValue (boolean) #optional\n         = (object) this Interactable\n        \\*/\n        squareResize: function (newValue) {\n            if (isBool(newValue)) {\n                this.options.resize.square = newValue;\n\n                return this;\n            }\n\n            if (newValue === null) {\n                delete this.options.resize.square;\n\n                return this;\n            }\n\n            return this.options.resize.square;\n        },\n\n        /*\\\n         * Interactable.gesturable\n         [ method ]\n         *\n         * Gets or sets whether multitouch gestures can be performed on the\n         * Interactable's element\n         *\n         = (boolean) Indicates if this can be the target of gesture events\n         | var isGestureable = interact(element).gesturable();\n         * or\n         - options (boolean | object) #optional true/false or An object with event listeners to be fired on gesture events (makes the Interactable gesturable)\n         = (object) this Interactable\n         | interact(element).gesturable({\n         |     onstart: function (event) {},\n         |     onmove : function (event) {},\n         |     onend  : function (event) {},\n         |\n         |     // limit multiple gestures.\n         |     // See the explanation in @Interactable.draggable example\n         |     max: Infinity,\n         |     maxPerElement: 1,\n         | });\n        \\*/\n        gesturable: function (options) {\n            if (isObject(options)) {\n                this.options.gesture.enabled = options.enabled === false? false: true;\n                this.setPerAction('gesture', options);\n                this.setOnEvents('gesture', options);\n\n                return this;\n            }\n\n            if (isBool(options)) {\n                this.options.gesture.enabled = options;\n\n                return this;\n            }\n\n            return this.options.gesture;\n        },\n\n        /*\\\n         * Interactable.autoScroll\n         [ method ]\n         **\n         * Deprecated. Add an `autoscroll` property to the options object\n         * passed to @Interactable.draggable or @Interactable.resizable instead.\n         *\n         * Returns or sets whether dragging and resizing near the edges of the\n         * window/container trigger autoScroll for this Interactable\n         *\n         = (object) Object with autoScroll properties\n         *\n         * or\n         *\n         - options (object | boolean) #optional\n         * options can be:\n         * - an object with margin, distance and interval properties,\n         * - true or false to enable or disable autoScroll or\n         = (Interactable) this Interactable\n        \\*/\n        autoScroll: function (options) {\n            if (isObject(options)) {\n                options = extend({ actions: ['drag', 'resize']}, options);\n            }\n            else if (isBool(options)) {\n                options = { actions: ['drag', 'resize'], enabled: options };\n            }\n\n            return this.setOptions('autoScroll', options);\n        },\n\n        /*\\\n         * Interactable.snap\n         [ method ]\n         **\n         * Deprecated. Add a `snap` property to the options object passed\n         * to @Interactable.draggable or @Interactable.resizable instead.\n         *\n         * Returns or sets if and how action coordinates are snapped. By\n         * default, snapping is relative to the pointer coordinates. You can\n         * change this by setting the\n         * [`elementOrigin`](https://github.com/taye/interact.js/pull/72).\n         **\n         = (boolean | object) `false` if snap is disabled; object with snap properties if snap is enabled\n         **\n         * or\n         **\n         - options (object | boolean | null) #optional\n         = (Interactable) this Interactable\n         > Usage\n         | interact(document.querySelector('#thing')).snap({\n         |     targets: [\n         |         // snap to this specific point\n         |         {\n         |             x: 100,\n         |             y: 100,\n         |             range: 25\n         |         },\n         |         // give this function the x and y page coords and snap to the object returned\n         |         function (x, y) {\n         |             return {\n         |                 x: x,\n         |                 y: (75 + 50 * Math.sin(x * 0.04)),\n         |                 range: 40\n         |             };\n         |         },\n         |         // create a function that snaps to a grid\n         |         interact.createSnapGrid({\n         |             x: 50,\n         |             y: 50,\n         |             range: 10,              // optional\n         |             offset: { x: 5, y: 10 } // optional\n         |         })\n         |     ],\n         |     // do not snap during normal movement.\n         |     // Instead, trigger only one snapped move event\n         |     // immediately before the end event.\n         |     endOnly: true,\n         |\n         |     relativePoints: [\n         |         { x: 0, y: 0 },  // snap relative to the top left of the element\n         |         { x: 1, y: 1 },  // and also to the bottom right\n         |     ],  \n         |\n         |     // offset the snap target coordinates\n         |     // can be an object with x/y or 'startCoords'\n         |     offset: { x: 50, y: 50 }\n         |   }\n         | });\n        \\*/\n        snap: function (options) {\n            var ret = this.setOptions('snap', options);\n\n            if (ret === this) { return this; }\n\n            return ret.drag;\n        },\n\n        setOptions: function (option, options) {\n            var actions = options && isArray(options.actions)\n                    ? options.actions\n                    : ['drag'];\n\n            var i;\n\n            if (isObject(options) || isBool(options)) {\n                for (i = 0; i < actions.length; i++) {\n                    var action = /resize/.test(actions[i])? 'resize' : actions[i];\n\n                    if (!isObject(this.options[action])) { continue; }\n\n                    var thisOption = this.options[action][option];\n\n                    if (isObject(options)) {\n                        extend(thisOption, options);\n                        thisOption.enabled = options.enabled === false? false: true;\n\n                        if (option === 'snap') {\n                            if (thisOption.mode === 'grid') {\n                                thisOption.targets = [\n                                    interact.createSnapGrid(extend({\n                                        offset: thisOption.gridOffset || { x: 0, y: 0 }\n                                    }, thisOption.grid || {}))\n                                ];\n                            }\n                            else if (thisOption.mode === 'anchor') {\n                                thisOption.targets = thisOption.anchors;\n                            }\n                            else if (thisOption.mode === 'path') {\n                                thisOption.targets = thisOption.paths;\n                            }\n\n                            if ('elementOrigin' in options) {\n                                thisOption.relativePoints = [options.elementOrigin];\n                            }\n                        }\n                    }\n                    else if (isBool(options)) {\n                        thisOption.enabled = options;\n                    }\n                }\n\n                return this;\n            }\n\n            var ret = {},\n                allActions = ['drag', 'resize', 'gesture'];\n\n            for (i = 0; i < allActions.length; i++) {\n                if (option in defaultOptions[allActions[i]]) {\n                    ret[allActions[i]] = this.options[allActions[i]][option];\n                }\n            }\n\n            return ret;\n        },\n\n\n        /*\\\n         * Interactable.inertia\n         [ method ]\n         **\n         * Deprecated. Add an `inertia` property to the options object passed\n         * to @Interactable.draggable or @Interactable.resizable instead.\n         *\n         * Returns or sets if and how events continue to run after the pointer is released\n         **\n         = (boolean | object) `false` if inertia is disabled; `object` with inertia properties if inertia is enabled\n         **\n         * or\n         **\n         - options (object | boolean | null) #optional\n         = (Interactable) this Interactable\n         > Usage\n         | // enable and use default settings\n         | interact(element).inertia(true);\n         |\n         | // enable and use custom settings\n         | interact(element).inertia({\n         |     // value greater than 0\n         |     // high values slow the object down more quickly\n         |     resistance     : 16,\n         |\n         |     // the minimum launch speed (pixels per second) that results in inertia start\n         |     minSpeed       : 200,\n         |\n         |     // inertia will stop when the object slows down to this speed\n         |     endSpeed       : 20,\n         |\n         |     // boolean; should actions be resumed when the pointer goes down during inertia\n         |     allowResume    : true,\n         |\n         |     // boolean; should the jump when resuming from inertia be ignored in event.dx/dy\n         |     zeroResumeDelta: false,\n         |\n         |     // if snap/restrict are set to be endOnly and inertia is enabled, releasing\n         |     // the pointer without triggering inertia will animate from the release\n         |     // point to the snaped/restricted point in the given amount of time (ms)\n         |     smoothEndDuration: 300,\n         |\n         |     // an array of action types that can have inertia (no gesture)\n         |     actions        : ['drag', 'resize']\n         | });\n         |\n         | // reset custom settings and use all defaults\n         | interact(element).inertia(null);\n        \\*/\n        inertia: function (options) {\n            var ret = this.setOptions('inertia', options);\n\n            if (ret === this) { return this; }\n\n            return ret.drag;\n        },\n\n        getAction: function (pointer, event, interaction, element) {\n            var action = this.defaultActionChecker(pointer, interaction, element);\n\n            if (this.options.actionChecker) {\n                return this.options.actionChecker(pointer, event, action, this, element, interaction);\n            }\n\n            return action;\n        },\n\n        defaultActionChecker: defaultActionChecker,\n\n        /*\\\n         * Interactable.actionChecker\n         [ method ]\n         *\n         * Gets or sets the function used to check action to be performed on\n         * pointerDown\n         *\n         - checker (function | null) #optional 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.\n         = (Function | Interactable) The checker function or this Interactable\n         *\n         | interact('.resize-drag')\n         |   .resizable(true)\n         |   .draggable(true)\n         |   .actionChecker(function (pointer, event, action, interactable, element, interaction) {\n         |\n         |   if (interact.matchesSelector(event.target, '.drag-handle') {\n         |     // force drag with handle target\n         |     action.name = drag;\n         |   }\n         |   else {\n         |     // resize from the top and right edges\n         |     action.name  = 'resize';\n         |     action.edges = { top: true, right: true };\n         |   }\n         |\n         |   return action;\n         | });\n        \\*/\n        actionChecker: function (checker) {\n            if (isFunction(checker)) {\n                this.options.actionChecker = checker;\n\n                return this;\n            }\n\n            if (checker === null) {\n                delete this.options.actionChecker;\n\n                return this;\n            }\n\n            return this.options.actionChecker;\n        },\n\n        /*\\\n         * Interactable.getRect\n         [ method ]\n         *\n         * The default function to get an Interactables bounding rect. Can be\n         * overridden using @Interactable.rectChecker.\n         *\n         - element (Element) #optional The element to measure.\n         = (object) The object's bounding rectangle.\n         o {\n         o     top   : 0,\n         o     left  : 0,\n         o     bottom: 0,\n         o     right : 0,\n         o     width : 0,\n         o     height: 0\n         o }\n        \\*/\n        getRect: function rectCheck (element) {\n            element = element || this._element;\n\n            if (this.selector && !(isElement(element))) {\n                element = this._context.querySelector(this.selector);\n            }\n\n            return getElementRect(element);\n        },\n\n        /*\\\n         * Interactable.rectChecker\n         [ method ]\n         *\n         * Returns or sets the function used to calculate the interactable's\n         * element's rectangle\n         *\n         - checker (function) #optional A function which returns this Interactable's bounding rectangle. See @Interactable.getRect\n         = (function | object) The checker function or this Interactable\n        \\*/\n        rectChecker: function (checker) {\n            if (isFunction(checker)) {\n                this.getRect = checker;\n\n                return this;\n            }\n\n            if (checker === null) {\n                delete this.options.getRect;\n\n                return this;\n            }\n\n            return this.getRect;\n        },\n\n        /*\\\n         * Interactable.styleCursor\n         [ method ]\n         *\n         * Returns or sets whether the action that would be performed when the\n         * mouse on the element are checked on `mousemove` so that the cursor\n         * may be styled appropriately\n         *\n         - newValue (boolean) #optional\n         = (boolean | Interactable) The current setting or this Interactable\n        \\*/\n        styleCursor: function (newValue) {\n            if (isBool(newValue)) {\n                this.options.styleCursor = newValue;\n\n                return this;\n            }\n\n            if (newValue === null) {\n                delete this.options.styleCursor;\n\n                return this;\n            }\n\n            return this.options.styleCursor;\n        },\n\n        /*\\\n         * Interactable.preventDefault\n         [ method ]\n         *\n         * Returns or sets whether to prevent the browser's default behaviour\n         * in response to pointer events. Can be set to:\n         *  - `'always'` to always prevent\n         *  - `'never'` to never prevent\n         *  - `'auto'` to let interact.js try to determine what would be best\n         *\n         - newValue (string) #optional `true`, `false` or `'auto'`\n         = (string | Interactable) The current setting or this Interactable\n        \\*/\n        preventDefault: function (newValue) {\n            if (/^(always|never|auto)$/.test(newValue)) {\n                this.options.preventDefault = newValue;\n                return this;\n            }\n\n            if (isBool(newValue)) {\n                this.options.preventDefault = newValue? 'always' : 'never';\n                return this;\n            }\n\n            return this.options.preventDefault;\n        },\n\n        /*\\\n         * Interactable.origin\n         [ method ]\n         *\n         * Gets or sets the origin of the Interactable's element.  The x and y\n         * of the origin will be subtracted from action event coordinates.\n         *\n         - origin (object | string) #optional An object eg. { x: 0, y: 0 } or string 'parent', 'self' or any CSS selector\n         * OR\n         - origin (Element) #optional An HTML or SVG Element whose rect will be used\n         **\n         = (object) The current origin or this Interactable\n        \\*/\n        origin: function (newValue) {\n            if (trySelector(newValue)) {\n                this.options.origin = newValue;\n                return this;\n            }\n            else if (isObject(newValue)) {\n                this.options.origin = newValue;\n                return this;\n            }\n\n            return this.options.origin;\n        },\n\n        /*\\\n         * Interactable.deltaSource\n         [ method ]\n         *\n         * Returns or sets the mouse coordinate types used to calculate the\n         * movement of the pointer.\n         *\n         - newValue (string) #optional Use 'client' if you will be scrolling while interacting; Use 'page' if you want autoScroll to work\n         = (string | object) The current deltaSource or this Interactable\n        \\*/\n        deltaSource: function (newValue) {\n            if (newValue === 'page' || newValue === 'client') {\n                this.options.deltaSource = newValue;\n\n                return this;\n            }\n\n            return this.options.deltaSource;\n        },\n\n        /*\\\n         * Interactable.restrict\n         [ method ]\n         **\n         * Deprecated. Add a `restrict` property to the options object passed to\n         * @Interactable.draggable, @Interactable.resizable or @Interactable.gesturable instead.\n         *\n         * Returns or sets the rectangles within which actions on this\n         * interactable (after snap calculations) are restricted. By default,\n         * restricting is relative to the pointer coordinates. You can change\n         * this by setting the\n         * [`elementRect`](https://github.com/taye/interact.js/pull/72).\n         **\n         - options (object) #optional an object with keys drag, resize, and/or gesture whose values are rects, Elements, CSS selectors, or 'parent' or 'self'\n         = (object) The current restrictions object or this Interactable\n         **\n         | interact(element).restrict({\n         |     // the rect will be `interact.getElementRect(element.parentNode)`\n         |     drag: element.parentNode,\n         |\n         |     // x and y are relative to the the interactable's origin\n         |     resize: { x: 100, y: 100, width: 200, height: 200 }\n         | })\n         |\n         | interact('.draggable').restrict({\n         |     // the rect will be the selected element's parent\n         |     drag: 'parent',\n         |\n         |     // do not restrict during normal movement.\n         |     // Instead, trigger only one restricted move event\n         |     // immediately before the end event.\n         |     endOnly: true,\n         |\n         |     // https://github.com/taye/interact.js/pull/72#issue-41813493\n         |     elementRect: { top: 0, left: 0, bottom: 1, right: 1 }\n         | });\n        \\*/\n        restrict: function (options) {\n            if (!isObject(options)) {\n                return this.setOptions('restrict', options);\n            }\n\n            var actions = ['drag', 'resize', 'gesture'],\n                ret;\n\n            for (var i = 0; i < actions.length; i++) {\n                var action = actions[i];\n\n                if (action in options) {\n                    var perAction = extend({\n                            actions: [action],\n                            restriction: options[action]\n                        }, options);\n\n                    ret = this.setOptions('restrict', perAction);\n                }\n            }\n\n            return ret;\n        },\n\n        /*\\\n         * Interactable.context\n         [ method ]\n         *\n         * Gets the selector context Node of the Interactable. The default is `window.document`.\n         *\n         = (Node) The context Node of this Interactable\n         **\n        \\*/\n        context: function () {\n            return this._context;\n        },\n\n        _context: document,\n\n        /*\\\n         * Interactable.ignoreFrom\n         [ method ]\n         *\n         * If the target of the `mousedown`, `pointerdown` or `touchstart`\n         * event or any of it's parents match the given CSS selector or\n         * Element, no drag/resize/gesture is started.\n         *\n         - newValue (string | Element | null) #optional a CSS selector string, an Element or `null` to not ignore any elements\n         = (string | Element | object) The current ignoreFrom value or this Interactable\n         **\n         | interact(element, { ignoreFrom: document.getElementById('no-action') });\n         | // or\n         | interact(element).ignoreFrom('input, textarea, a');\n        \\*/\n        ignoreFrom: function (newValue) {\n            if (trySelector(newValue)) {            // CSS selector to match event.target\n                this.options.ignoreFrom = newValue;\n                return this;\n            }\n\n            if (isElement(newValue)) {              // specific element\n                this.options.ignoreFrom = newValue;\n                return this;\n            }\n\n            return this.options.ignoreFrom;\n        },\n\n        /*\\\n         * Interactable.allowFrom\n         [ method ]\n         *\n         * A drag/resize/gesture is started only If the target of the\n         * `mousedown`, `pointerdown` or `touchstart` event or any of it's\n         * parents match the given CSS selector or Element.\n         *\n         - newValue (string | Element | null) #optional a CSS selector string, an Element or `null` to allow from any element\n         = (string | Element | object) The current allowFrom value or this Interactable\n         **\n         | interact(element, { allowFrom: document.getElementById('drag-handle') });\n         | // or\n         | interact(element).allowFrom('.handle');\n        \\*/\n        allowFrom: function (newValue) {\n            if (trySelector(newValue)) {            // CSS selector to match event.target\n                this.options.allowFrom = newValue;\n                return this;\n            }\n\n            if (isElement(newValue)) {              // specific element\n                this.options.allowFrom = newValue;\n                return this;\n            }\n\n            return this.options.allowFrom;\n        },\n\n        /*\\\n         * Interactable.element\n         [ method ]\n         *\n         * If this is not a selector Interactable, it returns the element this\n         * interactable represents\n         *\n         = (Element) HTML / SVG Element\n        \\*/\n        element: function () {\n            return this._element;\n        },\n\n        /*\\\n         * Interactable.fire\n         [ method ]\n         *\n         * Calls listeners for the given InteractEvent type bound globally\n         * and directly to this Interactable\n         *\n         - iEvent (InteractEvent) The InteractEvent object to be fired on this Interactable\n         = (Interactable) this Interactable\n        \\*/\n        fire: function (iEvent) {\n            if (!(iEvent && iEvent.type) || !contains(eventTypes, iEvent.type)) {\n                return this;\n            }\n\n            var listeners,\n                i,\n                len,\n                onEvent = 'on' + iEvent.type,\n                funcName = '';\n\n            // Interactable#on() listeners\n            if (iEvent.type in this._iEvents) {\n                listeners = this._iEvents[iEvent.type];\n\n                for (i = 0, len = listeners.length; i < len && !iEvent.immediatePropagationStopped; i++) {\n                    funcName = listeners[i].name;\n                    listeners[i](iEvent);\n                }\n            }\n\n            // interactable.onevent listener\n            if (isFunction(this[onEvent])) {\n                funcName = this[onEvent].name;\n                this[onEvent](iEvent);\n            }\n\n            // interact.on() listeners\n            if (iEvent.type in globalEvents && (listeners = globalEvents[iEvent.type]))  {\n\n                for (i = 0, len = listeners.length; i < len && !iEvent.immediatePropagationStopped; i++) {\n                    funcName = listeners[i].name;\n                    listeners[i](iEvent);\n                }\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.on\n         [ method ]\n         *\n         * Binds a listener for an InteractEvent or DOM event.\n         *\n         - eventType  (string | array | object) The types of events to listen for\n         - listener   (function) The function to be called on the given event(s)\n         - useCapture (boolean) #optional useCapture flag for addEventListener\n         = (object) This Interactable\n        \\*/\n        on: function (eventType, listener, useCapture) {\n            var i;\n\n            if (isString(eventType) && eventType.search(' ') !== -1) {\n                eventType = eventType.trim().split(/ +/);\n            }\n\n            if (isArray(eventType)) {\n                for (i = 0; i < eventType.length; i++) {\n                    this.on(eventType[i], listener, useCapture);\n                }\n\n                return this;\n            }\n\n            if (isObject(eventType)) {\n                for (var prop in eventType) {\n                    this.on(prop, eventType[prop], listener);\n                }\n\n                return this;\n            }\n\n            if (eventType === 'wheel') {\n                eventType = wheelEvent;\n            }\n\n            // convert to boolean\n            useCapture = useCapture? true: false;\n\n            if (contains(eventTypes, eventType)) {\n                // if this type of event was never bound to this Interactable\n                if (!(eventType in this._iEvents)) {\n                    this._iEvents[eventType] = [listener];\n                }\n                else {\n                    this._iEvents[eventType].push(listener);\n                }\n            }\n            // delegated event for selector\n            else if (this.selector) {\n                if (!delegatedEvents[eventType]) {\n                    delegatedEvents[eventType] = {\n                        selectors: [],\n                        contexts : [],\n                        listeners: []\n                    };\n\n                    // add delegate listener functions\n                    for (i = 0; i < documents.length; i++) {\n                        events.add(documents[i], eventType, delegateListener);\n                        events.add(documents[i], eventType, delegateUseCapture, true);\n                    }\n                }\n\n                var delegated = delegatedEvents[eventType],\n                    index;\n\n                for (index = delegated.selectors.length - 1; index >= 0; index--) {\n                    if (delegated.selectors[index] === this.selector\n                        && delegated.contexts[index] === this._context) {\n                        break;\n                    }\n                }\n\n                if (index === -1) {\n                    index = delegated.selectors.length;\n\n                    delegated.selectors.push(this.selector);\n                    delegated.contexts .push(this._context);\n                    delegated.listeners.push([]);\n                }\n\n                // keep listener and useCapture flag\n                delegated.listeners[index].push([listener, useCapture]);\n            }\n            else {\n                events.add(this._element, eventType, listener, useCapture);\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.off\n         [ method ]\n         *\n         * Removes an InteractEvent or DOM event listener\n         *\n         - eventType  (string | array | object) The types of events that were listened for\n         - listener   (function) The listener function to be removed\n         - useCapture (boolean) #optional useCapture flag for removeEventListener\n         = (object) This Interactable\n        \\*/\n        off: function (eventType, listener, useCapture) {\n            var i;\n\n            if (isString(eventType) && eventType.search(' ') !== -1) {\n                eventType = eventType.trim().split(/ +/);\n            }\n\n            if (isArray(eventType)) {\n                for (i = 0; i < eventType.length; i++) {\n                    this.off(eventType[i], listener, useCapture);\n                }\n\n                return this;\n            }\n\n            if (isObject(eventType)) {\n                for (var prop in eventType) {\n                    this.off(prop, eventType[prop], listener);\n                }\n\n                return this;\n            }\n\n            var eventList,\n                index = -1;\n\n            // convert to boolean\n            useCapture = useCapture? true: false;\n\n            if (eventType === 'wheel') {\n                eventType = wheelEvent;\n            }\n\n            // if it is an action event type\n            if (contains(eventTypes, eventType)) {\n                eventList = this._iEvents[eventType];\n\n                if (eventList && (index = indexOf(eventList, listener)) !== -1) {\n                    this._iEvents[eventType].splice(index, 1);\n                }\n            }\n            // delegated event\n            else if (this.selector) {\n                var delegated = delegatedEvents[eventType],\n                    matchFound = false;\n\n                if (!delegated) { return this; }\n\n                // count from last index of delegated to 0\n                for (index = delegated.selectors.length - 1; index >= 0; index--) {\n                    // look for matching selector and context Node\n                    if (delegated.selectors[index] === this.selector\n                        && delegated.contexts[index] === this._context) {\n\n                        var listeners = delegated.listeners[index];\n\n                        // each item of the listeners array is an array: [function, useCaptureFlag]\n                        for (i = listeners.length - 1; i >= 0; i--) {\n                            var fn = listeners[i][0],\n                                useCap = listeners[i][1];\n\n                            // check if the listener functions and useCapture flags match\n                            if (fn === listener && useCap === useCapture) {\n                                // remove the listener from the array of listeners\n                                listeners.splice(i, 1);\n\n                                // if all listeners for this interactable have been removed\n                                // remove the interactable from the delegated arrays\n                                if (!listeners.length) {\n                                    delegated.selectors.splice(index, 1);\n                                    delegated.contexts .splice(index, 1);\n                                    delegated.listeners.splice(index, 1);\n\n                                    // remove delegate function from context\n                                    events.remove(this._context, eventType, delegateListener);\n                                    events.remove(this._context, eventType, delegateUseCapture, true);\n\n                                    // remove the arrays if they are empty\n                                    if (!delegated.selectors.length) {\n                                        delegatedEvents[eventType] = null;\n                                    }\n                                }\n\n                                // only remove one listener\n                                matchFound = true;\n                                break;\n                            }\n                        }\n\n                        if (matchFound) { break; }\n                    }\n                }\n            }\n            // remove listener from this Interatable's element\n            else {\n                events.remove(this._element, eventType, listener, useCapture);\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.set\n         [ method ]\n         *\n         * Reset the options of this Interactable\n         - options (object) The new settings to apply\n         = (object) This Interactable\n        \\*/\n        set: function (options) {\n            if (!isObject(options)) {\n                options = {};\n            }\n\n            this.options = extend({}, defaultOptions.base);\n\n            var i,\n                actions = ['drag', 'drop', 'resize', 'gesture'],\n                methods = ['draggable', 'dropzone', 'resizable', 'gesturable'],\n                perActions = extend(extend({}, defaultOptions.perAction), options[action] || {});\n\n            for (i = 0; i < actions.length; i++) {\n                var action = actions[i];\n\n                this.options[action] = extend({}, defaultOptions[action]);\n\n                this.setPerAction(action, perActions);\n\n                this[methods[i]](options[action]);\n            }\n\n            var settings = [\n                    'accept', 'actionChecker', 'allowFrom', 'deltaSource',\n                    'dropChecker', 'ignoreFrom', 'origin', 'preventDefault',\n                    'rectChecker', 'styleCursor'\n                ];\n\n            for (i = 0, len = settings.length; i < len; i++) {\n                var setting = settings[i];\n\n                this.options[setting] = defaultOptions.base[setting];\n\n                if (setting in options) {\n                    this[setting](options[setting]);\n                }\n            }\n\n            return this;\n        },\n\n        /*\\\n         * Interactable.unset\n         [ method ]\n         *\n         * Remove this interactable from the list of interactables and remove\n         * it's drag, drop, resize and gesture capabilities\n         *\n         = (object) @interact\n        \\*/\n        unset: function () {\n            events.remove(this._element, 'all');\n\n            if (!isString(this.selector)) {\n                events.remove(this, 'all');\n                if (this.options.styleCursor) {\n                    this._element.style.cursor = '';\n                }\n            }\n            else {\n                // remove delegated events\n                for (var type in delegatedEvents) {\n                    var delegated = delegatedEvents[type];\n\n                    for (var i = 0; i < delegated.selectors.length; i++) {\n                        if (delegated.selectors[i] === this.selector\n                            && delegated.contexts[i] === this._context) {\n\n                            delegated.selectors.splice(i, 1);\n                            delegated.contexts .splice(i, 1);\n                            delegated.listeners.splice(i, 1);\n\n                            // remove the arrays if they are empty\n                            if (!delegated.selectors.length) {\n                                delegatedEvents[type] = null;\n                            }\n                        }\n\n                        events.remove(this._context, type, delegateListener);\n                        events.remove(this._context, type, delegateUseCapture, true);\n\n                        break;\n                    }\n                }\n            }\n\n            this.dropzone(false);\n\n            interactables.splice(indexOf(interactables, this), 1);\n\n            return interact;\n        }\n    };\n\n    function warnOnce (method, message) {\n        var warned = false;\n\n        return function () {\n            if (!warned) {\n                window.console.warn(message);\n                warned = true;\n            }\n\n            return method.apply(this, arguments);\n        };\n    }\n\n    Interactable.prototype.snap = warnOnce(Interactable.prototype.snap,\n         'Interactable#snap is deprecated. See the new documentation for snapping at http://interactjs.io/docs/snapping');\n    Interactable.prototype.restrict = warnOnce(Interactable.prototype.restrict,\n         'Interactable#restrict is deprecated. See the new documentation for resticting at http://interactjs.io/docs/restriction');\n    Interactable.prototype.inertia = warnOnce(Interactable.prototype.inertia,\n         'Interactable#inertia is deprecated. See the new documentation for inertia at http://interactjs.io/docs/inertia');\n    Interactable.prototype.autoScroll = warnOnce(Interactable.prototype.autoScroll,\n         'Interactable#autoScroll is deprecated. See the new documentation for autoScroll at http://interactjs.io/docs/#autoscroll');\n    Interactable.prototype.squareResize = warnOnce(Interactable.prototype.squareResize,\n         'Interactable#squareResize is deprecated. See http://interactjs.io/docs/#resize-square');\n\n    Interactable.prototype.accept = warnOnce(Interactable.prototype.accept,\n         'Interactable#accept is deprecated. use Interactable#dropzone({ accept: target }) instead');\n    Interactable.prototype.dropChecker = warnOnce(Interactable.prototype.dropChecker,\n         'Interactable#dropChecker is deprecated. use Interactable#dropzone({ dropChecker: checkerFunction }) instead');\n    Interactable.prototype.context = warnOnce(Interactable.prototype.context,\n         'Interactable#context as a method is deprecated. It will soon be a DOM Node instead');\n\n    /*\\\n     * interact.isSet\n     [ method ]\n     *\n     * Check if an element has been set\n     - element (Element) The Element being searched for\n     = (boolean) Indicates if the element or CSS selector was previously passed to interact\n    \\*/\n    interact.isSet = function(element, options) {\n        return interactables.indexOfElement(element, options && options.context) !== -1;\n    };\n\n    /*\\\n     * interact.on\n     [ method ]\n     *\n     * Adds a global listener for an InteractEvent or adds a DOM event to\n     * `document`\n     *\n     - type       (string | array | object) The types of events to listen for\n     - listener   (function) The function to be called on the given event(s)\n     - useCapture (boolean) #optional useCapture flag for addEventListener\n     = (object) interact\n    \\*/\n    interact.on = function (type, listener, useCapture) {\n        if (isString(type) && type.search(' ') !== -1) {\n            type = type.trim().split(/ +/);\n        }\n\n        if (isArray(type)) {\n            for (var i = 0; i < type.length; i++) {\n                interact.on(type[i], listener, useCapture);\n            }\n\n            return interact;\n        }\n\n        if (isObject(type)) {\n            for (var prop in type) {\n                interact.on(prop, type[prop], listener);\n            }\n\n            return interact;\n        }\n\n        // if it is an InteractEvent type, add listener to globalEvents\n        if (contains(eventTypes, type)) {\n            // if this type of event was never bound\n            if (!globalEvents[type]) {\n                globalEvents[type] = [listener];\n            }\n            else {\n                globalEvents[type].push(listener);\n            }\n        }\n        // If non InteractEvent type, addEventListener to document\n        else {\n            events.add(document, type, listener, useCapture);\n        }\n\n        return interact;\n    };\n\n    /*\\\n     * interact.off\n     [ method ]\n     *\n     * Removes a global InteractEvent listener or DOM event from `document`\n     *\n     - type       (string | array | object) The types of events that were listened for\n     - listener   (function) The listener function to be removed\n     - useCapture (boolean) #optional useCapture flag for removeEventListener\n     = (object) interact\n     \\*/\n    interact.off = function (type, listener, useCapture) {\n        if (isString(type) && type.search(' ') !== -1) {\n            type = type.trim().split(/ +/);\n        }\n\n        if (isArray(type)) {\n            for (var i = 0; i < type.length; i++) {\n                interact.off(type[i], listener, useCapture);\n            }\n\n            return interact;\n        }\n\n        if (isObject(type)) {\n            for (var prop in type) {\n                interact.off(prop, type[prop], listener);\n            }\n\n            return interact;\n        }\n\n        if (!contains(eventTypes, type)) {\n            events.remove(document, type, listener, useCapture);\n        }\n        else {\n            var index;\n\n            if (type in globalEvents\n                && (index = indexOf(globalEvents[type], listener)) !== -1) {\n                globalEvents[type].splice(index, 1);\n            }\n        }\n\n        return interact;\n    };\n\n    /*\\\n     * interact.enableDragging\n     [ method ]\n     *\n     * Deprecated.\n     *\n     * Returns or sets whether dragging is enabled for any Interactables\n     *\n     - newValue (boolean) #optional `true` to allow the action; `false` to disable action for all Interactables\n     = (boolean | object) The current setting or interact\n    \\*/\n    interact.enableDragging = warnOnce(function (newValue) {\n        if (newValue !== null && newValue !== undefined) {\n            actionIsEnabled.drag = newValue;\n\n            return interact;\n        }\n        return actionIsEnabled.drag;\n    }, 'interact.enableDragging is deprecated and will soon be removed.');\n\n    /*\\\n     * interact.enableResizing\n     [ method ]\n     *\n     * Deprecated.\n     *\n     * Returns or sets whether resizing is enabled for any Interactables\n     *\n     - newValue (boolean) #optional `true` to allow the action; `false` to disable action for all Interactables\n     = (boolean | object) The current setting or interact\n    \\*/\n    interact.enableResizing = warnOnce(function (newValue) {\n        if (newValue !== null && newValue !== undefined) {\n            actionIsEnabled.resize = newValue;\n\n            return interact;\n        }\n        return actionIsEnabled.resize;\n    }, 'interact.enableResizing is deprecated and will soon be removed.');\n\n    /*\\\n     * interact.enableGesturing\n     [ method ]\n     *\n     * Deprecated.\n     *\n     * Returns or sets whether gesturing is enabled for any Interactables\n     *\n     - newValue (boolean) #optional `true` to allow the action; `false` to disable action for all Interactables\n     = (boolean | object) The current setting or interact\n    \\*/\n    interact.enableGesturing = warnOnce(function (newValue) {\n        if (newValue !== null && newValue !== undefined) {\n            actionIsEnabled.gesture = newValue;\n\n            return interact;\n        }\n        return actionIsEnabled.gesture;\n    }, 'interact.enableGesturing is deprecated and will soon be removed.');\n\n    interact.eventTypes = eventTypes;\n\n    /*\\\n     * interact.debug\n     [ method ]\n     *\n     * Returns debugging data\n     = (object) An object with properties that outline the current state and expose internal functions and variables\n    \\*/\n    interact.debug = function () {\n        var interaction = interactions[0] || new Interaction();\n\n        return {\n            interactions          : interactions,\n            target                : interaction.target,\n            dragging              : interaction.dragging,\n            resizing              : interaction.resizing,\n            gesturing             : interaction.gesturing,\n            prepared              : interaction.prepared,\n            matches               : interaction.matches,\n            matchElements         : interaction.matchElements,\n\n            prevCoords            : interaction.prevCoords,\n            startCoords           : interaction.startCoords,\n\n            pointerIds            : interaction.pointerIds,\n            pointers              : interaction.pointers,\n            addPointer            : listeners.addPointer,\n            removePointer         : listeners.removePointer,\n            recordPointer        : listeners.recordPointer,\n\n            snap                  : interaction.snapStatus,\n            restrict              : interaction.restrictStatus,\n            inertia               : interaction.inertiaStatus,\n\n            downTime              : interaction.downTimes[0],\n            downEvent             : interaction.downEvent,\n            downPointer           : interaction.downPointer,\n            prevEvent             : interaction.prevEvent,\n\n            Interactable          : Interactable,\n            interactables         : interactables,\n            pointerIsDown         : interaction.pointerIsDown,\n            defaultOptions        : defaultOptions,\n            defaultActionChecker  : defaultActionChecker,\n\n            actionCursors         : actionCursors,\n            dragMove              : listeners.dragMove,\n            resizeMove            : listeners.resizeMove,\n            gestureMove           : listeners.gestureMove,\n            pointerUp             : listeners.pointerUp,\n            pointerDown           : listeners.pointerDown,\n            pointerMove           : listeners.pointerMove,\n            pointerHover          : listeners.pointerHover,\n\n            eventTypes            : eventTypes,\n\n            events                : events,\n            globalEvents          : globalEvents,\n            delegatedEvents       : delegatedEvents,\n\n            prefixedPropREs       : prefixedPropREs\n        };\n    };\n\n    // expose the functions used to calculate multi-touch properties\n    interact.getPointerAverage = pointerAverage;\n    interact.getTouchBBox     = touchBBox;\n    interact.getTouchDistance = touchDistance;\n    interact.getTouchAngle    = touchAngle;\n\n    interact.getElementRect         = getElementRect;\n    interact.getElementClientRect   = getElementClientRect;\n    interact.matchesSelector        = matchesSelector;\n    interact.closest                = closest;\n\n    /*\\\n     * interact.margin\n     [ method ]\n     *\n     * Deprecated. Use `interact(target).resizable({ margin: number });` instead.\n     * Returns or sets the margin for autocheck resizing used in\n     * @Interactable.getAction. That is the distance from the bottom and right\n     * edges of an element clicking in which will start resizing\n     *\n     - newValue (number) #optional\n     = (number | interact) The current margin value or interact\n    \\*/\n    interact.margin = warnOnce(function (newvalue) {\n        if (isNumber(newvalue)) {\n            margin = newvalue;\n\n            return interact;\n        }\n        return margin;\n    },\n    'interact.margin is deprecated. Use interact(target).resizable({ margin: number }); instead.') ;\n\n    /*\\\n     * interact.supportsTouch\n     [ method ]\n     *\n     = (boolean) Whether or not the browser supports touch input\n    \\*/\n    interact.supportsTouch = function () {\n        return supportsTouch;\n    };\n\n    /*\\\n     * interact.supportsPointerEvent\n     [ method ]\n     *\n     = (boolean) Whether or not the browser supports PointerEvents\n    \\*/\n    interact.supportsPointerEvent = function () {\n        return supportsPointerEvent;\n    };\n\n    /*\\\n     * interact.stop\n     [ method ]\n     *\n     * Cancels all interactions (end events are not fired)\n     *\n     - event (Event) An event on which to call preventDefault()\n     = (object) interact\n    \\*/\n    interact.stop = function (event) {\n        for (var i = interactions.length - 1; i >= 0; i--) {\n            interactions[i].stop(event);\n        }\n\n        return interact;\n    };\n\n    /*\\\n     * interact.dynamicDrop\n     [ method ]\n     *\n     * Returns or sets whether the dimensions of dropzone elements are\n     * calculated on every dragmove or only on dragstart for the default\n     * dropChecker\n     *\n     - newValue (boolean) #optional True to check on each move. False to check only before start\n     = (boolean | interact) The current setting or interact\n    \\*/\n    interact.dynamicDrop = function (newValue) {\n        if (isBool(newValue)) {\n            //if (dragging && dynamicDrop !== newValue && !newValue) {\n                //calcRects(dropzones);\n            //}\n\n            dynamicDrop = newValue;\n\n            return interact;\n        }\n        return dynamicDrop;\n    };\n\n    /*\\\n     * interact.pointerMoveTolerance\n     [ method ]\n     * Returns or sets the distance the pointer must be moved before an action\n     * sequence occurs. This also affects tolerance for tap events.\n     *\n     - newValue (number) #optional The movement from the start position must be greater than this value\n     = (number | Interactable) The current setting or interact\n    \\*/\n    interact.pointerMoveTolerance = function (newValue) {\n        if (isNumber(newValue)) {\n            pointerMoveTolerance = newValue;\n\n            return this;\n        }\n\n        return pointerMoveTolerance;\n    };\n\n    /*\\\n     * interact.maxInteractions\n     [ method ]\n     **\n     * Returns or sets the maximum number of concurrent interactions allowed.\n     * By default only 1 interaction is allowed at a time (for backwards\n     * compatibility). To allow multiple interactions on the same Interactables\n     * and elements, you need to enable it in the draggable, resizable and\n     * gesturable `'max'` and `'maxPerElement'` options.\n     **\n     - newValue (number) #optional Any number. newValue <= 0 means no interactions.\n    \\*/\n    interact.maxInteractions = function (newValue) {\n        if (isNumber(newValue)) {\n            maxInteractions = newValue;\n\n            return this;\n        }\n\n        return maxInteractions;\n    };\n\n    interact.createSnapGrid = function (grid) {\n        return function (x, y) {\n            var offsetX = 0,\n                offsetY = 0;\n\n            if (isObject(grid.offset)) {\n                offsetX = grid.offset.x;\n                offsetY = grid.offset.y;\n            }\n\n            var gridx = Math.round((x - offsetX) / grid.x),\n                gridy = Math.round((y - offsetY) / grid.y),\n\n                newX = gridx * grid.x + offsetX,\n                newY = gridy * grid.y + offsetY;\n\n            return {\n                x: newX,\n                y: newY,\n                range: grid.range\n            };\n        };\n    };\n\n    function endAllInteractions (event) {\n        for (var i = 0; i < interactions.length; i++) {\n            interactions[i].pointerEnd(event, event);\n        }\n    }\n\n    function listenToDocument (doc) {\n        if (contains(documents, doc)) { return; }\n\n        var win = doc.defaultView || doc.parentWindow;\n\n        // add delegate event listener\n        for (var eventType in delegatedEvents) {\n            events.add(doc, eventType, delegateListener);\n            events.add(doc, eventType, delegateUseCapture, true);\n        }\n\n        if (supportsPointerEvent) {\n            if (PointerEvent === win.MSPointerEvent) {\n                pEventTypes = {\n                    up: 'MSPointerUp', down: 'MSPointerDown', over: 'mouseover',\n                    out: 'mouseout', move: 'MSPointerMove', cancel: 'MSPointerCancel' };\n            }\n            else {\n                pEventTypes = {\n                    up: 'pointerup', down: 'pointerdown', over: 'pointerover',\n                    out: 'pointerout', move: 'pointermove', cancel: 'pointercancel' };\n            }\n\n            events.add(doc, pEventTypes.down  , listeners.selectorDown );\n            events.add(doc, pEventTypes.move  , listeners.pointerMove  );\n            events.add(doc, pEventTypes.over  , listeners.pointerOver  );\n            events.add(doc, pEventTypes.out   , listeners.pointerOut   );\n            events.add(doc, pEventTypes.up    , listeners.pointerUp    );\n            events.add(doc, pEventTypes.cancel, listeners.pointerCancel);\n\n            // autoscroll\n            events.add(doc, pEventTypes.move, listeners.autoScrollMove);\n        }\n        else {\n            events.add(doc, 'mousedown', listeners.selectorDown);\n            events.add(doc, 'mousemove', listeners.pointerMove );\n            events.add(doc, 'mouseup'  , listeners.pointerUp   );\n            events.add(doc, 'mouseover', listeners.pointerOver );\n            events.add(doc, 'mouseout' , listeners.pointerOut  );\n\n            events.add(doc, 'touchstart' , listeners.selectorDown );\n            events.add(doc, 'touchmove'  , listeners.pointerMove  );\n            events.add(doc, 'touchend'   , listeners.pointerUp    );\n            events.add(doc, 'touchcancel', listeners.pointerCancel);\n\n            // autoscroll\n            events.add(doc, 'mousemove', listeners.autoScrollMove);\n            events.add(doc, 'touchmove', listeners.autoScrollMove);\n        }\n\n        events.add(win, 'blur', endAllInteractions);\n\n        try {\n            if (win.frameElement) {\n                var parentDoc = win.frameElement.ownerDocument,\n                    parentWindow = parentDoc.defaultView;\n\n                events.add(parentDoc   , 'mouseup'      , listeners.pointerEnd);\n                events.add(parentDoc   , 'touchend'     , listeners.pointerEnd);\n                events.add(parentDoc   , 'touchcancel'  , listeners.pointerEnd);\n                events.add(parentDoc   , 'pointerup'    , listeners.pointerEnd);\n                events.add(parentDoc   , 'MSPointerUp'  , listeners.pointerEnd);\n                events.add(parentWindow, 'blur'         , endAllInteractions );\n            }\n        }\n        catch (error) {\n            interact.windowParentError = error;\n        }\n\n        // prevent native HTML5 drag on interact.js target elements\n        events.add(doc, 'dragstart', function (event) {\n            for (var i = 0; i < interactions.length; i++) {\n                var interaction = interactions[i];\n\n                if (interaction.element\n                    && (interaction.element === event.target\n                        || nodeContains(interaction.element, event.target))) {\n\n                    interaction.checkAndPreventDefault(event, interaction.target, interaction.element);\n                    return;\n                }\n            }\n        });\n\n        if (events.useAttachEvent) {\n            // For IE's lack of Event#preventDefault\n            events.add(doc, 'selectstart', function (event) {\n                var interaction = interactions[0];\n\n                if (interaction.currentAction()) {\n                    interaction.checkAndPreventDefault(event);\n                }\n            });\n\n            // For IE's bad dblclick event sequence\n            events.add(doc, 'dblclick', doOnInteractions('ie8Dblclick'));\n        }\n\n        documents.push(doc);\n    }\n\n    listenToDocument(document);\n\n    function indexOf (array, target) {\n        for (var i = 0, len = array.length; i < len; i++) {\n            if (array[i] === target) {\n                return i;\n            }\n        }\n\n        return -1;\n    }\n\n    function contains (array, target) {\n        return indexOf(array, target) !== -1;\n    }\n\n    function matchesSelector (element, selector, nodeList) {\n        if (ie8MatchesSelector) {\n            return ie8MatchesSelector(element, selector, nodeList);\n        }\n\n        // remove /deep/ from selectors if shadowDOM polyfill is used\n        if (window !== realWindow) {\n            selector = selector.replace(/\\/deep\\//g, ' ');\n        }\n\n        return element[prefixedMatchesSelector](selector);\n    }\n\n    function matchesUpTo (element, selector, limit) {\n        while (isElement(element)) {\n            if (matchesSelector(element, selector)) {\n                return true;\n            }\n\n            element = parentElement(element);\n\n            if (element === limit) {\n                return matchesSelector(element, selector);\n            }\n        }\n\n        return false;\n    }\n\n    // For IE8's lack of an Element#matchesSelector\n    // taken from http://tanalin.com/en/blog/2012/12/matches-selector-ie8/ and modified\n    if (!(prefixedMatchesSelector in Element.prototype) || !isFunction(Element.prototype[prefixedMatchesSelector])) {\n        ie8MatchesSelector = function (element, selector, elems) {\n            elems = elems || element.parentNode.querySelectorAll(selector);\n\n            for (var i = 0, len = elems.length; i < len; i++) {\n                if (elems[i] === element) {\n                    return true;\n                }\n            }\n\n            return false;\n        };\n    }\n\n    // requestAnimationFrame polyfill\n    (function() {\n        var lastTime = 0,\n            vendors = ['ms', 'moz', 'webkit', 'o'];\n\n        for(var x = 0; x < vendors.length && !realWindow.requestAnimationFrame; ++x) {\n            reqFrame = realWindow[vendors[x]+'RequestAnimationFrame'];\n            cancelFrame = realWindow[vendors[x]+'CancelAnimationFrame'] || realWindow[vendors[x]+'CancelRequestAnimationFrame'];\n        }\n\n        if (!reqFrame) {\n            reqFrame = function(callback) {\n                var currTime = new Date().getTime(),\n                    timeToCall = Math.max(0, 16 - (currTime - lastTime)),\n                    id = setTimeout(function() { callback(currTime + timeToCall); },\n                  timeToCall);\n                lastTime = currTime + timeToCall;\n                return id;\n            };\n        }\n\n        if (!cancelFrame) {\n            cancelFrame = function(id) {\n                clearTimeout(id);\n            };\n        }\n    }());\n\n    /* global exports: true, module, define */\n\n    // http://documentcloud.github.io/underscore/docs/underscore.html#section-11\n    if (typeof exports !== 'undefined') {\n        if (typeof module !== 'undefined' && module.exports) {\n            exports = module.exports = interact;\n        }\n        exports.interact = interact;\n    }\n    // AMD\n    else if (typeof define === 'function' && define.amd) {\n        define('interact', function() {\n            return interact;\n        });\n    }\n    else {\n        realWindow.interact = interact;\n    }\n\n} (typeof window === 'undefined'? undefined : window));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/interact.js/interact.js\n// module id = 13\n// module chunks = 0","export function manageZIndex(event) {\n  let { target } = event;\n\n  this.lastZ = this.lastZ ? this.lastZ+=1 : 1;\n  target.style.zIndex = this.lastZ;\n}\n\n\nexport function dragHandler(event) {\n  let newX, newY;\n  let { target, dx, dy } = event;\n\n  // Ensure target always has higher z-index than siblings\n  let siblingNodes = target.parentElement.children;\n\n  newX = (parseFloat(target.getAttribute('data-x')) || 0) + dx;\n  newY = (parseFloat(target.getAttribute('data-y')) || 0) + dy;\n  target.style.webkitTransform = target.style.transform = `translate(${newX}px, ${newY}px)`;\n  target.setAttribute('data-x', newX);\n  target.setAttribute('data-y', newY);\n}\n\nexport function resizeHandler(event) {\n  let x, y;\n  let { target, dx, dy } = event;\n  x = (parseFloat(target.getAttribute('data-x')) || 0);\n  y = (parseFloat(target.getAttribute('data-y')) || 0);\n\n  if (event.rect.height <= 400 && event.rect.height >= 100 ) {\n    // update the element's style\n    target.style.width  = event.rect.width + 'px';\n    target.style.height = event.rect.height + 'px';\n\n    // translate when resizing from top or left edges\n    x += event.deltaRect.left;\n    y += event.deltaRect.top;\n\n    target.style.webkitTransform = target.style.transform = 'translate(' + x + 'px,' + y + 'px)';\n  }\n\n  target.setAttribute('data-x', x);\n  target.setAttribute('data-y', y);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/utils/interact.js","import { LOADER } from '../constants/copy';\n// import Contributions from 'articles/contributions';\nimport Galleries from 'articles/galleries';\nimport Lightbox from 'articles/lightbox';\n\nclass Articles {\n  constructor(elems) {\n\n    this.elems = elems;\n\n    this.elems.articles = {\n      $articles : [].slice.call(document.getElementsByClassName('articles-category'))\n    };\n\n    this.elems.articles.$articles.map(($discipline, i) => {\n      $discipline.addEventListener('click', (e) => {\n        $('.articles-category').removeClass('darkgray');\n        e.target.classList.add('darkgray');\n        window.history.pushState(null, null, e.target.getAttribute('href'));\n      });\n    });\n\n    if (document.getElementsByClassName('slick-gallery')) {\n      let $galleryEls = $('.slick-gallery');\n      this.Galleries = new Galleries($galleryEls);\n    }\n\n    if (document.getElementsByClassName('lightbox-trigger')) {\n      this.Lightbox = new Lightbox();\n    }\n\n    if (document.getElementById('article-show')) {\n      // Sub-components\n      // this.Contributions  = new Contributions('Contributions', this.elems);\n      // Effects\n      this.progress = this.initProgressBar();\n    }\n  }\n\n  initProgressBar() {\n    this.elems.$progress = document.getElementById('progress');\n\n    // refreshes progress with each window scroll and resize event fired\n    ['scroll', 'resize'].forEach((e) => {\n      window.addEventListener(e, (f) => {\n        this.progress = this.updateProgressBar();\n      });\n    });\n\n    return this.updateProgressBar();\n  }\n\n  updateProgressBar() {\n\n    let viewHeight    = window.innerHeight;\n    let docLength     = document.body.scrollHeight;\n    let totalDistance = docLength - viewHeight;\n    let scrollTop     = (window.pageYOffset !== undefined) ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n\n    let percentage    = (scrollTop / totalDistance) * 100;\n\n    this.elems.$progress.style.width = percentage + '%';\n\n    return {\n      $progress: this.elems.$progress,\n      docLength: docLength,\n      totalDistance: totalDistance,\n      scrollTop: scrollTop,\n      percentage: percentage\n    }\n  }\n}\n\nexport default Articles;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/articles/index.js","class Galleries {\n  constructor(elems) {\n    this.elems = elems;\n    this.galleries = this.elems.map((index, gallery) => this.initGallery(gallery))\n  }\n\n  initGallery(gallery) {\n    let $this   = $(gallery);\n    let $center = $this.siblings('.center'); \n    $(gallery).slick({\n      appendDots: $center.find('.dots-parent')\n    });\n\n    $center.find('.slider-next-arrow').click(() => {\n      $this.slick('slickNext');\n    });\n\n    $center.find('.slider-prev-arrow').click(() => {\n      $this.slick('slickPrev');\n    });\n\n    if ($this.hasClass('focus-mode')) {\n      let $focusSlider = $this;\n      $this.find('.slick-slide').on('click', function(e) {\n        e.stopPropagation();\n        let $this = $(this);\n        let index = $(this).data().slickIndex;\n\n        if ($focusSlider.slick('slickCurrentSlide') !== index) {\n          $focusSlider.slick('slickCurrentSlide') > index ? $focusSlider.slick('slickPrev'): $focusSlider.slick('slickNext');\n        }\n      })\n    }\n  }\n}\n\nexport default Galleries;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/articles/galleries/index.js","import { LIGHTBOX_SLIDER } from '../../constants/settings';\n\nclass Lightbox {\n  constructor() {\n    this.initializers = [].slice.call(document.getElementsByClassName('lightbox-trigger'));\n    this.destroyers   = null;\n    this.lightboxEl = document.getElementById('lightbox');\n    this.lightboxGalleryEl = document.getElementsByClassName('lightbox-gallery')[0];\n    this.slickGallery = null;\n    this.isActive = false;\n    this.prevArrow = document.querySelector(this.selectors.prevArrow);\n    this.nextArrow = document.querySelector(this.selectors.nextArrow);\n    this.widthRequirement = 1024;\n    this.buildInitializers();\n  }\n\n  selectors = {\n    prevArrow: '[data-prev-arrow]',\n    nextArrow: '[data-next-arrow]',\n  };\n\n  buildInitializers() {\n    this.initializers.map((initializer, i) => {\n      initializer.addEventListener('click', e => {\n        if (parseInt($(window).width()) >= this.widthRequirement) {\n          if (!this.isActive) {\n            this.isActive = true;\n            this.buildGallery(initializer);\n            return this.openLightbox();\n          }\n        }\n      })\n    });\n  }\n\n  buildDestroyers() {\n    this.destroyers.map((destroyer, i) => {\n      destroyer.addEventListener('click', e => {\n        if (this.isActive) {\n          this.isActive = false;\n          this.destroyGallery();\n          return this.closeLightbox();\n        }\n      });\n    });\n  }\n\n  initGallery() {\n    let $lightboxGalleryEl = $(this.lightboxGalleryEl);\n    $lightboxGalleryEl.slick(LIGHTBOX_SLIDER);\n    this.slickGallery = $lightboxGalleryEl;\n  }\n\n  destroyGallery() {\n    this.slickGallery.slick('unslick');\n    this.slickGallery    = null;\n    let lightboxGallery  = this.lightboxGalleryEl.cloneNode(false);\n    this.lightboxEl.replaceChild(lightboxGallery, this.lightboxGalleryEl);\n    this.lightboxGalleryEl = lightboxGallery;\n  }\n\n  buildGallery(targetEl) {\n    // Get Lightbox Els\n    let siblingNodeList    = targetEl.parentNode.children;\n    let galleryEls         = [].slice.call(siblingNodeList).filter((el) => el.hasAttribute('data-image-url'));\n    let targetIndex        = galleryEls.indexOf(targetEl);\n    let lightboxGalleryEls = galleryEls.slice(targetIndex).concat(galleryEls.slice(0, targetIndex));\n\n    if (galleryEls.length === 1) {\n      this.hideArrows();\n    } else {\n      this.showArrows();\n    }\n\n    lightboxGalleryEls.map((el, i) => {\n      // Build Nodes\n      let childEls         = [].slice.call(el.children);\n      let slide            = document.createElement('div');\n      let imgWrapper       = document.createElement('div');\n      let imgEl            = document.createElement('img');\n      imgEl.src            = el.dataset.imageUrl;\n\n      // Build Slide\n      imgWrapper.classList.add('lightbox-destroy');\n      imgWrapper.appendChild(imgEl);\n\n      // Add Caption if it exists\n      let imgCaption = childEls.find(el => el.classList.contains('img-caption-container'));\n      if (imgCaption) {\n        let captionClone = imgCaption.cloneNode(true);\n        imgWrapper.appendChild(captionClone);\n      }\n      slide.appendChild(imgWrapper);\n\n      // Append Els\n      this.lightboxGalleryEl.appendChild(slide)\n\n      // Setup Destroyers\n      this.destroyers = [].slice.call(document.querySelectorAll('.lightbox-gallery'));\n      this.buildDestroyers();\n    });\n  }\n\n  hideArrows() {\n    this.prevArrow.classList.add('hide');\n    this.nextArrow.classList.add('hide');\n  }\n\n  showArrows() {\n    this.prevArrow.classList.remove('hide');\n    this.nextArrow.classList.remove('hide');\n  }\n\n  openLightbox() {\n    this.initGallery();\n    this.lightboxEl.classList.add('active');\n  }\n\n  closeLightbox() {\n    this.lightboxEl.classList.remove('active');\n  }\n}\n\nexport default Lightbox;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/articles/lightbox/index.js","class Museboard {\n  constructor(elems) {\n    this.paginators        = [].slice.call(document.getElementsByClassName('reference-paginator'));\n    this.refBlocks         = [].slice.call(document.getElementsByClassName('reference-block'));\n    this.references        = [].slice.call(document.getElementsByClassName('mb-reference'));\n    this.refsToggle         = [].slice.call(document.getElementsByClassName('ref-toggle'));\n\n    this.refsToggle.map((toggle, i) => {\n      toggle.addEventListener('click', (e) => {\n        let target     = e.target;\n        let refsToggle = this.refsToggle[0];\n        let refsList   = [].slice.call(document.getElementsByClassName('ref-list-mobile'))[0];\n\n        if (refsList.classList.contains('showing')) {\n          return refsList.classList.remove('showing');\n        }\n        return refsList.classList.add('showing');\n      });\n    });\n\n    //Pagination\n    if (this.paginators.length) {\n      this.paginators.map((paginator, i) => {\n        paginator.addEventListener('click', (e) => {\n          let target       = e.target;\n          let targetIndex  = parseInt(target.dataset.refBlockIndex);\n          let targetBlock  = document.getElementsByClassName(`ref-block-${targetIndex}`)[0];\n\n          if (target.classList.contains('active') && targetBlock.classList.contains('active')) { return; }\n\n          this.paginators.map((paginator) => removeClassName(paginator, 'active'))\n          this.refBlocks.map((block) => removeClassName(block, 'active'));\n\n          target.classList.add('active');\n          targetBlock.classList.add('active');\n        })\n      });\n    }\n\n    //Hover On/Off\n    this.references.map((ref, i) => {\n      ref.addEventListener('mouseenter', (e) => {\n        let targetRef     = e.target;\n        let refBlockIndex = parseInt(targetRef.parentElement.dataset.refBlockIndex);\n        let targetImage   = findTargetImage(targetRef, refBlockIndex);\n\n        if (\n            targetImage.classList.contains('active-select') &&\n            targetRef.classList.contains('active-select')\n          ) { return; }\n        this.hoverImageOn(targetImage);\n      });\n\n      ref.addEventListener('mouseleave', (e) => {\n        let targetRef     = e.target;\n        let refBlockIndex = parseInt(targetRef.parentElement.dataset.refBlockIndex);\n        let targetImage   = findTargetImage(targetRef, refBlockIndex);\n\n        if (\n            targetImage.classList.contains('active-select') &&\n            targetRef.classList.contains('active-select')\n          ) { return; }\n        this.hoverImageOff(targetImage);\n      });\n\n      // Click\n      ref.addEventListener('click', (e) => {\n        let targetRef   = e.currentTarget;\n        let refBlockIndex = parseInt(targetRef.parentElement.dataset.refBlockIndex);\n        let targetImage = findTargetImage(targetRef, refBlockIndex);\n\n        if (\n            targetImage.classList.contains('active-select') &&\n            targetRef.classList.contains('active-select')\n          ) {\n          return this.deselectReference(targetImage, targetRef);\n        }\n\n        return this.selectReference(targetImage, targetRef);\n      });\n    });\n  }\n\n  hoverImageOn(img) {\n    img.classList.add('active-hover');\n  }\n\n  hoverImageOff(img) {\n    img.classList.remove('active-hover');\n  }\n\n  selectReference(img, ref) {\n    ref.classList.add('active-select');\n    img.classList.add('active-select');\n  }\n\n  deselectReference(img, ref) {\n    ref.classList.remove('active-select');\n    img.classList.remove('active-select');\n  }\n}\n\nfunction findTargetImage(target, index=0) {\n  let imgBaseClass = 'ref-img';\n  let targetIndex  = target.dataset.refIndex;\n\n  return document.getElementsByClassName(`${imgBaseClass}-${targetIndex}`)[index] || null;\n}\n\nfunction removeClassName(el, className) {\n  if (el.classList.contains(className)) {\n    return el.classList.remove(className);\n  }\n  return el;\n}\n\nexport default Museboard;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/articles/museboard/index.js","class Disciplines {\n  constructor(elems) {\n\n    this.elems = elems;\n\n    this.elems.disciplines = {\n      $disciplines : [].slice.call(document.getElementsByClassName('disciplines-category'))\n    };\n\n    this.elems.disciplines.$disciplines.map(($discipline, i) => {\n      $discipline.addEventListener('click', (e) => {\n        $('.disciplines-category').removeClass('darkgray');\n        e.target.classList.add('darkgray');\n        window.history.pushState(null, null, e.target.getAttribute('href'));\n      });\n    });\n\n  }\n}\n\nexport default Disciplines;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/disciplines/index.js","class Musts {\n  constructor(elems) {\n    this.elems = elems;\n\n    this.elems.musts = {\n      $musts : [].slice.call(document.getElementsByClassName('musts-category'))\n    };\n\n    this.elems.musts.$musts.map(($discipline, i) => {\n      $discipline.addEventListener('click', (e) => {\n        $('.musts-category').removeClass('darkgray');\n        e.target.classList.add('darkgray');\n        window.history.pushState(null, null, e.target.getAttribute('href'));\n      });\n    });\n\n  }\n}\n\nexport default Musts;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/musts/index.js","import Subnav from 'global/subnav';\nimport { GLOBALS } from 'constants/settings';\n\nclass Creators {\n  constructor(elems) {\n    this.elems = elems;\n\n    this.elems.creators = {\n      $nav      : document.getElementById('creators-navigation'),\n      $letters  : [].slice.call(document.getElementsByClassName('creators-mobile-subnav-option')),\n      $name     : document.getElementById('creator-name'),\n      $results  : document.getElementById('creator-results'),\n      $creators : [].slice.call(document.getElementsByClassName('creators-list-entry'))\n    };\n\n    this.elems.creators.$letters.map(($letter, i) => {\n      $letter.addEventListener('click', (e) => {\n        $('html, body').animate({\n          scrollTop: this.elems.creators.$nav.offsetTop - 100\n        }, GLOBALS.transition * 2);\n      });\n    });\n\n    this.elems.creators.$creators.map(($creator, i) => {\n      $creator.addEventListener('click', (e) => {\n        $('.creators-list-entry').removeClass('active');\n        $creator.classList.add('active');\n        this.elems.creators.$name.innerHTML = e.target.innerHTML;\n        window.history.pushState(null, null, e.target.getAttribute('href'));\n      });\n    });\n\n    this.Subnav       = new Subnav('creators', this.elems);\n    this.MobileSubnav = new Subnav('creators-mobile', this.elems);\n  }\n}\n\nexport default Creators;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/creators/index.js","import Subnav from 'global/subnav';\nimport { GLOBALS } from 'constants/settings';\n\nclass Terms {\n  constructor(elems) {\n\n    this.elems = elems;\n\n    this.elems.terms = {\n      $nav      : document.getElementById('terms-navigation'),\n      $name     : document.getElementById('term-name'),\n      $results  : document.getElementById('term-results-name'),\n      $def      : document.getElementById('term-definition'),\n      $letters  : [].slice.call(document.getElementsByClassName('terms-mobile-subnav-option')),\n      $terms    : [].slice.call(document.getElementsByClassName('terms-list-entry'))\n    };\n\n    this.elems.terms.$letters.map(($letter, i) => {\n      $letter.addEventListener('click', (e) => {\n        $('html, body').animate({\n          scrollTop: this.elems.terms.$nav.offsetTop - 100\n        }, GLOBALS.transition * 2);\n      });\n    });\n\n    this.elems.terms.$terms.map(($term, i) => {\n      $term.addEventListener('click', (e) => {\n        $('.terms-list-entry').removeClass('active');\n        $term.classList.add('active');\n        this.elems.terms.$name.innerHTML  = e.target.innerHTML;\n        this.elems.terms.$results.innerHTML  = e.target.innerHTML;\n        this.elems.terms.$def.innerHTML   = e.target.dataset.definition;\n        window.history.pushState(null, null, e.target.getAttribute('href'));\n      });\n    });\n\n    this.Subnav       = new Subnav('terms', this.elems);\n    this.MobileSubnav = new Subnav('terms-mobile', this.elems);\n  }\n}\n\nexport default Terms;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/terms/index.js","import Subnav from 'global/subnav';\n\nclass About {\n  constructor(elems) {\n\n    this.elems = elems;\n\n    this.Subnav = new Subnav('about', this.elems);\n  }\n}\n\nexport default About;\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/about/index.js"],"sourceRoot":""}