diff --git a/README.md b/README.md
index 4edf567..17b35f9 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 Include the javascript and css files.
 
 ```html
-<script src="js/jquery-2.1.0.min.js" type="text/javascript"></script>
+<script src="js/jquery-3.2.1.min.js" type="text/javascript"></script>
 <script src="js/jquery.event.move.js" type="text/javascript"></script>
 <script src="js/jquery.twentytwenty.js" type="text/javascript"></script>
 <link rel="stylesheet" href="css/twentytwenty.css" type="text/css" media="screen" />
@@ -25,7 +25,7 @@ After including the files you are ready to create a container that holds two ima
 Now initialize the plugin on the window load:
 
 ```
-$(window).load(function(){
+$(function(){
   $("#container1").twentytwenty();
 });
 ```
@@ -34,7 +34,7 @@ $(window).load(function(){
 
 
 ```js
-$(window).load(function(){
+$(function(){
   $(".twentytwenty-container").twentytwenty({
     default_offset_pct: 0.7, // How much of the before image is visible when the page loads
     orientation: 'vertical', // Orientation of the before and after images ('horizontal' or 'vertical')
@@ -62,7 +62,7 @@ If you want to avoid a [FOUC](http://en.wikipedia.org/wiki/Flash_of_unstyled_con
 If you want to use multiple instances of this plugin on a single page you can target the container class:
 
 ```js
-$(window).load(function(){
+$(function(){
   $(".twentytwenty-container").twentytwenty();
 });
 ```
diff --git a/index.html b/index.html
index 0ee4982..a06c7ee 100644
--- a/index.html
+++ b/index.html
@@ -26,7 +26,7 @@ <h3>Basic Usage</h3>
         </div>
       </div>
     </div>
-    
+
     <div class="row" style="margin-top: 2em; margin-bottom: 2em;">
       <div class="large-4 columns">
         <h3>Vertical Orientation</h3>
@@ -58,12 +58,15 @@ <h3>Side by side</h3>
         </div>
       </div>
     </div>
-    
-    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.10.1/jquery.min.js"></script>
+
+    <script
+  src="https://code.jquery.com/jquery-3.2.1.js"
+  integrity="sha256-DZAnKJ/6XZ9si04Hgrsxu/8s717jcIzLy3oi35EouyE="
+  crossorigin="anonymous"></script>
     <script src="js/jquery.event.move.js"></script>
     <script src="js/jquery.twentytwenty.js"></script>
     <script>
-    $(window).load(function(){
+    $(function(){
       $(".twentytwenty-container[data-orientation!='vertical']").twentytwenty({default_offset_pct: 0.7});
       $(".twentytwenty-container[data-orientation='vertical']").twentytwenty({default_offset_pct: 0.3, orientation: 'vertical'});
     });
diff --git a/js/jquery.event.move.js b/js/jquery.event.move.js
index 08866fa..6eb633f 100644
--- a/js/jquery.event.move.js
+++ b/js/jquery.event.move.js
@@ -1,6 +1,6 @@
-// jquery.event.move
+// DOM.event.move
 //
-// 1.3.6
+// 2.0.0
 //
 // Stephen Band
 //
@@ -11,85 +11,141 @@
 // have the properties:
 //
 // pageX:
-// pageY:   Page coordinates of pointer.
+// pageY:     Page coordinates of pointer.
 // startX:
-// startY:  Page coordinates of pointer at movestart.
+// startY:    Page coordinates of pointer at movestart.
 // distX:
-// distY:  Distance the pointer has moved since movestart.
+// distY:     Distance the pointer has moved since movestart.
 // deltaX:
-// deltaY:  Distance the finger has moved since last event.
+// deltaY:    Distance the finger has moved since last event.
 // velocityX:
-// velocityY:  Average velocity over last few events.
+// velocityY: Average velocity over last few events.
 
 
-(function (module) {
+(function(fn) {
 	if (typeof define === 'function' && define.amd) {
-		// AMD. Register as an anonymous module.
-		define(['jquery'], module);
+        define([], fn);
+    } else if ((typeof module !== "undefined" && module !== null) && module.exports) {
+        module.exports = fn;
 	} else {
-		// Browser globals
-		module(jQuery);
-	}
-})(function(jQuery, undefined){
-
-	var // Number of pixels a pressed pointer travels before movestart
-	    // event is fired.
-	    threshold = 6,
-	
-	    add = jQuery.event.add,
-	
-	    remove = jQuery.event.remove,
-
-	    // Just sugar, so we can have arguments in the same order as
-	    // add and remove.
-	    trigger = function(node, type, data) {
-	    	jQuery.event.trigger(type, data, node);
-	    },
-
-	    // Shim for requestAnimationFrame, falling back to timer. See:
-	    // see http://paulirish.com/2011/requestanimationframe-for-smart-animating/
-	    requestFrame = (function(){
-	    	return (
-	    		window.requestAnimationFrame ||
-	    		window.webkitRequestAnimationFrame ||
-	    		window.mozRequestAnimationFrame ||
-	    		window.oRequestAnimationFrame ||
-	    		window.msRequestAnimationFrame ||
-	    		function(fn, element){
-	    			return window.setTimeout(function(){
-	    				fn();
-	    			}, 25);
-	    		}
-	    	);
-	    })(),
-	    
-	    ignoreTags = {
-	    	textarea: true,
-	    	input: true,
-	    	select: true,
-	    	button: true
-	    },
-	    
-	    mouseevents = {
-	    	move: 'mousemove',
-	    	cancel: 'mouseup dragstart',
-	    	end: 'mouseup'
-	    },
-	    
-	    touchevents = {
-	    	move: 'touchmove',
-	    	cancel: 'touchend',
-	    	end: 'touchend'
-	    };
+		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);
+			}
+		);
+	})();
+
+	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 = 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();
@@ -101,17 +157,17 @@
 				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();
@@ -121,9 +177,9 @@
 			// just the end callback.
 			else {
 				callback = active ?
-					function(){ cb(); fn(); } : 
+					function(){ cb(); fn(); } :
 					fn ;
-				
+
 				active = true;
 			}
 		};
@@ -131,27 +187,18 @@
 
 
 	// Functions
-	
-	function returnTrue() {
-		return true;
-	}
-	
-	function returnFalse() {
-		return false;
-	}
-	
+
+	function noop() {}
+
 	function preventDefault(e) {
 		e.preventDefault();
 	}
-	
-	function preventIgnoreTags(e) {
-		// Don't prevent interaction with form elements.
-		if (ignoreTags[ e.target.tagName.toLowerCase() ]) { return; }
-		
-		e.preventDefault();
+
+	function isIgnoreTag(e) {
+		return !!ignoreTags[e.target.tagName.toLowerCase()];
 	}
 
-	function isLeftButton(e) {
+	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);
@@ -163,13 +210,13 @@
 		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];
@@ -177,8 +224,8 @@
 		}
 	}
 
-	function changedTouch(e, event) {
-		var touch = identifiedTouch(e.changedTouches, event.identifier);
+	function changedTouch(e, data) {
+		var touch = identifiedTouch(e.changedTouches, data.identifier);
 
 		// This isn't the touch you're looking for.
 		if (!touch) { return; }
@@ -186,192 +233,164 @@
 		// 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 === event.pageX && touch.pageY === event.pageY) { return; }
+		if (touch.pageX === data.pageX && touch.pageY === data.pageY) { return; }
 
 		return touch;
 	}
 
 
 	// Handlers that decide when the first movestart is triggered
-	
-	function mousedown(e){
-		var data;
 
-		if (!isLeftButton(e)) { return; }
+	function mousedown(e){
+		// Ignore non-primary buttons
+		if (!isPrimaryButton(e)) { return; }
 
-		data = {
-			target: e.target,
-			startX: e.pageX,
-			startY: e.pageY,
-			timeStamp: e.timeStamp
-		};
+		// Ignore form and interactive elements
+		if (isIgnoreTag(e)) { return; }
 
-		add(document, mouseevents.move, mousemove, data);
-		add(document, mouseevents.cancel, mouseend, data);
+		on(document, mouseevents.move, mousemove, e);
+		on(document, mouseevents.cancel, mouseend, e);
 	}
 
-	function mousemove(e){
-		var data = e.data;
-
+	function mousemove(e, data){
 		checkThreshold(e, data, e, removeMouse);
 	}
 
-	function mouseend(e) {
+	function mouseend(e, data) {
 		removeMouse();
 	}
 
 	function removeMouse() {
-		remove(document, mouseevents.move, mousemove);
-		remove(document, mouseevents.cancel, mouseend);
+		off(document, mouseevents.move, mousemove);
+		off(document, mouseevents.cancel, mouseend);
 	}
 
 	function touchstart(e) {
-		var touch, template;
+		// Don't get in the way of interaction with form elements
+		if (ignoreTags[e.target.tagName.toLowerCase()]) { return; }
 
-		// Don't get in the way of interaction with form elements.
-		if (ignoreTags[ e.target.tagName.toLowerCase() ]) { return; }
+		var touch = e.changedTouches[0];
 
-		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 data. This object acts as a template for
 		// movestart, move and moveend event objects.
-		template = {
-			target: touch.target,
-			startX: touch.pageX,
-			startY: touch.pageY,
-			timeStamp: e.timeStamp,
-			identifier: touch.identifier
+		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); }
 		};
 
-		// Use the touch identifier as a namespace, so that we can later
-		// remove handlers pertaining only to this touch.
-		add(document, touchevents.move + '.' + touch.identifier, touchmove, template);
-		add(document, touchevents.cancel + '.' + touch.identifier, touchend, template);
+		on(document, touchevents.move, data.touchmove, data);
+		on(document, touchevents.cancel, data.touchend, data);
 	}
 
-	function touchmove(e){
-		var data = e.data,
-		    touch = changedTouch(e, data);
-
+	function touchmove(e, data) {
+		var touch = changedTouch(e, data);
 		if (!touch) { return; }
-
 		checkThreshold(e, data, touch, removeTouch);
 	}
 
-	function touchend(e) {
-		var template = e.data,
-		    touch = identifiedTouch(e.changedTouches, template.identifier);
-
+	function touchend(e, data) {
+		var touch = identifiedTouch(e.changedTouches, data.identifier);
 		if (!touch) { return; }
-
-		removeTouch(template.identifier);
+		removeTouch(data);
 	}
 
-	function removeTouch(identifier) {
-		remove(document, '.' + identifier, touchmove);
-		remove(document, '.' + identifier, touchend);
+	function removeTouch(data) {
+		off(document, touchevents.move, data.touchmove);
+		off(document, touchevents.cancel, data.touchend);
 	}
 
-
-	// Logic for deciding when to trigger a movestart.
-
-	function checkThreshold(e, template, touch, fn) {
-		var distX = touch.pageX - template.startX,
-		    distY = touch.pageY - template.startY;
+	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, template, touch, distX, distY, fn);
-	}
-
-	function handled() {
-		// this._handled should return false once, and after return true.
-		this._handled = returnTrue;
-		return false;
+		triggerStart(e, data, touch, distX, distY, fn);
 	}
 
-	function flagAsHandled(e) {
-		e._handled();
-	}
-
-	function triggerStart(e, template, touch, distX, distY, fn) {
-		var node = template.target,
-		    touches, time;
-
-		touches = e.targetTouches;
-		time = e.timeStamp - template.timeStamp;
+	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.
-		template.type = 'movestart';
-		template.distX = distX;
-		template.distY = distY;
-		template.deltaX = distX;
-		template.deltaY = distY;
-		template.pageX = touch.pageX;
-		template.pageY = touch.pageY;
-		template.velocityX = distX / time;
-		template.velocityY = distY / time;
-		template.targetTouches = touches;
-		template.finger = touches ?
-			touches.length :
-			1 ;
-
-		// The _handled method is fired to tell the default movestart
-		// handler that one of the move events is bound.
-		template._handled = handled;
-			
-		// Pass the touchmove event so it can be prevented if or when
-		// movestart is handled.
-		template._preventTouchmoveDefault = function() {
-			e.preventDefault();
+		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(template.target, template);
+		trigger(data.target, 'movestart', template);
 
 		// Unbind handlers that tracked the touch or mouse up till now.
-		fn(template.identifier);
+		fn(data);
 	}
 
 
 	// Handlers that control what happens following a movestart
 
-	function activeMousemove(e) {
-		var timer = e.data.timer;
+	function activeMousemove(e, data) {
+		var timer  = data.timer;
 
-		e.data.touch = e;
-		e.data.timeStamp = e.timeStamp;
+		data.touch = e;
+		data.timeStamp = e.timeStamp;
 		timer.kick();
 	}
 
-	function activeMouseend(e) {
-		var event = e.data.event,
-		    timer = e.data.timer;
-		
+	function activeMouseend(e, data) {
+		var target = data.target;
+		var event  = data.event;
+		var timer  = data.timer;
+
 		removeActiveMouse();
 
-		endEvent(event, timer, function() {
+		endEvent(target, event, timer, function() {
 			// Unbind the click suppressor, waiting until after mouseup
 			// has been handled.
 			setTimeout(function(){
-				remove(event.target, 'click', returnFalse);
+				off(target, 'click', preventDefault);
 			}, 0);
 		});
 	}
 
-	function removeActiveMouse(event) {
-		remove(document, mouseevents.move, activeMousemove);
-		remove(document, mouseevents.end, activeMouseend);
+	function removeActiveMouse() {
+		off(document, mouseevents.move, activeMousemove);
+		off(document, mouseevents.end, activeMouseend);
 	}
 
-	function activeTouchmove(e) {
-		var event = e.data.event,
-		    timer = e.data.timer,
-		    touch = changedTouch(e, event);
+	function activeTouchmove(e, data) {
+		var event = data.event;
+		var timer = data.timer;
+		var touch = changedTouch(e, event);
 
 		if (!touch) { return; }
 
@@ -379,40 +398,41 @@
 		e.preventDefault();
 
 		event.targetTouches = e.targetTouches;
-		e.data.touch = touch;
-		e.data.timeStamp = e.timeStamp;
+		data.touch = touch;
+		data.timeStamp = e.timeStamp;
+
 		timer.kick();
 	}
 
-	function activeTouchend(e) {
-		var event = e.data.event,
-		    timer = e.data.timer,
-		    touch = identifiedTouch(e.changedTouches, event.identifier);
+	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(event);
-		endEvent(event, timer);
+		removeActiveTouch(data);
+		endEvent(target, event, timer);
 	}
 
-	function removeActiveTouch(event) {
-		remove(document, '.' + event.identifier, activeTouchmove);
-		remove(document, '.' + event.identifier, activeTouchend);
+	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, timer) {
+	function updateEvent(event, touch, timeStamp) {
 		var time = timeStamp - event.timeStamp;
 
-		event.type = 'move';
 		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;
@@ -421,166 +441,144 @@
 		event.pageY =  touch.pageY;
 	}
 
-	function endEvent(event, timer, fn) {
+	function endEvent(target, event, timer, fn) {
 		timer.end(function(){
-			event.type = 'moveend';
-
-			trigger(event.target, event);
-			
+			trigger(target, 'moveend', event);
 			return fn && fn();
 		});
 	}
 
 
-	// jQuery special event definition
-
-	function setup(data, namespaces, eventHandle) {
-		// Stop the node from being dragged
-		//add(this, 'dragstart.move drag.move', preventDefault);
-		
-		// Prevent text selection and touch interface scrolling
-		//add(this, 'mousedown.move', preventIgnoreTags);
-		
-		// Tell movestart default handler that we've handled this
-		add(this, 'movestart.move', flagAsHandled);
-
-		// Don't bind to the DOM. For speed.
-		return true;
-	}
-	
-	function teardown(namespaces) {
-		remove(this, 'dragstart drag', preventDefault);
-		remove(this, 'mousedown touchstart', preventIgnoreTags);
-		remove(this, 'movestart', flagAsHandled);
-		
-		// Don't bind to the DOM. For speed.
-		return true;
-	}
-	
-	function addMethod(handleObj) {
-		// We're not interested in preventing defaults for handlers that
-		// come from internal move or moveend bindings
-		if (handleObj.namespace === "move" || handleObj.namespace === "moveend") {
-			return;
+	// 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);
 		}
-		
-		// Stop the node from being dragged
-		add(this, 'dragstart.' + handleObj.guid + ' drag.' + handleObj.guid, preventDefault, undefined, handleObj.selector);
-		
-		// Prevent text selection and touch interface scrolling
-		add(this, 'mousedown.' + handleObj.guid, preventIgnoreTags, undefined, handleObj.selector);
-	}
-	
-	function removeMethod(handleObj) {
-		if (handleObj.namespace === "move" || handleObj.namespace === "moveend") {
-			return;
+
+		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);
 		}
-		
-		remove(this, 'dragstart.' + handleObj.guid + ' drag.' + handleObj.guid);
-		remove(this, 'mousedown.' + handleObj.guid);
 	}
-	
-	jQuery.event.special.movestart = {
-		setup: setup,
-		teardown: teardown,
-		add: addMethod,
-		remove: removeMethod,
-
-		_default: function(e) {
-			var event, data;
-			
-			// If no move events were bound to any ancestors of this
-			// target, high tail it out of here.
-			if (!e._handled()) { return; }
-
-			function update(time) {
-				updateEvent(event, data.touch, data.timeStamp);
-				trigger(e.target, event);
-			}
 
-			event = {
-				target: e.target,
-				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,
-				timeStamp: e.timeStamp,
-				identifier: e.identifier,
-				targetTouches: e.targetTouches,
-				finger: e.finger
-			};
-
-			data = {
-				event: event,
-				timer: new Timer(update),
-				touch: undefined,
-				timeStamp: undefined
-			};
-			
-			if (e.identifier === undefined) {
-				// We're dealing with a mouse
-				// Stop clicks from propagating during a move
-				add(e.target, 'click', returnFalse);
-				add(document, mouseevents.move, activeMousemove, data);
-				add(document, mouseevents.end, activeMouseend, data);
-			}
-			else {
-				// We're dealing with a touch. Stop touchmove doing
-				// anything defaulty.
-				e._preventTouchmoveDefault();
-				add(document, touchevents.move + '.' + e.identifier, activeTouchmove, data);
-				add(document, touchevents.end + '.' + e.identifier, 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() {
-			// Bind a noop to movestart. Why? It's the movestart
-			// setup that decides whether other move events are fired.
-			add(this, 'movestart.move', jQuery.noop);
+			on(this, 'movestart', enableMove2);
+			return false;
 		},
-		
+
 		teardown: function() {
-			remove(this, 'movestart.move', jQuery.noop);
-		}
+			off(this, 'movestart', enableMove2);
+			return false;
+		},
+
+		add: add
 	};
-	
+
 	jQuery.event.special.moveend = {
 		setup: function() {
-			// Bind a noop to movestart. Why? It's the movestart
-			// setup that decides whether other move events are fired.
-			add(this, 'movestart.moveend', jQuery.noop);
+			on(this, 'movestart', enableMove3);
+			return false;
 		},
-		
+
 		teardown: function() {
-			remove(this, 'movestart.moveend', jQuery.noop);
-		}
-	};
+			off(this, 'movestart', enableMove3);
+			return false;
+		},
 
-	add(document, 'mousedown.move', mousedown);
-	add(document, 'touchstart.move', touchstart);
-
-	// Make jQuery copy touch event properties over to the jQuery event
-	// object, if they are not already listed. But only do the ones we
-	// really need. IE7/8 do not have Array#indexOf(), but nor do they
-	// have touch events, so let's assume we can ignore them.
-	if (typeof Array.prototype.indexOf === 'function') {
-		(function(jQuery, undefined){
-			var props = ["changedTouches", "targetTouches"],
-			    l = props.length;
-			
-			while (l--) {
-				if (jQuery.event.props.indexOf(props[l]) === -1) {
-					jQuery.event.props.push(props[l]);
-				}
-			}
-		})(jQuery);
+		add: add
 	};
-});
+});
\ No newline at end of file