https://kawarthalakespharmacy.com/wp-content/plugins/forminator/as…/js/select2.full.js?ver=1.14.6

1/*!
2 * Select2 4.0.5
3 * https://select2.github.io
4 *
5 * Released under the MIT license
6 * https://github.com/select2/select2/blob/master/LICENSE.md
7 *
8 * Modified logic/function,etc besides formatting should be marked with //FUI-SELECT2
9 * For easy debugging process or update upstream of select
10 */
11(function (factory) {
12	// FUI-SELECT2 disable AMD and module exports
13	if (false && typeof define === 'function' && define.amd) {
14		// AMD. Register as an anonymous module.
15		define(['jquery'], factory);
16	} else if (false && typeof module === 'object' && module.exports) {
17		// Node/CommonJS
18		module.exports = function (root, jQuery) {
19			if (jQuery === undefined) {
20				// require('jQuery') returns a factory that requires window to
21				// build a jQuery instance, we normalize how we use modules
22				// that require this pattern but the window provided is a noop
23				// if it's defined (how jquery works)
24				if (typeof window !== 'undefined') {
25					jQuery = require('jquery');
26				}
27				else {
28					jQuery = require('jquery')(root);
29				}
30			}
31			factory(jQuery);
32			return jQuery;
33		};
34	} else {
35		// Browser globals
36		factory(jQuery);
37	}
38} (function (jQuery) {
39	// This is needed so we can catch the AMD loader configuration and use it
40	// The inner file should be wrapped (by `banner.start.js`) in a function that
41	// returns the AMD loader references.
42	var S2 =(function () {
43		// Restore the Select2 AMD loader so it can be used
44		// Needed mostly in the language files, where the loader is not inserted
45		if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) {
46			var S2 = jQuery.fn.select2.amd;
47		}
48		var S2;(function () { if (!S2 || !S2.requirejs) {
49			if (!S2) { S2 = {}; } else { require = S2; }
50			/**
51			 * @license almond 0.3.3 Copyright jQuery Foundation and other contributors.
52			 * Released under MIT license, http://github.com/requirejs/almond/LICENSE
53			 */
54//Going sloppy to avoid 'use strict' string cost, but strict practices should
55//be followed.
56			/*global setTimeout: false */
57
58			var requirejs, require, define;
59			(function (undef) {
60				var main, req, makeMap, handlers,
61					defined = {},
62					waiting = {},
63					config = {},
64					defining = {},
65					hasOwn = Object.prototype.hasOwnProperty,
66					aps = [].slice,
67					jsSuffixRegExp = /\.js$/;
68
69				function hasProp(obj, prop) {
70					return hasOwn.call(obj, prop);
71				}
72
73				/**
74				 * Given a relative module name, like ./something, normalize it to
75				 * a real name that can be mapped to a path.
76				 * @param {String} name the relative name
77				 * @param {String} baseName a real name that the name arg is relative
78				 * to.
79				 * @returns {String} normalized name
80				 */
81				function normalize(name, baseName) {
82					var nameParts, nameSegment, mapValue, foundMap, lastIndex,
83						foundI, foundStarMap, starI, i, j, part, normalizedBaseParts,
84						baseParts = baseName && baseName.split("/"),
85						map = config.map,
86						starMap = (map && map['*']) || {};
87
88					//Adjust any relative paths.
89					if (name) {
90						name = name.split('/');
91						lastIndex = name.length - 1;
92
93						// If wanting node ID compatibility, strip .js from end
94						// of IDs. Have to do this here, and not in nameToUrl
95						// because node allows either .js or non .js to map
96						// to same file.
97						if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
98							name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
99						}
100
101						// Starts with a '.' so need the baseName
102						if (name[0].charAt(0) === '.' && baseParts) {
103							//Convert baseName to array, and lop off the last part,
104							//so that . matches that 'directory' and not name of the baseName's
105							//module. For instance, baseName of 'one/two/three', maps to
106							//'one/two/three.js', but we want the directory, 'one/two' for
107							//this normalization.
108							normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
109							name = normalizedBaseParts.concat(name);
110						}
111
112						//start trimDots
113						for (i = 0; i < name.length; i++) {
114							part = name[i];
115							if (part === '.') {
116								name.splice(i, 1);
117								i -= 1;
118							} else if (part === '..') {
119								// If at the start, or previous value is still ..,
120								// keep them so that when converted to a path it may
121								// still work when converted to a path, even though
122								// as an ID it is less than ideal. In larger point
123								// releases, may be better to just kick out an error.
124								if (i === 0 || (i === 1 && name[2] === '..') || name[i - 1] === '..') {
125									continue;
126								} else if (i > 0) {
127									name.splice(i - 1, 2);
128									i -= 2;
129								}
130							}
131						}
132						//end trimDots
133
134						name = name.join('/');
135					}
136
137					//Apply map config if available.
138					if ((baseParts || starMap) && map) {
139						nameParts = name.split('/');
140
141						for (i = nameParts.length; i > 0; i -= 1) {
142							nameSegment = nameParts.slice(0, i).join("/");
143
144							if (baseParts) {
145								//Find the longest baseName segment match in the config.
146								//So, do joins on the biggest to smallest lengths of baseParts.
147								for (j = baseParts.length; j > 0; j -= 1) {
148									mapValue = map[baseParts.slice(0, j).join('/')];
149
150									//baseName segment has  config, find if it has one for
151									//this name.
152									if (mapValue) {
153										mapValue = mapValue[nameSegment];
154										if (mapValue) {
155											//Match, update name to the new value.
156											foundMap = mapValue;
157											foundI = i;
158											break;
159										}
160									}
161								}
162							}
163
164							if (foundMap) {
165								break;
166							}
167
168							//Check for a star map match, but just hold on to it,
169							//if there is a shorter segment match later in a matching
170							//config, then favor over this star map.
171							if (!foundStarMap && starMap && starMap[nameSegment]) {
172								foundStarMap = starMap[nameSegment];
173								starI = i;
174							}
175						}
176
177						if (!foundMap && foundStarMap) {
178							foundMap = foundStarMap;
179							foundI = starI;
180						}
181
182						if (foundMap) {
183							nameParts.splice(0, foundI, foundMap);
184							name = nameParts.join('/');
185						}
186					}
187
188					return name;
189				}
190
191				function makeRequire(relName, forceSync) {
192					return function () {
193						//A version of a require function that passes a moduleName
194						//value for items that may need to
195						//look up paths relative to the moduleName
196						var args = aps.call(arguments, 0);
197
198						//If first arg is not require('string'), and there is only
199						//one arg, it is the array form without a callback. Insert
200						//a null so that the following concat is correct.
201						if (typeof args[0] !== 'string' && args.length === 1) {
202							args.push(null);
203						}
204						return req.apply(undef, args.concat([relName, forceSync]));
205					};
206				}
207
208				function makeNormalize(relName) {
209					return function (name) {
210						return normalize(name, relName);
211					};
212				}
213
214				function makeLoad(depName) {
215					return function (value) {
216						defined[depName] = value;
217					};
218				}
219
220				function callDep(name) {
221					if (hasProp(waiting, name)) {
222						var args = waiting[name];
223						delete waiting[name];
224						defining[name] = true;
225						main.apply(undef, args);
226					}
227
228					if (!hasProp(defined, name) && !hasProp(defining, name)) {
229						throw new Error('No ' + name);
230					}
231					return defined[name];
232				}
233
234				//Turns a plugin!resource to [plugin, resource]
235				//with the plugin being undefined if the name
236				//did not have a plugin prefix.
237				function splitPrefix(name) {
238					var prefix,
239						index = name ? name.indexOf('!') : -1;
240					if (index > -1) {
241						prefix = name.substring(0, index);
242						name = name.substring(index + 1, name.length);
243					}
244					return [prefix, name];
245				}
246
247				//Creates a parts array for a relName where first part is plugin ID,
248				//second part is resource ID. Assumes relName has already been normalized.
249				function makeRelParts(relName) {
250					return relName ? splitPrefix(relName) : [];
251				}
252
253				/**
254				 * Makes a name map, normalizing the name, and using a plugin
255				 * for normalization if necessary. Grabs a ref to plugin
256				 * too, as an optimization.
257				 */
258				makeMap = function (name, relParts) {
259					var plugin,
260						parts = splitPrefix(name),
261						prefix = parts[0],
262						relResourceName = relParts[1];
263
264					name = parts[1];
265
266					if (prefix) {
267						prefix = normalize(prefix, relResourceName);
268						plugin = callDep(prefix);
269					}
270
271					//Normalize according
272					if (prefix) {
273						if (plugin && plugin.normalize) {
274							name = plugin.normalize(name, makeNormalize(relResourceName));
275						} else {
276							name = normalize(name, relResourceName);
277						}
278					} else {
279						name = normalize(name, relResourceName);
280						parts = splitPrefix(name);
281						prefix = parts[0];
282						name = parts[1];
283						if (prefix) {
284							plugin = callDep(prefix);
285						}
286					}
287
288					//Using ridiculous property names for space reasons
289					return {
290						f: prefix ? prefix + '!' + name : name, //fullName
291						n: name,
292						pr: prefix,
293						p: plugin
294					};
295				};
296
297				function makeConfig(name) {
298					return function () {
299						return (config && config.config && config.config[name]) || {};
300					};
301				}
302
303				handlers = {
304					require: function (name) {
305						return makeRequire(name);
306					},
307					exports: function (name) {
308						var e = defined[name];
309						if (typeof e !== 'undefined') {
310							return e;
311						} else {
312							return (defined[name] = {});
313						}
314					},
315					module: function (name) {
316						return {
317							id: name,
318							uri: '',
319							exports: defined[name],
320							config: makeConfig(name)
321						};
322					}
323				};
324
325				main = function (name, deps, callback, relName) {
326					var cjsModule, depName, ret, map, i, relParts,
327						args = [],
328						callbackType = typeof callback,
329						usingExports;
330
331					//Use name if no relName
332					relName = relName || name;
333					relParts = makeRelParts(relName);
334
335					//Call the callback to define the module, if necessary.
336					if (callbackType === 'undefined' || callbackType === 'function') {
337						//Pull out the defined dependencies and pass the ordered
338						//values to the callback.
339						//Default to [require, exports, module] if no deps
340						deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
341						for (i = 0; i < deps.length; i += 1) {
342							map = makeMap(deps[i], relParts);
343							depName = map.f;
344
345							//Fast path CommonJS standard dependencies.
346							if (depName === "require") {
347								args[i] = handlers.require(name);
348							} else if (depName === "exports") {
349								//CommonJS module spec 1.1
350								args[i] = handlers.exports(name);
351								usingExports = true;
352							} else if (depName === "module") {
353								//CommonJS module spec 1.1
354								cjsModule = args[i] = handlers.module(name);
355							} else if (hasProp(defined, depName) ||
356									   hasProp(waiting, depName) ||
357									   hasProp(defining, depName)) {
358								args[i] = callDep(depName);
359							} else if (map.p) {
360								map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
361								args[i] = defined[depName];
362							} else {
363								throw new Error(name + ' missing ' + depName);
364							}
365						}
366
367						ret = callback ? callback.apply(defined[name], args) : undefined;
368
369						if (name) {
370							//If setting exports via "module" is in play,
371							//favor that over return value and exports. After that,
372							//favor a non-undefined return value over exports use.
373							if (cjsModule && cjsModule.exports !== undef &&
374								cjsModule.exports !== defined[name]) {
375								defined[name] = cjsModule.exports;
376							} else if (ret !== undef || !usingExports) {
377								//Use the return value from the function.
378								defined[name] = ret;
379							}
380						}
381					} else if (name) {
382						//May just be an object definition for the module. Only
383						//worry about defining if have a module name.
384						defined[name] = callback;
385					}
386				};
387
388				requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
389					if (typeof deps === "string") {
390						if (handlers[deps]) {
391							//callback in this case is really relName
392							return handlers[deps](callback);
393						}
394						//Just return the module wanted. In this scenario, the
395						//deps arg is the module name, and second arg (if passed)
396						//is just the relName.
397						//Normalize module name, if it contains . or ..
398						return callDep(makeMap(deps, makeRelParts(callback)).f);
399					} else if (!deps.splice) {
400						//deps is a config object, not an array.

401						config = deps;
402						if (config.deps) {
403							req(config.deps, config.callback);
404						}
405						if (!callback) {
406							return;
407						}
408
409						if (callback.splice) {
410							//callback is an array, which means it is a dependency list.
411							//Adjust args if there are dependencies
412							deps = callback;
413							callback = relName;
414							relName = null;
415						} else {
416							deps = undef;
417						}
418					}
419
420					//Support require(['a'])
421					callback = callback || function () {};
422
423					//If relName is a function, it is an errback handler,
424					//so remove it.
425					if (typeof relName === 'function') {
426						relName = forceSync;
427						forceSync = alt;
428					}
429
430					//Simulate async callback;
431					if (forceSync) {
432						main(undef, deps, callback, relName);
433					} else {
434						//Using a non-zero value because of concern for what old browsers
435						//do, and latest browsers "upgrade" to 4 if lower value is used:
436						//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
437						//If want a value immediately, use require('id') instead -- something
438						//that works in almond on the global level, but not guaranteed and
439						//unlikely to work in other AMD implementations.
440						setTimeout(function () {
441							main(undef, deps, callback, relName);
442						}, 4);
443					}
444
445					return req;
446				};
447
448				/**
449				 * Just drops the config on the floor, but returns req in case
450				 * the config return value is used.
451				 */
452				req.config = function (cfg) {
453					return req(cfg);
454				};
455
456				/**
457				 * Expose module registry for debugging and tooling
458				 */
459				requirejs._defined = defined;
460
461				define = function (name, deps, callback) {
462					if (typeof name !== 'string') {
463						throw new Error('See almond README: incorrect module build, no module name');
464					}
465
466					//This module may not have dependencies
467					if (!deps.splice) {
468						//deps is not an array, so probably means
469						//an object literal or factory function for
470						//the value. Adjust args.
471						callback = deps;
472						deps = [];
473					}
474
475					if (!hasProp(defined, name) && !hasProp(waiting, name)) {
476						waiting[name] = [name, deps, callback];
477					}
478				};
479
480				define.amd = {
481					jQuery: true
482				};
483			}());
484
485			S2.requirejs = requirejs;S2.require = require;S2.define = define;
486		}
487		}());
488		S2.define("almond", function(){});
489
490		/* global jQuery:false, $:false */
491		S2.define('jquery',[],function () {
492			var _$ = jQuery || $;
493
494			if (_$ == null && console && console.error) {
495				console.error(
496					'Select2: An instance of jQuery or a jQuery-compatible library was not ' +
497					'found. Make sure that you are including jQuery before Select2 on your ' +
498					'web page.'
499				);
500			}
501
502			return _$;
503		});
504
505		S2.define('select2/utils',[
506			'jquery'
507		], function ($) {
508			var Utils = {};
509
510			Utils.Extend = function (ChildClass, SuperClass) {
511				var __hasProp = {}.hasOwnProperty;
512
513				function BaseConstructor () {
514					this.constructor = ChildClass;
515				}
516
517				for (var key in SuperClass) {
518					if (__hasProp.call(SuperClass, key)) {
519						ChildClass[key] = SuperClass[key];
520					}
521				}
522
523				BaseConstructor.prototype = SuperClass.prototype;
524				ChildClass.prototype = new BaseConstructor();
525				ChildClass.__super__ = SuperClass.prototype;
526
527				return ChildClass;
528			};
529
530			function getMethods (theClass) {
531				var proto = theClass.prototype;
532
533				var methods = [];
534
535				for (var methodName in proto) {
536					var m = proto[methodName];
537
538					if (typeof m !== 'function') {
539						continue;
540					}
541
542					if (methodName === 'constructor') {
543						continue;
544					}
545
546					methods.push(methodName);
547				}
548
549				return methods;
550			}
551
552			Utils.Decorate = function (SuperClass, DecoratorClass) {
553				var decoratedMethods = getMethods(DecoratorClass);
554				var superMethods = getMethods(SuperClass);
555
556				function DecoratedClass () {
557					var unshift = Array.prototype.unshift;
558
559					var argCount = DecoratorClass.prototype.constructor.length;
560
561					var calledConstructor = SuperClass.prototype.constructor;
562
563					if (argCount > 0) {
564						unshift.call(arguments, SuperClass.prototype.constructor);
565
566						calledConstructor = DecoratorClass.prototype.constructor;
567					}
568
569					calledConstructor.apply(this, arguments);
570				}
571
572				DecoratorClass.displayName = SuperClass.displayName;
573
574				function ctr () {
575					this.constructor = DecoratedClass;
576				}
577
578				DecoratedClass.prototype = new ctr();
579
580				for (var m = 0; m < superMethods.length; m++) {
581					var superMethod = superMethods[m];
582
583					DecoratedClass.prototype[superMethod] =
584						SuperClass.prototype[superMethod];
585				}
586
587				var calledMethod = function (methodName) {
588					// Stub out the original method if it's not decorating an actual method
589					var originalMethod = function () {};
590
591					if (methodName in DecoratedClass.prototype) {
592						originalMethod = DecoratedClass.prototype[methodName];
593					}
594
595					var decoratedMethod = DecoratorClass.prototype[methodName];
596
597					return function () {
598						var unshift = Array.prototype.unshift;
599
600						unshift.call(arguments, originalMethod);
601
602						return decoratedMethod.apply(this, arguments);
603					};
604				};
605
606				for (var d = 0; d < decoratedMethods.length; d++) {
607					var decoratedMethod = decoratedMethods[d];
608
609					DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod);
610				}
611
612				return DecoratedClass;
613			};
614
615			var Observable = function () {
616				this.listeners = {};
617			};
618
619			Observable.prototype.on = function (event, callback) {
620				this.listeners = this.listeners || {};
621
622				if (event in this.listeners) {
623					this.listeners[event].push(callback);
624				} else {
625					this.listeners[event] = [callback];
626				}
627			};
628
629			Observable.prototype.trigger = function (event) {
630				var slice = Array.prototype.slice;
631				var params = slice.call(arguments, 1);
632
633				this.listeners = this.listeners || {};
634
635				// Params should always come in as an array
636				if (params == null) {
637					params = [];
638				}
639
640				// If there are no arguments to the event, use a temporary object
641				if (params.length === 0) {
642					params.push({});
643				}
644
645				// Set the `_type` of the first object to the event
646				params[0]._type = event;
647
648				if (event in this.listeners) {
649					this.invoke(this.listeners[event], slice.call(arguments, 1));
650				}
651
652				if ('*' in this.listeners) {
653					this.invoke(this.listeners['*'], arguments);
654				}
655			};
656
657			Observable.prototype.invoke = function (listeners, params) {
658				for (var i = 0, len = listeners.length; i < len; i++) {
659					listeners[i].apply(this, params);
660				}
661			};
662
663			Utils.Observable = Observable;
664
665			Utils.generateChars = function (length) {
666				var chars = '';
667
668				for (var i = 0; i < length; i++) {
669					var randomChar = Math.floor(Math.random() * 36);
670					chars += randomChar.toString(36);
671				}
672
673				return chars;
674			};
675
676			Utils.bind = function (func, context) {
677				return function () {
678					func.apply(context, arguments);
679				};
680			};
681
682			Utils._convertData = function (data) {
683				for (var originalKey in data) {
684					var keys = originalKey.split('-');
685
686					var dataLevel = data;
687
688					if (keys.length === 1) {
689						continue;
690					}
691
692					for (var k = 0; k < keys.length; k++) {
693						var key = keys[k];
694
695						// Lowercase the first letter
696						// By default, dash-separated becomes camelCase
697						key = key.substring(0, 1).toLowerCase() + key.substring(1);
698
699						if (!(key in dataLevel)) {
700							dataLevel[key] = {};
701						}
702
703						if (k == keys.length - 1) {
704							dataLevel[key] = data[originalKey];
705						}
706
707						dataLevel = dataLevel[key];
708					}
709
710					delete data[originalKey];
711				}
712
713				return data;
714			};
715
716			Utils.hasScroll = function (index, el) {
717				// Adapted from the function created by @ShadowScripter
718				// and adapted by @BillBarry on the Stack Exchange Code Review website.
719				// The original code can be found at
720				// http://codereview.stackexchange.com/q/13338
721				// and was designed to be used with the Sizzle selector engine.
722
723				var $el = $(el);
724				var overflowX = el.style.overflowX;
725				var overflowY = el.style.overflowY;
726
727				//Check both x and y declarations
728				if (overflowX === overflowY &&
729					(overflowY === 'hidden' || overflowY === 'visible')) {
730					return false;
731				}
732
733				if (overflowX === 'scroll' || overflowY === 'scroll') {
734					return true;
735				}
736
737				return ($el.innerHeight() < el.scrollHeight ||
738						$el.innerWidth() < el.scrollWidth);
739			};
740
741			Utils.escapeMarkup = function (markup) {
742				var replaceMap = {
743					'\\': '&#92;',
744					'&': '&amp;',
745					'<': '&lt;',
746					'>': '&gt;',
747					'"': '&quot;',
748					'\'': '&#39;',
749					'/': '&#47;'
750				};
751
752				// Do not try to escape the markup if it's not a string
753				if (typeof markup !== 'string') {
754					return markup;
755				}
756
757				return String(markup).replace(/[&<>"'\/\\]/g, function (match) {
758					return replaceMap[match];
759				});
760			};
761
762			// Append an array of jQuery nodes to a given element.
763			Utils.appendMany = function ($element, $nodes) {
764				// jQuery 1.7.x does not support $.fn.append() with an array
765				// Fall back to a jQuery object collection using $.fn.add()
766				if ($.fn.jquery.substr(0, 3) === '1.7') {
767					var $jqNodes = $();
768
769					$.map($nodes, function (node) {
770						$jqNodes = $jqNodes.add(node);
771					});
772
773					$nodes = $jqNodes;
774				}
775
776				$element.append($nodes);
777			};
778
779			return Utils;
780		});
781
782		S2.define('select2/results',[
783			'jquery',
784			'./utils'
785		], function ($, Utils) {
786			function Results ($element, options, dataAdapter) {
787				this.$element = $element;
788				this.data = dataAdapter;
789				this.options = options;
790
791				Results.__super__.constructor.call(this);
792			}
793
794			Utils.Extend(Results, Utils.Observable);
795
796			Results.prototype.render = function () {
797				var $results = $(
798					'<ul class="select2-results__options" role="tree"></ul>'
799				);
800
801				if (this.options.get('multiple')) {
802					$results.attr('aria-multiselectable', 'true');
803				}
804
805				this.$results = $results;
806
807				return $results;
808			};
809
810			Results.prototype.clear = function () {
811				this.$results.empty();
812			};
813
814			Results.prototype.displayMessage = function (params) {
815				var escapeMarkup = this.options.get('escapeMarkup');
816
817				this.clear();
818				this.hideLoading();
819
820				var $message = $(
821					'<li role="treeitem" aria-live="assertive"' +
822					' class="select2-results__option"></li>'
823				);
824
825				var message = this.options.get('translations').get(params.message);
826
827				$message.append(
828					escapeMarkup(
829						message(params.args)
830					)
831				);
832
833				$message[0].className += ' select2-results__message';
834
835				this.$results.append($message);
836			};
837
838			Results.prototype.hideMessages = function () {
839				this.$results.find('.select2-results__message').remove();
840			};
841
842			Results.prototype.append = function (data) {
843				this.hideLoading();
844
845				var $options = [];
846
847				if (data.results == null || data.results.length === 0) {
848					if (this.$results.children().length === 0) {
849						this.trigger('results:message', {
850							message: 'noResults'
851						});
852					}
853
854					return;
855				}
856
857				data.results = this.sort(data.results);
858
859				for (var d = 0; d < data.results.length; d++) {
860					var item = data.results[d];
861
862					var $option = this.option(item);
863
864					$options.push($option);
865				}
866
867				this.$results.append($options);
868			};
869
870			Results.prototype.position = function ($results, $dropdown) {
871				var $resultsContainer = $dropdown.find('.select2-results');
872				$resultsContainer.append($results);
873			};
874
875			Results.prototype.sort = function (data) {
876				var sorter = this.options.get('sorter');
877
878				return sorter(data);
879			};
880
881			Results.prototype.highlightFirstItem = function () {
882				var $options = this.$results
883								   .find('.select2-results__option[aria-selected]');
884
885				var $selected = $options.filter('[aria-selected=true]');
886
887				// Check if there are any selected options
888				if ($selected.length > 0) {
889					// If there are selected options, highlight the first
890					$selected.first().trigger('mouseenter');
891				} else {
892					// If there are no selected options, highlight the first option
893					// in the dropdown
894					$options.first().trigger('mouseenter');
895				}
896
897				this.ensureHighlightVisible();
898			};
899
900			Results.prototype.setClasses = function () {
901				var self = this;
902
903				this.data.current(function (selected) {
904					var selectedIds = $.map(selected, function (s) {
905						return s.id.toString();
906					});
907
908					var $options = self.$results
909									   .find('.select2-results__option[aria-selected]');
910
911					$options.each(function () {
912						var $option = $(this);
913
914						var item = $.data(this, 'data');
915
916						// id needs to be converted to a string when comparing
917						var id = '' + item.id;
918
919						if ((item.element != null && item.element.selected) ||
920							(item.element == null && $.inArray(id, selectedIds) > -1)) {
921							$option.attr('aria-selected', 'true');
922						} else {
923							$option.attr('aria-selected', 'false');
924						}
925					});
926
927				});
928			};
929
930			Results.prototype.showLoading = function (params) {
931				this.hideLoading();
932
933				var loadingMore = this.options.get('translations').get('searching');
934
935				var loading = {
936					disabled: true,
937					loading: true,
938					text: loadingMore(params)
939				};
940				var $loading = this.option(loading);
941				$loading.className += ' loading-results';
942
943				this.$results.prepend($loading);
944			};
945
946			Results.prototype.hideLoading = function () {
947				this.$results.find('.loading-results').remove();
948			};
949
950			Results.prototype.option = function (data) {
951				var option = document.createElement('li');
952				option.className = 'select2-results__option';
953
954				var attrs = {
955					'role': 'treeitem',
956					'aria-selected': 'false'
957				};
958
959				if (data.disabled) {
960					delete attrs['aria-selected'];
961					attrs['aria-disabled'] = 'true';
962				}
963
964				if (data.id == null) {
965					delete attrs['aria-selected'];
966				}
967
968				if (data._resultId != null) {
969					option.id = data._resultId;
970				}
971
972				if (data.title) {
973					option.title = data.title;
974				}
975
976				if (data.children) {
977					attrs.role = 'group';
978					attrs['aria-label'] = data.text;
979					delete attrs['aria-selected'];
980				}
981
982				for (var attr in attrs) {
983					var val = attrs[attr];
984
985					option.setAttribute(attr, val);
986				}
987
988				if (data.children) {
989					var $option = $(option);
990
991					var label = document.createElement('strong');
992					label.className = 'select2-results__group';
993
994					var $label = $(label);
995					this.template(data, label);
996
997					var $children = [];
998
999					for (var c = 0; c < data.children.length; c++) {
1000						var child = data.children[c];
1001
1002						var $child = this.option(child);
1003
1004						$children.push($child);
1005					}
1006
1007					var $childrenContainer = $('<ul></ul>', {
1008						'class': 'select2-results__options select2-results__options--nested'
1009					});
1010
1011					$childrenContainer.append($children);
1012
1013					$option.append(label);
1014					$option.append($childrenContainer);
1015				} else {
1016					this.template(data, option);
1017				}
1018
1019				$.data(option, 'data', data);
1020
1021				return option;
1022			};
1023
1024			Results.prototype.bind = function (container, $container) {
1025				var self = this;
1026
1027				var id = container.id + '-results';
1028
1029				this.$results.attr('id', id);
1030
1031				container.on('results:all', function (params) {
1032					self.clear();
1033					self.append(params.data);
1034
1035					if (container.isOpen()) {
1036						self.setClasses();
1037						self.highlightFirstItem();
1038					}
1039				});
1040
1041				container.on('results:append', function (params) {
1042					self.append(params.data);
1043
1044					if (container.isOpen()) {
1045						self.setClasses();
1046					}
1047				});
1048
1049				container.on('query', function (params) {
1050					self.hideMessages();
1051					self.showLoading(params);
1052				});
1053
1054				container.on('select', function () {
1055					if (!container.isOpen()) {
1056						return;
1057					}
1058
1059					self.setClasses();
1060					self.highlightFirstItem();
1061				});
1062
1063				container.on('unselect', function () {
1064					if (!container.isOpen()) {
1065						return;
1066					}
1067
1068					self.setClasses();
1069					self.highlightFirstItem();
1070				});
1071
1072				container.on('open', function () {
1073					// When the dropdown is open, aria-expended="true"
1074					self.$results.attr('aria-expanded', 'true');
1075					self.$results.attr('aria-hidden', 'false');
1076
1077					self.setClasses();
1078					self.ensureHighlightVisible();
1079				});
1080
1081				container.on('close', function () {
1082					// When the dropdown is closed, aria-expended="false"
1083					self.$results.attr('aria-expanded', 'false');
1084					self.$results.attr('aria-hidden', 'true');
1085					self.$results.removeAttr('aria-activedescendant');
1086				});
1087
1088				container.on('results:toggle', function () {
1089					var $highlighted = self.getHighlightedResults();
1090
1091					if ($highlighted.length === 0) {
1092						return;
1093					}
1094
1095					$highlighted.trigger('mouseup');
1096				});
1097
1098				container.on('results:select', function () {
1099					var $highlighted = self.getHighlightedResults();
1100
1101					if ($highlighted.length === 0) {
1102						return;
1103					}
1104
1105					var data = $highlighted.data('data');
1106
1107					if ($highlighted.attr('aria-selected') == 'true') {
1108						self.trigger('close', {});
1109					} else {
1110						self.trigger('select', {
1111							data: data
1112						});
1113					}
1114				});
1115
1116				container.on('results:previous', function () {
1117					var $highlighted = self.getHighlightedResults();
1118
1119					var $options = self.$results.find('[aria-selected]');
1120
1121					var currentIndex = $options.index($highlighted);
1122
1123					// If we are already at te top, don't move further
1124					if (currentIndex === 0) {
1125						return;
1126					}
1127
1128					var nextIndex = currentIndex - 1;
1129
1130					// If none are highlighted, highlight the first
1131					if ($highlighted.length === 0) {
1132						nextIndex = 0;
1133					}
1134
1135					var $next = $options.eq(nextIndex);
1136
1137					$next.trigger('mouseenter');
1138
1139					var currentOffset = self.$results.offset().top;
1140					var nextTop = $next.offset().top;
1141					var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset);
1142
1143					if (nextIndex === 0) {
1144						self.$results.scrollTop(0);
1145					} else if (nextTop - currentOffset < 0) {
1146						self.$results.scrollTop(nextOffset);
1147					}
1148				});
1149
1150				container.on('results:next', function () {
1151					var $highlighted = self.getHighlightedResults();
1152
1153					var $options = self.$results.find('[aria-selected]');
1154
1155					var currentIndex = $options.index($highlighted);
1156
1157					var nextIndex = currentIndex + 1;
1158
1159					// If we are at the last option, stay there
1160					if (nextIndex >= $options.length) {
1161						return;
1162					}
1163
1164					var $next = $options.eq(nextIndex);
1165
1166					$next.trigger('mouseenter');
1167
1168					var currentOffset = self.$results.offset().top +
1169										self.$results.outerHeight(false);
1170					var nextBottom = $next.offset().top + $next.outerHeight(false);
1171					var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset;
1172
1173					if (nextIndex === 0) {
1174						self.$results.scrollTop(0);
1175					} else if (nextBottom > currentOffset) {
1176						self.$results.scrollTop(nextOffset);
1177					}
1178				});
1179
1180				container.on('results:focus', function (params) {
1181					params.element.addClass('select2-results__option--highlighted');
1182				});
1183
1184				container.on('results:message', function (params) {
1185					self.displayMessage(params);
1186				});
1187
1188				if ($.fn.mousewheel) {
1189					this.$results.on('mousewheel', function (e) {
1190						var top = self.$results.scrollTop();
1191
1192						var bottom = self.$results.get(0).scrollHeight - top + e.deltaY;
1193
1194						var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0;
1195						var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height();
1196
1197						if (isAtTop) {
1198							self.$results.scrollTop(0);
1199
1200							e.preventDefault();
1201							e.stopPropagation();
1202						} else if (isAtBottom) {
1203							self.$results.scrollTop(
1204								self.$results.get(0).scrollHeight - self.$results.height()
1205							);
1206
1207							e.preventDefault();
1208							e.stopPropagation();
1209						}
1210					});
1211				}
1212
1213				this.$results.on('mouseup', '.select2-results__option[aria-selected]',
1214					function (evt) {
1215						var $this = $(this);
1216
1217						var data = $this.data('data');
1218
1219						if ($this.attr('aria-selected') === 'true') {
1220							if (self.options.get('multiple')) {
1221								self.trigger('unselect', {
1222									originalEvent: evt,
1223									data: data
1224								});
1225							} else {
1226								self.trigger('close', {});
1227							}
1228
1229							return;
1230						}
1231
1232						self.trigger('select', {
1233							originalEvent: evt,
1234							data: data
1235						});
1236					});
1237
1238				this.$results.on('mouseenter', '.select2-results__option[aria-selected]',
1239					function (evt) {
1240						var data = $(this).data('data');
1241
1242						self.getHighlightedResults()
1243							.removeClass('select2-results__option--highlighted');
1244
1245						self.trigger('results:focus', {
1246							data: data,
1247							element: $(this)
1248						});
1249					});
1250			};
1251
1252			Results.prototype.getHighlightedResults = function () {
1253				var $highlighted = this.$results
1254									   .find('.select2-results__option--highlighted');
1255
1256				return $highlighted;
1257			};
1258
1259			Results.prototype.destroy = function () {
1260				this.$results.remove();
1261			};
1262
1263			Results.prototype.ensureHighlightVisible = function () {
1264				var $highlighted = this.getHighlightedResults();
1265
1266				if ($highlighted.length === 0) {
1267					return;
1268				}
1269
1270				var $options = this.$results.find('[aria-selected]');
1271
1272				var currentIndex = $options.index($highlighted);
1273
1274				var currentOffset = this.$results.offset().top;
1275				var nextTop = $highlighted.offset().top;
1276				var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset);
1277
1278				var offsetDelta = nextTop - currentOffset;
1279				nextOffset -= $highlighted.outerHeight(false) * 2;
1280
1281				if (currentIndex <= 2) {
1282					this.$results.scrollTop(0);
1283				} else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) {
1284					this.$results.scrollTop(nextOffset);
1285				}
1286			};
1287
1288			Results.prototype.template = function (result, container) {
1289				var template = this.options.get('templateResult');
1290				var escapeMarkup = this.options.get('escapeMarkup');
1291
1292				var content = template(result, container);
1293
1294				if (content == null) {
1295					container.style.display = 'none';
1296				} else if (typeof content === 'string') {
1297					container.innerHTML = escapeMarkup(content);
1298				} else {
1299					$(container).append(content);
1300				}
1301			};
1302
1303			return Results;
1304		});
1305
1306		S2.define('select2/keys',[
1307
1308		], function () {
1309			var KEYS = {
1310				BACKSPACE: 8,
1311				TAB: 9,
1312				ENTER: 13,
1313				SHIFT: 16,
1314				CTRL: 17,
1315				ALT: 18,
1316				ESC: 27,
1317				SPACE: 32,
1318				PAGE_UP: 33,
1319				PAGE_DOWN: 34,
1320				END: 35,
1321				HOME: 36,
1322				LEFT: 37,
1323				UP: 38,
1324				RIGHT: 39,
1325				DOWN: 40,
1326				DELETE: 46
1327			};
1328
1329			return KEYS;
1330		});
1331
1332		S2.define('select2/selection/base',[
1333			'jquery',
1334			'../utils',
1335			'../keys'
1336		], function ($, Utils, KEYS) {
1337			function BaseSelection ($element, options) {
1338				this.$element = $element;
1339				this.options = options;
1340
1341				BaseSelection.__super__.constructor.call(this);
1342			}
1343
1344			Utils.Extend(BaseSelection, Utils.Observable);
1345
1346			BaseSelection.prototype.render = function () {
1347				var $selection = $(
1348					'<span class="select2-selection" role="combobox" ' +
1349					' aria-haspopup="true" aria-expanded="false">' +
1350					'</span>'
1351				);
1352
1353				this._tabindex = 0;
1354
1355				if (this.$element.data('old-tabindex') != null) {
1356					this._tabindex = this.$element.data('old-tabindex');
1357				} else if (this.$element.attr('tabindex') != null) {
1358					this._tabindex = this.$element.attr('tabindex');
1359				}
1360
1361				$selection.attr('title', this.$element.attr('title'));
1362				$selection.attr('tabindex', this._tabindex);
1363
1364				this.$selection = $selection;
1365
1366				return $selection;
1367			};
1368
1369			BaseSelection.prototype.bind = function (container, $container) {
1370				var self = this;
1371
1372				var id = container.id + '-container';
1373				var resultsId = container.id + '-results';
1374
1375				this.container = container;
1376
1377				this.$selection.on('focus', function (evt) {
1378					self.trigger('focus', evt);
1379				});
1380
1381				this.$selection.on('blur', function (evt) {
1382					self._handleBlur(evt);
1383				});
1384
1385				this.$selection.on('keydown', function (evt) {
1386					self.trigger('keypress', evt);
1387
1388					if (evt.which === KEYS.SPACE) {
1389						evt.preventDefault();
1390					}
1391				});
1392
1393				container.on('results:focus', function (params) {
1394					self.$selection.attr('aria-activedescendant', params.data._resultId);
1395				});
1396
1397				container.on('selection:update', function (params) {
1398					self.update(params.data);
1399				});
1400
1401				container.on('open', function () {
1402					// When the dropdown is open, aria-expanded="true"
1403					self.$selection.attr('aria-expanded', 'true');
1404					self.$selection.attr('aria-owns', resultsId);
1405
1406					self._attachCloseHandler(container);
1407				});
1408
1409				container.on('close', function () {
1410					// When the dropdown is closed, aria-expanded="false"
1411					self.$selection.attr('aria-expanded', 'false');
1412					self.$selection.removeAttr('aria-activedescendant');
1413					self.$selection.removeAttr('aria-owns');
1414
1415					self.$selection.focus();
1416
1417					self._detachCloseHandler(container);
1418				});
1419
1420				container.on('enable', function () {
1421					self.$selection.attr('tabindex', self._tabindex);
1422				});
1423
1424				container.on('disable', function () {
1425					self.$selection.attr('tabindex', '-1');
1426				});
1427			};
1428
1429			BaseSelection.prototype._handleBlur = function (evt) {
1430				var self = this;
1431
1432				// This needs to be delayed as the active element is the body when the tab
1433				// key is pressed, possibly along with others.
1434				window.setTimeout(function () {
1435					// Don't trigger `blur` if the focus is still in the selection
1436					if (
1437						(document.activeElement == self.$selection[0]) ||
1438						($.contains(self.$selection[0], document.activeElement))
1439					) {
1440						return;
1441					}
1442
1443					self.trigger('blur', evt);
1444				}, 1);
1445			};
1446
1447			BaseSelection.prototype._attachCloseHandler = function (container) {
1448				var self = this;
1449
1450				$(document.body).on('mousedown.select2.' + container.id, function (e) {
1451					var $target = $(e.target);
1452
1453					var $select = $target.closest('.select2');
1454
1455					var $all = $('.select2.select2-container--open');
1456
1457					$all.each(function () {
1458						var $this = $(this);
1459
1460						if (this == $select[0]) {
1461							return;
1462						}
1463
1464						var $element = $this.data('element');
1465
1466						// FUI-SELECT2 renamed function to FUIselect2
1467						$element.FUIselect2('close');
1468						// $element.select2('close');
1469					});
1470				});
1471			};
1472
1473			BaseSelection.prototype._detachCloseHandler = function (container) {
1474				$(document.body).off('mousedown.select2.' + container.id);
1475			};
1476
1477			BaseSelection.prototype.position = function ($selection, $container) {
1478				var $selectionContainer = $container.find('.selection');
1479				$selectionContainer.append($selection);
1480			};
1481
1482			BaseSelection.prototype.destroy = function () {
1483				this._detachCloseHandler(this.container);
1484			};
1485
1486			BaseSelection.prototype.update = function (data) {
1487				throw new Error('The `update` method must be defined in child classes.');
1488			};
1489
1490			return BaseSelection;
1491		});
1492
1493		S2.define('select2/selection/single',[
1494			'jquery',
1495			'./base',
1496			'../utils',
1497			'../keys'
1498		], function ($, BaseSelection, Utils, KEYS) {
1499			function SingleSelection () {
1500				SingleSelection.__super__.constructor.apply(this, arguments);
1501			}
1502
1503			Utils.Extend(SingleSelection, BaseSelection);
1504
1505			SingleSelection.prototype.render = function () {
1506				var $selection = SingleSelection.__super__.render.call(this);
1507
1508				$selection.addClass('select2-selection--single');
1509
1510				$selection.html(
1511					'<span class="select2-selection__rendered"></span>' +
1512					'<span class="select2-selection__arrow" role="presentation">' +
1513					'<b role="presentation"></b>' +
1514					'</span>'
1515				);
1516
1517				return $selection;
1518			};
1519
1520			SingleSelection.prototype.bind = function (container, $container) {
1521				var self = this;
1522
1523				SingleSelection.__super__.bind.apply(this, arguments);
1524
1525				var id = container.id + '-container';
1526
1527				this.$selection.find('.select2-selection__rendered').attr('id', id);
1528				this.$selection.attr('aria-labelledby', id);
1529
1530				this.$selection.on('mousedown', function (evt) {
1531					// Only respond to left clicks
1532					if (evt.which !== 1) {
1533						return;
1534					}
1535
1536					self.trigger('toggle', {
1537						originalEvent: evt
1538					});
1539				});
1540
1541				this.$selection.on('focus', function (evt) {
1542					// User focuses on the container
1543				});
1544
1545				this.$selection.on('blur', function (evt) {
1546					// User exits the container
1547				});
1548
1549				container.on('focus', function (evt) {
1550					if (!container.isOpen()) {
1551						self.$selection.focus();
1552					}
1553				});
1554
1555				container.on('selection:update', function (params) {
1556					self.update(params.data);
1557				});
1558			};
1559
1560			SingleSelection.prototype.clear = function () {
1561				this.$selection.find('.select2-selection__rendered').empty();
1562			};
1563
1564			SingleSelection.prototype.display = function (data, container) {
1565				var template = this.options.get('templateSelection');
1566				var escapeMarkup = this.options.get('escapeMarkup');
1567
1568				return escapeMarkup(template(data, container));
1569			};
1570
1571			SingleSelection.prototype.selectionContainer = function () {
1572				return $('<span></span>');
1573			};
1574
1575			SingleSelection.prototype.update = function (data) {
1576				if (data.length === 0) {
1577					this.clear();
1578					return;
1579				}
1580
1581				var selection = data[0];
1582
1583				var $rendered = this.$selection.find('.select2-selection__rendered');
1584				var formatted = this.display(selection, $rendered);
1585
1586				$rendered.empty().append(formatted);
1587				$rendered.prop('title', selection.title || selection.text);
1588			};
1589
1590			return SingleSelection;
1591		});
1592
1593		S2.define('select2/selection/multiple',[
1594			'jquery',
1595			'./base',
1596			'../utils'
1597		], function ($, BaseSelection, Utils) {
1598			function MultipleSelection ($element, options) {
1599				MultipleSelection.__super__.constructor.apply(this, arguments);
1600			}
1601
1602			Utils.Extend(MultipleSelection, BaseSelection);
1603
1604			MultipleSelection.prototype.render = function () {
1605				var $selection = MultipleSelection.__super__.render.call(this);
1606
1607				$selection.addClass('select2-selection--multiple');
1608
1609				$selection.html(
1610					'<ul class="select2-selection__rendered"></ul>'
1611				);
1612
1613				return $selection;
1614			};
1615
1616			MultipleSelection.prototype.bind = function (container, $container) {
1617				var self = this;
1618
1619				MultipleSelection.__super__.bind.apply(this, arguments);
1620
1621				this.$selection.on('click', function (evt) {
1622					self.trigger('toggle', {
1623						originalEvent: evt
1624					});
1625				});
1626
1627				this.$selection.on(
1628					'click',
1629					'.select2-selection__choice__remove',
1630					function (evt) {
1631						// Ignore the event if it is disabled
1632						if (self.options.get('disabled')) {
1633							return;
1634						}
1635
1636						var $remove = $(this);
1637						var $selection = $remove.parent();
1638
1639						var data = $selection.data('data');
1640
1641						self.trigger('unselect', {
1642							originalEvent: evt,
1643							data: data
1644						});
1645					}
1646				);
1647			};
1648
1649			MultipleSelection.prototype.clear = function () {
1650				this.$selection.find('.select2-selection__rendered').empty();
1651			};
1652
1653			MultipleSelection.prototype.display = function (data, container) {
1654				var template = this.options.get('templateSelection');
1655				var escapeMarkup = this.options.get('escapeMarkup');
1656
1657				return escapeMarkup(template(data, container));
1658			};
1659
1660			MultipleSelection.prototype.selectionContainer = function () {
1661				var $container = $(
1662					'<li class="select2-selection__choice">' +
1663					'<span class="select2-selection__choice__remove" role="presentation">' +
1664					'&times;' +
1665					'</span>' +
1666					'</li>'
1667				);
1668
1669				return $container;
1670			};
1671
1672			MultipleSelection.prototype.update = function (data) {
1673				this.clear();
1674
1675				if (data.length === 0) {
1676					return;
1677				}
1678
1679				var $selections = [];
1680
1681				for (var d = 0; d < data.length; d++) {
1682					var selection = data[d];
1683
1684					var $selection = this.selectionContainer();
1685					var formatted = this.display(selection, $selection);
1686
1687					$selection.append(formatted);
1688					$selection.prop('title', selection.title || selection.text);
1689
1690					$selection.data('data', selection);
1691
1692					$selections.push($selection);
1693				}
1694
1695				var $rendered = this.$selection.find('.select2-selection__rendered');
1696
1697				Utils.appendMany($rendered, $selections);
1698			};
1699
1700			return MultipleSelection;
1701		});
1702
1703		S2.define('select2/selection/placeholder',[
1704			'../utils'
1705		], function (Utils) {
1706			function Placeholder (decorated, $element, options) {
1707				this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
1708
1709				decorated.call(this, $element, options);
1710			}
1711
1712			Placeholder.prototype.normalizePlaceholder = function (_, placeholder) {
1713				if (typeof placeholder === 'string') {
1714					placeholder = {
1715						id: '',
1716						text: placeholder
1717					};
1718				}
1719
1720				return placeholder;
1721			};
1722
1723			Placeholder.prototype.createPlaceholder = function (decorated, placeholder) {
1724				var $placeholder = this.selectionContainer();
1725
1726				$placeholder.html(this.display(placeholder));
1727				$placeholder.addClass('select2-selection__placeholder')
1728							.removeClass('select2-selection__choice');
1729
1730				return $placeholder;
1731			};
1732
1733			Placeholder.prototype.update = function (decorated, data) {
1734				var singlePlaceholder = (
1735					data.length == 1 && data[0].id != this.placeholder.id
1736				);
1737				var multipleSelections = data.length > 1;
1738
1739				if (multipleSelections || singlePlaceholder) {
1740					return decorated.call(this, data);
1741				}
1742
1743				this.clear();
1744
1745				var $placeholder = this.createPlaceholder(this.placeholder);
1746
1747				this.$selection.find('.select2-selection__rendered').append($placeholder);
1748			};
1749
1750			return Placeholder;
1751		});
1752
1753		S2.define('select2/selection/allowClear',[
1754			'jquery',
1755			'../keys'
1756		], function ($, KEYS) {
1757			function AllowClear () { }
1758
1759			AllowClear.prototype.bind = function (decorated, container, $container) {
1760				var self = this;
1761
1762				decorated.call(this, container, $container);
1763
1764				if (this.placeholder == null) {
1765					if (this.options.get('debug') && window.console && console.error) {
1766						console.error(
1767							'Select2: The `allowClear` option should be used in combination ' +
1768							'with the `placeholder` option.'
1769						);
1770					}
1771				}
1772
1773				this.$selection.on('mousedown', '.select2-selection__clear',
1774					function (evt) {
1775						self._handleClear(evt);
1776					});
1777
1778				container.on('keypress', function (evt) {
1779					self._handleKeyboardClear(evt, container);
1780				});
1781			};
1782
1783			AllowClear.prototype._handleClear = function (_, evt) {
1784				// Ignore the event if it is disabled
1785				if (this.options.get('disabled')) {
1786					return;
1787				}
1788
1789				var $clear = this.$selection.find('.select2-selection__clear');
1790
1791				// Ignore the event if nothing has been selected
1792				if ($clear.length === 0) {
1793					return;
1794				}
1795
1796				evt.stopPropagation();
1797
1798				var data = $clear.data('data');
1799
1800				for (var d = 0; d < data.length; d++) {
1801					var unselectData = {
1802						data: data[d]
1803					};
1804
1805					// Trigger the `unselect` event, so people can prevent it from being
1806					// cleared.
1807					this.trigger('unselect', unselectData);
1808
1809					// If the event was prevented, don't clear it out.
1810					if (unselectData.prevented) {
1811						return;
1812					}
1813				}
1814
1815				this.$element.val(this.placeholder.id).trigger('change');
1816
1817				this.trigger('toggle', {});
1818			};
1819
1820			AllowClear.prototype._handleKeyboardClear = function (_, evt, container) {
1821				if (container.isOpen()) {
1822					return;
1823				}
1824
1825				if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) {
1826					this._handleClear(evt);
1827				}
1828			};
1829
1830			AllowClear.prototype.update = function (decorated, data) {
1831				decorated.call(this, data);
1832
1833				if (this.$selection.find('.select2-selection__placeholder').length > 0 ||
1834					data.length === 0) {
1835					return;
1836				}
1837
1838				var $remove = $(
1839					'<span class="select2-selection__clear">' +
1840					'&times;' +
1841					'</span>'
1842				);
1843				$remove.data('data', data);
1844
1845				this.$selection.find('.select2-selection__rendered').prepend($remove);
1846			};
1847
1848			return AllowClear;
1849		});
1850
1851		S2.define('select2/selection/search',[
1852			'jquery',
1853			'../utils',
1854			'../keys'
1855		], function ($, Utils, KEYS) {
1856			function Search (decorated, $element, options) {
1857				decorated.call(this, $element, options);
1858			}
1859
1860			Search.prototype.render = function (decorated) {
1861				var $search = $(
1862					'<li class="select2-search select2-search--inline">' +
1863					'<input class="select2-search__field" type="search" tabindex="-1"' +
1864					' autocomplete="off" autocorrect="off" autocapitalize="none"' +
1865					' spellcheck="false" role="textbox" aria-autocomplete="list" />' +
1866					'</li>'
1867				);
1868
1869				this.$searchContainer = $search;
1870				this.$search = $search.find('input');
1871
1872				var $rendered = decorated.call(this);
1873
1874				this._transferTabIndex();
1875
1876				return $rendered;
1877			};
1878
1879			Search.prototype.bind = function (decorated, container, $container) {
1880				var self = this;
1881
1882				decorated.call(this, container, $container);
1883
1884				container.on('open', function () {
1885					self.$search.trigger('focus');
1886				});
1887
1888				container.on('close', function () {
1889					self.$search.val('');
1890					self.$search.removeAttr('aria-activedescendant');
1891					self.$search.trigger('focus');
1892				});
1893
1894				container.on('enable', function () {
1895					self.$search.prop('disabled', false);
1896
1897					self._transferTabIndex();
1898				});
1899
1900				container.on('disable', function () {
1901					self.$search.prop('disabled', true);
1902				});
1903
1904				container.on('focus', function (evt) {
1905					self.$search.trigger('focus');
1906				});
1907
1908				container.on('results:focus', function (params) {
1909					self.$search.attr('aria-activedescendant', params.id);
1910				});
1911
1912				this.$selection.on('focusin', '.select2-search--inline', function (evt) {
1913					self.trigger('focus', evt);
1914				});
1915
1916				this.$selection.on('focusout', '.select2-search--inline', function (evt) {
1917					self._handleBlur(evt);
1918				});
1919
1920				this.$selection.on('keydown', '.select2-search--inline', function (evt) {
1921					evt.stopPropagation();
1922
1923					self.trigger('keypress', evt);
1924
1925					self._keyUpPrevented = evt.isDefaultPrevented();
1926
1927					var key = evt.which;
1928
1929					if (key === KEYS.BACKSPACE && self.$search.val() === '') {
1930						var $previousChoice = self.$searchContainer
1931												  .prev('.select2-selection__choice');
1932
1933						if ($previousChoice.length > 0) {
1934							var item = $previousChoice.data('data');
1935
1936							self.searchRemoveChoice(item);
1937
1938							evt.preventDefault();
1939						}
1940					}
1941				});
1942
1943				// Try to detect the IE version should the `documentMode` property that
1944				// is stored on the document. This is only implemented in IE and is
1945				// slightly cleaner than doing a user agent check.
1946				// This property is not available in Edge, but Edge also doesn't have
1947				// this bug.
1948				var msie = document.documentMode;
1949				var disableInputEvents = msie && msie <= 11;
1950
1951				// Workaround for browsers which do not support the `input` event
1952				// This will prevent double-triggering of events for browsers which support
1953				// both the `keyup` and `input` events.
1954				this.$selection.on(
1955					'input.searchcheck',
1956					'.select2-search--inline',
1957					function (evt) {
1958						// IE will trigger the `input` event when a placeholder is used on a
1959						// search box. To get around this issue, we are forced to ignore all
1960						// `input` events in IE and keep using `keyup`.
1961						if (disableInputEvents) {
1962							self.$selection.off('input.search input.searchcheck');
1963							return;
1964						}
1965
1966						// Unbind the duplicated `keyup` event
1967						self.$selection.off('keyup.search');
1968					}
1969				);
1970
1971				this.$selection.on(
1972					'keyup.search input.search',
1973					'.select2-search--inline',
1974					function (evt) {
1975						// IE will trigger the `input` event when a placeholder is used on a
1976						// search box. To get around this issue, we are forced to ignore all
1977						// `input` events in IE and keep using `keyup`.
1978						if (disableInputEvents && evt.type === 'input') {
1979							self.$selection.off('input.search input.searchcheck');
1980							return;
1981						}
1982
1983						var key = evt.which;
1984
1985						// We can freely ignore events from modifier keys
1986						if (key == KEYS.SHIFT || key == KEYS.CTRL || key == KEYS.ALT) {
1987							return;
1988						}
1989
1990						// Tabbing will be handled during the `keydown` phase
1991						if (key == KEYS.TAB) {
1992							return;
1993						}
1994
1995						self.handleSearch(evt);
1996					}
1997				);
1998			};
1999
2000			/**
2001			 * This method will transfer the tabindex attribute from the rendered
2002			 * selection to the search box. This allows for the search box to be used as
2003			 * the primary focus instead of the selection container.
2004			 *
2005			 * @private
2006			 */
2007			Search.prototype._transferTabIndex = function (decorated) {
2008				this.$search.attr('tabindex', this.$selection.attr('tabindex'));
2009				this.$selection.attr('tabindex', '-1');
2010			};
2011
2012			Search.prototype.createPlaceholder = function (decorated, placeholder) {
2013				this.$search.attr('placeholder', placeholder.text);
2014			};
2015
2016			Search.prototype.update = function (decorated, data) {
2017				var searchHadFocus = this.$search[0] == document.activeElement;
2018
2019				this.$search.attr('placeholder', '');
2020
2021				decorated.call(this, data);
2022
2023				this.$selection.find('.select2-selection__rendered')
2024					.append(this.$searchContainer);
2025
2026				this.resizeSearch();
2027				if (searchHadFocus) {
2028					this.$search.focus();
2029				}
2030			};
2031
2032			Search.prototype.handleSearch = function () {
2033				this.resizeSearch();
2034
2035				if (!this._keyUpPrevented) {
2036					var input = this.$search.val();
2037
2038					this.trigger('query', {
2039						term: input
2040					});
2041				}
2042
2043				this._keyUpPrevented = false;
2044			};
2045
2046			Search.prototype.searchRemoveChoice = function (decorated, item) {
2047				this.trigger('unselect', {
2048					data: item
2049				});
2050
2051				this.$search.val(item.text);
2052				this.handleSearch();
2053			};
2054
2055			Search.prototype.resizeSearch = function () {
2056				this.$search.css('width', '25px');
2057
2058				var width = '';
2059
2060				if (this.$search.attr('placeholder') !== '') {
2061					width = this.$selection.find('.select2-selection__rendered').innerWidth();
2062				} else {
2063					var minimumWidth = this.$search.val().length + 1;
2064
2065					width = (minimumWidth * 0.75) + 'em';
2066				}
2067
2068				this.$search.css('width', width);
2069			};
2070
2071			return Search;
2072		});
2073
2074		S2.define('select2/selection/eventRelay',[
2075			'jquery'
2076		], function ($) {
2077			function EventRelay () { }
2078
2079			EventRelay.prototype.bind = function (decorated, container, $container) {
2080				var self = this;
2081				var relayEvents = [
2082					'open', 'opening',
2083					'close', 'closing',
2084					'select', 'selecting',
2085					'unselect', 'unselecting'
2086				];
2087
2088				var preventableEvents = ['opening', 'closing', 'selecting', 'unselecting'];
2089
2090				decorated.call(this, container, $container);
2091
2092				container.on('*', function (name, params) {
2093					// Ignore events that should not be relayed
2094					if ($.inArray(name, relayEvents) === -1) {
2095						return;
2096					}
2097
2098					// The parameters should always be an object
2099					params = params || {};
2100
2101					// Generate the jQuery event for the Select2 event
2102					var evt = $.Event('select2:' + name, {
2103						params: params
2104					});
2105
2106					self.$element.trigger(evt);
2107
2108					// Only handle preventable events if it was one
2109					if ($.inArray(name, preventableEvents) === -1) {
2110						return;
2111					}
2112
2113					params.prevented = evt.isDefaultPrevented();
2114				});
2115			};
2116
2117			return EventRelay;
2118		});
2119
2120		S2.define('select2/translation',[
2121			'jquery',
2122			'require'
2123		], function ($, require) {
2124			function Translation (dict) {
2125				this.dict = dict || {};
2126			}
2127
2128			Translation.prototype.all = function () {
2129				return this.dict;
2130			};
2131
2132			Translation.prototype.get = function (key) {
2133				return this.dict[key];
2134			};
2135
2136			Translation.prototype.extend = function (translation) {
2137				this.dict = $.extend({}, translation.all(), this.dict);
2138			};
2139
2140			// Static functions
2141
2142			Translation._cache = {};
2143
2144			Translation.loadPath = function (path) {
2145				if (!(path in Translation._cache)) {
2146					var translations = require(path);
2147
2148					Translation._cache[path] = translations;
2149				}
2150
2151				return new Translation(Translation._cache[path]);
2152			};
2153
2154			return Translation;
2155		});
2156
2157		S2.define('select2/diacritics',[
2158
2159		], function () {
2160			var diacritics = {
2161				'\u24B6': 'A',
2162				'\uFF21': 'A',
2163				'\u00C0': 'A',
2164				'\u00C1': 'A',
2165				'\u00C2': 'A',
2166				'\u1EA6': 'A',
2167				'\u1EA4': 'A',
2168				'\u1EAA': 'A',
2169				'\u1EA8': 'A',
2170				'\u00C3': 'A',
2171				'\u0100': 'A',
2172				'\u0102': 'A',
2173				'\u1EB0': 'A',
2174				'\u1EAE': 'A',
2175				'\u1EB4': 'A',
2176				'\u1EB2': 'A',
2177				'\u0226': 'A',
2178				'\u01E0': 'A',
2179				'\u00C4': 'A',
2180				'\u01DE': 'A',
2181				'\u1EA2': 'A',
2182				'\u00C5': 'A',
2183				'\u01FA': 'A',
2184				'\u01CD': 'A',
2185				'\u0200': 'A',
2186				'\u0202': 'A',
2187				'\u1EA0': 'A',
2188				'\u1EAC': 'A',
2189				'\u1EB6': 'A',
2190				'\u1E00': 'A',
2191				'\u0104': 'A',
2192				'\u023A': 'A',
2193				'\u2C6F': 'A',
2194				'\uA732': 'AA',
2195				'\u00C6': 'AE',
2196				'\u01FC': 'AE',
2197				'\u01E2': 'AE',
2198				'\uA734': 'AO',
2199				'\uA736': 'AU',
2200				'\uA738': 'AV',
2201				'\uA73A': 'AV',
2202				'\uA73C': 'AY',
2203				'\u24B7': 'B',
2204				'\uFF22': 'B',
2205				'\u1E02': 'B',
2206				'\u1E04': 'B',
2207				'\u1E06': 'B',
2208				'\u0243': 'B',
2209				'\u0182': 'B',
2210				'\u0181': 'B',
2211				'\u24B8': 'C',
2212				'\uFF23': 'C',
2213				'\u0106': 'C',
2214				'\u0108': 'C',
2215				'\u010A': 'C',
2216				'\u010C': 'C',
2217				'\u00C7': 'C',
2218				'\u1E08': 'C',
2219				'\u0187': 'C',
2220				'\u023B': 'C',
2221				'\uA73E': 'C',
2222				'\u24B9': 'D',
2223				'\uFF24': 'D',
2224				'\u1E0A': 'D',
2225				'\u010E': 'D',
2226				'\u1E0C': 'D',
2227				'\u1E10': 'D',
2228				'\u1E12': 'D',
2229				'\u1E0E': 'D',
2230				'\u0110': 'D',
2231				'\u018B': 'D',
2232				'\u018A': 'D',
2233				'\u0189': 'D',
2234				'\uA779': 'D',
2235				'\u01F1': 'DZ',
2236				'\u01C4': 'DZ',
2237				'\u01F2': 'Dz',
2238				'\u01C5': 'Dz',
2239				'\u24BA': 'E',
2240				'\uFF25': 'E',
2241				'\u00C8': 'E',
2242				'\u00C9': 'E',
2243				'\u00CA': 'E',
2244				'\u1EC0': 'E',
2245				'\u1EBE': 'E',
2246				'\u1EC4': 'E',
2247				'\u1EC2': 'E',
2248				'\u1EBC': 'E',
2249				'\u0112': 'E',
2250				'\u1E14': 'E',
2251				'\u1E16': 'E',
2252				'\u0114': 'E',
2253				'\u0116': 'E',
2254				'\u00CB': 'E',
2255				'\u1EBA': 'E',
2256				'\u011A': 'E',
2257				'\u0204': 'E',
2258				'\u0206': 'E',
2259				'\u1EB8': 'E',
2260				'\u1EC6': 'E',
2261				'\u0228': 'E',
2262				'\u1E1C': 'E',
2263				'\u0118': 'E',
2264				'\u1E18': 'E',
2265				'\u1E1A': 'E',
2266				'\u0190': 'E',
2267				'\u018E': 'E',
2268				'\u24BB': 'F',
2269				'\uFF26': 'F',
2270				'\u1E1E': 'F',
2271				'\u0191': 'F',
2272				'\uA77B': 'F',
2273				'\u24BC': 'G',
2274				'\uFF27': 'G',
2275				'\u01F4': 'G',
2276				'\u011C': 'G',
2277				'\u1E20': 'G',
2278				'\u011E': 'G',
2279				'\u0120': 'G',
2280				'\u01E6': 'G',
2281				'\u0122': 'G',
2282				'\u01E4': 'G',
2283				'\u0193': 'G',
2284				'\uA7A0': 'G',
2285				'\uA77D': 'G',
2286				'\uA77E': 'G',
2287				'\u24BD': 'H',
2288				'\uFF28': 'H',
2289				'\u0124': 'H',
2290				'\u1E22': 'H',
2291				'\u1E26': 'H',
2292				'\u021E': 'H',
2293				'\u1E24': 'H',
2294				'\u1E28': 'H',
2295				'\u1E2A': 'H',
2296				'\u0126': 'H',
2297				'\u2C67': 'H',
2298				'\u2C75': 'H',
2299				'\uA78D': 'H',
2300				'\u24BE': 'I',
2301				'\uFF29': 'I',
2302				'\u00CC': 'I',
2303				'\u00CD': 'I',
2304				'\u00CE': 'I',
2305				'\u0128': 'I',
2306				'\u012A': 'I',
2307				'\u012C': 'I',
2308				'\u0130': 'I',
2309				'\u00CF': 'I',
2310				'\u1E2E': 'I',
2311				'\u1EC8': 'I',
2312				'\u01CF': 'I',
2313				'\u0208': 'I',
2314				'\u020A': 'I',
2315				'\u1ECA': 'I',
2316				'\u012E': 'I',
2317				'\u1E2C': 'I',
2318				'\u0197': 'I',
2319				'\u24BF': 'J',
2320				'\uFF2A': 'J',
2321				'\u0134': 'J',
2322				'\u0248': 'J',
2323				'\u24C0': 'K',
2324				'\uFF2B': 'K',
2325				'\u1E30': 'K',
2326				'\u01E8': 'K',
2327				'\u1E32': 'K',
2328				'\u0136': 'K',
2329				'\u1E34': 'K',
2330				'\u0198': 'K',
2331				'\u2C69': 'K',
2332				'\uA740': 'K',
2333				'\uA742': 'K',
2334				'\uA744': 'K',
2335				'\uA7A2': 'K',
2336				'\u24C1': 'L',
2337				'\uFF2C': 'L',
2338				'\u013F': 'L',
2339				'\u0139': 'L',
2340				'\u013D': 'L',
2341				'\u1E36': 'L',
2342				'\u1E38': 'L',
2343				'\u013B': 'L',
2344				'\u1E3C': 'L',
2345				'\u1E3A': 'L',
2346				'\u0141': 'L',
2347				'\u023D': 'L',
2348				'\u2C62': 'L',
2349				'\u2C60': 'L',
2350				'\uA748': 'L',
2351				'\uA746': 'L',
2352				'\uA780': 'L',
2353				'\u01C7': 'LJ',
2354				'\u01C8': 'Lj',
2355				'\u24C2': 'M',
2356				'\uFF2D': 'M',
2357				'\u1E3E': 'M',
2358				'\u1E40': 'M',
2359				'\u1E42': 'M',
2360				'\u2C6E': 'M',
2361				'\u019C': 'M',
2362				'\u24C3': 'N',
2363				'\uFF2E': 'N',
2364				'\u01F8': 'N',
2365				'\u0143': 'N',
2366				'\u00D1': 'N',
2367				'\u1E44': 'N',
2368				'\u0147': 'N',
2369				'\u1E46': 'N',
2370				'\u0145': 'N',
2371				'\u1E4A': 'N',
2372				'\u1E48': 'N',
2373				'\u0220': 'N',
2374				'\u019D': 'N',
2375				'\uA790': 'N',
2376				'\uA7A4': 'N',
2377				'\u01CA': 'NJ',
2378				'\u01CB': 'Nj',
2379				'\u24C4': 'O',
2380				'\uFF2F': 'O',
2381				'\u00D2': 'O',
2382				'\u00D3': 'O',
2383				'\u00D4': 'O',
2384				'\u1ED2': 'O',
2385				'\u1ED0': 'O',
2386				'\u1ED6': 'O',
2387				'\u1ED4': 'O',
2388				'\u00D5': 'O',
2389				'\u1E4C': 'O',
2390				'\u022C': 'O',
2391				'\u1E4E': 'O',
2392				'\u014C': 'O',
2393				'\u1E50': 'O',
2394				'\u1E52': 'O',
2395				'\u014E': 'O',
2396				'\u022E': 'O',
2397				'\u0230': 'O',
2398				'\u00D6': 'O',
2399				'\u022A': 'O',
2400				'\u1ECE': 'O',
2401				'\u0150': 'O',
2402				'\u01D1': 'O',
2403				'\u020C': 'O',
2404				'\u020E': 'O',
2405				'\u01A0': 'O',
2406				'\u1EDC': 'O',
2407				'\u1EDA': 'O',
2408				'\u1EE0': 'O',
2409				'\u1EDE': 'O',
2410				'\u1EE2': 'O',
2411				'\u1ECC': 'O',
2412				'\u1ED8': 'O',
2413				'\u01EA': 'O',
2414				'\u01EC': 'O',
2415				'\u00D8': 'O',
2416				'\u01FE': 'O',
2417				'\u0186': 'O',
2418				'\u019F': 'O',
2419				'\uA74A': 'O',
2420				'\uA74C': 'O',
2421				'\u01A2': 'OI',
2422				'\uA74E': 'OO',
2423				'\u0222': 'OU',
2424				'\u24C5': 'P',
2425				'\uFF30': 'P',
2426				'\u1E54': 'P',
2427				'\u1E56': 'P',
2428				'\u01A4': 'P',
2429				'\u2C63': 'P',
2430				'\uA750': 'P',
2431				'\uA752': 'P',
2432				'\uA754': 'P',
2433				'\u24C6': 'Q',
2434				'\uFF31': 'Q',
2435				'\uA756': 'Q',
2436				'\uA758': 'Q',
2437				'\u024A': 'Q',
2438				'\u24C7': 'R',
2439				'\uFF32': 'R',
2440				'\u0154': 'R',
2441				'\u1E58': 'R',
2442				'\u0158': 'R',
2443				'\u0210': 'R',
2444				'\u0212': 'R',
2445				'\u1E5A': 'R',
2446				'\u1E5C': 'R',
2447				'\u0156': 'R',
2448				'\u1E5E': 'R',
2449				'\u024C': 'R',
2450				'\u2C64': 'R',
2451				'\uA75A': 'R',
2452				'\uA7A6': 'R',
2453				'\uA782': 'R',
2454				'\u24C8': 'S',
2455				'\uFF33': 'S',
2456				'\u1E9E': 'S',
2457				'\u015A': 'S',
2458				'\u1E64': 'S',
2459				'\u015C': 'S',
2460				'\u1E60': 'S',
2461				'\u0160': 'S',
2462				'\u1E66': 'S',
2463				'\u1E62': 'S',
2464				'\u1E68': 'S',
2465				'\u0218': 'S',
2466				'\u015E': 'S',
2467				'\u2C7E': 'S',
2468				'\uA7A8': 'S',
2469				'\uA784': 'S',
2470				'\u24C9': 'T',
2471				'\uFF34': 'T',
2472				'\u1E6A': 'T',
2473				'\u0164': 'T',
2474				'\u1E6C': 'T',
2475				'\u021A': 'T',
2476				'\u0162': 'T',
2477				'\u1E70': 'T',
2478				'\u1E6E': 'T',
2479				'\u0166': 'T',
2480				'\u01AC': 'T',
2481				'\u01AE': 'T',
2482				'\u023E': 'T',
2483				'\uA786': 'T',
2484				'\uA728': 'TZ',
2485				'\u24CA': 'U',
2486				'\uFF35': 'U',
2487				'\u00D9': 'U',
2488				'\u00DA': 'U',
2489				'\u00DB': 'U',
2490				'\u0168': 'U',
2491				'\u1E78': 'U',
2492				'\u016A': 'U',
2493				'\u1E7A': 'U',
2494				'\u016C': 'U',
2495				'\u00DC': 'U',
2496				'\u01DB': 'U',
2497				'\u01D7': 'U',
2498				'\u01D5': 'U',
2499				'\u01D9': 'U',
2500				'\u1EE6': 'U',
2501				'\u016E': 'U',
2502				'\u0170': 'U',
2503				'\u01D3': 'U',
2504				'\u0214': 'U',
2505				'\u0216': 'U',
2506				'\u01AF': 'U',
2507				'\u1EEA': 'U',
2508				'\u1EE8': 'U',
2509				'\u1EEE': 'U',
2510				'\u1EEC': 'U',
2511				'\u1EF0': 'U',
2512				'\u1EE4': 'U',
2513				'\u1E72': 'U',
2514				'\u0172': 'U',
2515				'\u1E76': 'U',
2516				'\u1E74': 'U',
2517				'\u0244': 'U',
2518				'\u24CB': 'V',
2519				'\uFF36': 'V',
2520				'\u1E7C': 'V',
2521				'\u1E7E': 'V',
2522				'\u01B2': 'V',
2523				'\uA75E': 'V',
2524				'\u0245': 'V',
2525				'\uA760': 'VY',
2526				'\u24CC': 'W',
2527				'\uFF37': 'W',
2528				'\u1E80': 'W',
2529				'\u1E82': 'W',
2530				'\u0174': 'W',
2531				'\u1E86': 'W',
2532				'\u1E84': 'W',
2533				'\u1E88': 'W',
2534				'\u2C72': 'W',
2535				'\u24CD': 'X',
2536				'\uFF38': 'X',
2537				'\u1E8A': 'X',
2538				'\u1E8C': 'X',
2539				'\u24CE': 'Y',
2540				'\uFF39': 'Y',
2541				'\u1EF2': 'Y',
2542				'\u00DD': 'Y',
2543				'\u0176': 'Y',
2544				'\u1EF8': 'Y',
2545				'\u0232': 'Y',
2546				'\u1E8E': 'Y',
2547				'\u0178': 'Y',
2548				'\u1EF6': 'Y',
2549				'\u1EF4': 'Y',
2550				'\u01B3': 'Y',
2551				'\u024E': 'Y',
2552				'\u1EFE': 'Y',
2553				'\u24CF': 'Z',
2554				'\uFF3A': 'Z',
2555				'\u0179': 'Z',
2556				'\u1E90': 'Z',
2557				'\u017B': 'Z',
2558				'\u017D': 'Z',
2559				'\u1E92': 'Z',
2560				'\u1E94': 'Z',
2561				'\u01B5': 'Z',
2562				'\u0224': 'Z',
2563				'\u2C7F': 'Z',
2564				'\u2C6B': 'Z',
2565				'\uA762': 'Z',
2566				'\u24D0': 'a',
2567				'\uFF41': 'a',
2568				'\u1E9A': 'a',
2569				'\u00E0': 'a',
2570				'\u00E1': 'a',
2571				'\u00E2': 'a',
2572				'\u1EA7': 'a',
2573				'\u1EA5': 'a',
2574				'\u1EAB': 'a',
2575				'\u1EA9': 'a',
2576				'\u00E3': 'a',
2577				'\u0101': 'a',
2578				'\u0103': 'a',
2579				'\u1EB1': 'a',
2580				'\u1EAF': 'a',
2581				'\u1EB5': 'a',
2582				'\u1EB3': 'a',
2583				'\u0227': 'a',
2584				'\u01E1': 'a',
2585				'\u00E4': 'a',
2586				'\u01DF': 'a',
2587				'\u1EA3': 'a',
2588				'\u00E5': 'a',
2589				'\u01FB': 'a',
2590				'\u01CE': 'a',
2591				'\u0201': 'a',
2592				'\u0203': 'a',
2593				'\u1EA1': 'a',
2594				'\u1EAD': 'a',
2595				'\u1EB7': 'a',
2596				'\u1E01': 'a',
2597				'\u0105': 'a',
2598				'\u2C65': 'a',
2599				'\u0250': 'a',
2600				'\uA733': 'aa',
2601				'\u00E6': 'ae',
2602				'\u01FD': 'ae',
2603				'\u01E3': 'ae',
2604				'\uA735': 'ao',
2605				'\uA737': 'au',
2606				'\uA739': 'av',
2607				'\uA73B': 'av',
2608				'\uA73D': 'ay',
2609				'\u24D1': 'b',
2610				'\uFF42': 'b',
2611				'\u1E03': 'b',
2612				'\u1E05': 'b',
2613				'\u1E07': 'b',
2614				'\u0180': 'b',
2615				'\u0183': 'b',
2616				'\u0253': 'b',
2617				'\u24D2': 'c',
2618				'\uFF43': 'c',
2619				'\u0107': 'c',
2620				'\u0109': 'c',
2621				'\u010B': 'c',
2622				'\u010D': 'c',
2623				'\u00E7': 'c',
2624				'\u1E09': 'c',
2625				'\u0188': 'c',
2626				'\u023C': 'c',
2627				'\uA73F': 'c',
2628				'\u2184': 'c',
2629				'\u24D3': 'd',
2630				'\uFF44': 'd',
2631				'\u1E0B': 'd',
2632				'\u010F': 'd',
2633				'\u1E0D': 'd',
2634				'\u1E11': 'd',
2635				'\u1E13': 'd',
2636				'\u1E0F': 'd',
2637				'\u0111': 'd',
2638				'\u018C': 'd',
2639				'\u0256': 'd',
2640				'\u0257': 'd',
2641				'\uA77A': 'd',
2642				'\u01F3': 'dz',
2643				'\u01C6': 'dz',
2644				'\u24D4': 'e',
2645				'\uFF45': 'e',
2646				'\u00E8': 'e',
2647				'\u00E9': 'e',
2648				'\u00EA': 'e',
2649				'\u1EC1': 'e',
2650				'\u1EBF': 'e',
2651				'\u1EC5': 'e',
2652				'\u1EC3': 'e',
2653				'\u1EBD': 'e',
2654				'\u0113': 'e',
2655				'\u1E15': 'e',
2656				'\u1E17': 'e',
2657				'\u0115': 'e',
2658				'\u0117': 'e',
2659				'\u00EB': 'e',
2660				'\u1EBB': 'e',
2661				'\u011B': 'e',
2662				'\u0205': 'e',
2663				'\u0207': 'e',
2664				'\u1EB9': 'e',
2665				'\u1EC7': 'e',
2666				'\u0229': 'e',
2667				'\u1E1D': 'e',
2668				'\u0119': 'e',
2669				'\u1E19': 'e',
2670				'\u1E1B': 'e',
2671				'\u0247': 'e',
2672				'\u025B': 'e',
2673				'\u01DD': 'e',
2674				'\u24D5': 'f',
2675				'\uFF46': 'f',
2676				'\u1E1F': 'f',
2677				'\u0192': 'f',
2678				'\uA77C': 'f',
2679				'\u24D6': 'g',
2680				'\uFF47': 'g',
2681				'\u01F5': 'g',
2682				'\u011D': 'g',
2683				'\u1E21': 'g',
2684				'\u011F': 'g',
2685				'\u0121': 'g',
2686				'\u01E7': 'g',
2687				'\u0123': 'g',
2688				'\u01E5': 'g',
2689				'\u0260': 'g',
2690				'\uA7A1': 'g',
2691				'\u1D79': 'g',
2692				'\uA77F': 'g',
2693				'\u24D7': 'h',
2694				'\uFF48': 'h',
2695				'\u0125': 'h',
2696				'\u1E23': 'h',
2697				'\u1E27': 'h',
2698				'\u021F': 'h',
2699				'\u1E25': 'h',
2700				'\u1E29': 'h',
2701				'\u1E2B': 'h',
2702				'\u1E96': 'h',
2703				'\u0127': 'h',
2704				'\u2C68': 'h',
2705				'\u2C76': 'h',
2706				'\u0265': 'h',
2707				'\u0195': 'hv',
2708				'\u24D8': 'i',
2709				'\uFF49': 'i',
2710				'\u00EC': 'i',
2711				'\u00ED': 'i',
2712				'\u00EE': 'i',
2713				'\u0129': 'i',
2714				'\u012B': 'i',
2715				'\u012D': 'i',
2716				'\u00EF': 'i',
2717				'\u1E2F': 'i',
2718				'\u1EC9': 'i',
2719				'\u01D0': 'i',
2720				'\u0209': 'i',
2721				'\u020B': 'i',
2722				'\u1ECB': 'i',
2723				'\u012F': 'i',
2724				'\u1E2D': 'i',
2725				'\u0268': 'i',
2726				'\u0131': 'i',
2727				'\u24D9': 'j',
2728				'\uFF4A': 'j',
2729				'\u0135': 'j',
2730				'\u01F0': 'j',
2731				'\u0249': 'j',
2732				'\u24DA': 'k',
2733				'\uFF4B': 'k',
2734				'\u1E31': 'k',
2735				'\u01E9': 'k',
2736				'\u1E33': 'k',
2737				'\u0137': 'k',
2738				'\u1E35': 'k',
2739				'\u0199': 'k',
2740				'\u2C6A': 'k',
2741				'\uA741': 'k',
2742				'\uA743': 'k',
2743				'\uA745': 'k',
2744				'\uA7A3': 'k',
2745				'\u24DB': 'l',
2746				'\uFF4C': 'l',
2747				'\u0140': 'l',
2748				'\u013A': 'l',
2749				'\u013E': 'l',
2750				'\u1E37': 'l',
2751				'\u1E39': 'l',
2752				'\u013C': 'l',
2753				'\u1E3D': 'l',
2754				'\u1E3B': 'l',
2755				'\u017F': 'l',
2756				'\u0142': 'l',
2757				'\u019A': 'l',
2758				'\u026B': 'l',
2759				'\u2C61': 'l',
2760				'\uA749': 'l',
2761				'\uA781': 'l',
2762				'\uA747': 'l',
2763				'\u01C9': 'lj',
2764				'\u24DC': 'm',
2765				'\uFF4D': 'm',
2766				'\u1E3F': 'm',
2767				'\u1E41': 'm',
2768				'\u1E43': 'm',
2769				'\u0271': 'm',
2770				'\u026F': 'm',
2771				'\u24DD': 'n',
2772				'\uFF4E': 'n',