Proyectos de Subversion Moodle

Rev

| Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 1 
/*!
2 
 * Select2 4.0.13
3 
 * https://select2.github.io
4 
 *
5 
 * Released under the MIT license
6 
 * https://github.com/select2/select2/blob/master/LICENSE.md
7 
 */
8 
;(function (factory) {
9 
    if (typeof define === 'function' && define.amd) {
10 
        // AMD. Register as an anonymous module.
11 
        define(['jquery'], factory);
12 
    } else if (typeof 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 
        }
44 
        var S2;(function () { if (!S2 || !S2.requirejs) {
45 
            if (!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 
 
54 
            var 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 
 
481 
            S2.requirejs = requirejs;S2.require = require;S2.define = define;
482 
        }
483 
        }());
484 
        S2.define("almond", function(){});
485 
 
486 
        /* global jQuery:false, $:false */
487 
        S2.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 
 
501 
        S2.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 
                    var 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.
715 
                // The original code can be found at
716 
                // http://codereview.stackexchange.com/q/13338
717 
                // and was designed to be used with the Sizzle selector engine.
718 
 
719 
                var $el = $(el);
720 
                var overflowX = el.style.overflowX;
721 
                var overflowY = el.style.overflowY;
722 
 
723 
                //Check both x and y declarations
724 
                if (overflowX === overflowY &&
725 
                    (overflowY === 'hidden' || overflowY === 'visible')) {
726 
                    return false;
727 
                }
728 
 
729 
                if (overflowX === 'scroll' || overflowY === 'scroll') {
730 
                    return true;
731 
                }
732 
 
733 
                return ($el.innerHeight() < el.scrollHeight ||
734 
                    $el.innerWidth() < el.scrollWidth);
735 
            };
736 
 
737 
            Utils.escapeMarkup = function (markup) {
738 
                var replaceMap = {
739 
                    '\\': '&#92;',
740 
                    '&': '&amp;',
741 
                    '<': '&lt;',
742 
                    '>': '&gt;',
743 
                    '"': '&quot;',
744 
                    '\'': '&#39;',
745 
                    '/': '&#47;'
746 
                };
747 
 
748 
                // Do not try to escape the markup if it's not a string
749 
                if (typeof markup !== 'string') {
750 
                    return markup;
751 
                }
752 
 
753 
                return String(markup).replace(/[&<>"'\/\\]/g, function (match) {
754 
                    return replaceMap[match];
755 
                });
756 
            };
757 
 
758 
            // Append an array of jQuery nodes to a given element.
759 
            Utils.appendMany = function ($element, $nodes) {
760 
                // jQuery 1.7.x does not support $.fn.append() with an array
761 
                // Fall back to a jQuery object collection using $.fn.add()
762 
                if ($.fn.jquery.substr(0, 3) === '1.7') {
763 
                    var $jqNodes = $();
764 
 
765 
                    $.map($nodes, function (node) {
766 
                        $jqNodes = $jqNodes.add(node);
767 
                    });
768 
 
769 
                    $nodes = $jqNodes;
770 
                }
771 
 
772 
                $element.append($nodes);
773 
            };
774 
 
775 
            // Cache objects in Utils.__cache instead of $.data (see #4346)
776 
            Utils.__cache = {};
777 
 
778 
            var id = 0;
779 
            Utils.GetUniqueElementId = function (element) {
780 
                // Get a unique element Id. If element has no id,
781 
                // creates a new unique number, stores it in the id
782 
                // attribute and returns the new id.
783 
                // If an id already exists, it simply returns it.
784 
 
785 
                var select2Id = element.getAttribute('data-select2-id');
786 
                if (select2Id == null) {
787 
                    // If element has id, use it.
788 
                    if (element.id) {
789 
                        select2Id = element.id;
790 
                        element.setAttribute('data-select2-id', select2Id);
791 
                    } else {
792 
                        element.setAttribute('data-select2-id', ++id);
793 
                        select2Id = id.toString();
794 
                    }
795 
                }
796 
                return select2Id;
797 
            };
798 
 
799 
            Utils.StoreData = function (element, name, value) {
800 
                // Stores an item in the cache for a specified element.
801 
                // name is the cache key.
802 
                var id = Utils.GetUniqueElementId(element);
803 
                if (!Utils.__cache[id]) {
804 
                    Utils.__cache[id] = {};
805 
                }
806 
 
807 
                Utils.__cache[id][name] = value;
808 
            };
809 
 
810 
            Utils.GetData = function (element, name) {
811 
                // Retrieves a value from the cache by its key (name)
812 
                // name is optional. If no name specified, return
813 
                // all cache items for the specified element.
814 
                // and for a specified element.
815 
                var id = Utils.GetUniqueElementId(element);
816 
                if (name) {
817 
                    if (Utils.__cache[id]) {
818 
                        if (Utils.__cache[id][name] != null) {
819 
                            return Utils.__cache[id][name];
820 
                        }
821 
                        return $(element).data(name); // Fallback to HTML5 data attribs.
822 
                    }
823 
                    return $(element).data(name); // Fallback to HTML5 data attribs.
824 
                } else {
825 
                    return Utils.__cache[id];
826 
                }
827 
            };
828 
 
829 
            Utils.RemoveData = function (element) {
830 
                // Removes all cached items for a specified element.
831 
                var id = Utils.GetUniqueElementId(element);
832 
                if (Utils.__cache[id] != null) {
833 
                    delete Utils.__cache[id];
834 
                }
835 
 
836 
                element.removeAttribute('data-select2-id');
837 
            };
838 
 
839 
            return Utils;
840 
        });
841 
 
842 
        S2.define('select2/results',[
843 
            'jquery',
844 
            './utils'
845 
        ], function ($, Utils) {
846 
            function Results ($element, options, dataAdapter) {
847 
                this.$element = $element;
848 
                this.data = dataAdapter;
849 
                this.options = options;
850 
 
851 
                Results.__super__.constructor.call(this);
852 
            }
853 
 
854 
            Utils.Extend(Results, Utils.Observable);
855 
 
856 
            Results.prototype.render = function () {
857 
                var $results = $(
858 
                    '<ul class="select2-results__options" role="listbox"></ul>'
859 
                );
860 
 
861 
                if (this.options.get('multiple')) {
862 
                    $results.attr('aria-multiselectable', 'true');
863 
                }
864 
 
865 
                this.$results = $results;
866 
 
867 
                return $results;
868 
            };
869 
 
870 
            Results.prototype.clear = function () {
871 
                this.$results.empty();
872 
            };
873 
 
874 
            Results.prototype.displayMessage = function (params) {
875 
                var escapeMarkup = this.options.get('escapeMarkup');
876 
 
877 
                this.clear();
878 
                this.hideLoading();
879 
 
880 
                var $message = $(
881 
                    '<li role="alert" aria-live="assertive"' +
882 
                    ' class="select2-results__option"></li>'
883 
                );
884 
 
885 
                var message = this.options.get('translations').get(params.message);
886 
 
887 
                $message.append(
888 
                    escapeMarkup(
889 
                        message(params.args)
890 
                    )
891 
                );
892 
 
893 
                $message[0].className += ' select2-results__message';
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 
 
1378 
        S2.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 
 
1404 
        S2.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 
 
1583 
        S2.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 
 
1691 
        S2.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 
 
1808 
        S2.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 
 
1858 
        S2.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 
 
1972 
        S2.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 
 
2209 
        S2.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 
 
2258 
        S2.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 
 
2295 
        S2.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 
 
3146 
        S2.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 
 
3187 
        S2.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 
 
3473 
        S2.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 
 
3557 
        S2.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 
 
3668 
        S2.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 
 
3795 
        S2.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 
 
3912 
        S2.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 
 
3943 
        S2.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 
 
3975 
        S2.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 
 
4030 
        S2.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 
 
4073 
        S2.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;
4180 
            };
4181 
 
4182 
            Search.prototype.showSearch = function (_, params) {
4183 
                return true;
4184 
            };
4185 
 
4186 
            return Search;
4187 
        });
4188 
 
4189 
        S2.define('select2/dropdown/hidePlaceholder',[
4190 
 
4191 
        ], function () {
4192 
            function HidePlaceholder (decorated, $element, options, dataAdapter) {
4193 
                this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
4194 
 
4195 
                decorated.call(this, $element, options, dataAdapter);
4196 
            }
4197 
 
4198 
            HidePlaceholder.prototype.append = function (decorated, data) {
4199 
                data.results = this.removePlaceholder(data.results);
4200 
 
4201 
                decorated.call(this, data);
4202 
            };
4203 
 
4204 
            HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder) {
4205 
                if (typeof placeholder === 'string') {
4206 
                    placeholder = {
4207 
                        id: '',
4208 
                        text: placeholder
4209 
                    };
4210 
                }
4211 
 
4212 
                return placeholder;
4213 
            };
4214 
 
4215 
            HidePlaceholder.prototype.removePlaceholder = function (_, data) {
4216 
                var modifiedData = data.slice(0);
4217 
 
4218 
                for (var d = data.length - 1; d >= 0; d--) {
4219 
                    var item = data[d];
4220 
 
4221 
                    if (this.placeholder.id === item.id) {
4222 
                        modifiedData.splice(d, 1);
4223 
                    }
4224 
                }
4225 
 
4226 
                return modifiedData;
4227 
            };
4228 
 
4229 
            return HidePlaceholder;
4230 
        });
4231 
 
4232 
        S2.define('select2/dropdown/infiniteScroll',[
4233 
            'jquery'
4234 
        ], function ($) {
4235 
            function InfiniteScroll (decorated, $element, options, dataAdapter) {
4236 
                this.lastParams = {};
4237 
 
4238 
                decorated.call(this, $element, options, dataAdapter);
4239 
 
4240 
                this.$loadingMore = this.createLoadingMore();
4241 
                this.loading = false;
4242 
            }
4243 
 
4244 
            InfiniteScroll.prototype.append = function (decorated, data) {
4245 
                this.$loadingMore.remove();
4246 
                this.loading = false;
4247 
 
4248 
                decorated.call(this, data);
4249 
 
4250 
                if (this.showLoadingMore(data)) {
4251 
                    this.$results.append(this.$loadingMore);
4252 
                    this.loadMoreIfNeeded();
4253 
                }
4254 
            };
4255 
 
4256 
            InfiniteScroll.prototype.bind = function (decorated, container, $container) {
4257 
                var self = this;
4258 
 
4259 
                decorated.call(this, container, $container);
4260 
 
4261 
                container.on('query', function (params) {
4262 
                    self.lastParams = params;
4263 
                    self.loading = true;
4264 
                });
4265 
 
4266 
                container.on('query:append', function (params) {
4267 
                    self.lastParams = params;
4268 
                    self.loading = true;
4269 
                });
4270 
 
4271 
                this.$results.on('scroll', this.loadMoreIfNeeded.bind(this));
4272 
            };
4273 
 
4274 
            InfiniteScroll.prototype.loadMoreIfNeeded = function () {
4275 
                var isLoadMoreVisible = $.contains(
4276 
                    document.documentElement,
4277 
                    this.$loadingMore[0]
4278 
                );
4279 
 
4280 
                if (this.loading || !isLoadMoreVisible) {
4281 
                    return;
4282 
                }
4283 
 
4284 
                var currentOffset = this.$results.offset().top +
4285 
                    this.$results.outerHeight(false);
4286 
                var loadingMoreOffset = this.$loadingMore.offset().top +
4287 
                    this.$loadingMore.outerHeight(false);
4288 
 
4289 
                if (currentOffset + 50 >= loadingMoreOffset) {
4290 
                    this.loadMore();
4291 
                }
4292 
            };
4293 
 
4294 
            InfiniteScroll.prototype.loadMore = function () {
4295 
                this.loading = true;
4296 
 
4297 
                var params = $.extend({}, {page: 1}, this.lastParams);
4298 
 
4299 
                params.page++;
4300 
 
4301 
                this.trigger('query:append', params);
4302 
            };
4303 
 
4304 
            InfiniteScroll.prototype.showLoadingMore = function (_, data) {
4305 
                return data.pagination && data.pagination.more;
4306 
            };
4307 
 
4308 
            InfiniteScroll.prototype.createLoadingMore = function () {
4309 
                var $option = $(
4310 
                    '<li ' +
4311 
                    'class="select2-results__option select2-results__option--load-more"' +
4312 
                    'role="option" aria-disabled="true"></li>'
4313 
                );
4314 
 
4315 
                var message = this.options.get('translations').get('loadingMore');
4316 
 
4317 
                $option.html(message(this.lastParams));
4318 
 
4319 
                return $option;
4320 
            };
4321 
 
4322 
            return InfiniteScroll;
4323 
        });
4324 
 
4325 
        S2.define('select2/dropdown/attachBody',[
4326 
            'jquery',
4327 
            '../utils'
4328 
        ], function ($, Utils) {
4329 
            function AttachBody (decorated, $element, options) {
4330 
                this.$dropdownParent = $(options.get('dropdownParent') || document.body);
4331 
 
4332 
                decorated.call(this, $element, options);
4333 
            }
4334 
 
4335 
            AttachBody.prototype.bind = function (decorated, container, $container) {
4336 
                var self = this;
4337 
 
4338 
                decorated.call(this, container, $container);
4339 
 
4340 
                container.on('open', function () {
4341 
                    self._showDropdown();
4342 
                    self._attachPositioningHandler(container);
4343 
 
4344 
                    // Must bind after the results handlers to ensure correct sizing
4345 
                    self._bindContainerResultHandlers(container);
4346 
                });
4347 
 
4348 
                container.on('close', function () {
4349 
                    self._hideDropdown();
4350 
                    self._detachPositioningHandler(container);
4351 
                });
4352 
 
4353 
                this.$dropdownContainer.on('mousedown', function (evt) {
4354 
                    evt.stopPropagation();
4355 
                });
4356 
            };
4357 
 
4358 
            AttachBody.prototype.destroy = function (decorated) {
4359 
                decorated.call(this);
4360 
 
4361 
                this.$dropdownContainer.remove();
4362 
            };
4363 
 
4364 
            AttachBody.prototype.position = function (decorated, $dropdown, $container) {
4365 
                // Clone all of the container classes
4366 
                $dropdown.attr('class', $container.attr('class'));
4367 
 
4368 
                $dropdown.removeClass('select2');
4369 
                $dropdown.addClass('select2-container--open');
4370 
 
4371 
                $dropdown.css({
4372 
                    position: 'absolute',
4373 
                    top: -999999
4374 
                });
4375 
 
4376 
                this.$container = $container;
4377 
            };
4378 
 
4379 
            AttachBody.prototype.render = function (decorated) {
4380 
                var $container = $('<span></span>');
4381 
 
4382 
                var $dropdown = decorated.call(this);
4383 
                $container.append($dropdown);
4384 
 
4385 
                this.$dropdownContainer = $container;
4386 
 
4387 
                return $container;
4388 
            };
4389 
 
4390 
            AttachBody.prototype._hideDropdown = function (decorated) {
4391 
                this.$dropdownContainer.detach();
4392 
            };
4393 
 
4394 
            AttachBody.prototype._bindContainerResultHandlers =
4395 
                function (decorated, container) {
4396 
 
4397 
                    // These should only be bound once
4398 
                    if (this._containerResultsHandlersBound) {
4399 
                        return;
4400 
                    }
4401 
 
4402 
                    var self = this;
4403 
 
4404 
                    container.on('results:all', function () {
4405 
                        self._positionDropdown();
4406 
                        self._resizeDropdown();
4407 
                    });
4408 
 
4409 
                    container.on('results:append', function () {
4410 
                        self._positionDropdown();
4411 
                        self._resizeDropdown();
4412 
                    });
4413 
 
4414 
                    container.on('results:message', function () {
4415 
                        self._positionDropdown();
4416 
                        self._resizeDropdown();
4417 
                    });
4418 
 
4419 
                    container.on('select', function () {
4420 
                        self._positionDropdown();
4421 
                        self._resizeDropdown();
4422 
                    });
4423 
 
4424 
                    container.on('unselect', function () {
4425 
                        self._positionDropdown();
4426 
                        self._resizeDropdown();
4427 
                    });
4428 
 
4429 
                    this._containerResultsHandlersBound = true;
4430 
                };
4431 
 
4432 
            AttachBody.prototype._attachPositioningHandler =
4433 
                function (decorated, container) {
4434 
                    var self = this;
4435 
 
4436 
                    var scrollEvent = 'scroll.select2.' + container.id;
4437 
                    var resizeEvent = 'resize.select2.' + container.id;
4438 
                    var orientationEvent = 'orientationchange.select2.' + container.id;
4439 
 
4440 
                    var $watchers = this.$container.parents().filter(Utils.hasScroll);
4441 
                    $watchers.each(function () {
4442 
                        Utils.StoreData(this, 'select2-scroll-position', {
4443 
                            x: $(this).scrollLeft(),
4444 
                            y: $(this).scrollTop()
4445 
                        });
4446 
                    });
4447 
 
4448 
                    $watchers.on(scrollEvent, function (ev) {
4449 
                        var position = Utils.GetData(this, 'select2-scroll-position');
4450 
                        $(this).scrollTop(position.y);
4451 
                    });
4452 
 
4453 
                    $(window).on(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent,
4454 
                        function (e) {
4455 
                            self._positionDropdown();
4456 
                            self._resizeDropdown();
4457 
                        });
4458 
                };
4459 
 
4460 
            AttachBody.prototype._detachPositioningHandler =
4461 
                function (decorated, container) {
4462 
                    var scrollEvent = 'scroll.select2.' + container.id;
4463 
                    var resizeEvent = 'resize.select2.' + container.id;
4464 
                    var orientationEvent = 'orientationchange.select2.' + container.id;
4465 
 
4466 
                    var $watchers = this.$container.parents().filter(Utils.hasScroll);
4467 
                    $watchers.off(scrollEvent);
4468 
 
4469 
                    $(window).off(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent);
4470 
                };
4471 
 
4472 
            AttachBody.prototype._positionDropdown = function () {
4473 
                var $window = $(window);
4474 
 
4475 
                var isCurrentlyAbove = this.$dropdown.hasClass('select2-dropdown--above');
4476 
                var isCurrentlyBelow = this.$dropdown.hasClass('select2-dropdown--below');
4477 
 
4478 
                var newDirection = null;
4479 
 
4480 
                var offset = this.$container.offset();
4481 
 
4482 
                offset.bottom = offset.top + this.$container.outerHeight(false);
4483 
 
4484 
                var container = {
4485 
                    height: this.$container.outerHeight(false)
4486 
                };
4487 
 
4488 
                container.top = offset.top;
4489 
                container.bottom = offset.top + container.height;
4490 
 
4491 
                var dropdown = {
4492 
                    height: this.$dropdown.outerHeight(false)
4493 
                };
4494 
 
4495 
                var viewport = {
4496 
                    top: $window.scrollTop(),
4497 
                    bottom: $window.scrollTop() + $window.height()
4498 
                };
4499 
 
4500 
                var enoughRoomAbove = viewport.top < (offset.top - dropdown.height);
4501 
                var enoughRoomBelow = viewport.bottom > (offset.bottom + dropdown.height);
4502 
 
4503 
                var css = {
4504 
                    left: offset.left,
4505 
                    top: container.bottom
4506 
                };
4507 
 
4508 
                // Determine what the parent element is to use for calculating the offset
4509 
                var $offsetParent = this.$dropdownParent;
4510 
 
4511 
                // For statically positioned elements, we need to get the element
4512 
                // that is determining the offset
4513 
                if ($offsetParent.css('position') === 'static') {
4514 
                    $offsetParent = $offsetParent.offsetParent();
4515 
                }
4516 
 
4517 
                var parentOffset = {
4518 
                    top: 0,
4519 
                    left: 0
4520 
                };
4521 
 
4522 
                if (
4523 
                    $.contains(document.body, $offsetParent[0]) ||
4524 
                    $offsetParent[0].isConnected
4525 
                ) {
4526 
                    parentOffset = $offsetParent.offset();
4527 
                }
4528 
 
4529 
                css.top -= parentOffset.top;
4530 
                css.left -= parentOffset.left;
4531 
 
4532 
                if (!isCurrentlyAbove && !isCurrentlyBelow) {
4533 
                    newDirection = 'below';
4534 
                }
4535 
 
4536 
                if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) {
4537 
                    newDirection = 'above';
4538 
                } else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) {
4539 
                    newDirection = 'below';
4540 
                }
4541 
 
4542 
                if (newDirection == 'above' ||
4543 
                    (isCurrentlyAbove && newDirection !== 'below')) {
4544 
                    css.top = container.top - parentOffset.top - dropdown.height;
4545 
                }
4546 
 
4547 
                if (newDirection != null) {
4548 
                    this.$dropdown
4549 
                        .removeClass('select2-dropdown--below select2-dropdown--above')
4550 
                        .addClass('select2-dropdown--' + newDirection);
4551 
                    this.$container
4552 
                        .removeClass('select2-container--below select2-container--above')
4553 
                        .addClass('select2-container--' + newDirection);
4554 
                }
4555 
 
4556 
                this.$dropdownContainer.css(css);
4557 
            };
4558 
 
4559 
            AttachBody.prototype._resizeDropdown = function () {
4560 
                var css = {
4561 
                    width: this.$container.outerWidth(false) + 'px'
4562 
                };
4563 
 
4564 
                if (this.options.get('dropdownAutoWidth')) {
4565 
                    css.minWidth = css.width;
4566 
                    css.position = 'relative';
4567 
                    css.width = 'auto';
4568 
                }
4569 
 
4570 
                this.$dropdown.css(css);
4571 
            };
4572 
 
4573 
            AttachBody.prototype._showDropdown = function (decorated) {
4574 
                this.$dropdownContainer.appendTo(this.$dropdownParent);
4575 
 
4576 
                this._positionDropdown();
4577 
                this._resizeDropdown();
4578 
            };
4579 
 
4580 
            return AttachBody;
4581 
        });
4582 
 
4583 
        S2.define('select2/dropdown/minimumResultsForSearch',[
4584 
 
4585 
        ], function () {
4586 
            function countResults (data) {
4587 
                var count = 0;
4588 
 
4589 
                for (var d = 0; d < data.length; d++) {
4590 
                    var item = data[d];
4591 
 
4592 
                    if (item.children) {
4593 
                        count += countResults(item.children);
4594 
                    } else {
4595 
                        count++;
4596 
                    }
4597 
                }
4598 
 
4599 
                return count;
4600 
            }
4601 
 
4602 
            function MinimumResultsForSearch (decorated, $element, options, dataAdapter) {
4603 
                this.minimumResultsForSearch = options.get('minimumResultsForSearch');
4604 
 
4605 
                if (this.minimumResultsForSearch < 0) {
4606 
                    this.minimumResultsForSearch = Infinity;
4607 
                }
4608 
 
4609 
                decorated.call(this, $element, options, dataAdapter);
4610 
            }
4611 
 
4612 
            MinimumResultsForSearch.prototype.showSearch = function (decorated, params) {
4613 
                if (countResults(params.data.results) < this.minimumResultsForSearch) {
4614 
                    return false;
4615 
                }
4616 
 
4617 
                return decorated.call(this, params);
4618 
            };
4619 
 
4620 
            return MinimumResultsForSearch;
4621 
        });
4622 
 
4623 
        S2.define('select2/dropdown/selectOnClose',[
4624 
            '../utils'
4625 
        ], function (Utils) {
4626 
            function SelectOnClose () { }
4627 
 
4628 
            SelectOnClose.prototype.bind = function (decorated, container, $container) {
4629 
                var self = this;
4630 
 
4631 
                decorated.call(this, container, $container);
4632 
 
4633 
                container.on('close', function (params) {
4634 
                    self._handleSelectOnClose(params);
4635 
                });
4636 
            };
4637 
 
4638 
            SelectOnClose.prototype._handleSelectOnClose = function (_, params) {
4639 
                if (params && params.originalSelect2Event != null) {
4640 
                    var event = params.originalSelect2Event;
4641 
 
4642 
                    // Don't select an item if the close event was triggered from a select or
4643 
                    // unselect event
4644 
                    if (event._type === 'select' || event._type === 'unselect') {
4645 
                        return;
4646 
                    }
4647 
                }
4648 
 
4649 
                var $highlightedResults = this.getHighlightedResults();
4650 
 
4651 
                // Only select highlighted results
4652 
                if ($highlightedResults.length < 1) {
4653 
                    return;
4654 
                }
4655 
 
4656 
                var data = Utils.GetData($highlightedResults[0], 'data');
4657 
 
4658 
                // Don't re-select already selected resulte
4659 
                if (
4660 
                    (data.element != null && data.element.selected) ||
4661 
                    (data.element == null && data.selected)
4662 
                ) {
4663 
                    return;
4664 
                }
4665 
 
4666 
                this.trigger('select', {
4667 
                    data: data
4668 
                });
4669 
            };
4670 
 
4671 
            return SelectOnClose;
4672 
        });
4673 
 
4674 
        S2.define('select2/dropdown/closeOnSelect',[
4675 
 
4676 
        ], function () {
4677 
            function CloseOnSelect () { }
4678 
 
4679 
            CloseOnSelect.prototype.bind = function (decorated, container, $container) {
4680 
                var self = this;
4681 
 
4682 
                decorated.call(this, container, $container);
4683 
 
4684 
                container.on('select', function (evt) {
4685 
                    self._selectTriggered(evt);
4686 
                });
4687 
 
4688 
                container.on('unselect', function (evt) {
4689 
                    self._selectTriggered(evt);
4690 
                });
4691 
            };
4692 
 
4693 
            CloseOnSelect.prototype._selectTriggered = function (_, evt) {
4694 
                var originalEvent = evt.originalEvent;
4695 
 
4696 
                // Don't close if the control key is being held
4697 
                if (originalEvent && (originalEvent.ctrlKey || originalEvent.metaKey)) {
4698 
                    return;
4699 
                }
4700 
 
4701 
                this.trigger('close', {
4702 
                    originalEvent: originalEvent,
4703 
                    originalSelect2Event: evt
4704 
                });
4705 
            };
4706 
 
4707 
            return CloseOnSelect;
4708 
        });
4709 
 
4710 
        S2.define('select2/i18n/en',[],function () {
4711 
            // English
4712 
            return {
4713 
                errorLoading: function () {
4714 
                    return 'The results could not be loaded.';
4715 
                },
4716 
                inputTooLong: function (args) {
4717 
                    var overChars = args.input.length - args.maximum;
4718 
 
4719 
                    var message = 'Please delete ' + overChars + ' character';
4720 
 
4721 
                    if (overChars != 1) {
4722 
                        message += 's';
4723 
                    }
4724 
 
4725 
                    return message;
4726 
                },
4727 
                inputTooShort: function (args) {
4728 
                    var remainingChars = args.minimum - args.input.length;
4729 
 
4730 
                    var message = 'Please enter ' + remainingChars + ' or more characters';
4731 
 
4732 
                    return message;
4733 
                },
4734 
                loadingMore: function () {
4735 
                    return 'Loading more results…';
4736 
                },
4737 
                maximumSelected: function (args) {
4738 
                    var message = 'You can only select ' + args.maximum + ' item';
4739 
 
4740 
                    if (args.maximum != 1) {
4741 
                        message += 's';
4742 
                    }
4743 
 
4744 
                    return message;
4745 
                },
4746 
                noResults: function () {
4747 
                    return 'No results found';
4748 
                },
4749 
                searching: function () {
4750 
                    return 'Searching…';
4751 
                },
4752 
                removeAllItems: function () {
4753 
                    return 'Remove all items';
4754 
                }
4755 
            };
4756 
        });
4757 
 
4758 
        S2.define('select2/defaults',[
4759 
            'jquery',
4760 
            'require',
4761 
 
4762 
            './results',
4763 
 
4764 
            './selection/single',
4765 
            './selection/multiple',
4766 
            './selection/placeholder',
4767 
            './selection/allowClear',
4768 
            './selection/search',
4769 
            './selection/eventRelay',
4770 
 
4771 
            './utils',
4772 
            './translation',
4773 
            './diacritics',
4774 
 
4775 
            './data/select',
4776 
            './data/array',
4777 
            './data/ajax',
4778 
            './data/tags',
4779 
            './data/tokenizer',
4780 
            './data/minimumInputLength',
4781 
            './data/maximumInputLength',
4782 
            './data/maximumSelectionLength',
4783 
 
4784 
            './dropdown',
4785 
            './dropdown/search',
4786 
            './dropdown/hidePlaceholder',
4787 
            './dropdown/infiniteScroll',
4788 
            './dropdown/attachBody',
4789 
            './dropdown/minimumResultsForSearch',
4790 
            './dropdown/selectOnClose',
4791 
            './dropdown/closeOnSelect',
4792 
 
4793 
            './i18n/en'
4794 
        ], function ($, require,
4795 
 
4796 
                     ResultsList,
4797 
 
4798 
                     SingleSelection, MultipleSelection, Placeholder, AllowClear,
4799 
                     SelectionSearch, EventRelay,
4800 
 
4801 
                     Utils, Translation, DIACRITICS,
4802 
 
4803 
                     SelectData, ArrayData, AjaxData, Tags, Tokenizer,
4804 
                     MinimumInputLength, MaximumInputLength, MaximumSelectionLength,
4805 
 
4806 
                     Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll,
4807 
                     AttachBody, MinimumResultsForSearch, SelectOnClose, CloseOnSelect,
4808 
 
4809 
                     EnglishTranslation) {
4810 
            function Defaults () {
4811 
                this.reset();
4812 
            }
4813 
 
4814 
            Defaults.prototype.apply = function (options) {
4815 
                options = $.extend(true, {}, this.defaults, options);
4816 
 
4817 
                if (options.dataAdapter == null) {
4818 
                    if (options.ajax != null) {
4819 
                        options.dataAdapter = AjaxData;
4820 
                    } else if (options.data != null) {
4821 
                        options.dataAdapter = ArrayData;
4822 
                    } else {
4823 
                        options.dataAdapter = SelectData;
4824 
                    }
4825 
 
4826 
                    if (options.minimumInputLength > 0) {
4827 
                        options.dataAdapter = Utils.Decorate(
4828 
                            options.dataAdapter,
4829 
                            MinimumInputLength
4830 
                        );
4831 
                    }
4832 
 
4833 
                    if (options.maximumInputLength > 0) {
4834 
                        options.dataAdapter = Utils.Decorate(
4835 
                            options.dataAdapter,
4836 
                            MaximumInputLength
4837 
                        );
4838 
                    }
4839 
 
4840 
                    if (options.maximumSelectionLength > 0) {
4841 
                        options.dataAdapter = Utils.Decorate(
4842 
                            options.dataAdapter,
4843 
                            MaximumSelectionLength
4844 
                        );
4845 
                    }
4846 
 
4847 
                    if (options.tags) {
4848 
                        options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags);
4849 
                    }
4850 
 
4851 
                    if (options.tokenSeparators != null || options.tokenizer != null) {
4852 
                        options.dataAdapter = Utils.Decorate(
4853 
                            options.dataAdapter,
4854 
                            Tokenizer
4855 
                        );
4856 
                    }
4857 
 
4858 
                    if (options.query != null) {
4859 
                        var Query = require(options.amdBase + 'compat/query');
4860 
 
4861 
                        options.dataAdapter = Utils.Decorate(
4862 
                            options.dataAdapter,
4863 
                            Query
4864 
                        );
4865 
                    }
4866 
 
4867 
                    if (options.initSelection != null) {
4868 
                        var InitSelection = require(options.amdBase + 'compat/initSelection');
4869 
 
4870 
                        options.dataAdapter = Utils.Decorate(
4871 
                            options.dataAdapter,
4872 
                            InitSelection
4873 
                        );
4874 
                    }
4875 
                }
4876 
 
4877 
                if (options.resultsAdapter == null) {
4878 
                    options.resultsAdapter = ResultsList;
4879 
 
4880 
                    if (options.ajax != null) {
4881 
                        options.resultsAdapter = Utils.Decorate(
4882 
                            options.resultsAdapter,
4883 
                            InfiniteScroll
4884 
                        );
4885 
                    }
4886 
 
4887 
                    if (options.placeholder != null) {
4888 
                        options.resultsAdapter = Utils.Decorate(
4889 
                            options.resultsAdapter,
4890 
                            HidePlaceholder
4891 
                        );
4892 
                    }
4893 
 
4894 
                    if (options.selectOnClose) {
4895 
                        options.resultsAdapter = Utils.Decorate(
4896 
                            options.resultsAdapter,
4897 
                            SelectOnClose
4898 
                        );
4899 
                    }
4900 
                }
4901 
 
4902 
                if (options.dropdownAdapter == null) {
4903 
                    if (options.multiple) {
4904 
                        options.dropdownAdapter = Dropdown;
4905 
                    } else {
4906 
                        var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch);
4907 
 
4908 
                        options.dropdownAdapter = SearchableDropdown;
4909 
                    }
4910 
 
4911 
                    if (options.minimumResultsForSearch !== 0) {
4912 
                        options.dropdownAdapter = Utils.Decorate(
4913 
                            options.dropdownAdapter,
4914 
                            MinimumResultsForSearch
4915 
                        );
4916 
                    }
4917 
 
4918 
                    if (options.closeOnSelect) {
4919 
                        options.dropdownAdapter = Utils.Decorate(
4920 
                            options.dropdownAdapter,
4921 
                            CloseOnSelect
4922 
                        );
4923 
                    }
4924 
 
4925 
                    if (
4926 
                        options.dropdownCssClass != null ||
4927 
                        options.dropdownCss != null ||
4928 
                        options.adaptDropdownCssClass != null
4929 
                    ) {
4930 
                        var DropdownCSS = require(options.amdBase + 'compat/dropdownCss');
4931 
 
4932 
                        options.dropdownAdapter = Utils.Decorate(
4933 
                            options.dropdownAdapter,
4934 
                            DropdownCSS
4935 
                        );
4936 
                    }
4937 
 
4938 
                    options.dropdownAdapter = Utils.Decorate(
4939 
                        options.dropdownAdapter,
4940 
                        AttachBody
4941 
                    );
4942 
                }
4943 
 
4944 
                if (options.selectionAdapter == null) {
4945 
                    if (options.multiple) {
4946 
                        options.selectionAdapter = MultipleSelection;
4947 
                    } else {
4948 
                        options.selectionAdapter = SingleSelection;
4949 
                    }
4950 
 
4951 
                    // Add the placeholder mixin if a placeholder was specified
4952 
                    if (options.placeholder != null) {
4953 
                        options.selectionAdapter = Utils.Decorate(
4954 
                            options.selectionAdapter,
4955 
                            Placeholder
4956 
                        );
4957 
                    }
4958 
 
4959 
                    if (options.allowClear) {
4960 
                        options.selectionAdapter = Utils.Decorate(
4961 
                            options.selectionAdapter,
4962 
                            AllowClear
4963 
                        );
4964 
                    }
4965 
 
4966 
                    if (options.multiple) {
4967 
                        options.selectionAdapter = Utils.Decorate(
4968 
                            options.selectionAdapter,
4969 
                            SelectionSearch
4970 
                        );
4971 
                    }
4972 
 
4973 
                    if (
4974 
                        options.containerCssClass != null ||
4975 
                        options.containerCss != null ||
4976 
                        options.adaptContainerCssClass != null
4977 
                    ) {
4978 
                        var ContainerCSS = require(options.amdBase + 'compat/containerCss');
4979 
 
4980 
                        options.selectionAdapter = Utils.Decorate(
4981 
                            options.selectionAdapter,
4982 
                            ContainerCSS
4983 
                        );
4984 
                    }
4985 
 
4986 
                    options.selectionAdapter = Utils.Decorate(
4987 
                        options.selectionAdapter,
4988 
                        EventRelay
4989 
                    );
4990 
                }
4991 
 
4992 
                // If the defaults were not previously applied from an element, it is
4993 
                // possible for the language option to have not been resolved
4994 
                options.language = this._resolveLanguage(options.language);
4995 
 
4996 
                // Always fall back to English since it will always be complete
4997 
                options.language.push('en');
4998 
 
4999 
                var uniqueLanguages = [];
5000 
 
5001 
                for (var l = 0; l < options.language.length; l++) {
5002 
                    var language = options.language[l];
5003 
 
5004 
                    if (uniqueLanguages.indexOf(language) === -1) {
5005 
                        uniqueLanguages.push(language);
5006 
                    }
5007 
                }
5008 
 
5009 
                options.language = uniqueLanguages;
5010 
 
5011 
                options.translations = this._processTranslations(
5012 
                    options.language,
5013 
                    options.debug
5014 
                );
5015 
 
5016 
                return options;
5017 
            };
5018 
 
5019 
            Defaults.prototype.reset = function () {
5020 
                function stripDiacritics (text) {
5021 
                    // Used 'uni range + named function' from http://jsperf.com/diacritics/18
5022 
                    function match(a) {
5023 
                        return DIACRITICS[a] || a;
5024 
                    }
5025 
 
5026 
                    return text.replace(/[^\u0000-\u007E]/g, match);
5027 
                }
5028 
 
5029 
                function matcher (params, data) {
5030 
                    // Always return the object if there is nothing to compare
5031 
                    if ($.trim(params.term) === '') {
5032 
                        return data;
5033 
                    }
5034 
 
5035 
                    // Do a recursive check for options with children
5036 
                    if (data.children && data.children.length > 0) {
5037 
                        // Clone the data object if there are children
5038 
                        // This is required as we modify the object to remove any non-matches
5039 
                        var match = $.extend(true, {}, data);
5040 
 
5041 
                        // Check each child of the option
5042 
                        for (var c = data.children.length - 1; c >= 0; c--) {
5043 
                            var child = data.children[c];
5044 
 
5045 
                            var matches = matcher(params, child);
5046 
 
5047 
                            // If there wasn't a match, remove the object in the array
5048 
                            if (matches == null) {
5049 
                                match.children.splice(c, 1);
5050 
                            }
5051 
                        }
5052 
 
5053 
                        // If any children matched, return the new object
5054 
                        if (match.children.length > 0) {
5055 
                            return match;
5056 
                        }
5057 
 
5058 
                        // If there were no matching children, check just the plain object
5059 
                        return matcher(params, match);
5060 
                    }
5061 
 
5062 
                    var original = stripDiacritics(data.text).toUpperCase();
5063 
                    var term = stripDiacritics(params.term).toUpperCase();
5064 
 
5065 
                    // Check if the text contains the term
5066 
                    if (original.indexOf(term) > -1) {
5067 
                        return data;
5068 
                    }
5069 
 
5070 
                    // If it doesn't contain the term, don't return anything
5071 
                    return null;
5072 
                }
5073 
 
5074 
                this.defaults = {
5075 
                    amdBase: './',
5076 
                    amdLanguageBase: './i18n/',
5077 
                    closeOnSelect: true,
5078 
                    debug: false,
5079 
                    dropdownAutoWidth: false,
5080 
                    escapeMarkup: Utils.escapeMarkup,
5081 
                    language: {},
5082 
                    matcher: matcher,
5083 
                    minimumInputLength: 0,
5084 
                    maximumInputLength: 0,
5085 
                    maximumSelectionLength: 0,
5086 
                    minimumResultsForSearch: 0,
5087 
                    selectOnClose: false,
5088 
                    scrollAfterSelect: false,
5089 
                    sorter: function (data) {
5090 
                        return data;
5091 
                    },
5092 
                    templateResult: function (result) {
5093 
                        return result.text;
5094 
                    },
5095 
                    templateSelection: function (selection) {
5096 
                        return selection.text;
5097 
                    },
5098 
                    theme: 'default',
5099 
                    width: 'resolve'
5100 
                };
5101 
            };
5102 
 
5103 
            Defaults.prototype.applyFromElement = function (options, $element) {
5104 
                var optionLanguage = options.language;
5105 
                var defaultLanguage = this.defaults.language;
5106 
                var elementLanguage = $element.prop('lang');
5107 
                var parentLanguage = $element.closest('[lang]').prop('lang');
5108 
 
5109 
                var languages = Array.prototype.concat.call(
5110 
                    this._resolveLanguage(elementLanguage),
5111 
                    this._resolveLanguage(optionLanguage),
5112 
                    this._resolveLanguage(defaultLanguage),
5113 
                    this._resolveLanguage(parentLanguage)
5114 
                );
5115 
 
5116 
                options.language = languages;
5117 
 
5118 
                return options;
5119 
            };
5120 
 
5121 
            Defaults.prototype._resolveLanguage = function (language) {
5122 
                if (!language) {
5123 
                    return [];
5124 
                }
5125 
 
5126 
                if ($.isEmptyObject(language)) {
5127 
                    return [];
5128 
                }
5129 
 
5130 
                if ($.isPlainObject(language)) {
5131 
                    return [language];
5132 
                }
5133 
 
5134 
                var languages;
5135 
 
5136 
                if (!$.isArray(language)) {
5137 
                    languages = [language];
5138 
                } else {
5139 
                    languages = language;
5140 
                }
5141 
 
5142 
                var resolvedLanguages = [];
5143 
 
5144 
                for (var l = 0; l < languages.length; l++) {
5145 
                    resolvedLanguages.push(languages[l]);
5146 
 
5147 
                    if (typeof languages[l] === 'string' && languages[l].indexOf('-') > 0) {
5148 
                        // Extract the region information if it is included
5149 
                        var languageParts = languages[l].split('-');
5150 
                        var baseLanguage = languageParts[0];
5151 
 
5152 
                        resolvedLanguages.push(baseLanguage);
5153 
                    }
5154 
                }
5155 
 
5156 
                return resolvedLanguages;
5157 
            };
5158 
 
5159 
            Defaults.prototype._processTranslations = function (languages, debug) {
5160 
                var translations = new Translation();
5161 
 
5162 
                for (var l = 0; l < languages.length; l++) {
5163 
                    var languageData = new Translation();
5164 
 
5165 
                    var language = languages[l];
5166 
 
5167 
                    if (typeof language === 'string') {
5168 
                        try {
5169 
                            // Try to load it with the original name
5170 
                            languageData = Translation.loadPath(language);
5171 
                        } catch (e) {
5172 
                            try {
5173 
                                // If we couldn't load it, check if it wasn't the full path
5174 
                                language = this.defaults.amdLanguageBase + language;
5175 
                                languageData = Translation.loadPath(language);
5176 
                            } catch (ex) {
5177 
                                // The translation could not be loaded at all. Sometimes this is
5178 
                                // because of a configuration problem, other times this can be
5179 
                                // because of how Select2 helps load all possible translation files
5180 
                                if (debug && window.console && console.warn) {
5181 
                                    console.warn(
5182 
                                        'Select2: The language file for "' + language + '" could ' +
5183 
                                        'not be automatically loaded. A fallback will be used instead.'
5184 
                                    );
5185 
                                }
5186 
                            }
5187 
                        }
5188 
                    } else if ($.isPlainObject(language)) {
5189 
                        languageData = new Translation(language);
5190 
                    } else {
5191 
                        languageData = language;
5192 
                    }
5193 
 
5194 
                    translations.extend(languageData);
5195 
                }
5196 
 
5197 
                return translations;
5198 
            };
5199 
 
5200 
            Defaults.prototype.set = function (key, value) {
5201 
                var camelKey = $.camelCase(key);
5202 
 
5203 
                var data = {};
5204 
                data[camelKey] = value;
5205 
 
5206 
                var convertedData = Utils._convertData(data);
5207 
 
5208 
                $.extend(true, this.defaults, convertedData);
5209 
            };
5210 
 
5211 
            var defaults = new Defaults();
5212 
 
5213 
            return defaults;
5214 
        });
5215 
 
5216 
        S2.define('select2/options',[
5217 
            'require',
5218 
            'jquery',
5219 
            './defaults',
5220 
            './utils'
5221 
        ], function (require, $, Defaults, Utils) {
5222 
            function Options (options, $element) {
5223 
                this.options = options;
5224 
 
5225 
                if ($element != null) {
5226 
                    this.fromElement($element);
5227 
                }
5228 
 
5229 
                if ($element != null) {
5230 
                    this.options = Defaults.applyFromElement(this.options, $element);
5231 
                }
5232 
 
5233 
                this.options = Defaults.apply(this.options);
5234 
 
5235 
                if ($element && $element.is('input')) {
5236 
                    var InputCompat = require(this.get('amdBase') + 'compat/inputData');
5237 
 
5238 
                    this.options.dataAdapter = Utils.Decorate(
5239 
                        this.options.dataAdapter,
5240 
                        InputCompat
5241 
                    );
5242 
                }
5243 
            }
5244 
 
5245 
            Options.prototype.fromElement = function ($e) {
5246 
                var excludedData = ['select2'];
5247 
 
5248 
                if (this.options.multiple == null) {
5249 
                    this.options.multiple = $e.prop('multiple');
5250 
                }
5251 
 
5252 
                if (this.options.disabled == null) {
5253 
                    this.options.disabled = $e.prop('disabled');
5254 
                }
5255 
 
5256 
                if (this.options.dir == null) {
5257 
                    if ($e.prop('dir')) {
5258 
                        this.options.dir = $e.prop('dir');
5259 
                    } else if ($e.closest('[dir]').prop('dir')) {
5260 
                        this.options.dir = $e.closest('[dir]').prop('dir');
5261 
                    } else {
5262 
                        this.options.dir = 'ltr';
5263 
                    }
5264 
                }
5265 
 
5266 
                $e.prop('disabled', this.options.disabled);
5267 
                $e.prop('multiple', this.options.multiple);
5268 
 
5269 
                if (Utils.GetData($e[0], 'select2Tags')) {
5270 
                    if (this.options.debug && window.console && console.warn) {
5271 
                        console.warn(
5272 
                            'Select2: The `data-select2-tags` attribute has been changed to ' +
5273 
                            'use the `data-data` and `data-tags="true"` attributes and will be ' +
5274 
                            'removed in future versions of Select2.'
5275 
                        );
5276 
                    }
5277 
 
5278 
                    Utils.StoreData($e[0], 'data', Utils.GetData($e[0], 'select2Tags'));
5279 
                    Utils.StoreData($e[0], 'tags', true);
5280 
                }
5281 
 
5282 
                if (Utils.GetData($e[0], 'ajaxUrl')) {
5283 
                    if (this.options.debug && window.console && console.warn) {
5284 
                        console.warn(
5285 
                            'Select2: The `data-ajax-url` attribute has been changed to ' +
5286 
                            '`data-ajax--url` and support for the old attribute will be removed' +
5287 
                            ' in future versions of Select2.'
5288 
                        );
5289 
                    }
5290 
 
5291 
                    $e.attr('ajax--url', Utils.GetData($e[0], 'ajaxUrl'));
5292 
                    Utils.StoreData($e[0], 'ajax-Url', Utils.GetData($e[0], 'ajaxUrl'));
5293 
                }
5294 
 
5295 
                var dataset = {};
5296 
 
5297 
                function upperCaseLetter(_, letter) {
5298 
                    return letter.toUpperCase();
5299 
                }
5300 
 
5301 
                // Pre-load all of the attributes which are prefixed with `data-`
5302 
                for (var attr = 0; attr < $e[0].attributes.length; attr++) {
5303 
                    var attributeName = $e[0].attributes[attr].name;
5304 
                    var prefix = 'data-';
5305 
 
5306 
                    if (attributeName.substr(0, prefix.length) == prefix) {
5307 
                        // Get the contents of the attribute after `data-`
5308 
                        var dataName = attributeName.substring(prefix.length);
5309 
 
5310 
                        // Get the data contents from the consistent source
5311 
                        // This is more than likely the jQuery data helper
5312 
                        var dataValue = Utils.GetData($e[0], dataName);
5313 
 
5314 
                        // camelCase the attribute name to match the spec
5315 
                        var camelDataName = dataName.replace(/-([a-z])/g, upperCaseLetter);
5316 
 
5317 
                        // Store the data attribute contents into the dataset since
5318 
                        dataset[camelDataName] = dataValue;
5319 
                    }
5320 
                }
5321 
 
5322 
                // Prefer the element's `dataset` attribute if it exists
5323 
                // jQuery 1.x does not correctly handle data attributes with multiple dashes
5324 
                if ($.fn.jquery && $.fn.jquery.substr(0, 2) == '1.' && $e[0].dataset) {
5325 
                    dataset = $.extend(true, {}, $e[0].dataset, dataset);
5326 
                }
5327 
 
5328 
                // Prefer our internal data cache if it exists
5329 
                var data = $.extend(true, {}, Utils.GetData($e[0]), dataset);
5330 
 
5331 
                data = Utils._convertData(data);
5332 
 
5333 
                for (var key in data) {
5334 
                    if ($.inArray(key, excludedData) > -1) {
5335 
                        continue;
5336 
                    }
5337 
 
5338 
                    if ($.isPlainObject(this.options[key])) {
5339 
                        $.extend(this.options[key], data[key]);
5340 
                    } else {
5341 
                        this.options[key] = data[key];
5342 
                    }
5343 
                }
5344 
 
5345 
                return this;
5346 
            };
5347 
 
5348 
            Options.prototype.get = function (key) {
5349 
                return this.options[key];
5350 
            };
5351 
 
5352 
            Options.prototype.set = function (key, val) {
5353 
                this.options[key] = val;
5354 
            };
5355 
 
5356 
            return Options;
5357 
        });
5358 
 
5359 
        S2.define('select2/core',[
5360 
            'jquery',
5361 
            './options',
5362 
            './utils',
5363 
            './keys'
5364 
        ], function ($, Options, Utils, KEYS) {
5365 
            var Select2 = function ($element, options) {
5366 
                if (Utils.GetData($element[0], 'select2') != null) {
5367 
                    Utils.GetData($element[0], 'select2').destroy();
5368 
                }
5369 
 
5370 
                this.$element = $element;
5371 
 
5372 
                this.id = this._generateId($element);
5373 
 
5374 
                options = options || {};
5375 
 
5376 
                this.options = new Options(options, $element);
5377 
 
5378 
                Select2.__super__.constructor.call(this);
5379 
 
5380 
                // Set up the tabindex
5381 
 
5382 
                var tabindex = $element.attr('tabindex') || 0;
5383 
                Utils.StoreData($element[0], 'old-tabindex', tabindex);
5384 
                $element.attr('tabindex', '-1');
5385 
 
5386 
                // Set up containers and adapters
5387 
 
5388 
                var DataAdapter = this.options.get('dataAdapter');
5389 
                this.dataAdapter = new DataAdapter($element, this.options);
5390 
 
5391 
                var $container = this.render();
5392 
 
5393 
                this._placeContainer($container);
5394 
 
5395 
                var SelectionAdapter = this.options.get('selectionAdapter');
5396 
                this.selection = new SelectionAdapter($element, this.options);
5397 
                this.$selection = this.selection.render();
5398 
 
5399 
                this.selection.position(this.$selection, $container);
5400 
 
5401 
                var DropdownAdapter = this.options.get('dropdownAdapter');
5402 
                this.dropdown = new DropdownAdapter($element, this.options);
5403 
                this.$dropdown = this.dropdown.render();
5404 
 
5405 
                this.dropdown.position(this.$dropdown, $container);
5406 
 
5407 
                var ResultsAdapter = this.options.get('resultsAdapter');
5408 
                this.results = new ResultsAdapter($element, this.options, this.dataAdapter);
5409 
                this.$results = this.results.render();
5410 
 
5411 
                this.results.position(this.$results, this.$dropdown);
5412 
 
5413 
                // Bind events
5414 
 
5415 
                var self = this;
5416 
 
5417 
                // Bind the container to all of the adapters
5418 
                this._bindAdapters();
5419 
 
5420 
                // Register any DOM event handlers
5421 
                this._registerDomEvents();
5422 
 
5423 
                // Register any internal event handlers
5424 
                this._registerDataEvents();
5425 
                this._registerSelectionEvents();
5426 
                this._registerDropdownEvents();
5427 
                this._registerResultsEvents();
5428 
                this._registerEvents();
5429 
 
5430 
                // Set the initial state
5431 
                this.dataAdapter.current(function (initialData) {
5432 
                    self.trigger('selection:update', {
5433 
                        data: initialData
5434 
                    });
5435 
                });
5436 
 
5437 
                // Hide the original select
5438 
                $element.addClass('select2-hidden-accessible');
5439 
                $element.attr('aria-hidden', 'true');
5440 
 
5441 
                // Synchronize any monitored attributes
5442 
                this._syncAttributes();
5443 
 
5444 
                Utils.StoreData($element[0], 'select2', this);
5445 
 
5446 
                // Ensure backwards compatibility with $element.data('select2').
5447 
                $element.data('select2', this);
5448 
            };
5449 
 
5450 
            Utils.Extend(Select2, Utils.Observable);
5451 
 
5452 
            Select2.prototype._generateId = function ($element) {
5453 
                var id = '';
5454 
 
5455 
                if ($element.attr('id') != null) {
5456 
                    id = $element.attr('id');
5457 
                } else if ($element.attr('name') != null) {
5458 
                    id = $element.attr('name') + '-' + Utils.generateChars(2);
5459 
                } else {
5460 
                    id = Utils.generateChars(4);
5461 
                }
5462 
 
5463 
                id = id.replace(/(:|\.|\[|\]|,)/g, '');
5464 
                id = 'select2-' + id;
5465 
 
5466 
                return id;
5467 
            };
5468 
 
5469 
            Select2.prototype._placeContainer = function ($container) {
5470 
                $container.insertAfter(this.$element);
5471 
 
5472 
                var width = this._resolveWidth(this.$element, this.options.get('width'));
5473 
 
5474 
                if (width != null) {
5475 
                    $container.css('width', width);
5476 
                }
5477 
            };
5478 
 
5479 
            Select2.prototype._resolveWidth = function ($element, method) {
5480 
                var WIDTH = /^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i;
5481 
 
5482 
                if (method == 'resolve') {
5483 
                    var styleWidth = this._resolveWidth($element, 'style');
5484 
 
5485 
                    if (styleWidth != null) {
5486 
                        return styleWidth;
5487 
                    }
5488 
 
5489 
                    return this._resolveWidth($element, 'element');
5490 
                }
5491 
 
5492 
                if (method == 'element') {
5493 
                    var elementWidth = $element.outerWidth(false);
5494 
 
5495 
                    if (elementWidth <= 0) {
5496 
                        return 'auto';
5497 
                    }
5498 
 
5499 
                    return elementWidth + 'px';
5500 
                }
5501 
 
5502 
                if (method == 'style') {
5503 
                    var style = $element.attr('style');
5504 
 
5505 
                    if (typeof(style) !== 'string') {
5506 
                        return null;
5507 
                    }
5508 
 
5509 
                    var attrs = style.split(';');
5510 
 
5511 
                    for (var i = 0, l = attrs.length; i < l; i = i + 1) {
5512 
                        var attr = attrs[i].replace(/\s/g, '');
5513 
                        var matches = attr.match(WIDTH);
5514 
 
5515 
                        if (matches !== null && matches.length >= 1) {
5516 
                            return matches[1];
5517 
                        }
5518 
                    }
5519 
 
5520 
                    return null;
5521 
                }
5522 
 
5523 
                if (method == 'computedstyle') {
5524 
                    var computedStyle = window.getComputedStyle($element[0]);
5525 
 
5526 
                    return computedStyle.width;
5527 
                }
5528 
 
5529 
                return method;
5530 
            };
5531 
 
5532 
            Select2.prototype._bindAdapters = function () {
5533 
                this.dataAdapter.bind(this, this.$container);
5534 
                this.selection.bind(this, this.$container);
5535 
 
5536 
                this.dropdown.bind(this, this.$container);
5537 
                this.results.bind(this, this.$container);
5538 
            };
5539 
 
5540 
            Select2.prototype._registerDomEvents = function () {
5541 
                var self = this;
5542 
 
5543 
                this.$element.on('change.select2', function () {
5544 
                    self.dataAdapter.current(function (data) {
5545 
                        self.trigger('selection:update', {
5546 
                            data: data
5547 
                        });
5548 
                    });
5549 
                });
5550 
 
5551 
                this.$element.on('focus.select2', function (evt) {
5552 
                    self.trigger('focus', evt);
5553 
                });
5554 
 
5555 
                this._syncA = Utils.bind(this._syncAttributes, this);
5556 
                this._syncS = Utils.bind(this._syncSubtree, this);
5557 
 
5558 
                if (this.$element[0].attachEvent) {
5559 
                    this.$element[0].attachEvent('onpropertychange', this._syncA);
5560 
                }
5561 
 
5562 
                var observer = window.MutationObserver ||
5563 
                    window.WebKitMutationObserver ||
5564 
                    window.MozMutationObserver
5565 
                ;
5566 
 
5567 
                if (observer != null) {
5568 
                    this._observer = new observer(function (mutations) {
5569 
                        self._syncA();
5570 
                        self._syncS(null, mutations);
5571 
                    });
5572 
                    this._observer.observe(this.$element[0], {
5573 
                        attributes: true,
5574 
                        childList: true,
5575 
                        subtree: false
5576 
                    });
5577 
                } else if (this.$element[0].addEventListener) {
5578 
                    this.$element[0].addEventListener(
5579 
                        'DOMAttrModified',
5580 
                        self._syncA,
5581 
                        false
5582 
                    );
5583 
                    this.$element[0].addEventListener(
5584 
                        'DOMNodeInserted',
5585 
                        self._syncS,
5586 
                        false
5587 
                    );
5588 
                    this.$element[0].addEventListener(
5589 
                        'DOMNodeRemoved',
5590 
                        self._syncS,
5591 
                        false
5592 
                    );
5593 
                }
5594 
            };
5595 
 
5596 
            Select2.prototype._registerDataEvents = function () {
5597 
                var self = this;
5598 
 
5599 
                this.dataAdapter.on('*', function (name, params) {
5600 
                    self.trigger(name, params);
5601 
                });
5602 
            };
5603 
 
5604 
            Select2.prototype._registerSelectionEvents = function () {
5605 
                var self = this;
5606 
                var nonRelayEvents = ['toggle', 'focus'];
5607 
 
5608 
                this.selection.on('toggle', function () {
5609 
                    self.toggleDropdown();
5610 
                });
5611 
 
5612 
                this.selection.on('focus', function (params) {
5613 
                    self.focus(params);
5614 
                });
5615 
 
5616 
                this.selection.on('*', function (name, params) {
5617 
                    if ($.inArray(name, nonRelayEvents) !== -1) {
5618 
                        return;
5619 
                    }
5620 
 
5621 
                    self.trigger(name, params);
5622 
                });
5623 
            };
5624 
 
5625 
            Select2.prototype._registerDropdownEvents = function () {
5626 
                var self = this;
5627 
 
5628 
                this.dropdown.on('*', function (name, params) {
5629 
                    self.trigger(name, params);
5630 
                });
5631 
            };
5632 
 
5633 
            Select2.prototype._registerResultsEvents = function () {
5634 
                var self = this;
5635 
 
5636 
                this.results.on('*', function (name, params) {
5637 
                    self.trigger(name, params);
5638 
                });
5639 
            };
5640 
 
5641 
            Select2.prototype._registerEvents = function () {
5642 
                var self = this;
5643 
 
5644 
                this.on('open', function () {
5645 
                    self.$container.addClass('select2-container--open');
5646 
                });
5647 
 
5648 
                this.on('close', function () {
5649 
                    self.$container.removeClass('select2-container--open');
5650 
                });
5651 
 
5652 
                this.on('enable', function () {
5653 
                    self.$container.removeClass('select2-container--disabled');
5654 
                });
5655 
 
5656 
                this.on('disable', function () {
5657 
                    self.$container.addClass('select2-container--disabled');
5658 
                });
5659 
 
5660 
                this.on('blur', function () {
5661 
                    self.$container.removeClass('select2-container--focus');
5662 
                });
5663 
 
5664 
                this.on('query', function (params) {
5665 
                    if (!self.isOpen()) {
5666 
                        self.trigger('open', {});
5667 
                    }
5668 
 
5669 
                    this.dataAdapter.query(params, function (data) {
5670 
                        self.trigger('results:all', {
5671 
                            data: data,
5672 
                            query: params
5673 
                        });
5674 
                    });
5675 
                });
5676 
 
5677 
                this.on('query:append', function (params) {
5678 
                    this.dataAdapter.query(params, function (data) {
5679 
                        self.trigger('results:append', {
5680 
                            data: data,
5681 
                            query: params
5682 
                        });
5683 
                    });
5684 
                });
5685 
 
5686 
                this.on('keypress', function (evt) {
5687 
                    var key = evt.which;
5688 
 
5689 
                    if (self.isOpen()) {
5690 
                        if (key === KEYS.ESC || key === KEYS.TAB ||
5691 
                            (key === KEYS.UP && evt.altKey)) {
5692 
                            self.close(evt);
5693 
 
5694 
                            evt.preventDefault();
5695 
                        } else if (key === KEYS.ENTER) {
5696 
                            self.trigger('results:select', {});
5697 
 
5698 
                            evt.preventDefault();
5699 
                        } else if ((key === KEYS.SPACE && evt.ctrlKey)) {
5700 
                            self.trigger('results:toggle', {});
5701 
 
5702 
                            evt.preventDefault();
5703 
                        } else if (key === KEYS.UP) {
5704 
                            self.trigger('results:previous', {});
5705 
 
5706 
                            evt.preventDefault();
5707 
                        } else if (key === KEYS.DOWN) {
5708 
                            self.trigger('results:next', {});
5709 
 
5710 
                            evt.preventDefault();
5711 
                        }
5712 
                    } else {
5713 
                        if (key === KEYS.ENTER || key === KEYS.SPACE ||
5714 
                            (key === KEYS.DOWN && evt.altKey)) {
5715 
                            self.open();
5716 
 
5717 
                            evt.preventDefault();
5718 
                        }
5719 
                    }
5720 
                });
5721 
            };
5722 
 
5723 
            Select2.prototype._syncAttributes = function () {
5724 
                this.options.set('disabled', this.$element.prop('disabled'));
5725 
 
5726 
                if (this.isDisabled()) {
5727 
                    if (this.isOpen()) {
5728 
                        this.close();
5729 
                    }
5730 
 
5731 
                    this.trigger('disable', {});
5732 
                } else {
5733 
                    this.trigger('enable', {});
5734 
                }
5735 
            };
5736 
 
5737 
            Select2.prototype._isChangeMutation = function (evt, mutations) {
5738 
                var changed = false;
5739 
                var self = this;
5740 
 
5741 
                // Ignore any mutation events raised for elements that aren't options or
5742 
                // optgroups. This handles the case when the select element is destroyed
5743 
                if (
5744 
                    evt && evt.target && (
5745 
                        evt.target.nodeName !== 'OPTION' && evt.target.nodeName !== 'OPTGROUP'
5746 
                    )
5747 
                ) {
5748 
                    return;
5749 
                }
5750 
 
5751 
                if (!mutations) {
5752 
                    // If mutation events aren't supported, then we can only assume that the
5753 
                    // change affected the selections
5754 
                    changed = true;
5755 
                } else if (mutations.addedNodes && mutations.addedNodes.length > 0) {
5756 
                    for (var n = 0; n < mutations.addedNodes.length; n++) {
5757 
                        var node = mutations.addedNodes[n];
5758 
 
5759 
                        if (node.selected) {
5760 
                            changed = true;
5761 
                        }
5762 
                    }
5763 
                } else if (mutations.removedNodes && mutations.removedNodes.length > 0) {
5764 
                    changed = true;
5765 
                } else if ($.isArray(mutations)) {
5766 
                    $.each(mutations, function(evt, mutation) {
5767 
                        if (self._isChangeMutation(evt, mutation)) {
5768 
                            // We've found a change mutation.
5769 
                            // Let's escape from the loop and continue
5770 
                            changed = true;
5771 
                            return false;
5772 
                        }
5773 
                    });
5774 
                }
5775 
                return changed;
5776 
            };
5777 
 
5778 
            Select2.prototype._syncSubtree = function (evt, mutations) {
5779 
                var changed = this._isChangeMutation(evt, mutations);
5780 
                var self = this;
5781 
 
5782 
                // Only re-pull the data if we think there is a change
5783 
                if (changed) {
5784 
                    this.dataAdapter.current(function (currentData) {
5785 
                        self.trigger('selection:update', {
5786 
                            data: currentData
5787 
                        });
5788 
                    });
5789 
                }
5790 
            };
5791 
 
5792 
            /**
5793 
             * Override the trigger method to automatically trigger pre-events when
5794 
             * there are events that can be prevented.
5795 
             */
5796 
            Select2.prototype.trigger = function (name, args) {
5797 
                var actualTrigger = Select2.__super__.trigger;
5798 
                var preTriggerMap = {
5799 
                    'open': 'opening',
5800 
                    'close': 'closing',
5801 
                    'select': 'selecting',
5802 
                    'unselect': 'unselecting',
5803 
                    'clear': 'clearing'
5804 
                };
5805 
 
5806 
                if (args === undefined) {
5807 
                    args = {};
5808 
                }
5809 
 
5810 
                if (name in preTriggerMap) {
5811 
                    var preTriggerName = preTriggerMap[name];
5812 
                    var preTriggerArgs = {
5813 
                        prevented: false,
5814 
                        name: name,
5815 
                        args: args
5816 
                    };
5817 
 
5818 
                    actualTrigger.call(this, preTriggerName, preTriggerArgs);
5819 
 
5820 
                    if (preTriggerArgs.prevented) {
5821 
                        args.prevented = true;
5822 
 
5823 
                        return;
5824 
                    }
5825 
                }
5826 
 
5827 
                actualTrigger.call(this, name, args);
5828 
            };
5829 
 
5830 
            Select2.prototype.toggleDropdown = function () {
5831 
                if (this.isDisabled()) {
5832 
                    return;
5833 
                }
5834 
 
5835 
                if (this.isOpen()) {
5836 
                    this.close();
5837 
                } else {
5838 
                    this.open();
5839 
                }
5840 
            };
5841 
 
5842 
            Select2.prototype.open = function () {
5843 
                if (this.isOpen()) {
5844 
                    return;
5845 
                }
5846 
 
5847 
                if (this.isDisabled()) {
5848 
                    return;
5849 
                }
5850 
 
5851 
                this.trigger('query', {});
5852 
            };
5853 
 
5854 
            Select2.prototype.close = function (evt) {
5855 
                if (!this.isOpen()) {
5856 
                    return;
5857 
                }
5858 
 
5859 
                this.trigger('close', { originalEvent : evt });
5860 
            };
5861 
 
5862 
            /**
5863 
             * Helper method to abstract the "enabled" (not "disabled") state of this
5864 
             * object.
5865 
             *
5866 
             * @return {true} if the instance is not disabled.
5867 
             * @return {false} if the instance is disabled.
5868 
             */
5869 
            Select2.prototype.isEnabled = function () {
5870 
                return !this.isDisabled();
5871 
            };
5872 
 
5873 
            /**
5874 
             * Helper method to abstract the "disabled" state of this object.
5875 
             *
5876 
             * @return {true} if the disabled option is true.
5877 
             * @return {false} if the disabled option is false.
5878 
             */
5879 
            Select2.prototype.isDisabled = function () {
5880 
                return this.options.get('disabled');
5881 
            };
5882 
 
5883 
            Select2.prototype.isOpen = function () {
5884 
                return this.$container.hasClass('select2-container--open');
5885 
            };
5886 
 
5887 
            Select2.prototype.hasFocus = function () {
5888 
                return this.$container.hasClass('select2-container--focus');
5889 
            };
5890 
 
5891 
            Select2.prototype.focus = function (data) {
5892 
                // No need to re-trigger focus events if we are already focused
5893 
                if (this.hasFocus()) {
5894 
                    return;
5895 
                }
5896 
 
5897 
                this.$container.addClass('select2-container--focus');
5898 
                this.trigger('focus', {});
5899 
            };
5900 
 
5901 
            Select2.prototype.enable = function (args) {
5902 
                if (this.options.get('debug') && window.console && console.warn) {
5903 
                    console.warn(
5904 
                        'Select2: The `select2("enable")` method has been deprecated and will' +
5905 
                        ' be removed in later Select2 versions. Use $element.prop("disabled")' +
5906 
                        ' instead.'
5907 
                    );
5908 
                }
5909 
 
5910 
                if (args == null || args.length === 0) {
5911 
                    args = [true];
5912 
                }
5913 
 
5914 
                var disabled = !args[0];
5915 
 
5916 
                this.$element.prop('disabled', disabled);
5917 
            };
5918 
 
5919 
            Select2.prototype.data = function () {
5920 
                if (this.options.get('debug') &&
5921 
                    arguments.length > 0 && window.console && console.warn) {
5922 
                    console.warn(
5923 
                        'Select2: Data can no longer be set using `select2("data")`. You ' +
5924 
                        'should consider setting the value instead using `$element.val()`.'
5925 
                    );
5926 
                }
5927 
 
5928 
                var data = [];
5929 
 
5930 
                this.dataAdapter.current(function (currentData) {
5931 
                    data = currentData;
5932 
                });
5933 
 
5934 
                return data;
5935 
            };
5936 
 
5937 
            Select2.prototype.val = function (args) {
5938 
                if (this.options.get('debug') && window.console && console.warn) {
5939 
                    console.warn(
5940 
                        'Select2: The `select2("val")` method has been deprecated and will be' +
5941 
                        ' removed in later Select2 versions. Use $element.val() instead.'
5942 
                    );
5943 
                }
5944 
 
5945 
                if (args == null || args.length === 0) {
5946 
                    return this.$element.val();
5947 
                }
5948 
 
5949 
                var newVal = args[0];
5950 
 
5951 
                if ($.isArray(newVal)) {
5952 
                    newVal = $.map(newVal, function (obj) {
5953 
                        return obj.toString();
5954 
                    });
5955 
                }
5956 
 
5957 
                this.$element.val(newVal).trigger('input').trigger('change');
5958 
            };
5959 
 
5960 
            Select2.prototype.destroy = function () {
5961 
                this.$container.remove();
5962 
 
5963 
                if (this.$element[0].detachEvent) {
5964 
                    this.$element[0].detachEvent('onpropertychange', this._syncA);
5965 
                }
5966 
 
5967 
                if (this._observer != null) {
5968 
                    this._observer.disconnect();
5969 
                    this._observer = null;
5970 
                } else if (this.$element[0].removeEventListener) {
5971 
                    this.$element[0]
5972 
                        .removeEventListener('DOMAttrModified', this._syncA, false);
5973 
                    this.$element[0]
5974 
                        .removeEventListener('DOMNodeInserted', this._syncS, false);
5975 
                    this.$element[0]
5976 
                        .removeEventListener('DOMNodeRemoved', this._syncS, false);
5977 
                }
5978 
 
5979 
                this._syncA = null;
5980 
                this._syncS = null;
5981 
 
5982 
                this.$element.off('.select2');
5983 
                this.$element.attr('tabindex',
5984 
                    Utils.GetData(this.$element[0], 'old-tabindex'));
5985 
 
5986 
                this.$element.removeClass('select2-hidden-accessible');
5987 
                this.$element.attr('aria-hidden', 'false');
5988 
                Utils.RemoveData(this.$element[0]);
5989 
                this.$element.removeData('select2');
5990 
 
5991 
                this.dataAdapter.destroy();
5992 
                this.selection.destroy();
5993 
                this.dropdown.destroy();
5994 
                this.results.destroy();
5995 
 
5996 
                this.dataAdapter = null;
5997 
                this.selection = null;
5998 
                this.dropdown = null;
5999 
                this.results = null;
6000 
            };
6001 
 
6002 
            Select2.prototype.render = function () {
6003 
                var $container = $(
6004 
                    '<span class="select2 select2-container">' +
6005 
                    '<span class="selection"></span>' +
6006 
                    '<span class="dropdown-wrapper" aria-hidden="true"></span>' +
6007 
                    '</span>'
6008 
                );
6009 
 
6010 
                $container.attr('dir', this.options.get('dir'));
6011 
 
6012 
                this.$container = $container;
6013 
 
6014 
                this.$container.addClass('select2-container--' + this.options.get('theme'));
6015 
 
6016 
                Utils.StoreData($container[0], 'element', this.$element);
6017 
 
6018 
                return $container;
6019 
            };
6020 
 
6021 
            return Select2;
6022 
        });
6023 
 
6024 
        S2.define('select2/compat/utils',[
6025 
            'jquery'
6026 
        ], function ($) {
6027 
            function syncCssClasses ($dest, $src, adapter) {
6028 
                var classes, replacements = [], adapted;
6029 
 
6030 
                classes = $.trim($dest.attr('class'));
6031 
 
6032 
                if (classes) {
6033 
                    classes = '' + classes; // for IE which returns object
6034 
 
6035 
                    $(classes.split(/\s+/)).each(function () {
6036 
                        // Save all Select2 classes
6037 
                        if (this.indexOf('select2-') === 0) {
6038 
                            replacements.push(this);
6039 
                        }
6040 
                    });
6041 
                }
6042 
 
6043 
                classes = $.trim($src.attr('class'));
6044 
 
6045 
                if (classes) {
6046 
                    classes = '' + classes; // for IE which returns object
6047 
 
6048 
                    $(classes.split(/\s+/)).each(function () {
6049 
                        // Only adapt non-Select2 classes
6050 
                        if (this.indexOf('select2-') !== 0) {
6051 
                            adapted = adapter(this);
6052 
 
6053 
                            if (adapted != null) {
6054 
                                replacements.push(adapted);
6055 
                            }
6056 
                        }
6057 
                    });
6058 
                }
6059 
 
6060 
                $dest.attr('class', replacements.join(' '));
6061 
            }
6062 
 
6063 
            return {
6064 
                syncCssClasses: syncCssClasses
6065 
            };
6066 
        });
6067 
 
6068 
        S2.define('select2/compat/containerCss',[
6069 
            'jquery',
6070 
            './utils'
6071 
        ], function ($, CompatUtils) {
6072 
            // No-op CSS adapter that discards all classes by default
6073 
            function _containerAdapter (clazz) {
6074 
                return null;
6075 
            }
6076 
 
6077 
            function ContainerCSS () { }
6078 
 
6079 
            ContainerCSS.prototype.render = function (decorated) {
6080 
                var $container = decorated.call(this);
6081 
 
6082 
                var containerCssClass = this.options.get('containerCssClass') || '';
6083 
 
6084 
                if ($.isFunction(containerCssClass)) {
6085 
                    containerCssClass = containerCssClass(this.$element);
6086 
                }
6087 
 
6088 
                var containerCssAdapter = this.options.get('adaptContainerCssClass');
6089 
                containerCssAdapter = containerCssAdapter || _containerAdapter;
6090 
 
6091 
                if (containerCssClass.indexOf(':all:') !== -1) {
6092 
                    containerCssClass = containerCssClass.replace(':all:', '');
6093 
 
6094 
                    var _cssAdapter = containerCssAdapter;
6095 
 
6096 
                    containerCssAdapter = function (clazz) {
6097 
                        var adapted = _cssAdapter(clazz);
6098 
 
6099 
                        if (adapted != null) {
6100 
                            // Append the old one along with the adapted one
6101 
                            return adapted + ' ' + clazz;
6102 
                        }
6103 
 
6104 
                        return clazz;
6105 
                    };
6106 
                }
6107 
 
6108 
                var containerCss = this.options.get('containerCss') || {};
6109 
 
6110 
                if ($.isFunction(containerCss)) {
6111 
                    containerCss = containerCss(this.$element);
6112 
                }
6113 
 
6114 
                CompatUtils.syncCssClasses($container, this.$element, containerCssAdapter);
6115 
 
6116 
                $container.css(containerCss);
6117 
                $container.addClass(containerCssClass);
6118 
 
6119 
                return $container;
6120 
            };
6121 
 
6122 
            return ContainerCSS;
6123 
        });
6124 
 
6125 
        S2.define('select2/compat/dropdownCss',[
6126 
            'jquery',
6127 
            './utils'
6128 
        ], function ($, CompatUtils) {
6129 
            // No-op CSS adapter that discards all classes by default
6130 
            function _dropdownAdapter (clazz) {
6131 
                return null;
6132 
            }
6133 
 
6134 
            function DropdownCSS () { }
6135 
 
6136 
            DropdownCSS.prototype.render = function (decorated) {
6137 
                var $dropdown = decorated.call(this);
6138 
 
6139 
                var dropdownCssClass = this.options.get('dropdownCssClass') || '';
6140 
 
6141 
                if ($.isFunction(dropdownCssClass)) {
6142 
                    dropdownCssClass = dropdownCssClass(this.$element);
6143 
                }
6144 
 
6145 
                var dropdownCssAdapter = this.options.get('adaptDropdownCssClass');
6146 
                dropdownCssAdapter = dropdownCssAdapter || _dropdownAdapter;
6147 
 
6148 
                if (dropdownCssClass.indexOf(':all:') !== -1) {
6149 
                    dropdownCssClass = dropdownCssClass.replace(':all:', '');
6150 
 
6151 
                    var _cssAdapter = dropdownCssAdapter;
6152 
 
6153 
                    dropdownCssAdapter = function (clazz) {
6154 
                        var adapted = _cssAdapter(clazz);
6155 
 
6156 
                        if (adapted != null) {
6157 
                            // Append the old one along with the adapted one
6158 
                            return adapted + ' ' + clazz;
6159 
                        }
6160 
 
6161 
                        return clazz;
6162 
                    };
6163 
                }
6164 
 
6165 
                var dropdownCss = this.options.get('dropdownCss') || {};
6166 
 
6167 
                if ($.isFunction(dropdownCss)) {
6168 
                    dropdownCss = dropdownCss(this.$element);
6169 
                }
6170 
 
6171 
                CompatUtils.syncCssClasses($dropdown, this.$element, dropdownCssAdapter);
6172 
 
6173 
                $dropdown.css(dropdownCss);
6174 
                $dropdown.addClass(dropdownCssClass);
6175 
 
6176 
                return $dropdown;
6177 
            };
6178 
 
6179 
            return DropdownCSS;
6180 
        });
6181 
 
6182 
        S2.define('select2/compat/initSelection',[
6183 
            'jquery'
6184 
        ], function ($) {
6185 
            function InitSelection (decorated, $element, options) {
6186 
                if (options.get('debug') && window.console && console.warn) {
6187 
                    console.warn(
6188 
                        'Select2: The `initSelection` option has been deprecated in favor' +
6189 
                        ' of a custom data adapter that overrides the `current` method. ' +
6190 
                        'This method is now called multiple times instead of a single ' +
6191 
                        'time when the instance is initialized. Support will be removed ' +
6192 
                        'for the `initSelection` option in future versions of Select2'
6193 
                    );
6194 
                }
6195 
 
6196 
                this.initSelection = options.get('initSelection');
6197 
                this._isInitialized = false;
6198 
 
6199 
                decorated.call(this, $element, options);
6200 
            }
6201 
 
6202 
            InitSelection.prototype.current = function (decorated, callback) {
6203 
                var self = this;
6204 
 
6205 
                if (this._isInitialized) {
6206 
                    decorated.call(this, callback);
6207 
 
6208 
                    return;
6209 
                }
6210 
 
6211 
                this.initSelection.call(null, this.$element, function (data) {
6212 
                    self._isInitialized = true;
6213 
 
6214 
                    if (!$.isArray(data)) {
6215 
                        data = [data];
6216 
                    }
6217 
 
6218 
                    callback(data);
6219 
                });
6220 
            };
6221 
 
6222 
            return InitSelection;
6223 
        });
6224 
 
6225 
        S2.define('select2/compat/inputData',[
6226 
            'jquery',
6227 
            '../utils'
6228 
        ], function ($, Utils) {
6229 
            function InputData (decorated, $element, options) {
6230 
                this._currentData = [];
6231 
                this._valueSeparator = options.get('valueSeparator') || ',';
6232 
 
6233 
                if ($element.prop('type') === 'hidden') {
6234 
                    if (options.get('debug') && console && console.warn) {
6235 
                        console.warn(
6236 
                            'Select2: Using a hidden input with Select2 is no longer ' +
6237 
                            'supported and may stop working in the future. It is recommended ' +
6238 
                            'to use a `<select>` element instead.'
6239 
                        );
6240 
                    }
6241 
                }
6242 
 
6243 
                decorated.call(this, $element, options);
6244 
            }
6245 
 
6246 
            InputData.prototype.current = function (_, callback) {
6247 
                function getSelected (data, selectedIds) {
6248 
                    var selected = [];
6249 
 
6250 
                    if (data.selected || $.inArray(data.id, selectedIds) !== -1) {
6251 
                        data.selected = true;
6252 
                        selected.push(data);
6253 
                    } else {
6254 
                        data.selected = false;
6255 
                    }
6256 
 
6257 
                    if (data.children) {
6258 
                        selected.push.apply(selected, getSelected(data.children, selectedIds));
6259 
                    }
6260 
 
6261 
                    return selected;
6262 
                }
6263 
 
6264 
                var selected = [];
6265 
 
6266 
                for (var d = 0; d < this._currentData.length; d++) {
6267 
                    var data = this._currentData[d];
6268 
 
6269 
                    selected.push.apply(
6270 
                        selected,
6271 
                        getSelected(
6272 
                            data,
6273 
                            this.$element.val().split(
6274 
                                this._valueSeparator
6275 
                            )
6276 
                        )
6277 
                    );
6278 
                }
6279 
 
6280 
                callback(selected);
6281 
            };
6282 
 
6283 
            InputData.prototype.select = function (_, data) {
6284 
                if (!this.options.get('multiple')) {
6285 
                    this.current(function (allData) {
6286 
                        $.map(allData, function (data) {
6287 
                            data.selected = false;
6288 
                        });
6289 
                    });
6290 
 
6291 
                    this.$element.val(data.id);
6292 
                    this.$element.trigger('input').trigger('change');
6293 
                } else {
6294 
                    var value = this.$element.val();
6295 
                    value += this._valueSeparator + data.id;
6296 
 
6297 
                    this.$element.val(value);
6298 
                    this.$element.trigger('input').trigger('change');
6299 
                }
6300 
            };
6301 
 
6302 
            InputData.prototype.unselect = function (_, data) {
6303 
                var self = this;
6304 
 
6305 
                data.selected = false;
6306 
 
6307 
                this.current(function (allData) {
6308 
                    var values = [];
6309 
 
6310 
                    for (var d = 0; d < allData.length; d++) {
6311 
                        var item = allData[d];
6312 
 
6313 
                        if (data.id == item.id) {
6314 
                            continue;
6315 
                        }
6316 
 
6317 
                        values.push(item.id);
6318 
                    }
6319 
 
6320 
                    self.$element.val(values.join(self._valueSeparator));
6321 
                    self.$element.trigger('input').trigger('change');
6322 
                });
6323 
            };
6324 
 
6325 
            InputData.prototype.query = function (_, params, callback) {
6326 
                var results = [];
6327 
 
6328 
                for (var d = 0; d < this._currentData.length; d++) {
6329 
                    var data = this._currentData[d];
6330 
 
6331 
                    var matches = this.matches(params, data);
6332 
 
6333 
                    if (matches !== null) {
6334 
                        results.push(matches);
6335 
                    }
6336 
                }
6337 
 
6338 
                callback({
6339 
                    results: results
6340 
                });
6341 
            };
6342 
 
6343 
            InputData.prototype.addOptions = function (_, $options) {
6344 
                var options = $.map($options, function ($option) {
6345 
                    return Utils.GetData($option[0], 'data');
6346 
                });
6347 
 
6348 
                this._currentData.push.apply(this._currentData, options);
6349 
            };
6350 
 
6351 
            return InputData;
6352 
        });
6353 
 
6354 
        S2.define('select2/compat/matcher',[
6355 
            'jquery'
6356 
        ], function ($) {
6357 
            function oldMatcher (matcher) {
6358 
                function wrappedMatcher (params, data) {
6359 
                    var match = $.extend(true, {}, data);
6360 
 
6361 
                    if (params.term == null || $.trim(params.term) === '') {
6362 
                        return match;
6363 
                    }
6364 
 
6365 
                    if (data.children) {
6366 
                        for (var c = data.children.length - 1; c >= 0; c--) {
6367 
                            var child = data.children[c];
6368 
 
6369 
                            // Check if the child object matches
6370 
                            // The old matcher returned a boolean true or false
6371 
                            var doesMatch = matcher(params.term, child.text, child);
6372 
 
6373 
                            // If the child didn't match, pop it off
6374 
                            if (!doesMatch) {
6375 
                                match.children.splice(c, 1);
6376 
                            }
6377 
                        }
6378 
 
6379 
                        if (match.children.length > 0) {
6380 
                            return match;
6381 
                        }
6382 
                    }
6383 
 
6384 
                    if (matcher(params.term, data.text, data)) {
6385 
                        return match;
6386 
                    }
6387 
 
6388 
                    return null;
6389 
                }
6390 
 
6391 
                return wrappedMatcher;
6392 
            }
6393 
 
6394 
            return oldMatcher;
6395 
        });
6396 
 
6397 
        S2.define('select2/compat/query',[
6398 
 
6399 
        ], function () {
6400 
            function Query (decorated, $element, options) {
6401 
                if (options.get('debug') && window.console && console.warn) {
6402 
                    console.warn(
6403 
                        'Select2: The `query` option has been deprecated in favor of a ' +
6404 
                        'custom data adapter that overrides the `query` method. Support ' +
6405 
                        'will be removed for the `query` option in future versions of ' +
6406 
                        'Select2.'
6407 
                    );
6408 
                }
6409 
 
6410 
                decorated.call(this, $element, options);
6411 
            }
6412 
 
6413 
            Query.prototype.query = function (_, params, callback) {
6414 
                params.callback = callback;
6415 
 
6416 
                var query = this.options.get('query');
6417 
 
6418 
                query.call(null, params);
6419 
            };
6420 
 
6421 
            return Query;
6422 
        });
6423 
 
6424 
        S2.define('select2/dropdown/attachContainer',[
6425 
 
6426 
        ], function () {
6427 
            function AttachContainer (decorated, $element, options) {
6428 
                decorated.call(this, $element, options);
6429 
            }
6430 
 
6431 
            AttachContainer.prototype.position =
6432 
                function (decorated, $dropdown, $container) {
6433 
                    var $dropdownContainer = $container.find('.dropdown-wrapper');
6434 
                    $dropdownContainer.append($dropdown);
6435 
 
6436 
                    $dropdown.addClass('select2-dropdown--below');
6437 
                    $container.addClass('select2-container--below');
6438 
                };
6439 
 
6440 
            return AttachContainer;
6441 
        });
6442 
 
6443 
        S2.define('select2/dropdown/stopPropagation',[
6444 
 
6445 
        ], function () {
6446 
            function StopPropagation () { }
6447 
 
6448 
            StopPropagation.prototype.bind = function (decorated, container, $container) {
6449 
                decorated.call(this, container, $container);
6450 
 
6451 
                var stoppedEvents = [
6452 
                    'blur',
6453 
                    'change',
6454 
                    'click',
6455 
                    'dblclick',
6456 
                    'focus',
6457 
                    'focusin',
6458 
                    'focusout',
6459 
                    'input',
6460 
                    'keydown',
6461 
                    'keyup',
6462 
                    'keypress',
6463 
                    'mousedown',
6464 
                    'mouseenter',
6465 
                    'mouseleave',
6466 
                    'mousemove',
6467 
                    'mouseover',
6468 
                    'mouseup',
6469 
                    'search',
6470 
                    'touchend',
6471 
                    'touchstart'
6472 
                ];
6473 
 
6474 
                this.$dropdown.on(stoppedEvents.join(' '), function (evt) {
6475 
                    evt.stopPropagation();
6476 
                });
6477 
            };
6478 
 
6479 
            return StopPropagation;
6480 
        });
6481 
 
6482 
        S2.define('select2/selection/stopPropagation',[
6483 
 
6484 
        ], function () {
6485 
            function StopPropagation () { }
6486 
 
6487 
            StopPropagation.prototype.bind = function (decorated, container, $container) {
6488 
                decorated.call(this, container, $container);
6489 
 
6490 
                var stoppedEvents = [
6491 
                    'blur',
6492 
                    'change',
6493 
                    'click',
6494 
                    'dblclick',
6495 
                    'focus',
6496 
                    'focusin',
6497 
                    'focusout',
6498 
                    'input',
6499 
                    'keydown',
6500 
                    'keyup',
6501 
                    'keypress',
6502 
                    'mousedown',
6503 
                    'mouseenter',
6504 
                    'mouseleave',
6505 
                    'mousemove',
6506 
                    'mouseover',
6507 
                    'mouseup',
6508 
                    'search',
6509 
                    'touchend',
6510 
                    'touchstart'
6511 
                ];
6512 
 
6513 
                this.$selection.on(stoppedEvents.join(' '), function (evt) {
6514 
                    evt.stopPropagation();
6515 
                });
6516 
            };
6517 
 
6518 
            return StopPropagation;
6519 
        });
6520 
 
6521 
        /*!
6522 
 * jQuery Mousewheel 3.1.13
6523 
 *
6524 
 * Copyright jQuery Foundation and other contributors
6525 
 * Released under the MIT license
6526 
 * http://jquery.org/license
6527 
 */
6528 
 
6529 
        (function (factory) {
6530 
            if ( typeof S2.define === 'function' && S2.define.amd ) {
6531 
                // AMD. Register as an anonymous module.
6532 
                S2.define('jquery-mousewheel',['jquery'], factory);
6533 
            } else if (typeof exports === 'object') {
6534 
                // Node/CommonJS style for Browserify
6535 
                module.exports = factory;
6536 
            } else {
6537 
                // Browser globals
6538 
                factory(jQuery);
6539 
            }
6540 
        }(function ($) {
6541 
 
6542 
            var toFix  = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'],
6543 
                toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ?
6544 
                    ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'],
6545 
                slice  = Array.prototype.slice,
6546 
                nullLowestDeltaTimeout, lowestDelta;
6547 
 
6548 
            if ( $.event.fixHooks ) {
6549 
                for ( var i = toFix.length; i; ) {
6550 
                    $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
6551 
                }
6552 
            }
6553 
 
6554 
            var special = $.event.special.mousewheel = {
6555 
                version: '3.1.12',
6556 
 
6557 
                setup: function() {
6558 
                    if ( this.addEventListener ) {
6559 
                        for ( var i = toBind.length; i; ) {
6560 
                            this.addEventListener( toBind[--i], handler, false );
6561 
                        }
6562 
                    } else {
6563 
                        this.onmousewheel = handler;
6564 
                    }
6565 
                    // Store the line height and page height for this particular element
6566 
                    $.data(this, 'mousewheel-line-height', special.getLineHeight(this));
6567 
                    $.data(this, 'mousewheel-page-height', special.getPageHeight(this));
6568 
                },
6569 
 
6570 
                teardown: function() {
6571 
                    if ( this.removeEventListener ) {
6572 
                        for ( var i = toBind.length; i; ) {
6573 
                            this.removeEventListener( toBind[--i], handler, false );
6574 
                        }
6575 
                    } else {
6576 
                        this.onmousewheel = null;
6577 
                    }
6578 
                    // Clean up the data we added to the element
6579 
                    $.removeData(this, 'mousewheel-line-height');
6580 
                    $.removeData(this, 'mousewheel-page-height');
6581 
                },
6582 
 
6583 
                getLineHeight: function(elem) {
6584 
                    var $elem = $(elem),
6585 
                        $parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
6586 
                    if (!$parent.length) {
6587 
                        $parent = $('body');
6588 
                    }
6589 
                    return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16;
6590 
                },
6591 
 
6592 
                getPageHeight: function(elem) {
6593 
                    return $(elem).height();
6594 
                },
6595 
 
6596 
                settings: {
6597 
                    adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
6598 
                    normalizeOffset: true  // calls getBoundingClientRect for each event
6599 
                }
6600 
            };
6601 
 
6602 
            $.fn.extend({
6603 
                mousewheel: function(fn) {
6604 
                    return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
6605 
                },
6606 
 
6607 
                unmousewheel: function(fn) {
6608 
                    return this.unbind('mousewheel', fn);
6609 
                }
6610 
            });
6611 
 
6612 
 
6613 
            function handler(event) {
6614 
                var orgEvent   = event || window.event,
6615 
                    args       = slice.call(arguments, 1),
6616 
                    delta      = 0,
6617 
                    deltaX     = 0,
6618 
                    deltaY     = 0,
6619 
                    absDelta   = 0,
6620 
                    offsetX    = 0,
6621 
                    offsetY    = 0;
6622 
                event = $.event.fix(orgEvent);
6623 
                event.type = 'mousewheel';
6624 
 
6625 
                // Old school scrollwheel delta
6626 
                if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }
6627 
                if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }
6628 
                if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }
6629 
                if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
6630 
 
6631 
                // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
6632 
                if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
6633 
                    deltaX = deltaY * -1;
6634 
                    deltaY = 0;
6635 
                }
6636 
 
6637 
                // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
6638 
                delta = deltaY === 0 ? deltaX : deltaY;
6639 
 
6640 
                // New school wheel delta (wheel event)
6641 
                if ( 'deltaY' in orgEvent ) {
6642 
                    deltaY = orgEvent.deltaY * -1;
6643 
                    delta  = deltaY;
6644 
                }
6645 
                if ( 'deltaX' in orgEvent ) {
6646 
                    deltaX = orgEvent.deltaX;
6647 
                    if ( deltaY === 0 ) { delta  = deltaX * -1; }
6648 
                }
6649 
 
6650 
                // No change actually happened, no reason to go any further
6651 
                if ( deltaY === 0 && deltaX === 0 ) { return; }
6652 
 
6653 
                // Need to convert lines and pages to pixels if we aren't already in pixels
6654 
                // There are three delta modes:
6655 
                //   * deltaMode 0 is by pixels, nothing to do
6656 
                //   * deltaMode 1 is by lines
6657 
                //   * deltaMode 2 is by pages
6658 
                if ( orgEvent.deltaMode === 1 ) {
6659 
                    var lineHeight = $.data(this, 'mousewheel-line-height');
6660 
                    delta  *= lineHeight;
6661 
                    deltaY *= lineHeight;
6662 
                    deltaX *= lineHeight;
6663 
                } else if ( orgEvent.deltaMode === 2 ) {
6664 
                    var pageHeight = $.data(this, 'mousewheel-page-height');
6665 
                    delta  *= pageHeight;
6666 
                    deltaY *= pageHeight;
6667 
                    deltaX *= pageHeight;
6668 
                }
6669 
 
6670 
                // Store lowest absolute delta to normalize the delta values
6671 
                absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
6672 
 
6673 
                if ( !lowestDelta || absDelta < lowestDelta ) {
6674 
                    lowestDelta = absDelta;
6675 
 
6676 
                    // Adjust older deltas if necessary
6677 
                    if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
6678 
                        lowestDelta /= 40;
6679 
                    }
6680 
                }
6681 
 
6682 
                // Adjust older deltas if necessary
6683 
                if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
6684 
                    // Divide all the things by 40!
6685 
                    delta  /= 40;
6686 
                    deltaX /= 40;
6687 
                    deltaY /= 40;
6688 
                }
6689 
 
6690 
                // Get a whole, normalized value for the deltas
6691 
                delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);
6692 
                deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
6693 
                deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
6694 
 
6695 
                // Normalise offsetX and offsetY properties
6696 
                if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
6697 
                    var boundingRect = this.getBoundingClientRect();
6698 
                    offsetX = event.clientX - boundingRect.left;
6699 
                    offsetY = event.clientY - boundingRect.top;
6700 
                }
6701 
 
6702 
                // Add information to the event object
6703 
                event.deltaX = deltaX;
6704 
                event.deltaY = deltaY;
6705 
                event.deltaFactor = lowestDelta;
6706 
                event.offsetX = offsetX;
6707 
                event.offsetY = offsetY;
6708 
                // Go ahead and set deltaMode to 0 since we converted to pixels
6709 
                // Although this is a little odd since we overwrite the deltaX/Y
6710 
                // properties with normalized deltas.
6711 
                event.deltaMode = 0;
6712 
 
6713 
                // Add event and delta to the front of the arguments
6714 
                args.unshift(event, delta, deltaX, deltaY);
6715 
 
6716 
                // Clearout lowestDelta after sometime to better
6717 
                // handle multiple device types that give different
6718 
                // a different lowestDelta
6719 
                // Ex: trackpad = 3 and mouse wheel = 120
6720 
                if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
6721 
                nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
6722 
 
6723 
                return ($.event.dispatch || $.event.handle).apply(this, args);
6724 
            }
6725 
 
6726 
            function nullLowestDelta() {
6727 
                lowestDelta = null;
6728 
            }
6729 
 
6730 
            function shouldAdjustOldDeltas(orgEvent, absDelta) {
6731 
                // If this is an older event and the delta is divisable by 120,
6732 
                // then we are assuming that the browser is treating this as an
6733 
                // older mouse wheel event and that we should divide the deltas
6734 
                // by 40 to try and get a more usable deltaFactor.
6735 
                // Side note, this actually impacts the reported scroll distance
6736 
                // in older browsers and can cause scrolling to be slower than native.
6737 
                // Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
6738 
                return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
6739 
            }
6740 
 
6741 
        }));
6742 
 
6743 
        S2.define('jquery.select2',[
6744 
            'jquery',
6745 
            'jquery-mousewheel',
6746 
 
6747 
            './select2/core',
6748 
            './select2/defaults',
6749 
            './select2/utils'
6750 
        ], function ($, _, Select2, Defaults, Utils) {
6751 
            if ($.fn.select2 == null) {
6752 
                // All methods that should return the element
6753 
                var thisMethods = ['open', 'close', 'destroy'];
6754 
 
6755 
                $.fn.select2 = function (options) {
6756 
                    options = options || {};
6757 
 
6758 
                    if (typeof options === 'object') {
6759 
                        this.each(function () {
6760 
                            var instanceOptions = $.extend(true, {}, options);
6761 
 
6762 
                            var instance = new Select2($(this), instanceOptions);
6763 
                        });
6764 
 
6765 
                        return this;
6766 
                    } else if (typeof options === 'string') {
6767 
                        var ret;
6768 
                        var args = Array.prototype.slice.call(arguments, 1);
6769 
 
6770 
                        this.each(function () {
6771 
                            var instance = Utils.GetData(this, 'select2');
6772 
 
6773 
                            if (instance == null && window.console && console.error) {
6774 
                                console.error(
6775 
                                    'The select2(\'' + options + '\') method was called on an ' +
6776 
                                    'element that is not using Select2.'
6777 
                                );
6778 
                            }
6779 
 
6780 
                            ret = instance[options].apply(instance, args);
6781 
                        });
6782 
 
6783 
                        // Check if we should be returning `this`
6784 
                        if ($.inArray(options, thisMethods) > -1) {
6785 
                            return this;
6786 
                        }
6787 
 
6788 
                        return ret;
6789 
                    } else {
6790 
                        throw new Error('Invalid arguments for Select2: ' + options);
6791 
                    }
6792 
                };
6793 
            }
6794 
 
6795 
            if ($.fn.select2.defaults == null) {
6796 
                $.fn.select2.defaults = Defaults;
6797 
            }
6798 
 
6799 
            return Select2;
6800 
        });
6801 
 
6802 
        // Return the AMD loader configuration so it can be used outside of this file
6803 
        return {
6804 
            define: S2.define,
6805 
            require: S2.require
6806 
        };
6807 
    }());
6808 
 
6809 
    // Autoload the jQuery bindings
6810 
    // We know that all of the modules exist above this, so we're safe
6811 
    var select2 = S2.require('jquery.select2');
6812 
 
6813 
    // Hold the AMD module references on the jQuery function that was just loaded
6814 
    // This allows Select2 to use the internal loader outside of this file, such
6815 
    // as in the language files.
6816 
    jQuery.fn.select2.amd = S2;
6817 
 
6818 
    // Return the Select2 instance for anyone who is importing it.
6819 
    return select2;
6820 
}));