text: // DOM.event.move
  //
  // 2.0.0
  //
  // Stephen Band
  //
  // Triggers 'movestart', 'move' and 'moveend' events after
  // mousemoves following a mousedown cross a distance threshold,
  // similar to the native 'dragstart', 'drag' and 'dragend' events.
  // Move events are throttled to animation frames. Move event objects
  // have the properties:
  //
  // pageX:
  // pageY:     Page coordinates of pointer.
  // startX:
  // startY:    Page coordinates of pointer at movestart.
  // distX:
  // distY:     Distance the pointer has moved since movestart.
  // deltaX:
  // deltaY:    Distance the finger has moved since last event.
  // velocityX:
  // velocityY: Average velocity over last few events.
  
  
  (function(fn) {
  	if (typeof define === 'function' && define.amd) {
          define([], fn);
      } else if ((typeof module !== "undefined" && module !== null) && module.exports) {
          module.exports = fn;
  	} else {
  		fn();
  	}
  })(function(){
  	var assign = Object.assign || window.jQuery && jQuery.extend;
  
  	// Number of pixels a pressed pointer travels before movestart
  	// event is fired.
  	var threshold = 8;
  
  	// Shim for requestAnimationFrame, falling back to timer. See:
  	// see http://paulirish.com/2011/requestanimationframe-for-smart-animating/
  	var requestFrame = (function(){
  		return (
  			window.requestAnimationFrame ||
  			window.webkitRequestAnimationFrame ||
  			window.mozRequestAnimationFrame ||
  			window.oRequestAnimationFrame ||
  			window.msRequestAnimationFrame ||
  			function(fn, element){
  				return window.setTimeout(function(){
  					fn();
  				}, 25);
  			}
  		);
  	})();
  	
  	// Shim for customEvent
  	// see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent#Polyfill
  	(function () {
  		if ( typeof window.CustomEvent === "function" ) return false;
  		function CustomEvent ( event, params ) {
  			params = params || { bubbles: false, cancelable: false, detail: undefined };
  			var evt = document.createEvent( 'CustomEvent' );
  			evt.initCustomEvent( event, params.bubbles, params.cancelable, params.detail );
  			return evt;
  		}
  		
  		CustomEvent.prototype = window.Event.prototype;
  		window.CustomEvent = CustomEvent;
  	})();
  
  	var ignoreTags = {
  			textarea: true,
  			input: true,
  			select: true,
  			button: true
  		};
  
  	var mouseevents = {
  		move:   'mousemove',
  		cancel: 'mouseup dragstart',
  		end:    'mouseup'
  	};
  
  	var touchevents = {
  		move:   'touchmove',
  		cancel: 'touchend',
  		end:    'touchend'
  	};
  
  	var rspaces = /\s+/;
  
  
  	// DOM Events
  
  	var eventOptions = { bubbles: true, cancelable: true };
  
  	var eventsSymbol = typeof Symbol === "function" ? Symbol('events') : {};
  
  	function createEvent(type) {
  		return new CustomEvent(type, eventOptions);
  	}
  
  	function getEvents(node) {
  		return node[eventsSymbol] || (node[eventsSymbol] = {});
  	}
  
  	function on(node, types, fn, data, selector) {
  		types = types.split(rspaces);
  
  		var events = getEvents(node);
  		var i = types.length;
  		var handlers, type;
  
  		function handler(e) { fn(e, data); }
  
  		while (i--) {
  			type = types[i];
  			handlers = events[type] || (events[type] = []);
  			handlers.push([fn, handler]);
  			node.addEventListener(type, handler);
  		}
  	}
  
  	function off(node, types, fn, selector) {
  		types = types.split(rspaces);
  
  		var events = getEvents(node);
  		var i = types.length;
  		var type, handlers, k;
  
  		if (!events) { return; }
  
  		while (i--) {
  			type = types[i];
  			handlers = events[type];
  			if (!handlers) { continue; }
  			k = handlers.length;
  			while (k--) {
  				if (handlers[k][0] === fn) {
  					node.removeEventListener(type, handlers[k][1]);
  					handlers.splice(k, 1);
  				}
  			}
  		}
  	}
  
  	function trigger(node, type, properties) {
  		// Don't cache events. It prevents you from triggering an event of a
  		// given type from inside the handler of another event of that type.
  		var event = createEvent(type);
  		if (properties) { assign(event, properties); }
  		node.dispatchEvent(event);
  	}
  
  
  	// Constructors
  
  	function Timer(fn){
  		var callback = fn,
  		    active = false,
  		    running = false;
  
  		function trigger(time) {
  			if (active){
  				callback();
  				requestFrame(trigger);
  				running = true;
  				active = false;
  			}
  			else {
  				running = false;
  			}
  		}
  
  		this.kick = function(fn) {
  			active = true;
  			if (!running) { trigger(); }
  		};
  
  		this.end = function(fn) {
  			var cb = callback;
  
  			if (!fn) { return; }
  
  			// If the timer is not running, simply call the end callback.
  			if (!running) {
  				fn();
  			}
  			// If the timer is running, and has been kicked lately, then
  			// queue up the current callback and the end callback, otherwise
  			// just the end callback.
  			else {
  				callback = active ?
  					function(){ cb(); fn(); } :
  					fn ;
  
  				active = true;
  			}
  		};
  	}
  
  
  	// Functions
  
  	function noop() {}
  
  	function preventDefault(e) {
  		e.preventDefault();
  	}
  
  	function isIgnoreTag(e) {
  		return !!ignoreTags[e.target.tagName.toLowerCase()];
  	}
  
  	function isPrimaryButton(e) {
  		// Ignore mousedowns on any button other than the left (or primary)
  		// mouse button, or when a modifier key is pressed.
  		return (e.which === 1 && !e.ctrlKey && !e.altKey);
  	}
  
  	function identifiedTouch(touchList, id) {
  		var i, l;
  
  		if (touchList.identifiedTouch) {
  			return touchList.identifiedTouch(id);
  		}
  
  		// touchList.identifiedTouch() does not exist in
  		// webkit yet… we must do the search ourselves...
  
  		i = -1;
  		l = touchList.length;
  
  		while (++i < l) {
  			if (touchList[i].identifier === id) {
  				return touchList[i];
  			}
  		}
  	}
  
  	function changedTouch(e, data) {
  		var touch = identifiedTouch(e.changedTouches, data.identifier);
  
  		// This isn't the touch you're looking for.
  		if (!touch) { return; }
  
  		// Chrome Android (at least) includes touches that have not
  		// changed in e.changedTouches. That's a bit annoying. Check
  		// that this touch has changed.
  		if (touch.pageX === data.pageX && touch.pageY === data.pageY) { return; }
  
  		return touch;
  	}
  
  
  	// Handlers that decide when the first movestart is triggered
  
  	function mousedown(e){
  		// Ignore non-primary buttons
  		if (!isPrimaryButton(e)) { return; }
  
  		// Ignore form and interactive elements
  		if (isIgnoreTag(e)) { return; }
  
  		on(document, mouseevents.move, mousemove, e);
  		on(document, mouseevents.cancel, mouseend, e);
  	}
  
  	function mousemove(e, data){
  		checkThreshold(e, data, e, removeMouse);
  	}
  
  	function mouseend(e, data) {
  		removeMouse();
  	}
  
  	function removeMouse() {
  		off(document, mouseevents.move, mousemove);
  		off(document, mouseevents.cancel, mouseend);
  	}
  
  	function touchstart(e) {
  		// Don't get in the way of interaction with form elements
  		if (ignoreTags[e.target.tagName.toLowerCase()]) { return; }
  
  		var touch = e.changedTouches[0];
  
  		// iOS live updates the touch objects whereas Android gives us copies.
  		// That means we can't trust the touchstart object to stay the same,
  		// so we must copy the location. This object acts as a template for
  		// movestart, move and moveend event objects.
  		var data = {
  			target:     touch.target,
  			pageX:      touch.pageX,
  			pageY:      touch.pageY,
  			identifier: touch.identifier,
  
  			// The only way to make handlers individually unbindable is by
  			// making them unique.
  			touchmove:  function(e, data) { touchmove(e, data); },
  			touchend:   function(e, data) { touchend(e, data); }
  		};
  
  		on(document, touchevents.move, data.touchmove, data);
  		on(document, touchevents.cancel, data.touchend, data);
  	}
  
  	function touchmove(e, data) {
  		var touch = changedTouch(e, data);
  		if (!touch) { return; }
  		checkThreshold(e, data, touch, removeTouch);
  	}
  
  	function touchend(e, data) {
  		var touch = identifiedTouch(e.changedTouches, data.identifier);
  		if (!touch) { return; }
  		removeTouch(data);
  	}
  
  	function removeTouch(data) {
  		off(document, touchevents.move, data.touchmove);
  		off(document, touchevents.cancel, data.touchend);
  	}
  
  	function checkThreshold(e, data, touch, fn) {
  		var distX = touch.pageX - data.pageX;
  		var distY = touch.pageY - data.pageY;
  
  		// Do nothing if the threshold has not been crossed.
  		if ((distX * distX) + (distY * distY) < (threshold * threshold)) { return; }
  
  		triggerStart(e, data, touch, distX, distY, fn);
  	}
  
  	function triggerStart(e, data, touch, distX, distY, fn) {
  		var touches = e.targetTouches;
  		var time = e.timeStamp - data.timeStamp;
  
  		// Create a movestart object with some special properties that
  		// are passed only to the movestart handlers.
  		var template = {
  			altKey:     e.altKey,
  			ctrlKey:    e.ctrlKey,
  			shiftKey:   e.shiftKey,
  			startX:     data.pageX,
  			startY:     data.pageY,
  			distX:      distX,
  			distY:      distY,
  			deltaX:     distX,
  			deltaY:     distY,
  			pageX:      touch.pageX,
  			pageY:      touch.pageY,
  			velocityX:  distX / time,
  			velocityY:  distY / time,
  			identifier: data.identifier,
  			targetTouches: touches,
  			finger: touches ? touches.length : 1,
  			enableMove: function() {
  				this.moveEnabled = true;
  				this.enableMove = noop;
  				e.preventDefault();
  			}
  		};
  
  		// Trigger the movestart event.
  		trigger(data.target, 'movestart', template);
  
  		// Unbind handlers that tracked the touch or mouse up till now.
  		fn(data);
  	}
  
  
  	// Handlers that control what happens following a movestart
  
  	function activeMousemove(e, data) {
  		var timer  = data.timer;
  
  		data.touch = e;
  		data.timeStamp = e.timeStamp;
  		timer.kick();
  	}
  
  	function activeMouseend(e, data) {
  		var target = data.target;
  		var event  = data.event;
  		var timer  = data.timer;
  
  		removeActiveMouse();
  
  		endEvent(target, event, timer, function() {
  			// Unbind the click suppressor, waiting until after mouseup
  			// has been handled.
  			setTimeout(function(){
  				off(target, 'click', preventDefault);
  			}, 0);
  		});
  	}
  
  	function removeActiveMouse() {
  		off(document, mouseevents.move, activeMousemove);
  		off(document, mouseevents.end, activeMouseend);
  	}
  
  	function activeTouchmove(e, data) {
  		var event = data.event;
  		var timer = data.timer;
  		var touch = changedTouch(e, event);
  
  		if (!touch) { return; }
  
  		// Stop the interface from gesturing
  		e.preventDefault();
  
  		event.targetTouches = e.targetTouches;
  		data.touch = touch;
  		data.timeStamp = e.timeStamp;
  
  		timer.kick();
  	}
  
  	function activeTouchend(e, data) {
  		var target = data.target;
  		var event  = data.event;
  		var timer  = data.timer;
  		var touch  = identifiedTouch(e.changedTouches, event.identifier);
  
  		// This isn't the touch you're looking for.
  		if (!touch) { return; }
  
  		removeActiveTouch(data);
  		endEvent(target, event, timer);
  	}
  
  	function removeActiveTouch(data) {
  		off(document, touchevents.move, data.activeTouchmove);
  		off(document, touchevents.end, data.activeTouchend);
  	}
  
  
  	// Logic for triggering move and moveend events
  
  	function updateEvent(event, touch, timeStamp) {
  		var time = timeStamp - event.timeStamp;
  
  		event.distX =  touch.pageX - event.startX;
  		event.distY =  touch.pageY - event.startY;
  		event.deltaX = touch.pageX - event.pageX;
  		event.deltaY = touch.pageY - event.pageY;
  
  		// Average the velocity of the last few events using a decay
  		// curve to even out spurious jumps in values.
  		event.velocityX = 0.3 * event.velocityX + 0.7 * event.deltaX / time;
  		event.velocityY = 0.3 * event.velocityY + 0.7 * event.deltaY / time;
  		event.pageX =  touch.pageX;
  		event.pageY =  touch.pageY;
  	}
  
  	function endEvent(target, event, timer, fn) {
  		timer.end(function(){
  			trigger(target, 'moveend', event);
  			return fn && fn();
  		});
  	}
  
  
  	// Set up the DOM
  
  	function movestart(e) {
  		if (e.defaultPrevented) { return; }
  		if (!e.moveEnabled) { return; }
  
  		var event = {
  			startX:        e.startX,
  			startY:        e.startY,
  			pageX:         e.pageX,
  			pageY:         e.pageY,
  			distX:         e.distX,
  			distY:         e.distY,
  			deltaX:        e.deltaX,
  			deltaY:        e.deltaY,
  			velocityX:     e.velocityX,
  			velocityY:     e.velocityY,
  			identifier:    e.identifier,
  			targetTouches: e.targetTouches,
  			finger:        e.finger
  		};
  
  		var data = {
  			target:    e.target,
  			event:     event,
  			timer:     new Timer(update),
  			touch:     undefined,
  			timeStamp: e.timeStamp
  		};
  
  		function update(time) {
  			updateEvent(event, data.touch, data.timeStamp);
  			trigger(data.target, 'move', event);
  		}
  
  		if (e.identifier === undefined) {
  			// We're dealing with a mouse event.
  			// Stop clicks from propagating during a move
  			on(e.target, 'click', preventDefault);
  			on(document, mouseevents.move, activeMousemove, data);
  			on(document, mouseevents.end, activeMouseend, data);
  		}
  		else {
  			// In order to unbind correct handlers they have to be unique
  			data.activeTouchmove = function(e, data) { activeTouchmove(e, data); };
  			data.activeTouchend = function(e, data) { activeTouchend(e, data); };
  
  			// We're dealing with a touch.
  			on(document, touchevents.move, data.activeTouchmove, data);
  			on(document, touchevents.end, data.activeTouchend, data);
  		}
  	}
  
  	on(document, 'mousedown', mousedown);
  	on(document, 'touchstart', touchstart);
  	on(document, 'movestart', movestart);
  
  
  	// jQuery special events
  	//
  	// jQuery event objects are copies of DOM event objects. They need
  	// a little help copying the move properties across.
  
  	if (!window.jQuery) { return; }
  
  	var properties = ("startX startY pageX pageY distX distY deltaX deltaY velocityX velocityY").split(' ');
  
  	function enableMove1(e) { e.enableMove(); }
  	function enableMove2(e) { e.enableMove(); }
  	function enableMove3(e) { e.enableMove(); }
  
  	function add(handleObj) {
  		var handler = handleObj.handler;
  
  		handleObj.handler = function(e) {
  			// Copy move properties across from originalEvent
  			var i = properties.length;
  			var property;
  
  			while(i--) {
  				property = properties[i];
  				e[property] = e.originalEvent[property];
  			}
  
  			handler.apply(this, arguments);
  		};
  	}
  
  	jQuery.event.special.movestart = {
  		setup: function() {
  			// Movestart must be enabled to allow other move events
  			on(this, 'movestart', enableMove1);
  
  			// Do listen to DOM events
  			return false;
  		},
  
  		teardown: function() {
  			off(this, 'movestart', enableMove1);
  			return false;
  		},
  
  		add: add
  	};
  
  	jQuery.event.special.move = {
  		setup: function() {
  			on(this, 'movestart', enableMove2);
  			return false;
  		},
  
  		teardown: function() {
  			off(this, 'movestart', enableMove2);
  			return false;
  		},
  
  		add: add
  	};
  
  	jQuery.event.special.moveend = {
  		setup: function() {
  			on(this, 'movestart', enableMove3);
  			return false;
  		},
  
  		teardown: function() {
  			off(this, 'movestart', enableMove3);
  			return false;
  		},
  
  		add: add
  	};
  });
  