nouislider-rails 6.0.1 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23943f5ff9d0c4c8250cf42650d496927b85a4ba
-  data.tar.gz: 923878695c0f36b2a92ccf75360d4163e284a997
+  metadata.gz: 8c836710318e117437b0d7f90ee0208a50214103
+  data.tar.gz: c2f2a7fac403d92f029e1490ba3986e55e040f97
 SHA512:
-  metadata.gz: 36e0aad250ccd59357bfa374bcefd6084346a2c0c74941939fed9ca6bffb23f8be25a6a9613455d165155bfca92fb00421e287132029c619daf6b1bcebef0ea4
-  data.tar.gz: 481477ce08cc866531a19df13f3f5a9be53afead08afb1e3afdc44faa6925f991928fd3af216246534412b72bf9e1635d8b9dee987aca16da6b7850cc448a626
+  metadata.gz: 7107eca155b0c8861b5993e252a65b57200c2ee09d211697fed7e898ba71173fe45ecdc280ae984c53e33eb74e64d7c96dd50dbc975adb929158107ca0305f9c
+  data.tar.gz: 5cde020e4e9a4858e4d0ef526d511c90f728bc03754ba033cebb889ad60874ed3de015d0109a43b552de315c3e28385d5964d22585ee53f8310576db675808b2

data/lib/nouislider/rails/version.rb

@@ -1,5 +1,5 @@
 module Nouislider
   module Rails
-    VERSION = "6.0.1"
+    VERSION = "6.1.0"
   end
 end

data/nouislider-rails.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Charles Lee"]
   spec.email         = ["chug2k@gmail.com"]
   spec.summary       = "jquery-nouislider.js for the Rails asset pipeline."
-  spec.description   = "Currently tracking 6.0 of jquery-noUiSlider: https://github.com/leongersen/noUiSlider). All credit and thanks to @leongersen for the awesome library."
+  spec.description   = "Currently tracking 6.1 of jquery-noUiSlider: https://github.com/leongersen/noUiSlider). All credit and thanks to @leongersen for the awesome library."
   spec.homepage      = "https://github.com/chug2k/nouislider-rails"
   spec.license       = "MIT"
 

data/vendor/assets/javascripts/Link.js

@@ -0,0 +1,389 @@
+/**@preserve
+$.Link (part of noUiSlider) - WTFPL */
+
+/*jslint browser: true */
+/*jslint sub: true */
+/*jslint white: true */
+
+(function( $ ){
+
+	'use strict';
+
+	// Throw an error if formatting options are incompatible.
+	function throwEqualError( F, a, b ) {
+		if ( (F[a] || F[b]) && (F[a] === F[b]) ) {
+			throw new Error("(Link) '"+a+"' can't match '"+b+"'.'");
+		}
+	}
+
+	// Test in an object is an instance of jQuery or Zepto.
+	function isInstance ( a ) {
+		return a instanceof $ || ( $['zepto'] && $['zepto']['isZ'](a) );
+	}
+
+var
+/** @const */ Formatting = [
+/*  0 */  'decimals'
+/*  1 */ ,'mark'
+/*  2 */ ,'thousand'
+/*  3 */ ,'prefix'
+/*  4 */ ,'postfix'
+/*  5 */ ,'encoder'
+/*  6 */ ,'decoder'
+/*  7 */ ,'negative'
+/*  8 */ ,'negativeBefore'
+/*  9 */ ,'to'
+/* 10 */ ,'from'
+	],
+/** @const */ FormatDefaults = [
+/*  0 */  2
+/*  1 */ ,'.'
+/*  2 */ ,''
+/*  3 */ ,''
+/*  4 */ ,''
+/*  5 */ ,function(a){ return a; }
+/*  6 */ ,function(a){ return a; }
+/*  7 */ ,'-'
+/*  8 */ ,''
+/*  9 */ ,function(a){ return a; }
+/* 10 */ ,function(a){ return a; }
+	];
+
+
+	/** @constructor */
+	function Format( options ){
+
+		// If no settings where provided, the defaults will be loaded.
+		if ( options === undefined ){
+			options = {};
+		}
+
+		if ( typeof options !== 'object' ){
+			throw new Error("(Format) 'format' option must be an object.");
+		}
+
+		var settings = {};
+
+		// Copy all values into a new object.
+		$(Formatting).each(function(i, val){
+
+			if ( options[val] === undefined ){
+
+				settings[val] = FormatDefaults[i];
+
+			// When we aren't loading defaults, validate the entry.
+			} else if ( (typeof options[val]) === (typeof FormatDefaults[i]) ) {
+
+				// Support for up to 7 decimals.
+				// More can't be guaranteed due to floating point issues.
+				if ( val === 'decimals' ){
+					if ( options[val] < 0 || options[val] > 7 ){
+						throw new Error("(Format) 'format.decimals' option must be between 0 and 7.");
+					}
+				}
+
+				settings[val] = options[val];
+
+			// If the value isn't valid, emit an error.
+			} else {
+				throw new Error("(Format) 'format."+val+"' must be a " + typeof FormatDefaults[i] + ".");
+			}
+		});
+
+		// Some values can't be extracted from a
+		// string if certain combinations are present.
+		throwEqualError(settings, 'mark', 'thousand');
+		throwEqualError(settings, 'prefix', 'negative');
+		throwEqualError(settings, 'prefix', 'negativeBefore');
+
+		this.settings = settings;
+	}
+
+	// Shorthand for internal value get
+	Format.prototype.v = function ( a ) {
+		return this.settings[a];
+	};
+
+	Format.prototype.to = function ( number ) {
+
+		function reverse ( a ) {
+			return a.split('').reverse().join('');
+		}
+
+		number = this.v('encoder')( number );
+
+		var decimals = this.v('decimals'),
+			negative = '', preNegative = '', base = '', mark = '';
+
+		// Rounding away decimals might cause a value of -0
+		// when using very small ranges. Remove those cases.
+		if ( parseFloat(number.toFixed(decimals)) === 0 ) {
+			number = '0';
+		}
+
+		if ( number < 0 ) {
+			negative = this.v('negative');
+			preNegative = this.v('negativeBefore');
+		}
+
+		// Round to proper decimal count
+		number = Math.abs(number).toFixed(decimals).toString();
+		number = number.split('.');
+
+		// Group numbers in sets of three.
+		if ( this.v('thousand') ) {
+			base = reverse(number[0]).match(/.{1,3}/g);
+			base = reverse(base.join(reverse( this.v('thousand') )));
+		} else {
+			base = number[0];
+		}
+
+		// Ignore the decimal separator if decimals are set to 0.
+		if ( this.v('mark') && number.length > 1 ) {
+			mark = this.v('mark') + number[1];
+		}
+
+		// Return the finalized formatted number.
+		return this.v('to')(preNegative +
+			this.v('prefix') +
+			negative +
+			base +
+			mark +
+			this.v('postfix'));
+	};
+
+	Format.prototype.from = function ( input ) {
+
+		function esc(s){
+			return s.replace(/[\-\/\\\^$*+?.()|\[\]{}]/g, '\\$&');
+		}
+
+		var isNeg;
+		// The set request might want to ignore this handle.
+		// Test for 'undefined' too, as a two-handle slider
+		// can still be set with an integer.
+		if ( input === null || input === undefined ) {
+			return false;
+		}
+
+		input = this.v('from')(input);
+
+		// Remove formatting and set period for float parsing.
+		input = input.toString();
+
+		// Replace the preNegative indicator.
+		isNeg = input.replace(new RegExp('^' + esc( this.v('negativeBefore') )), '');
+
+		// Check if the value changed by removing the negativeBefore symbol.
+		if( input !== isNeg ) {
+			input = isNeg;
+			isNeg = '-';
+		} else {
+			isNeg = '';
+		}
+
+		// If prefix is set and the number is actually prefixed.
+		input = input.replace(new RegExp('^'+esc( this.v('prefix') )), '');
+
+		// Only replace if a negative sign is set.
+		if ( this.v('negative') ) {
+
+			// Reset isNeg to prevent double '-' insertion.
+			isNeg = '';
+
+			// Reset the negative sign to '-'
+			input = input.replace(new RegExp('^'+esc( this.v('negative') )), '-');
+		}
+
+		// Clean the input string
+		input = input
+		// If postfix is set and the number is postfixed.
+			.replace( new RegExp(esc( this.v('postfix') ) + '$'), '')
+		// Remove the separator every three digits.
+			.replace( new RegExp(esc( this.v('thousand') ), 'g'), '')
+		// Set the decimal separator back to period.
+			.replace( this.v('mark'), '.');
+
+		// Run the user defined decoder. Returns input by default.
+		input = this.v('decoder')( parseFloat( isNeg + input ) );
+
+		// Ignore invalid input
+		if (isNaN( input )) {
+			return false;
+		}
+
+		return input;
+	};
+
+
+/** @expose */
+/** @constructor */
+	function Link ( entry, update ) {
+
+		if ( typeof entry !== "object" ) {
+			$.error("(Link) Initialize with an object.");
+		}
+
+		// Make sure Link isn't called as a function, in which case
+		// the 'this' scope would be the window.
+		return new Link.prototype.init( entry['target']||function(){}, entry['method'], entry['format']||{}, update );
+	}
+
+	Link.prototype.setTooltip = function ( target, method ) {
+
+		// By default, use the 'html' method.
+		this.method = method || 'html';
+
+		// Use jQuery to create the element
+		this.el = $( target.replace('-tooltip-', '') || '<div/>' )[0];
+	};
+
+	Link.prototype.setHidden = function ( target ) {
+
+		this.method = 'val';
+
+		this.el = document.createElement('input');
+		this.el.name = target;
+		this.el.type = 'hidden';
+	};
+
+	Link.prototype.setField = function ( target ) {
+
+		// Returns nulled array.
+		function at(a,b,c){
+			return [c?a:b, c?b:a];
+		}
+
+		// In IE < 9, .bind() isn't available, need this link in .change().
+		var that = this;
+
+		// Default to .val if this is an input element.
+		this.method = 'val';
+		// Set the slider to a new value on change.
+		this.target = target.on('change', function( e ){
+			that.obj.val(
+				at(null, $(e.target).val(), that.N),
+				{ 'link': that, 'set': true }
+			);
+		});
+	};
+
+
+	// Initialisor
+	/** @constructor */
+	Link.prototype.init = function ( target, method, format, update ) {
+
+		// Write all formatting to this object.
+		// No validation needed, as we'll merge these with the parent
+		// format options first.
+		this.formatting = format;
+
+		// Store the update option.
+		this.update = !update;
+
+		// If target is a string, a new hidden input will be created.
+		if ( typeof target === 'string' && target.indexOf('-tooltip-') === 0 ) {
+			this.setTooltip( target, method );
+			return;
+		}
+
+		// If the string doesn't begin with '-', which is reserved, add a new hidden input.
+		if ( typeof target === 'string' && target.indexOf('-') !== 0 ) {
+			this.setHidden( target );
+			return;
+		}
+
+		// The target can also be a function, which will be called.
+		if ( typeof target === 'function' ) {
+			this.target = false;
+			this.method = target;
+			return;
+		}
+
+		if ( isInstance(target) ) {
+			// If a jQuery/Zepto input element is provided, but no method is set,
+			// the element can assume it needs to respond to 'change'...
+
+			if ( !method ) {
+
+				if ( target.is('input, select, textarea') ) {
+					this.setField( target );
+					return;
+				}
+
+				// If no method is set, and we are not auto-binding an input, default to 'html'.
+				method = 'html';
+			}
+
+			// The method must exist on the element.
+			if ( typeof method === 'function' || (typeof method === 'string' && target[method]) ) {
+				this.method = method;
+				this.target = target;
+				return;
+			}
+		}
+
+		// Nothing matched, throw error.
+		throw new RangeError("(Link) Invalid Link.");
+	};
+
+	// Provides external items with the slider value.
+	Link.prototype.write = function ( value, handle, slider, update ) {
+
+		// Don't synchronize this Link.
+		if ( this.update && update === false ) {
+			return;
+		}
+
+		this.actual = value;
+
+		// Format values for display.
+		value = this.format( value );
+
+		// Store the numerical value.
+		this.saved = value;
+
+		// Branch between serialization to a function or an object.
+		if ( typeof this.method === 'function' ) {
+			// When target is undefined, the target was a function.
+			// In that case, provided the slider as the calling scope.
+			// Use [0] to get the DOM element, not the $ instance.
+			this.method.call( this.target[0] || slider[0], value, handle, slider );
+		} else {
+			this.target[ this.method ]( value, handle, slider );
+		}
+	};
+
+	// Set formatting options.
+	Link.prototype.setFormatting = function ( options ) {
+		this.formatting = new Format($.extend({},
+			options,
+			this.formatting instanceof Format ? this.formatting.settings : this.formatting
+		));
+	};
+
+	Link.prototype.setObject = function ( obj ) {
+		this.obj = obj;
+	};
+
+	Link.prototype.setIndex = function ( index ) {
+		this.N = index;
+	};
+
+	// Parses slider value to user defined display.
+	Link.prototype.format = function ( a ) {
+		return this.formatting.to(a);
+	};
+
+	// Converts a formatted value back to a real number.
+	Link.prototype.getValue = function ( a ) {
+		return this.formatting.from(a);
+	};
+
+	// We can now test for Link.init to be an instance of Link.
+	Link.prototype.init.prototype = Link.prototype;
+
+	/** @expose */
+	$.Link = Link;
+
+}( window['jQuery'] || window['Zepto'] ));

data/vendor/assets/javascripts/jquery.nouislider.js

@@ -1,1650 +1,1252 @@
-/*! $.noUiSlider - WTFPL - refreshless.com/nouislider/ */
+/**@preserve
+$.fn.noUiSlider - WTFPL - refreshless.com/nouislider/ */
 
 /*jslint browser: true */
-/*jslint devel: true */
-/*jslint continue: true */
-/*jslint plusplus: true */
 /*jslint sub: true */
 /*jslint white: true */
-
-// ==ClosureCompiler==
-// @externs_url http://refreshless.com/externs/jquery-1.8.js
-// @compilation_level ADVANCED_OPTIMIZATIONS
-// @warning_level VERBOSE
-// ==/ClosureCompiler==
+/*jslint continue: true */
+/*jslint plusplus: true */
 
 (function( $ ){
 
-  'use strict';
-
-  var
-  // Cache the document selector;
-      /** @const */ doc = $(document),
-  // Namespace for binding and unbinding slider events;
-      /** @const */ namespace = '.nui',
-  // Copy of the current value function;
-      /** @const */ $val = $.fn.val,
-  // Determine the events to bind. IE11 implements pointerEvents without
-  // a prefix, which breaks compatibility with the IE10 implementation.
-      /** @const */ actions = window.navigator.pointerEnabled ? {
-        start: 'pointerdown',
-        move: 'pointermove',
-        end: 'pointerup'
-      } : window.navigator.msPointerEnabled ? {
-        start: 'MSPointerDown',
-        move: 'MSPointerMove',
-        end: 'MSPointerUp'
-      } : {
-        start: 'mousedown touchstart',
-        move: 'mousemove touchmove',
-        end: 'mouseup touchend'
-      },
-  // Re-usable list of classes;
-      /** @const */ Classes = [
-        /*  0 */  'noUi-target'
-        /*  1 */ ,'noUi-base'
-        /*  2 */ ,'noUi-origin'
-        /*  3 */ ,'noUi-handle'
-        /*  4 */ ,'noUi-horizontal'
-        /*  5 */ ,'noUi-vertical'
-        /*  6 */ ,'noUi-background'
-        /*  7 */ ,'noUi-connect'
-        /*  8 */ ,'noUi-ltr'
-        /*  9 */ ,'noUi-rtl'
-        /* 10 */ ,'noUi-dragable'
-        /* 11 */ ,''
-        /* 12 */ ,'noUi-state-drag'
-        /* 13 */ ,''
-        /* 14 */ ,'noUi-state-tap'
-        /* 15 */ ,'noUi-active'
-        /* 16 */ ,'noUi-extended'
-        /* 17 */ ,'noUi-stacking'
-      ],
-      /** @const */ Formatting = [
-        /*  0 */  'decimals'
-        /*  1 */ ,'mark'
-        /*  2 */ ,'thousand'
-        /*  3 */ ,'prefix'
-        /*  4 */ ,'postfix'
-        /*  5 */ ,'encoder'
-        /*  6 */ ,'decoder'
-        /*  7 */ ,'negative'
-        /*  8 */ ,'negativeBefore'
-      ],
-      /** @const */ FormatDefaults = [
-        /*  0 */  2
-        /*  1 */ ,'.'
-        /*  2 */ ,''
-        /*  3 */ ,''
-        /*  4 */ ,''
-        /*  5 */ ,function(a){ return a; }
-        /*  6 */ ,function(a){ return a; }
-        /*  7 */ ,'-'
-        /*  8 */ ,''
-      ];
-
-
-// Error handling
-
-  function throwError( message ){
-    throw new RangeError('noUiSlider: ' + message);
-  }
-
-  // Throw an error if formatting options are incompatible.
-  function throwEqualError( F, a, b ) {
-    if ( (F[a] || F[b]) && (F[a] === F[b]) ) {
-      throwError("(Link) '"+a+"' can't match '"+b+"'.'");
-    }
-  }
+	'use strict';
+
+	var
+	// Cache the document selector;
+	/** @const */
+	doc = $(document),
+	// Namespace for binding and unbinding slider events;
+	/** @const */
+	namespace = '.nui',
+	// Determine the events to bind. IE11 implements pointerEvents without
+	// a prefix, which breaks compatibility with the IE10 implementation.
+	/** @const */
+	actions = window.navigator['pointerEnabled'] ? {
+		start: 'pointerdown',
+		move: 'pointermove',
+		end: 'pointerup'
+	} : window.navigator['msPointerEnabled'] ? {
+		start: 'MSPointerDown',
+		move: 'MSPointerMove',
+		end: 'MSPointerUp'
+	} : {
+		start: 'mousedown touchstart',
+		move: 'mousemove touchmove',
+		end: 'mouseup touchend'
+	},
+	// Re-usable list of classes;
+	/** @const */
+	Classes = [
+/*  0 */  'noUi-target'
+/*  1 */ ,'noUi-base'
+/*  2 */ ,'noUi-origin'
+/*  3 */ ,'noUi-handle'
+/*  4 */ ,'noUi-horizontal'
+/*  5 */ ,'noUi-vertical'
+/*  6 */ ,'noUi-background'
+/*  7 */ ,'noUi-connect'
+/*  8 */ ,'noUi-ltr'
+/*  9 */ ,'noUi-rtl'
+/* 10 */ ,'noUi-dragable'
+/* 11 */ ,''
+/* 12 */ ,'noUi-state-drag'
+/* 13 */ ,''
+/* 14 */ ,'noUi-state-tap'
+/* 15 */ ,'noUi-active'
+/* 16 */ ,'noUi-extended'
+/* 17 */ ,'noUi-stacking'
+	];
 
 
 // General helpers
 
-  // Limits a value to 0 - 100
-  function limit ( a ) {
-    return Math.max(Math.min(a, 100), 0);
-  }
+	// Limits a value to 0 - 100
+	function limit ( a ) {
+		return Math.max(Math.min(a, 100), 0);
+	}
 
-  // Round a value to the closest 'to'.
-  function closest ( value, to ) {
-    return Math.round(value / to) * to;
-  }
+	// Round a value to the closest 'to'.
+	function closest ( value, to ) {
+		return Math.round(value / to) * to;
+	}
 
-  // Determine the size of a sub-range in relation to a full range.
-  function subRangeRatio ( pa, pb ) {
-    return (100 / (pb - pa));
-  }
+	// Determine the size of a sub-range in relation to a full range.
+	function subRangeRatio ( pa, pb ) {
+		return (100 / (pb - pa));
+	}
 
 
 // Type validation
 
-  function typeMatch ( a, b ) {
-    return (typeof a) === (typeof b);
-  }
+	// Checks whether a value is numerical.
+	function isNumeric ( a ) {
+		return typeof a === 'number' && !isNaN( a ) && isFinite( a );
+	}
 
-  // Test in an object is an instance of jQuery or Zepto.
-  function isInstance ( a ) {
-    return a instanceof $ || ( $['zepto'] && $['zepto']['isZ'](a) );
-  }
-
-  // Checks whether a value is numerical.
-  function isNumeric ( a ) {
-    return typeof a === 'number' && !isNaN( a ) && isFinite( a );
-  }
-
-  // Wraps a variable as an array, if it isn't one yet.
-  function asArray ( a ) {
-    return $.isArray(a) ? a : [a];
-  }
+	// Wraps a variable as an array, if it isn't one yet.
+	function asArray ( a ) {
+		return $.isArray(a) ? a : [a];
+	}
 
 
 // Class handling
 
-  // Sets a class and removes it after [duration] ms.
-  function addClassFor ( element, className, duration ) {
-    element.addClass(className);
-    setTimeout(function(){
-      element.removeClass(className);
-    }, duration);
-  }
-
-  // Tests if element has a class, adds it if not. Returns original state.
-  function getsClass ( element, className ) {
-
-    var has = element.hasClass(className);
-
-    if ( !has ) {
-      element.addClass( className );
-    }
-
-    return has;
-  }
+	// Sets a class and removes it after [duration] ms.
+	function addClassFor ( element, className, duration ) {
+		element.addClass(className);
+		setTimeout(function(){
+			element.removeClass(className);
+		}, duration);
+	}
 
 
 // Value calculation
 
-  // (percentage) How many percent is this value of this range?
-  function fromPercentage ( range, value ) {
-    return (value * 100) / ( range[1] - range[0] );
-  }
+	// (percentage) How many percent is this value of this range?
+	function fromPercentage ( range, value ) {
+		return (value * 100) / ( range[1] - range[0] );
+	}
 
-  // (percentage) Where is this value on this range?
-  function toPercentage ( range, value ) {
-    return fromPercentage( range, range[0] < 0 ?
-        value + Math.abs(range[0]) :
-        value - range[0] );
-  }
+	// (percentage) Where is this value on this range?
+	function toPercentage ( range, value ) {
+		return fromPercentage( range, range[0] < 0 ?
+			value + Math.abs(range[0]) :
+				value - range[0] );
+	}
 
-  // (value) How much is this percentage on this range?
-  function isPercentage ( range, value ) {
-    return ((value * ( range[1] - range[0] )) / 100) + range[0];
-  }
+	// (value) How much is this percentage on this range?
+	function isPercentage ( range, value ) {
+		return ((value * ( range[1] - range[0] )) / 100) + range[0];
+	}
 
-  // (percentage)
-  function toStepping ( options, value ) {
+	// (percentage)
+	function toStepping ( options, value ) {
 
-    if ( value >= options.xVal.slice(-1)[0] ){
-      return 100;
-    }
+		if ( value >= options.xVal.slice(-1)[0] ){
+			return 100;
+		}
 
-    var j = 1, va, vb, pa, pb;
-    while ( value >= options.xVal[j] ){
-      j++;
-    }
+		var j = 1, va, vb, pa, pb;
+		while ( value >= options.xVal[j] ){
+			j++;
+		}
 
-    va = options.xVal[j-1];
-    vb = options.xVal[j];
-    pa = options.xPct[j-1];
-    pb = options.xPct[j];
+		va = options.xVal[j-1];
+		vb = options.xVal[j];
+		pa = options.xPct[j-1];
+		pb = options.xPct[j];
 
-    return pa + (toPercentage([va, vb], value) / subRangeRatio (pa, pb));
-  }
+		return pa + (toPercentage([va, vb], value) / subRangeRatio (pa, pb));
+	}
 
-  // (value)
-  function fromStepping ( options, value ) {
+	// (value)
+	function fromStepping ( options, value ) {
 
-    // There is no range group that fits 100
-    if ( value >= 100 ){
-      return options.xVal.slice(-1)[0];
-    }
+		// There is no range group that fits 100
+		if ( value >= 100 ){
+			return options.xVal.slice(-1)[0];
+		}
 
-    var j = 1, va, vb, pa, pb;
-    while ( value >= options.xPct[j] ){
-      j++;
-    }
+		var j = 1, va, vb, pa, pb;
+		while ( value >= options.xPct[j] ){
+			j++;
+		}
 
-    va = options.xVal[j-1];
-    vb = options.xVal[j];
-    pa = options.xPct[j-1];
-    pb = options.xPct[j];
+		va = options.xVal[j-1];
+		vb = options.xVal[j];
+		pa = options.xPct[j-1];
+		pb = options.xPct[j];
 
-    return isPercentage([va, vb], (value - pa) * subRangeRatio (pa, pb));
-  }
+		return isPercentage([va, vb], (value - pa) * subRangeRatio (pa, pb));
+	}
 
-  // (percentage) Get the step that applies at a certain value.
-  function getStep ( options, value ){
+	// (percentage) Get the step that applies at a certain value.
+	function getStep ( options, value ){
 
-    var j = 1, a, b;
-    while ( value >= options.xPct[j] ){
-      j++;
-    }
+		var j = 1, a, b;
+		while ( value >= options.xPct[j] ){
+			j++;
+		}
 
-    if ( options.snap ) {
+		if ( options.snap ) {
 
-      a = options.xPct[j-1];
-      b = options.xPct[j];
+			a = options.xPct[j-1];
+			b = options.xPct[j];
 
-      if ((value - a) > ((b-a)/2)){
-        return b;
-      }
+			if ((value - a) > ((b-a)/2)){
+				return b;
+			}
 
-      return a;
-    }
+			return a;
+		}
 
-    if ( !options.xSteps[j-1] ){
-      return value;
-    }
+		if ( !options.xSteps[j-1] ){
+			return value;
+		}
 
-    return options.xPct[j-1] + closest(
-        value - options.xPct[j-1],
-        options.xSteps[j-1]
-    );
-  }
+		return options.xPct[j-1] + closest(
+			value - options.xPct[j-1],
+			options.xSteps[j-1]
+		);
+	}
 
 
 // Event handling
 
-  // Provide a clean event with standardized offset values.
-  function fixEvent ( e ) {
-
-    // Prevent scrolling and panning on touch events, while
-    // attempting to slide. The tap event also depends on this.
-    e.preventDefault();
-
-    // Filter the event to register the type, which can be
-    // touch, mouse or pointer. Offset changes need to be
-    // made on an event specific basis.
-    var  touch = e.type.indexOf('touch') === 0
-        ,mouse = e.type.indexOf('mouse') === 0
-        ,pointer = e.type.indexOf('pointer') === 0
-        ,x,y, event = e;
-
-    // IE10 implemented pointer events with a prefix;
-    if ( e.type.indexOf('MSPointer') === 0 ) {
-      pointer = true;
-    }
-
-    // Get the originalEvent, if the event has been wrapped
-    // by jQuery. Zepto doesn't wrap the event.
-    if ( e.originalEvent ) {
-      e = e.originalEvent;
-    }
+	// Provide a clean event with standardized offset values.
+	function fixEvent ( e ) {
 
-    if ( touch ) {
-      // noUiSlider supports one movement at a time,
-      // so we can select the first 'changedTouch'.
-      x = e.changedTouches[0].pageX;
-      y = e.changedTouches[0].pageY;
-    }
+		// Prevent scrolling and panning on touch events, while
+		// attempting to slide. The tap event also depends on this.
+		e.preventDefault();
 
-    if ( mouse || pointer ) {
+		// Filter the event to register the type, which can be
+		// touch, mouse or pointer. Offset changes need to be
+		// made on an event specific basis.
+		var  touch = e.type.indexOf('touch') === 0
+			,mouse = e.type.indexOf('mouse') === 0
+			,pointer = e.type.indexOf('pointer') === 0
+			,x,y, event = e;
 
-      // Polyfill the pageXOffset and pageYOffset
-      // variables for IE7 and IE8;
-      if( !pointer && window.pageXOffset === undefined ){
-        window.pageXOffset = document.documentElement.scrollLeft;
-        window.pageYOffset = document.documentElement.scrollTop;
-      }
+		// IE10 implemented pointer events with a prefix;
+		if ( e.type.indexOf('MSPointer') === 0 ) {
+			pointer = true;
+		}
 
-      x = e.clientX + window.pageXOffset;
-      y = e.clientY + window.pageYOffset;
-    }
+		// Get the originalEvent, if the event has been wrapped
+		// by jQuery. Zepto doesn't wrap the event.
+		if ( e.originalEvent ) {
+			e = e.originalEvent;
+		}
 
-    event.points = [x, y];
-    event.cursor = mouse;
+		if ( touch ) {
+			// noUiSlider supports one movement at a time,
+			// so we can select the first 'changedTouch'.
+			x = e.changedTouches[0].pageX;
+			y = e.changedTouches[0].pageY;
+		}
 
-    return event;
-  }
-
-
-// Organize formatting in an object.
-
-  /** @constructor */
-  function Format( options ){
+		if ( mouse || pointer ) {
 
-    // If no settings where provided, the defaults will be loaded.
-    if ( options === undefined ){
-      options = {};
-    }
-
-    if ( typeof options !== 'object' ){
-      throwError("(Format) 'format' option must be an object.");
-    }
-
-    var settings = {};
-
-    // Copy all values into a new object.
-    $(Formatting).each(function(i, val){
-
-      if ( options[val] === undefined ){
-
-        settings[val] = FormatDefaults[i];
-
-        // When we aren't loading defaults, validate the entry.
-      } else if ( typeMatch(options[val],  FormatDefaults[i]) ) {
-
-        // Support for up to 7 decimals.
-        // More can't be guaranteed due to floating point issues.
-        if ( val === 'decimals' ){
-          if ( options[val] < 0 || options[val] > 7 ){
-            throwError("(Format) 'format.decimals' option must be between 0 and 7.");
-          }
-        }
-
-        settings[val] = options[val];
-
-        // If the value isn't valid, emit an error.
-      } else {
-        throwError("(Format) 'format."+val+"' must be a " + typeof FormatDefaults[i] + ".");
-      }
-    });
-
-    // Some values can't be extracted from a
-    // string if certain combinations are present.
-    throwEqualError(settings, 'mark', 'thousand');
-    throwEqualError(settings, 'prefix', 'negative');
-    throwEqualError(settings, 'prefix', 'negativeBefore');
-
-    this.settings = settings;
-  }
-
-  // Shorthand for internal value get
-  Format.prototype.v = function ( a ) {
-    return this.settings[a];
-  };
-
-  Format.prototype.to = function ( number ) {
-
-    function reverse ( a ) {
-      return a.split('').reverse().join('');
-    }
-
-    number = this.v('encoder')( number );
-
-    var negative = '', preNegative = '', base = '', mark = '';
-
-    if ( number < 0 ) {
-      negative = this.v('negative');
-      preNegative = this.v('negativeBefore');
-    }
+			// Polyfill the pageXOffset and pageYOffset
+			// variables for IE7 and IE8;
+			if( !pointer && window.pageXOffset === undefined ){
+				window.pageXOffset = document.documentElement.scrollLeft;
+				window.pageYOffset = document.documentElement.scrollTop;
+			}
 
-    // Round to proper decimal count
-    number = Math.abs(number).toFixed( this.v('decimals') ).toString();
-    number = number.split('.');
-
-    // Rounding away decimals might cause a value of -0
-    // when using very small ranges. Remove those cases.
-    if ( parseFloat(number) === 0 ) {
-      number[0] = '0';
-    }
-
-    // Group numbers in sets of three.
-    if ( this.v('thousand') ) {
-      base = reverse(number[0]).match(/.{1,3}/g);
-      base = reverse(base.join(reverse( this.v('thousand') )));
-    } else {
-      base = number[0];
-    }
+			x = e.clientX + window.pageXOffset;
+			y = e.clientY + window.pageYOffset;
+		}
 
-    // Ignore the decimal separator if decimals are set to 0.
-    if ( this.v('mark') && number.length > 1 ) {
-      mark = this.v('mark') + number[1];
-    }
+		event.points = [x, y];
+		event.cursor = mouse;
 
-    // Return the finalized formatted number.
-    return preNegative +
-        this.v('prefix') +
-        negative +
-        base +
-        mark +
-        this.v('postfix');
-  };
-
-  Format.prototype.from = function ( input ) {
-
-    function esc(s){
-      return s.replace(/[\-\/\\\^$*+?.()|\[\]{}]/g, '\\$&');
-    }
-
-    var isNeg;
-    // The set request might want to ignore this handle.
-    // Test for 'undefined' too, as a two-handle slider
-    // can still be set with an integer.
-    if( input === null || input === undefined ) {
-      return false;
-    }
-
-    // Remove formatting and set period for float parsing.
-    input = input.toString();
-
-    // Replace the preNegative indicator.
-    isNeg = input.replace(new RegExp('^' + esc( this.v('negativeBefore') )), '');
-
-    // Check if the value changed by removing the negativeBefore symbol.
-    if( input !== isNeg ) {
-      input = isNeg;
-      isNeg = '-';
-    } else {
-      isNeg = '';
-    }
-
-    // If prefix is set and the number is actually prefixed.
-    input = input.replace(new RegExp('^'+esc( this.v('prefix') )), '');
-
-    // Only replace if a negative sign is set.
-    if ( this.v['negative'] ) {
-
-      // Reset isNeg to prevent double '-' insertion.
-      isNeg = '';
-
-      // Reset the negative sign to '-'
-      input = input.replace(new RegExp('^'+esc( this.v('negative') )), '-');
-    }
-
-    // Clean the input string
-    input = input
-      // If postfix is set and the number is postfixed.
-        .replace( new RegExp(esc( this.v('postfix') ) + '$'), '')
-      // Remove the separator every three digits.
-        .replace( new RegExp(esc( this.v('thousand') ), 'g'), '')
-      // Set the decimal separator back to period.
-        .replace( this.v('mark'), '.');
-
-    // Run the user defined decoder. Returns input by default.
-    input = this.v('decoder')( parseFloat( isNeg + input ) );
-
-    // Ignore invalid input
-    if (isNaN( input )) {
-      return false;
-    }
-
-    return input;
-  };
-
-
-// Serialization target
-
-  /** @constructor */
-  function Link( entry, update ){
-
-    // Make sure Link isn't called as a function, in which case
-    // the 'this' scope would be the window.
-    if ( !(this instanceof Link) ) {
-      throw new Error( "Link: " +
-          "Don't use Link as a function. " +
-          "Use the 'new' keyword.");
-    }
-
-    if ( !entry ) {
-      throw new RangeError("Link: missing parameters.");
-    }
-
-    // Write all formatting to this object.
-    // No validation needed, as we'll merge these with the parent
-    // format options first.
-    this.formatting = entry['format'] || {};
-
-    // Store the update option.
-    this.update = !update;
-
-    // In IE < 9, .bind() isn't available, need this link in .change().
-    var that = this,
+		return event;
+	}
 
-    // Get values from the input.
-        target = entry['target'] || function(){},
-        method = entry['method'],
 
-    // Find the type of this link.
-        isTooltip = ( typeof target === 'string' && target.indexOf('-tooltip-') === 0 ),
-        isHidden = ( typeof target === 'string' && target.indexOf('-') !== 0 ),
-        isMethod = ( typeof target === 'function' ),
-        is$ = ( isInstance(target) ),
-        isInput = ( is$ && target.is('input, select, textarea') ),
-        methodIsFunction = ( is$ && typeof method === 'function' ),
-        methodIsName = ( is$ && typeof method === 'string' && target[method] );
-
-    // If target is a string, a new hidden input will be created.
-    if ( isTooltip ) {
-
-      // By default, use the 'html' method.
-      this.method = method || 'html';
-
-      // Use jQuery to create the element
-      this.el = $( target.replace('-tooltip-', '') || '<div/>' )[0];
-
-      return;
-    }
-
-    // If the string doesn't begin with '-', which is reserved, add a new hidden input.
-    if ( isHidden ) {
-
-      this.method = 'val';
+// Input validation
 
-      this.el = document.createElement('input');
-      this.el.name = target;
-      this.el.type = 'hidden';
+	function testStep ( parsed, entry ) {
+
+		if ( !isNumeric( entry ) ) {
+			throw new Error("noUiSlider: 'step' is not numeric.");
+		}
+
+		// The step option can still be used to set stepping
+		// for linear sliders. Overwritten if set in 'range'.
+		parsed.xSteps[0] = entry;
+	}
+
+	function testRange ( parsed, entry ) {
+
+		// Filter incorrect input.
+		if ( typeof entry !== 'object' || $.isArray(entry) ) {
+			throw new Error("noUiSlider: 'range' is not an object.");
+		}
+
+		// Loop all entries.
+		$.each( entry, function ( index, value ) {
+
+			var percentage;
+
+			// Wrap numerical input in an array.
+			if ( typeof value === "number" ) {
+				value = [value];
+			}
+
+			// Reject any invalid input.
+			if ( !$.isArray( value ) ){
+				throw new Error("noUiSlider: 'range' contains invalid value.");
+			}
+
+			// Covert min/max syntax to 0 and 100.
+			if ( index === 'min' ) {
+				percentage = 0;
+			} else if ( index === 'max' ) {
+				percentage = 100;
+			} else {
+				percentage = parseFloat( index );
+			}
+
+			// Check for correct input.
+			if ( !isNumeric( percentage ) || !isNumeric( value[0] ) ) {
+				throw new Error("noUiSlider: 'range' value isn't numeric.");
+			}
+
+			// Store values.
+			parsed.xPct.push( percentage );
+			parsed.xVal.push( value[0] );
+
+			// NaN will evaluate to false too, but to keep
+			// logging clear, set step explicitly. Make sure
+			// not to override the 'step' setting with false.
+			if ( !percentage ) {
+				if ( !isNaN( value[1] ) ) {
+					parsed.xSteps[0] = value[1];
+				}
+			} else {
+				parsed.xSteps.push( isNaN(value[1]) ? false : value[1] );
+			}
+		});
+
+		$.each(parsed.xSteps, function(i,n){
+
+			// Ignore 'false' stepping.
+			if ( !n ) {
+				return true;
+			}
+
+			// Check if step fits. Not required, but this might serve some goal.
+			// !((parsed.xVal[i+1] - parsed.xVal[i]) % n);
+
+			// Factor to range ratio
+			parsed.xSteps[i] = fromPercentage([
+				 parsed.xVal[i]
+				,parsed.xVal[i+1]
+			], n) / subRangeRatio (
+				parsed.xPct[i],
+				parsed.xPct[i+1] );
+		});
+	}
+
+	function testStart ( parsed, entry ) {
+
+		if ( typeof entry === "number" ) {
+			entry = [entry];
+		}
+
+		// Validate input. Values aren't tested, the internal Link will do
+		// that and provide a valid location.
+		if ( !$.isArray( entry ) || !entry.length || entry.length > 2 ) {
+			throw new Error("noUiSlider: 'start' option is incorrect.");
+		}
+
+		// Store the number of handles.
+		parsed.handles = entry.length;
+
+		// When the slider is initialized, the .val method will
+		// be called with the start options.
+		parsed.start = entry;
+	}
+
+	function testSnap ( parsed, entry ) {
+
+		// Enforce 100% stepping within subranges.
+		parsed.snap = entry;
+
+		if ( typeof entry !== 'boolean' ){
+			throw new Error("noUiSlider: 'snap' option must be a boolean.");
+		}
+	}
+
+	function testConnect ( parsed, entry ) {
+
+		if ( entry === 'lower' && parsed.handles === 1 ) {
+			parsed.connect = 1;
+		} else if ( entry === 'upper' && parsed.handles === 1 ) {
+			parsed.connect = 2;
+		} else if ( entry === true && parsed.handles === 2 ) {
+			parsed.connect = 3;
+		} else if ( entry === false ) {
+			parsed.connect = 0;
+		} else {
+			throw new Error("noUiSlider: 'connect' option doesn't match handle count.");
+		}
+	}
+
+	function testOrientation ( parsed, entry ) {
+
+		// Set orientation to an a numerical value for easy
+		// array selection.
+		switch ( entry ){
+		  case 'horizontal':
+			parsed.ort = 0;
+			break;
+		  case 'vertical':
+			parsed.ort = 1;
+			break;
+		  default:
+			throw new Error("noUiSlider: 'orientation' option is invalid.");
+		}
+	}
+
+	function testMargin ( parsed, entry ) {
+
+		if ( parsed.xPct.length > 2 ) {
+			throw new Error("noUiSlider: 'margin' option is only supported on linear sliders.");
+		}
+
+		// Parse value to range and store. As xVal is checked
+		// to be no bigger than 2, use it as range.
+		parsed.margin = fromPercentage(parsed.xVal, entry);
+
+		if ( !isNumeric(entry) ){
+			throw new Error("noUiSlider: 'margin' option must be numeric.");
+		}
+	}
+
+	function testDirection ( parsed, entry ) {
+
+		// Set direction as a numerical value for easy parsing.
+		// Invert connection for RTL sliders, so that the proper
+		// handles get the connect/background classes.
+		switch ( entry ) {
+		  case 'ltr':
+			parsed.dir = 0;
+			break;
+		  case 'rtl':
+			parsed.dir = 1;
+			parsed.connect = [0,2,1,3][parsed.connect];
+			break;
+		  default:
+			throw new Error("noUiSlider: 'direction' option was not recognized.");
+		}
+	}
+
+	function testBehaviour ( parsed, entry ) {
+
+		// Make sure the input is a string.
+		if ( typeof entry !== 'string' ) {
+			throw new Error("noUiSlider: 'behaviour' must be a string containing options.");
+		}
+
+		// Check if the string contains any keywords.
+		// None are required.
+		var tap = entry.indexOf('tap') >= 0,
+			extend = entry.indexOf('extend') >= 0,
+			drag = entry.indexOf('drag') >= 0,
+			fixed = entry.indexOf('fixed') >= 0,
+			snap = entry.indexOf('snap') >= 0;
+
+		parsed.events = {
+			tap: tap || snap,
+			extend: extend,
+			drag: drag,
+			fixed: fixed,
+			snap: snap
+		};
+	}
+
+	function testSerialization ( parsed, entry, sliders ) {
+
+		parsed.ser = [ entry['lower'], entry['upper'] ];
+		parsed.formatting = entry['format'];
+
+		$.each( parsed.ser, function( index, linkInstances ){
+
+			// Check if the provided option is an array.
+			if ( !$.isArray(linkInstances) ) {
+				throw new Error("noUiSlider: 'serialization."+(!index ? 'lower' : 'upper')+"' must be an array.");
+			}
+
+			$.each(linkInstances, function(){
+
+				// Check if entry is a Link.
+				if ( !(this instanceof $.Link) ) {
+					throw new Error("noUiSlider: 'serialization."+(!index ? 'lower' : 'upper')+"' can only contain Link instances.");
+				}
+
+				// Assign properties.
+				this.setIndex ( index );
+				this.setObject( sliders );
+				this.setFormatting( entry['format'] );
+			});
+		});
+
+		// If the slider has two handles and is RTL,
+		// reverse the serialization input. For one handle,
+		// lower is still lower.
+		if ( parsed.dir && parsed.handles > 1 ) {
+			parsed.ser.reverse();
+		}
+	}
+
+	// Test all developer settings and parse to assumption-safe values.
+	function test ( options, sliders ){
+
+	/*	Every input option is tested and parsed. This'll prevent
+		endless validation in internal methods. These tests are
+		structured with an item for every option available. An
+		option can be marked as required by setting the 'r' flag.
+		The testing function is provided with three arguments:
+			- The provided value for the option;
+			- A reference to the options object;
+			- The name for the option;
+
+		The testing function returns false when an error is detected,
+		or true when everything is OK. It can also modify the option
+		object, to make sure all values can be correctly looped elsewhere. */
+
+		var parsed = {
+			 xPct: []
+			,xVal: []
+			,xSteps: [ false ]
+			,margin: 0
+		}, tests;
+
+		tests = {
+			'step': { r: false, t: testStep },
+			'range': { r: true, t: testRange },
+			'start': { r: true, t: testStart },
+			'snap': { r: false, t: testSnap },
+			'connect': { r: true, t: testConnect },
+			'orientation': { r: false, t: testOrientation },
+			'margin': { r: false, t: testMargin },
+			'direction': { r: true, t: testDirection },
+			'behaviour': { r: true, t: testBehaviour },
+			'serialization': { r: true, t: testSerialization }
+		};
+
+		// Set defaults where applicable.
+		options = $.extend({
+			'connect': false,
+			'direction': 'ltr',
+			'behaviour': 'tap',
+			'orientation': 'horizontal'
+		}, options);
+
+		// Make sure the test for serialization runs.
+		options['serialization'] = $.extend({
+			 'lower': []
+			,'upper': []
+			,'format': {}
+		}, options['serialization']);
+
+		// Run all options through a testing mechanism to ensure correct
+		// input. It should be noted that options might get modified to
+		// be handled properly. E.g. wrapping integers in arrays.
+		$.each( tests, function( name, test ){
+
+			if ( options[name] === undefined ) {
+
+				if ( test.r ) {
+					throw new Error("noUiSlider: '" + name + "' is required.");
+				}
+
+				return true;
+			}
+
+			test.t( parsed, options[name], sliders );
+		});
+
+		// Pre-define the styles.
+		parsed.style = parsed.ort ? 'top' : 'left';
+
+		return parsed;
+	}
 
-      return;
-    }
 
-    // The target can also be a function, which will be called.
-    if ( isMethod ) {
-      this.target = false;
-      this.method = target;
-      return;
-    }
+// DOM additions
 
-    // If the target is and $ element.
-    if ( is$ ) {
+	// Append a handle to the base.
+	function addHandle ( options, index ) {
+
+		var handle = $('<div><div/></div>').addClass( Classes[2] ),
+			additions = [ '-lower', '-upper' ];
 
-      // The method must exist on the element.
-      if ( method && ( methodIsFunction || methodIsName ) ) {
-        this.target = target;
-        this.method = method;
-        return;
-      }
+		if ( options.dir ) {
+			additions.reverse();
+		}
 
-      // If a jQuery/Zepto input element is provided, but no method is set,
-      // the element can assume it needs to respond to 'change'...
-      if ( !method && isInput ) {
+		handle.children().addClass(
+			Classes[3] + " " + Classes[3]+additions[index]
+		);
 
-        // Default to .val if this is an input element.
-        this.method = 'val';
-        this.target = target;
+		return handle;
+	}
 
-        // Set the slider to a new value on change.
-        this.target.on('change', function( e ){
+	// Create a copy of an element-creating Link.
+	function addElement ( handle, link ) {
+
+		// If the Link requires creation of a new element,
+		// create this element and return a new Link instance.
+		if ( link.el ) {
 
-          // Returns null array.
-          function at(a,b,c){
-            return [c?a:b, c?b:a];
-          }
+			link = new $.Link({
+				'target': $(link.el).clone().appendTo( handle ),
+				'method': link.method,
+				'format': link.formatting
+			}, true);
+		}
 
-          var output = at(null, $(e.target).val(), that.N);
+		// Otherwise, return the reference.
+		return link;
+	}
 
-          that.obj.val(output, { 'link': that });
-        });
+	// Loop all links for a handle.
+	function addElements ( elements, handle, formatting ) {
 
-        return;
-      }
+		var index, list = [], standard = new $.Link({}, true);
 
-      // ... or not.
-      if ( !method && !isInput ) {
+		// Use the Link interface to provide unified
+		// formatting for the .val() method.
+		standard.setFormatting(formatting);
 
-        // Default arbitrarily to 'html'.
-        this.method = 'html';
-        this.target = target;
+		// The list now contains at least one element.
+		list.push( standard );
 
-        return;
-      }
-    }
+		// Loop all links in either 'lower' or 'upper'.
+		for ( index = 0; index < elements.length; index++ ) {
+			list.push(addElement(handle, elements[index]));
+		}
 
-    throw new RangeError("Link: Invalid Link.");
-  }
+		return list;
+	}
 
-  // Provides external items with the slider value.
-  Link.prototype.write = function ( options, value, handle, slider, update ) {
+	// Go over all Links and assign them to a handle.
+	function addLinks ( options, handles ) {
 
-    // Don't synchronize this Link.
-    if ( this.update && update === false ) {
-      return;
-    }
+		var index, links = [];
 
-    // Convert the value to the slider stepping/range.
-    value = fromStepping( options, value );
+		// Copy the links into a new array, instead of modifying
+		// the 'options.ser' list. This allows replacement of the invalid
+		// '.el' Links, while the others are still passed by reference.
+		for ( index = 0; index < options.handles; index++ ) {
 
-    // Format values for display.
-    value = this.format( value );
+			// Append a new array.
+			links[index] = addElements(
+				options.ser[index],
+				handles[index].children(),
+				options.formatting
+			);
+		}
 
-    // Store the numerical value.
-    this.saved = value;
+		return links;
+	}
 
-    // Branch between serialization to a function or an object.
-    if ( typeof this.method === 'function' ) {
-      // When target is undefined, the target was a function.
-      // In that case, provided the slider as the calling scope.
-      // Use [0] to get the DOM element, not the $ instance.
-      this.method.call( this.target[0] || slider[0], value, handle, slider );
-    } else {
-      this.target[ this.method ]( value, handle, slider );
-    }
-  };
+	// Add the proper connection classes.
+	function addConnection ( connect, target, handles ) {
 
-  // Parses slider value to user defined display.
-  Link.prototype.format = function ( a ) {
-    return this.formatting.to(a);
-  };
+		// Apply the required connection classes to the elements
+		// that need them. Some classes are made up for several
+		// segments listed in the class list, to allow easy
+		// renaming and provide a minor compression benefit.
+		switch ( connect ) {
+			case 1:	target.addClass( Classes[7] );
+					handles[0].addClass( Classes[6] );
+					break;
+			case 3: handles[1].addClass( Classes[6] );
+					/* falls through */
+			case 2: handles[0].addClass( Classes[7] );
+					/* falls through */
+			case 0: target.addClass(Classes[6]);
+					break;
+		}
+	}
 
-  // Converts a formatted value back to a real number.
-  Link.prototype.valueOf = function ( a ) {
-    return this.formatting.from(a);
-  };
+	// Add handles and loop Link elements.
+	function addHandles ( options, base ) {
 
+		var index, handles = [];
 
-// Input validation
+		// Append handles.
+		for ( index = 0; index < options.handles; index++ ) {
 
-  function testStep ( parsed, entry ) {
-
-    if ( !isNumeric( entry ) ) {
-      throwError("'step' is not numeric.");
-    }
-
-    // The step option can still be used to set stepping
-    // for linear sliders. Overwritten if set in 'range'.
-    parsed.xSteps[0] = entry;
-  }
-
-  function testRange ( parsed, entry ) {
-
-    // Filter incorrect input.
-    if ( typeof entry !== 'object' || $.isArray(entry) ) {
-      throwError("'range' is not an object.");
-    }
-
-    // Loop all entries.
-    $.each( entry, function ( index, value ) {
-
-      var percentage;
-
-      // Wrap numerical input in an array.
-      if ( typeof value === "number" ) {
-        value = [value];
-      }
-
-      // Reject any invalid input.
-      if ( !$.isArray( value ) ){
-        throwError("'range' contains invalid value.");
-      }
-
-      // Covert min/max syntax to 0 and 100.
-      if ( index === 'min' ) {
-        percentage = 0;
-      } else if ( index === 'max' ) {
-        percentage = 100;
-      } else {
-        percentage = parseFloat( index );
-      }
-
-      // Check for correct input.
-      if ( !isNumeric( percentage ) || !isNumeric( value[0] ) ) {
-        throwError("'range' value isn't numeric.");
-      }
-
-      // Store values.
-      parsed.xPct.push( percentage );
-      parsed.xVal.push( value[0] );
-
-      // NaN will evaluate to false too, but to keep
-      // logging clear, set step explicitly. Make sure
-      // not to override the 'step' setting with false.
-      if ( !percentage ) {
-        if ( !isNaN( value[1] ) ) {
-          parsed.xSteps[0] = value[1];
-        }
-      } else {
-        parsed.xSteps.push( isNaN(value[1]) ? false : value[1] );
-      }
-    });
-
-    $.each(parsed.xSteps, function(i,n){
-
-      // Ignore 'false' stepping.
-      if ( !n ) {
-        return true;
-      }
-
-      // Check if step fits. Not required, but this might serve some goal.
-      // !((parsed.xVal[i+1] - parsed.xVal[i]) % n);
-
-      // Factor to range ratio
-      parsed.xSteps[i] = fromPercentage([
-        parsed.xVal[i]
-        ,parsed.xVal[i+1]
-      ], n) / subRangeRatio (
-          parsed.xPct[i],
-          parsed.xPct[i+1] );
-    });
-  }
-
-  function testStart ( parsed, entry ) {
-
-    if ( typeof entry === "number" ) {
-      entry = [entry];
-    }
-
-    // Validate input. Values aren't tested, the internal Link will do
-    // that and provide a valid location.
-    if ( !$.isArray( entry ) || !entry.length || entry.length > 2 ) {
-      throwError("'start' option is incorrect.");
-    }
-
-    // Store the number of handles.
-    parsed.handles = entry.length;
-
-    // When the slider is initialized, the .val method will
-    // be called with the start options.
-    parsed.start = entry;
-  }
-
-  function testSnap ( parsed, entry ) {
-
-    // Enforce 100% stepping within subranges.
-    parsed.snap = entry;
-
-    if ( typeof entry !== 'boolean' ){
-      throwError("'snap' option must be a boolean.");
-    }
-  }
-
-  function testConnect ( parsed, entry ) {
-
-    if ( entry === 'lower' && parsed.handles === 1 ) {
-      parsed.connect = 1;
-    } else if ( entry === 'upper' && parsed.handles === 1 ) {
-      parsed.connect = 2;
-    } else if ( entry === true && parsed.handles === 2 ) {
-      parsed.connect = 3;
-    } else if ( entry === false ) {
-      parsed.connect = 0;
-    } else {
-      throwError("'connect' option was doesn't match handle count.");
-    }
-  }
-
-  function testOrientation ( parsed, entry ) {
-
-    // Set orientation to an a numerical value for easy
-    // array selection.
-    switch ( entry ){
-      case 'horizontal':
-        parsed.ort = 0;
-        break;
-      case 'vertical':
-        parsed.ort = 1;
-        break;
-      default:
-        throwError("'orientation' option is invalid.");
-    }
-  }
-
-  function testMargin ( parsed, entry ) {
-
-    if ( parsed.xPct.length > 2 ) {
-      throwError("'margin' option is only supported on linear sliders.");
-    }
-
-    // Parse value to range and store. As xVal is checked
-    // to be no bigger than 2, use it as range.
-    parsed.margin = fromPercentage(parsed.xVal, entry);
-
-    if ( !isNumeric(entry) ){
-      throwError("'margin' option must be numeric.");
-    }
-  }
-
-  function testDirection ( parsed, entry ) {
-
-    // Set direction as a numerical value for easy parsing.
-    // Invert connection for RTL sliders, so that the proper
-    // handles get the connect/background classes.
-    switch ( entry ) {
-      case 'ltr':
-        parsed.dir = 0;
-        break;
-      case 'rtl':
-        parsed.dir = 1;
-        parsed.connect = [0,2,1,3][parsed.connect];
-        break;
-      default:
-        throwError("'direction' option was not recognized.");
-    }
-  }
-
-  function testBehaviour ( parsed, entry ) {
-
-    // Make sure the input is a string.
-    if ( typeof entry !== 'string' ) {
-      throwError("'behaviour' must be a string containing options.");
-    }
-
-    // Check if the string contains any keywords.
-    // None are required.
-    var tap = entry.indexOf('tap') >= 0,
-        extend = entry.indexOf('extend') >= 0,
-        drag = entry.indexOf('drag') >= 0,
-        fixed = entry.indexOf('fixed') >= 0,
-        snap = entry.indexOf('snap') >= 0;
-
-    parsed.events = {
-      tap: tap || snap,
-      extend: extend,
-      drag: drag,
-      fixed: fixed,
-      snap: snap
-    };
-  }
-
-  function testSerialization ( parsed, entry, sliders ) {
-
-    parsed.ser = [ entry['lower'], entry['upper'] ];
-    parsed.formatting = new Format( entry['format'] );
-
-    $.each( parsed.ser, function( i, a ){
-
-      // Check if the provided option is an array.
-      if ( !$.isArray(a) ) {
-        throwError("'serialization."+(!i?'lower':'upper')+"' must be an array.");
-      }
-
-      $.each(a, function(){
-
-        // Check if entry is a Link.
-        if ( !(this instanceof Link) ) {
-          throwError("'serialization."+(!i?'lower':'upper')+"' can only contain Link instances.");
-        }
-
-        // Assign other properties.
-        this.N = i;
-        this.obj = sliders;
-        this.scope = this.scope || sliders;
-
-        // Run internal validator.
-        this.formatting = new Format($.extend({}
-            ,entry['format']
-            ,this.formatting
-        ));
-      });
-    });
-
-    // If the slider has two handles and is RTL,
-    // reverse the serialization input. For one handle,
-    // lower is still lower.
-    if ( parsed.dir && parsed.handles > 1 ) {
-      parsed.ser.reverse();
-    }
-  }
-
-  // Test all developer settings and parse to assumption-safe values.
-  function test ( options, sliders ){
-
-    /*	Every input option is tested and parsed. This'll prevent
-     endless validation in internal methods. These tests are
-     structured with an item for every option available. An
-     option can be marked as required by setting the 'r' flag.
-     The testing function is provided with three arguments:
-     - The provided value for the option;
-     - A reference to the options object;
-     - The name for the option;
-
-     The testing function returns false when an error is detected,
-     or true when everything is OK. It can also modify the option
-     object, to make sure all values can be correctly looped elsewhere. */
-
-    var parsed = {
-      xPct: []
-      ,xVal: []
-      ,xSteps: [ false ]
-      ,margin: 0
-    }, tests;
-
-    tests = {
-      'step': { r: false, t: testStep },
-      'range': { r: true, t: testRange },
-      'start': { r: true, t: testStart },
-      'snap': { r: false, t: testSnap },
-      'connect': { r: true, t: testConnect },
-      'orientation': { r: false, t: testOrientation },
-      'margin': { r: false, t: testMargin },
-      'direction': { r: true, t: testDirection },
-      'behaviour': { r: true, t: testBehaviour },
-      'serialization': { r: true, t: testSerialization }
-    };
-
-    // Set defaults where applicable.
-    options = $.extend({
-      'connect': false
-      ,'direction': 'ltr'
-      ,'behaviour': 'tap'
-      ,'orientation': 'horizontal'
-    }, options);
-
-    // Make sure the test for serialization runs.
-    options['serialization'] = $.extend({
-      'lower': []
-      ,'upper': []
-      ,'format': {}
-    }, options['serialization']);
-
-    // Run all options through a testing mechanism to ensure correct
-    // input. It should be noted that options might get modified to
-    // be handled properly. E.g. wrapping integers in arrays.
-    $.each( tests, function( name, test ){
-
-      if ( options[name] === undefined ) {
-        if ( test.r ) {
-          throwError("'" + name + "' is required.");
-        } else {
-          return true;
-        }
-      }
-
-      test.t( parsed, options[name], sliders );
-    });
-
-    // Pre-define the styles.
-    parsed.style = parsed.ort ? 'top' : 'left';
-
-    return parsed;
-  }
+			// Keep a list of all added handles.
+			handles.push( addHandle( options, index ).appendTo(base) );
+		}
 
+		return handles;
+	}
 
-// DOM additions
+	// Initialize a single slider.
+	function addSlider ( options, target ) {
 
-  // Append a handle to the base.
-  function addHandle ( options, index ) {
-
-    var handle = $('<div><div/></div>').addClass( Classes[2] ),
-        additions = [ '-lower', '-upper' ];
-
-    if ( options.dir ) {
-      additions.reverse();
-    }
-
-    handle.children().addClass(
-        Classes[3] + " " + Classes[3]+additions[index]
-    );
-
-    return handle;
-  }
-
-  // Create a copy of an element-creating Link.
-  function addElement ( handle, link ) {
-
-    // If the Link requires creation of a new element,
-    // create this element and return a new Link instance.
-    if ( link.el ) {
-      link = new Link({
-        'target': $(link.el).clone().appendTo( handle ),
-        'method': link.method,
-        'format': link.formatting
-      }, true);
-    }
-
-    // Otherwise, return the reference.
-    return link;
-  }
-
-  // Loop all links for a handle.
-  function addElements ( elements, handle, formatting ) {
-
-    var index, list = [];
-
-    // Use the Link interface to provide unified
-    // formatting for the .val() method.
-    list.push(
-        new Link({
-          'format': formatting
-        }, true)
-    );
-
-    // Loop all links in either 'lower' or 'upper'.
-    for ( index = 0; index < elements.length; index++ ) {
-      list.push(addElement(handle, elements[index]));
-    }
-
-    return list;
-  }
-
-  // Go over all Links and assign them to a handle.
-  function addLinks ( options, handles ) {
-
-    var index, links = [];
-
-    // Copy the links into a new array, instead of modifying
-    // the 'options.ser' list. This allows replacement of the invalid
-    // '.el' Links, while the others are still passed by reference.
-    for ( index = 0; index < options.handles; index++ ) {
-
-      // Append a new array.
-      links[index] = addElements(
-          options.ser[index],
-          handles[index].children(),
-          options.formatting
-      );
-    }
-
-    return links;
-  }
-
-  // Add the proper connection classes.
-  function addConnection ( connect, target, handles ) {
-
-    // Apply the required connection classes to the elements
-    // that need them. Some classes are made up for several
-    // segments listed in the class list, to allow easy
-    // renaming and provide a minor compression benefit.
-    switch ( connect ) {
-      case 1:	target.addClass( Classes[7] );
-        handles[0].addClass( Classes[6] );
-        break;
-      case 3: handles[1].addClass( Classes[6] );
-      /* falls through */
-      case 2: handles[0].addClass( Classes[7] );
-      /* falls through */
-      case 0: target.addClass(Classes[6]);
-        break;
-    }
-  }
-
-  // Add handles and loop Link elements.
-  function addHandles ( options, base ) {
-
-    var index, handles = [];
-
-    // Append handles.
-    for ( index = 0; index < options.handles; index++ ) {
-
-      // Keep a list of all added handles.
-      handles.push( addHandle( options, index ).appendTo(base) );
-    }
-
-    return handles;
-  }
-
-  // Initialize a single slider.
-  function addSlider ( options, target ) {
-
-    // Apply classes and data to the target.
-    target.addClass([
-      Classes[0],
-      Classes[8 + options.dir],
-      Classes[4 + options.ort]
-    ].join(' '));
-
-    return $('<div/>').appendTo(target).addClass( Classes[1] );
-  }
+		// Apply classes and data to the target.
+		target.addClass([
+			Classes[0],
+			Classes[8 + options.dir],
+			Classes[4 + options.ort]
+		].join(' '));
+
+		return $('<div/>').appendTo(target).addClass( Classes[1] );
+	}
 
 
 // Slider scope
 
-  function closure ( target, options, originalOptions ){
+function closure ( target, options, originalOptions ){
 
 // Internal variables
 
-    // All variables local to 'closure' are marked $.
-    var $Target = $(target),
-        $Locations = [-1, -1],
-        $Base,
-        $Serialization,
-        $Handles;
+	// All variables local to 'closure' are marked $.
+	var $Target = $(target),
+		$Locations = [-1, -1],
+		$Base,
+		$Serialization,
+		$Handles;
 
-    // Shorthand for base dimensions.
-    function baseSize ( ) {
-      return $Base[['width', 'height'][options.ort]]();
-    }
+	// Shorthand for base dimensions.
+	function baseSize ( ) {
+		return $Base[['width', 'height'][options.ort]]();
+	}
 
 
 // External event handling
 
-    function fireEvents ( events ) {
+	function fireEvents ( events ) {
 
-      // Use the external api to get the values.
-      // Wrap the values in an array, as .trigger takes
-      // only one additional argument.
-      var index, values = [ $Target.val() ];
+		// Use the external api to get the values.
+		// Wrap the values in an array, as .trigger takes
+		// only one additional argument.
+		var index, values = [ $Target.val() ];
 
-      for ( index = 0; index < events.length; index++ ){
-        $Target.trigger(events[index], values);
-      }
-    }
+		for ( index = 0; index < events.length; index++ ){
+			$Target.trigger(events[index], values);
+		}
+	}
 
 
 // Handle placement
 
-    // Test suggested values and apply margin, step.
-    function setHandle ( handle, to, delimit ) {
-
-      var n = handle[0] !== $Handles[0][0] ? 1 : 0,
-          lower = $Locations[0] + options.margin,
-          upper = $Locations[1] - options.margin;
-
-      // Don't delimit range dragging.
-      if ( delimit && $Handles.length > 1 ) {
-        to = n ? Math.max( to, lower ) : Math.min( to, upper );
-      }
-
-      // Handle the step option.
-      if ( to < 100 ){
-        to = getStep(options, to);
-      }
-
-      // Limit to 0/100 for .val input, trim anything beyond 7 digits, as
-      // JavaScript has some issues in its floating point implementation.
-      to = limit(parseFloat(to.toFixed(7)));
-
-      // Return falsy if handle can't move. False for 0 or 100 limit,
-      // '0' for limiting by another handle.
-      if ( to === $Locations[n] ) {
-        if ( $Handles.length === 1 ) {
-          return false;
-        }
-        return ( to === lower || to === upper ) ? 0 : false;
-      }
-
-      // Set the handle to the new position.
-      handle.css( options.style, to + '%' );
-
-      // Force proper handle stacking
-      if ( handle.is(':first-child') ) {
-        handle.toggleClass(Classes[17], to > 50 );
-      }
+	// Test suggested values and apply margin, step.
+	function setHandle ( handle, to, delimit ) {
+
+		var n = handle[0] !== $Handles[0][0] ? 1 : 0,
+			lower = $Locations[0] + options.margin,
+			upper = $Locations[1] - options.margin;
+
+		// Don't delimit range dragging.
+		if ( delimit && $Handles.length > 1 ) {
+			to = n ? Math.max( to, lower ) : Math.min( to, upper );
+		}
+
+		// Handle the step option.
+		if ( to < 100 ){
+			to = getStep(options, to);
+		}
+
+		// Limit to 0/100 for .val input, trim anything beyond 7 digits, as
+		// JavaScript has some issues in its floating point implementation.
+		to = limit(parseFloat(to.toFixed(7)));
+
+		// Return falsy if handle can't move. False for 0 or 100 limit,
+		// '0' for limiting by another handle.
+		if ( to === $Locations[n] ) {
+			if ( $Handles.length === 1 ) {
+				return false;
+			}
+			return ( to === lower || to === upper ) ? 0 : false;
+		}
+
+		// Set the handle to the new position.
+		handle.css( options.style, to + '%' );
+
+		// Force proper handle stacking
+		if ( handle.is(':first-child') ) {
+			handle.toggleClass(Classes[17], to > 50 );
+		}
+
+		// Update locations.
+		$Locations[n] = to;
+
+		// Invert the value if this is a right-to-left slider.
+		if ( options.dir ) {
+			to = 100 - to;
+		}
+
+		// Write values to serialization Links.
+		// Convert the value to the correct relative representation.
+		// Convert the value to the slider stepping/range.
+		$($Serialization[n]).each(function(){
+			this.write( fromStepping( options, to ), handle.children(), $Target );
+		});
+
+		return true;
+	}
+
+	// Delimit proposed values for handle positions.
+	function getPositions ( a, b, delimit ) {
+
+		// Add movement to current position.
+		var c = a + b[0], d = a + b[1];
+
+		// Only alter the other position on drag,
+		// not on standard sliding.
+		if ( delimit ) {
+			if ( c < 0 ) {
+				d += Math.abs(c);
+			}
+			if ( d > 100 ) {
+				c -= ( d - 100 );
+			}
+
+			// Limit values to 0 and 100.
+			return [limit(c), limit(d)];
+		}
+
+		return [c,d];
+	}
+
+	// Handles movement by tapping.
+	function jump ( handle, to, instant ) {
+
+		if ( !instant ) {
+			// Flag the slider as it is now in a transitional state.
+			// Transition takes 300 ms, so re-enable the slider afterwards.
+			addClassFor( $Target, Classes[14], 300 );
+		}
+
+		// Move the handle to the new position.
+		setHandle( handle, to, false );
+
+		fireEvents(['slide', 'set', 'change']);
+	}
 
-      // Update locations.
-      $Locations[n] = to;
 
-      // Invert the value if this is a right-to-left slider.
-      if ( options.dir ) {
-        to = 100 - to;
-      }
+// Events
 
-      // Write values to serialization Links.
-      // Convert the value to the correct relative representation.
-      $($Serialization[n]).each(function(){
-        this.write( options, to, handle.children(), $Target );
-      });
+	// Handler for attaching events trough a proxy.
+	function attach ( events, element, callback, data ) {
 
-      return true;
-    }
+		// Add the noUiSlider namespace to all events.
+		events = events.replace( /\s/g, namespace + ' ' ) + namespace;
 
-    // Delimit proposed values for handle positions.
-    function getPositions ( a, b, delimit ) {
+		// Bind a closure on the target.
+		return element.on( events, function( e ){
 
-      // Add movement to current position.
-      var c = a + b[0], d = a + b[1];
+			// jQuery and Zepto handle unset attributes differently.
+			var disabled = $Target.attr('disabled');
+				disabled = !( disabled === undefined || disabled === null );
 
-      // Only alter the other position on drag,
-      // not on standard sliding.
-      if ( delimit ) {
-        if ( c < 0 ) {
-          d += Math.abs(c);
-        }
-        if ( d > 100 ) {
-          c -= ( d - 100 );
-        }
+			// Test if there is anything that should prevent an event
+			// from being handled, such as a disabled state or an active
+			// 'tap' transition.
+			if( $Target.hasClass( Classes[14] ) || disabled ) {
+				return false;
+			}
 
-        // Limit values to 0 and 100.
-        return [limit(c), limit(d)];
-      }
+			e = fixEvent(e);
+			e.calcPoint = e.points[ options.ort ];
 
-      return [c,d];
-    }
+			// Call the event handler with the event [ and additional data ].
+			callback ( e, data );
+		});
+	}
 
-    // Handles movement by tapping.
-    function jump ( handle, to, instant ) {
+	// Handle movement on document for handle and range drag.
+	function move ( event, data ) {
 
-      if ( !instant ) {
-        // Flag the slider as it is now in a transitional state.
-        // Transition takes 300 ms, so re-enable the slider afterwards.
-        addClassFor( $Target, Classes[14], 300 );
-      }
+		var handles = data.handles || $Handles, positions, state = false,
+			proposal = ((event.calcPoint - data.start) * 100) / baseSize(),
+			h = handles[0][0] !== $Handles[0][0] ? 1 : 0;
 
-      // Move the handle to the new position.
-      setHandle( handle, to, false );
+		// Calculate relative positions for the handles.
+		positions = getPositions( proposal, data.positions, handles.length > 1);
 
-      fireEvents(['slide', 'set', 'change']);
-    }
+		state = setHandle ( handles[0], positions[h], handles.length === 1 );
 
+		if ( handles.length > 1 ) {
+			state = setHandle ( handles[1], positions[h?0:1], false ) || state;
+		}
 
-// Events
+		// Fire the 'slide' event if any handle moved.
+		if ( state ) {
+			fireEvents(['slide']);
+		}
+	}
 
-    // Handler for attaching events trough a proxy.
-    function attach ( events, element, callback, data ) {
+	// Unbind move events on document, call callbacks.
+	function end ( event ) {
 
-      // Add the noUiSlider namespace to all events.
-      events = events.replace( /\s/g, namespace + ' ' ) + namespace;
+		// The handle is no longer active, so remove the class.
+		$('.' + Classes[15]).removeClass(Classes[15]);
 
-      // Bind a closure on the target.
-      return element.on( events, function( e ){
+		// Remove cursor styles and text-selection events bound to the body.
+		if ( event.cursor ) {
+			$('body').css('cursor', '').off( namespace );
+		}
 
-        // jQuery and Zepto handle unset attributes differently.
-        var disabled = $Target.attr('disabled');
-        disabled = !( disabled === undefined || disabled === null );
+		// Unbind the move and end events, which are added on 'start'.
+		doc.off( namespace );
 
-        // Test if there is anything that should prevent an event
-        // from being handled, such as a disabled state or an active
-        // 'tap' transition.
-        if( $Target.hasClass( Classes[14] ) || disabled ) {
-          return false;
-        }
+		// Remove dragging class.
+		$Target.removeClass(Classes[12]);
 
-        e = fixEvent(e);
-        e.calcPoint = e.points[ options.ort ];
+		// Fire the change and set events.
+		fireEvents(['set', 'change']);
+	}
 
-        // Call the event handler with the event [ and additional data ].
-        callback ( e, data );
-      });
-    }
+	// Bind move events on document.
+	function start ( event, data ) {
 
-    // Handle movement on document for handle and range drag.
-    function move ( event, data ) {
+		// Mark the handle as 'active' so it can be styled.
+		if( data.handles.length === 1 ) {
+			data.handles[0].children().addClass(Classes[15]);
+		}
 
-      var handles = data.handles || $Handles, positions, state = false,
-          proposal = ((event.calcPoint - data.start) * 100) / baseSize(),
-          h = handles[0][0] !== $Handles[0][0] ? 1 : 0;
+		// A drag should never propagate up to the 'tap' event.
+		event.stopPropagation();
 
-      // Calculate relative positions for the handles.
-      positions = getPositions( proposal, data.positions, handles.length > 1);
+		// Attach the move event.
+		attach ( actions.move, doc, move, {
+			start: event.calcPoint,
+			handles: data.handles,
+			positions: [
+				$Locations[0],
+				$Locations[$Handles.length - 1]
+			]
+		});
 
-      state = setHandle ( handles[0], positions[h], handles.length === 1 );
+		// Unbind all movement when the drag ends.
+		attach ( actions.end, doc, end, null );
 
-      if ( handles.length > 1 ) {
-        state = setHandle ( handles[1], positions[h?0:1], false ) || state;
-      }
+		// Text selection isn't an issue on touch devices,
+		// so adding cursor styles can be skipped.
+		if ( event.cursor ) {
 
-      // Fire the 'slide' event if any handle moved.
-      if ( state ) {
-        fireEvents(['slide']);
-      }
-    }
+			// Prevent the 'I' cursor and extend the range-drag cursor.
+			$('body').css('cursor', $(event.target).css('cursor'));
 
-    // Unbind move events on document, call callbacks.
-    function end ( event ) {
+			// Mark the target with a dragging state.
+			if ( $Handles.length > 1 ) {
+				$Target.addClass(Classes[12]);
+			}
 
-      // The handle is no longer active, so remove the class.
-      $('.' + Classes[15]).removeClass(Classes[15]);
+			// Prevent text selection when dragging the handles.
+			$('body').on('selectstart' + namespace, false);
+		}
+	}
 
-      // Remove cursor styles and text-selection events bound to the body.
-      if ( event.cursor ) {
-        $('body').css('cursor', '').off( namespace );
-      }
+	// Move closest handle to tapped location.
+	function tap ( event ) {
 
-      // Unbind the move and end events, which are added on 'start'.
-      doc.off( namespace );
+		var location = event.calcPoint, total = 0, to;
 
-      // Remove dragging class.
-      $Target.removeClass(Classes[12]);
+		// The tap event shouldn't propagate up and cause 'edge' to run.
+		event.stopPropagation();
 
-      // Fire the change and set events.
-      fireEvents(['set', 'change']);
-    }
+		// Add up the handle offsets.
+		$.each( $Handles, function(){
+			total += this.offset()[ options.style ];
+		});
 
-    // Bind move events on document.
-    function start ( event, data ) {
+		// Find the handle closest to the tapped position.
+		total = ( location < total/2 || $Handles.length === 1 ) ? 0 : 1;
 
-      // Mark the handle as 'active' so it can be styled.
-      if( data.handles.length === 1 ) {
-        data.handles[0].children().addClass(Classes[15]);
-      }
+		location -= $Base.offset()[ options.style ];
 
-      // A drag should never propagate up to the 'tap' event.
-      event.stopPropagation();
+		// Calculate the new position.
+		to = ( location * 100 ) / baseSize();
 
-      // Attach the move event.
-      attach ( actions.move, doc, move, {
-        start: event.calcPoint,
-        handles: data.handles,
-        positions: [
-          $Locations[0],
-          $Locations[$Handles.length - 1]
-        ]
-      });
+		// Find the closest handle and calculate the tapped point.
+		// The set handle to the new position.
+		jump( $Handles[total], to, options.events.snap );
 
-      // Unbind all movement when the drag ends.
-      attach ( actions.end, doc, end, null );
+		if ( options.events.snap ) {
+			start(event, { handles: [$Handles[total]] });
+		}
+	}
 
-      // Text selection isn't an issue on touch devices,
-      // so adding cursor styles can be skipped.
-      if ( event.cursor ) {
+	// Move handle to edges when target gets tapped.
+	function edge ( event ) {
 
-        // Prevent the 'I' cursor and extend the range-drag cursor.
-        $('body').css('cursor', $(event.target).css('cursor'));
+		var i = event.calcPoint < $Base.offset()[ options.style ],
+			to = i ? 0 : 100;
 
-        // Mark the target with a dragging state.
-        if ( $Handles.length > 1 ) {
-          $Target.addClass(Classes[12]);
-        }
+		i = i ? 0 : $Handles.length - 1;
 
-        // Prevent text selection when dragging the handles.
-        $('body').on('selectstart' + namespace, false);
-      }
-    }
+		jump( $Handles[i], to, false );
+	}
 
-    // Move closest handle to tapped location.
-    function tap ( event ) {
+	// Attach events to several slider parts.
+	function events ( behaviour ) {
 
-      var location = event.calcPoint, total = 0, to;
+		var i, drag;
 
-      // The tap event shouldn't propagate up and cause 'edge' to run.
-      event.stopPropagation();
+		// Attach the standard drag event to the handles.
+		if ( !behaviour.fixed ) {
 
-      // Add up the handle offsets.
-      $.each( $Handles, function(){
-        total += this.offset()[ options.style ];
-      });
+			for ( i = 0; i < $Handles.length; i++ ) {
 
-      // Find the handle closest to the tapped position.
-      total = ( location < total/2 || $Handles.length === 1 ) ? 0 : 1;
+				// These events are only bound to the visual handle
+				// element, not the 'real' origin element.
+				attach ( actions.start, $Handles[i].children(), start, {
+					handles: [ $Handles[i] ]
+				});
+			}
+		}
 
-      location -= $Base.offset()[ options.style ];
+		// Attach the tap event to the slider base.
+		if ( behaviour.tap ) {
+			attach ( actions.start, $Base, tap, {
+				handles: $Handles
+			});
+		}
 
-      // Calculate the new position.
-      to = ( location * 100 ) / baseSize();
+		// Extend tapping behaviour to target
+		if ( behaviour.extend ) {
 
-      // Find the closest handle and calculate the tapped point.
-      // The set handle to the new position.
-      jump( $Handles[total], to, options.events.snap );
+			$Target.addClass( Classes[16] );
 
-      if ( options.events.snap ) {
-        start(event, { handles: [$Handles[total]] });
-      }
-    }
+			if ( behaviour.tap ) {
+				attach ( actions.start, $Target, edge, {
+					handles: $Handles
+				});
+			}
+		}
 
-    // Move handle to edges when target gets tapped.
-    function edge ( event ) {
+		// Make the range dragable.
+		if ( behaviour.drag ){
 
-      var i = event.calcPoint < $Base.offset()[ options.style ],
-          to = i ? 0 : 100;
+			drag = $Base.find( '.' + Classes[7] ).addClass( Classes[10] );
 
-      i = i ? 0 : $Handles.length - 1;
+			// When the range is fixed, the entire range can
+			// be dragged by the handles. The handle in the first
+			// origin will propagate the start event upward,
+			// but it needs to be bound manually on the other.
+			if ( behaviour.fixed ) {
+				drag = drag.add($Base.children().not( drag ).children());
+			}
 
-      jump( $Handles[i], to, false );
-    }
+			attach ( actions.start, drag, start, {
+				handles: $Handles
+			});
+		}
+	}
 
-    // Attach events to several slider parts.
-    function events ( behaviour ) {
 
-      var i, drag;
+// Initialize slider
 
-      // Attach the standard drag event to the handles.
-      if ( !behaviour.fixed ) {
+	// Throw an error if the slider was already initialized.
+	if ( $Target.hasClass(Classes[0]) ) {
+		throw new Error('Slider was already initialized.');
+	}
 
-        for ( i = 0; i < $Handles.length; i++ ) {
+	// Create the base element, initialise HTML and set classes.
+	// Add handles and links.
+	$Base = addSlider( options, $Target );
+	$Handles = addHandles( options, $Base );
+	$Serialization = addLinks( options, $Handles );
 
-          // These events are only bound to the visual handle
-          // element, not the 'real' origin element.
-          attach ( actions.start, $Handles[i].children(), start, {
-            handles: [ $Handles[i] ]
-          });
-        }
-      }
+	// Set the connect classes.
+	addConnection ( options.connect, $Target, $Handles );
 
-      // Attach the tap event to the slider base.
-      if ( behaviour.tap ) {
-        attach ( actions.start, $Base, tap, {
-          handles: $Handles
-        });
-      }
+	// Attach user events.
+	events( options.events );
 
-      // Extend tapping behaviour to target
-      if ( behaviour.extend ) {
 
-        $Target.addClass( Classes[16] );
+// Methods
 
-        if ( behaviour.tap ) {
-          attach ( actions.start, $Target, edge, {
-            handles: $Handles
-          });
-        }
-      }
+	// Set the slider value.
+	/** @expose */
+	target.vSet = function ( ) {
+
+		var args = Array.prototype.slice.call( arguments, 0 ),
+			callback, link, update, animate,
+			i, count, actual, to, values = asArray( args[0] );
+
+		// Extract modifiers for value method.
+		if ( typeof args[1] === 'object' ) {
+			callback = args[1]['set'];
+			link = args[1]['link'];
+			update = args[1]['update'];
+			animate = args[1]['animate'];
+
+		// Support the 'true' option.
+		} else if ( args[1] === true ) {
+			callback = true;
+		}
+
+		// The RTL settings is implemented by reversing the front-end,
+		// internal mechanisms are the same.
+		if ( options.dir && options.handles > 1 ) {
+			values.reverse();
+		}
+
+		// Animation is optional.
+		if ( animate ) {
+			addClassFor( $Target, Classes[14], 300 );
+		}
+
+		// Determine how often to set the handles.
+		count = $Handles.length > 1 ? 3 : 1;
+		if ( values.length === 1 ) {
+			count = 1;
+		}
+
+		// If there are multiple handles to be set run the setting
+		// mechanism twice for the first handle, to make sure it
+		// can be bounced of the second one properly.
+		for ( i = 0; i < count; i++ ) {
+
+			to = link || $Serialization[i%2][0];
+			to = to.getValue( values[i%2] );
+
+			if ( to === false ) {
+				continue;
+			}
+
+			// Calculate the new handle position
+			to = toStepping( options, to );
+
+			// Invert the value if this is a right-to-left slider.
+			if ( options.dir ) {
+				to = 100 - to;
+			}
+
+			// Force delimitation.
+			if ( setHandle( $Handles[i%2], to, true ) === true ) {
+				continue;
+			}
+
+			// Reset the input if it doesn't match the slider.
+			$($Serialization[i%2]).each(function(index){
+
+				if (!index) {
+					actual = this.actual;
+					return true;
+				}
+
+				this.write(
+					actual,
+					$Handles[i%2].children(),
+					$Target,
+					update
+				);
+			});
+		}
+
+		// Optionally fire the 'set' event.
+		if( callback === true ) {
+			fireEvents(['set']);
+		}
+
+		return this;
+	};
+
+	// Get the slider value.
+	/** @expose */
+	target.vGet = function ( ) {
+
+		var i, retour = [];
+
+		// Get the value from all handles.
+		for ( i = 0; i < options.handles; i++ ){
+			retour[i] = $Serialization[i][0].saved;
+		}
+
+		// If only one handle is used, return a single value.
+		if ( retour.length === 1 ){
+			return retour[0];
+		}
+
+		if ( options.dir ) {
+			return retour.reverse();
+		}
+
+		return retour;
+	};
+
+	// Destroy the slider and unbind all events.
+	/** @expose */
+	target.destroy = function ( ) {
+
+		// Loop all linked serialization objects and unbind all
+		// events in the noUiSlider namespace.
+		$.each($Serialization, function(){
+			$.each(this, function(){
+				// Won't remove 'change' when bound implicitly.
+				if ( this.target ) {
+					this.target.off( namespace );
+				}
+			});
+		});
+
+		// Unbind events on the slider, remove all classes and child elements.
+		$(this).off(namespace)
+			.removeClass(Classes.join(' '))
+			.empty();
+
+		// Return the original options from the closure.
+		return originalOptions;
+	};
 
-      // Make the range dragable.
-      if ( behaviour.drag ){
 
-        drag = $Base.find( '.' + Classes[7] ).addClass( Classes[10] );
+// Value setting
 
-        // When the range is fixed, the entire range can
-        // be dragged by the handles. The handle in the first
-        // origin will propagate the start event upward,
-        // but it needs to be bound manually on the other.
-        if ( behaviour.fixed ) {
-          drag = drag.add($Base.children().not( drag ).children());
-        }
+	// Use the public value method to set the start values.
+	$Target.val( options.start );
+}
 
-        attach ( actions.start, drag, start, {
-          handles: $Handles
-        });
-      }
-    }
 
+// Access points
 
-// Initialize slider
+	// Run the standard initializer
+	function initialize ( originalOptions ) {
 
-    // Throw an error if the slider was already initialized.
-    if ( !$Target.is(':empty') ) {
-      throw new Error('Slider was already initialized.');
-    }
+		// Throw error if group is empty.
+		if ( !this.length ){
+			throw new Error("noUiSlider: Can't initialize slider on empty selection.");
+		}
 
-    // Create the base element, initialise HTML and set classes.
-    // Add handles and links.
-    $Base = addSlider( options, $Target );
-    $Handles = addHandles( options, $Base );
-    $Serialization = addLinks( options, $Handles );
+		// Test the options once, not for every slider.
+		var options = test( originalOptions, this );
 
-    // Set the connect classes.
-    addConnection ( options.connect, $Target, $Handles );
+		// Loop all items, and provide a new closed-scope environment.
+		return this.each(function(){
+			closure(this, options, originalOptions);
+		});
+	}
 
-    // Attach user events.
-    events( options.events );
+	// Destroy the slider, then re-enter initialization.
+	function rebuild ( options ) {
 
+		return this.each(function(){
 
-// Methods
+			// Get the current values from the slider,
+			// including the initialization options.
+			var values = $(this).val(),
+				originalOptions = this.destroy(),
 
-    // Set the slider value.
-    target.vSet = function ( values, callback, link, update, animate ){
-
-      var i, to;
-
-      // The RTL settings is implemented by reversing the front-end,
-      // internal mechanisms are the same.
-      if ( options.dir && options.handles > 1 ) {
-        values.reverse();
-      }
-
-      // Animation is optional.
-      if ( animate ) {
-        addClassFor( $Target, Classes[14], 300 );
-      }
-
-      // If there are multiple handles to be set run the setting
-      // mechanism twice for the first handle, to make sure it
-      // can be bounced of the second one properly.
-      for ( i = 0; i < ( $Handles.length > 1 ? 3 : 1 ); i++ ) {
-
-        to = link || $Serialization[i%2][0];
-        to = to.valueOf( values[i%2] );
-
-        if ( to === false ) {
-          continue;
-        }
-
-        // Calculate the new handle position
-        to = toStepping( options, to );
-
-        // Invert the value if this is a right-to-left slider.
-        if ( options.dir ) {
-          to = 100 - to;
-        }
-
-        // Force delimitation.
-        if ( setHandle( $Handles[i%2], to, true ) === true ) {
-          continue;
-        }
-
-        // Reset the input if it doesn't match the slider.
-        $($Serialization[i%2]).each(function(){
-          this.write(
-              options,
-              $Locations[i%2],
-              $Handles[i%2].children(),
-              $Target,
-              update
-          );
-        });
-      }
-
-      // Optionally fire the 'set' event.
-      if( callback === true ) {
-        fireEvents(['set']);
-      }
-
-      return this;
-    };
-
-    // Get the slider value.
-    target.vGet = function ( ){
-
-      var i, retour = [];
-
-      // Get the value from all handles.
-      for ( i = 0; i < options.handles; i++ ){
-        retour[i] = $Serialization[i][0].saved;
-      }
-
-      // If only one handle is used, return a single value.
-      if ( retour.length === 1 ){
-        return retour[0];
-      }
-
-      if ( options.dir && options.handles > 1 ) {
-        return retour.reverse();
-      }
-
-      return retour;
-    };
-
-    // Destroy the slider and unbind all events.
-    target.destroy = function ( ){
-
-      // Loop all linked serialization objects and unbind all
-      // events in the noUiSlider namespace.
-      $.each($Serialization, function(){
-        $.each(this, function(){
-          // Won't remove 'change' when bound implicitly.
-          if ( this.target ) {
-            this.target.off( namespace );
-          }
-        });
-      });
-
-      // Unbind events on the slider, remove all classes and child elements.
-      $(this).off(namespace)
-          .removeClass(Classes.join(' '))
-          .empty();
-
-      // Return the original options from the closure.
-      return originalOptions;
-    };
+				// Extend the previous options with the newly provided ones.
+				newOptions = $.extend( {}, originalOptions, options );
 
+			// Run the standard initializer.
+			$(this).noUiSlider( newOptions );
 
-// Value setting
+			// If the start option hasn't changed,
+			// reset the previous values.
+			if ( originalOptions.start === newOptions.start ) {
+				$(this).val(values);
+			}
+		});
+	}
 
-    // Use the public value method to set the start values.
-    $Target.val( options.start );
-  }
 
+// Remap the serialization constructor for legacy support.
+	/** @expose */
+	$.noUiSlider = { 'Link': $.Link };
 
-// Access points
+// Extend jQuery/Zepto with the noUiSlider method.
+	/** @expose */
+	$.fn.noUiSlider = function ( options, re ) {
+		return ( re ? rebuild : initialize ).call(this, options);
+	};
 
-  // Run the standard initializer
-  function initialize ( originalOptions ) {
-
-    // Throw error if group is empty.
-    if ( !this.length ){
-      throwError("Can't initialize slider on empty selection.");
-    }
-
-    // Test the options once, not for every slider.
-    var options = test( originalOptions, this );
-
-    // Loop all items, and provide a new closed-scope environment.
-    return this.each(function(){
-      closure(this, options, originalOptions);
-    });
-  }
-
-  // Destroy the slider, then re-enter initialization.
-  function rebuild ( options ) {
-
-    return this.each(function(){
-
-      // Get the current values from the slider,
-      // including the initialization options.
-      var values = $(this).val(),
-          originalOptions = this.destroy(),
-
-      // Extend the previous options with the newly provided ones.
-          newOptions = $.extend( {}, originalOptions, options );
-
-      // Run the standard initializer.
-      $(this).noUiSlider( newOptions );
-
-      // If the start option hasn't changed,
-      // reset the previous values.
-      if ( originalOptions.start === newOptions.start ) {
-        $(this).val(values);
-      }
-    });
-  }
-
-
-  // Expose serialization constructor.
-  /** @expose */
-  $.noUiSlider = { 'Link': Link };
-
-  // Extend jQuery/Zepto with the noUiSlider method.
-  /** @expose */
-  $.fn.noUiSlider = function ( options, re ) {
-    return ( re ? rebuild : initialize ).call(this, options);
-  };
-
-  $.fn.val = function ( ) {
-
-    // Convert the function arguments to an array.
-    var args = Array.prototype.slice.call( arguments, 0 ),
-        set, link, update, animate;
-
-    // Test if there are arguments, and if not, call the 'get' method.
-    if ( !args.length ) {
-
-      // Determine whether to use the native val method.
-      if ( this.hasClass(Classes[0]) ) {
-        return this[0].vGet();
-      }
-
-      return $val.apply( this );
-    }
-
-    // Extract modifiers for value method.
-    if ( typeof args[1] === 'object' ) {
-      set = args[1]['set'];
-      link = args[1]['link'];
-      update = args[1]['update'];
-      animate = args[1]['animate'];
-
-      // Support the 'true' option.
-    } else if ( args[1] === true ) {
-      set = true;
-    }
-
-    // Loop all individual items, and handle setting appropriately.
-    return this.each(function(){
-
-      if ( $(this).hasClass(Classes[0]) ) {
-        this.vSet( asArray(args[0]), set, link, update, animate );
-      } else {
-        $val.apply( $(this), args );
-      }
-    });
-  };
+// Attach a classbased val handler.
+	$.classVal(Classes[0], 'vGet', 'vSet', false);
 
 }( window['jQuery'] || window['Zepto'] ));