selectize-rails 0.1.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f5f5589d1ad2624b7e8dd134e6da8febf3d5e34
-  data.tar.gz: 59832eaa0ba270ff1df87a7e4d46ac97c9943d93
+  metadata.gz: 593dca340fc41a504f86cf87414f89fd259c9e53
+  data.tar.gz: 191e50886524103975c3ed0b41d15d3ef02660b6
 SHA512:
-  metadata.gz: 193daee9a81ac47beb089eb6bfa3a314505c0113f5bd92c14495c80b5c038fcc3a4654c40546e1c504e12686e9f0751f2d3158fa50c39be100031edd06cd0650
-  data.tar.gz: 3979aa2049b5d43e9569a142db01c2c453df4fef9544598b857dc286e1a1396a14bd989458e048af25647f39a38030591baf6e3c90b457291792bb692de94673
+  metadata.gz: 72c76cb2a46c77530aad637ab86ed92ed72d3519afa0db9130d2283ce4acabc85872d8cbe7be31fb0f3edef23dcd36dd418e69b0f5cc67c11c415d748e90b212
+  data.tar.gz: 07f2912e36d5cc23cd8f5f00a8525f63bd7ecd631cda7d57ac9131fc000bd1f006598ed303d96f27be8cca6cdc3f38dc42c377101c969e2234d2339c422accbd

data/README.md

@@ -35,6 +35,7 @@ See the [demo page of Brian Reavis](http://brianreavis.github.io/selectize.js/)
 
     | Version | Notes                                                                     |
     |---------+---------------------------------------------------------------------------|
+    |   0.6.1 | update and set gem version equal to selectize.js version                  |
     |   0.1.0 | Initial release with plugin version 0.1.5                                 |
 
 ## License

data/lib/selectize-rails/version.rb

@@ -1,5 +1,5 @@
 module Selectize
   module Rails
-    VERSION = "0.1.0"
+    VERSION = "0.6.1"
   end
 end

data/vendor/assets/javascripts/selectize.js

@@ -1,6 +1,6 @@
-/*! selectize.js | https://github.com/brianreavis/selectize.js | Apache License (v2) */
+/*! selectize.js - v0.6.1 | https://github.com/brianreavis/selectize.js | Apache License (v2) */
 
-(function (factory) {
+(function(factory) {
 	if (typeof exports === 'object') {
 		factory(require('jquery'));
 	} else if (typeof define === 'function' && define.amd) {
@@ -9,10 +9,10 @@
 		factory(jQuery);
 	}
 }(function ($) {
-	"use strict";	
-	
-	// --- src/contrib/highlight.js ---
-	
+	"use strict";
+
+	/* --- file: "src/contrib/highlight.js" --- */
+
 	/**
 	* highlight v3 | MIT license | Johann Burkard <jb@eaio.com>
 	* Highlights arbitrary terms in a node.
@@ -20,11 +20,11 @@
 	* - Modified by Marshal <beatgates@gmail.com> 2011-6-24 (added regex)
 	* - Modified by Brian Reavis <brian@thirdroute.com> 2012-8-27 (cleanup)
 	*/
-	
+
 	var highlight = function($element, pattern) {
 		if (typeof pattern === 'string' && !pattern.length) return;
 		var regex = (typeof pattern === 'string') ? new RegExp(pattern, 'i') : pattern;
-	
+
 		var highlight = function(node) {
 			var skip = 0;
 			if (node.nodeType === 3) {
@@ -47,12 +47,12 @@
 			}
 			return skip;
 		};
-	
+
 		return $element.each(function() {
 			highlight(this);
 		});
 	};
-	
+
 	var unhighlight = function($element) {
 		return $element.find('span.highlight').each(function() {
 			var parent = this.parentNode;
@@ -60,9 +60,56 @@
 			parent.normalize();
 		}).end();
 	};
-	
-	// --- src/constants.js ---
-	
+
+	/* --- file: "src/contrib/microevent.js" --- */
+
+	/**
+	* MicroEvent - to make any js object an event emitter
+	*
+	* - pure javascript - server compatible, browser compatible
+	* - dont rely on the browser doms
+	* - super simple - you get it immediatly, no mistery, no magic involved
+	*
+	* @author Jerome Etienne (https://github.com/jeromeetienne)
+	*/
+
+	var MicroEvent = function() {};
+	MicroEvent.prototype = {
+		on: function(event, fct){
+			this._events = this._events || {};
+			this._events[event] = this._events[event] || [];
+			this._events[event].push(fct);
+		},
+		off: function(event, fct){
+			this._events = this._events || {};
+			if (event in this._events === false) return;
+			this._events[event].splice(this._events[event].indexOf(fct), 1);
+		},
+		trigger: function(event /* , args... */){
+			this._events = this._events || {};
+			if (event in this._events === false) return;
+			for (var i = 0; i < this._events[event].length; i++){
+				this._events[event][i].apply(this, Array.prototype.slice.call(arguments, 1));
+			}
+		}
+	};
+
+	/**
+	* Mixin will delegate all MicroEvent.js function in the destination object.
+	*
+	* - MicroEvent.mixin(Foobar) will make Foobar able to use MicroEvent
+	*
+	* @param {object} the object which will support MicroEvent
+	*/
+	MicroEvent.mixin = function(destObject){
+		var props = ['on', 'off', 'trigger'];
+		for (var i = 0; i < props.length; i++){
+			destObject.prototype[props[i]] = MicroEvent.prototype[props[i]];
+		}
+	};
+
+	/* --- file: "src/constants.js" --- */
+
 	/**
 	* selectize - A highly customizable select control with autocomplete.
 	* Copyright (c) 2013 Brian Reavis & contributors
@@ -78,9 +125,10 @@
 	*
 	* @author Brian Reavis <brian@thirdroute.com>
 	*/
-	
+
 	var IS_MAC        = /Mac/.test(navigator.userAgent);
-	
+
+	var KEY_A         = 65;
 	var KEY_COMMA     = 188;
 	var KEY_RETURN    = 13;
 	var KEY_ESC       = 27;
@@ -91,12 +139,13 @@
 	var KEY_BACKSPACE = 8;
 	var KEY_DELETE    = 46;
 	var KEY_SHIFT     = 16;
+	var KEY_CMD       = IS_MAC ? 91 : 17;
 	var KEY_CTRL      = IS_MAC ? 18 : 17;
 	var KEY_TAB       = 9;
-	
+
 	var TAG_SELECT    = 1;
 	var TAG_INPUT     = 2;
-	
+
 	var DIACRITICS = {
 		'a': '[aÀÁÂÃÄÅàáâãäå]',
 		'c': '[cÇç]',
@@ -109,130 +158,134 @@
 		'y': '[yŸÿý]',
 		'z': '[zŽž]'
 	};
-	
-	// --- src/selectize.jquery.js ---
-	
-	var defaults = {
-		delimiter: ',',
-		persist: true,
-		diacritics: true,
-		create: false,
-		highlight: true,
-		openOnFocus: true,
-		maxOptions: 1000,
-		maxItems: null,
-		hideSelected: null,
-	
-		scrollDuration: 60,
-		loadThrottle: 300,
-	
-		dataAttr: 'data-data',
-		sortField: null,
-		sortDirection: 'asc',
-		valueField: 'value',
-		labelField: 'text',
-		searchField: ['text'],
-	
-		mode: null,
-		theme: 'default',
-		wrapperClass: 'selectize-control',
-		inputClass: 'selectize-input',
-		dropdownClass: 'selectize-dropdown',
-	
-		load            : null, // function(query, callback)
-		score           : null, // function(search)
-		onChange        : null, // function(value)
-		onItemAdd       : null, // function(value, $item) { ... }
-		onItemRemove    : null, // function(value) { ... }
-		onClear         : null, // function() { ... }
-		onOptionAdd     : null, // function(value, data) { ... }
-		onOptionRemove  : null, // function(value) { ... }
-		onDropdownOpen  : null, // function($dropdown) { ... }
-		onDropdownClose : null, // function($dropdown) { ... }
-		onType          : null, // function(str) { ... }
-	
-		render: {
-			item: null,
-			option: null,
-			option_create: null
-		}
-	};
-	
-	$.fn.selectize = function (settings) {
-		var defaults = $.fn.selectize.defaults;
-		settings = settings || {};
-	
-		return this.each(function() {
-			var instance, value, values, i, n, data, dataAttr, settings_element, tagName;
-			var $options, $option, $input = $(this);
-	
-			tagName = $input[0].tagName.toLowerCase();
-	
-			if (typeof settings === 'string') {
-				instance = $input.data('selectize');
-				instance[settings].apply(instance, Array.prototype.splice.apply(arguments, 1));
-			} else {
-				dataAttr = settings.dataAttr || defaults.dataAttr;
-				settings_element = {};
-				settings_element.placeholder = $input.attr('placeholder');
-				settings_element.options = {};
-				settings_element.items = [];
-	
-				if (tagName === 'select') {
-					settings_element.maxItems = !!$input.attr('multiple') ? null : 1;
-					$options = $input.children();
-					for (i = 0, n = $options.length; i < n; i++) {
-						$option = $($options[i]);
-						value = $option.attr('value') || '';
-						if (!value.length) continue;
-						data = (dataAttr && $option.attr(dataAttr)) || {
-							'text'  : $option.html(),
-							'value' : value
-						};
-	
-						if (typeof data === 'string') data = JSON.parse(data);
-						settings_element.options[value] = data;
-						if ($option.is(':selected')) {
-							settings_element.items.push(value);
-						}
-					}
-				} else {
-					value = $.trim($input.val() || '');
-					if (value.length) {
-						values = value.split(settings.delimiter || defaults.delimiter);
-						for (i = 0, n = values.length; i < n; i++) {
-							settings_element.options[values[i]] = {
-								'text'  : values[i],
-								'value' : values[i]
-							};
-						}
-						settings_element.items = values;
+
+	/* --- file: "src/plugins.js" --- */
+
+	var Plugins = {};
+
+	Plugins.mixin = function(Interface, interfaceName) {
+		Interface.plugins = {};
+
+		/**
+		 * Initializes the provided functions.
+		 * Acceptable formats:
+		 *
+		 * List (without options):
+		 *   ['a', 'b', 'c']
+		 *
+		 * List (with options)
+		 *   {'a': { ... }, 'b': { ... }, 'c': { ... }}
+		 *
+		 * @param {mixed} plugins
+		 */
+		Interface.prototype.loadPlugins = function(plugins) {
+			var i, n, key;
+			this.plugins = [];
+			this.pluginSettings = {};
+
+			if ($.isArray(plugins)) {
+				for (i = 0, n = plugins.length; i < n; i++) {
+					this.loadPlugin(plugins[i]);
+				}
+			} else if (plugins) {
+				this.pluginSettings = $.extend({}, plugins);
+				for (key in plugins) {
+					if (plugins.hasOwnProperty(key)) {
+						this.loadPlugin(key);
 					}
 				}
-	
-				instance = new Selectize($input, $.extend(true, {}, defaults, settings_element, settings));
-				$input.data('selectize', instance);
-				$input.addClass('selectized');
 			}
-		});
+		};
+
+		/**
+		 * Initializes a plugin.
+		 *
+		 * @param {string} name
+		 */
+		Interface.prototype.loadPlugin = function(name) {
+			var plugin, i, n;
+
+			if (this.plugins.indexOf(name) !== -1) return;
+			if (!Interface.plugins.hasOwnProperty(name)) {
+				throw new Error(interfaceName + ' unable to find "' +  name + '" plugin');
+			}
+
+			plugin = Interface.plugins[name];
+
+			// initialize plugin and dependencies
+			this.plugins.push(name);
+			for (i = 0, n = plugin.dependencies.length; i < n; i++) {
+				this.loadPlugin(plugin.dependencies[i]);
+			}
+			plugin.fn.apply(this, [this.pluginSettings[name] || {}]);
+		};
+
+		/**
+		 * Registers a plugin.
+		 *
+		 * @param {string} name
+		 * @param {array} dependencies (optional)
+		 * @param {function} fn
+		 */
+		Interface.registerPlugin = function(name) {
+			var args = arguments;
+			Interface.plugins[name] = {
+				'name'         : name,
+				'fn'           : args[args.length - 1],
+				'dependencies' : args.length === 3 ? args[1] : []
+			};
+		};
 	};
-	
-	$.fn.selectize.defaults = defaults;
-	
-	// --- src/utils.js ---
-	
+
+	/* --- file: "src/utils.js" --- */
+
 	var isset = function(object) {
 		return typeof object !== 'undefined';
 	};
-	
+
 	var htmlEntities = function(str) {
 		return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 	};
-	
+
 	var quoteRegExp = function(str) {
 		return (str + '').replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
 	};
-	
+
+	var hook = {};
+
+	/**
+	* Wraps `method` on `self` so that `fn`
+	* is invoked before the original method.
+	*
+	* @param {object} self
+	* @param {string} method
+	* @param {function} fn
+	*/
+	hook.before = function(self, method, fn) {
+		var original = self[method];
+		self[method] = function() {
+			fn.apply(self, arguments);
+			return original.apply(self, arguments);
+		};
+	};
+
+	/**
+	* Wraps `method` on `self` so that `fn`
+	* is invoked after the original method.
+	*
+	* @param {object} self
+	* @param {string} method
+	* @param {function} fn
+	*/
+	hook.after = function(self, method, fn) {
+		var original = self[method];
+		self[method] = function() {
+			var result = original.apply(self, arguments);
+			fn.apply(self, arguments);
+			return result;
+		};
+	};
+
 	var once = function(fn) {
 		var called = false;
 		return function() {
@@ -241,7 +294,7 @@
 			fn.apply(this, arguments);
 		};
 	};
-	
+
 	var debounce = function(fn, delay) {
 		var timeout;
 		return function() {
@@ -253,7 +306,37 @@
 			}, delay);
 		};
 	};
-	
+
+	/**
+	* Debounce all fired events types listed in `types`
+	* while executing the provided `fn`.
+	*
+	* @param {object} self
+	* @param {array} types
+	* @param {function} fn
+	*/
+	var debounce_events = function(self, types, fn) {
+		var type;
+		var trigger = self.trigger;
+		var event_args = {};
+
+		// override trigger method
+		self.trigger = function() {
+			event_args[arguments[0]] = arguments;
+		};
+
+		// invoke provided function
+		fn.apply(self, []);
+		self.trigger = trigger;
+
+		// trigger queued events
+		for (type in event_args) {
+			if (event_args.hasOwnProperty(type)) {
+				trigger.apply(self, event_args[type]);
+			}
+		}
+	};
+
 	/**
 	* A workaround for http://bugs.jquery.com/ticket/6696
 	*
@@ -272,7 +355,7 @@
 			return fn.apply(this, [e]);
 		});
 	};
-	
+
 	var getSelection = function(input) {
 		var result = {};
 		if ('selectionStart' in input) {
@@ -288,7 +371,7 @@
 		}
 		return result;
 	};
-	
+
 	var transferStyles = function($from, $to, properties) {
 		var styles = {};
 		if (properties) {
@@ -301,7 +384,7 @@
 		$to.css(styles);
 		return $to;
 	};
-	
+
 	var measureString = function(str, $parent) {
 		var $test = $('<test>').css({
 			position: 'absolute',
@@ -311,7 +394,7 @@
 			padding: 0,
 			whiteSpace: 'nowrap'
 		}).text(str).appendTo('body');
-	
+
 		transferStyles($parent, $test, [
 			'letterSpacing',
 			'fontSize',
@@ -319,19 +402,22 @@
 			'fontWeight',
 			'textTransform'
 		]);
-	
+
 		var width = $test.width();
 		$test.remove();
-	
+
 		return width;
 	};
-	
+
 	var autoGrow = function($input) {
 		var update = function(e) {
 			var value, keyCode, printable, placeholder, width;
-			var shift, character;
-	
-			e = e || window.event;
+			var shift, character, selection;
+			e = e || window.event || {};
+
+			if (e.metaKey || e.altKey) return;
+			if ($input.data('grow') === false) return;
+
 			value = $input.val();
 			if (e.type && e.type.toLowerCase() === 'keydown') {
 				keyCode = e.keyCode;
@@ -341,8 +427,17 @@
 					(keyCode >= 48 && keyCode <= 57)  || // 0-9
 					keyCode == 32 // space
 				);
-	
-				if (printable) {
+
+				if (keyCode === KEY_DELETE || keyCode === KEY_BACKSPACE) {
+					selection = getSelection($input[0]);
+					if (selection.length) {
+						value = value.substring(0, selection.start) + value.substring(selection.start + selection.length);
+					} else if (keyCode === KEY_BACKSPACE && selection.start) {
+						value = value.substring(0, selection.start - 1) + value.substring(selection.start + 1);
+					} else if (keyCode === KEY_DELETE && typeof selection.start !== 'undefined') {
+						value = value.substring(0, selection.start) + value.substring(selection.start + 1);
+					}
+				} else if (printable) {
 					shift = e.shiftKey;
 					character = String.fromCharCode(e.keyCode);
 					if (shift) character = character.toUpperCase();
@@ -350,24 +445,25 @@
 					value += character;
 				}
 			}
-	
+
 			placeholder = $input.attr('placeholder') || '';
 			if (!value.length && placeholder.length) {
 				value = placeholder;
 			}
-	
+
 			width = measureString(value, $input) + 4;
 			if (width !== $input.width()) {
 				$input.width(width);
 				$input.triggerHandler('resize');
 			}
 		};
+
 		$input.on('keydown keyup update blur', update);
-		update({});
+		update();
 	};
-	
-	// --- src/selectize.js ---
-	
+
+	/* --- file: "src/selectize.js" --- */
+
 	/**
 	* selectize.js
 	* Copyright (c) 2013 Brian Reavis & contributors
@@ -383,42 +479,48 @@
 	*
 	* @author Brian Reavis <brian@thirdroute.com>
 	*/
-	
+
 	var Selectize = function($input, settings) {
+		var key, i, n;
 		$input[0].selectize   = this;
-	
+
 		this.$input           = $input;
 		this.tagType          = $input[0].tagName.toLowerCase() === 'select' ? TAG_SELECT : TAG_INPUT;
 		this.settings         = settings;
-	
+
 		this.highlightedValue = null;
 		this.isOpen           = false;
+		this.isDisabled       = false;
 		this.isLocked         = false;
 		this.isFocused        = false;
 		this.isInputFocused   = false;
+		this.isInputHidden    = false;
 		this.isSetup          = false;
 		this.isShiftDown      = false;
+		this.isCmdDown        = false;
 		this.isCtrlDown       = false;
 		this.ignoreFocus      = false;
+		this.ignoreHover      = false;
 		this.hasOptions       = false;
 		this.currentResults   = null;
 		this.lastValue        = '';
 		this.caretPos         = 0;
 		this.loading          = 0;
 		this.loadedSearches   = {};
-	
+
 		this.$activeOption    = null;
 		this.$activeItems     = [];
-	
+
+		this.optgroups        = {};
 		this.options          = {};
 		this.userOptions      = {};
 		this.items            = [];
 		this.renderCache      = {};
 		this.onSearchChange   = debounce(this.onSearchChange, this.settings.loadThrottle);
-	
+
 		if ($.isArray(settings.options)) {
-			var key = settings.valueField;
-			for (var i = 0; i < settings.options.length; i++) {
+			key = settings.valueField;
+			for (i = 0, n = settings.options.length; i < n; i++) {
 				if (settings.options[i].hasOwnProperty(key)) {
 					this.options[settings.options[i][key]] = settings.options[i];
 				}
@@ -427,16 +529,39 @@
 			$.extend(this.options, settings.options);
 			delete this.settings.options;
 		}
-	
+
+		if ($.isArray(settings.optgroups)) {
+			key = settings.optgroupValueField;
+			for (i = 0, n = settings.optgroups.length; i < n; i++) {
+				if (settings.optgroups[i].hasOwnProperty(key)) {
+					this.optgroups[settings.optgroups[i][key]] = settings.optgroups[i];
+				}
+			}
+		} else if (typeof settings.optgroups === 'object') {
+			$.extend(this.optgroups, settings.optgroups);
+			delete this.settings.optgroups;
+		}
+
 		// option-dependent defaults
 		this.settings.mode = this.settings.mode || (this.settings.maxItems === 1 ? 'single' : 'multi');
 		if (typeof this.settings.hideSelected !== 'boolean') {
 			this.settings.hideSelected = this.settings.mode === 'multi';
 		}
-	
+
+		this.loadPlugins(this.settings.plugins);
+		this.setupCallbacks();
 		this.setup();
 	};
-	
+
+	// mixins
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	MicroEvent.mixin(Selectize);
+	Plugins.mixin(Selectize, 'Selectize');
+
+	// methods
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
 	/**
 	* Creates all elements and sets up event bindings.
 	*/
@@ -446,54 +571,61 @@
 		var $control;
 		var $control_input;
 		var $dropdown;
+		var $dropdown_content;
 		var inputMode;
-		var displayMode;
 		var timeout_blur;
 		var timeout_focus;
-	
-		$wrapper       = $('<div>').addClass(this.settings.theme).addClass(this.settings.wrapperClass);
-		$control       = $('<div>').addClass(this.settings.inputClass).addClass('items').toggleClass('has-options', !$.isEmptyObject(this.options)).appendTo($wrapper);
-		$control_input = $('<input type="text">').appendTo($control);
-		$dropdown      = $('<div>').addClass(this.settings.dropdownClass).hide().appendTo($wrapper);
-	
-		displayMode = this.$input.css('display');
+		var tab_index;
+		var classes;
+
+		tab_index         = this.$input.attr('tabindex') || '';
+		classes           = this.$input.attr('class') || '';
+		$wrapper          = $('<div>').addClass(this.settings.theme).addClass(this.settings.wrapperClass).addClass(classes);
+		$control          = $('<div>').addClass(this.settings.inputClass).addClass('items').toggleClass('has-options', !$.isEmptyObject(this.options)).appendTo($wrapper);
+		$control_input    = $('<input type="text">').appendTo($control).attr('tabindex',tab_index);
+		$dropdown         = $('<div>').addClass(this.settings.dropdownClass).hide().appendTo($wrapper);
+		$dropdown_content = $('<div>').addClass(this.settings.dropdownContentClass).appendTo($dropdown);
+
 		$wrapper.css({
 			width: this.$input[0].style.width,
-			display: displayMode
+			display: this.$input.css('display')
 		});
-	
+
+		if (this.plugins.length) {
+			$wrapper.addClass('plugin-' + this.plugins.join(' plugin-'));
+		}
+
 		inputMode = this.settings.mode;
 		$wrapper.toggleClass('single', inputMode === 'single');
 		$wrapper.toggleClass('multi', inputMode === 'multi');
-	
+
 		if ((this.settings.maxItems === null || this.settings.maxItems > 1) && this.tagType === TAG_SELECT) {
 			this.$input.attr('multiple', 'multiple');
 		}
-	
+
 		if (this.settings.placeholder) {
 			$control_input.attr('placeholder', this.settings.placeholder);
 		}
-	
-		this.$wrapper       = $wrapper;
-		this.$control       = $control;
-		this.$control_input = $control_input;
-		this.$dropdown      = $dropdown;
-	
+
+		this.$wrapper          = $wrapper;
+		this.$control          = $control;
+		this.$control_input    = $control_input;
+		this.$dropdown         = $dropdown;
+		this.$dropdown_content = $dropdown_content;
+
 		$control.on('mousedown', function(e) {
-			if (e.currentTarget === self.$control[0]) {
-				$control_input.trigger('focus');
-			} else {
-				self.focus(true);
+			if (!e.isDefaultPrevented()) {
+				window.setTimeout(function() {
+					self.focus(true);
+				}, 0);
 			}
-			e.preventDefault();
 		});
-	
-		watchChildEvent($dropdown, 'mouseenter', '*', function() { return self.onOptionHover.apply(self, arguments); });
-		watchChildEvent($dropdown, 'mousedown', '*', function() { return self.onOptionSelect.apply(self, arguments); });
+
+		$dropdown.on('mouseenter', '[data-selectable]', function() { return self.onOptionHover.apply(self, arguments); });
+		$dropdown.on('mousedown', '[data-selectable]', function() { return self.onOptionSelect.apply(self, arguments); });
 		watchChildEvent($control, 'mousedown', '*:not(input)', function() { return self.onItemSelect.apply(self, arguments); });
-	
 		autoGrow($control_input);
-	
+
 		$control_input.on({
 			mousedown : function(e) { e.stopPropagation(); },
 			keydown   : function() { return self.onKeyDown.apply(self, arguments); },
@@ -503,25 +635,20 @@
 			blur      : function() { return self.onBlur.apply(self, arguments); },
 			focus     : function() { return self.onFocus.apply(self, arguments); }
 		});
-	
+
 		$(document).on({
 			keydown: function(e) {
+				self.isCmdDown = e[IS_MAC ? 'metaKey' : 'ctrlKey'];
 				self.isCtrlDown = e[IS_MAC ? 'altKey' : 'ctrlKey'];
 				self.isShiftDown = e.shiftKey;
-				if (self.isFocused && !self.isLocked) {
-					var tagName = (e.target.tagName || '').toLowerCase();
-					if (tagName === 'input' || tagName === 'textarea') return;
-					if ([KEY_SHIFT, KEY_BACKSPACE, KEY_DELETE, KEY_ESC, KEY_LEFT, KEY_RIGHT, KEY_TAB].indexOf(e.keyCode) !== -1) {
-						return self.onKeyDown.apply(self, arguments);
-					}
-				}
 			},
 			keyup: function(e) {
 				if (e.keyCode === KEY_CTRL) self.isCtrlDown = false;
-				else if (e.keyCode === KEY_SHIFT) self.isShiftDown = false;
+				if (e.keyCode === KEY_SHIFT) self.isShiftDown = false;
+				if (e.keyCode === KEY_CMD) self.isCmdDown = false;
 			},
 			mousedown: function(e) {
-				if (self.isFocused && !self.isLocked) {
+				if (self.isFocused) {
 					// prevent events on the dropdown scrollbar from causing the control to blur
 					if (e.target === self.$dropdown[0]) {
 						var ignoreFocus = self.ignoreFocus;
@@ -539,42 +666,80 @@
 				}
 			}
 		});
-	
+
 		$(window).on({
 			resize: function() {
 				if (self.isOpen) {
 					self.positionDropdown.apply(self, arguments);
 				}
+			},
+			mousemove: function() {
+				self.ignoreHover = false;
 			}
 		});
-	
-		this.$input.hide().after(this.$wrapper);
-	
+
+		this.$input.attr('tabindex',-1).hide().after(this.$wrapper);
+
 		if ($.isArray(this.settings.items)) {
 			this.setValue(this.settings.items);
 			delete this.settings.items;
 		}
-	
+
 		this.updateOriginalInput();
 		this.refreshItems();
 		this.updatePlaceholder();
 		this.isSetup = true;
+
+		if (this.$input.is(':disabled')) {
+			this.disable();
+		}
+
+		// preload options
+		if (this.settings.preload) {
+			this.onSearchChange('');
+		}
+	};
+
+	/**
+	* Maps fired events to callbacks provided
+	* in the settings used when creating the control.
+	*/
+	Selectize.prototype.setupCallbacks = function() {
+		var key, fn, callbacks = {
+			'change'         : 'onChange',
+			'item_add'       : 'onItemAdd',
+			'item_remove'    : 'onItemRemove',
+			'clear'          : 'onClear',
+			'option_add'     : 'onOptionAdd',
+			'option_remove'  : 'onOptionRemove',
+			'option_clear'   : 'onOptionClear',
+			'dropdown_open'  : 'onDropdownOpen',
+			'dropdown_close' : 'onDropdownClose',
+			'type'           : 'onType'
+		};
+
+		for (key in callbacks) {
+			if (callbacks.hasOwnProperty(key)) {
+				fn = this.settings[callbacks[key]];
+				if (fn) this.on(key, fn);
+			}
+		}
 	};
-	
+
 	/**
 	* Triggers a callback defined in the user-provided settings.
 	* Events: onItemAdd, onOptionAdd, etc
 	*
 	* @param {string} event
 	*/
-	Selectize.prototype.trigger = function(event) {
+	Selectize.prototype.triggerCallback = function(event) {
 		var args;
 		if (typeof this.settings[event] === 'function') {
 			args = Array.prototype.slice.apply(arguments, [1]);
-			this.settings.event.apply(this, args);
+			this.settings[event].apply(this, args);
 		}
 	};
-	
+
 	/**
 	* Triggered on <input> keypress.
 	*
@@ -582,7 +747,7 @@
 	* @returns {boolean}
 	*/
 	Selectize.prototype.onKeyPress = function(e) {
-		if (this.isLocked) return;
+		if (this.isLocked) return e && e.preventDefault();
 		var character = String.fromCharCode(e.keyCode || e.which);
 		if (this.settings.create && character === this.settings.delimiter) {
 			this.createItem();
@@ -590,7 +755,7 @@
 			return false;
 		}
 	};
-	
+
 	/**
 	* Triggered on <input> keydown.
 	*
@@ -598,62 +763,73 @@
 	* @returns {boolean}
 	*/
 	Selectize.prototype.onKeyDown = function(e) {
-		if (this.isLocked) return;
 		var isInput = e.target === this.$control_input[0];
-	
-		switch (e.keyCode || e.which) {
+
+		if (this.isLocked) {
+			if (e.keyCode !== KEY_TAB) {
+				e.preventDefault();
+			}
+			return;
+		}
+
+		switch (e.keyCode) {
+			case KEY_A:
+				if (this.isCmdDown) {
+					this.selectAll();
+					e.preventDefault();
+					return;
+				}
+				break;
 			case KEY_ESC:
 				this.blur();
 				return;
 			case KEY_DOWN:
-				if (!this.isOpen && this.hasOptions && this.isInputFocused) {
+				if (!this.isOpen && this.hasOptions) {
 					this.open();
 				} else if (this.$activeOption) {
-					var $next = this.$activeOption.next();
+					this.ignoreHover = true;
+					var $next = this.getAdjacentOption(this.$activeOption, 1);
 					if ($next.length) this.setActiveOption($next, true, true);
 				}
 				e.preventDefault();
-				break;
+				return;
 			case KEY_UP:
 				if (this.$activeOption) {
-					var $prev = this.$activeOption.prev();
+					this.ignoreHover = true;
+					var $prev = this.getAdjacentOption(this.$activeOption, -1);
 					if ($prev.length) this.setActiveOption($prev, true, true);
 				}
 				e.preventDefault();
-				break;
+				return;
 			case KEY_RETURN:
 				if (this.$activeOption) {
 					this.onOptionSelect({currentTarget: this.$activeOption});
 				}
 				e.preventDefault();
-				break;
+				return;
 			case KEY_LEFT:
 				this.advanceSelection(-1, e);
-				break;
+				return;
 			case KEY_RIGHT:
 				this.advanceSelection(1, e);
-				break;
+				return;
 			case KEY_TAB:
 				if (this.settings.create && $.trim(this.$control_input.val()).length) {
 					this.createItem();
 					e.preventDefault();
 				}
-				break;
+				return;
 			case KEY_BACKSPACE:
 			case KEY_DELETE:
 				this.deleteSelection(e);
-				break;
-			default:
-				if (this.isFull()) {
-					e.preventDefault();
-					return;
-				}
+				return;
 		}
-		if (!this.isFull()) {
-			this.focus(true);
+		if (this.isFull() || this.isInputHidden) {
+			e.preventDefault();
+			return;
 		}
 	};
-	
+
 	/**
 	* Triggered on <input> keyup.
 	*
@@ -661,16 +837,16 @@
 	* @returns {boolean}
 	*/
 	Selectize.prototype.onKeyUp = function(e) {
-		if (this.isLocked) return;
+		if (this.isLocked) return e && e.preventDefault();
 		var value = this.$control_input.val() || '';
 		if (this.lastValue !== value) {
 			this.lastValue = value;
 			this.onSearchChange(value);
 			this.refreshOptions();
-			this.trigger('onType', value);
+			this.trigger('type', value);
 		}
 	};
-	
+
 	/**
 	* Invokes the user-provide option provider / loader.
 	*
@@ -680,43 +856,38 @@
 	* @param {string} value
 	*/
 	Selectize.prototype.onSearchChange = function(value) {
-		if (!this.settings.load) return;
-		if (this.loadedSearches.hasOwnProperty(value)) return;
 		var self = this;
-		var $wrapper = this.$wrapper.addClass('loading');
-	
-		this.loading++;
-		this.loadedSearches[value] = true;
-		this.settings.load.apply(this, [value, function(results) {
-			self.loading = Math.max(self.loading - 1, 0);
-			if (results && results.length) {
-				self.addOption(results);
-				self.refreshOptions(false);
-				if (self.isInputFocused) self.open();
-			}
-			if (!self.loading) {
-				$wrapper.removeClass('loading');
-			}
-		}]);
+		var fn = self.settings.load;
+		if (!fn) return;
+		if (self.loadedSearches.hasOwnProperty(value)) return;
+		self.loadedSearches[value] = true;
+		self.load(function(callback) {
+			fn.apply(self, [value, callback]);
+		});
 	};
-	
+
 	/**
 	* Triggered on <input> focus.
 	*
-	* @param {object} e
+	* @param {object} e (optional)
 	* @returns {boolean}
 	*/
 	Selectize.prototype.onFocus = function(e) {
-		this.showInput();
 		this.isInputFocused = true;
 		this.isFocused = true;
+		if (this.isDisabled) {
+			this.blur();
+			e.preventDefault();
+			return false;
+		}
 		if (this.ignoreFocus) return;
-	
+
+		this.showInput();
 		this.setActiveItem(null);
-		this.$control.addClass('focus');
 		this.refreshOptions(!!this.settings.openOnFocus);
+		this.refreshClasses();
 	};
-	
+
 	/**
 	* Triggered on <input> blur.
 	*
@@ -726,17 +897,16 @@
 	Selectize.prototype.onBlur = function(e) {
 		this.isInputFocused = false;
 		if (this.ignoreFocus) return;
-	
+
 		this.close();
 		this.setTextboxValue('');
+		this.setActiveItem(null);
 		this.setActiveOption(null);
-		this.setCaret(this.items.length, false);
-		if (!this.$activeItems.length) {
-			this.$control.removeClass('focus');
-			this.isFocused = false;
-		}
+		this.setCaret(this.items.length);
+		this.isFocused = false;
+		this.refreshClasses();
 	};
-	
+
 	/**
 	* Triggered when the user rolls over
 	* an option in the autocomplete dropdown menu.
@@ -745,9 +915,10 @@
 	* @returns {boolean}
 	*/
 	Selectize.prototype.onOptionHover = function(e) {
+		if (this.ignoreHover) return;
 		this.setActiveOption(e.currentTarget, false);
 	};
-	
+
 	/**
 	* Triggered when the user clicks on an option
 	* in the autocomplete dropdown menu.
@@ -756,18 +927,22 @@
 	* @returns {boolean}
 	*/
 	Selectize.prototype.onOptionSelect = function(e) {
+		e.preventDefault && e.preventDefault();
+		e.stopPropagation && e.stopPropagation();
+		this.focus(false);
+
 		var $target = $(e.currentTarget);
 		if ($target.hasClass('create')) {
 			this.createItem();
 		} else {
 			var value = $target.attr('data-value');
 			if (value) {
-				this.addItem(value);
 				this.setTextboxValue('');
+				this.addItem(value);
 			}
 		}
 	};
-	
+
 	/**
 	* Triggered when the user clicks on an item
 	* that has been selected.
@@ -777,22 +952,49 @@
 	*/
 	Selectize.prototype.onItemSelect = function(e) {
 		if (this.settings.mode === 'multi') {
-			this.$control_input.trigger('blur');
+			e.preventDefault();
 			this.setActiveItem(e.currentTarget, e);
-			e.stopPropagation();
+			this.focus(false);
+			this.hideInput();
 		}
 	};
-	
+
+	/**
+	* Invokes the provided method that provides
+	* results to a callback---which are then added
+	* as options to the control.
+	*
+	* @param {function} fn
+	*/
+	Selectize.prototype.load = function(fn) {
+		var self = this;
+		var $wrapper = self.$wrapper.addClass('loading');
+
+		self.loading++;
+		fn.apply(self, [function(results) {
+			self.loading = Math.max(self.loading - 1, 0);
+			if (results && results.length) {
+				self.addOption(results);
+				self.refreshOptions(false);
+				if (self.isInputFocused) self.open();
+			}
+			if (!self.loading) {
+				$wrapper.removeClass('loading');
+			}
+			self.trigger('load', results);
+		}]);
+	};
+
 	/**
 	* Sets the input field of the control to the specified value.
 	*
 	* @param {string} value
 	*/
 	Selectize.prototype.setTextboxValue = function(value) {
-		this.$control_input.val(value);
+		this.$control_input.val(value).triggerHandler('update');
 		this.lastValue = value;
 	};
-	
+
 	/**
 	* Returns the value of the control. If multiple items
 	* can be selected (e.g. <select multiple>), this returns
@@ -808,20 +1010,22 @@
 			return this.items.join(this.settings.delimiter);
 		}
 	};
-	
+
 	/**
 	* Resets the selected items to the given value.
 	*
 	* @param {mixed} value
 	*/
 	Selectize.prototype.setValue = function(value) {
-		this.clear();
-		var items = $.isArray(value) ? value : [value];
-		for (var i = 0, n = items.length; i < n; i++) {
-			this.addItem(items[i]);
-		}
+		debounce_events(this, ['change'], function() {
+			this.clear();
+			var items = $.isArray(value) ? value : [value];
+			for (var i = 0, n = items.length; i < n; i++) {
+				this.addItem(items[i]);
+			}
+		});
 	};
-	
+
 	/**
 	* Sets the selected item.
 	*
@@ -832,9 +1036,9 @@
 		var eventName;
 		var i, idx, begin, end, item, swap;
 		var $last;
-	
+
 		$item = $($item);
-	
+
 		// clear the active selection
 		if (!$item.length) {
 			$(this.$activeItems).removeClass('active');
@@ -842,10 +1046,10 @@
 			this.isFocused = this.isInputFocused;
 			return;
 		}
-	
+
 		// modify selection
 		eventName = e && e.type.toLowerCase();
-	
+
 		if (eventName === 'mousedown' && this.isShiftDown && this.$activeItems.length) {
 			$last = this.$control.children('.active:last');
 			begin = Array.prototype.indexOf.apply(this.$control[0].childNodes, [$last[0]]);
@@ -875,10 +1079,10 @@
 			$(this.$activeItems).removeClass('active');
 			this.$activeItems = [$item.addClass('active')[0]];
 		}
-	
+
 		this.isFocused = !!this.$activeItems.length || this.isInputFocused;
 	};
-	
+
 	/**
 	* Sets the selected item in the dropdown menu
 	* of available options.
@@ -890,49 +1094,61 @@
 	Selectize.prototype.setActiveOption = function($option, scroll, animate) {
 		var height_menu, height_item, y;
 		var scroll_top, scroll_bottom;
-	
+
 		if (this.$activeOption) this.$activeOption.removeClass('active');
 		this.$activeOption = null;
-	
+
 		$option = $($option);
 		if (!$option.length) return;
-	
+
 		this.$activeOption = $option.addClass('active');
-	
+
 		if (scroll || !isset(scroll)) {
-	
+
 			height_menu   = this.$dropdown.height();
 			height_item   = this.$activeOption.outerHeight(true);
 			scroll        = this.$dropdown.scrollTop() || 0;
 			y             = this.$activeOption.offset().top - this.$dropdown.offset().top + scroll;
 			scroll_top    = y;
 			scroll_bottom = y - height_menu + height_item;
-	
+
 			if (y + height_item > height_menu - scroll) {
 				this.$dropdown.stop().animate({scrollTop: scroll_bottom}, animate ? this.settings.scrollDuration : 0);
 			} else if (y < scroll) {
 				this.$dropdown.stop().animate({scrollTop: scroll_top}, animate ? this.settings.scrollDuration : 0);
 			}
-	
+
 		}
 	};
-	
+
+	/**
+	* Selects all items (CTRL + A).
+	*/
+	Selectize.prototype.selectAll = function() {
+		this.$activeItems = Array.prototype.slice.apply(this.$control.children(':not(input)').addClass('active'));
+		this.isFocused = true;
+		if (this.$activeItems.length) this.hideInput();
+	};
+
 	/**
 	* Hides the input element out of view, while
 	* retaining its focus.
 	*/
 	Selectize.prototype.hideInput = function() {
-		this.$control_input.css({opacity: 0});
-		this.isInputFocused = false;
+		this.close();
+		this.setTextboxValue('');
+		this.$control_input.css({opacity: 0, position: 'absolute', left: -10000});
+		this.isInputHidden = true;
 	};
-	
+
 	/**
 	* Restores input visibility.
 	*/
 	Selectize.prototype.showInput = function() {
-		this.$control_input.css({opacity: 1});
+		this.$control_input.css({opacity: 1, position: 'relative', left: 0});
+		this.isInputHidden = false;
 	};
-	
+
 	/**
 	* Gives the control focus. If "trigger" is falsy,
 	* focus handlers won't be fired--causing the focus
@@ -941,20 +1157,24 @@
 	* @param {boolean} trigger
 	*/
 	Selectize.prototype.focus = function(trigger) {
-		var ignoreFocus = this.ignoreFocus;
-		this.ignoreFocus = !trigger;
-		this.$control_input[0].focus();
-		this.ignoreFocus = ignoreFocus;
+		if (this.isDisabled) return;
+		var self = this;
+		self.ignoreFocus = true;
+		self.$control_input[0].focus();
+		self.isInputFocused = true;
+		window.setTimeout(function() {
+			self.ignoreFocus = false;
+			if (trigger) self.onFocus();
+		}, 0);
 	};
-	
+
 	/**
 	* Forces the control out of focus.
 	*/
 	Selectize.prototype.blur = function() {
 		this.$control_input.trigger('blur');
-		this.setActiveItem(null);
 	};
-	
+
 	/**
 	* Splits a search string into an array of
 	* individual regexps to be used to match results.
@@ -965,11 +1185,11 @@
 	Selectize.prototype.parseSearchTokens = function(query) {
 		query = $.trim(String(query || '').toLowerCase());
 		if (!query || !query.length) return [];
-	
+
 		var i, n, regex, letter;
 		var tokens = [];
 		var words = query.split(/ +/);
-	
+
 		for (i = 0, n = words.length; i < n; i++) {
 			regex = quoteRegExp(words[i]);
 			if (this.settings.diacritics) {
@@ -984,10 +1204,10 @@
 				regex  : new RegExp(regex, 'i')
 			});
 		}
-	
+
 		return tokens;
 	};
-	
+
 	/**
 	* Returns a function to be used to score individual results.
 	* Results will be sorted by the score (descending). Scores less
@@ -1000,14 +1220,14 @@
 	Selectize.prototype.getScoreFunction = function(search) {
 		var self = this;
 		var tokens = search.tokens;
-	
+
 		var calculateFieldScore = (function() {
 			if (!tokens.length) {
 				return function() { return 0; };
 			} else if (tokens.length === 1) {
 				return function(value) {
 					var score, pos;
-	
+
 					value = String(value || '').toLowerCase();
 					pos = value.search(tokens[0].regex);
 					if (pos === -1) return 0;
@@ -1018,7 +1238,7 @@
 			} else {
 				return function(value) {
 					var score, pos, i, j;
-	
+
 					value = String(value || '').toLowerCase();
 					score = 0;
 					for (i = 0, j = tokens.length; i < j; i++) {
@@ -1031,7 +1251,7 @@
 				};
 			}
 		})();
-	
+
 		var calculateScore = (function() {
 			var fields = self.settings.searchField;
 			if (typeof fields === 'string') {
@@ -1059,10 +1279,10 @@
 				};
 			}
 		})();
-	
+
 		return calculateScore;
 	};
-	
+
 	/**
 	* Searches through available options and returns
 	* a sorted array of matches. Includes options that
@@ -1088,20 +1308,20 @@
 	Selectize.prototype.search = function(query, settings) {
 		var self = this;
 		var value, score, search, calculateScore;
-	
+
 		settings = settings || {};
 		query = $.trim(String(query || '').toLowerCase());
-	
+
 		if (query !== this.lastQuery) {
 			this.lastQuery = query;
-	
+
 			search = {
 				query  : query,
 				tokens : this.parseSearchTokens(query),
 				total  : 0,
 				items  : []
 			};
-	
+
 			// generate result scoring function
 			if (this.settings.score) {
 				calculateScore = this.settings.score.apply(this, [search]);
@@ -1111,7 +1331,7 @@
 			} else {
 				calculateScore = this.getScoreFunction(search);
 			}
-	
+
 			// perform search and sort
 			if (query.length) {
 				for (value in this.options) {
@@ -1155,11 +1375,11 @@
 		} else {
 			search = $.extend(true, {}, this.currentResults);
 		}
-	
+
 		// apply limits and return
 		return this.prepareResults(search, settings);
 	};
-	
+
 	/**
 	* Filters out any items that have already been selected
 	* and applies search limits.
@@ -1176,15 +1396,15 @@
 				}
 			}
 		}
-	
+
 		search.total = search.items.length;
 		if (typeof settings.limit === 'number') {
 			search.items = search.items.slice(0, settings.limit);
 		}
-	
+
 		return search;
 	};
-	
+
 	/**
 	* Refreshes the list of available options shown
 	* in the autocomplete dropdown menu.
@@ -1195,80 +1415,150 @@
 		if (typeof triggerDropdown === 'undefined') {
 			triggerDropdown = true;
 		}
-	
-		var i, n;
+
+		var i, n, groups, groups_order, option, optgroup, html, html_children;
 		var hasCreateOption;
 		var query = this.$control_input.val();
 		var results = this.search(query, {});
-		var html = [];
-	
+		var $active, $create;
+		var $dropdown_content = this.$dropdown_content;
+
 		// build markup
 		n = results.items.length;
 		if (typeof this.settings.maxOptions === 'number') {
 			n = Math.min(n, this.settings.maxOptions);
 		}
+
+		// render and group available options individually
+		groups = {};
+
+		if (this.settings.optgroupOrder) {
+			groups_order = this.settings.optgroupOrder;
+			for (i = 0; i < groups_order.length; i++) {
+				groups[groups_order[i]] = [];
+			}
+		} else {
+			groups_order = [];
+		}
+
 		for (i = 0; i < n; i++) {
-			html.push(this.render('option', this.options[results.items[i].value]));
+			option = this.options[results.items[i].value];
+			optgroup = option[this.settings.optgroupField] || '';
+			if (!this.optgroups.hasOwnProperty(optgroup)) {
+				optgroup = '';
+			}
+			if (!groups.hasOwnProperty(optgroup)) {
+				groups[optgroup] = [];
+				groups_order.push(optgroup);
+			}
+			groups[optgroup].push(this.render('option', option));
 		}
-	
-		this.$dropdown.html(html.join(''));
-	
+
+		// render optgroup headers & join groups
+		html = [];
+		for (i = 0, n = groups_order.length; i < n; i++) {
+			optgroup = groups_order[i];
+			if (this.optgroups.hasOwnProperty(optgroup) && groups[optgroup].length) {
+				// render the optgroup header and options within it,
+				// then pass it to the wrapper template
+				html_children = this.render('optgroup_header', this.optgroups[optgroup]) || '';
+				html_children += groups[optgroup].join('');
+				html.push(this.render('optgroup', $.extend({}, this.optgroups[optgroup], {
+					html: html_children
+				})));
+			} else {
+				html.push(groups[optgroup].join(''));
+			}
+		}
+
+		$dropdown_content.html(html.join(''));
+
 		// highlight matching terms inline
 		if (this.settings.highlight && results.query.length && results.tokens.length) {
 			for (i = 0, n = results.tokens.length; i < n; i++) {
-				highlight(this.$dropdown, results.tokens[i].regex);
+				highlight($dropdown_content, results.tokens[i].regex);
 			}
 		}
-	
+
 		// add "selected" class to selected options
 		if (!this.settings.hideSelected) {
 			for (i = 0, n = this.items.length; i < n; i++) {
 				this.getOption(this.items[i]).addClass('selected');
 			}
 		}
-	
+
 		// add create option
 		hasCreateOption = this.settings.create && results.query.length;
 		if (hasCreateOption) {
-			this.$dropdown.prepend(this.render('option_create', {input: query}));
+			$dropdown_content.prepend(this.render('option_create', {input: query}));
+			$create = $($dropdown_content[0].childNodes[0]);
 		}
-	
+
 		// activate
 		this.hasOptions = results.items.length > 0 || hasCreateOption;
 		if (this.hasOptions) {
-			this.setActiveOption(this.$dropdown[0].childNodes[hasCreateOption && results.items.length > 0 ? 1 : 0]);
+			if (results.items.length > 0) {
+				if ($create) {
+					$active = this.getAdjacentOption($create, 1);
+				} else {
+					$active = $dropdown_content.find("[data-selectable]").first();
+				}
+			} else {
+				$active = $create;
+			}
+			this.setActiveOption($active);
 			if (triggerDropdown && !this.isOpen) { this.open(); }
 		} else {
 			this.setActiveOption(null);
 			if (triggerDropdown && this.isOpen) { this.close(); }
 		}
 	};
-	
+
 	/**
 	* Adds an available option. If it already exists,
 	* nothing will happen. Note: this does not refresh
 	* the options list dropdown (use `refreshOptions`
 	* for that).
 	*
+	* Usage:
+	*
+	*   this.addOption(value, data)
+	*   this.addOption(data)
+	*
 	* @param {string} value
 	* @param {object} data
 	*/
 	Selectize.prototype.addOption = function(value, data) {
+		var i, n, optgroup;
+
 		if ($.isArray(value)) {
-			for (var i = 0, n = value.length; i < n; i++) {
+			for (i = 0, n = value.length; i < n; i++) {
 				this.addOption(value[i][this.settings.valueField], value[i]);
 			}
 			return;
 		}
-	
+
+		value = value || '';
 		if (this.options.hasOwnProperty(value)) return;
-		value = String(value);
+
 		this.userOptions[value] = true;
 		this.options[value] = data;
 		this.lastQuery = null;
-		this.trigger('onOptionAdd', value, data);
+		this.trigger('option_add', value, data);
+	};
+
+	/**
+	* Registers a new optgroup for options
+	* to be bucketed into.
+	*
+	* @param {string} id
+	* @param {object} data
+	*/
+	Selectize.prototype.addOptionGroup = function(id, data) {
+		this.optgroups[id] = data;
+		this.trigger('optgroup_add', value, data);
 	};
-	
+
 	/**
 	* Updates an option available for selection. If
 	* it is visible in the selected items or options
@@ -1282,21 +1572,21 @@
 		this.options[value] = data;
 		if (isset(this.renderCache['item'])) delete this.renderCache['item'][value];
 		if (isset(this.renderCache['option'])) delete this.renderCache['option'][value];
-	
+
 		if (this.items.indexOf(value) !== -1) {
 			var $item = this.getItem(value);
 			var $item_new = $(this.render('item', data));
 			if ($item.hasClass('active')) $item_new.addClass('active');
 			$item.replaceWith($item_new);
 		}
-	
+
 		if (this.isOpen) {
 			this.refreshOptions(false);
 		}
 	};
-	
+
 	/**
-	* Removes an option.
+	* Removes a single option.
 	*
 	* @param {string} value
 	*/
@@ -1305,9 +1595,22 @@
 		delete this.userOptions[value];
 		delete this.options[value];
 		this.lastQuery = null;
-		this.trigger('onOptionRemove', value);
+		this.trigger('option_remove', value);
+		this.removeItem(value);
+	};
+
+	/**
+	* Clears all options.
+	*/
+	Selectize.prototype.clearOptions = function() {
+		this.loadedSearches = {};
+		this.userOptions = {};
+		this.options = {};
+		this.lastQuery = null;
+		this.trigger('option_clear');
+		this.clear();
 	};
-	
+
 	/**
 	* Returns the jQuery element of the option
 	* matching the given value.
@@ -1316,9 +1619,24 @@
 	* @returns {object}
 	*/
 	Selectize.prototype.getOption = function(value) {
-		return this.$dropdown.children('[data-value="' + value.replace(/(['"])/g, '\\$1') + '"]:first');
+		return value ? this.$dropdown_content.find('[data-selectable]').filter('[data-value="' + value.replace(/(['"])/g, '\\$1') + '"]:first') : $();
 	};
-	
+
+	/**
+	* Returns the jQuery element of the next or
+	* previous selectable option.
+	*
+	* @param {object} $option
+	* @param {int} direction  can be 1 for next or -1 for previous
+	* @return {object}
+	*/
+	Selectize.prototype.getAdjacentOption = function($option, direction) {
+		var $options = this.$dropdown.find('[data-selectable]');
+		var index    = $options.index($option) + direction;
+
+		return index >= 0 && index < $options.length ? $options.eq(index) : $();
+	};
+
 	/**
 	* Returns the jQuery element of the item
 	* matching the given value.
@@ -1337,7 +1655,7 @@
 		}
 		return $();
 	};
-	
+
 	/**
 	* "Selects" an item. Adds it to the list
 	* at the current caret position.
@@ -1345,65 +1663,60 @@
 	* @param {string} value
 	*/
 	Selectize.prototype.addItem = function(value) {
-		var $item;
-		var self = this;
-		var inputMode = this.settings.mode;
-		var isFull = this.isFull();
-		value = String(value);
-	
-		if (inputMode === 'single') this.clear();
-		if (inputMode === 'multi' && isFull) return;
-		if (this.items.indexOf(value) !== -1) return;
-		if (!this.options.hasOwnProperty(value)) return;
-	
-		$item = $(this.render('item', this.options[value]));
-		this.items.splice(this.caretPos, 0, value);
-		this.insertAtCaret($item);
-	
-		isFull = this.isFull();
-		this.$control.toggleClass('has-items', true);
-		this.$control.toggleClass('full', isFull).toggleClass('not-full', !isFull);
-	
-		if (this.isSetup) {
-			// remove the option from the menu
-			var options = this.$dropdown[0].childNodes;
-			for (var i = 0; i < options.length; i++) {
-				var $option = $(options[i]);
-				if ($option.attr('data-value') === value) {
-					$option.remove();
-					if ($option[0] === this.$activeOption[0]) {
-						this.setActiveOption(options.length ? $(options[0]).addClass('active') : null);
-					}
-					break;
+		debounce_events(this, ['change'], function() {
+			var $item, $option;
+			var self = this;
+			var inputMode = this.settings.mode;
+			var i, active, options, value_next;
+			value = String(value);
+
+			if (inputMode === 'single') this.clear();
+			if (inputMode === 'multi' && this.isFull()) return;
+			if (this.items.indexOf(value) !== -1) return;
+			if (!this.options.hasOwnProperty(value)) return;
+
+			$item = $(this.render('item', this.options[value]));
+			this.items.splice(this.caretPos, 0, value);
+			this.insertAtCaret($item);
+			this.refreshClasses();
+
+			if (this.isSetup) {
+				// remove the option from the menu
+				options = this.$dropdown_content.find('[data-selectable]');
+				$option = this.getOption(value);
+				value_next = this.getAdjacentOption($option, 1).attr('data-value');
+				this.refreshOptions(true);
+				if (value_next) {
+					this.setActiveOption(this.getOption(value_next));
 				}
+
+				// hide the menu if the maximum number of items have been selected or no options are left
+				if (!options.length || (this.settings.maxItems !== null && this.items.length >= this.settings.maxItems)) {
+					this.close();
+				} else {
+					this.positionDropdown();
+				}
+
+				// restore focus to input
+				if (this.isFocused) {
+					window.setTimeout(function() {
+						if (inputMode === 'single') {
+							self.blur();
+							self.focus(false);
+							self.hideInput();
+						} else {
+							self.focus(false);
+						}
+					}, 0);
+				}
+
+				this.updatePlaceholder();
+				this.trigger('item_add', value, $item);
+				this.updateOriginalInput();
 			}
-	
-			// hide the menu if the maximum number of items have been selected or no options are left
-			if (!options.length || (this.settings.maxItems !== null && this.items.length >= this.settings.maxItems)) {
-				this.close();
-			} else {
-				this.positionDropdown();
-			}
-	
-			// restore focus to input
-			if (this.isFocused) {
-				window.setTimeout(function() {
-					if (inputMode === 'single') {
-						self.blur();
-						self.focus(false);
-						self.hideInput();
-					} else {
-						self.focus(false);
-					}
-				}, 0);
-			}
-	
-			this.updatePlaceholder();
-			this.updateOriginalInput();
-			this.trigger('onItemAdd', value, $item);
-		}
+		});
 	};
-	
+
 	/**
 	* Removes the selected item matching
 	* the provided value.
@@ -1412,38 +1725,36 @@
 	*/
 	Selectize.prototype.removeItem = function(value) {
 		var $item, i, idx;
-	
+
 		$item = (typeof value === 'object') ? value : this.getItem(value);
 		value = String($item.attr('data-value'));
 		i = this.items.indexOf(value);
-	
+
 		if (i !== -1) {
 			$item.remove();
 			if ($item.hasClass('active')) {
 				idx = this.$activeItems.indexOf($item[0]);
 				this.$activeItems.splice(idx, 1);
 			}
-	
+
 			this.items.splice(i, 1);
-			this.$control.toggleClass('has-items', this.items.length > 0);
-			this.$control.removeClass('full').addClass('not-full');
 			this.lastQuery = null;
 			if (!this.settings.persist && this.userOptions.hasOwnProperty(value)) {
 				this.removeOption(value);
 			}
-			this.setCaret(i);
-			this.positionDropdown();
-			this.refreshOptions(false);
-	
-			if (!this.hasOptions) { this.close(); }
-			else if (this.isInputFocused) { this.open(); }
-	
+
+			if (i < this.caretPos) {
+				this.setCaret(this.caretPos - 1);
+			}
+
+			this.refreshClasses();
 			this.updatePlaceholder();
 			this.updateOriginalInput();
-			this.trigger('onItemRemove', value);
+			this.positionDropdown();
+			this.trigger('item_remove', value);
 		}
 	};
-	
+
 	/**
 	* Invokes the `create` method provided in the
 	* selectize options that should provide the data
@@ -1458,53 +1769,66 @@
 		var caret = this.caretPos;
 		if (!input.length) return;
 		this.lock();
-		this.$control_input[0].blur();
-	
+
 		var setup = (typeof this.settings.create === 'function') ? this.settings.create : function(input) {
 			var data = {};
 			data[self.settings.labelField] = input;
 			data[self.settings.valueField] = input;
 			return data;
 		};
-	
+
 		var create = once(function(data) {
 			self.unlock();
 			self.focus(false);
-	
+
 			var value = data && data[self.settings.valueField];
 			if (!value) return;
-	
+
+			self.setTextboxValue('');
 			self.addOption(value, data);
-			self.setCaret(caret, false);
+			self.setCaret(caret);
 			self.addItem(value);
-			self.refreshOptions(false);
-			self.setTextboxValue('');
+			self.refreshOptions(true);
+			self.focus(false);
 		});
-	
-		var output = setup(input, create);
-		if (typeof output === 'object') {
+
+		var output = setup.apply(this, [input, create]);
+		if (typeof output !== 'undefined') {
 			create(output);
 		}
 	};
-	
+
 	/**
 	* Re-renders the selected item lists.
 	*/
 	Selectize.prototype.refreshItems = function() {
-		var isFull = this.isFull();
 		this.lastQuery = null;
-		this.$control.toggleClass('full', isFull).toggleClass('not-full', !isFull);
-		this.$control.toggleClass('has-items', this.items.length > 0);
-	
+
 		if (this.isSetup) {
 			for (var i = 0; i < this.items.length; i++) {
 				this.addItem(this.items);
 			}
 		}
-	
+
+		this.refreshClasses();
 		this.updateOriginalInput();
 	};
-	
+
+	/**
+	* Updates all state-dependent CSS classes.
+	*/
+	Selectize.prototype.refreshClasses = function() {
+		var isFull = this.isFull();
+		var isLocked = this.isLocked;
+		this.$control
+			.toggleClass('focus', this.isFocused)
+			.toggleClass('disabled', this.isDisabled)
+			.toggleClass('locked', isLocked)
+			.toggleClass('full', isFull).toggleClass('not-full', !isFull)
+			.toggleClass('has-items', this.items.length > 0);
+		this.$control_input.data('grow', !isFull && !isLocked);
+	};
+
 	/**
 	* Determines whether or not more items can be added
 	* to the control without exceeding the user-defined maximum.
@@ -1514,14 +1838,14 @@
 	Selectize.prototype.isFull = function() {
 		return this.settings.maxItems !== null && this.items.length >= this.settings.maxItems;
 	};
-	
+
 	/**
 	* Refreshes the original <select> or <input>
 	* element to reflect the current state.
 	*/
 	Selectize.prototype.updateOriginalInput = function() {
 		var i, n, options;
-	
+
 		if (this.$input[0].tagName.toLowerCase() === 'select') {
 			options = [];
 			for (i = 0, n = this.items.length; i < n; i++) {
@@ -1534,13 +1858,13 @@
 		} else {
 			this.$input.val(this.getValue());
 		}
-	
+
 		this.$input.trigger('change');
 		if (this.isSetup) {
-			this.trigger('onChange', this.$input.val());
+			this.trigger('change', this.$input.val());
 		}
 	};
-	
+
 	/**
 	* Shows/hide the input placeholder depending
 	* on if there items in the list already.
@@ -1548,7 +1872,7 @@
 	Selectize.prototype.updatePlaceholder = function() {
 		if (!this.settings.placeholder) return;
 		var $input = this.$control_input;
-	
+
 		if (this.items.length) {
 			$input.removeAttr('placeholder');
 		} else {
@@ -1556,20 +1880,22 @@
 		}
 		$input.triggerHandler('update');
 	};
-	
+
 	/**
 	* Shows the autocomplete dropdown containing
 	* the available options.
 	*/
 	Selectize.prototype.open = function() {
-		if (this.isOpen || (this.settings.mode === 'multi' && this.isFull())) return;
+		if (this.isLocked || this.isOpen || (this.settings.mode === 'multi' && this.isFull())) return;
+		this.focus();
 		this.isOpen = true;
-		this.positionDropdown();
+		this.$dropdown.css({visibility: 'hidden', display: 'block'});
 		this.$control.addClass('dropdown-active');
-		this.$dropdown.show();
-		this.trigger('onDropdownOpen', this.$dropdown);
+		this.positionDropdown();
+		this.$dropdown.css({visibility: 'visible'});
+		this.trigger('dropdown_open', this.$dropdown);
 	};
-	
+
 	/**
 	* Closes the autocomplete dropdown menu.
 	*/
@@ -1577,10 +1903,11 @@
 		if (!this.isOpen) return;
 		this.$dropdown.hide();
 		this.$control.removeClass('dropdown-active');
+		this.setActiveOption(null);
 		this.isOpen = false;
-		this.trigger('onDropdownClose', this.$dropdown);
+		this.trigger('dropdown_close', this.$dropdown);
 	};
-	
+
 	/**
 	* Calculates and applies the appropriate
 	* position of the dropdown.
@@ -1589,29 +1916,30 @@
 		var $control = this.$control;
 		var offset = $control.position();
 		offset.top += $control.outerHeight(true);
-	
+
 		this.$dropdown.css({
 			width : $control.outerWidth(),
 			top   : offset.top,
 			left  : offset.left
 		});
 	};
-	
+
 	/**
 	* Resets / clears all selected items
 	* from the control.
 	*/
 	Selectize.prototype.clear = function() {
 		if (!this.items.length) return;
-		this.$control.removeClass('has-items');
 		this.$control.children(':not(input)').remove();
 		this.items = [];
 		this.setCaret(0);
 		this.updatePlaceholder();
 		this.updateOriginalInput();
-		this.trigger('onClear');
+		this.refreshClasses();
+		this.showInput();
+		this.trigger('clear');
 	};
-	
+
 	/**
 	* A helper method for inserting an element
 	* at the current caret position.
@@ -1627,42 +1955,60 @@
 		}
 		this.setCaret(caret + 1);
 	};
-	
+
 	/**
 	* Removes the current selected item(s).
 	*
 	* @param {object} e (optional)
+	* @returns {boolean}
 	*/
 	Selectize.prototype.deleteSelection = function(e) {
 		var i, n, direction, selection, values, caret, $tail;
-	
-		direction = (e.keyCode === KEY_BACKSPACE) ? -1 : 1;
+
+		direction = (e && e.keyCode === KEY_BACKSPACE) ? -1 : 1;
 		selection = getSelection(this.$control_input[0]);
+
+		// determine items that will be removed
+		values = [];
+
 		if (this.$activeItems.length) {
 			$tail = this.$control.children('.active:' + (direction > 0 ? 'last' : 'first'));
-			caret = Array.prototype.indexOf.apply(this.$control[0].childNodes, [$tail[0]]);
-			if (this.$activeItems.length > 1 && direction > 0) { caret--; }
-	
-			values = [];
+			caret = this.$control.children(':not(input)').index($tail);
+			if (direction > 0) { caret++; }
+
 			for (i = 0, n = this.$activeItems.length; i < n; i++) {
 				values.push($(this.$activeItems[i]).attr('data-value'));
 			}
-			while (values.length) {
-				this.removeItem(values.pop());
+			if (e) {
+				e.preventDefault();
+				e.stopPropagation();
 			}
-	
-			this.setCaret(caret);
-			e.preventDefault();
-			e.stopPropagation();
-		} else if ((this.isInputFocused || this.settings.mode === 'single') && this.items.length) {
+		} else if ((this.isFocused || this.settings.mode === 'single') && this.items.length) {
 			if (direction < 0 && selection.start === 0 && selection.length === 0) {
-				this.removeItem(this.items[this.caretPos - 1]);
+				values.push(this.items[this.caretPos - 1]);
 			} else if (direction > 0 && selection.start === this.$control_input.val().length) {
-				this.removeItem(this.items[this.caretPos]);
+				values.push(this.items[this.caretPos]);
 			}
 		}
+
+		// allow the callback to abort
+		if (!values.length || (typeof this.settings.onDelete === 'function' && this.settings.onDelete(values) === false)) {
+			return false;
+		}
+
+		// perform removal
+		if (typeof caret !== 'undefined') {
+			this.setCaret(caret);
+		}
+		while (values.length) {
+			this.removeItem(values.pop());
+		}
+
+		this.showInput();
+		this.refreshOptions(true);
+		return true;
 	};
-	
+
 	/**
 	* Selects the previous / next item (depending
 	* on the `direction` argument).
@@ -1674,28 +2020,33 @@
 	* @param {object} e (optional)
 	*/
 	Selectize.prototype.advanceSelection = function(direction, e) {
+		var tail, selection, idx, valueLength, cursorAtEdge, $tail;
+
 		if (direction === 0) return;
-		var tail = direction > 0 ? 'last' : 'first';
-		var selection = getSelection(this.$control_input[0]);
-	
-		if (this.isInputFocused) {
-			var valueLength = this.$control_input.val().length;
-			var cursorAtEdge = direction < 0
+
+		tail = direction > 0 ? 'last' : 'first';
+		selection = getSelection(this.$control_input[0]);
+
+		if (this.isInputFocused && !this.isInputHidden) {
+			valueLength = this.$control_input.val().length;
+			cursorAtEdge = direction < 0
 				? selection.start === 0 && selection.length === 0
 				: selection.start === valueLength;
-	
+
 			if (cursorAtEdge && !valueLength) {
 				this.advanceCaret(direction, e);
 			}
 		} else {
-			var $tail = this.$control.children('.active:' + tail);
+			$tail = this.$control.children('.active:' + tail);
 			if ($tail.length) {
-				var idx = Array.prototype.indexOf.apply(this.$control[0].childNodes, [$tail[0]]);
+				idx = this.$control.children(':not(input)').index($tail);
+				this.setActiveItem(null);
 				this.setCaret(direction > 0 ? idx + 1 : idx);
+				this.showInput();
 			}
 		}
 	};
-	
+
 	/**
 	* Moves the caret left / right.
 	*
@@ -1708,7 +2059,7 @@
 		if (this.isShiftDown) {
 			var $adj = this.$control_input[fn]();
 			if ($adj.length) {
-				this.blur();
+				this.hideInput();
 				this.setActiveItem($adj);
 				e && e.preventDefault();
 			}
@@ -1716,52 +2067,72 @@
 			this.setCaret(this.caretPos + direction);
 		}
 	};
-	
+
 	/**
 	* Moves the caret to the specified index.
 	*
 	* @param {int} i
-	* @param {boolean} focus
 	*/
-	Selectize.prototype.setCaret = function(i, focus) {
-		if (this.settings.mode === 'single' || this.isFull()) {
+	Selectize.prototype.setCaret = function(i) {
+		if (this.settings.mode === 'single') {
 			i = this.items.length;
 		} else {
 			i = Math.max(0, Math.min(this.items.length, i));
 		}
-	
-		this.ignoreFocus = true;
-		this.$control_input.detach();
-		if (i === this.items.length) {
-			this.$control.append(this.$control_input);
-		} else {
-			this.$control_input.insertBefore(this.$control.children(':not(input)')[i]);
-		}
-		this.ignoreFocus = false;
-		if (focus && this.isSetup) {
-			this.focus(true);
+
+		// the input must be moved by leaving it in place and moving the
+		// siblings, due to the fact that focus cannot be restored once lost
+		// on mobile webkit devices
+		var j, n, fn, $children, $child;
+		$children = this.$control.children(':not(input)');
+		for (j = 0, n = $children.length; j < n; j++) {
+			$child = $($children[j]).detach();
+			if (j <  i) {
+				this.$control_input.before($child);
+			} else {
+				this.$control.append($child);
+			}
 		}
-	
+
 		this.caretPos = i;
 	};
-	
+
 	/**
 	* Disables user input on the control. Used while
 	* items are being asynchronously created.
 	*/
 	Selectize.prototype.lock = function() {
+		this.close();
 		this.isLocked = true;
-		this.$control.addClass('locked');
+		this.refreshClasses();
 	};
-	
+
 	/**
 	* Re-enables user input on the control.
 	*/
 	Selectize.prototype.unlock = function() {
 		this.isLocked = false;
-		this.$control.removeClass('locked');
+		this.refreshClasses();
+	};
+
+	/**
+	* Disables user input on the control completely.
+	* While disabled, it cannot receive focus.
+	*/
+	Selectize.prototype.disable = function() {
+		this.isDisabled = true;
+		this.lock();
+	};
+
+	/**
+	* Enables the control so that it can respond
+	* to focus and user input.
+	*/
+	Selectize.prototype.enable = function() {
+		this.isDisabled = false;
+		this.unlock();
 	};
-	
+
 	/**
 	* A helper method for rendering "item" and
 	* "option" templates, given the data.
@@ -1771,17 +2142,17 @@
 	* @returns {string}
 	*/
 	Selectize.prototype.render = function(templateName, data) {
-		cache = isset(cache) ? cache : true;
-	
-		var value, label;
+		var value, id, label;
 		var html = '';
 		var cache = false;
-	
-		if (['option', 'item'].indexOf(templateName) !== -1) {
+		var regex_tag = /^[\	 ]*<([a-z][a-z0-9\-_]*(?:\:[a-z][a-z0-9\-_]*)?)/i;
+
+		if (templateName === 'option' || templateName === 'item') {
 			value = data[this.settings.valueField];
 			cache = isset(value);
 		}
-	
+
+		// pull markup from cache if it exists
 		if (cache) {
 			if (!isset(this.renderCache[templateName])) {
 				this.renderCache[templateName] = {};
@@ -1790,34 +2161,466 @@
 				return this.renderCache[templateName][value];
 			}
 		}
-	
+
+		// render markup
 		if (this.settings.render && typeof this.settings.render[templateName] === 'function') {
-			html = this.settings.render[templateName].apply(this, [data]);
+			html = this.settings.render[templateName].apply(this, [data, htmlEntities]);
 		} else {
 			label = data[this.settings.labelField];
 			switch (templateName) {
+				case 'optgroup':
+					html = '<div class="optgroup">' + data.html + "</div>";
+					break;
+				case 'optgroup_header':
+					label = data[this.settings.optgroupLabelField];
+					html = '<div class="optgroup-header">' + htmlEntities(label) + '</div>';
+					break;
 				case 'option':
-					html = '<div class="option">' + label + '</div>';
+					html = '<div class="option">' + htmlEntities(label) + '</div>';
 					break;
 				case 'item':
-					html = '<div class="item">' + label + '</div>';
+					html = '<div class="item">' + htmlEntities(label) + '</div>';
 					break;
 				case 'option_create':
 					html = '<div class="create">Create <strong>' + htmlEntities(data.input) + '</strong>&hellip;</div>';
 					break;
 			}
 		}
-	
-		if (isset(value)) {
-			html = html.replace(/^[\	 ]*<([a-z][a-z0-9\-_]*(?:\:[a-z][a-z0-9\-_]*)?)/i, '<$1 data-value="' + value + '"');
+
+		// add mandatory attributes
+		if (templateName === 'option' || templateName === 'option_create') {
+			html = html.replace(regex_tag, '<$1 data-selectable');
+		}
+		if (templateName === 'optgroup') {
+			id = data[this.settings.optgroupValueField] || '';
+			html = html.replace(regex_tag, '<$1 data-group="' + htmlEntities(id) + '"');
 		}
+		if (templateName === 'option' || templateName === 'item') {
+			html = html.replace(regex_tag, '<$1 data-value="' + htmlEntities(value || '') + '"');
+		}
+
+		// update cache
 		if (cache) {
 			this.renderCache[templateName][value] = html;
 		}
-	
+
 		return html;
 	};
 
+	Selectize.defaults = {
+		plugins: [],
+		delimiter: ',',
+		persist: true,
+		diacritics: true,
+		create: false,
+		highlight: true,
+		openOnFocus: true,
+		maxOptions: 1000,
+		maxItems: null,
+		hideSelected: null,
+		preload: false,
+
+		scrollDuration: 60,
+		loadThrottle: 300,
+
+		dataAttr: 'data-data',
+		optgroupField: 'optgroup',
+		sortField: null,
+		sortDirection: 'asc',
+		valueField: 'value',
+		labelField: 'text',
+		optgroupLabelField: 'label',
+		optgroupValueField: 'value',
+		optgroupOrder: null,
+		searchField: ['text'],
+
+		mode: null,
+		theme: 'default',
+		wrapperClass: 'selectize-control',
+		inputClass: 'selectize-input',
+		dropdownClass: 'selectize-dropdown',
+		dropdownContentClass: 'selectize-dropdown-content',
+
+		load            : null, // function(query, callback)
+		score           : null, // function(search)
+		onChange        : null, // function(value)
+		onItemAdd       : null, // function(value, $item) { ... }
+		onItemRemove    : null, // function(value) { ... }
+		onClear         : null, // function() { ... }
+		onOptionAdd     : null, // function(value, data) { ... }
+		onOptionRemove  : null, // function(value) { ... }
+		onOptionClear   : null, // function() { ... }
+		onDropdownOpen  : null, // function($dropdown) { ... }
+		onDropdownClose : null, // function($dropdown) { ... }
+		onType          : null, // function(str) { ... }
+		onDelete        : null, // function(values) { ... }
+
+		render: {
+			item: null,
+			optgroup: null,
+			optgroup_header: null,
+			option: null,
+			option_create: null
+		}
+	};
+
+	/* --- file: "src/selectize.jquery.js" --- */
+
+	$.fn.selectize = function(settings) {
+		settings = settings || {};
+
+		var defaults = $.fn.selectize.defaults;
+		var dataAttr = settings.dataAttr || defaults.dataAttr;
+
+		/**
+		 * Initializes selectize from a <input type="text"> element.
+		 *
+		 * @param {object} $input
+		 * @param {object} settings
+		 */
+		var init_textbox = function($input, settings_element) {
+			var i, n, values, value = $.trim($input.val() || '');
+			if (!value.length) return;
+
+			values = value.split(settings.delimiter || defaults.delimiter);
+			for (i = 0, n = values.length; i < n; i++) {
+				settings_element.options[values[i]] = {
+					'text'  : values[i],
+					'value' : values[i]
+				};
+			}
+
+			settings_element.items = values;
+		};
+
+		/**
+		 * Initializes selectize from a <select> element.
+		 *
+		 * @param {object} $input
+		 * @param {object} settings
+		 */
+		var init_select = function($input, settings_element) {
+			var i, n, tagName;
+			var $children;
+			settings_element.maxItems = !!$input.attr('multiple') ? null : 1;
+
+			var readData = function($el) {
+				var data = dataAttr && $el.attr(dataAttr);
+				if (typeof data === 'string' && data.length) {
+					return JSON.parse(data);
+				}
+				return null;
+			};
+
+			var addOption = function($option, group) {
+				$option = $($option);
+
+				var value = $option.attr('value') || '';
+				if (!value.length) return;
+
+				settings_element.options[value] = readData($option) || {
+					'text'     : $option.html(),
+					'value'    : value,
+					'optgroup' : group
+				};
+				if ($option.is(':selected')) {
+					settings_element.items.push(value);
+				}
+			};
+
+			var addGroup = function($optgroup) {
+				var i, n, $options = $('option', $optgroup);
+				$optgroup = $($optgroup);
+
+				var id = $optgroup.attr('label');
+				if (id && id.length) {
+					settings_element.optgroups[id] = readData($optgroup) || {
+						'label': id
+					};
+				}
+
+				for (i = 0, n = $options.length; i < n; i++) {
+					addOption($options[i], id);
+				}
+			};
+
+			$children = $input.children();
+			for (i = 0, n = $children.length; i < n; i++) {
+				tagName = $children[i].tagName.toLowerCase();
+				if (tagName === 'optgroup') {
+					addGroup($children[i]);
+				} else if (tagName === 'option') {
+					addOption($children[i]);
+				}
+			}
+		};
+
+		return this.each(function() {
+			var instance;
+			var $input = $(this);
+			var tag_name = $input[0].tagName.toLowerCase();
+			var settings_element = {
+				'placeholder' : $input.attr('placeholder'),
+				'options'     : {},
+				'optgroups'   : {},
+				'items'       : []
+			};
+
+			if (tag_name === 'select') {
+				init_select($input, settings_element);
+			} else {
+				init_textbox($input, settings_element);
+			}
+
+			instance = new Selectize($input, $.extend(true, {}, defaults, settings_element, settings));
+			$input.data('selectize', instance);
+			$input.addClass('selectized');
+		});
+	};
+
+	$.fn.selectize.defaults = Selectize.defaults;
+
+	/* --- file: "src/plugins/drag_drop/plugin.js" --- */
+
+	/**
+	* Plugin: "drag_drop" (selectize.js)
+	* Copyright (c) 2013 Brian Reavis & contributors
+	*
+	* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
+	* file except in compliance with the License. You may obtain a copy of the License at:
+	* http://www.apache.org/licenses/LICENSE-2.0
+	*
+	* Unless required by applicable law or agreed to in writing, software distributed under
+	* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+	* ANY KIND, either express or implied. See the License for the specific language
+	* governing permissions and limitations under the License.
+	*
+	* @author Brian Reavis <brian@thirdroute.com>
+	*/
+
+	Selectize.registerPlugin('drag_drop', function(options) {
+		if (!$.fn.sortable) throw new Error('The "drag_drop" Selectize plugin requires jQuery UI "sortable".');
+		if (this.settings.mode !== 'multi') return;
+		var self = this;
+
+		this.setup = (function() {
+			var original = self.setup;
+			return function() {
+				original.apply(this, arguments);
+
+				var $control = this.$control.sortable({
+					items: '[data-value]',
+					forcePlaceholderSize: true,
+					start: function(e, ui) {
+						ui.placeholder.css('width', ui.helper.css('width'));
+						$control.css({overflow: 'visible'});
+					},
+					stop: function() {
+						$control.css({overflow: 'hidden'});
+						var active = this.$activeItems ? this.$activeItems.slice() : null;
+						var values = [];
+						$control.children('[data-value]').each(function() {
+							values.push($(this).attr('data-value'));
+						});
+						self.setValue(values);
+						self.setActiveItem(active);
+					}
+				});
+			};
+		})();
+
+	});
+
+	/* --- file: "src/plugins/optgroup_columns/plugin.js" --- */
+
+	/**
+	* Plugin: "optgroup_columns" (selectize.js)
+	* Copyright (c) 2013 Simon Hewitt & contributors
+	*
+	* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
+	* file except in compliance with the License. You may obtain a copy of the License at:
+	* http://www.apache.org/licenses/LICENSE-2.0
+	*
+	* Unless required by applicable law or agreed to in writing, software distributed under
+	* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+	* ANY KIND, either express or implied. See the License for the specific language
+	* governing permissions and limitations under the License.
+	*
+	* @author Simon Hewitt <si@sjhewitt.co.uk>
+	*/
+
+	Selectize.registerPlugin('optgroup_columns', function(options) {
+		var self = this;
+
+		options = $.extend({
+			equalizeWidth  : true,
+			equalizeHeight : true
+		}, options);
+
+		this.getAdjacentOption = function($option, direction) {
+			var $options = $option.closest('[data-group]').find('[data-selectable]');
+			var index    = $options.index($option) + direction;
+
+			return index >= 0 && index < $options.length ? $options.eq(index) : $();
+		};
+
+		this.onKeyDown = (function() {
+			var original = self.onKeyDown;
+			return function(e) {
+				var index, $option, $options, $optgroup;
+
+				if (this.isOpen && (e.keyCode === KEY_LEFT || e.keyCode === KEY_RIGHT)) {
+					self.ignoreHover = true;
+					$optgroup = this.$activeOption.closest('[data-group]');
+					index = $optgroup.find('[data-selectable]').index(this.$activeOption);
+
+					if(e.keyCode === KEY_LEFT) {
+						$optgroup = $optgroup.prev('[data-group]');
+					} else {
+						$optgroup = $optgroup.next('[data-group]');
+					}
+
+					$options = $optgroup.find('[data-selectable]');
+					$option  = $options.eq(Math.min($options.length - 1, index));
+					if ($option.length) {
+						this.setActiveOption($option);
+					}
+					return;
+				}
+
+				return original.apply(this, arguments);
+			};
+		})();
+
+		var equalizeSizes = function() {
+			var i, n, height_max, width, width_last, width_parent, $optgroups;
+
+			$optgroups = $('[data-group]', self.$dropdown_content);
+			n = $optgroups.length;
+			if (!n || !self.$dropdown_content.width()) return;
+
+			if (options.equalizeHeight) {
+				height_max = 0;
+				for (i = 0; i < n; i++) {
+					height_max = Math.max(height_max, $optgroups.eq(i).height());
+				}
+				$optgroups.css({height: height_max});
+			}
+
+			if (options.equalizeWidth) {
+				width_parent = self.$dropdown_content.innerWidth();
+				width = Math.round(width_parent / n);
+				$optgroups.css({width: width});
+				if (n > 1) {
+					width_last = width_parent - width * (n - 1);
+					$optgroups.eq(n - 1).css({width: width_last});
+				}
+			}
+		};
+
+		if (options.equalizeHeight || options.equalizeWidth) {
+			hook.after(this, 'positionDropdown', equalizeSizes);
+			hook.after(this, 'refreshOptions', equalizeSizes);
+		}
+
+
+	});
+
+	/* --- file: "src/plugins/remove_button/plugin.js" --- */
+
+	/**
+	* Plugin: "remove_button" (selectize.js)
+	* Copyright (c) 2013 Brian Reavis & contributors
+	*
+	* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
+	* file except in compliance with the License. You may obtain a copy of the License at:
+	* http://www.apache.org/licenses/LICENSE-2.0
+	*
+	* Unless required by applicable law or agreed to in writing, software distributed under
+	* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+	* ANY KIND, either express or implied. See the License for the specific language
+	* governing permissions and limitations under the License.
+	*
+	* @author Brian Reavis <brian@thirdroute.com>
+	*/
+
+	Selectize.registerPlugin('remove_button', function(options) {
+		var self = this;
+
+		// override the item rendering method to add a "x" to each
+		this.settings.render.item = function(data) {
+			var label = data[self.settings.labelField];
+			return '<div class="item">' + label + ' <a href="javascript:void(0)" class="remove" tabindex="-1" title="Remove">&times;</a></div>';
+		};
+
+		// override the setup method to add an extra "click" handler
+		// that listens for mousedown events on the "x"
+		this.setup = (function() {
+			var original = self.setup;
+			return function() {
+				original.apply(this, arguments);
+				this.$control.on('click', '.remove', function(e) {
+					e.preventDefault();
+					var $item = $(e.target).parent();
+					self.setActiveItem($item);
+					if (self.deleteSelection()) {
+						self.setCaret(self.items.length);
+					}
+				});
+			};
+		})();
+
+	});
+
+	/* --- file: "src/plugins/restore_on_backspace/plugin.js" --- */
+
+	/**
+	* Plugin: "restore_on_backspace" (selectize.js)
+	* Copyright (c) 2013 Brian Reavis & contributors
+	*
+	* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
+	* file except in compliance with the License. You may obtain a copy of the License at:
+	* http://www.apache.org/licenses/LICENSE-2.0
+	*
+	* Unless required by applicable law or agreed to in writing, software distributed under
+	* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+	* ANY KIND, either express or implied. See the License for the specific language
+	* governing permissions and limitations under the License.
+	*
+	* @author Brian Reavis <brian@thirdroute.com>
+	*/
+
+	(function() {
+		Selectize.registerPlugin('restore_on_backspace', function(options) {
+			var self = this;
+
+			options.text = options.text || function(option) {
+				return option[this.settings.labelField];
+			};
+
+			this.onKeyDown = (function(e) {
+				var original = self.onKeyDown;
+				return function(e) {
+					var index, option;
+					if (e.keyCode === KEY_BACKSPACE && this.$control_input.val() === '' && !this.$activeItems.length) {
+						index = this.caretPos - 1;
+						if (index >= 0 && index < this.items.length) {
+							option = this.options[this.items[index]];
+							if (this.deleteSelection(e)) {
+								this.setTextboxValue(options.text.apply(this, [option]));
+								this.refreshOptions(true);
+							}
+							e.preventDefault();
+							return;
+						}
+					}
+					return original.apply(this, arguments);
+				};
+			})();
+
+		});
+	})();
+
 	return Selectize;
 
 }));