nouislider-rails 6.2.0 → 7.0.1

data/vendor/assets/javascripts/libLink/jquery.liblink.js

@@ -0,0 +1,311 @@
+/*jslint browser: true */
+/*jslint white: true */
+
+(function( $ ){
+
+    'use strict';
+
+// Helpers
+
+    // Test in an object is an instance of jQuery or Zepto.
+    function isInstance ( a ) {
+        return a instanceof $ || ( $.zepto && $.zepto.isZ(a) );
+    }
+
+
+// Link types
+
+    function fromPrefix ( target, method ) {
+
+        // If target is a string, a new hidden input will be created.
+        if ( typeof target === 'string' && target.indexOf('-inline-') === 0 ) {
+
+            // By default, use the 'html' method.
+            this.method = method || 'html';
+
+            // Use jQuery to create the element
+            this.target = this.el = $( target.replace('-inline-', '') || '<div/>' );
+
+            return true;
+        }
+    }
+
+    function fromString ( target ) {
+
+        // If the string doesn't begin with '-', which is reserved, add a new hidden input.
+        if ( typeof target === 'string' && target.indexOf('-') !== 0 ) {
+
+            this.method = 'val';
+
+            var element = document.createElement('input');
+            element.name = target;
+            element.type = 'hidden';
+            this.target = this.el = $(element);
+
+            return true;
+        }
+    }
+
+    function fromFunction ( target ) {
+
+        // The target can also be a function, which will be called.
+        if ( typeof target === 'function' ) {
+            this.target = false;
+            this.method = target;
+
+            return true;
+        }
+    }
+
+    function fromInstance ( target, method ) {
+
+        if ( isInstance( target ) && !method ) {
+
+            // If a jQuery/Zepto input element is provided, but no method is set,
+            // the element can assume it needs to respond to 'change'...
+            if ( target.is('input, select, textarea') ) {
+
+                // Default to .val if this is an input element.
+                this.method = 'val';
+
+                // Fire the API changehandler when the target changes.
+                this.target = target.on('change.liblink', this.changeHandler);
+
+            } else {
+
+                this.target = target;
+
+                // If no method is set, and we are not auto-binding an input, default to 'html'.
+                this.method = 'html';
+            }
+
+            return true;
+        }
+    }
+
+    function fromInstanceMethod ( target, method ) {
+
+        // The method must exist on the element.
+        if ( isInstance( target ) &&
+            (typeof method === 'function' ||
+            (typeof method === 'string' && target[method]))
+        ) {
+            this.method = method;
+            this.target = target;
+
+            return true;
+        }
+    }
+
+    var
+        /** @const */
+        creationFunctions = [fromPrefix, fromString, fromFunction, fromInstance, fromInstanceMethod];
+
+
+// Link Instance
+
+    /** @constructor */
+    function Link ( target, method, format ) {
+
+        var that = this, valid = false;
+
+        // Forward calls within scope.
+        this.changeHandler = function ( changeEvent ) {
+            var decodedValue = that.formatInstance.from( $(this).val() );
+
+            // If the value is invalid, stop this event, as well as it's propagation.
+            if ( decodedValue === false || isNaN(decodedValue) ) {
+
+                // Reset the value.
+                $(this).val(that.lastSetValue);
+                return false;
+            }
+
+            that.changeHandlerMethod.call( '', changeEvent, decodedValue );
+        };
+
+        // See if this Link needs individual targets based on its usage.
+        // If so, return the element that needs to be copied by the
+        // implementing interface.
+        // Default the element to false.
+        this.el = false;
+
+        // Store the formatter, or use the default.
+        this.formatInstance = format;
+
+        // Try all Link types.
+        /*jslint unparam: true*/
+        $.each(creationFunctions, function(i, fn){
+            valid = fn.call(that, target, method);
+            return !valid;
+        });
+        /*jslint unparam: false*/
+
+        // Nothing matched, throw error.
+        if ( !valid ) {
+            throw new RangeError("(Link) Invalid Link.");
+        }
+    }
+
+    // Provides external items with the object value.
+    Link.prototype.set = function ( value ) {
+
+        // Ignore the value, so only the passed-on arguments remain.
+        var args = Array.prototype.slice.call( arguments ),
+            additionalArgs = args.slice(1);
+
+        // Store some values. The actual, numerical value,
+        // the formatted value and the parameters for use in 'resetValue'.
+        // Slice additionalArgs to break the relation.
+        this.lastSetValue = this.formatInstance.to( value );
+
+        // Prepend the value to the function arguments.
+        additionalArgs.unshift(
+            this.lastSetValue
+        );
+
+        // When target is undefined, the target was a function.
+        // In that case, provided the object as the calling scope.
+        // Branch between writing to a function or an object.
+        ( typeof this.method === 'function' ?
+            this.method :
+            this.target[ this.method ] ).apply( this.target, additionalArgs );
+    };
+
+
+// Developer API
+
+    /** @constructor */
+    function LinkAPI ( origin ) {
+        this.items = [];
+        this.elements = [];
+        this.origin = origin;
+    }
+
+    LinkAPI.prototype.push = function( item, element ) {
+        this.items.push(item);
+
+        // Prevent 'false' elements
+        if ( element ) {
+            this.elements.push(element);
+        }
+    };
+
+    LinkAPI.prototype.reconfirm = function ( flag ) {
+        var i;
+        for ( i = 0; i < this.elements.length; i += 1 ) {
+            this.origin.LinkConfirm(flag, this.elements[i]);
+        }
+    };
+
+    LinkAPI.prototype.remove = function ( flag ) {
+        var i;
+        for ( i = 0; i < this.items.length; i += 1 ) {
+            this.items[i].target.off('.liblink');
+        }
+        for ( i = 0; i < this.elements.length; i += 1 ) {
+            this.elements[i].remove();
+        }
+    };
+
+    LinkAPI.prototype.change = function ( value ) {
+
+        if ( this.origin.LinkIsEmitting ) {
+            return false;
+        }
+
+        this.origin.LinkIsEmitting = true;
+
+        var args = Array.prototype.slice.call( arguments, 1 ), i;
+        args.unshift( value );
+
+        // Write values to serialization Links.
+        // Convert the value to the correct relative representation.
+        for ( i = 0; i < this.items.length; i += 1 ) {
+            this.items[i].set.apply(this.items[i], args);
+        }
+
+        this.origin.LinkIsEmitting = false;
+    };
+
+
+// jQuery plugin
+
+    function binder ( flag, target, method, format ){
+
+        if ( flag === 0 ) {
+            flag = this.LinkDefaultFlag;
+        }
+
+        // Create a list of API's (if it didn't exist yet);
+        if ( !this.linkAPI ) {
+            this.linkAPI = {};
+        }
+
+        // Add an API point.
+        if ( !this.linkAPI[flag] ) {
+            this.linkAPI[flag] = new LinkAPI(this);
+        }
+
+        var linkInstance = new Link ( target, method, format || this.LinkDefaultFormatter );
+
+        // Default the calling scope to the linked object.
+        if ( !linkInstance.target ) {
+            linkInstance.target = $(this);
+        }
+
+        // If the Link requires creation of a new element,
+        // Pass the element and request confirmation to get the changehandler.
+        // Set the method to be called when a Link changes.
+        linkInstance.changeHandlerMethod = this.LinkConfirm( flag, linkInstance.el );
+
+        // Store the linkInstance in the flagged list.
+        this.linkAPI[flag].push( linkInstance, linkInstance.el );
+
+        // Now that Link have been connected, request an update.
+        this.LinkUpdate( flag );
+    }
+
+    /** @export */
+    $.fn.Link = function( flag ){
+
+        var that = this;
+
+        // Delete all linkAPI
+        if ( flag === false ) {
+
+            return that.each(function(){
+
+                // .Link(false) can be called on elements without Links.
+                // When that happens, the objects can't be looped.
+                if ( !this.linkAPI ) {
+                    return;
+                }
+
+                $.map(this.linkAPI, function(api){
+                    api.remove();
+                });
+
+                delete this.linkAPI;
+            });
+        }
+
+        if ( flag === undefined ) {
+
+            flag = 0;
+
+        } else if ( typeof flag !== 'string') {
+
+            throw new Error("Flag must be string.");
+        }
+
+        return {
+            to: function( a, b, c ){
+                return that.each(function(){
+                    binder.call(this, flag, a, b, c);
+                });
+            }
+        };
+    };
+
+}( window.jQuery || window.Zepto ));

data/vendor/assets/javascripts/nouislider/module.base.js

@@ -0,0 +1,872 @@
+/*jslint browser: true */
+/*jslint white: true */
+
+(function( $ ){
+
+	'use strict';
+
+	var
+	// Cache the document selector;
+	/** @const */
+	doc = $(document),
+	// Make a backup of the original jQuery/Zepto .val() method.
+	/** @const */
+	$val = $.fn.val,
+	// 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 */ ,''
+/* 17 */ ,'noUi-stacking'
+	];
+
+
+// General helpers
+
+	// Limits a value to 0 - 100
+	function limit ( a ) {
+		return Math.max(Math.min(a, 100), 0);
+	}
+
+	// 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);
+	}
+
+	// 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];
+	}
+
+
+
+// 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;
+		}
+
+		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;
+		}
+
+		if ( mouse || pointer ) {
+
+			// 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;
+			}
+
+			x = e.clientX + window.pageXOffset;
+			y = e.clientY + window.pageYOffset;
+		}
+
+		event.points = [x, y];
+		event.cursor = mouse;
+
+		return event;
+	}
+
+
+// DOM additions
+
+	// Append a handle to the base.
+	function addHandle ( direction, index ) {
+
+		var handle = $('<div><div/></div>').addClass( Classes[2] ),
+			additions = [ '-lower', '-upper' ];
+
+		if ( direction ) {
+			additions.reverse();
+		}
+
+		handle.children().addClass(
+			Classes[3] + " " + Classes[3]+additions[index]
+		);
+
+		return handle;
+	}
+
+	// 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 to the slider base.
+	function addHandles ( nrHandles, direction, base ) {
+
+		var index, handles = [];
+
+		// Append handles.
+		for ( index = 0; index < nrHandles; index += 1 ) {
+
+			// Keep a list of all added handles.
+			handles.push( addHandle( direction, index ).appendTo(base) );
+		}
+
+		return handles;
+	}
+
+	// Initialize a single slider.
+	function addSlider ( direction, orientation, target ) {
+
+		// Apply classes and data to the target.
+		target.addClass([
+			Classes[0],
+			Classes[8 + direction],
+			Classes[4 + orientation]
+		].join(' '));
+
+		return $('<div/>').appendTo(target).addClass( Classes[1] );
+	}
+
+
+// Slider scope
+
+function closure ( target, options, originalOptions ){
+
+// Internal variables
+
+	// All variables local to 'closure' are marked $.
+	var $Target = $(target),
+		$Locations = [-1, -1],
+		$Base,
+		$Handles,
+		$Spectrum = options.spectrum,
+		$Values = [],
+	// libLink. For rtl sliders, 'lower' and 'upper' should not be inverted
+	// for one-handle sliders, so trim 'upper' it that case.
+		triggerPos = ['lower', 'upper'].slice(0, options.handles);
+
+	// Invert the libLink connection for rtl sliders.
+	if ( options.dir ) {
+		triggerPos.reverse();
+	}
+
+
+// Helpers
+
+	// Shorthand for base dimensions.
+	function baseSize ( ) {
+		return $Base[['width', 'height'][options.ort]]();
+	}
+
+	// External event handling
+	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() ];
+
+		for ( index = 0; index < events.length; index += 1 ){
+			$Target.trigger(events[index], values);
+		}
+	}
+
+	// Returns the input array, respecting the slider direction configuration.
+	function inSliderOrder ( values ) {
+
+		// If only one handle is used, return a single value.
+		if ( values.length === 1 ){
+			return values[0];
+		}
+
+		if ( options.dir ) {
+			return values.reverse();
+		}
+
+		return values;
+	}
+
+
+// libLink integration
+
+	// Create a new function which calls .val on input change.
+	function createChangeHandler ( trigger ) {
+		return function ( ignore, value ){
+			// Determine which array position to 'null' based on 'trigger'.
+			$Target.val( [ trigger ? null : value, trigger ? value : null ], true );
+		};
+	}
+
+	// Called by libLink when it wants a set of links updated.
+	function linkUpdate ( flag ) {
+
+		var trigger = $.inArray(flag, triggerPos);
+
+		// The API might not have been set yet.
+		if ( $Target[0].linkAPI && $Target[0].linkAPI[flag] ) {
+			$Target[0].linkAPI[flag].change(
+				$Values[trigger],
+				$Handles[trigger].children(),
+				$Target
+			);
+		}
+	}
+
+	// Called by libLink to append an element to the slider.
+	function linkConfirm ( flag, element ) {
+
+		// Find the trigger for the passed flag.
+		var trigger = $.inArray(flag, triggerPos);
+
+		// If set, append the element to the handle it belongs to.
+		if ( element ) {
+			element.appendTo( $Handles[trigger].children() );
+		}
+
+		// The public API is reversed for rtl sliders, so the changeHandler
+		// should not be aware of the inverted trigger positions.
+		if ( options.dir ) {
+			trigger = trigger === 1 ? 0 : 1;
+		}
+
+		return createChangeHandler( trigger );
+	}
+
+	// Place elements back on the slider.
+	function reAppendLink ( ) {
+
+		var i, flag;
+
+		// The API keeps a list of elements: we can re-append them on rebuild.
+		for ( i = 0; i < triggerPos.length; i += 1 ) {
+			if ( this.linkAPI && this.linkAPI[(flag = triggerPos[i])] ) {
+				this.linkAPI[flag].reconfirm(flag);
+			}
+		}
+	}
+
+	target.LinkUpdate = linkUpdate;
+	target.LinkConfirm = linkConfirm;
+	target.LinkDefaultFormatter = options.format;
+	target.LinkDefaultFlag = 'lower';
+
+	target.reappend = reAppendLink;
+
+
+	// Test suggested values and apply margin, step.
+	function setHandle ( handle, to, noLimitOption ) {
+
+		var trigger = handle[0] !== $Handles[0][0] ? 1 : 0,
+			lowerMargin = $Locations[0] + options.margin,
+			upperMargin = $Locations[1] - options.margin,
+			lowerLimit = $Locations[0] + options.limit,
+			upperLimit = $Locations[1] - options.limit;
+
+		// For sliders with multiple handles,
+		// limit movement to the other handle.
+		// Apply the margin option by adding it to the handle positions.
+		if ( $Handles.length > 1 ) {
+			to = trigger ? Math.max( to, lowerMargin ) : Math.min( to, upperMargin );
+		}
+
+		// The limit option has the opposite effect, limiting handles to a
+		// maximum distance from another. Limit must be > 0, as otherwise
+		// handles would be unmoveable. 'noLimitOption' is set to 'false'
+		// for the .val() method, except for pass 4/4.
+		if ( noLimitOption !== false && options.limit && $Handles.length > 1 ) {
+			to = trigger ? Math.min ( to, lowerLimit ) : Math.max( to, upperLimit );
+		}
+
+		// Handle the step option.
+		to = $Spectrum.getStep( 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 false if handle can't move.
+		if ( to === $Locations[trigger] ) {
+			return 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[trigger] = to;
+
+		// Convert the value to the slider stepping/range.
+		$Values[trigger] = $Spectrum.fromStepping( to );
+
+		linkUpdate(triggerPos[trigger]);
+
+		return true;
+	}
+
+	// Loop values from value method and apply them.
+	function setValues ( count, values ) {
+
+		var i, trigger, to;
+
+		// With the limit option, we'll need another limiting pass.
+		if ( options.limit ) {
+			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 += 1 ) {
+
+			trigger = i%2;
+
+			// Get the current argument from the array.
+			to = values[trigger];
+
+			// Setting with null indicates an 'ignore'.
+			// Inputting 'false' is invalid.
+			if ( to !== null && to !== false ) {
+
+				// If a formatted number was passed, attemt to decode it.
+				if ( typeof to === 'number' ) {
+					to = String(to);
+				}
+
+				to = options.format.from( to );
+
+				// Request an update for all links if the value was invalid.
+				// Do so too if setting the handle fails.
+				if ( to === false || isNaN(to) || setHandle( $Handles[trigger], $Spectrum.toStepping( to ), i === (3 - options.dir) ) === false ) {
+
+					linkUpdate(triggerPos[trigger]);
+				}
+			}
+		}
+	}
+
+
+
+	// Handler for attaching events trough a proxy.
+	function attach ( events, element, callback, data ) {
+
+		// This function can be used to 'filter' events to the slider.
+
+		// Add the noUiSlider namespace to all events.
+		events = events.replace( /\s/g, namespace + ' ' ) + namespace;
+
+		// Bind a closure on the target.
+		return element.on( events, function( e ){
+
+			// jQuery and Zepto (1) handle unset attributes differently,
+			// but always falsy; #208
+			if ( !!$Target.attr('disabled') ) {
+				return false;
+			}
+
+			// Stop if an active 'tap' transition is taking place.
+			if ( $Target.hasClass( Classes[14] ) ) {
+				return false;
+			}
+
+			e = fixEvent(e);
+			e.calcPoint = e.points[ options.ort ];
+
+			// Call the event handler with the event [ and additional data ].
+			callback ( e, data );
+		});
+	}
+
+	// Handle movement on document for handle and range drag.
+	function move ( event, data ) {
+
+		var handles = data.handles || $Handles, positions, state = false,
+			proposal = ((event.calcPoint - data.start) * 100) / baseSize(),
+			h = handles[0][0] !== $Handles[0][0] ? 1 : 0;
+
+		// Calculate relative positions for the handles.
+		positions = getPositions( proposal, data.positions, handles.length > 1);
+
+		state = setHandle ( handles[0], positions[h], handles.length === 1 );
+
+		if ( handles.length > 1 ) {
+			state = setHandle ( handles[1], positions[h?0:1], false ) || state;
+		}
+
+		// Fire the 'slide' event if any handle moved.
+		if ( state ) {
+			fireEvents(['slide']);
+		}
+	}
+
+	// Unbind move events on document, call callbacks.
+	function end ( event ) {
+
+		// The handle is no longer active, so remove the class.
+		$('.' + Classes[15]).removeClass(Classes[15]);
+
+		// Remove cursor styles and text-selection events bound to the body.
+		if ( event.cursor ) {
+			$('body').css('cursor', '').off( namespace );
+		}
+
+		// Unbind the move and end events, which are added on 'start'.
+		doc.off( namespace );
+
+		// Remove dragging class.
+		$Target.removeClass(Classes[12]);
+
+		// Fire the change and set events.
+		fireEvents(['set', 'change']);
+	}
+
+	// Bind move events on document.
+	function start ( event, data ) {
+
+		// Mark the handle as 'active' so it can be styled.
+		if( data.handles.length === 1 ) {
+			data.handles[0].children().addClass(Classes[15]);
+		}
+
+		// A drag should never propagate up to the 'tap' event.
+		event.stopPropagation();
+
+		// Attach the move event.
+		attach ( actions.move, doc, move, {
+			start: event.calcPoint,
+			handles: data.handles,
+			positions: [
+				$Locations[0],
+				$Locations[$Handles.length - 1]
+			]
+		});
+
+		// Unbind all movement when the drag ends.
+		attach ( actions.end, doc, end, null );
+
+		// Text selection isn't an issue on touch devices,
+		// so adding cursor styles can be skipped.
+		if ( event.cursor ) {
+
+			// Prevent the 'I' cursor and extend the range-drag cursor.
+			$('body').css('cursor', $(event.target).css('cursor'));
+
+			// Mark the target with a dragging state.
+			if ( $Handles.length > 1 ) {
+				$Target.addClass(Classes[12]);
+			}
+
+			// Prevent text selection when dragging the handles.
+			$('body').on('selectstart' + namespace, false);
+		}
+	}
+
+	// Move closest handle to tapped location.
+	function tap ( event ) {
+
+		var location = event.calcPoint, total = 0, to;
+
+		// The tap event shouldn't propagate up and cause 'edge' to run.
+		event.stopPropagation();
+
+		// Add up the handle offsets.
+		$.each( $Handles, function(){
+			total += this.offset()[ options.style ];
+		});
+
+		// Find the handle closest to the tapped position.
+		total = ( location < total/2 || $Handles.length === 1 ) ? 0 : 1;
+
+		location -= $Base.offset()[ options.style ];
+
+		// Calculate the new position.
+		to = ( location * 100 ) / baseSize();
+
+		if ( !options.events.snap ) {
+			// 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 );
+		}
+
+		// Find the closest handle and calculate the tapped point.
+		// The set handle to the new position.
+		setHandle( $Handles[total], to );
+
+		fireEvents(['slide', 'set', 'change']);
+
+		if ( options.events.snap ) {
+			start(event, { handles: [$Handles[total]] });
+		}
+	}
+
+	// Attach events to several slider parts.
+	function events ( behaviour ) {
+
+		var i, drag;
+
+		// Attach the standard drag event to the handles.
+		if ( !behaviour.fixed ) {
+
+			for ( i = 0; i < $Handles.length; i += 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] ]
+				});
+			}
+		}
+
+		// Attach the tap event to the slider base.
+		if ( behaviour.tap ) {
+
+			attach ( actions.start, $Base, tap, {
+				handles: $Handles
+			});
+		}
+
+		// Make the range dragable.
+		if ( behaviour.drag ){
+
+			drag = $Base.find( '.' + Classes[7] ).addClass( Classes[10] );
+
+			// 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());
+			}
+
+			attach ( actions.start, drag, start, {
+				handles: $Handles
+			});
+		}
+	}
+
+
+
+	// Set the slider value.
+	function valueSet ( input ) {
+
+		// LibLink: don't accept new values when currently emitting changes.
+		if ( $Target[0].LinkIsEmitting ) {
+			return this;
+		}
+
+		var count, values = asArray( input );
+
+		// 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.
+		// Make sure the initial values where set before using animated
+		// placement. (no report, unit testing);
+		if ( options.animate && $Locations[0] !== -1 ) {
+			addClassFor( $Target, Classes[14], 300 );
+		}
+
+		// Determine how often to set the handles.
+		count = $Handles.length > 1 ? 3 : 1;
+
+		if ( values.length === 1 ) {
+			count = 1;
+		}
+
+		setValues ( count, values );
+
+		// Fire the 'set' event. As of noUiSlider 7,
+		// this is no longer optional.
+		fireEvents(['set']);
+
+		return this;
+	}
+
+	// Get the slider value.
+	function valueGet ( ) {
+
+		var i, retour = [];
+
+		// Get the value from all handles.
+		for ( i = 0; i < options.handles; i += 1 ){
+			retour[i] = options.format.to( $Values[i] );
+		}
+
+		return inSliderOrder( retour );
+	}
+
+
+
+	// Destroy the slider and unbind all events.
+	function destroyTarget ( ) {
+
+		// Unbind events on the slider, remove all classes and child elements.
+		$(this).off(namespace)
+			.removeClass(Classes.join(' '))
+			.empty();
+
+		delete this.LinkUpdate;
+		delete this.LinkConfirm;
+		delete this.LinkDefaultFormatter;
+		delete this.LinkDefaultFlag;
+		delete this.reappend;
+		delete this.vGet;
+		delete this.vSet;
+		delete this.getCurrentStep;
+		delete this.getInfo;
+		delete this.destroy;
+
+		// Return the original options from the closure.
+		return originalOptions;
+	}
+
+	// Get the current step size for the slider.
+	function getCurrentStep ( ) {
+
+		// Check all locations, map them to their stepping point.
+		// Get the step point, then find it in the input list.
+		var retour = $.map($Locations, function( location, index ){
+
+			var step = $Spectrum.getApplicableStep( location ),
+				value = $Values[index],
+				increment = step[2],
+				decrement = (value - step[2]) >= step[1] ? step[2] : step[0];
+
+			return [[decrement, increment]];
+		});
+
+		// Return values in the proper order.
+		return inSliderOrder( retour );
+	}
+
+
+
+// Initialize slider
+
+	// Throw an error if the slider was already initialized.
+	if ( $Target.hasClass(Classes[0]) ) {
+		throw new Error('Slider was already initialized.');
+	}
+
+	// Create the base element, initialise HTML and set classes.
+	// Add handles and links.
+	$Base = addSlider( options.dir, options.ort, $Target );
+	$Handles = addHandles( options.handles, options.dir, $Base );
+
+	// Set the connect classes.
+	addConnection ( options.connect, $Target, $Handles );
+
+	// Attach user events.
+	events( options.events );
+
+// Methods
+
+	target.vSet = valueSet;
+	target.vGet = valueGet;
+	target.destroy = destroyTarget;
+	target.getCurrentStep = getCurrentStep;
+	target.getInfo = function(){
+		return [
+			$Spectrum,
+			options.style,
+			options.ort
+		];
+	};
+
+	// Use the public value method to set the start values.
+	$Target.val( options.start );
+}
+
+
+// Access points
+
+	// Run the standard initializer
+	function initialize ( originalOptions ) {
+
+		// Throw error if group is empty.
+		if ( !this.length ){
+			throw new Error("noUiSlider: Can't initialize slider on empty selection.");
+		}
+
+		// Test the options once, not for every slider.
+		var options = $.noUiSlider.testOptions( 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(){
+
+			// The rebuild flag can be used if the slider wasn't initialized yet.
+			if ( !this.destroy ) {
+				$(this).noUiSlider( options );
+				return;
+			}
+
+			// 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 );
+
+			// Place Link elements back.
+			this.reappend();
+
+			// If the start option hasn't changed,
+			// reset the previous values.
+			if ( originalOptions.start === newOptions.start ) {
+				$(this).val(values);
+			}
+		});
+	}
+
+	// Access the internal getting and setting methods based on argument count.
+	function value ( ) {
+		return this[0][ !arguments.length ? 'vGet' : 'vSet' ].apply(this[0], arguments);
+	}
+
+	// Override the .val() method. Test every element. Is it a slider? Go to
+	// the slider value handling. No? Use the standard method.
+	// Note how $.fn.val expects 'this' to be an instance of $. For convenience,
+	// the above 'value' function does too.
+	$.fn.val = function ( ) {
+
+		// this === instanceof $
+
+		function valMethod( a ){
+			return a.hasClass(Classes[0]) ? value : $val;
+		}
+
+		var args = arguments,
+			first = $(this[0]);
+
+		if ( !arguments.length ) {
+			return valMethod(first).call(first);
+		}
+
+		// Return the set so it remains chainable
+		return this.each(function(){
+			valMethod($(this)).apply($(this), args);
+		});
+	};
+
+// Extend jQuery/Zepto with the noUiSlider method.
+	$.fn.noUiSlider = function ( options, rebuildFlag ) {
+		return ( rebuildFlag ? rebuild : initialize ).call(this, options);
+	};
+
+}( window.jQuery || window.Zepto ));