text: /*	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 defaultFormatter = { 'to': function( value ){
  		return value !== undefined && value.toFixed(2);
  	}, 'from': Number };
  
  	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.singleStep = entry;
  	}
  
  	function testRange ( parsed, entry ) {
  
  		// Filter incorrect input.
  		if ( typeof entry !== 'object' || Array.isArray(entry) ) {
  			throw new Error("noUiSlider: 'range' is not an object.");
  		}
  
  		// Catch missing start or end.
  		if ( entry.min === undefined || entry.max === undefined ) {
  			throw new Error("noUiSlider: Missing 'min' or 'max' in 'range'.");
  		}
  
  		// Catch equal start or end.
  		if ( entry.min === entry.max ) {
  			throw new Error("noUiSlider: 'range' 'min' and 'max' cannot be equal.");
  		}
  
  		parsed.spectrum = new Spectrum(entry, parsed.snap, parsed.dir, parsed.singleStep);
  	}
  
  	function testStart ( parsed, entry ) {
  
  		entry = asArray(entry);
  
  		// Validate input. Values aren't tested, as the public .val method
  		// will always provide a valid location.
  		if ( !Array.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 testAnimate ( parsed, entry ) {
  
  		// Enforce 100% stepping within subranges.
  		parsed.animate = entry;
  
  		if ( typeof entry !== 'boolean' ){
  			throw new Error("noUiSlider: 'animate' 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 ( !isNumeric(entry) ){
  			throw new Error("noUiSlider: 'margin' option must be numeric.");
  		}
  
  		// Issue #582
  		if ( entry === 0 ) {
  			return;
  		}
  
  		parsed.margin = parsed.spectrum.getMargin(entry);
  
  		if ( !parsed.margin ) {
  			throw new Error("noUiSlider: 'margin' option is only supported on linear sliders.");
  		}
  	}
  
  	function testLimit ( parsed, entry ) {
  
  		if ( !isNumeric(entry) ){
  			throw new Error("noUiSlider: 'limit' option must be numeric.");
  		}
  
  		parsed.limit = parsed.spectrum.getMargin(entry);
  
  		if ( !parsed.limit ) {
  			throw new Error("noUiSlider: 'limit' option is only supported on linear sliders.");
  		}
  	}
  
  	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,
  			drag = entry.indexOf('drag') >= 0,
  			fixed = entry.indexOf('fixed') >= 0,
  			snap = entry.indexOf('snap') >= 0,
  			hover = entry.indexOf('hover') >= 0;
  
  		// Fix #472
  		if ( drag && !parsed.connect ) {
  			throw new Error("noUiSlider: 'drag' behaviour must be used with 'connect': true.");
  		}
  
  		parsed.events = {
  			tap: tap || snap,
  			drag: drag,
  			fixed: fixed,
  			snap: snap,
  			hover: hover
  		};
  	}
  
  	function testTooltips ( parsed, entry ) {
  
  		var i;
  
  		if ( entry === false ) {
  			return;
  		} else if ( entry === true ) {
  
  			parsed.tooltips = [];
  
  			for ( i = 0; i < parsed.handles; i++ ) {
  				parsed.tooltips.push(true);
  			}
  
  		} else {
  
  			parsed.tooltips = asArray(entry);
  
  			if ( parsed.tooltips.length !== parsed.handles ) {
  				throw new Error("noUiSlider: must pass a formatter for all handles.");
  			}
  
  			parsed.tooltips.forEach(function(formatter){
  				if ( typeof formatter !== 'boolean' && (typeof formatter !== 'object' || typeof formatter.to !== 'function') ) {
  					throw new Error("noUiSlider: 'tooltips' must be passed a formatter or 'false'.");
  				}
  			});
  		}
  	}
  
  	function testFormat ( parsed, entry ) {
  
  		parsed.format = entry;
  
  		// Any object with a to and from method is supported.
  		if ( typeof entry.to === 'function' && typeof entry.from === 'function' ) {
  			return true;
  		}
  
  		throw new Error( "noUiSlider: 'format' requires 'to' and 'from' methods.");
  	}
  
  	function testCssPrefix ( parsed, entry ) {
  
  		if ( entry !== undefined && typeof entry !== 'string' ) {
  			throw new Error( "noUiSlider: 'cssPrefix' must be a string.");
  		}
  
  		parsed.cssPrefix = entry;
  	}
  
  	// Test all developer settings and parse to assumption-safe values.
  	function testOptions ( options ) {
  
  		// To prove a fix for #537, freeze options here.
  		// If the object is modified, an error will be thrown.
  		// Object.freeze(options);
  
  		var parsed = {
  			margin: 0,
  			limit: 0,
  			animate: true,
  			format: defaultFormatter
  		}, tests;
  
  		// Tests are executed in the order they are presented here.
  		tests = {
  			'step': { r: false, t: testStep },
  			'start': { r: true, t: testStart },
  			'connect': { r: true, t: testConnect },
  			'direction': { r: true, t: testDirection },
  			'snap': { r: false, t: testSnap },
  			'animate': { r: false, t: testAnimate },
  			'range': { r: true, t: testRange },
  			'orientation': { r: false, t: testOrientation },
  			'margin': { r: false, t: testMargin },
  			'limit': { r: false, t: testLimit },
  			'behaviour': { r: true, t: testBehaviour },
  			'format': { r: false, t: testFormat },
  			'tooltips': { r: false, t: testTooltips },
  			'cssPrefix': { r: false, t: testCssPrefix }
  		};
  
  		var defaults = {
  			'connect': false,
  			'direction': 'ltr',
  			'behaviour': 'tap',
  			'orientation': 'horizontal'
  		};
  
  		// 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.
  		Object.keys(tests).forEach(function( name ){
  
  			// If the option isn't set, but it is required, throw an error.
  			if ( options[name] === undefined && defaults[name] === undefined ) {
  
  				if ( tests[name].r ) {
  					throw new Error("noUiSlider: '" + name + "' is required.");
  				}
  
  				return true;
  			}
  
  			tests[name].t( parsed, options[name] === undefined ? defaults[name] : options[name] );
  		});
  
  		// Forward pips options
  		parsed.pips = options.pips;
  
  		// Pre-define the styles.
  		parsed.style = parsed.ort ? 'top' : 'left';
  
  		return parsed;
  	}
  