https://hydroterra.com.au/wp-content/plugins/woocommerce-request-a-quote//assets/js/select2.js?ver=1.0

1/*!
2 * Select2 4.0.0
3 * https://select2.github.io
4 *
5 * Released under the MIT license
6 * https://github.com/select2/select2/blob/master/LICENSE.md
7 */
8(function (factory) {
9	if (typeof define === 'function' && define.amd) {
10	  // AMD. Register as an anonymous module.
11	  define(['jquery'], factory);
12	} else if (typeof exports === 'object') {
13	  // Node/CommonJS
14	  factory(require('jquery'));
15	} else {
16	  // Browser globals
17	  factory(jQuery);
18	}
19}(function (jQuery) {
20  // This is needed so we can catch the AMD loader configuration and use it
21  // The inner file should be wrapped (by `banner.start.js`) in a function that
22  // returns the AMD loader references.
23  var S2 =
24(function () {
25		  // Restore the Select2 AMD loader so it can be used
26		  // Needed mostly in the language files, where the loader is not inserted
27		if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) {
28	  var S2 = jQuery.fn.select2.amd;
29		}
30		var S2;(function () { if (!S2 || !S2.requirejs) {
31				if (!S2) {
32			S2 = {}; } else {
33						require = S2; }
34		/**
35		 * @license almond 0.2.9 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
36		 * Available via the MIT or new BSD license.
37		 * see: http://github.com/jrburke/almond for details
38		 */
39		//Going sloppy to avoid 'use strict' string cost, but strict practices should
40		//be followed.
41		/*jslint sloppy: true */
42		/*global setTimeout: false */
43
44		var requirejs, require, define;
45		(function (undef) {
46								var main, req, makeMap, handlers,
47							defined        = {},
48							waiting        = {},
49							config         = {},
50							defining       = {},
51							hasOwn         = Object.prototype.hasOwnProperty,
52							aps            = [].slice,
53							jsSuffixRegExp = /\.js$/;
54
55						function hasProp(obj, prop) {
56				return hasOwn.call(obj, prop);
57						}
58
59						/**
60						 * Given a relative module name, like ./something, normalize it to
61						 * a real name that can be mapped to a path.
62				 *
63						 * @param {String} name the relative name
64						 * @param {String} baseName a real name that the name arg is relative
65						 * to.
66						 * @returns {String} normalized name
67						 */
68						function normalize(name, baseName) {
69			var nameParts, nameSegment, mapValue, foundMap, lastIndex,
70				foundI, foundStarMap, starI, i, j, part,
71				baseParts = baseName && baseName.split("/"),
72				map       = config.map,
73				starMap   = (map && map['*']) || {};
74
75			//Adjust any relative paths.
76							if (name && name.charAt(0) === ".") {
77								//If have a base name, try to normalize against it,
78								//otherwise, assume it is a top-level require that will
79								//be relative to baseUrl in the end.
80								if (baseName) {
81									//Convert baseName to array, and lop off the last part,
82									//so that . matches that "directory" and not name of the baseName's
83									//module. For instance, baseName of "one/two/three", maps to
84									//"one/two/three.js", but we want the directory, "one/two" for
85									//this normalization.
86									baseParts = baseParts.slice(0, baseParts.length - 1);
87									name      = name.split('/');
88									lastIndex = name.length - 1;
89
90									// Node .js allowance:
91									if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
92										name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
93									}
94
95									name = baseParts.concat(name);
96
97									//start trimDots
98									for (i = 0; i < name.length; i += 1) {
99										part = name[i];
100										if (part === ".") {
101											name.splice(i, 1);
102											i -= 1;
103										} else if (part === "..") {
104											if (i === 1 && (name[2] === '..' || name[0] === '..')) {
105												//End of the line. Keep at least one non-dot
106												//path segment at the front so it can be mapped
107												//correctly to disk. Otherwise, there is likely
108												//no path mapping for a path starting with '..'.
109												//This can still fail, but catches the most reasonable
110												//uses of ..
111												break;
112											} else if (i > 0) {
113												name.splice(i - 1, 2);
114												i -= 2;
115											}
116										}
117									}
118									//end trimDots
119
120									name = name.join("/");
121								} else if (name.indexOf('./') === 0) {
122									// No baseName, so this is ID is resolved relative
123									// to baseUrl, pull off the leading dot.
124									name = name.substring(2);
125								}
126							}
127
128			//Apply map config if available.
129							if ((baseParts || starMap) && map) {

130								nameParts = name.split('/');
131
132								for (i = nameParts.length; i > 0; i -= 1) {
133									nameSegment = nameParts.slice(0, i).join("/");
134
135									if (baseParts) {
136										//Find the longest baseName segment match in the config.
137										//So, do joins on the biggest to smallest lengths of baseParts.
138										for (j = baseParts.length; j > 0; j -= 1) {
139											mapValue = map[baseParts.slice(0, j).join('/')];
140
141											//baseName segment has  config, find if it has one for
142											//this name.
143											if (mapValue) {
144												mapValue = mapValue[nameSegment];
145												if (mapValue) {
146													//Match, update name to the new value.
147													foundMap = mapValue;
148													foundI   = i;
149													break;
150												}
151											}
152										}
153									}
154
155									if (foundMap) {
156										break;
157									}
158
159									//Check for a star map match, but just hold on to it,
160									//if there is a shorter segment match later in a matching
161									//config, then favor over this star map.
162									if (!foundStarMap && starMap && starMap[nameSegment]) {
163										foundStarMap = starMap[nameSegment];
164										starI        = i;
165									}
166								}
167
168								if (!foundMap && foundStarMap) {
169									foundMap = foundStarMap;
170									foundI   = starI;
171								}
172
173								if (foundMap) {
174									nameParts.splice(0, foundI, foundMap);
175									name = nameParts.join('/');
176								}
177							}
178
179			return name;
180						}
181
182						function makeRequire(relName, forceSync) {
183			return function () {
184									//A version of a require function that passes a moduleName
185									//value for items that may need to
186									//look up paths relative to the moduleName
187									return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
188							};
189									}
190
191						function makeNormalize(relName) {
192							return function (name) {
193								return normalize(name, relName);
194							};
195						}
196
197						function makeLoad(depName) {
198							return function (value) {
199								defined[depName] = value;
200							};
201						}
202
203						function callDep(name) {
204							if (hasProp(waiting, name)) {
205								var args = waiting[name];
206								delete waiting[name];
207								defining[name] = true;
208								main.apply(undef, args);
209							}
210
211							if (!hasProp(defined, name) && !hasProp(defining, name)) {
212								throw new Error('No ' + name);
213							}
214							return defined[name];
215						}
216
217						//Turns a plugin!resource to [plugin, resource]
218						//with the plugin being undefined if the name
219						//did not have a plugin prefix.
220						function splitPrefix(name) {
221							var prefix,
222								index = name ? name.indexOf('!') : -1;
223							if (index > -1) {
224								prefix = name.substring(0, index);
225								name   = name.substring(index + 1, name.length);
226							}
227							return [prefix, name];
228						}
229
230						/**
231						 * Makes a name map, normalizing the name, and using a plugin
232						 * for normalization if necessary. Grabs a ref to plugin
233						 * too, as an optimization.
234						 */
235						makeMap = function (name, relName) {
236							var plugin,
237								parts  = splitPrefix(name),
238								prefix = parts[0];
239
240							name = parts[1];
241
242							if (prefix) {
243								prefix = normalize(prefix, relName);
244								plugin = callDep(prefix);
245							}
246
247							//Normalize according
248							if (prefix) {
249								if (plugin && plugin.normalize) {
250									name = plugin.normalize(name, makeNormalize(relName));
251								} else {
252									name = normalize(name, relName);
253								}
254							} else {
255								name   = normalize(name, relName);
256								parts  = splitPrefix(name);
257								prefix = parts[0];
258								name   = parts[1];
259								if (prefix) {
260									plugin = callDep(prefix);
261								}
262							}
263
264							//Using ridiculous property names for space reasons
265							return {
266								f: prefix ? prefix + '!' + name : name, //fullName
267								n: name,
268								pr: prefix,
269								p: plugin
270							};
271						};
272
273			function makeConfig(name) {
274			return function () {
275					return (config && config.config && config.config[name]) || {};
276				};
277						}
278
279					handlers = {
280						require: function (name) {
281							return makeRequire(name);
282						},
283						exports: function (name) {
284							var e = defined[name];
285							if (typeof e !== 'undefined') {
286								return e;
287							} else {
288								return (defined[name] = {});
289							}
290						},
291						module: function (name) {
292							return {
293								id: name,
294								uri: '',
295								exports: defined[name],
296								config: makeConfig(name)
297							};
298						}
299						};
300
301								main = function (name, deps, callback, relName) {
302									var cjsModule, depName, ret, map, i,
303										args         = [],
304										callbackType = typeof callback,
305										usingExports;
306
307									//Use name if no relName
308									relName = relName || name;
309
310									//Call the callback to define the module, if necessary.
311									if (callbackType === 'undefined' || callbackType === 'function') {
312										//Pull out the defined dependencies and pass the ordered
313										//values to the callback.
314										//Default to [require, exports, module] if no deps
315										deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
316										for (i = 0; i < deps.length; i += 1) {
317											map     = makeMap(deps[i], relName);
318											depName = map.f;
319
320											//Fast path CommonJS standard dependencies.
321											if (depName === "require") {
322												args[i] = handlers.require(name);
323											} else if (depName === "exports") {
324												//CommonJS module spec 1.1
325												args[i]      = handlers.exports(name);
326												usingExports = true;
327											} else if (depName === "module") {
328												//CommonJS module spec 1.1
329												cjsModule = args[i] = handlers.module(name);
330											} else if (hasProp(defined, depName) ||
331											   hasProp(waiting, depName) ||
332											   hasProp(defining, depName)) {
333												args[i] = callDep(depName);
334											} else if (map.p) {
335												map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
336												args[i] = defined[depName];
337											} else {
338												throw new Error(name + ' missing ' + depName);
339											}
340										}
341
342										ret = callback ? callback.apply(defined[name], args) : undefined;
343
344										if (name) {
345											//If setting exports via "module" is in play,
346											//favor that over return value and exports. After that,
347											//favor a non-undefined return value over exports use.
348											if (cjsModule && cjsModule.exports !== undef &&
349											cjsModule.exports !== defined[name]) {
350												defined[name] = cjsModule.exports;
351											} else if (ret !== undef || !usingExports) {
352												//Use the return value from the function.
353												defined[name] = ret;
354											}
355										}
356									} else if (name) {
357										//May just be an object definition for the module. Only
358										//worry about defining if have a module name.
359										defined[name] = callback;
360									}
361											};
362
363					requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
364						if (typeof deps === "string") {
365							if (handlers[deps]) {
366								//callback in this case is really relName
367								return handlers[deps](callback);
368							}
369							//Just return the module wanted. In this scenario, the
370							//deps arg is the module name, and second arg (if passed)
371							//is just the relName.
372							//Normalize module name, if it contains . or ..
373							return callDep(makeMap(deps, callback).f);
374						} else if (!deps.splice) {
375							//deps is a config object, not an array.

376							config = deps;
377							if (config.deps) {
378								req(config.deps, config.callback);
379							}
380							if (!callback) {
381								return;
382							}
383
384							if (callback.splice) {
385								//callback is an array, which means it is a dependency list.
386								//Adjust args if there are dependencies
387								deps     = callback;
388								callback = relName;
389								relName  = null;
390							} else {
391								deps = undef;
392							}
393						}
394
395						//Support require(['a'])
396						callback = callback || function () {};
397
398						//If relName is a function, it is an errback handler,
399						//so remove it.
400						if (typeof relName === 'function') {
401							relName   = forceSync;
402							forceSync = alt;
403						}
404
405						//Simulate async callback;
406						if (forceSync) {
407							main(undef, deps, callback, relName);
408						} else {
409							//Using a non-zero value because of concern for what old browsers
410							//do, and latest browsers "upgrade" to 4 if lower value is used:
411							//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
412							//If want a value immediately, use require('id') instead -- something
413							//that works in almond on the global level, but not guaranteed and
414							//unlikely to work in other AMD implementations.
415							setTimeout(function () {
416								main(undef, deps, callback, relName);
417							}, 4);
418						}
419
420						return req;
421								};
422
423					/**
424					 * Just drops the config on the floor, but returns req in case
425					 * the config return value is used.
426					 */
427					req.config = function (cfg) {
428						return req(cfg);
429								};
430
431					/**
432					 * Expose module registry for debugging and tooling
433					 */
434					requirejs._defined = defined;
435
436					define = function (name, deps, callback) {
437
438						//This module may not have dependencies
439						if (!deps.splice) {
440							//deps is not an array, so probably means
441							//an object literal or factory function for
442							//the value. Adjust args.
443							callback = deps;
444							deps     = [];
445						}
446
447						if (!hasProp(defined, name) && !hasProp(waiting, name)) {
448							waiting[name] = [name, deps, callback];
449						}
450								};
451
452					define.amd = {
453						jQuery: true
454						};
455					}());
456
457		S2.requirejs = requirejs;S2.require = require;S2.define = define;
458		}
459		}());
460		S2.define("almond", function(){});
461
462		/* global jQuery:false, $:false */
463		S2.define('jquery',[],function () {
464		  var _$ = jQuery || $;
465
466			if (_$ == null && console && console.error) {
467		  console.error(
468			'Select2: An instance of jQuery or a jQuery-compatible library was not ' +
469			'found. Make sure that you are including jQuery before Select2 on your ' +
470			'web page.'
471		  );
472			}
473
474		  return _$;
475		});
476
477		S2.define('select2/utils',[
478		  'jquery'
479		], function ($) {
480		  var Utils = {};
481
482		  Utils.Extend = function (ChildClass, SuperClass) {
483				var __hasProp = {}.hasOwnProperty;
484
485				function BaseConstructor () {
486					  this.constructor = ChildClass;
487				  }
488
489				for (var key in SuperClass) {
490					if (__hasProp.call(SuperClass, key)) {
491						ChildClass[key] = SuperClass[key];
492					}
493				  }
494
495				BaseConstructor.prototype = SuperClass.prototype;
496				ChildClass.prototype      = new BaseConstructor();
497				ChildClass.__super__      = SuperClass.prototype;
498
499				return ChildClass;
500			};
501
502			function getMethods (theClass) {
503	  var proto = theClass.prototype;
504
505	  var methods = [];
506
507				for (var methodName in proto) {
508				  var m = proto[methodName];
509
510					if (typeof m !== 'function') {
511					continue;
512					}
513
514					if (methodName === 'constructor') {
515			  continue;
516					}
517
518			  methods.push(methodName);
519				}
520
521	  return methods;
522			}
523
524	  Utils.Decorate = function (SuperClass, DecoratorClass) {
525					var decoratedMethods = getMethods(DecoratorClass);
526					var superMethods     = getMethods(SuperClass);
527
528				function DecoratedClass () {
529			var unshift = Array.prototype.unshift;
530
531			var argCount = DecoratorClass.prototype.constructor.length;
532
533			var calledConstructor = SuperClass.prototype.constructor;
534
535					if (argCount > 0) {
536						  unshift.call(arguments, SuperClass.prototype.constructor);
537
538						  calledConstructor = DecoratorClass.prototype.constructor;
539					}
540
541			calledConstructor.apply(this, arguments);
542					  }
543
544					DecoratorClass.displayName = SuperClass.displayName;
545
546				function ctr () {
547				this.constructor = DecoratedClass;
548					  }
549
550					DecoratedClass.prototype = new ctr();
551
552				for (var m = 0; m < superMethods.length; m++) {
553					var superMethod = superMethods[m];
554
555					DecoratedClass.prototype[superMethod] =
556					  SuperClass.prototype[superMethod];
557					  }
558
559					var calledMethod = function (methodName) {
560					  // Stub out the original method if it's not decorating an actual method
561					  var originalMethod = function () {};
562
563						if (methodName in DecoratedClass.prototype) {
564					originalMethod = DecoratedClass.prototype[methodName];
565						}
566
567				var decoratedMethod = DecoratorClass.prototype[methodName];
568
569				return function () {
570							  var unshift = Array.prototype.unshift;
571
572							  unshift.call(arguments, originalMethod);
573
574							  return decoratedMethod.apply(this, arguments);
575						};
576						  };
577
578			for (var d = 0; d < decoratedMethods.length; d++) {
579		  var decoratedMethod = decoratedMethods[d];
580
581		  DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod);
582			}
583
584			  return DecoratedClass;
585			};
586
587		  var Observable = function () {
588				this.listeners = {};
589			};
590
591		  Observable.prototype.on = function (event, callback) {
592				this.listeners = this.listeners || {};
593
594				if (event in this.listeners) {
595				  this.listeners[event].push(callback);
596				} else {
597				  this.listeners[event] = [callback];
598				}
599			};
600
601		  Observable.prototype.trigger = function (event) {
602				var slice = Array.prototype.slice;
603
604				this.listeners = this.listeners || {};
605
606				if (event in this.listeners) {
607				  this.invoke(this.listeners[event], slice.call(arguments, 1));
608				}
609
610				if ('*' in this.listeners) {
611				  this.invoke(this.listeners['*'], arguments);
612				}
613			};
614
615		  Observable.prototype.invoke = function (listeners, params) {
616				for (var i = 0, len = listeners.length; i < len; i++) {
617				  listeners[i].apply(this, params);
618				}
619			};
620
621		  Utils.Observable = Observable;
622
623		  Utils.generateChars = function (length) {
624				var chars = '';
625
626				for (var i = 0; i < length; i++) {
627				  var randomChar = Math.floor(Math.random() * 36);
628				  chars         += randomChar.toString(36);
629				}
630
631				return chars;
632			};
633
634		  Utils.bind = function (func, context) {
635				return function () {
636				  func.apply(context, arguments);
637				};
638			};
639
640		  Utils._convertData = function (data) {
641				for (var originalKey in data) {
642				  var keys = originalKey.split('-');
643
644				  var dataLevel = data;
645
646					if (keys.length === 1) {
647					continue;
648					}
649
650					for (var k = 0; k < keys.length; k++) {
651			  var key = keys[k];
652
653			  // Lowercase the first letter
654			  // By default, dash-separated becomes camelCase
655			  key = key.substring(0, 1).toLowerCase() + key.substring(1);
656
657						if (!(key in dataLevel)) {
658							dataLevel[key] = {};
659						}
660
661						if (k == keys.length - 1) {
662						  dataLevel[key] = data[originalKey];
663						}
664
665			  dataLevel = dataLevel[key];
666					}
667
668			  delete data[originalKey];
669				}
670
671				return data;
672			};
673
674		  Utils.hasScroll = function (index, el) {
675				// Adapted from the function created by @ShadowScripter
676				// and adapted by @BillBarry on the Stack Exchange Code Review website.
677				// The original code can be found at
678				// http://codereview.stackexchange.com/q/13338
679				// and was designed to be used with the Sizzle selector engine.
680
681				var $el       = $(el);
682				var overflowX = el.style.overflowX;
683				var overflowY = el.style.overflowY;
684
685				//Check both x and y declarations
686				if (overflowX === overflowY &&
687				(overflowY === 'hidden' || overflowY === 'visible')) {
688				  return false;
689				}
690
691				if (overflowX === 'scroll' || overflowY === 'scroll') {
692				  return true;
693				}
694
695				return ($el.innerHeight() < el.scrollHeight ||
696				$el.innerWidth() < el.scrollWidth);
697			};
698
699		  Utils.escapeMarkup = function (markup) {
700				var replaceMap = {
701					'\\': '&#92;',
702					'&': '&amp;',
703					'<': '&lt;',
704					'>': '&gt;',
705					'"': '&quot;',
706					'\'': '&#39;',
707					'/': '&#47;'
708				};
709
710				// Do not try to escape the markup if it's not a string
711				if (typeof markup !== 'string') {
712				  return markup;
713				}
714
715				return String(markup).replace(/[&<>"'\/\\]/g, function (match) {
716				  return replaceMap[match];
717				});
718			};
719
720		  // Append an array of jQuery nodes to a given element.
721		  Utils.appendMany = function ($element, $nodes) {
722				// jQuery 1.7.x does not support $.fn.append() with an array
723				// Fall back to a jQuery object collection using $.fn.add()
724				if ($.fn.jquery.substr(0, 3) === '1.7') {
725				  var $jqNodes = $();
726
727				  $.map($nodes, function (node) {
728						$jqNodes = $jqNodes.add(node);
729					});
730
731				  $nodes = $jqNodes;
732				}
733
734				$element.append($nodes);
735			};
736
737		  return Utils;
738		});
739
740		S2.define('select2/results',[
741		  'jquery',
742		  './utils'
743		], function ($, Utils) {
744			function Results ($element, options, dataAdapter) {
745		  this.$element = $element;
746		  this.data     = dataAdapter;
747		  this.options  = options;
748
749		  Results.__super__.constructor.call(this);
750			}
751
752		  Utils.Extend(Results, Utils.Observable);
753
754		  Results.prototype.render = function () {
755				var $results = $(
756				'<ul class="select2-results__options" role="tree"></ul>'
757				);
758
759				if (this.options.get('multiple')) {
760				  $results.attr('aria-multiselectable', 'true');
761				}
762
763				this.$results = $results;
764
765				return $results;
766			};
767
768		  Results.prototype.clear = function () {
769				this.$results.empty();
770			};
771
772		  Results.prototype.displayMessage = function (params) {
773				var escapeMarkup = this.options.get('escapeMarkup');
774
775				this.clear();
776				this.hideLoading();
777
778				var $message = $(
779				'<li role="treeitem" class="select2-results__option"></li>'
780				);
781
782				var message = this.options.get('translations').get(params.message);
783
784				$message.append(
785				escapeMarkup(
786				message(params.args)
787				)
788				);
789
790				this.$results.append($message);
791			};
792
793		  Results.prototype.append = function (data) {
794				this.hideLoading();
795
796				var $options = [];
797
798				if (data.results == null || data.results.length === 0) {
799					if (this.$results.children().length === 0) {
800					this.trigger('results:message', {
801							message: 'noResults'
802					});
803					}
804
805				  return;
806				}
807
808				data.results = this.sort(data.results);
809
810				for (var d = 0; d < data.results.length; d++) {
811				  var item = data.results[d];
812
813				  var $option = this.option(item);
814
815				  $options.push($option);
816				}
817
818				this.$results.append($options);
819			};
820
821		  Results.prototype.position = function ($results, $dropdown) {
822				var $resultsContainer = $dropdown.find('.select2-results');
823				$resultsContainer.append($results);
824			};
825
826		  Results.prototype.sort = function (data) {
827				var sorter = this.options.get('sorter');
828
829				return sorter(data);
830			};
831
832		  Results.prototype.setClasses = function () {
833				var self = this;
834
835				this.data.current(function (selected) {
836				  var selectedIds = $.map(selected, function (s) {
837						return s.id.toString();
838					});
839
840				  var $options = self.$results
841				  .find('.select2-results__option[aria-selected]');
842
843				  $options.each(function () {
844						var $option = $(this);
845
846						var item = $.data(this, 'data');
847
848						// id needs to be converted to a string when comparing
849						var id = '' + item.id;
850
851						if ((item.element != null && item.element.selected) ||
852						(item.element == null && $.inArray(id, selectedIds) > -1)) {
853								$option.attr('aria-selected', 'true');
854							} else {
855							$option.attr('aria-selected', 'false');
856							}
857					});
858
859				  var $selected = $options.filter('[aria-selected=true]');
860
861				  // Check if there are any selected options
862					if ($selected.length > 0) {
863				  // If there are selected options, highlight the first
864				  $selected.first().trigger('mouseenter');
865					} else {
866			  // If there are no selected options, highlight the first option
867			  // in the dropdown
868			  $options.first().trigger('mouseenter');
869					}
870				});
871			};
872
873		  Results.prototype.showLoading = function (params) {
874				this.hideLoading();
875
876				var loadingMore = this.options.get('translations').get('searching');
877
878				var loading         = {
879					disabled: true,
880					loading: true,
881					text: loadingMore(params)
882				};
883				var $loading        = this.option(loading);
884				$loading.className += ' loading-results';
885
886				this.$results.prepend($loading);
887			};
888
889		  Results.prototype.hideLoading = function () {
890				this.$results.find('.loading-results').remove();
891			};
892
893		  Results.prototype.option = function (data) {
894				var option       = document.createElement('li');
895				option.className = 'select2-results__option';
896
897				var attrs = {
898					'role': 'treeitem',
899					'aria-selected': 'false'
900				};
901
902				if (data.disabled) {
903				  delete attrs['aria-selected'];
904				  attrs['aria-disabled'] = 'true';
905				}
906
907				if (data.id == null) {
908				  delete attrs['aria-selected'];
909				}
910
911				if (data._resultId != null) {
912				  option.id = data._resultId;
913				}
914
915				if (data.title) {
916				  option.title = data.title;
917				}
918
919				if (data.children) {
920				  attrs.role          = 'group';
921				  attrs['aria-label'] = data.text;
922				  delete attrs['aria-selected'];
923				}
924
925				for (var attr in attrs) {
926				  var val = attrs[attr];
927
928				  option.setAttribute(attr, val);
929				}
930
931				if (data.children) {
932				  var $option = $(option);
933
934				  var label       = document.createElement('strong');
935				  label.className = 'select2-results__group';
936
937				  var $label = $(label);
938				  this.template(data, label);
939
940				  var $children = [];
941
942					for (var c = 0; c < data.children.length; c++) {
943				  var child = data.children[c];
944
945				  var $child = this.option(child);
946
947				  $children.push($child);
948					}
949
950				  var $childrenContainer = $('<ul></ul>', {
951						'class': 'select2-results__options select2-results__options--nested'
952				  });
953
954				  $childrenContainer.append($children);
955
956				  $option.append(label);
957				  $option.append($childrenContainer);
958				} else {
959				  this.template(data, option);
960				}
961
962				$.data(option, 'data', data);
963
964				return option;
965			};
966
967		  Results.prototype.bind = function (container, $container) {
968				var self = this;
969
970				var id = container.id + '-results';
971
972				this.$results.attr('id', id);
973
974				container.on('results:all', function (params) {
975				  self.clear();
976				  self.append(params.data);
977
978					if (container.isOpen()) {
979				  self.setClasses();
980					}
981				});
982
983				container.on('results:append', function (params) {
984				  self.append(params.data);
985
986					if (container.isOpen()) {
987				  self.setClasses();
988					}
989				});
990
991				container.on('query', function (params) {
992				  self.showLoading(params);
993				});
994
995				container.on('select', function () {
996					if (!container.isOpen()) {
997				  return;
998					}
999
1000				  self.setClasses();
1001				});
1002
1003				container.on('unselect', function () {
1004					if (!container.isOpen()) {
1005				  return;
1006					}
1007
1008				  self.setClasses();
1009				});
1010
1011				container.on('open', function () {
1012				  // When the dropdown is open, aria-expended="true"
1013				  self.$results.attr('aria-expanded', 'true');
1014				  self.$results.attr('aria-hidden', 'false');
1015
1016				  self.setClasses();
1017				  self.ensureHighlightVisible();
1018				});
1019
1020				container.on('close', function () {
1021				  // When the dropdown is closed, aria-expended="false"
1022				  self.$results.attr('aria-expanded', 'false');
1023				  self.$results.attr('aria-hidden', 'true');
1024				  self.$results.removeAttr('aria-activedescendant');
1025				});
1026
1027				container.on('results:toggle', function () {
1028				  var $highlighted = self.getHighlightedResults();
1029
1030					if ($highlighted.length === 0) {
1031				  return;
1032					}
1033
1034				  $highlighted.trigger('mouseup');
1035				});
1036
1037				container.on('results:select', function () {
1038				  var $highlighted = self.getHighlightedResults();
1039
1040					if ($highlighted.length === 0) {
1041				  return;
1042					}
1043
1044				  var data = $highlighted.data('data');
1045
1046					if ($highlighted.attr('aria-selected') == 'true') {
1047			  self.trigger('close');
1048					} else {
1049			  self.trigger('select', {
1050							data: data
1051			  });
1052					}
1053				});
1054
1055				container.on('results:previous', function () {
1056				  var $highlighted = self.getHighlightedResults();
1057
1058				  var $options = self.$results.find('[aria-selected]');
1059
1060				  var currentIndex = $options.index($highlighted);
1061
1062				  // If we are already at te top, don't move further
1063					if (currentIndex === 0) {
1064				  return;
1065					}
1066
1067				  var nextIndex = currentIndex - 1;
1068
1069				  // If none are highlighted, highlight the first
1070					if ($highlighted.length === 0) {
1071			  nextIndex = 0;
1072					}
1073
1074			  var $next = $options.eq(nextIndex);
1075
1076			  $next.trigger('mouseenter');
1077
1078			  var currentOffset = self.$results.offset().top;
1079			  var nextTop       = $next.offset().top;
1080			  var nextOffset    = self.$results.scrollTop() + (nextTop - currentOffset);
1081
1082					if (nextIndex === 0) {
1083						self.$results.scrollTop(0);
1084					} else if (nextTop - currentOffset < 0) {
1085		  self.$results.scrollTop(nextOffset);
1086					}
1087				});
1088
1089				container.on('results:next', function () {
1090				  var $highlighted = self.getHighlightedResults();
1091
1092				  var $options = self.$results.find('[aria-selected]');
1093
1094				  var currentIndex = $options.index($highlighted);
1095
1096				  var nextIndex = currentIndex + 1;
1097
1098				  // If we are at the last option, stay there
1099					if (nextIndex >= $options.length) {
1100				  return;
1101					}
1102
1103				  var $next = $options.eq(nextIndex);
1104
1105				  $next.trigger('mouseenter');
1106
1107				  var currentOffset = self.$results.offset().top +
1108				self.$results.outerHeight(false);
1109				  var nextBottom    = $next.offset().top + $next.outerHeight(false);
1110				  var nextOffset    = self.$results.scrollTop() + nextBottom - currentOffset;
1111
1112					if (nextIndex === 0) {
1113			  self.$results.scrollTop(0);
1114					} else if (nextBottom > currentOffset) {
1115			  self.$results.scrollTop(nextOffset);
1116					}
1117				});
1118
1119				container.on('results:focus', function (params) {
1120				  params.element.addClass('select2-results__option--highlighted');
1121				});
1122
1123				container.on('results:message', function (params) {
1124				  self.displayMessage(params);
1125				});
1126
1127				if ($.fn.mousewheel) {
1128				  this.$results.on('mousewheel', function (e) {
1129						var top = self.$results.scrollTop();
1130
1131						var bottom = (
1132						self.$results.get(0).scrollHeight -
1133						self.$results.scrollTop() +
1134						e.deltaY
1135						);
1136
1137						var isAtTop    = e.deltaY > 0 && top - e.deltaY <= 0;
1138						var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height();
1139
1140						if (isAtTop) {
1141							self.$results.scrollTop(0);
1142
1143							e.preventDefault();
1144							e.stopPropagation();
1145						} else if (isAtBottom) {
1146						  self.$results.scrollTop(
1147							self.$results.get(0).scrollHeight - self.$results.height()
1148						  );
1149
1150						  e.preventDefault();
1151						  e.stopPropagation();
1152						}
1153					});
1154				}
1155
1156				this.$results.on('mouseup', '.select2-results__option[aria-selected]',
1157				function (evt) {
1158			var $this = $(this);
1159
1160			var data = $this.data('data');
1161
1162					if ($this.attr('aria-selected') === 'true') {
1163						if (self.options.get('multiple')) {
1164				self.trigger('unselect', {
1165								originalEvent: evt,
1166								data: data
1167				});
1168						} else {
1169			  self.trigger('close');
1170						}
1171
1172				return;
1173					}
1174
1175			self.trigger('select', {
1176						originalEvent: evt,
1177						data: data
1178			});
1179				});
1180
1181				this.$results.on('mouseenter', '.select2-results__option[aria-selected]',
1182				function (evt) {
1183			var data = $(this).data('data');
1184
1185			self.getHighlightedResults()
1186				.removeClass('select2-results__option--highlighted');
1187
1188			self.trigger('results:focus', {
1189						data: data,
1190						element: $(this)
1191			});
1192				});
1193			};
1194
1195		  Results.prototype.getHighlightedResults = function () {
1196				var $highlighted = this.$results
1197				.find('.select2-results__option--highlighted');
1198
1199				return $highlighted;
1200			};
1201
1202		  Results.prototype.destroy = function () {
1203				this.$results.remove();
1204			};
1205
1206		  Results.prototype.ensureHighlightVisible = function () {
1207				var $highlighted = this.getHighlightedResults();
1208
1209				if ($highlighted.length === 0) {
1210				  return;
1211				}
1212
1213				var $options = this.$results.find('[aria-selected]');
1214
1215				var currentIndex = $options.index($highlighted);
1216
1217				var currentOffset = this.$results.offset().top;
1218				var nextTop       = $highlighted.offset().top;
1219				var nextOffset    = this.$results.scrollTop() + (nextTop - currentOffset);
1220
1221				var offsetDelta = nextTop - currentOffset;
1222				nextOffset     -= $highlighted.outerHeight(false) * 2;
1223
1224				if (currentIndex <= 2) {
1225				  this.$results.scrollTop(0);
1226				} else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) {
1227				  this.$results.scrollTop(nextOffset);
1228				}
1229			};
1230
1231		  Results.prototype.template = function (result, container) {
1232				var template     = this.options.get('templateResult');
1233				var escapeMarkup = this.options.get('escapeMarkup');
1234
1235				var content = template(result);
1236
1237				if (content == null) {
1238				  container.style.display = 'none';
1239				} else if (typeof content === 'string') {
1240				  container.innerHTML = escapeMarkup(content);
1241				} else {
1242				  $(container).append(content);
1243					}
1244			};
1245
1246		  return Results;
1247		});
1248
1249		S2.define('select2/keys',[
1250
1251		], function () {
1252		  var KEYS = {
1253				BACKSPACE: 8,
1254				TAB: 9,
1255				ENTER: 13,
1256				SHIFT: 16,
1257				CTRL: 17,
1258				ALT: 18,
1259				ESC: 27,
1260				SPACE: 32,
1261				PAGE_UP: 33,
1262				PAGE_DOWN: 34,
1263				END: 35,
1264				HOME: 36,
1265				LEFT: 37,
1266				UP: 38,
1267				RIGHT: 39,
1268				DOWN: 40,
1269				DELETE: 46
1270			};
1271
1272		  return KEYS;
1273		});
1274
1275		S2.define('select2/selection/base',[
1276		  'jquery',
1277		  '../utils',
1278		  '../keys'
1279		], function ($, Utils, KEYS) {
1280			function BaseSelection ($element, options) {
1281		  this.$element = $element;
1282		  this.options  = options;
1283
1284		  BaseSelection.__super__.constructor.call(this);
1285			}
1286
1287		  Utils.Extend(BaseSelection, Utils.Observable);
1288
1289		  BaseSelection.prototype.render = function () {
1290				var $selection = $(
1291				'<span class="select2-selection" role="combobox" ' +
1292				'aria-autocomplete="list" aria-haspopup="true" aria-expanded="false">' +
1293				'</span>'
1294				);
1295
1296				this._tabindex = 0;
1297
1298				if (this.$element.data('old-tabindex') != null) {
1299				  this._tabindex = this.$element.data('old-tabindex');
1300				} else if (this.$element.attr('tabindex') != null) {
1301				  this._tabindex = this.$element.attr('tabindex');
1302				}
1303
1304				$selection.attr('title', this.$element.attr('title'));
1305				$selection.attr('tabindex', this._tabindex);
1306
1307				this.$selection = $selection;
1308
1309				return $selection;
1310			};
1311
1312		  BaseSelection.prototype.bind = function (container, $container) {
1313				var self = this;
1314
1315				var id        = container.id + '-container';
1316				var resultsId = container.id + '-results';
1317
1318				this.container = container;
1319
1320				this.$selection.on('focus', function (evt) {
1321				  self.trigger('focus', evt);
1322				});
1323
1324				this.$selection.on('blur', function (evt) {
1325				  self.trigger('blur', evt);
1326				});
1327
1328				this.$selection.on('keydown', function (evt) {
1329				  self.trigger('keypress', evt);
1330
1331					if (evt.which === KEYS.SPACE) {
1332				  evt.preventDefault();
1333					}
1334				});
1335
1336				container.on('results:focus', function (params) {
1337				  self.$selection.attr('aria-activedescendant', params.data._resultId);
1338				});
1339
1340				container.on('selection:update', function (params) {
1341				  self.update(params.data);
1342				});
1343
1344				container.on('open', function () {
1345				  // When the dropdown is open, aria-expanded="true"
1346				  self.$selection.attr('aria-expanded', 'true');
1347				  self.$selection.attr('aria-owns', resultsId);
1348
1349				  self._attachCloseHandler(container);
1350				});
1351
1352				container.on('close', function () {
1353				  // When the dropdown is closed, aria-expanded="false"
1354				  self.$selection.attr('aria-expanded', 'false');
1355				  self.$selection.removeAttr('aria-activedescendant');
1356				  self.$selection.removeAttr('aria-owns');
1357
1358				  self.$selection.focus();
1359
1360				  self._detachCloseHandler(container);
1361				});
1362
1363				container.on('enable', function () {
1364				  self.$selection.attr('tabindex', self._tabindex);
1365				});
1366
1367				container.on('disable', function () {
1368				  self.$selection.attr('tabindex', '-1');
1369				});
1370			};
1371
1372		  BaseSelection.prototype._attachCloseHandler = function (container) {
1373				var self = this;
1374
1375				$(document.body).on('mousedown.select2.' + container.id, function (e) {
1376				  var $target = $(e.target);
1377
1378				  var $select = $target.closest('.select2');
1379
1380				  var $all = $('.select2.select2-container--open');
1381
1382				  $all.each(function () {
1383						var $this = $(this);
1384
1385						if (this == $select[0]) {
1386								return;
1387							}
1388
1389						var $element = $this.data('element');
1390
1391						$element.select2('close');
1392					});
1393				});
1394			};
1395
1396		  BaseSelection.prototype._detachCloseHandler = function (container) {
1397				$(document.body).off('mousedown.select2.' + container.id);
1398			};
1399
1400		  BaseSelection.prototype.position = function ($selection, $container) {
1401				var $selectionContainer = $container.find('.selection');
1402				$selectionContainer.append($selection);
1403			};
1404
1405		  BaseSelection.prototype.destroy = function () {
1406				this._detachCloseHandler(this.container);
1407			};
1408
1409		  BaseSelection.prototype.update = function (data) {
1410				throw new Error('The `update` method must be defined in child classes.');
1411			};
1412
1413		  return BaseSelection;
1414		});
1415
1416		S2.define('select2/selection/single',[
1417		  'jquery',
1418		  './base',
1419		  '../utils',
1420		  '../keys'
1421		], function ($, BaseSelection, Utils, KEYS) {
1422			function SingleSelection () {
1423		  SingleSelection.__super__.constructor.apply(this, arguments);
1424			}
1425
1426		  Utils.Extend(SingleSelection, BaseSelection);
1427
1428		  SingleSelection.prototype.render = function () {
1429				var $selection = SingleSelection.__super__.render.call(this);
1430
1431				$selection.addClass('select2-selection--single');
1432
1433				$selection.html(
1434				'<span class="select2-selection__rendered"></span>' +
1435				'<span class="select2-selection__arrow" role="presentation">' +
1436				'<b role="presentation"></b>' +
1437				'</span>'
1438				);
1439
1440				return $selection;
1441			};
1442
1443		  SingleSelection.prototype.bind = function (container, $container) {
1444				var self = this;
1445
1446				SingleSelection.__super__.bind.apply(this, arguments);
1447
1448				var id = container.id + '-container';
1449
1450				this.$selection.find('.select2-selection__rendered').attr('id', id);
1451				this.$selection.attr('aria-labelledby', id);
1452
1453				this.$selection.on('mousedown', function (evt) {
1454				  // Only respond to left clicks
1455					if (evt.which !== 1) {
1456				  return;
1457					}
1458
1459				  self.trigger('toggle', {
1460						originalEvent: evt
1461				  });
1462				});
1463
1464				this.$selection.on('focus', function (evt) {
1465				  // User focuses on the container
1466				});
1467
1468				this.$selection.on('blur', function (evt) {
1469				  // User exits the container
1470				});
1471
1472				container.on('selection:update', function (params) {
1473				  self.update(params.data);
1474				});
1475			};
1476
1477		  SingleSelection.prototype.clear = function () {
1478				this.$selection.find('.select2-selection__rendered').empty();
1479			};
1480
1481		  SingleSelection.prototype.display = function (data) {
1482				var template     = this.options.get('templateSelection');
1483				var escapeMarkup = this.options.get('escapeMarkup');
1484
1485				return escapeMarkup(template(data));
1486			};
1487
1488		  SingleSelection.prototype.selectionContainer = function () {
1489				return $('<span></span>');
1490			};
1491
1492		  SingleSelection.prototype.update = function (data) {
1493				if (data.length === 0) {
1494				  this.clear();
1495				  return;
1496				}
1497
1498				var selection = data[0];
1499
1500				var formatted = this.display(selection);
1501
1502				var $rendered = this.$selection.find('.select2-selection__rendered');
1503				$rendered.empty().append(formatted);
1504				$rendered.prop('title', selection.title || selection.text);
1505			};
1506
1507		  return SingleSelection;
1508		});
1509
1510		S2.define('select2/selection/multiple',[
1511		  'jquery',
1512		  './base',
1513		  '../utils'
1514		], function ($, BaseSelection, Utils) {
1515			function MultipleSelection ($element, options) {
1516		  MultipleSelection.__super__.constructor.apply(this, arguments);
1517			}
1518
1519		  Utils.Extend(MultipleSelection, BaseSelection);
1520
1521		  MultipleSelection.prototype.render = function () {
1522				var $selection = MultipleSelection.__super__.render.call(this);
1523
1524				$selection.addClass('select2-selection--multiple');
1525
1526				$selection.html(
1527				'<ul class="select2-selection__rendered"></ul>'
1528				);
1529
1530				return $selection;
1531			};
1532
1533		  MultipleSelection.prototype.bind = function (container, $container) {
1534				var self = this;
1535
1536				MultipleSelection.__super__.bind.apply(this, arguments);
1537
1538				this.$selection.on('click', function (evt) {
1539				  self.trigger('toggle', {
1540						originalEvent: evt
1541				  });
1542				});
1543
1544				this.$selection.on('click', '.select2-selection__choice__remove',
1545				function (evt) {
1546			var $remove    = $(this);
1547			var $selection = $remove.parent();
1548
1549			var data = $selection.data('data');
1550
1551			self.trigger('unselect', {
1552						originalEvent: evt,
1553						data: data
1554			});
1555				});
1556			};
1557
1558		  MultipleSelection.prototype.clear = function () {
1559				this.$selection.find('.select2-selection__rendered').empty();
1560			};
1561
1562		  MultipleSelection.prototype.display = function (data) {
1563				var template     = this.options.get('templateSelection');
1564				var escapeMarkup = this.options.get('escapeMarkup');
1565
1566				return escapeMarkup(template(data));
1567			};
1568
1569		  MultipleSelection.prototype.selectionContainer = function () {
1570				var $container = $(
1571				'<li class="select2-selection__choice">' +
1572				'<span class="select2-selection__choice__remove" role="presentation">' +
1573				'&times;' +
1574				'</span>' +
1575				'</li>'
1576				);
1577
1578				return $container;
1579			};
1580
1581		  MultipleSelection.prototype.update = function (data) {
1582				this.clear();
1583
1584				if (data.length === 0) {
1585				  return;
1586				}
1587
1588				var $selections = [];
1589
1590				for (var d = 0; d < data.length; d++) {
1591				  var selection = data[d];
1592
1593				  var formatted  = this.display(selection);
1594				  var $selection = this.selectionContainer();
1595
1596				  $selection.append(formatted);
1597				  $selection.prop('title', selection.title || selection.text);
1598
1599				  $selection.data('data', selection);
1600
1601				  $selections.push($selection);
1602				}
1603
1604				var $rendered = this.$selection.find('.select2-selection__rendered');
1605
1606				Utils.appendMany($rendered, $selections);
1607			};
1608
1609		  return MultipleSelection;
1610		});
1611
1612		S2.define('select2/selection/placeholder',[
1613		  '../utils'
1614		], function (Utils) {
1615			function Placeholder (decorated, $element, options) {
1616		  this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
1617
1618		  decorated.call(this, $element, options);
1619			}
1620
1621		  Placeholder.prototype.normalizePlaceholder = function (_, placeholder) {
1622				if (typeof placeholder === 'string') {
1623				  placeholder = {
1624						id: '',
1625						text: placeholder
1626					};
1627				}
1628
1629				return placeholder;
1630			};
1631
1632		  Placeholder.prototype.createPlaceholder = function (decorated, placeholder) {
1633				var $placeholder = this.selectionContainer();
1634
1635				$placeholder.html(this.display(placeholder));
1636				$placeholder.addClass('select2-selection__placeholder')
1637				.removeClass('select2-selection__choice');
1638
1639				return $placeholder;
1640			};
1641
1642		  Placeholder.prototype.update = function (decorated, data) {
1643				var singlePlaceholder  = (
1644				data.length == 1 && data[0].id != this.placeholder.id
1645				);
1646				var multipleSelections = data.length > 1;
1647
1648				if (multipleSelections || singlePlaceholder) {
1649				  return decorated.call(this, data);
1650				}
1651
1652				this.clear();
1653
1654				var $placeholder = this.createPlaceholder(this.placeholder);
1655
1656				this.$selection.find('.select2-selection__rendered').append($placeholder);
1657			};
1658
1659		  return Placeholder;
1660		});
1661
1662		S2.define('select2/selection/allowClear',[
1663		  'jquery',
1664		  '../keys'
1665		], function ($, KEYS) {
1666			function AllowClear () { }
1667
1668		  AllowClear.prototype.bind = function (decorated, container, $container) {
1669				var self = this;
1670
1671				decorated.call(this, container, $container);
1672
1673				if (this.placeholder == null) {
1674					if (this.options.get('debug') && window.console && console.error) {
1675				  console.error(
1676					'Select2: The `allowClear` option should be used in combination ' +
1677					'with the `placeholder` option.'
1678				  );
1679					}
1680				  }
1681
1682				this.$selection.on('mousedown', '.select2-selection__clear',
1683				function (evt) {
1684				  self._handleClear(evt);
1685				  });
1686
1687				container.on('keypress', function (evt) {
1688					self._handleKeyboardClear(evt, container);
1689				  });
1690			};
1691
1692		  AllowClear.prototype._handleClear = function (_, evt) {
1693				// Ignore the event if it is disabled
1694				if (this.options.get('disabled')) {
1695				  return;
1696				}
1697
1698				var $clear = this.$selection.find('.select2-selection__clear');
1699
1700				// Ignore the event if nothing has been selected
1701				if ($clear.length === 0) {
1702				  return;
1703				}
1704
1705				evt.stopPropagation();
1706
1707				var data = $clear.data('data');
1708
1709				for (var d = 0; d < data.length; d++) {
1710				  var unselectData = {
1711						data: data[d]
1712					};
1713
1714				  // Trigger the `unselect` event, so people can prevent it from being
1715				  // cleared.
1716				  this.trigger('unselect', unselectData);
1717
1718				  // If the event was prevented, don't clear it out.
1719					if (unselectData.prevented) {
1720					return;
1721					}
1722				}
1723
1724				this.$element.val(this.placeholder.id).trigger('change');
1725
1726				this.trigger('toggle');
1727			};
1728
1729		  AllowClear.prototype._handleKeyboardClear = function (_, evt, container) {
1730				if (container.isOpen()) {
1731				  return;
1732				}
1733
1734				if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) {
1735				  this._handleClear(evt);
1736				}
1737			};
1738
1739		  AllowClear.prototype.update = function (decorated, data) {
1740				decorated.call(this, data);
1741
1742				if (this.$selection.find('.select2-selection__placeholder').length > 0 ||
1743				data.length === 0) {
1744				  return;
1745				}
1746
1747				var $remove = $(
1748				'<span class="select2-selection__clear">' +
1749				'&times;' +
1750				'</span>'
1751				);
1752				$remove.data('data', data);
1753
1754				this.$selection.find('.select2-selection__rendered').prepend($remove);
1755			};
1756
1757		  return AllowClear;
1758		});
1759
1760		S2.define('select2/selection/search',[
1761		  'jquery',
1762		  '../utils',
1763		  '../keys'
1764		], function ($, Utils, KEYS) {
1765			function Search (decorated, $element, options) {
1766		  decorated.call(this, $element, options);
1767			}
1768
1769		  Search.prototype.render = function (decorated) {
1770				var $search = $(
1771				'<li class="select2-search select2-search--inline">' +
1772				'<input class="select2-search__field" type="search" tabindex="-1"' +
1773				' autocomplete="off" autocorrect="off" autocapitalize="off"' +
1774				' spellcheck="false" role="textbox" />' +
1775				'</li>'
1776				);
1777
1778				this.$searchContainer = $search;
1779				this.$search          = $search.find('input');
1780
1781				var $rendered = decorated.call(this);
1782
1783				return $rendered;
1784			};
1785
1786		  Search.prototype.bind = function (decorated, container, $container) {
1787				var self = this;
1788
1789				decorated.call(this, container, $container);
1790
1791				container.on('open', function () {
1792				  self.$search.attr('tabindex', 0);
1793
1794				  self.$search.focus();
1795				});
1796
1797				container.on('close', function () {
1798				  self.$search.attr('tabindex', -1);
1799
1800				  self.$search.val('');
1801				  self.$search.focus();
1802				});
1803
1804				container.on('enable', function () {
1805				  self.$search.prop('disabled', false);
1806				});
1807
1808				container.on('disable', function () {
1809				  self.$search.prop('disabled', true);
1810				});
1811
1812				this.$selection.on('focusin', '.select2-search--inline', function (evt) {
1813				  self.trigger('focus', evt);
1814				});
1815
1816				this.$selection.on('focusout', '.select2-search--inline', function (evt) {
1817				  self.trigger('blur', evt);
1818				});
1819
1820				this.$selection.on('keydown', '.select2-search--inline', function (evt) {
1821				  evt.stopPropagation();
1822
1823				  self.trigger('keypress', evt);
1824
1825				  self._keyUpPrevented = evt.isDefaultPrevented();
1826
1827				  var key = evt.which;
1828
1829					if (key === KEYS.BACKSPACE && self.$search.val() === '') {
1830				  var $previousChoice = self.$searchContainer
1831					.prev('.select2-selection__choice');
1832
1833						if ($previousChoice.length > 0) {
1834								var item = $previousChoice.data('data');
1835
1836								self.searchRemoveChoice(item);
1837
1838								evt.preventDefault();
1839						}
1840					}
1841				});
1842
1843				// Workaround for browsers which do not support the `input` event
1844				// This will prevent double-triggering of events for browsers which support
1845				// both the `keyup` and `input` events.
1846				this.$selection.on('input', '.select2-search--inline', function (evt) {
1847				  // Unbind the duplicated `keyup` event
1848				  self.$selection.off('keyup.search');
1849				});
1850
1851				this.$selection.on('keyup.search input', '.select2-search--inline',
1852				function (evt) {
1853			  self.handleSearch(evt);
1854				});
1855			};
1856
1857		  Search.prototype.createPlaceholder = function (decorated, placeholder) {
1858				this.$search.attr('placeholder', placeholder.text);
1859			};
1860
1861		  Search.prototype.update = function (decorated, data) {
1862				this.$search.attr('placeholder', '');
1863
1864				decorated.call(this, data);
1865
1866				this.$selection.find('.select2-selection__rendered')
1867				   .append(this.$searchContainer);
1868
1869				this.resizeSearch();
1870			};
1871
1872		  Search.prototype.handleSearch = function () {
1873				this.resizeSearch();
1874
1875				if (!this._keyUpPrevented) {
1876				  var input = this.$search.val();
1877
1878				  this.trigger('query', {
1879						term: input
1880				  });
1881				}
1882
1883				this._keyUpPrevented = false;
1884			};
1885
1886		  Search.prototype.searchRemoveChoice = function (decorated, item) {
1887				this.trigger('unselect', {
1888					data: item
1889					});
1890
1891				this.trigger('open');
1892
1893				this.$search.val(item.text + ' ');
1894			};
1895
1896		  Search.prototype.resizeSearch = function () {
1897				this.$search.css('width', '25px');
1898
1899				var width = '';
1900
1901				if (this.$search.attr('placeholder') !== '') {
1902				  width = this.$selection.find('.select2-selection__rendered').innerWidth();
1903				} else {
1904				  var minimumWidth = this.$search.val().length + 1;
1905
1906				  width = (minimumWidth * 0.75) + 'em';
1907				}
1908
1909				this.$search.css('width', width);
1910			};
1911
1912		  return Search;
1913		});
1914
1915		S2.define('select2/selection/eventRelay',[
1916		  'jquery'
1917		], function ($) {
1918			function EventRelay () { }
1919
1920		  EventRelay.prototype.bind = function (decorated, container, $container) {
1921				var self        = this;
1922				var relayEvents = [
1923				'open', 'opening',
1924				'close', 'closing',
1925				'select', 'selecting',
1926				'unselect', 'unselecting'
1927				];
1928
1929				var preventableEvents = ['opening', 'closing', 'selecting', 'unselecting'];
1930
1931				decorated.call(this, container, $container);
1932
1933				container.on('*', function (name, params) {
1934					// Ignore events that should not be relayed
1935					if ($.inArray(name, relayEvents) === -1) {
1936				  return;
1937					}
1938
1939				  // The parameters should always be an object
1940				  params = params || {};
1941
1942				  // Generate the jQuery event for the Select2 event
1943				  var evt = $.Event('select2:' + name, {
1944						params: params
1945						});
1946
1947					self.$element.trigger(evt);
1948
1949					// Only handle preventable events if it was one
1950					if ($.inArray(name, preventableEvents) === -1) {
1951				  return;
1952					}
1953
1954				  params.prevented = evt.isDefaultPrevented();
1955				  });
1956			};
1957
1958		  return EventRelay;
1959		});
1960
1961		S2.define('select2/translation',[
1962		  'jquery',
1963		  'require'
1964		], function ($, require) {
1965			function Translation (dict) {
1966		  this.dict = dict || {};
1967			}
1968
1969		  Translation.prototype.all = function () {
1970				return this.dict;
1971			};
1972
1973		  Translation.prototype.get = function (key) {
1974				return this.dict[key];
1975			};
1976
1977		  Translation.prototype.extend = function (translation) {
1978				this.dict = $.extend({}, translation.all(), this.dict);
1979			};
1980
1981		  // Static functions
1982
1983		  Translation._cache = {};
1984
1985		  Translation.loadPath = function (path) {
1986				if (!(path in Translation._cache)) {
1987				  var translations = require(path);
1988
1989				  Translation._cache[path] = translations;
1990				}
1991
1992				return new Translation(Translation._cache[path]);
1993			};
1994
1995		  return Translation;
1996		});
1997
1998		S2.define('select2/diacritics',[
1999
2000		], function () {

2614				'\u01F9': 'n',
2615				'\u0144': 'n',
2616				'\u00F1': 'n',
2617				'\u1E45': 'n',
2618				'\u0148': 'n',
2619				'\u1E47': 'n',
2620				'\u0146': 'n',
2621				'\u1E4B': 'n',
2622				'\u1E49': 'n',
2623				'\u019E': 'n',
2624				'\u0272': 'n',
2625				'\u0149': 'n',
2626				'\uA791': 'n',
2627				'\uA7A5': 'n',
2628				'\u01CC': 'nj',
2629				'\u24DE': 'o',
2630				'\uFF4F': 'o',
2631				'\u00F2': 'o',
2632				'\u00F3': 'o',
2633				'\u00F4': 'o',
2634				'\u1ED3': 'o',
2635				'\u1ED1': 'o',
2636				'\u1ED7': 'o',
2637				'\u1ED5': 'o',
2638				'\u00F5': 'o',
2639				'\u1E4D': 'o',
2640				'\u022D': 'o',
2641				'\u1E4F': 'o',
2642				'\u014D': 'o',
2643				'\u1E51': 'o',
2644				'\u1E53': 'o',
2645				'\u014F': 'o',
2646				'\u022F': 'o',
2647				'\u0231': 'o',
2648				'\u00F6': 'o',
2649				'\u022B': 'o',
2650				'\u1ECF': 'o',
2651				'\u0151': 'o',
2652				'\u01D2': 'o',
2653				'\u020D': 'o',
2654				'\u020F': 'o',
2655				'\u01A1': 'o',
2656				'\u1EDD': 'o',
2657				'\u1EDB': 'o',
2658				'\u1EE1': 'o',
2659				'\u1EDF': 'o',
2660				'\u1EE3': 'o',
2661				'\u1ECD': 'o',
2662				'\u1ED9': 'o',
2663				'\u01EB': 'o',
2664				'\u01ED': 'o',
2665				'\u00F8': 'o',
2666				'\u01FF': 'o',
2667				'\u0254': 'o',
2668				'\uA74B': 'o',
2669				'\uA74D': 'o',
2670				'\u0275': 'o',
2671				'\u01A3': 'oi',
2672				'\u0223': 'ou',
2673				'\uA74F': 'oo',
2674				'\u24DF': 'p',
2675				'\uFF50': 'p',
2676				'\u1E55': 'p',
2677				'\u1E57': 'p',
2678				'\u01A5': 'p',
2679				'\u1D7D': 'p',
2680				'\uA751': 'p',
2681				'\uA753': 'p',
2682				'\uA755': 'p',
2683				'\u24E0': 'q',
2684				'\uFF51': 'q',
2685				'\u024B': 'q',
2686				'\uA757': 'q',
2687				'\uA759': 'q',
2688				'\u24E1': 'r',
2689				'\uFF52': 'r',
2690				'\u0155': 'r',
2691				'\u1E59': 'r',
2692				'\u0159': 'r',
2693				'\u0211': 'r',
2694				'\u0213': 'r',
2695				'\u1E5B': 'r',
2696				'\u1E5D': 'r',
2697				'\u0157': 'r',
2698				'\u1E5F': 'r',
2699				'\u024D': 'r',
2700				'\u027D': 'r',
2701				'\uA75B': 'r',
2702				'\uA7A7': 'r',
2703				'\uA783': 'r',
2704				'\u24E2': 's',
2705				'\uFF53': 's',
2706				'\u00DF': 's',
2707				'\u015B': 's',
2708				'\u1E65': 's',
2709				'\u015D': 's',
2710				'\u1E61': 's',
2711				'\u0161': 's',
2712				'\u1E67': 's',
2713				'\u1E63': 's',
2714				'\u1E69': 's',
2715				'\u0219': 's',
2716				'\u015F': 's',
2717				'\u023F': 's',
2718				'\uA7A9': 's',
2719				'\uA785': 's',
2720				'\u1E9B': 's',
2721				'\u24E3': 't',
2722				'\uFF54': 't',
2723				'\u1E6B': 't',
2724				'\u1E97': 't',
2725				'\u0165': 't',
2726				'\u1E6D': 't',
2727				'\u021B': 't',
2728				'\u0163': 't',
2729				'\u1E71': 't',
2730				'\u1E6F': 't',
2731				'\u0167': 't',
2732				'\u01AD': 't',
2733				'\u0288': 't',
2734				'\u2C66': 't',
2735				'\uA787': 't',
2736				'\uA729': 'tz',
2737				'\u24E4': 'u',
2738				'\uFF55': 'u',
2739				'\u00F9': 'u',
2740				'\u00FA': 'u',
2741				'\u00FB': 'u',
2742				'\u0169': 'u',
2743				'\u1E79': 'u',
2744				'\u016B': 'u',
2745				'\u1E7B': 'u',
2746				'\u016D': 'u',
2747				'\u00FC': 'u',
2748				'\u01DC': 'u',
2749				'\u01D8': 'u',
2750				'\u01D6': 'u',
2751				'\u01DA': 'u',
2752				'\u1EE7': 'u',
2753				'\u016F': 'u',
2754				'\u0171': 'u',
2755				'\u01D4': 'u',
2756				'\u0215': 'u',
2757				'\u0217': 'u',
2758				'\u01B0': 'u',
2759				'\u1EEB': 'u',
2760				'\u1EE9': 'u',
2761				'\u1EEF': 'u',
2762				'\u1EED': 'u',
2763				'\u1EF1': 'u',
2764				'\u1EE5': 'u',
2765				'\u1E73': 'u',
2766				'\u0173': 'u',
2767				'\u1E77': 'u',
2768				'\u1E75': 'u',
2769				'\u0289': 'u',
2770				'\u24E5': 'v',
2771				'\uFF56': 'v',
2772				'\u1E7D': 'v',
2773				'\u1E7F': 'v',
2774				'\u028B': 'v',
2775				'\uA75F': 'v',
2776				'\u028C': 'v',
2777				'\uA761': 'vy',
2778				'\u24E6': 'w',
2779				'\uFF57': 'w',
2780				'\u1E81': 'w',
2781				'\u1E83': 'w',
2782				'\u0175': 'w',
2783				'\u1E87': 'w',
2784				'\u1E85': 'w',
2785				'\u1E98': 'w',
2786				'\u1E89': 'w',
2787				'\u2C73': 'w',
2788				'\u24E7': 'x',
2789				'\uFF58': 'x',
2790				'\u1E8B': 'x',
2791				'\u1E8D': 'x',
2792				'\u24E8': 'y',
2793				'\uFF59': 'y',
2794				'\u1EF3': 'y',
2795				'\u00FD': 'y',
2796				'\u0177': 'y',
2797				'\u1EF9': 'y',
2798				'\u0233': 'y',
2799				'\u1E8F': 'y',
2800				'\u00FF': 'y',
2801				'\u1EF7': 'y',
2802				'\u1E99': 'y',
2803				'\u1EF5': 'y',
2804				'\u01B4': 'y',
2805				'\u024F': 'y',
2806				'\u1EFF': 'y',
2807				'\u24E9': 'z',
2808				'\uFF5A': 'z',
2809				'\u017A': 'z',
2810				'\u1E91': 'z',
2811				'\u017C': 'z',
2812				'\u017E': 'z',
2813				'\u1E93': 'z',
2814				'\u1E95': 'z',
2815				'\u01B6': 'z',
2816				'\u0225': 'z',
2817				'\u0240': 'z',
2818				'\u2C6C': 'z',
2819				'\uA763': 'z',
2820				'\u0386': '\u0391',
2821				'\u0388': '\u0395',
2822				'\u0389': '\u0397',
2823				'\u038A': '\u0399',
2824				'\u03AA': '\u0399',
2825				'\u038C': '\u039F',
2826				'\u038E': '\u03A5',
2827				'\u03AB': '\u03A5',
2828				'\u038F': '\u03A9',
2829				'\u03AC': '\u03B1',
2830				'\u03AD': '\u03B5',
2831				'\u03AE': '\u03B7',
2832				'\u03AF': '\u03B9',
2833				'\u03CA': '\u03B9',
2834				'\u0390': '\u03B9',
2835				'\u03CC': '\u03BF',
2836				'\u03CD': '\u03C5',
2837				'\u03CB': '\u03C5',
2838				'\u03B0': '\u03C5',
2839				'\u03C9': '\u03C9',
2840				'\u03C2': '\u03C3'
2841			};
2842
2843		  return diacritics;
2844		});
2845
2846		S2.define('select2/data/base',[
2847		  '../utils'
2848		], function (Utils) {
2849			function BaseAdapter ($element, options) {
2850		  BaseAdapter.__super__.constructor.call(this);
2851			}
2852
2853		  Utils.Extend(BaseAdapter, Utils.Observable);
2854
2855		  BaseAdapter.prototype.current = function (callback) {
2856				throw new Error('The `current` method must be defined in child classes.');
2857			};
2858
2859		  BaseAdapter.prototype.query = function (params, callback) {
2860				throw new Error('The `query` method must be defined in child classes.');
2861			};
2862
2863		  BaseAdapter.prototype.bind = function (container, $container) {
2864				// Can be implemented in subclasses
2865			};
2866
2867		  BaseAdapter.prototype.destroy = function () {
2868				// Can be implemented in subclasses
2869			};
2870
2871		  BaseAdapter.prototype.generateResultId = function (container, data) {
2872				var id = container.id + '-result-';
2873
2874				id += Utils.generateChars(4);
2875
2876				if (data.id != null) {
2877				  id += '-' + data.id.toString();
2878				} else {
2879				  id += '-' + Utils.generateChars(4);
2880				}
2881				return id;
2882			};
2883
2884		  return BaseAdapter;
2885		});
2886
2887		S2.define('select2/data/select',[
2888		  './base',
2889		  '../utils',
2890		  'jquery'
2891		], function (BaseAdapter, Utils, $) {
2892			function SelectAdapter ($element, options) {
2893		  this.$element = $element;
2894		  this.options  = options;
2895
2896		  SelectAdapter.__super__.constructor.call(this);
2897			}
2898
2899		  Utils.Extend(SelectAdapter, BaseAdapter);
2900
2901		  SelectAdapter.prototype.current = function (callback) {
2902				var data = [];
2903				var self = this;
2904
2905				this.$element.find(':selected').each(function () {
2906				  var $option = $(this);
2907
2908				  var option = self.item($option);
2909
2910				  data.push(option);
2911				});
2912