https://worldfringe.com/wp-content/plugins/ultimate-member/assets/libs/select2/select2.full.js?ver=4.0.13

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 module === 'object' && module.exports) {
13    // Node/CommonJS
14    module.exports = function (root, jQuery) {
15      if (jQuery === undefined) {
16        // require('jQuery') returns a factory that requires window to
17        // build a jQuery instance, we normalize how we use modules
18        // that require this pattern but the window provided is a noop
19        // if it's defined (how jquery works)
20        if (typeof window !== 'undefined') {
21          jQuery = require('jquery');
22        }
23        else {
24          jQuery = require('jquery')(root);
25        }
26      }
27      factory(jQuery);
28      return jQuery;
29    };
30  } else {
31    // Browser globals
32    factory(jQuery);
33  }
34} (function (jQuery) {
35  // This is needed so we can catch the AMD loader configuration and use it
36  // The inner file should be wrapped (by `banner.start.js`) in a function that
37  // returns the AMD loader references.
38  var S2 =(function () {
39  // Restore the Select2 AMD loader so it can be used
40  // Needed mostly in the language files, where the loader is not inserted
41  if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) {
42    var S2 = jQuery.fn.select2.amd;
43  }
44var S2;(function () { if (!S2 || !S2.requirejs) {
45if (!S2) { S2 = {}; } else { require = S2; }
46/**
47 * @license almond 0.3.3 Copyright jQuery Foundation and other contributors.
48 * Released under MIT license, http://github.com/requirejs/almond/LICENSE
49 */
50//Going sloppy to avoid 'use strict' string cost, but strict practices should
51//be followed.
52/*global setTimeout: false */
53
54var requirejs, require, define;
55(function (undef) {
56    var main, req, makeMap, handlers,
57        defined = {},
58        waiting = {},
59        config = {},
60        defining = {},
61        hasOwn = Object.prototype.hasOwnProperty,
62        aps = [].slice,
63        jsSuffixRegExp = /\.js$/;
64
65    function hasProp(obj, prop) {
66        return hasOwn.call(obj, prop);
67    }
68
69    /**
70     * Given a relative module name, like ./something, normalize it to
71     * a real name that can be mapped to a path.
72     * @param {String} name the relative name
73     * @param {String} baseName a real name that the name arg is relative
74     * to.
75     * @returns {String} normalized name
76     */
77    function normalize(name, baseName) {
78        var nameParts, nameSegment, mapValue, foundMap, lastIndex,
79            foundI, foundStarMap, starI, i, j, part, normalizedBaseParts,
80            baseParts = baseName && baseName.split("/"),
81            map = config.map,
82            starMap = (map && map['*']) || {};
83
84        //Adjust any relative paths.
85        if (name) {
86            name = name.split('/');
87            lastIndex = name.length - 1;
88
89            // If wanting node ID compatibility, strip .js from end
90            // of IDs. Have to do this here, and not in nameToUrl
91            // because node allows either .js or non .js to map
92            // to same file.
93            if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
94                name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
95            }
96
97            // Starts with a '.' so need the baseName
98            if (name[0].charAt(0) === '.' && baseParts) {
99                //Convert baseName to array, and lop off the last part,
100                //so that . matches that 'directory' and not name of the baseName's
101                //module. For instance, baseName of 'one/two/three', maps to
102                //'one/two/three.js', but we want the directory, 'one/two' for
103                //this normalization.
104                normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
105                name = normalizedBaseParts.concat(name);
106            }
107
108            //start trimDots
109            for (i = 0; i < name.length; i++) {
110                part = name[i];
111                if (part === '.') {
112                    name.splice(i, 1);
113                    i -= 1;
114                } else if (part === '..') {
115                    // If at the start, or previous value is still ..,
116                    // keep them so that when converted to a path it may
117                    // still work when converted to a path, even though
118                    // as an ID it is less than ideal. In larger point
119                    // releases, may be better to just kick out an error.
120                    if (i === 0 || (i === 1 && name[2] === '..') || name[i - 1] === '..') {
121                        continue;
122                    } else if (i > 0) {
123                        name.splice(i - 1, 2);
124                        i -= 2;
125                    }
126                }
127            }
128            //end trimDots
129
130            name = name.join('/');
131        }
132
133        //Apply map config if available.
134        if ((baseParts || starMap) && map) {
135            nameParts = name.split('/');
136
137            for (i = nameParts.length; i > 0; i -= 1) {
138                nameSegment = nameParts.slice(0, i).join("/");
139
140                if (baseParts) {
141                    //Find the longest baseName segment match in the config.
142                    //So, do joins on the biggest to smallest lengths of baseParts.
143                    for (j = baseParts.length; j > 0; j -= 1) {
144                        mapValue = map[baseParts.slice(0, j).join('/')];
145
146                        //baseName segment has  config, find if it has one for
147                        //this name.
148                        if (mapValue) {
149                            mapValue = mapValue[nameSegment];
150                            if (mapValue) {
151                                //Match, update name to the new value.
152                                foundMap = mapValue;
153                                foundI = i;
154                                break;
155                            }
156                        }
157                    }
158                }
159
160                if (foundMap) {
161                    break;
162                }
163
164                //Check for a star map match, but just hold on to it,
165                //if there is a shorter segment match later in a matching
166                //config, then favor over this star map.
167                if (!foundStarMap && starMap && starMap[nameSegment]) {
168                    foundStarMap = starMap[nameSegment];
169                    starI = i;
170                }
171            }
172
173            if (!foundMap && foundStarMap) {
174                foundMap = foundStarMap;
175                foundI = starI;
176            }
177
178            if (foundMap) {
179                nameParts.splice(0, foundI, foundMap);
180                name = nameParts.join('/');
181            }
182        }
183
184        return name;
185    }
186
187    function makeRequire(relName, forceSync) {
188        return function () {
189            //A version of a require function that passes a moduleName
190            //value for items that may need to
191            //look up paths relative to the moduleName
192            var args = aps.call(arguments, 0);
193
194            //If first arg is not require('string'), and there is only
195            //one arg, it is the array form without a callback. Insert
196            //a null so that the following concat is correct.
197            if (typeof args[0] !== 'string' && args.length === 1) {
198                args.push(null);
199            }
200            return req.apply(undef, args.concat([relName, forceSync]));
201        };
202    }
203
204    function makeNormalize(relName) {
205        return function (name) {
206            return normalize(name, relName);
207        };
208    }
209
210    function makeLoad(depName) {
211        return function (value) {
212            defined[depName] = value;
213        };
214    }
215
216    function callDep(name) {
217        if (hasProp(waiting, name)) {
218            var args = waiting[name];
219            delete waiting[name];
220            defining[name] = true;
221            main.apply(undef, args);
222        }
223
224        if (!hasProp(defined, name) && !hasProp(defining, name)) {
225            throw new Error('No ' + name);
226        }
227        return defined[name];
228    }
229
230    //Turns a plugin!resource to [plugin, resource]
231    //with the plugin being undefined if the name
232    //did not have a plugin prefix.
233    function splitPrefix(name) {
234        var prefix,
235            index = name ? name.indexOf('!') : -1;
236        if (index > -1) {
237            prefix = name.substring(0, index);
238            name = name.substring(index + 1, name.length);
239        }
240        return [prefix, name];
241    }
242
243    //Creates a parts array for a relName where first part is plugin ID,
244    //second part is resource ID. Assumes relName has already been normalized.
245    function makeRelParts(relName) {
246        return relName ? splitPrefix(relName) : [];
247    }
248
249    /**
250     * Makes a name map, normalizing the name, and using a plugin
251     * for normalization if necessary. Grabs a ref to plugin
252     * too, as an optimization.
253     */
254    makeMap = function (name, relParts) {
255        var plugin,
256            parts = splitPrefix(name),
257            prefix = parts[0],
258            relResourceName = relParts[1];
259
260        name = parts[1];
261
262        if (prefix) {
263            prefix = normalize(prefix, relResourceName);
264            plugin = callDep(prefix);
265        }
266
267        //Normalize according
268        if (prefix) {
269            if (plugin && plugin.normalize) {
270                name = plugin.normalize(name, makeNormalize(relResourceName));
271            } else {
272                name = normalize(name, relResourceName);
273            }
274        } else {
275            name = normalize(name, relResourceName);
276            parts = splitPrefix(name);
277            prefix = parts[0];
278            name = parts[1];
279            if (prefix) {
280                plugin = callDep(prefix);
281            }
282        }
283
284        //Using ridiculous property names for space reasons
285        return {
286            f: prefix ? prefix + '!' + name : name, //fullName
287            n: name,
288            pr: prefix,
289            p: plugin
290        };
291    };
292
293    function makeConfig(name) {
294        return function () {
295            return (config && config.config && config.config[name]) || {};
296        };
297    }
298
299    handlers = {
300        require: function (name) {
301            return makeRequire(name);
302        },
303        exports: function (name) {
304            var e = defined[name];
305            if (typeof e !== 'undefined') {
306                return e;
307            } else {
308                return (defined[name] = {});
309            }
310        },
311        module: function (name) {
312            return {
313                id: name,
314                uri: '',
315                exports: defined[name],
316                config: makeConfig(name)
317            };
318        }
319    };
320
321    main = function (name, deps, callback, relName) {
322        var cjsModule, depName, ret, map, i, relParts,
323            args = [],
324            callbackType = typeof callback,
325            usingExports;
326
327        //Use name if no relName
328        relName = relName || name;
329        relParts = makeRelParts(relName);
330
331        //Call the callback to define the module, if necessary.
332        if (callbackType === 'undefined' || callbackType === 'function') {
333            //Pull out the defined dependencies and pass the ordered
334            //values to the callback.
335            //Default to [require, exports, module] if no deps
336            deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
337            for (i = 0; i < deps.length; i += 1) {
338                map = makeMap(deps[i], relParts);
339                depName = map.f;
340
341                //Fast path CommonJS standard dependencies.
342                if (depName === "require") {
343                    args[i] = handlers.require(name);
344                } else if (depName === "exports") {
345                    //CommonJS module spec 1.1
346                    args[i] = handlers.exports(name);
347                    usingExports = true;
348                } else if (depName === "module") {
349                    //CommonJS module spec 1.1
350                    cjsModule = args[i] = handlers.module(name);
351                } else if (hasProp(defined, depName) ||
352                           hasProp(waiting, depName) ||
353                           hasProp(defining, depName)) {
354                    args[i] = callDep(depName);
355                } else if (map.p) {
356                    map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
357                    args[i] = defined[depName];
358                } else {
359                    throw new Error(name + ' missing ' + depName);
360                }
361            }
362
363            ret = callback ? callback.apply(defined[name], args) : undefined;
364
365            if (name) {
366                //If setting exports via "module" is in play,
367                //favor that over return value and exports. After that,
368                //favor a non-undefined return value over exports use.
369                if (cjsModule && cjsModule.exports !== undef &&
370                        cjsModule.exports !== defined[name]) {
371                    defined[name] = cjsModule.exports;
372                } else if (ret !== undef || !usingExports) {
373                    //Use the return value from the function.
374                    defined[name] = ret;
375                }
376            }
377        } else if (name) {
378            //May just be an object definition for the module. Only
379            //worry about defining if have a module name.
380            defined[name] = callback;
381        }
382    };
383
384    requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
385        if (typeof deps === "string") {
386            if (handlers[deps]) {
387                //callback in this case is really relName
388                return handlers[deps](callback);
389            }
390            //Just return the module wanted. In this scenario, the
391            //deps arg is the module name, and second arg (if passed)
392            //is just the relName.
393            //Normalize module name, if it contains . or ..
394            return callDep(makeMap(deps, makeRelParts(callback)).f);
395        } else if (!deps.splice) {
396            //deps is a config object, not an array.
397            config = deps;
398            if (config.deps) {
399                req(config.deps, config.callback);
400            }
401            if (!callback) {
402                return;
403            }
404
405            if (callback.splice) {
406                //callback is an array, which means it is a dependency list.
407                //Adjust args if there are dependencies
408                deps = callback;
409                callback = relName;
410                relName = null;
411            } else {
412                deps = undef;
413            }
414        }
415
416        //Support require(['a'])
417        callback = callback || function () {};
418
419        //If relName is a function, it is an errback handler,
420        //so remove it.
421        if (typeof relName === 'function') {
422            relName = forceSync;
423            forceSync = alt;
424        }
425
426        //Simulate async callback;
427        if (forceSync) {
428            main(undef, deps, callback, relName);
429        } else {
430            //Using a non-zero value because of concern for what old browsers
431            //do, and latest browsers "upgrade" to 4 if lower value is used:
432            //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
433            //If want a value immediately, use require('id') instead -- something
434            //that works in almond on the global level, but not guaranteed and
435            //unlikely to work in other AMD implementations.
436            setTimeout(function () {
437                main(undef, deps, callback, relName);
438            }, 4);
439        }
440
441        return req;
442    };
443
444    /**
445     * Just drops the config on the floor, but returns req in case
446     * the config return value is used.
447     */
448    req.config = function (cfg) {
449        return req(cfg);
450    };
451
452    /**
453     * Expose module registry for debugging and tooling
454     */
455    requirejs._defined = defined;
456
457    define = function (name, deps, callback) {
458        if (typeof name !== 'string') {
459            throw new Error('See almond README: incorrect module build, no module name');
460        }
461
462        //This module may not have dependencies
463        if (!deps.splice) {
464            //deps is not an array, so probably means
465            //an object literal or factory function for
466            //the value. Adjust args.
467            callback = deps;
468            deps = [];
469        }
470
471        if (!hasProp(defined, name) && !hasProp(waiting, name)) {
472            waiting[name] = [name, deps, callback];
473        }
474    };
475
476    define.amd = {
477        jQuery: true
478    };
479}());
480
481S2.requirejs = requirejs;S2.require = require;S2.define = define;
482}
483}());
484S2.define("almond", function(){});
485
486/* global jQuery:false, $:false */
487S2.define('jquery',[],function () {
488  var _$ = jQuery || $;
489
490  if (_$ == null && console && console.error) {
491    console.error(
492      'Select2: An instance of jQuery or a jQuery-compatible library was not ' +
493      'found. Make sure that you are including jQuery before Select2 on your ' +
494      'web page.'
495    );
496  }
497
498  return _$;
499});
500
501S2.define('select2/utils',[
502  'jquery'
503], function ($) {
504  var Utils = {};
505
506  Utils.Extend = function (ChildClass, SuperClass) {
507    var __hasProp = {}.hasOwnProperty;
508
509    function BaseConstructor () {
510      this.constructor = ChildClass;
511    }
512
513    for (var key in SuperClass) {
514      if (__hasProp.call(SuperClass, key)) {
515        ChildClass[key] = SuperClass[key];
516      }
517    }
518
519    BaseConstructor.prototype = SuperClass.prototype;
520    ChildClass.prototype = new BaseConstructor();
521    ChildClass.__super__ = SuperClass.prototype;
522
523    return ChildClass;
524  };
525
526  function getMethods (theClass) {
527    var proto = theClass.prototype;
528
529    var methods = [];
530
531    for (var methodName in proto) {
532      var m = proto[methodName];
533
534      if (typeof m !== 'function') {
535        continue;
536      }
537
538      if (methodName === 'constructor') {
539        continue;
540      }
541
542      methods.push(methodName);
543    }
544
545    return methods;
546  }
547
548  Utils.Decorate = function (SuperClass, DecoratorClass) {
549    var decoratedMethods = getMethods(DecoratorClass);
550    var superMethods = getMethods(SuperClass);
551
552    function DecoratedClass () {
553      var unshift = Array.prototype.unshift;
554
555      var argCount = DecoratorClass.prototype.constructor.length;
556
557      var calledConstructor = SuperClass.prototype.constructor;
558
559      if (argCount > 0) {
560        unshift.call(arguments, SuperClass.prototype.constructor);
561
562        calledConstructor = DecoratorClass.prototype.constructor;
563      }
564
565      calledConstructor.apply(this, arguments);
566    }
567
568    DecoratorClass.displayName = SuperClass.displayName;
569
570    function ctr () {
571      this.constructor = DecoratedClass;
572    }
573
574    DecoratedClass.prototype = new ctr();
575
576    for (var m = 0; m < superMethods.length; m++) {
577      

577var superMethod = superMethods[m];
578
579      DecoratedClass.prototype[superMethod] =
580        SuperClass.prototype[superMethod];
581    }
582
583    var calledMethod = function (methodName) {
584      // Stub out the original method if it's not decorating an actual method
585      var originalMethod = function () {};
586
587      if (methodName in DecoratedClass.prototype) {
588        originalMethod = DecoratedClass.prototype[methodName];
589      }
590
591      var decoratedMethod = DecoratorClass.prototype[methodName];
592
593      return function () {
594        var unshift = Array.prototype.unshift;
595
596        unshift.call(arguments, originalMethod);
597
598        return decoratedMethod.apply(this, arguments);
599      };
600    };
601
602    for (var d = 0; d < decoratedMethods.length; d++) {
603      var decoratedMethod = decoratedMethods[d];
604
605      DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod);
606    }
607
608    return DecoratedClass;
609  };
610
611  var Observable = function () {
612    this.listeners = {};
613  };
614
615  Observable.prototype.on = function (event, callback) {
616    this.listeners = this.listeners || {};
617
618    if (event in this.listeners) {
619      this.listeners[event].push(callback);
620    } else {
621      this.listeners[event] = [callback];
622    }
623  };
624
625  Observable.prototype.trigger = function (event) {
626    var slice = Array.prototype.slice;
627    var params = slice.call(arguments, 1);
628
629    this.listeners = this.listeners || {};
630
631    // Params should always come in as an array
632    if (params == null) {
633      params = [];
634    }
635
636    // If there are no arguments to the event, use a temporary object
637    if (params.length === 0) {
638      params.push({});
639    }
640
641    // Set the `_type` of the first object to the event
642    params[0]._type = event;
643
644    if (event in this.listeners) {
645      this.invoke(this.listeners[event], slice.call(arguments, 1));
646    }
647
648    if ('*' in this.listeners) {
649      this.invoke(this.listeners['*'], arguments);
650    }
651  };
652
653  Observable.prototype.invoke = function (listeners, params) {
654    for (var i = 0, len = listeners.length; i < len; i++) {
655      listeners[i].apply(this, params);
656    }
657  };
658
659  Utils.Observable = Observable;
660
661  Utils.generateChars = function (length) {
662    var chars = '';
663
664    for (var i = 0; i < length; i++) {
665      var randomChar = Math.floor(Math.random() * 36);
666      chars += randomChar.toString(36);
667    }
668
669    return chars;
670  };
671
672  Utils.bind = function (func, context) {
673    return function () {
674      func.apply(context, arguments);
675    };
676  };
677
678  Utils._convertData = function (data) {
679    for (var originalKey in data) {
680      var keys = originalKey.split('-');
681
682      var dataLevel = data;
683
684      if (keys.length === 1) {
685        continue;
686      }
687
688      for (var k = 0; k < keys.length; k++) {
689        var key = keys[k];
690
691        // Lowercase the first letter
692        // By default, dash-separated becomes camelCase
693        key = key.substring(0, 1).toLowerCase() + key.substring(1);
694
695        if (!(key in dataLevel)) {
696          dataLevel[key] = {};
697        }
698
699        if (k == keys.length - 1) {
700          dataLevel[key] = data[originalKey];
701        }
702
703        dataLevel = dataLevel[key];
704      }
705
706      delete data[originalKey];
707    }
708
709    return data;
710  };
711
712  Utils.hasScroll = function (index, el) {
713    // Adapted from the function created by @ShadowScripter
714    // and adapted by @BillBarry on the Stack Exchange Code Review website.

894
895    this.$results.append($message);
896  };
897
898  Results.prototype.hideMessages = function () {
899    this.$results.find('.select2-results__message').remove();
900  };
901
902  Results.prototype.append = function (data) {
903    this.hideLoading();
904
905    var $options = [];
906
907    if (data.results == null || data.results.length === 0) {
908      if (this.$results.children().length === 0) {
909        this.trigger('results:message', {
910          message: 'noResults'
911        });
912      }
913
914      return;
915    }
916
917    data.results = this.sort(data.results);
918
919    for (var d = 0; d < data.results.length; d++) {
920      var item = data.results[d];
921
922      var $option = this.option(item);
923
924      $options.push($option);
925    }
926
927    this.$results.append($options);
928  };
929
930  Results.prototype.position = function ($results, $dropdown) {
931    var $resultsContainer = $dropdown.find('.select2-results');
932    $resultsContainer.append($results);
933  };
934
935  Results.prototype.sort = function (data) {
936    var sorter = this.options.get('sorter');
937
938    return sorter(data);
939  };
940
941  Results.prototype.highlightFirstItem = function () {
942    var $options = this.$results
943      .find('.select2-results__option[aria-selected]');
944
945    var $selected = $options.filter('[aria-selected=true]');
946
947    // Check if there are any selected options
948    if ($selected.length > 0) {
949      // If there are selected options, highlight the first
950      $selected.first().trigger('mouseenter');
951    } else {
952      // If there are no selected options, highlight the first option
953      // in the dropdown
954      $options.first().trigger('mouseenter');
955    }
956
957    this.ensureHighlightVisible();
958  };
959
960  Results.prototype.setClasses = function () {
961    var self = this;
962
963    this.data.current(function (selected) {
964      var selectedIds = $.map(selected, function (s) {
965        return s.id.toString();
966      });
967
968      var $options = self.$results
969        .find('.select2-results__option[aria-selected]');
970
971      $options.each(function () {
972        var $option = $(this);
973
974        var item = Utils.GetData(this, 'data');
975
976        // id needs to be converted to a string when comparing
977        var id = '' + item.id;
978
979        if ((item.element != null && item.element.selected) ||
980            (item.element == null && $.inArray(id, selectedIds) > -1)) {
981          $option.attr('aria-selected', 'true');
982        } else {
983          $option.attr('aria-selected', 'false');
984        }
985      });
986
987    });
988  };
989
990  Results.prototype.showLoading = function (params) {
991    this.hideLoading();
992
993    var loadingMore = this.options.get('translations').get('searching');
994
995    var loading = {
996      disabled: true,
997      loading: true,
998      text: loadingMore(params)
999    };
1000    var $loading = this.option(loading);
1001    $loading.className += ' loading-results';
1002
1003    this.$results.prepend($loading);
1004  };
1005
1006  Results.prototype.hideLoading = function () {
1007    this.$results.find('.loading-results').remove();
1008  };
1009
1010  Results.prototype.option = function (data) {
1011    var option = document.createElement('li');
1012    option.className = 'select2-results__option';
1013
1014    var attrs = {
1015      'role': 'option',
1016      'aria-selected': 'false'
1017    };
1018
1019    var matches = window.Element.prototype.matches ||
1020      window.Element.prototype.msMatchesSelector ||
1021      window.Element.prototype.webkitMatchesSelector;
1022
1023    if ((data.element != null && matches.call(data.element, ':disabled')) ||
1024        (data.element == null && data.disabled)) {
1025      delete attrs['aria-selected'];
1026      attrs['aria-disabled'] = 'true';
1027    }
1028
1029    if (data.id == null) {
1030      delete attrs['aria-selected'];
1031    }
1032
1033    if (data._resultId != null) {
1034      option.id = data._resultId;
1035    }
1036
1037    if (data.title) {
1038      option.title = data.title;
1039    }
1040
1041    if (data.children) {
1042      attrs.role = 'group';
1043      attrs['aria-label'] = data.text;
1044      delete attrs['aria-selected'];
1045    }
1046
1047    for (var attr in attrs) {
1048      var val = attrs[attr];
1049
1050      option.setAttribute(attr, val);
1051    }
1052
1053    if (data.children) {
1054      var $option = $(option);
1055
1056      var label = document.createElement('strong');
1057      label.className = 'select2-results__group';
1058
1059      var $label = $(label);
1060      this.template(data, label);
1061
1062      var $children = [];
1063
1064      for (var c = 0; c < data.children.length; c++) {
1065        var child = data.children[c];
1066
1067        var $child = this.option(child);
1068
1069        $children.push($child);
1070      }
1071
1072      var $childrenContainer = $('<ul></ul>', {
1073        'class': 'select2-results__options select2-results__options--nested'
1074      });
1075
1076      $childrenContainer.append($children);
1077
1078      $option.append(label);
1079      $option.append($childrenContainer);
1080    } else {
1081      this.template(data, option);
1082    }
1083
1084    Utils.StoreData(option, 'data', data);
1085
1086    return option;
1087  };
1088
1089  Results.prototype.bind = function (container, $container) {
1090    var self = this;
1091
1092    var id = container.id + '-results';
1093
1094    this.$results.attr('id', id);
1095
1096    container.on('results:all', function (params) {
1097      self.clear();
1098      self.append(params.data);
1099
1100      if (container.isOpen()) {
1101        self.setClasses();
1102        self.highlightFirstItem();
1103      }
1104    });
1105
1106    container.on('results:append', function (params) {
1107      self.append(params.data);
1108
1109      if (container.isOpen()) {
1110        self.setClasses();
1111      }
1112    });
1113
1114    container.on('query', function (params) {
1115      self.hideMessages();
1116      self.showLoading(params);
1117    });
1118
1119    container.on('select', function () {
1120      if (!container.isOpen()) {
1121        return;
1122      }
1123
1124      self.setClasses();
1125
1126      if (self.options.get('scrollAfterSelect')) {
1127        self.highlightFirstItem();
1128      }
1129    });
1130
1131    container.on('unselect', function () {
1132      if (!container.isOpen()) {
1133        return;
1134      }
1135
1136      self.setClasses();
1137
1138      if (self.options.get('scrollAfterSelect')) {
1139        self.highlightFirstItem();
1140      }
1141    });
1142
1143    container.on('open', function () {
1144      // When the dropdown is open, aria-expended="true"
1145      self.$results.attr('aria-expanded', 'true');
1146      self.$results.attr('aria-hidden', 'false');
1147
1148      self.setClasses();
1149      self.ensureHighlightVisible();
1150    });
1151
1152    container.on('close', function () {
1153      // When the dropdown is closed, aria-expended="false"
1154      self.$results.attr('aria-expanded', 'false');
1155      self.$results.attr('aria-hidden', 'true');
1156      self.$results.removeAttr('aria-activedescendant');
1157    });
1158
1159    container.on('results:toggle', function () {
1160      var $highlighted = self.getHighlightedResults();
1161
1162      if ($highlighted.length === 0) {
1163        return;
1164      }
1165
1166      $highlighted.trigger('mouseup');
1167    });
1168
1169    container.on('results:select', function () {
1170      var $highlighted = self.getHighlightedResults();
1171
1172      if ($highlighted.length === 0) {
1173        return;
1174      }
1175
1176      var data = Utils.GetData($highlighted[0], 'data');
1177
1178      if ($highlighted.attr('aria-selected') == 'true') {
1179        self.trigger('close', {});
1180      } else {
1181        self.trigger('select', {
1182          data: data
1183        });
1184      }
1185    });
1186
1187    container.on('results:previous', function () {
1188      var $highlighted = self.getHighlightedResults();
1189
1190      var $options = self.$results.find('[aria-selected]');
1191
1192      var currentIndex = $options.index($highlighted);
1193
1194      // If we are already at the top, don't move further
1195      // If no options, currentIndex will be -1
1196      if (currentIndex <= 0) {
1197        return;
1198      }
1199
1200      var nextIndex = currentIndex - 1;
1201
1202      // If none are highlighted, highlight the first
1203      if ($highlighted.length === 0) {
1204        nextIndex = 0;
1205      }
1206
1207      var $next = $options.eq(nextIndex);
1208
1209      $next.trigger('mouseenter');
1210
1211      var currentOffset = self.$results.offset().top;
1212      var nextTop = $next.offset().top;
1213      var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset);
1214
1215      if (nextIndex === 0) {
1216        self.$results.scrollTop(0);
1217      } else if (nextTop - currentOffset < 0) {
1218        self.$results.scrollTop(nextOffset);
1219      }
1220    });
1221
1222    container.on('results:next', function () {
1223      var $highlighted = self.getHighlightedResults();
1224
1225      var $options = self.$results.find('[aria-selected]');
1226
1227      var currentIndex = $options.index($highlighted);
1228
1229      var nextIndex = currentIndex + 1;
1230
1231      // If we are at the last option, stay there
1232      if (nextIndex >= $options.length) {
1233        return;
1234      }
1235
1236      var $next = $options.eq(nextIndex);
1237
1238      $next.trigger('mouseenter');
1239
1240      var currentOffset = self.$results.offset().top +
1241        self.$results.outerHeight(false);
1242      var nextBottom = $next.offset().top + $next.outerHeight(false);
1243      var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset;
1244
1245      if (nextIndex === 0) {
1246        self.$results.scrollTop(0);
1247      } else if (nextBottom > currentOffset) {
1248        self.$results.scrollTop(nextOffset);
1249      }
1250    });
1251
1252    container.on('results:focus', function (params) {
1253      params.element.addClass('select2-results__option--highlighted');
1254    });
1255
1256    container.on('results:message', function (params) {

1257      self.displayMessage(params);
1258    });
1259
1260    if ($.fn.mousewheel) {
1261      this.$results.on('mousewheel', function (e) {
1262        var top = self.$results.scrollTop();
1263
1264        var bottom = self.$results.get(0).scrollHeight - top + e.deltaY;
1265
1266        var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0;
1267        var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height();
1268
1269        if (isAtTop) {
1270          self.$results.scrollTop(0);
1271
1272          e.preventDefault();
1273          e.stopPropagation();
1274        } else if (isAtBottom) {
1275          self.$results.scrollTop(
1276            self.$results.get(0).scrollHeight - self.$results.height()
1277          );
1278
1279          e.preventDefault();
1280          e.stopPropagation();
1281        }
1282      });
1283    }
1284
1285    this.$results.on('mouseup', '.select2-results__option[aria-selected]',
1286      function (evt) {
1287      var $this = $(this);
1288
1289      var data = Utils.GetData(this, 'data');
1290
1291      if ($this.attr('aria-selected') === 'true') {
1292        if (self.options.get('multiple')) {
1293          self.trigger('unselect', {
1294            originalEvent: evt,
1295            data: data
1296          });
1297        } else {
1298          self.trigger('close', {});
1299        }
1300
1301        return;
1302      }
1303
1304      self.trigger('select', {
1305        originalEvent: evt,
1306        data: data
1307      });
1308    });
1309
1310    this.$results.on('mouseenter', '.select2-results__option[aria-selected]',
1311      function (evt) {
1312      var data = Utils.GetData(this, 'data');
1313
1314      self.getHighlightedResults()
1315          .removeClass('select2-results__option--highlighted');
1316
1317      self.trigger('results:focus', {
1318        data: data,
1319        element: $(this)
1320      });
1321    });
1322  };
1323
1324  Results.prototype.getHighlightedResults = function () {
1325    var $highlighted = this.$results
1326    .find('.select2-results__option--highlighted');
1327
1328    return $highlighted;
1329  };
1330
1331  Results.prototype.destroy = function () {
1332    this.$results.remove();
1333  };
1334
1335  Results.prototype.ensureHighlightVisible = function () {
1336    var $highlighted = this.getHighlightedResults();
1337
1338    if ($highlighted.length === 0) {
1339      return;
1340    }
1341
1342    var $options = this.$results.find('[aria-selected]');
1343
1344    var currentIndex = $options.index($highlighted);
1345
1346    var currentOffset = this.$results.offset().top;
1347    var nextTop = $highlighted.offset().top;
1348    var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset);
1349
1350    var offsetDelta = nextTop - currentOffset;
1351    nextOffset -= $highlighted.outerHeight(false) * 2;
1352
1353    if (currentIndex <= 2) {
1354      this.$results.scrollTop(0);
1355    } else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) {
1356      this.$results.scrollTop(nextOffset);
1357    }
1358  };
1359
1360  Results.prototype.template = function (result, container) {
1361    var template = this.options.get('templateResult');
1362    var escapeMarkup = this.options.get('escapeMarkup');
1363
1364    var content = template(result, container);
1365
1366    if (content == null) {
1367      container.style.display = 'none';
1368    } else if (typeof content === 'string') {
1369      container.innerHTML = escapeMarkup(content);
1370    } else {
1371      $(container).append(content);
1372    }
1373  };
1374
1375  return Results;
1376});
1377
1378S2.define('select2/keys',[
1379
1380], function () {
1381  var KEYS = {
1382    BACKSPACE: 8,
1383    TAB: 9,
1384    ENTER: 13,
1385    SHIFT: 16,
1386    CTRL: 17,
1387    ALT: 18,
1388    ESC: 27,
1389    SPACE: 32,
1390    PAGE_UP: 33,
1391    PAGE_DOWN: 34,
1392    END: 35,
1393    HOME: 36,
1394    LEFT: 37,
1395    UP: 38,
1396    RIGHT: 39,
1397    DOWN: 40,
1398    DELETE: 46
1399  };
1400
1401  return KEYS;
1402});
1403
1404S2.define('select2/selection/base',[
1405  'jquery',
1406  '../utils',
1407  '../keys'
1408], function ($, Utils, KEYS) {
1409  function BaseSelection ($element, options) {
1410    this.$element = $element;
1411    this.options = options;
1412
1413    BaseSelection.__super__.constructor.call(this);
1414  }
1415
1416  Utils.Extend(BaseSelection, Utils.Observable);
1417
1418  BaseSelection.prototype.render = function () {
1419    var $selection = $(
1420      '<span class="select2-selection" role="combobox" ' +
1421      ' aria-haspopup="true" aria-expanded="false">' +
1422      '</span>'
1423    );
1424
1425    this._tabindex = 0;
1426
1427    if (Utils.GetData(this.$element[0], 'old-tabindex') != null) {
1428      this._tabindex = Utils.GetData(this.$element[0], 'old-tabindex');
1429    } else if (this.$element.attr('tabindex') != null) {
1430      this._tabindex = this.$element.attr('tabindex');
1431    }
1432
1433    $selection.attr('title', this.$element.attr('title'));
1434    $selection.attr('tabindex', this._tabindex);
1435    $selection.attr('aria-disabled', 'false');
1436
1437    this.$selection = $selection;
1438
1439    return $selection;
1440  };
1441
1442  BaseSelection.prototype.bind = function (container, $container) {
1443    var self = this;
1444
1445    var resultsId = container.id + '-results';
1446
1447    this.container = container;
1448
1449    this.$selection.on('focus', function (evt) {
1450      self.trigger('focus', evt);
1451    });
1452
1453    this.$selection.on('blur', function (evt) {
1454      self._handleBlur(evt);
1455    });
1456
1457    this.$selection.on('keydown', function (evt) {
1458      self.trigger('keypress', evt);
1459
1460      if (evt.which === KEYS.SPACE) {
1461        evt.preventDefault();
1462      }
1463    });
1464
1465    container.on('results:focus', function (params) {
1466      self.$selection.attr('aria-activedescendant', params.data._resultId);
1467    });
1468
1469    container.on('selection:update', function (params) {
1470      self.update(params.data);
1471    });
1472
1473    container.on('open', function () {
1474      // When the dropdown is open, aria-expanded="true"
1475      self.$selection.attr('aria-expanded', 'true');
1476      self.$selection.attr('aria-owns', resultsId);
1477
1478      self._attachCloseHandler(container);
1479    });
1480
1481    container.on('close', function () {
1482      // When the dropdown is closed, aria-expanded="false"
1483      self.$selection.attr('aria-expanded', 'false');
1484      self.$selection.removeAttr('aria-activedescendant');
1485      self.$selection.removeAttr('aria-owns');
1486
1487      self.$selection.trigger('focus');
1488
1489      self._detachCloseHandler(container);
1490    });
1491
1492    container.on('enable', function () {
1493      self.$selection.attr('tabindex', self._tabindex);
1494      self.$selection.attr('aria-disabled', 'false');
1495    });
1496
1497    container.on('disable', function () {
1498      self.$selection.attr('tabindex', '-1');
1499      self.$selection.attr('aria-disabled', 'true');
1500    });
1501  };
1502
1503  BaseSelection.prototype._handleBlur = function (evt) {
1504    var self = this;
1505
1506    // This needs to be delayed as the active element is the body when the tab
1507    // key is pressed, possibly along with others.
1508    window.setTimeout(function () {
1509      // Don't trigger `blur` if the focus is still in the selection
1510      if (
1511        (document.activeElement == self.$selection[0]) ||
1512        ($.contains(self.$selection[0], document.activeElement))
1513      ) {
1514        return;
1515      }
1516
1517      self.trigger('blur', evt);
1518    }, 1);
1519  };
1520
1521  BaseSelection.prototype._attachCloseHandler = function (container) {
1522
1523    $(document.body).on('mousedown.select2.' + container.id, function (e) {
1524      var $target = $(e.target);
1525
1526      var $select = $target.closest('.select2');
1527
1528      var $all = $('.select2.select2-container--open');
1529
1530      $all.each(function () {
1531        if (this == $select[0]) {
1532          return;
1533        }
1534
1535        var $element = Utils.GetData(this, 'element');
1536
1537        $element.select2('close');
1538      });
1539    });
1540  };
1541
1542  BaseSelection.prototype._detachCloseHandler = function (container) {
1543    $(document.body).off('mousedown.select2.' + container.id);
1544  };
1545
1546  BaseSelection.prototype.position = function ($selection, $container) {
1547    var $selectionContainer = $container.find('.selection');
1548    $selectionContainer.append($selection);
1549  };
1550
1551  BaseSelection.prototype.destroy = function () {
1552    this._detachCloseHandler(this.container);
1553  };
1554
1555  BaseSelection.prototype.update = function (data) {
1556    throw new Error('The `update` method must be defined in child classes.');
1557  };
1558
1559  /**
1560   * Helper method to abstract the "enabled" (not "disabled") state of this
1561   * object.
1562   *
1563   * @return {true} if the instance is not disabled.
1564   * @return {false} if the instance is disabled.
1565   */
1566  BaseSelection.prototype.isEnabled = function () {
1567    return !this.isDisabled();
1568  };
1569
1570  /**
1571   * Helper method to abstract the "disabled" state of this object.
1572   *
1573   * @return {true} if the disabled option is true.
1574   * @return {false} if the disabled option is false.
1575   */
1576  BaseSelection.prototype.isDisabled = function () {
1577    return this.options.get('disabled');
1578  };
1579
1580  return BaseSelection;
1581});
1582
1583S2.define('select2/selection/single',[
1584  'jquery',
1585  './base',
1586  '../utils',
1587  '../keys'
1588], function ($, BaseSelection, Utils, KEYS) {
1589  function SingleSelection () {
1590    SingleSelection.__super__.constructor.apply(this, arguments);
1591  }
1592
1593  Utils.Extend(SingleSelection, BaseSelection);
1594
1595  SingleSelection.prototype.render = function () {
1596    var $selection = SingleSelection.__super__.render.call(this);
1597
1598    $selection.addClass('select2-selection--single');
1599
1600    $selection.html(
1601      '<span class="select2-selection__rendered"></span>' +
1602      '<span class="select2-selection__arrow" role="presentation">' +
1603        '<b role="presentation"></b>' +
1604      '</span>'
1605    );
1606
1607    return $selection;
1608  };
1609
1610  SingleSelection.prototype.bind = function (container, $container) {
1611    var self = this;
1612
1613    SingleSelection.__super__.bind.apply(this, arguments);
1614
1615    var id = container.id + '-container';
1616
1617    this.$selection.find('.select2-selection__rendered')
1618      .attr('id', id)
1619      .attr('role', 'textbox')
1620      .attr('aria-readonly', 'true');
1621    this.$selection.attr('aria-labelledby', id);
1622
1623    this.$selection.on('mousedown', function (evt) {
1624      // Only respond to left clicks
1625      if (evt.which !== 1) {
1626        return;
1627      }
1628
1629      self.trigger('toggle', {
1630        originalEvent: evt
1631      });
1632    });
1633
1634    this.$selection.on('focus', function (evt) {
1635      // User focuses on the container
1636    });
1637
1638    this.$selection.on('blur', function (evt) {
1639      // User exits the container
1640    });
1641
1642    container.on('focus', function (evt) {
1643      if (!container.isOpen()) {
1644        self.$selection.trigger('focus');
1645      }
1646    });
1647  };
1648
1649  SingleSelection.prototype.clear = function () {
1650    var $rendered = this.$selection.find('.select2-selection__rendered');
1651    $rendered.empty();
1652    $rendered.removeAttr('title'); // clear tooltip on empty
1653  };
1654
1655  SingleSelection.prototype.display = function (data, container) {
1656    var template = this.options.get('templateSelection');
1657    var escapeMarkup = this.options.get('escapeMarkup');
1658
1659    return escapeMarkup(template(data, container));
1660  };
1661
1662  SingleSelection.prototype.selectionContainer = function () {
1663    return $('<span></span>');
1664  };
1665
1666  SingleSelection.prototype.update = function (data) {
1667    if (data.length === 0) {
1668      this.clear();
1669      return;
1670    }
1671
1672    var selection = data[0];
1673
1674    var $rendered = this.$selection.find('.select2-selection__rendered');
1675    var formatted = this.display(selection, $rendered);
1676
1677    $rendered.empty().append(formatted);
1678
1679    var title = selection.title || selection.text;
1680
1681    if (title) {
1682      $rendered.attr('title', title);
1683    } else {
1684      $rendered.removeAttr('title');
1685    }
1686  };
1687
1688  return SingleSelection;
1689});
1690
1691S2.define('select2/selection/multiple',[
1692  'jquery',
1693  './base',
1694  '../utils'
1695], function ($, BaseSelection, Utils) {
1696  function MultipleSelection ($element, options) {
1697    MultipleSelection.__super__.constructor.apply(this, arguments);
1698  }
1699
1700  Utils.Extend(MultipleSelection, BaseSelection);
1701
1702  MultipleSelection.prototype.render = function () {
1703    var $selection = MultipleSelection.__super__.render.call(this);
1704
1705    $selection.addClass('select2-selection--multiple');
1706
1707    $selection.html(
1708      '<ul class="select2-selection__rendered"></ul>'
1709    );
1710
1711    return $selection;
1712  };
1713
1714  MultipleSelection.prototype.bind = function (container, $container) {
1715    var self = this;
1716
1717    MultipleSelection.__super__.bind.apply(this, arguments);
1718
1719    this.$selection.on('click', function (evt) {
1720      self.trigger('toggle', {
1721        originalEvent: evt
1722      });
1723    });
1724
1725    this.$selection.on(
1726      'click',
1727      '.select2-selection__choice__remove',
1728      function (evt) {
1729        // Ignore the event if it is disabled
1730        if (self.isDisabled()) {
1731          return;
1732        }
1733
1734        var $remove = $(this);
1735        var $selection = $remove.parent();
1736
1737        var data = Utils.GetData($selection[0], 'data');
1738
1739        self.trigger('unselect', {
1740          originalEvent: evt,
1741          data: data
1742        });
1743      }
1744    );
1745  };
1746
1747  MultipleSelection.prototype.clear = function () {
1748    var $rendered = this.$selection.find('.select2-selection__rendered');
1749    $rendered.empty();
1750    $rendered.removeAttr('title');
1751  };
1752
1753  MultipleSelection.prototype.display = function (data, container) {
1754    var template = this.options.get('templateSelection');
1755    var escapeMarkup = this.options.get('escapeMarkup');
1756
1757    return escapeMarkup(template(data, container));
1758  };
1759
1760  MultipleSelection.prototype.selectionContainer = function () {
1761    var $container = $(
1762      '<li class="select2-selection__choice">' +
1763        '<span class="select2-selection__choice__remove" role="presentation">' +
1764          '&times;' +
1765        '</span>' +
1766      '</li>'
1767    );
1768
1769    return $container;
1770  };
1771
1772  MultipleSelection.prototype.update = function (data) {
1773    this.clear();
1774
1775    if (data.length === 0) {
1776      return;
1777    }
1778
1779    var $selections = [];
1780
1781    for (var d = 0; d < data.length; d++) {
1782      var selection = data[d];
1783
1784      var $selection = this.selectionContainer();
1785      var formatted = this.display(selection, $selection);
1786
1787      $selection.append(formatted);
1788
1789      var title = selection.title || selection.text;
1790
1791      if (title) {
1792        $selection.attr('title', title);
1793      }
1794
1795      Utils.StoreData($selection[0], 'data', selection);
1796
1797      $selections.push($selection);
1798    }
1799
1800    var $rendered = this.$selection.find('.select2-selection__rendered');
1801
1802    Utils.appendMany($rendered, $selections);
1803  };
1804
1805  return MultipleSelection;
1806});
1807
1808S2.define('select2/selection/placeholder',[
1809  '../utils'
1810], function (Utils) {
1811  function Placeholder (decorated, $element, options) {
1812    this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
1813
1814    decorated.call(this, $element, options);
1815  }
1816
1817  Placeholder.prototype.normalizePlaceholder = function (_, placeholder) {
1818    if (typeof placeholder === 'string') {
1819      placeholder = {
1820        id: '',
1821        text: placeholder
1822      };
1823    }
1824
1825    return placeholder;
1826  };
1827
1828  Placeholder.prototype.createPlaceholder = function (decorated, placeholder) {
1829    var $placeholder = this.selectionContainer();
1830
1831    $placeholder.html(this.display(placeholder));
1832    $placeholder.addClass('select2-selection__placeholder')
1833                .removeClass('select2-selection__choice');
1834
1835    return $placeholder;
1836  };
1837
1838  Placeholder.prototype.update = function (decorated, data) {
1839    var singlePlaceholder = (
1840      data.length == 1 && data[0].id != this.placeholder.id
1841    );
1842    var multipleSelections = data.length > 1;
1843
1844    if (multipleSelections || singlePlaceholder) {
1845      return decorated.call(this, data);
1846    }
1847
1848    this.clear();
1849
1850    var $placeholder = this.createPlaceholder(this.placeholder);
1851
1852    this.$selection.find('.select2-selection__rendered').append($placeholder);
1853  };
1854
1855  return Placeholder;
1856});
1857
1858S2.define('select2/selection/allowClear',[
1859  'jquery',
1860  '../keys',
1861  '../utils'
1862], function ($, KEYS, Utils) {
1863  function AllowClear () { }
1864
1865  AllowClear.prototype.bind = function (decorated, container, $container) {
1866    var self = this;
1867
1868    decorated.call(this, container, $container);
1869
1870    if (this.placeholder == null) {
1871      if (this.options.get('debug') && window.console && console.error) {
1872        console.error(
1873          'Select2: The `allowClear` option should be used in combination ' +
1874          'with the `placeholder` option.'
1875        );
1876      }
1877    }
1878
1879    this.$selection.on('mousedown', '.select2-selection__clear',
1880      function (evt) {
1881        self._handleClear(evt);
1882    });
1883
1884    container.on('keypress', function (evt) {
1885      self._handleKeyboardClear(evt, container);
1886    });
1887  };
1888
1889  AllowClear.prototype._handleClear = function (_, evt) {
1890    // Ignore the event if it is disabled
1891    if (this.isDisabled()) {
1892      return;
1893    }
1894
1895    var $clear = this.$selection.find('.select2-selection__clear');
1896
1897    // Ignore the event if nothing has been selected
1898    if ($clear.length === 0) {
1899      return;
1900    }
1901
1902    evt.stopPropagation();
1903
1904    var data = Utils.GetData($clear[0], 'data');
1905
1906    var previousVal = this.$element.val();
1907    this.$element.val(this.placeholder.id);
1908
1909    var unselectData = {
1910      data: data
1911    };
1912    this.trigger('clear', unselectData);
1913    if (unselectData.prevented) {
1914      this.$element.val(previousVal);
1915      return;
1916    }
1917
1918    for (var d = 0; d < data.length; d++) {
1919      unselectData = {
1920        data: data[d]
1921      };
1922
1923      // Trigger the `unselect` event, so people can prevent it from being
1924      // cleared.
1925      this.trigger('unselect', unselectData);
1926
1927      // If the event was prevented, don't clear it out.
1928      if (unselectData.prevented) {
1929        this.$element.val(previousVal);
1930        return;
1931      }
1932    }
1933
1934    this.$element.trigger('input').trigger('change');
1935
1936    this.trigger('toggle', {});
1937  };
1938
1939  AllowClear.prototype._handleKeyboardClear = function (_, evt, container) {
1940    if (container.isOpen()) {
1941      return;
1942    }
1943
1944    if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) {
1945      this._handleClear(evt);
1946    }
1947  };
1948
1949  AllowClear.prototype.update = function (decorated, data) {
1950    decorated.call(this, data);
1951
1952    if (this.$selection.find('.select2-selection__placeholder').length > 0 ||
1953        data.length === 0) {
1954      return;
1955    }
1956
1957    var removeAll = this.options.get('translations').get('removeAllItems');
1958
1959    var $remove = $(
1960      '<span class="select2-selection__clear" title="' + removeAll() +'">' +
1961        '&times;' +
1962      '</span>'
1963    );
1964    Utils.StoreData($remove[0], 'data', data);
1965
1966    this.$selection.find('.select2-selection__rendered').prepend($remove);
1967  };
1968
1969  return AllowClear;
1970});
1971
1972S2.define('select2/selection/search',[
1973  'jquery',
1974  '../utils',
1975  '../keys'
1976], function ($, Utils, KEYS) {
1977  function Search (decorated, $element, options) {
1978    decorated.call(this, $element, options);
1979  }
1980
1981  Search.prototype.render = function (decorated) {
1982    var $search = $(
1983      '<li class="select2-search select2-search--inline">' +
1984        '<input class="select2-search__field" type="search" tabindex="-1"' +
1985        ' autocomplete="off" autocorrect="off" autocapitalize="none"' +
1986        ' spellcheck="false" role="searchbox" aria-autocomplete="list" />' +
1987      '</li>'
1988    );
1989
1990    this.$searchContainer = $search;
1991    this.$search = $search.find('input');
1992
1993    var $rendered = decorated.call(this);
1994
1995    this._transferTabIndex();
1996
1997    return $rendered;
1998  };
1999
2000  Search.prototype.bind = function (decorated, container, $container) {
2001    var self = this;
2002
2003    var resultsId = container.id + '-results';
2004
2005    decorated.call(this, container, $container);
2006
2007    container.on('open', function () {
2008      self.$search.attr('aria-controls', resultsId);
2009      self.$search.trigger('focus');
2010    });
2011
2012    container.on('close', function () {
2013      self.$search.val('');
2014      self.$search.removeAttr('aria-controls');
2015      self.$search.removeAttr('aria-activedescendant');
2016      self.$search.trigger('focus');
2017    });
2018
2019    container.on('enable', function () {
2020      self.$search.prop('disabled', false);
2021
2022      self._transferTabIndex();
2023    });
2024
2025    container.on('disable', function () {
2026      self.$search.prop('disabled', true);
2027    });
2028
2029    container.on('focus', function (evt) {
2030      self.$search.trigger('focus');
2031    });
2032
2033    container.on('results:focus', function (params) {
2034      if (params.data._resultId) {
2035        self.$search.attr('aria-activedescendant', params.data._resultId);
2036      } else {
2037        self.$search.removeAttr('aria-activedescendant');
2038      }
2039    });
2040
2041    this.$selection.on('focusin', '.select2-search--inline', function (evt) {
2042      self.trigger('focus', evt);
2043    });
2044
2045    this.$selection.on('focusout', '.select2-search--inline', function (evt) {
2046      self._handleBlur(evt);
2047    });
2048
2049    this.$selection.on('keydown', '.select2-search--inline', function (evt) {
2050      evt.stopPropagation();
2051
2052      self.trigger('keypress', evt);
2053
2054      self._keyUpPrevented = evt.isDefaultPrevented();
2055
2056      var key = evt.which;
2057
2058      if (key === KEYS.BACKSPACE && self.$search.val() === '') {
2059        var $previousChoice = self.$searchContainer
2060          .prev('.select2-selection__choice');
2061
2062        if ($previousChoice.length > 0) {
2063          var item = Utils.GetData($previousChoice[0], 'data');
2064
2065          self.searchRemoveChoice(item);
2066
2067          evt.preventDefault();
2068        }
2069      }
2070    });
2071
2072    this.$selection.on('click', '.select2-search--inline', function (evt) {
2073      if (self.$search.val()) {
2074        evt.stopPropagation();
2075      }
2076    });
2077
2078    // Try to detect the IE version should the `documentMode` property that
2079    // is stored on the document. This is only implemented in IE and is
2080    // slightly cleaner than doing a user agent check.
2081    // This property is not available in Edge, but Edge also doesn't have
2082    // this bug.
2083    var msie = document.documentMode;
2084    var disableInputEvents = msie && msie <= 11;
2085
2086    // Workaround for browsers which do not support the `input` event
2087    // This will prevent double-triggering of events for browsers which support
2088    // both the `keyup` and `input` events.
2089    this.$selection.on(
2090      'input.searchcheck',
2091      '.select2-search--inline',
2092      function (evt) {
2093        // IE will trigger the `input` event when a placeholder is used on a
2094        // search box. To get around this issue, we are forced to ignore all
2095        // `input` events in IE and keep using `keyup`.
2096        if (disableInputEvents) {
2097          self.$selection.off('input.search input.searchcheck');
2098          return;
2099        }
2100
2101        // Unbind the duplicated `keyup` event
2102        self.$selection.off('keyup.search');
2103      }
2104    );
2105
2106    this.$selection.on(
2107      'keyup.search input.search',
2108      '.select2-search--inline',
2109      function (evt) {
2110        // IE will trigger the `input` event when a placeholder is used on a
2111        // search box. To get around this issue, we are forced to ignore all
2112        // `input` events in IE and keep using `keyup`.
2113        if (disableInputEvents && evt.type === 'input') {
2114          self.$selection.off('input.search input.searchcheck');
2115          return;
2116        }
2117
2118        var key = evt.which;
2119
2120        // We can freely ignore events from modifier keys
2121        if (key == KEYS.SHIFT || key == KEYS.CTRL || key == KEYS.ALT) {
2122          return;
2123        }
2124
2125        // Tabbing will be handled during the `keydown` phase
2126        if (key == KEYS.TAB) {
2127          return;
2128        }
2129
2130        self.handleSearch(evt);
2131      }
2132    );
2133  };
2134
2135  /**
2136   * This method will transfer the tabindex attribute from the rendered
2137   * selection to the search box. This allows for the search box to be used as
2138   * the primary focus instead of the selection container.
2139   *
2140   * @private
2141   */
2142  Search.prototype._transferTabIndex = function (decorated) {
2143    this.$search.attr('tabindex', this.$selection.attr('tabindex'));
2144    this.$selection.attr('tabindex', '-1');
2145  };
2146
2147  Search.prototype.createPlaceholder = function (decorated, placeholder) {
2148    this.$search.attr('placeholder', placeholder.text);
2149  };
2150
2151  Search.prototype.update = function (decorated, data) {
2152    var searchHadFocus = this.$search[0] == document.activeElement;
2153
2154    this.$search.attr('placeholder', '');
2155
2156    decorated.call(this, data);
2157
2158    this.$selection.find('.select2-selection__rendered')
2159                   .append(this.$searchContainer);
2160
2161    this.resizeSearch();
2162    if (searchHadFocus) {
2163      this.$search.trigger('focus');
2164    }
2165  };
2166
2167  Search.prototype.handleSearch = function () {
2168    this.resizeSearch();
2169
2170    if (!this._keyUpPrevented) {
2171      var input = this.$search.val();
2172
2173      this.trigger('query', {
2174        term: input
2175      });
2176    }
2177
2178    this._keyUpPrevented = false;

2179  };
2180
2181  Search.prototype.searchRemoveChoice = function (decorated, item) {
2182    this.trigger('unselect', {
2183      data: item
2184    });
2185
2186    this.$search.val(item.text);
2187    this.handleSearch();
2188  };
2189
2190  Search.prototype.resizeSearch = function () {
2191    this.$search.css('width', '25px');
2192
2193    var width = '';
2194
2195    if (this.$search.attr('placeholder') !== '') {
2196      width = this.$selection.find('.select2-selection__rendered').width();
2197    } else {
2198      var minimumWidth = this.$search.val().length + 1;
2199
2200      width = (minimumWidth * 0.75) + 'em';
2201    }
2202
2203    this.$search.css('width', width);
2204  };
2205
2206  return Search;
2207});
2208
2209S2.define('select2/selection/eventRelay',[
2210  'jquery'
2211], function ($) {
2212  function EventRelay () { }
2213
2214  EventRelay.prototype.bind = function (decorated, container, $container) {
2215    var self = this;
2216    var relayEvents = [
2217      'open', 'opening',
2218      'close', 'closing',
2219      'select', 'selecting',
2220      'unselect', 'unselecting',
2221      'clear', 'clearing'
2222    ];
2223
2224    var preventableEvents = [
2225      'opening', 'closing', 'selecting', 'unselecting', 'clearing'
2226    ];
2227
2228    decorated.call(this, container, $container);
2229
2230    container.on('*', function (name, params) {
2231      // Ignore events that should not be relayed
2232      if ($.inArray(name, relayEvents) === -1) {
2233        return;
2234      }
2235
2236      // The parameters should always be an object
2237      params = params || {};
2238
2239      // Generate the jQuery event for the Select2 event
2240      var evt = $.Event('select2:' + name, {
2241        params: params
2242      });
2243
2244      self.$element.trigger(evt);
2245
2246      // Only handle preventable events if it was one
2247      if ($.inArray(name, preventableEvents) === -1) {
2248        return;
2249      }
2250
2251      params.prevented = evt.isDefaultPrevented();
2252    });
2253  };
2254
2255  return EventRelay;
2256});
2257
2258S2.define('select2/translation',[
2259  'jquery',
2260  'require'
2261], function ($, require) {
2262  function Translation (dict) {
2263    this.dict = dict || {};
2264  }
2265
2266  Translation.prototype.all = function () {
2267    return this.dict;
2268  };
2269
2270  Translation.prototype.get = function (key) {
2271    return this.dict[key];
2272  };
2273
2274  Translation.prototype.extend = function (translation) {
2275    this.dict = $.extend({}, translation.all(), this.dict);
2276  };
2277
2278  // Static functions
2279
2280  Translation._cache = {};
2281
2282  Translation.loadPath = function (path) {
2283    if (!(path in Translation._cache)) {
2284      var translations = require(path);
2285
2286      Translation._cache[path] = translations;
2287    }
2288
2289    return new Translation(Translation._cache[path]);
2290  };
2291
2292  return Translation;
2293});
2294
2295S2.define('select2/diacritics',[
2296
2297], function () {
2298  var diacritics = {
2299    '\u24B6': 'A',
2300    '\uFF21': 'A',
2301    '\u00C0': 'A',
2302    '\u00C1': 'A',
2303    '\u00C2': 'A',
2304    '\u1EA6': 'A',
2305    '\u1EA4': 'A',
2306    '\u1EAA': 'A',
2307    '\u1EA8': 'A',
2308    '\u00C3': 'A',
2309    '\u0100': 'A',
2310    '\u0102': 'A',
2311    '\u1EB0': 'A',
2312    '\u1EAE': 'A',
2313    '\u1EB4': 'A',
2314    '\u1EB2': 'A',
2315    '\u0226': 'A',
2316    '\u01E0': 'A',
2317    '\u00C4': 'A',
2318    '\u01DE': 'A',
2319    '\u1EA2': 'A',
2320    '\u00C5': 'A',
2321    '\u01FA': 'A',
2322    '\u01CD': 'A',
2323    '\u0200': 'A',
2324    '\u0202': 'A',
2325    '\u1EA0': 'A',
2326    '\u1EAC': 'A',
2327    '\u1EB6': 'A',
2328    '\u1E00': 'A',
2329    '\u0104': 'A',
2330    '\u023A': 'A',
2331    '\u2C6F': 'A',
2332    '\uA732': 'AA',
2333    '\u00C6': 'AE',
2334    '\u01FC': 'AE',
2335    '\u01E2': 'AE',
2336    '\uA734': 'AO',
2337    '\uA736': 'AU',
2338    '\uA738': 'AV',
2339    '\uA73A': 'AV',
2340    '\uA73C': 'AY',
2341    '\u24B7': 'B',
2342    '\uFF22': 'B',
2343    '\u1E02': 'B',
2344    '\u1E04': 'B',
2345    '\u1E06': 'B',
2346    '\u0243': 'B',
2347    '\u0182': 'B',
2348    '\u0181': 'B',
2349    '\u24B8': 'C',
2350    '\uFF23': 'C',
2351    '\u0106': 'C',
2352    '\u0108': 'C',
2353    '\u010A': 'C',
2354    '\u010C': 'C',
2355    '\u00C7': 'C',
2356    '\u1E08': 'C',
2357    '\u0187': 'C',
2358    '\u023B': 'C',
2359    '\uA73E': 'C',
2360    '\u24B9': 'D',
2361    '\uFF24': 'D',
2362    '\u1E0A': 'D',
2363    '\u010E': 'D',
2364    '\u1E0C': 'D',
2365    '\u1E10': 'D',
2366    '\u1E12': 'D',
2367    '\u1E0E': 'D',
2368    '\u0110': 'D',
2369    '\u018B': 'D',
2370    '\u018A': 'D',
2371    '\u0189': 'D',
2372    '\uA779': 'D',
2373    '\u01F1': 'DZ',
2374    '\u01C4': 'DZ',
2375    '\u01F2': 'Dz',
2376    '\u01C5': 'Dz',
2377    '\u24BA': 'E',
2378    '\uFF25': 'E',
2379    '\u00C8': 'E',
2380    '\u00C9': 'E',
2381    '\u00CA': 'E',
2382    '\u1EC0': 'E',
2383    '\u1EBE': 'E',
2384    '\u1EC4': 'E',
2385    '\u1EC2': 'E',
2386    '\u1EBC': 'E',
2387    '\u0112': 'E',
2388    '\u1E14': 'E',
2389    '\u1E16': 'E',
2390    '\u0114': 'E',
2391    '\u0116': 'E',
2392    '\u00CB': 'E',
2393    '\u1EBA': 'E',
2394    '\u011A': 'E',
2395    '\u0204': 'E',
2396    '\u0206': 'E',
2397    '\u1EB8': 'E',
2398    '\u1EC6': 'E',
2399    '\u0228': 'E',
2400    '\u1E1C': 'E',
2401    '\u0118': 'E',
2402    '\u1E18': 'E',
2403    '\u1E1A': 'E',
2404    '\u0190': 'E',
2405    '\u018E': 'E',
2406    '\u24BB': 'F',
2407    '\uFF26': 'F',
2408    '\u1E1E': 'F',
2409    '\u0191': 'F',
2410    '\uA77B': 'F',
2411    '\u24BC': 'G',
2412    '\uFF27': 'G',
2413    '\u01F4': 'G',
2414    '\u011C': 'G',
2415    '\u1E20': 'G',
2416    '\u011E': 'G',
2417    '\u0120': 'G',
2418    '\u01E6': 'G',
2419    '\u0122': 'G',
2420    '\u01E4': 'G',
2421    '\u0193': 'G',
2422    '\uA7A0': 'G',
2423    '\uA77D': 'G',
2424    '\uA77E': 'G',
2425    '\u24BD': 'H',
2426    '\uFF28': 'H',
2427    '\u0124': 'H',
2428    '\u1E22': 'H',
2429    '\u1E26': 'H',
2430    '\u021E': 'H',
2431    '\u1E24': 'H',
2432    '\u1E28': 'H',
2433    '\u1E2A': 'H',
2434    '\u0126': 'H',
2435    '\u2C67': 'H',
2436    '\u2C75': 'H',
2437    '\uA78D': 'H',
2438    '\u24BE': 'I',
2439    '\uFF29': 'I',
2440    '\u00CC': 'I',
2441    '\u00CD': 'I',
2442    '\u00CE': 'I',
2443    '\u0128': 'I',
2444    '\u012A': 'I',
2445    '\u012C': 'I',
2446    '\u0130': 'I',
2447    '\u00CF': 'I',
2448    '\u1E2E': 'I',
2449    '\u1EC8': 'I',
2450    '\u01CF': 'I',
2451    '\u0208': 'I',
2452    '\u020A': 'I',
2453    '\u1ECA': 'I',
2454    '\u012E': 'I',
2455    '\u1E2C': 'I',
2456    '\u0197': 'I',
2457    '\u24BF': 'J',
2458    '\uFF2A': 'J',
2459    '\u0134': 'J',
2460    '\u0248': 'J',
2461    '\u24C0': 'K',
2462    '\uFF2B': 'K',
2463    '\u1E30': 'K',
2464    '\u01E8': 'K',
2465    '\u1E32': 'K',
2466    '\u0136': 'K',
2467    '\u1E34': 'K',
2468    '\u0198': 'K',
2469    '\u2C69': 'K',
2470    '\uA740': 'K',
2471    '\uA742': 'K',
2472    '\uA744': 'K',
2473    '\uA7A2': 'K',
2474    '\u24C1': 'L',
2475    '\uFF2C': 'L',
2476    '\u013F': 'L',
2477    '\u0139': 'L',
2478    '\u013D': 'L',
2479    '\u1E36': 'L',
2480    '\u1E38': 'L',
2481    '\u013B': 'L',
2482    '\u1E3C': 'L',
2483    '\u1E3A': 'L',
2484    '\u0141': 'L',
2485    '\u023D': 'L',
2486    '\u2C62': 'L',
2487    '\u2C60': 'L',
2488    '\uA748': 'L',
2489    '\uA746': 'L',
2490    '\uA780': 'L',
2491    '\u01C7': 'LJ',
2492    '\u01C8': 'Lj',
2493    '\u24C2': 'M',
2494    '\uFF2D': 'M',
2495    '\u1E3E': 'M',
2496    '\u1E40': 'M',
2497    '\u1E42': 'M',
2498    '\u2C6E': 'M',
2499    '\u019C': 'M',
2500    '\u24C3': 'N',
2501    '\uFF2E': 'N',
2502    '\u01F8': 'N',
2503    '\u0143': 'N',
2504    '\u00D1': 'N',
2505    '\u1E44': 'N',
2506    '\u0147': 'N',
2507    '\u1E46': 'N',
2508    '\u0145': 'N',
2509    '\u1E4A': 'N',
2510    '\u1E48': 'N',
2511    '\u0220': 'N',
2512    '\u019D': 'N',
2513    '\uA790': 'N',
2514    '\uA7A4': 'N',
2515    '\u01CA': 'NJ',
2516    '\u01CB': 'Nj',
2517    '\u24C4': 'O',
2518    '\uFF2F': 'O',
2519    '\u00D2': 'O',
2520    '\u00D3': 'O',
2521    '\u00D4': 'O',
2522    '\u1ED2': 'O',
2523    '\u1ED0': 'O',
2524    '\u1ED6': 'O',
2525    '\u1ED4': 'O',
2526    '\u00D5': 'O',
2527    '\u1E4C': 'O',
2528    '\u022C': 'O',
2529    '\u1E4E': 'O',
2530    '\u014C': 'O',
2531    '\u1E50': 'O',
2532    '\u1E52': 'O',
2533    '\u014E': 'O',
2534    '\u022E': 'O',
2535    '\u0230': 'O',
2536    '\u00D6': 'O',
2537    '\u022A': 'O',
2538    '\u1ECE': 'O',
2539    '\u0150': 'O',
2540    '\u01D1': 'O',
2541    '\u020C': 'O',
2542    '\u020E': 'O',
2543    '\u01A0': 'O',
2544    '\u1EDC': 'O',
2545    '\u1EDA': 'O',
2546    '\u1EE0': 'O',
2547    '\u1EDE': 'O',
2548    '\u1EE2': 'O',
2549    '\u1ECC': 'O',
2550    '\u1ED8': 'O',
2551    '\u01EA': 'O',
2552    '\u01EC': 'O',
2553    '\u00D8': 'O',
2554    '\u01FE': 'O',
2555    '\u0186': 'O',
2556    '\u019F': 'O',
2557    '\uA74A': 'O',
2558    '\uA74C': 'O',
2559    '\u0152': 'OE',
2560    '\u01A2': 'OI',
2561    '\uA74E': 'OO',
2562    '\u0222': 'OU',
2563    '\u24C5': 'P',
2564    '\uFF30': 'P',
2565    '\u1E54': 'P',
2566    '\u1E56': 'P',
2567    '\u01A4': 'P',
2568    '\u2C63': 'P',
2569    '\uA750': 'P',
2570    '\uA752': 'P',
2571    '\uA754': 'P',
2572    '\u24C6': 'Q',
2573    '\uFF31': 'Q',
2574    '\uA756': 'Q',
2575    '\uA758': 'Q',
2576    '\u024A': 'Q',
2577    '\u24C7': 'R',
2578    '\uFF32': 'R',
2579    '\u0154': 'R',
2580    '\u1E58': 'R',
2581    '\u0158': 'R',
2582    '\u0210': 'R',
2583    '\u0212': 'R',
2584    '\u1E5A': 'R',
2585    '\u1E5C': 'R',
2586    '\u0156': 'R',
2587    '\u1E5E': 'R',
2588    '\u024C': 'R',
2589    '\u2C64': 'R',
2590    '\uA75A': 'R',
2591    '\uA7A6': 'R',
2592    '\uA782': 'R',
2593    '\u24C8': 'S',
2594    '\uFF33': 'S',
2595    '\u1E9E': 'S',
2596    '\u015A': 'S',
2597    '\u1E64': 'S',
2598    '\u015C': 'S',
2599    '\u1E60': 'S',
2600    '\u0160': 'S',
2601    '\u1E66': 'S',
2602    '\u1E62': 'S',
2603    '\u1E68': 'S',
2604    '\u0218': 'S',
2605    '\u015E': 'S',
2606    '\u2C7E': 'S',
2607    '\uA7A8': 'S',
2608    '\uA784': 'S',
2609    '\u24C9': 'T',
2610    '\uFF34': 'T',
2611    '\u1E6A': 'T',
2612    '\u0164': 'T',
2613    '\u1E6C': 'T',
2614    '\u021A': 'T',
2615    '\u0162': 'T',
2616    '\u1E70': 'T',
2617    '\u1E6E': 'T',
2618    '\u0166': 'T',
2619    '\u01AC': 'T',
2620    '\u01AE': 'T',
2621    '\u023E': 'T',
2622    '\uA786': 'T',
2623    '\uA728': 'TZ',
2624    '\u24CA': 'U',
2625    '\uFF35': 'U',
2626    '\u00D9': 'U',
2627    '\u00DA': 'U',
2628    '\u00DB': 'U',
2629    '\u0168': 'U',
2630    '\u1E78': 'U',
2631    '\u016A': 'U',
2632    '\u1E7A': 'U',
2633    '\u016C': 'U',
2634    '\u00DC': 'U',
2635    '\u01DB': 'U',
2636    '\u01D7': 'U',
2637    '\u01D5': 'U',
2638    '\u01D9': 'U',
2639    '\u1EE6': 'U',
2640    '\u016E': 'U',
2641    '\u0170': 'U',
2642    '\u01D3': 'U',
2643    '\u0214': 'U',
2644    '\u0216': 'U',
2645    '\u01AF': 'U',
2646    '\u1EEA': 'U',
2647    '\u1EE8': 'U',
2648    '\u1EEE': 'U',
2649    '\u1EEC': 'U',
2650    '\u1EF0': 'U',
2651    '\u1EE4': 'U',
2652    '\u1E72': 'U',
2653    '\u0172': 'U',
2654    '\u1E76': 'U',
2655    '\u1E74': 'U',
2656    '\u0244': 'U',
2657    '\u24CB': 'V',
2658    '\uFF36': 'V',
2659    '\u1E7C': 'V',
2660    '\u1E7E': 'V',
2661    '\u01B2': 'V',
2662    '\uA75E': 'V',
2663    '\u0245': 'V',
2664    '\uA760': 'VY',
2665    '\u24CC': 'W',
2666    '\uFF37': 'W',
2667    '\u1E80': 'W',
2668    '\u1E82': 'W',
2669    '\u0174': 'W',
2670    '\u1E86': 'W',
2671    '\u1E84': 'W',
2672    '\u1E88': 'W',
2673    '\u2C72': 'W',
2674    '\u24CD': 'X',
2675    '\uFF38': 'X',
2676    '\u1E8A': 'X',
2677    '\u1E8C': 'X',
2678    '\u24CE': 'Y',
2679    '\uFF39': 'Y',
2680    '\u1EF2': 'Y',
2681    '\u00DD': 'Y',
2682    '\u0176': 'Y',
2683    '\u1EF8': 'Y',
2684    '\u0232': 'Y',
2685    '\u1E8E': 'Y',
2686    '\u0178': 'Y',
2687    '\u1EF6': 'Y',
2688    '\u1EF4': 'Y',
2689    '\u01B3': 'Y',
2690    '\u024E': 'Y',
2691    '\u1EFE': 'Y',
2692    '\u24CF': 'Z',
2693    '\uFF3A': 'Z',
2694    '\u0179': 'Z',
2695    '\u1E90': 'Z',
2696    '\u017B': 'Z',
2697    '\u017D': 'Z',
2698    '\u1E92': 'Z',
2699    '\u1E94': 'Z',
2700    '\u01B5': 'Z',
2701    '\u0224': 'Z',
2702    '\u2C7F': 'Z',
2703    '\u2C6B': 'Z',
2704    '\uA762': 'Z',
2705    '\u24D0': 'a',
2706    '\uFF41': 'a',
2707    '\u1E9A': 'a',
2708    '\u00E0': 'a',
2709    '\u00E1': 'a',
2710    '\u00E2': 'a',
2711    '\u1EA7': 'a',
2712    '\u1EA5': 'a',
2713    '\u1EAB': 'a',
2714    '\u1EA9': 'a',
2715    '\u00E3': 'a',
2716    '\u0101': 'a',
2717    '\u0103': 'a',
2718    '\u1EB1': 'a',
2719    '\u1EAF': 'a',
2720    '\u1EB5': 'a',
2721    '\u1EB3': 'a',
2722    '\u0227': 'a',
2723    '\u01E1': 'a',
2724    '\u00E4': 'a',
2725    '\u01DF': 'a',
2726    '\u1EA3': 'a',
2727    '\u00E5': 'a',
2728    '\u01FB': 'a',
2729    '\u01CE': 'a',
2730    '\u0201': 'a',
2731    '\u0203': 'a',
2732    '\u1EA1': 'a',
2733    '\u1EAD': 'a',
2734    '\u1EB7': 'a',
2735    '\u1E01': 'a',
2736    '\u0105': 'a',
2737    '\u2C65': 'a',
2738    '\u0250': 'a',
2739    '\uA733': 'aa',
2740    '\u00E6': 'ae',
2741    '\u01FD': 'ae',
2742    '\u01E3': 'ae',
2743    '\uA735': 'ao',
2744    '\uA737': 'au',
2745    '\uA739': 'av',
2746    '\uA73B': 'av',
2747    '\uA73D': 'ay',
2748    '\u24D1': 'b',
2749    '\uFF42': 'b',
2750    '\u1E03': 'b',
2751    '\u1E05': 'b',
2752    '\u1E07': 'b',
2753    '\u0180': 'b',
2754    '\u0183': 'b',
2755    '\u0253': 'b',
2756    '\u24D2': 'c',
2757    '\uFF43': 'c',
2758    '\u0107': 'c',
2759    '\u0109': 'c',
2760    '\u010B': 'c',
2761    '\u010D': 'c',
2762    '\u00E7': 'c',
2763    '\u1E09': 'c',
2764    '\u0188': 'c',
2765    '\u023C': 'c',
2766    '\uA73F': 'c',
2767    '\u2184': 'c',
2768    '\u24D3': 'd',
2769    '\uFF44': 'd',
2770    '\u1E0B': 'd',
2771    '\u010F': 'd',
2772    '\u1E0D': 'd',
2773    '\u1E11': 'd',
2774    '\u1E13': 'd',
2775    '\u1E0F': 'd',
2776    '\u0111': 'd',
2777    '\u018C': 'd',
2778    '\u0256': 'd',
2779    '\u0257': 'd',
2780    '\uA77A': 'd',
2781    '\u01F3': 'dz',
2782    '\u01C6': 'dz',
2783    '\u24D4': 'e',
2784    '\uFF45': 'e',
2785    '\u00E8': 'e',
2786    '\u00E9': 'e',
2787    '\u00EA': 'e',
2788    '\u1EC1': 'e',
2789    '\u1EBF': 'e',
2790    '\u1EC5': 'e',
2791    '\u1EC3': 'e',
2792    '\u1EBD': 'e',
2793    '\u0113': 'e',
2794    '\u1E15': 'e',
2795    '\u1E17': 'e',
2796    '\u0115': 'e',
2797    '\u0117': 'e',
2798    '\u00EB': 'e',
2799    '\u1EBB': 'e',
2800    '\u011B': 'e',
2801    '\u0205': 'e',
2802    '\u0207': 'e',
2803    '\u1EB9': 'e',
2804    '\u1EC7': 'e',
2805    '\u0229': 'e',
2806    '\u1E1D': 'e',
2807    '\u0119': 'e',
2808    '\u1E19': 'e',
2809    '\u1E1B': 'e',
2810    '\u0247': 'e',
2811    '\u025B': 'e',
2812    '\u01DD': 'e',
2813    '\u24D5': 'f',
2814    '\uFF46': 'f',
2815    '\u1E1F': 'f',
2816    '\u0192': 'f',
2817    '\uA77C': 'f',
2818    '\u24D6': 'g',
2819    '\uFF47': 'g',
2820    '\u01F5': 'g',
2821    '\u011D': 'g',
2822    '\u1E21': 'g',
2823    '\u011F': 'g',
2824    '\u0121': 'g',
2825    '\u01E7': 'g',
2826    '\u0123': 'g',
2827    '\u01E5': 'g',
2828    '\u0260': 'g',
2829    '\uA7A1': 'g',
2830    '\u1D79': 'g',
2831    '\uA77F': 'g',
2832    '\u24D7': 'h',
2833    '\uFF48': 'h',
2834    '\u0125': 'h',
2835    '\u1E23': 'h',
2836    '\u1E27': 'h',
2837    '\u021F': 'h',
2838    '\u1E25': 'h',
2839    '\u1E29': 'h',
2840    '\u1E2B': 'h',
2841    '\u1E96': 'h',
2842    '\u0127': 'h',
2843    '\u2C68': 'h',
2844    '\u2C76': 'h',
2845    '\u0265': 'h',
2846    '\u0195': 'hv',
2847    '\u24D8': 'i',
2848    '\uFF49': 'i',
2849    '\u00EC': 'i',
2850    '\u00ED': 'i',
2851    '\u00EE': 'i',
2852    '\u0129': 'i',
2853    '\u012B': 'i',
2854    '\u012D': 'i',
2855    '\u00EF': 'i',
2856    '\u1E2F': 'i',
2857    '\u1EC9': 'i',
2858    '\u01D0': 'i',
2859    '\u0209': 'i',
2860    '\u020B': 'i',
2861    '\u1ECB': 'i',
2862    '\u012F': 'i',
2863    '\u1E2D': 'i',
2864    '\u0268': 'i',
2865    '\u0131': 'i',
2866    '\u24D9': 'j',
2867    '\uFF4A': 'j',
2868    '\u0135': 'j',
2869    '\u01F0': 'j',
2870    '\u0249': 'j',
2871    '\u24DA': 'k',
2872    '\uFF4B': 'k',
2873    '\u1E31': 'k',
2874    '\u01E9': 'k',
2875    '\u1E33': 'k',
2876    '\u0137': 'k',
2877    '\u1E35': 'k',
2878    '\u0199': 'k',
2879    '\u2C6A': 'k',
2880    '\uA741': 'k',
2881    '\uA743': 'k',
2882    '\uA745': 'k',
2883    '\uA7A3': 'k',
2884    '\u24DB': 'l',
2885    '\uFF4C': 'l',
2886    '\u0140': 'l',
2887    '\u013A': 'l',
2888    '\u013E': 'l',
2889    '\u1E37': 'l',
2890    '\u1E39': 'l',
2891    '\u013C': 'l',
2892    '\u1E3D': 'l',
2893    '\u1E3B': 'l',
2894    '\u017F': 'l',
2895    '\u0142': 'l',
2896    '\u019A': 'l',
2897    '\u026B': 'l',
2898    '\u2C61': 'l',
2899    '\uA749': 'l',
2900    '\uA781': 'l',
2901    '\uA747': 'l',
2902    '\u01C9': 'lj',
2903    '\u24DC': 'm',
2904    '\uFF4D': 'm',
2905    '\u1E3F': 'm',
2906    '\u1E41': 'm',
2907    '\u1E43': 'm',
2908    '\u0271': 'm',
2909    '\u026F': 'm',
2910    '\u24DD': 'n',
2911    '\uFF4E': 'n',
2912    '\u01F9': 'n',
2913    '\u0144': 'n',
2914    '\u00F1': 'n',
2915    '\u1E45': 'n',
2916    '\u0148': 'n',
2917    '\u1E47': 'n',
2918    '\u0146': 'n',
2919    '\u1E4B': 'n',
2920    '\u1E49': 'n',
2921    '\u019E': 'n',
2922    '\u0272': 'n',
2923    '\u0149': 'n',
2924    '\uA791': 'n',
2925    '\uA7A5': 'n',
2926    '\u01CC': 'nj',
2927    '\u24DE': 'o',
2928    '\uFF4F': 'o',
2929    '\u00F2': 'o',
2930    '\u00F3': 'o',
2931    '\u00F4': 'o',
2932    '\u1ED3': 'o',
2933    '\u1ED1': 'o',
2934    '\u1ED7': 'o',
2935    '\u1ED5': 'o',
2936    '\u00F5': 'o',
2937    '\u1E4D': 'o',
2938    '\u022D': 'o',
2939    '\u1E4F': 'o',
2940    '\u014D': 'o',
2941    '\u1E51': 'o',
2942    '\u1E53': 'o',
2943    '\u014F': 'o',
2944    '\u022F': 'o',
2945    '\u0231': 'o',
2946    '\u00F6': 'o',
2947    '\u022B': 'o',
2948    '\u1ECF': 'o',
2949    '\u0151': 'o',
2950    '\u01D2': 'o',
2951    '\u020D': 'o',
2952    '\u020F': 'o',
2953    '\u01A1': 'o',
2954    '\u1EDD': 'o',
2955    '\u1EDB': 'o',
2956    '\u1EE1': 'o',
2957    '\u1EDF': 'o',
2958    '\u1EE3': 'o',
2959    '\u1ECD': 'o',
2960    '\u1ED9': 'o',
2961    '\u01EB': 'o',
2962    '\u01ED': 'o',
2963    '\u00F8': 'o',
2964    '\u01FF': 'o',
2965    '\u0254': 'o',
2966    '\uA74B': 'o',
2967    '\uA74D': 'o',
2968    '\u0275': 'o',
2969    '\u0153': 'oe',
2970    '\u01A3': 'oi',
2971    '\u0223': 'ou',
2972    '\uA74F': 'oo',
2973    '\u24DF': 'p',
2974    '\uFF50': 'p',
2975    '\u1E55': 'p',
2976    '\u1E57': 'p',
2977    '\u01A5': 'p',
2978    '\u1D7D': 'p',
2979    '\uA751': 'p',
2980    '\uA753': 'p',
2981    '\uA755': 'p',
2982    '\u24E0': 'q',
2983    '\uFF51': 'q',
2984    '\u024B': 'q',
2985    '\uA757': 'q',
2986    '\uA759': 'q',
2987    '\u24E1': 'r',
2988    '\uFF52': 'r',
2989    '\u0155': 'r',
2990    '\u1E59': 'r',
2991    '\u0159': 'r',
2992    '\u0211': 'r',
2993    '\u0213': 'r',
2994    '\u1E5B': 'r',
2995    '\u1E5D': 'r',
2996    '\u0157': 'r',
2997    '\u1E5F': 'r',
2998    '\u024D': 'r',
2999    '\u027D': 'r',
3000    '\uA75B': 'r',
3001    '\uA7A7': 'r',
3002    '\uA783': 'r',
3003    '\u24E2': 's',
3004    '\uFF53': 's',
3005    '\u00DF': 's',
3006    '\u015B': 's',
3007    '\u1E65': 's',
3008    '\u015D': 's',
3009    '\u1E61': 's',
3010    '\u0161': 's',
3011    '\u1E67': 's',
3012    '\u1E63': 's',
3013    '\u1E69': 's',
3014    '\u0219': 's',
3015    '\u015F': 's',
3016    '\u023F': 's',
3017    '\uA7A9': 's',
3018    '\uA785': 's',
3019    '\u1E9B': 's',
3020    '\u24E3': 't',
3021    '\uFF54': 't',
3022    '\u1E6B': 't',
3023    '\u1E97': 't',
3024    '\u0165': 't',
3025    '\u1E6D': 't',
3026    '\u021B': 't',
3027    '\u0163': 't',
3028    '\u1E71': 't',
3029    '\u1E6F': 't',
3030    '\u0167': 't',
3031    '\u01AD': 't',
3032    '\u0288': 't',
3033    '\u2C66': 't',
3034    '\uA787': 't',
3035    '\uA729': 'tz',
3036    '\u24E4': 'u',
3037    '\uFF55': 'u',
3038    '\u00F9': 'u',
3039    '\u00FA': 'u',
3040    '\u00FB': 'u',
3041    '\u0169': 'u',
3042    '\u1E79': 'u',
3043    '\u016B': 'u',
3044    '\u1E7B': 'u',
3045    '\u016D': 'u',
3046    '\u00FC': 'u',
3047    '\u01DC': 'u',
3048    '\u01D8': 'u',
3049    '\u01D6': 'u',
3050    '\u01DA': 'u',
3051    '\u1EE7': 'u',
3052    '\u016F': 'u',
3053    '\u0171': 'u',
3054    '\u01D4': 'u',
3055    '\u0215': 'u',
3056    '\u0217': 'u',
3057    '\u01B0': 'u',
3058    '\u1EEB': 'u',
3059    '\u1EE9': 'u',
3060    '\u1EEF': 'u',
3061    '\u1EED': 'u',
3062    '\u1EF1': 'u',
3063    '\u1EE5': 'u',
3064    '\u1E73': 'u',
3065    '\u0173': 'u',
3066    '\u1E77': 'u',
3067    '\u1E75': 'u',
3068    '\u0289': 'u',
3069    '\u24E5': 'v',
3070    '\uFF56': 'v',
3071    '\u1E7D': 'v',
3072    '\u1E7F': 'v',
3073    '\u028B': 'v',
3074    '\uA75F': 'v',
3075    '\u028C': 'v',
3076    '\uA761': 'vy',
3077    '\u24E6': 'w',
3078    '\uFF57': 'w',
3079    '\u1E81': 'w',
3080    '\u1E83': 'w',
3081    '\u0175': 'w',
3082    '\u1E87': 'w',
3083    '\u1E85': 'w',
3084    '\u1E98': 'w',
3085    '\u1E89': 'w',
3086    '\u2C73': 'w',
3087    '\u24E7': 'x',
3088    '\uFF58': 'x',
3089    '\u1E8B': 'x',
3090    '\u1E8D': 'x',
3091    '\u24E8': 'y',
3092    '\uFF59': 'y',
3093    '\u1EF3': 'y',
3094    '\u00FD': 'y',
3095    '\u0177': 'y',
3096    '\u1EF9': 'y',
3097    '\u0233': 'y',
3098    '\u1E8F': 'y',
3099    '\u00FF': 'y',
3100    '\u1EF7': 'y',
3101    '\u1E99': 'y',
3102    '\u1EF5': 'y',
3103    '\u01B4': 'y',
3104    '\u024F': 'y',
3105    '\u1EFF': 'y',
3106    '\u24E9': 'z',
3107    '\uFF5A': 'z',
3108    '\u017A': 'z',
3109    '\u1E91': 'z',
3110    '\u017C': 'z',
3111    '\u017E': 'z',
3112    '\u1E93': 'z',
3113    '\u1E95': 'z',
3114    '\u01B6': 'z',
3115    '\u0225': 'z',
3116    '\u0240': 'z',
3117    '\u2C6C': 'z',
3118    '\uA763': 'z',
3119    '\u0386': '\u0391',
3120    '\u0388': '\u0395',
3121    '\u0389': '\u0397',
3122    '\u038A': '\u0399',
3123    '\u03AA': '\u0399',
3124    '\u038C': '\u039F',
3125    '\u038E': '\u03A5',
3126    '\u03AB': '\u03A5',
3127    '\u038F': '\u03A9',
3128    '\u03AC': '\u03B1',
3129    '\u03AD': '\u03B5',
3130    '\u03AE': '\u03B7',
3131    '\u03AF': '\u03B9',
3132    '\u03CA': '\u03B9',
3133    '\u0390': '\u03B9',
3134    '\u03CC': '\u03BF',
3135    '\u03CD': '\u03C5',
3136    '\u03CB': '\u03C5',
3137    '\u03B0': '\u03C5',
3138    '\u03CE': '\u03C9',
3139    '\u03C2': '\u03C3',
3140    '\u2019': '\''
3141  };
3142
3143  return diacritics;
3144});
3145
3146S2.define('select2/data/base',[
3147  '../utils'
3148], function (Utils) {
3149  function BaseAdapter ($element, options) {
3150    BaseAdapter.__super__.constructor.call(this);
3151  }
3152
3153  Utils.Extend(BaseAdapter, Utils.Observable);
3154
3155  BaseAdapter.prototype.current = function (callback) {
3156    throw new Error('The `current` method must be defined in child classes.');
3157  };
3158
3159  BaseAdapter.prototype.query = function (params, callback) {
3160    throw new Error('The `query` method must be defined in child classes.');
3161  };
3162
3163  BaseAdapter.prototype.bind = function (container, $container) {
3164    // Can be implemented in subclasses
3165  };
3166
3167  BaseAdapter.prototype.destroy = function () {
3168    // Can be implemented in subclasses
3169  };
3170
3171  BaseAdapter.prototype.generateResultId = function (container, data) {
3172    var id = container.id + '-result-';
3173
3174    id += Utils.generateChars(4);
3175
3176    if (data.id != null) {
3177      id += '-' + data.id.toString();
3178    } else {
3179      id += '-' + Utils.generateChars(4);
3180    }
3181    return id;
3182  };
3183
3184  return BaseAdapter;
3185});
3186
3187S2.define('select2/data/select',[
3188  './base',
3189  '../utils',
3190  'jquery'
3191], function (BaseAdapter, Utils, $) {
3192  function SelectAdapter ($element, options) {
3193    this.$element = $element;
3194    this.options = options;
3195
3196    SelectAdapter.__super__.constructor.call(this);
3197  }
3198
3199  Utils.Extend(SelectAdapter, BaseAdapter);
3200
3201  SelectAdapter.prototype.current = function (callback) {
3202    var data = [];
3203    var self = this;
3204
3205    this.$element.find(':selected').each(function () {
3206      var $option = $(this);
3207
3208      var option = self.item($option);
3209
3210      data.push(option);
3211    });
3212
3213    callback(data);
3214  };
3215
3216  SelectAdapter.prototype.select = function (data) {
3217    var self = this;
3218
3219    data.selected = true;
3220
3221    // If data.element is a DOM node, use it instead
3222    if ($(data.element).is('option')) {
3223      data.element.selected = true;
3224
3225      this.$element.trigger('input').trigger('change');
3226
3227      return;
3228    }
3229
3230    if (this.$element.prop('multiple')) {
3231      this.current(function (currentData) {
3232        var val = [];
3233
3234        data = [data];
3235        data.push.apply(data, currentData);
3236
3237        for (var d = 0; d < data.length; d++) {
3238          var id = data[d].id;
3239
3240          if ($.inArray(id, val) === -1) {
3241            val.push(id);
3242          }
3243        }
3244
3245        self.$element.val(val);
3246        self.$element.trigger('input').trigger('change');
3247      });
3248    } else {
3249      var val = data.id;
3250
3251      this.$element.val(val);
3252      this.$element.trigger('input').trigger('change');
3253    }
3254  };
3255
3256  SelectAdapter.prototype.unselect = function (data) {
3257    var self = this;
3258
3259    if (!this.$element.prop('multiple')) {
3260      return;
3261    }
3262
3263    data.selected = false;
3264
3265    if ($(data.element).is('option')) {
3266      data.element.selected = false;
3267
3268      this.$element.trigger('input').trigger('change');
3269
3270      return;
3271    }
3272
3273    this.current(function (currentData) {
3274      var val = [];
3275
3276      for (var d = 0; d < currentData.length; d++) {
3277        var id = currentData[d].id;
3278
3279        if (id !== data.id && $.inArray(id, val) === -1) {
3280          val.push(id);
3281        }
3282      }
3283
3284      self.$element.val(val);
3285
3286      self.$element.trigger('input').trigger('change');
3287    });
3288  };
3289
3290  SelectAdapter.prototype.bind = function (container, $container) {
3291    var self = this;
3292
3293    this.container = container;
3294
3295    container.on('select', function (params) {
3296      self.select(params.data);
3297    });
3298
3299    container.on('unselect', function (params) {
3300      self.unselect(params.data);
3301    });
3302  };
3303
3304  SelectAdapter.prototype.destroy = function () {
3305    // Remove anything added to child elements
3306    this.$element.find('*').each(function () {
3307      // Remove any custom data set by Select2
3308      Utils.RemoveData(this);
3309    });
3310  };
3311
3312  SelectAdapter.prototype.query = function (params, callback) {
3313    var data = [];
3314    var self = this;
3315
3316    var $options = this.$element.children();
3317
3318    $options.each(function () {
3319      var $option = $(this);
3320
3321      if (!$option.is('option') && !$option.is('optgroup')) {
3322        return;
3323      }
3324
3325      var option = self.item($option);
3326
3327      var matches = self.matches(params, option);
3328
3329      if (matches !== null) {
3330        data.push(matches);
3331      }
3332    });
3333
3334    callback({
3335      results: data
3336    });
3337  };
3338
3339  SelectAdapter.prototype.addOptions = function ($options) {
3340    Utils.appendMany(this.$element, $options);
3341  };
3342
3343  SelectAdapter.prototype.option = function (data) {
3344    var option;
3345
3346    if (data.children) {
3347      option = document.createElement('optgroup');
3348      option.label = data.text;
3349    } else {
3350      option = document.createElement('option');
3351
3352      if (option.textContent !== undefined) {
3353        option.textContent = data.text;
3354      } else {
3355        option.innerText = data.text;
3356      }
3357    }
3358
3359    if (data.id !== undefined) {
3360      option.value = data.id;
3361    }
3362
3363    if (data.disabled) {
3364      option.disabled = true;
3365    }
3366
3367    if (data.selected) {
3368      option.selected = true;
3369    }
3370
3371    if (data.title) {
3372      option.title = data.title;
3373    }
3374
3375    var $option = $(option);
3376
3377    var normalizedData = this._normalizeItem(data);
3378    normalizedData.element = option;
3379
3380    // Override the option's data with the combined data
3381    Utils.StoreData(option, 'data', normalizedData);
3382
3383    return $option;
3384  };
3385
3386  SelectAdapter.prototype.item = function ($option) {
3387    var data = {};
3388
3389    data = Utils.GetData($option[0], 'data');
3390
3391    if (data != null) {
3392      return data;
3393    }
3394
3395    if ($option.is('option')) {
3396      data = {
3397        id: $option.val(),
3398        text: $option.text(),
3399        disabled: $option.prop('disabled'),
3400        selected: $option.prop('selected'),
3401        title: $option.prop('title')
3402      };
3403    } else if ($option.is('optgroup')) {
3404      data = {
3405        text: $option.prop('label'),
3406        children: [],
3407        title: $option.prop('title')
3408      };
3409
3410      var $children = $option.children('option');
3411      var children = [];
3412
3413      for (var c = 0; c < $children.length; c++) {
3414        var $child = $($children[c]);
3415
3416        var child = this.item($child);
3417
3418        children.push(child);
3419      }
3420
3421      data.children = children;
3422    }
3423
3424    data = this._normalizeItem(data);
3425    data.element = $option[0];
3426
3427    Utils.StoreData($option[0], 'data', data);
3428
3429    return data;
3430  };
3431
3432  SelectAdapter.prototype._normalizeItem = function (item) {
3433    if (item !== Object(item)) {
3434      item = {
3435        id: item,
3436        text: item
3437      };
3438    }
3439
3440    item = $.extend({}, {
3441      text: ''
3442    }, item);
3443
3444    var defaults = {
3445      selected: false,
3446      disabled: false
3447    };
3448
3449    if (item.id != null) {
3450      item.id = item.id.toString();
3451    }
3452
3453    if (item.text != null) {
3454      item.text = item.text.toString();
3455    }
3456
3457    if (item._resultId == null && item.id && this.container != null) {
3458      item._resultId = this.generateResultId(this.container, item);
3459    }
3460
3461    return $.extend({}, defaults, item);
3462  };
3463
3464  SelectAdapter.prototype.matches = function (params, data) {
3465    var matcher = this.options.get('matcher');
3466
3467    return matcher(params, data);
3468  };
3469
3470  return SelectAdapter;
3471});
3472
3473S2.define('select2/data/array',[
3474  './select',
3475  '../utils',
3476  'jquery'
3477], function (SelectAdapter, Utils, $) {
3478  function ArrayAdapter ($element, options) {
3479    this._dataToConvert = options.get('data') || [];
3480
3481    ArrayAdapter.__super__.constructor.call(this, $element, options);
3482  }
3483
3484  Utils.Extend(ArrayAdapter, SelectAdapter);
3485
3486  ArrayAdapter.prototype.bind = function (container, $container) {
3487    ArrayAdapter.__super__.bind.call(this, container, $container);
3488
3489    this.addOptions(this.convertToOptions(this._dataToConvert));
3490  };
3491
3492  ArrayAdapter.prototype.select = function (data) {
3493    var $option = this.$element.find('option').filter(function (i, elm) {
3494      return elm.value == data.id.toString();
3495    });
3496
3497    if ($option.length === 0) {
3498      $option = this.option(data);
3499
3500      this.addOptions($option);
3501    }
3502
3503    ArrayAdapter.__super__.select.call(this, data);
3504  };
3505
3506  ArrayAdapter.prototype.convertToOptions = function (data) {
3507    var self = this;
3508
3509    var $existing = this.$element.find('option');
3510    var existingIds = $existing.map(function () {
3511      return self.item($(this)).id;
3512    }).get();
3513
3514    var $options = [];
3515
3516    // Filter out all items except for the one passed in the argument
3517    function onlyItem (item) {
3518      return function () {
3519        return $(this).val() == item.id;
3520      };
3521    }
3522
3523    for (var d = 0; d < data.length; d++) {
3524      var item = this._normalizeItem(data[d]);
3525
3526      // Skip items which were pre-loaded, only merge the data
3527      if ($.inArray(item.id, existingIds) >= 0) {
3528        var $existingOption = $existing.filter(onlyItem(item));
3529
3530        var existingData = this.item($existingOption);
3531        var newData = $.extend(true, {}, item, existingData);
3532
3533        var $newOption = this.option(newData);
3534
3535        $existingOption.replaceWith($newOption);
3536
3537        continue;
3538      }
3539
3540      var $option = this.option(item);
3541
3542      if (item.children) {
3543        var $children = this.convertToOptions(item.children);
3544
3545        Utils.appendMany($option, $children);
3546      }
3547
3548      $options.push($option);
3549    }
3550
3551    return $options;
3552  };
3553
3554  return ArrayAdapter;
3555});
3556
3557S2.define('select2/data/ajax',[
3558  './array',
3559  '../utils',
3560  'jquery'
3561], function (ArrayAdapter, Utils, $) {
3562  function AjaxAdapter ($element, options) {
3563    this.ajaxOptions = this._applyDefaults(options.get('ajax'));
3564
3565    if (this.ajaxOptions.processResults != null) {
3566      this.processResults = this.ajaxOptions.processResults;
3567    }
3568
3569    AjaxAdapter.__super__.constructor.call(this, $element, options);
3570  }
3571
3572  Utils.Extend(AjaxAdapter, ArrayAdapter);
3573
3574  AjaxAdapter.prototype._applyDefaults = function (options) {
3575    var defaults = {
3576      data: function (params) {
3577        return $.extend({}, params, {
3578          q: params.term
3579        });
3580      },
3581      transport: function (params, success, failure) {
3582        var $request = $.ajax(params);
3583
3584        $request.then(success);
3585        $request.fail(failure);
3586
3587        return $request;
3588      }
3589    };
3590
3591    return $.extend({}, defaults, options, true);
3592  };
3593
3594  AjaxAdapter.prototype.processResults = function (results) {
3595    return results;
3596  };
3597
3598  AjaxAdapter.prototype.query = function (params, callback) {
3599    var matches = [];
3600    var self = this;
3601
3602    if (this._request != null) {
3603      // JSONP requests cannot always be aborted
3604      if ($.isFunction(this._request.abort)) {
3605        this._request.abort();
3606      }
3607
3608      this._request = null;
3609    }
3610
3611    var options = $.extend({
3612      type: 'GET'
3613    }, this.ajaxOptions);
3614
3615    if (typeof options.url === 'function') {
3616      options.url = options.url.call(this.$element, params);
3617    }
3618
3619    if (typeof options.data === 'function') {
3620      options.data = options.data.call(this.$element, params);
3621    }
3622
3623    function request () {
3624      var $request = options.transport(options, function (data) {
3625        var results = self.processResults(data, params);
3626
3627        if (self.options.get('debug') && window.console && console.error) {
3628          // Check to make sure that the response included a `results` key.
3629          if (!results || !results.results || !$.isArray(results.results)) {
3630            console.error(
3631              'Select2: The AJAX results did not return an array in the ' +
3632              '`results` key of the response.'
3633            );
3634          }
3635        }
3636
3637        callback(results);
3638      }, function () {
3639        // Attempt to detect if a request was aborted
3640        // Only works if the transport exposes a status property
3641        if ('status' in $request &&
3642            ($request.status === 0 || $request.status === '0')) {
3643          return;
3644        }
3645
3646        self.trigger('results:message', {
3647          message: 'errorLoading'
3648        });
3649      });
3650
3651      self._request = $request;
3652    }
3653
3654    if (this.ajaxOptions.delay && params.term != null) {
3655      if (this._queryTimeout) {
3656        window.clearTimeout(this._queryTimeout);
3657      }
3658
3659      this._queryTimeout = window.setTimeout(request, this.ajaxOptions.delay);
3660    } else {
3661      request();
3662    }
3663  };
3664
3665  return AjaxAdapter;
3666});
3667
3668S2.define('select2/data/tags',[
3669  'jquery'
3670], function ($) {
3671  function Tags (decorated, $element, options) {
3672    var tags = options.get('tags');
3673
3674    var createTag = options.get('createTag');
3675
3676    if (createTag !== undefined) {
3677      this.createTag = createTag;
3678    }
3679
3680    var insertTag = options.get('insertTag');
3681
3682    if (insertTag !== undefined) {
3683        this.insertTag = insertTag;
3684    }
3685
3686    decorated.call(this, $element, options);
3687
3688    if ($.isArray(tags)) {
3689      for (var t = 0; t < tags.length; t++) {
3690        var tag = tags[t];
3691        var item = this._normalizeItem(tag);
3692
3693        var $option = this.option(item);
3694
3695        this.$element.append($option);
3696      }
3697    }
3698  }
3699
3700  Tags.prototype.query = function (decorated, params, callback) {
3701    var self = this;
3702
3703    this._removeOldTags();
3704
3705    if (params.term == null || params.page != null) {
3706      decorated.call(this, params, callback);
3707      return;
3708    }
3709
3710    function wrapper (obj, child) {
3711      var data = obj.results;
3712
3713      for (var i = 0; i < data.length; i++) {
3714        var option = data[i];
3715
3716        var checkChildren = (
3717          option.children != null &&
3718          !wrapper({
3719            results: option.children
3720          }, true)
3721        );
3722
3723        var optionText = (option.text || '').toUpperCase();
3724        var paramsTerm = (params.term || '').toUpperCase();
3725
3726        var checkText = optionText === paramsTerm;
3727
3728        if (checkText || checkChildren) {
3729          if (child) {
3730            return false;
3731          }
3732
3733          obj.data = data;
3734          callback(obj);
3735
3736          return;
3737        }
3738      }
3739
3740      if (child) {
3741        return true;
3742      }
3743
3744      var tag = self.createTag(params);
3745
3746      if (tag != null) {
3747        var $option = self.option(tag);
3748        $option.attr('data-select2-tag', true);
3749
3750        self.addOptions([$option]);
3751
3752        self.insertTag(data, tag);
3753      }
3754
3755      obj.results = data;
3756
3757      callback(obj);
3758    }
3759
3760    decorated.call(this, params, wrapper);
3761  };
3762
3763  Tags.prototype.createTag = function (decorated, params) {
3764    var term = $.trim(params.term);
3765
3766    if (term === '') {
3767      return null;
3768    }
3769
3770    return {
3771      id: term,
3772      text: term
3773    };
3774  };
3775
3776  Tags.prototype.insertTag = function (_, data, tag) {
3777    data.unshift(tag);
3778  };
3779
3780  Tags.prototype._removeOldTags = function (_) {
3781    var $options = this.$element.find('option[data-select2-tag]');
3782
3783    $options.each(function () {
3784      if (this.selected) {
3785        return;
3786      }
3787
3788      $(this).remove();
3789    });
3790  };
3791
3792  return Tags;
3793});
3794
3795S2.define('select2/data/tokenizer',[
3796  'jquery'
3797], function ($) {
3798  function Tokenizer (decorated, $element, options) {
3799    var tokenizer = options.get('tokenizer');
3800
3801    if (tokenizer !== undefined) {
3802      this.tokenizer = tokenizer;
3803    }
3804
3805    decorated.call(this, $element, options);
3806  }
3807
3808  Tokenizer.prototype.bind = function (decorated, container, $container) {
3809    decorated.call(this, container, $container);
3810
3811    this.$search =  container.dropdown.$search || container.selection.$search ||
3812      $container.find('.select2-search__field');
3813  };
3814
3815  Tokenizer.prototype.query = function (decorated, params, callback) {
3816    var self = this;
3817
3818    function createAndSelect (data) {
3819      // Normalize the data object so we can use it for checks
3820      var item = self._normalizeItem(data);
3821
3822      // Check if the data object already exists as a tag
3823      // Select it if it doesn't
3824      var $existingOptions = self.$element.find('option').filter(function () {
3825        return $(this).val() === item.id;
3826      });
3827
3828      // If an existing option wasn't found for it, create the option
3829      if (!$existingOptions.length) {
3830        var $option = self.option(item);
3831        $option.attr('data-select2-tag', true);
3832
3833        self._removeOldTags();
3834        self.addOptions([$option]);
3835      }
3836
3837      // Select the item, now that we know there is an option for it
3838      select(item);
3839    }
3840
3841    function select (data) {
3842      self.trigger('select', {
3843        data: data
3844      });
3845    }
3846
3847    params.term = params.term || '';
3848
3849    var tokenData = this.tokenizer(params, this.options, createAndSelect);
3850
3851    if (tokenData.term !== params.term) {
3852      // Replace the search term if we have the search box
3853      if (this.$search.length) {
3854        this.$search.val(tokenData.term);
3855        this.$search.trigger('focus');
3856      }
3857
3858      params.term = tokenData.term;
3859    }
3860
3861    decorated.call(this, params, callback);
3862  };
3863
3864  Tokenizer.prototype.tokenizer = function (_, params, options, callback) {
3865    var separators = options.get('tokenSeparators') || [];
3866    var term = params.term;
3867    var i = 0;
3868
3869    var createTag = this.createTag || function (params) {
3870      return {
3871        id: params.term,
3872        text: params.term
3873      };
3874    };
3875
3876    while (i < term.length) {
3877      var termChar = term[i];
3878
3879      if ($.inArray(termChar, separators) === -1) {
3880        i++;
3881
3882        continue;
3883      }
3884
3885      var part = term.substr(0, i);
3886      var partParams = $.extend({}, params, {
3887        term: part
3888      });
3889
3890      var data = createTag(partParams);
3891
3892      if (data == null) {
3893        i++;
3894        continue;
3895      }
3896
3897      callback(data);
3898
3899      // Reset the term to not include the tokenized portion
3900      term = term.substr(i + 1) || '';
3901      i = 0;
3902    }
3903
3904    return {
3905      term: term
3906    };
3907  };
3908
3909  return Tokenizer;
3910});
3911
3912S2.define('select2/data/minimumInputLength',[
3913
3914], function () {
3915  function MinimumInputLength (decorated, $e, options) {
3916    this.minimumInputLength = options.get('minimumInputLength');
3917
3918    decorated.call(this, $e, options);
3919  }
3920
3921  MinimumInputLength.prototype.query = function (decorated, params, callback) {
3922    params.term = params.term || '';
3923
3924    if (params.term.length < this.minimumInputLength) {
3925      this.trigger('results:message', {
3926        message: 'inputTooShort',
3927        args: {
3928          minimum: this.minimumInputLength,
3929          input: params.term,
3930          params: params
3931        }
3932      });
3933
3934      return;
3935    }
3936
3937    decorated.call(this, params, callback);
3938  };
3939
3940  return MinimumInputLength;
3941});
3942
3943S2.define('select2/data/maximumInputLength',[
3944
3945], function () {
3946  function MaximumInputLength (decorated, $e, options) {
3947    this.maximumInputLength = options.get('maximumInputLength');
3948
3949    decorated.call(this, $e, options);
3950  }
3951
3952  MaximumInputLength.prototype.query = function (decorated, params, callback) {
3953    params.term = params.term || '';
3954
3955    if (this.maximumInputLength > 0 &&
3956        params.term.length > this.maximumInputLength) {
3957      this.trigger('results:message', {
3958        message: 'inputTooLong',
3959        args: {
3960          maximum: this.maximumInputLength,
3961          input: params.term,
3962          params: params
3963        }
3964      });
3965
3966      return;
3967    }
3968
3969    decorated.call(this, params, callback);
3970  };
3971
3972  return MaximumInputLength;
3973});
3974
3975S2.define('select2/data/maximumSelectionLength',[
3976
3977], function (){
3978  function MaximumSelectionLength (decorated, $e, options) {
3979    this.maximumSelectionLength = options.get('maximumSelectionLength');
3980
3981    decorated.call(this, $e, options);
3982  }
3983
3984  MaximumSelectionLength.prototype.bind =
3985    function (decorated, container, $container) {
3986      var self = this;
3987
3988      decorated.call(this, container, $container);
3989
3990      container.on('select', function () {
3991        self._checkIfMaximumSelected();
3992      });
3993  };
3994
3995  MaximumSelectionLength.prototype.query =
3996    function (decorated, params, callback) {
3997      var self = this;
3998
3999      this._checkIfMaximumSelected(function () {
4000        decorated.call(self, params, callback);
4001      });
4002  };
4003
4004  MaximumSelectionLength.prototype._checkIfMaximumSelected =
4005    function (_, successCallback) {
4006      var self = this;
4007
4008      this.current(function (currentData) {
4009        var count = currentData != null ? currentData.length : 0;
4010        if (self.maximumSelectionLength > 0 &&
4011          count >= self.maximumSelectionLength) {
4012          self.trigger('results:message', {
4013            message: 'maximumSelected',
4014            args: {
4015              maximum: self.maximumSelectionLength
4016            }
4017          });
4018          return;
4019        }
4020
4021        if (successCallback) {
4022          successCallback();
4023        }
4024      });
4025  };
4026
4027  return MaximumSelectionLength;
4028});
4029
4030S2.define('select2/dropdown',[
4031  'jquery',
4032  './utils'
4033], function ($, Utils) {
4034  function Dropdown ($element, options) {
4035    this.$element = $element;
4036    this.options = options;
4037
4038    Dropdown.__super__.constructor.call(this);
4039  }
4040
4041  Utils.Extend(Dropdown, Utils.Observable);
4042
4043  Dropdown.prototype.render = function () {
4044    var $dropdown = $(
4045      '<span class="select2-dropdown">' +
4046        '<span class="select2-results"></span>' +
4047      '</span>'
4048    );
4049
4050    $dropdown.attr('dir', this.options.get('dir'));
4051
4052    this.$dropdown = $dropdown;
4053
4054    return $dropdown;
4055  };
4056
4057  Dropdown.prototype.bind = function () {
4058    // Should be implemented in subclasses
4059  };
4060
4061  Dropdown.prototype.position = function ($dropdown, $container) {
4062    // Should be implemented in subclasses
4063  };
4064
4065  Dropdown.prototype.destroy = function () {
4066    // Remove the dropdown from the DOM
4067    this.$dropdown.remove();
4068  };
4069
4070  return Dropdown;
4071});
4072
4073S2.define('select2/dropdown/search',[
4074  'jquery',
4075  '../utils'
4076], function ($, Utils) {
4077  function Search () { }
4078
4079  Search.prototype.render = function (decorated) {
4080    var $rendered = decorated.call(this);
4081
4082    var $search = $(
4083      '<span class="select2-search select2-search--dropdown">' +
4084        '<input class="select2-search__field" type="search" tabindex="-1"' +
4085        ' autocomplete="off" autocorrect="off" autocapitalize="none"' +
4086        ' spellcheck="false" role="searchbox" aria-autocomplete="list" />' +
4087      '</span>'
4088    );
4089
4090    this.$searchContainer = $search;
4091    this.$search = $search.find('input');
4092
4093    $rendered.prepend($search);
4094
4095    return $rendered;
4096  };
4097
4098  Search.prototype.bind = function (decorated, container, $container) {
4099    var self = this;
4100
4101    var resultsId = container.id + '-results';
4102
4103    decorated.call(this, container, $container);
4104
4105    this.$search.on('keydown', function (evt) {
4106      self.trigger('keypress', evt);
4107
4108      self._keyUpPrevented = evt.isDefaultPrevented();
4109    });
4110
4111    // Workaround for browsers which do not support the `input` event
4112    // This will prevent double-triggering of events for browsers which support
4113    // both the `keyup` and `input` events.
4114    this.$search.on('input', function (evt) {
4115      // Unbind the duplicated `keyup` event
4116      $(this).off('keyup');
4117    });
4118
4119    this.$search.on('keyup input', function (evt) {
4120      self.handleSearch(evt);
4121    });
4122
4123    container.on('open', function () {
4124      self.$search.attr('tabindex', 0);
4125      self.$search.attr('aria-controls', resultsId);
4126
4127      self.$search.trigger('focus');
4128
4129      window.setTimeout(function () {
4130        self.$search.trigger('focus');
4131      }, 0);
4132    });
4133
4134    container.on('close', function () {
4135      self.$search.attr('tabindex', -1);
4136      self.$search.removeAttr('aria-controls');
4137      self.$search.removeAttr('aria-activedescendant');
4138
4139      self.$search.val('');
4140      self.$search.trigger('blur');
4141    });
4142
4143    container.on('focus', function () {
4144      if (!container.isOpen()) {
4145        self.$search.trigger('focus');
4146      }
4147    });
4148
4149    container.on('results:all', function (params) {
4150      if (params.query.term == null || params.query.term === '') {
4151        var showSearch = self.showSearch(params);
4152
4153        if (showSearch) {
4154          self.$searchContainer.removeClass('select2-search--hide');
4155        } else {
4156          self.$searchContainer.addClass('select2-search--hide');
4157        }
4158      }
4159    });
4160
4161    container.on('results:focus', function (params) {
4162      if (params.data._resultId) {
4163        self.$search.attr('aria-activedescendant', params.data._resultId);
4164      } else {
4165        self.$search.removeAttr('aria-activedescendant');
4166      }
4167    });
4168  };
4169
4170  Search.prototype.handleSearch = function (evt) {
4171    if (!this._keyUpPrevented) {
4172      var input = this.$search.val();
4173
4174      this.trigger('query', {
4175        term: input
4176      });
4177    }
4178
4179    this._keyUpPrevented = false;