; 
(function (factory){ 
if (typeof define === 'function' && define.amd) { 
define(['jquery'] , factory); 
} 
 else if (typeof module === 'object' && module.exports) { 
module.exports = function (root, jQuery){ 
if (jQuery === undefined) { 
if (typeof window !== 'undefined') { 
jQuery = require('jquery'); 
} 
 else { 
jQuery = require('jquery')(root); 
} 
} 
factory(jQuery); 
return jQuery; 
} 
; 
} 
 else { 
factory(jQuery); 
} 
} 
(function (jQuery){ 
var S2 = (function (){ 
if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) { 
var S2 = jQuery.fn.select2.amd; 
} 
var S2; 
(function (){ 
if (!S2 || !S2.requirejs) { 
if (!S2) { 
S2 = { 
}
; 
} 
 else { 
require = S2; 
} 
var requirejs, require, define; 
(function (undef){ 
var main, req, makeMap, handlers, defined = { 
}
, waiting = { 
}
, config = { 
}
, defining = { 
}
, hasOwn = Object.prototype.hasOwnProperty, aps = [] .slice, jsSuffixRegExp = /\.js$/; 
function hasProp(obj, prop){ 
return hasOwn.call(obj, prop); 
} 
function normalize(name, baseName){ 
var nameParts, nameSegment, mapValue, foundMap, lastIndex, foundI, foundStarMap, starI, i, j, part, normalizedBaseParts, baseParts = baseName && baseName.split("/"), map = config.map, starMap = (map && map["*"] ) || { 
}
; 
if (name) { 
name = name.split('/'); 
lastIndex = _AN_Read_length('length', name) - 1; 
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) { 
name[lastIndex] = _AN_Call_replace('replace', name[lastIndex], jsSuffixRegExp, ''); 
} 
if (name[0].charAt(0) === '.' && baseParts) { 
normalizedBaseParts = baseParts.slice(0, _AN_Read_length('length', baseParts) - 1); 
name = normalizedBaseParts.concat(name); 
} 
for (i = 0; i < _AN_Read_length('length', name); i++ ){ 
part = name[i]; 
if (part === '.') { 
name.splice(i, 1); 
i -= 1; 
} 
 else if (part === '..') { 
if (i === 0 || (i === 1 && name[2] === '..') || name[i - 1] === '..') { 
continue ; 
} 
 else if (i > 0) { 
name.splice(i - 1, 2); 
i -= 2; 
} 
} 
} 
name = name.join('/'); 
} 
if ((baseParts || starMap) && map) { 
nameParts = name.split('/'); 
for (i = _AN_Read_length('length', nameParts); i > 0; i -= 1){ 
nameSegment = nameParts.slice(0, i).join("/"); 
if (baseParts) { 
for (j = _AN_Read_length("length", baseParts); j > 0; j -= 1){ 
mapValue = map[baseParts.slice(0, j).join('/')]; 
if (mapValue) { 
mapValue = mapValue[nameSegment]; 
if (mapValue) { 
foundMap = mapValue; 
foundI = i; 
break ; 
} 
} 
} 
} 
if (foundMap) { 
break ; 
} 
if (!foundStarMap && starMap && starMap[nameSegment]) { 
foundStarMap = starMap[nameSegment]; 
starI = i; 
} 
} 
if (!foundMap && foundStarMap) { 
foundMap = foundStarMap; 
foundI = starI; 
} 
if (foundMap) { 
nameParts.splice(0, foundI, foundMap); 
name = nameParts.join('/'); 
} 
} 
return name; 
} 
function makeRequire(relName, forceSync){ 
return function (){ 
var args = aps.call(arguments, 0); 
if (typeof args[0] !== 'string' && _AN_Read_length('length', args) === 1) { 
args.push(null ); 
} 
return req.apply(undef, args.concat([relName, forceSync] )); 
} 
; 
} 
function makeNormalize(relName){ 
return function (name){ 
return normalize(name, relName); 
} 
; 
} 
function makeLoad(depName){ 
return function (value){ 
defined[depName] = value; 
} 
; 
} 
function callDep(name){ 
if (hasProp(waiting, name)) { 
var args = waiting[name]; 
delete waiting[name]; 
defining[name] = true ; 
main.apply(undef, args); 
} 
if (!hasProp(defined, name) && !hasProp(defining, name)) { 
throw new Error('No ' + name)
} 
return defined[name]; 
} 
function splitPrefix(name){ 
var prefix, index = name? name.indexOf('!'): -1; 
if (index > -1) { 
prefix = name.substring(0, index); 
name = name.substring(index + 1, _AN_Read_length('length', name)); 
} 
return [prefix, name] ; 
} 
function makeRelParts(relName){ 
return relName? splitPrefix(relName): [] ; 
} 
makeMap = function (name, relParts){ 
var plugin, parts = splitPrefix(name), prefix = parts[0], relResourceName = relParts[1]; 
name = parts[1]; 
if (prefix) { 
prefix = normalize(prefix, relResourceName); 
plugin = callDep(prefix); 
} 
if (prefix) { 
if (plugin && plugin.normalize) { 
name = plugin.normalize(name, makeNormalize(relResourceName)); 
} 
 else { 
name = normalize(name, relResourceName); 
} 
} 
 else { 
name = normalize(name, relResourceName); 
parts = splitPrefix(name); 
prefix = parts[0]; 
name = parts[1]; 
if (prefix) { 
plugin = callDep(prefix); 
} 
} 
return { 
f: prefix? prefix + '!' + name: name,
n: name,
pr: prefix,
p: plugin}
; 
} 
; 
function makeConfig(name){ 
return function (){ 
return (config && config.config && config.config[name]) || { 
}
; 
} 
; 
} 
handlers = { 
require: function (name){ 
return makeRequire(name); 
} 
,
exports: function (name){ 
var e = defined[name]; 
if (typeof e !== 'undefined') { 
return e; 
} 
 else { 
return (defined[name] = { 
}
); 
} 
} 
,
module: function (name){ 
return { 
id: name,
uri: '',
exports: defined[name],
config: makeConfig(name)}
; 
} 
}
; 
main = function (name, deps, callback, relName){ 
var cjsModule, depName, ret, map, i, relParts, args = [] , callbackType = typeof callback, usingExports; 
relName = relName || name; 
relParts = makeRelParts(relName); 
if (callbackType === 'undefined' || callbackType === 'function') { 
deps = !_AN_Read_length('length', deps) && _AN_Read_length('length', callback)? ['require', 'exports', 'module'] : deps; 
for (i = 0; i < _AN_Read_length('length', deps); i += 1){ 
map = makeMap(deps[i], relParts); 
depName = map.f; 
if (depName === "require") { 
args[i] = handlers.require(name); 
} 
 else if (depName === "exports") { 
args[i] = handlers.exports(name); 
usingExports = true ; 
} 
 else if (depName === "module") { 
cjsModule = args[i] = handlers.module(name); 
} 
 else if (hasProp(defined, depName) || hasProp(waiting, depName) || hasProp(defining, depName)) { 
args[i] = callDep(depName); 
} 
 else if (map.p) { 
_AN_Call_load("load", map.p, map.n, makeRequire(relName, true ), makeLoad(depName), { 
}
); 
args[i] = defined[depName]; 
} 
 else { 
throw new Error(name + ' missing ' + depName)
} 
} 
ret = callback? callback.apply(defined[name], args): undefined; 
if (name) { 
if (cjsModule && cjsModule.exports !== undef && cjsModule.exports !== defined[name]) { 
defined[name] = cjsModule.exports; 
} 
 else if (ret !== undef || !usingExports) { 
defined[name] = ret; 
} 
} 
} 
 else if (name) { 
defined[name] = callback; 
} 
} 
; 
requirejs = require = req = function (deps, callback, relName, forceSync, alt){ 
if (typeof deps === "string") { 
if (handlers[deps]) { 
return handlers[deps](callback); 
} 
return callDep(makeMap(deps, makeRelParts(callback)).f); 
} 
 else if (!deps.splice) { 
config = deps; 
if (config.deps) { 
req(config.deps, config.callback); 
} 
if (!callback) { 
return ; 
} 
if (callback.splice) { 
deps = callback; 
callback = relName; 
relName = null ; 
} 
 else { 
deps = undef; 
} 
} 
callback = callback || function (){ 
} 
; 
if (typeof relName === 'function') { 
relName = forceSync; 
forceSync = alt; 
} 
if (forceSync) { 
main(undef, deps, callback, relName); 
} 
 else { 
_AN_Call_settimeout('setTimeout', window, function (){ 
main(undef, deps, callback, relName); 
} 
, 4); 
} 
return req; 
} 
; 
req.config = function (cfg){ 
return req(cfg); 
} 
; 
requirejs._defined = defined; 
define = function (name, deps, callback){ 
if (typeof name !== 'string') { 
throw new Error('See almond README: incorrect module build, no module name')
} 
if (!deps.splice) { 
callback = deps; 
deps = [] ; 
} 
if (!hasProp(defined, name) && !hasProp(waiting, name)) { 
waiting[name] = [name, deps, callback] ; 
} 
} 
; 
define.amd = { 
jQuery: true }
; 
} 
()); 
S2.requirejs = requirejs; 
S2.require = require; 
S2.define = define; 
} 
} 
()); 
S2.define("almond", function (){ 
} 
); 
S2.define('jquery', [] , function (){ 
var _$ = jQuery || $; 
if (_$ == null  && console && console.error) { 
console.error('Select2: An instance of jQuery or a jQuery-compatible library was not ' + 'found. Make sure that you are including jQuery before Select2 on your ' + 'web page.'); 
} 
return _$; 
} 
); 
S2.define('select2/utils', ['jquery'] , function ($){ 
var Utils = { 
}
; 
Utils.Extend = function (ChildClass, SuperClass){ 
var __hasProp = { 
}
.hasOwnProperty; 
function BaseConstructor(){ 
this.constructor = ChildClass; 
} 
for (var key in SuperClass){ 
if (__hasProp.call(SuperClass, key)) { 
ChildClass[key] = SuperClass[key]; 
} 
} 
BaseConstructor.prototype = SuperClass.prototype; 
ChildClass.prototype = new BaseConstructor(); 
ChildClass.__super__ = SuperClass.prototype; 
return ChildClass; 
} 
; 
function getMethods(theClass){ 
var proto = theClass.prototype; 
var methods = [] ; 
for (var methodName in proto){ 
var m = proto[methodName]; 
if (typeof m !== 'function') { 
continue ; 
} 
if (methodName === 'constructor') { 
continue ; 
} 
methods.push(methodName); 
} 
return methods; 
} 
Utils.Decorate = function (SuperClass, DecoratorClass){ 
var decoratedMethods = getMethods(DecoratorClass); 
var superMethods = getMethods(SuperClass); 
function DecoratedClass(){ 
var unshift = Array.prototype.unshift; 
var argCount = _AN_Read_length('length', DecoratorClass.prototype.constructor); 
var calledConstructor = SuperClass.prototype.constructor; 
if (argCount > 0) { 
unshift.call(arguments, SuperClass.prototype.constructor); 
calledConstructor = DecoratorClass.prototype.constructor; 
} 
calledConstructor.apply(this, arguments); 
} 
DecoratorClass.displayName = SuperClass.displayName; 
function ctr(){ 
this.constructor = DecoratedClass; 
} 
DecoratedClass.prototype = new ctr(); 
for (var m = 0; 
m < _AN_Read_length('length', superMethods); m++ ){ 
var superMethod = superMethods[m]; 
DecoratedClass.prototype[superMethod] = SuperClass.prototype[superMethod]; 
} 
var calledMethod = function (methodName){ 
var originalMethod = function (){ 
} 
; 
if (methodName in DecoratedClass.prototype) { 
originalMethod = DecoratedClass.prototype[methodName]; 
} 
var decoratedMethod = DecoratorClass.prototype[methodName]; 
return function (){ 
var unshift = Array.prototype.unshift; 
unshift.call(arguments, originalMethod); 
return decoratedMethod.apply(this, arguments); 
} 
; 
} 
; 
for (var d = 0; 
d < _AN_Read_length('length', decoratedMethods); d++ ){ 
var decoratedMethod = decoratedMethods[d]; 
DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod); 
} 
return DecoratedClass; 
} 
; 
var Observable = function (){ 
this.listeners = { 
}
; 
} 
; 
Observable.prototype.on = function (event, callback){ 
this.listeners = this.listeners || { 
}
; 
if (event in this.listeners) { 
this.listeners[event].push(callback); 
} 
 else { 
this.listeners[event] = [callback] ; 
} 
} 
; 
Observable.prototype.trigger = function (event){ 
var slice = Array.prototype.slice; 
var params = slice.call(arguments, 1); 
this.listeners = this.listeners || { 
}
; 
if (params == null ) { 
params = [] ; 
} 
if (_AN_Read_length('length', params) === 0) { 
params.push({ 
}
); 
} 
params[0]._type = event; 
if (event in this.listeners) { 
this.invoke(this.listeners[event], slice.call(arguments, 1)); 
} 
if ('*' in this.listeners) { 
this.invoke(this.listeners["*"] , arguments); 
} 
} 
; 
Observable.prototype.invoke = function (listeners, params){ 
for (var i = 0, len = _AN_Read_length('length', listeners); 
i < len; i++ ){ 
listeners[i].apply(this, params); 
} 
} 
; 
Utils.Observable = Observable; 
Utils.generateChars = function (length){ 
var chars = ''; 
for (var i = 0; 
i < length; i++ ){ 
var randomChar = Math.floor(Math.random() * 36); 
chars += randomChar.toString(36); 
} 
return chars; 
} 
; 
Utils.bind = function (func, context){ 
return function (){ 
func.apply(context, arguments); 
} 
; 
} 
; 
Utils._convertData = function (data){ 
for (var originalKey in data){ 
var keys = originalKey.split('-'); 
var dataLevel = data; 
if (_AN_Read_length('length', keys) === 1) { 
continue ; 
} 
for (var k = 0; 
k < _AN_Read_length('length', keys); k++ ){ 
var key = keys[k]; 
key = key.substring(0, 1).toLowerCase() + key.substring(1); 
if (!(key in dataLevel)) { 
dataLevel[key] = { 
}
; 
} 
if (k == _AN_Read_length('length', keys) - 1) { 
dataLevel[key] = data[originalKey]; 
} 
dataLevel = dataLevel[key]; 
} 
delete data[originalKey]; 
} 
return data; 
} 
; 
Utils.hasScroll = function (index, el){ 
var $el = $(el); 
var overflowX = el.style.overflowX; 
var overflowY = el.style.overflowY; 
if (overflowX === overflowY && (overflowY === 'hidden' || overflowY === 'visible')) { 
return false ; 
} 
if (overflowX === 'scroll' || overflowY === 'scroll') { 
return true ; 
} 
return ($el.innerHeight() < el.scrollHeight || $el.innerWidth() < el.scrollWidth); 
} 
; 
Utils.escapeMarkup = function (markup){ 
var replaceMap = { 
'\\': '&#92;',
'&': '&amp;',
'<': '&lt;',
'>': '&gt;',
'"': '&quot;',
'\'': '&#39;',
'/': '&#47;'}
; 
if (typeof markup !== 'string') { 
return markup; 
} 
return _AN_Call_replace('replace', String(markup), /[&<>"'\/\\]/g, function (match){ 
return replaceMap[match]; 
} 
); 
} 
; 
Utils.__cache = { 
}
; 
var id = 0; 
Utils.GetUniqueElementId = function (element){ 
var select2Id = _AN_Call_getattribute('getAttribute', element, 'data-select2-id'); 
if (select2Id != null ) { 
return select2Id; 
} 
if (element.id) { 
select2Id = 'select2-data-' + element.id; 
} 
 else { 
select2Id = 'select2-data-' + (++id).toString() + '-' + Utils.generateChars(4); 
} 
_AN_Call_setattribute('setAttribute', element, 'data-select2-id', select2Id); 
return select2Id; 
} 
; 
Utils.StoreData = function (element, name, value){ 
var id = Utils.GetUniqueElementId(element); 
if (!Utils.__cache[id]) { 
Utils.__cache[id] = { 
}
; 
} 
Utils.__cache[id][name] = value; 
} 
; 
Utils.GetData = function (element, name){ 
var id = Utils.GetUniqueElementId(element); 
if (name) { 
if (Utils.__cache[id]) { 
if (Utils.__cache[id][name] != null ) { 
return Utils.__cache[id][name]; 
} 
return $(element).data(name); 
} 
return $(element).data(name); 
} 
 else { 
return Utils.__cache[id]; 
} 
} 
; 
Utils.RemoveData = function (element){ 
var id = Utils.GetUniqueElementId(element); 
if (Utils.__cache[id] != null ) { 
delete Utils.__cache[id]; 
} 
element.removeAttribute('data-select2-id'); 
} 
; 
Utils.copyNonInternalCssClasses = function (dest, src){ 
var classes; 
var destinationClasses = _AN_Call_getattribute('getAttribute', dest, 'class').trim().split(/\s+/); 
destinationClasses = destinationClasses.filter(function (clazz){ 
return clazz.indexOf('select2-') === 0; 
} 
); 
var sourceClasses = _AN_Call_getattribute('getAttribute', src, 'class').trim().split(/\s+/); 
sourceClasses = sourceClasses.filter(function (clazz){ 
return clazz.indexOf('select2-') !== 0; 
} 
); 
var replacements = destinationClasses.concat(sourceClasses); 
_AN_Call_setattribute('setAttribute', dest, 'class', replacements.join(' ')); 
} 
; 
return Utils; 
} 
); 
S2.define('select2/results', ['jquery', './utils'] , function ($, Utils){ 
function Results($element, options, dataAdapter){ 
this.$element = $element; 
this.data = dataAdapter; 
this.options = options; 
Results.__super__.constructor.call(this); 
} 
Utils.Extend(Results, Utils.Observable); 
Results.prototype.render = function (){ 
var $results = $('<ul class="select2-results__options" role="listbox"></ul>'); 
if (this.options.get('multiple')) { 
$results.attr('aria-multiselectable', 'true'); 
} 
this.$results = $results; 
return $results; 
} 
; 
Results.prototype.clear = function (){ 
this.$results.empty(); 
} 
; 
Results.prototype.displayMessage = function (params){ 
var escapeMarkup = this.options.get('escapeMarkup'); 
_AN_Call_clear('clear', this); 
this.hideLoading(); 
var $message = $('<li role="alert" aria-live="assertive"' + ' class="select2-results__option"></li>'); 
var message = this.options.get('translations').get(params.message); 
$message.append(escapeMarkup(message(params.args))); 
$message[0].className += ' select2-results__message'; 
this.$results.append($message); 
} 
; 
Results.prototype.hideMessages = function (){ 
this.$results.find('.select2-results__message').remove(); 
} 
; 
Results.prototype.append = function (data){ 
this.hideLoading(); 
var $options = [] ; 
if (data.results == null  || _AN_Read_length('length', data.results) === 0) { 
if (_AN_Read_length('length', this.$results.children()) === 0) { 
this.trigger('results:message', { 
message: 'noResults'}
); 
} 
return ; 
} 
data.results = this.sort(data.results); 
for (var d = 0; 
d < _AN_Read_length('length', data.results); d++ ){ 
var item = data.results[d]; 
var $option = this.option(item); 
$options.push($option); 
} 
this.$results.append($options); 
} 
; 
Results.prototype.position = function ($results, $dropdown){ 
var $resultsContainer = $dropdown.find('.select2-results'); 
$resultsContainer.append($results); 
} 
; 
Results.prototype.sort = function (data){ 
var sorter = this.options.get('sorter'); 
return sorter(data); 
} 
; 
Results.prototype.highlightFirstItem = function (){ 
var $options = this.$results.find('.select2-results__option--selectable'); 
var $selected = $options.filter('.select2-results__option--selected'); 
if (_AN_Read_length('length', $selected) > 0) { 
$selected.first().trigger('mouseenter'); 
} 
 else { 
$options.first().trigger('mouseenter'); 
} 
this.ensureHighlightVisible(); 
} 
; 
Results.prototype.setClasses = function (){ 
var self = this; 
this.data.current(function (selected){ 
var selectedIds = selected.map(function (s){ 
return s.id.toString(); 
} 
); 
var $options = self.$results.find('.select2-results__option--selectable'); 
$options.each(function (){ 
var $option = $(this); 
var item = Utils.GetData(this, 'data'); 
var id = '' + item.id; 
if ((item.element != null  && item.element.selected) || (item.element == null  && selectedIds.indexOf(id) > -1)) { 
this.classList.add('select2-results__option--selected'); 
$option.attr('aria-selected', 'true'); 
} 
 else { 
this.classList.remove('select2-results__option--selected'); 
$option.attr('aria-selected', 'false'); 
} 
} 
); 
} 
); 
} 
; 
Results.prototype.showLoading = function (params){ 
this.hideLoading(); 
var loadingMore = this.options.get('translations').get('searching'); 
var loading = { 
disabled: true ,
loading: true ,
text: loadingMore(params)}
; 
var $loading = this.option(loading); 
$loading.className += ' loading-results'; 
this.$results.prepend($loading); 
} 
; 
Results.prototype.hideLoading = function (){ 
this.$results.find('.loading-results').remove(); 
} 
; 
Results.prototype.option = function (data){ 
var option = _AN_Call_createelement('createElement', document, 'li'); 
option.classList.add('select2-results__option'); 
option.classList.add('select2-results__option--selectable'); 
var attrs = { 
'role': 'option'}
; 
var matches = window.Element.prototype.matches || window.Element.prototype.msMatchesSelector || window.Element.prototype.webkitMatchesSelector; 
if ((data.element != null  && matches.call(data.element, ':disabled')) || (data.element == null  && data.disabled)) { 
attrs["aria-disabled"]  = 'true'; 
option.classList.remove('select2-results__option--selectable'); 
option.classList.add('select2-results__option--disabled'); 
} 
if (data.id == null ) { 
option.classList.remove('select2-results__option--selectable'); 
} 
if (data._resultId != null ) { 
option.id = data._resultId; 
} 
if (data.title) { 
option.title = data.title; 
} 
if (data.children) { 
attrs.role = 'group'; 
attrs["aria-label"]  = data.text; 
option.classList.remove('select2-results__option--selectable'); 
option.classList.add('select2-results__option--group'); 
} 
for (var attr in attrs){ 
var val = attrs[attr]; 
_AN_Call_setattribute('setAttribute', option, attr, val); 
} 
if (data.children) { 
var $option = $(option); 
var label = _AN_Call_createelement('createElement', document, 'strong'); 
label.className = 'select2-results__group'; 
this.template(data, label); 
var $children = [] ; 
for (var c = 0; 
c < _AN_Read_length('length', data.children); c++ ){ 
var child = data.children[c]; 
var $child = this.option(child); 
$children.push($child); 
} 
var $childrenContainer = $('<ul></ul>', { 
'class': 'select2-results__options select2-results__options--nested',
'role': 'none'}
); 
$childrenContainer.append($children); 
$option.append(label); 
$option.append($childrenContainer); 
} 
 else { 
this.template(data, option); 
} 
Utils.StoreData(option, 'data', data); 
return option; 
} 
; 
Results.prototype.bind = function (container, $container){ 
var self = this; 
var id = container.id + '-results'; 
this.$results.attr('id', id); 
container.on('results:all', function (params){ 
_AN_Call_clear('clear', self); 
self.append(params.data); 
if (container.isOpen()) { 
self.setClasses(); 
self.highlightFirstItem(); 
} 
} 
); 
container.on('results:append', function (params){ 
self.append(params.data); 
if (container.isOpen()) { 
self.setClasses(); 
} 
} 
); 
container.on('query', function (params){ 
self.hideMessages(); 
self.showLoading(params); 
} 
); 
container.on('select', function (){ 
if (!container.isOpen()) { 
return ; 
} 
self.setClasses(); 
if (self.options.get('scrollAfterSelect')) { 
self.highlightFirstItem(); 
} 
} 
); 
container.on('unselect', function (){ 
if (!container.isOpen()) { 
return ; 
} 
self.setClasses(); 
if (self.options.get('scrollAfterSelect')) { 
self.highlightFirstItem(); 
} 
} 
); 
container.on('open', function (){ 
self.$results.attr('aria-expanded', 'true'); 
self.$results.attr('aria-hidden', 'false'); 
self.setClasses(); 
self.ensureHighlightVisible(); 
} 
); 
container.on('close', function (){ 
self.$results.attr('aria-expanded', 'false'); 
self.$results.attr('aria-hidden', 'true'); 
self.$results.removeAttr('aria-activedescendant'); 
} 
); 
container.on('results:toggle', function (){ 
var $highlighted = self.getHighlightedResults(); 
if (_AN_Read_length('length', $highlighted) === 0) { 
return ; 
} 
$highlighted.trigger('mouseup'); 
} 
); 
container.on('results:select', function (){ 
var $highlighted = self.getHighlightedResults(); 
if (_AN_Read_length('length', $highlighted) === 0) { 
return ; 
} 
var data = Utils.GetData($highlighted[0], 'data'); 
if ($highlighted.hasClass('select2-results__option--selected')) { 
self.trigger('close', { 
}
); 
} 
 else { 
self.trigger('select', { 
data: data}
); 
} 
} 
); 
container.on('results:previous', function (){ 
var $highlighted = self.getHighlightedResults(); 
var $options = self.$results.find('.select2-results__option--selectable'); 
var currentIndex = $options.index($highlighted); 
if (currentIndex <= 0) { 
return ; 
} 
var nextIndex = currentIndex - 1; 
if (_AN_Read_length('length', $highlighted) === 0) { 
nextIndex = 0; 
} 
var $next = $options.eq(nextIndex); 
$next.trigger('mouseenter'); 
var currentOffset = self.$results.offset().top; 
var nextTop = $next.offset().top; 
var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset); 
if (nextIndex === 0) { 
self.$results.scrollTop(0); 
} 
 else if (nextTop - currentOffset < 0) { 
self.$results.scrollTop(nextOffset); 
} 
} 
); 
container.on('results:next', function (){ 
var $highlighted = self.getHighlightedResults(); 
var $options = self.$results.find('.select2-results__option--selectable'); 
var currentIndex = $options.index($highlighted); 
var nextIndex = currentIndex + 1; 
if (nextIndex >= _AN_Read_length('length', $options)) { 
return ; 
} 
var $next = $options.eq(nextIndex); 
$next.trigger('mouseenter'); 
var currentOffset = self.$results.offset().top + self.$results.outerHeight(false ); 
var nextBottom = $next.offset().top + $next.outerHeight(false ); 
var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset; 
if (nextIndex === 0) { 
self.$results.scrollTop(0); 
} 
 else if (nextBottom > currentOffset) { 
self.$results.scrollTop(nextOffset); 
} 
} 
); 
container.on('results:focus', function (params){ 
params.element[0].classList.add('select2-results__option--highlighted'); 
_AN_Call_setattribute('setAttribute', params.element[0], 'aria-selected', 'true'); 
} 
); 
container.on('results:message', function (params){ 
self.displayMessage(params); 
} 
); 
if ($.fn.mousewheel) { 
this.$results.on('mousewheel', function (e){ 
var top = self.$results.scrollTop(); 
var bottom = self.$results.get(0).scrollHeight - top + e.deltaY; 
var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0; 
var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height(); 
if (isAtTop) { 
self.$results.scrollTop(0); 
e.preventDefault(); 
e.stopPropagation(); 
} 
 else if (isAtBottom) { 
self.$results.scrollTop(self.$results.get(0).scrollHeight - self.$results.height()); 
e.preventDefault(); 
e.stopPropagation(); 
} 
} 
); 
} 
this.$results.on('mouseup', '.select2-results__option--selectable', function (evt){ 
var $this = $(this); 
var data = Utils.GetData(this, 'data'); 
if ($this.hasClass('select2-results__option--selected')) { 
if (self.options.get('multiple')) { 
self.trigger('unselect', { 
originalEvent: evt,
data: data}
); 
} 
 else { 
self.trigger('close', { 
}
); 
} 
return ; 
} 
self.trigger('select', { 
originalEvent: evt,
data: data}
); 
} 
); 
this.$results.on('mouseenter', '.select2-results__option--selectable', function (evt){ 
var data = Utils.GetData(this, 'data'); 
self.getHighlightedResults().removeClass('select2-results__option--highlighted').attr('aria-selected', 'false'); 
self.trigger('results:focus', { 
data: data,
element: $(this)}
); 
} 
); 
} 
; 
Results.prototype.getHighlightedResults = function (){ 
var $highlighted = this.$results.find('.select2-results__option--highlighted'); 
return $highlighted; 
} 
; 
Results.prototype.destroy = function (){ 
this.$results.remove(); 
} 
; 
Results.prototype.ensureHighlightVisible = function (){ 
var $highlighted = this.getHighlightedResults(); 
if (_AN_Read_length('length', $highlighted) === 0) { 
return ; 
} 
var $options = this.$results.find('.select2-results__option--selectable'); 
var currentIndex = $options.index($highlighted); 
var currentOffset = this.$results.offset().top; 
var nextTop = $highlighted.offset().top; 
var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset); 
var offsetDelta = nextTop - currentOffset; 
nextOffset -= $highlighted.outerHeight(false ) * 2; 
if (currentIndex <= 2) { 
this.$results.scrollTop(0); 
} 
 else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) { 
this.$results.scrollTop(nextOffset); 
} 
} 
; 
Results.prototype.template = function (result, container){ 
var template = this.options.get('templateResult'); 
var escapeMarkup = this.options.get('escapeMarkup'); 
var content = template(result, container); 
if (content == null ) { 
container.style.display = 'none'; 
} 
 else if (typeof content === 'string') { 
_AN_Write_innerhtml('innerHTML', container, false , escapeMarkup(content)); 
} 
 else { 
$(container).append(content); 
} 
} 
; 
return Results; 
} 
); 
S2.define('select2/keys', [] , function (){ 
var KEYS = { 
BACKSPACE: 8,
TAB: 9,
ENTER: 13,
SHIFT: 16,
CTRL: 17,
ALT: 18,
ESC: 27,
SPACE: 32,
PAGE_UP: 33,
PAGE_DOWN: 34,
END: 35,
HOME: 36,
LEFT: 37,
UP: 38,
RIGHT: 39,
DOWN: 40,
DELETE: 46}
; 
return KEYS; 
} 
); 
S2.define('select2/selection/base', ['jquery', '../utils', '../keys'] , function ($, Utils, KEYS){ 
function BaseSelection($element, options){ 
this.$element = $element; 
this.options = options; 
BaseSelection.__super__.constructor.call(this); 
} 
Utils.Extend(BaseSelection, Utils.Observable); 
BaseSelection.prototype.render = function (){ 
var $selection = $('<span class="select2-selection" role="combobox" ' + ' aria-haspopup="true" aria-expanded="false">' + '</span>'); 
this._tabindex = 0; 
if (Utils.GetData(this.$element[0], 'old-tabindex') != null ) { 
this._tabindex = Utils.GetData(this.$element[0], 'old-tabindex'); 
} 
 else if (this.$element.attr('tabindex') != null ) { 
this._tabindex = this.$element.attr('tabindex'); 
} 
$selection.attr('title', this.$element.attr('title')); 
$selection.attr('tabindex', this._tabindex); 
$selection.attr('aria-disabled', 'false'); 
this.$selection = $selection; 
return $selection; 
} 
; 
BaseSelection.prototype.bind = function (container, $container){ 
var self = this; 
var resultsId = container.id + '-results'; 
this.container = container; 
this.$selection.on('focus', function (evt){ 
self.trigger('focus', evt); 
} 
); 
this.$selection.on('blur', function (evt){ 
self._handleBlur(evt); 
} 
); 
this.$selection.on('keydown', function (evt){ 
self.trigger('keypress', evt); 
if (evt.which === KEYS.SPACE) { 
evt.preventDefault(); 
} 
} 
); 
container.on('results:focus', function (params){ 
self.$selection.attr('aria-activedescendant', params.data._resultId); 
} 
); 
container.on('selection:update', function (params){ 
self.update(params.data); 
} 
); 
container.on('open', function (){ 
self.$selection.attr('aria-expanded', 'true'); 
self.$selection.attr('aria-owns', resultsId); 
self._attachCloseHandler(container); 
} 
); 
container.on('close', function (){ 
self.$selection.attr('aria-expanded', 'false'); 
self.$selection.removeAttr('aria-activedescendant'); 
self.$selection.removeAttr('aria-owns'); 
self.$selection.trigger('focus'); 
self._detachCloseHandler(container); 
} 
); 
container.on('enable', function (){ 
self.$selection.attr('tabindex', self._tabindex); 
self.$selection.attr('aria-disabled', 'false'); 
} 
); 
container.on('disable', function (){ 
self.$selection.attr('tabindex', '-1'); 
self.$selection.attr('aria-disabled', 'true'); 
} 
); 
} 
; 
BaseSelection.prototype._handleBlur = function (evt){ 
var self = this; 
_AN_Call_settimeout('setTimeout', window, function (){ 
if ((document.activeElement == self.$selection[0]) || ($.contains(self.$selection[0], document.activeElement))) { 
return ; 
} 
self.trigger('blur', evt); 
} 
, 1); 
} 
; 
BaseSelection.prototype._attachCloseHandler = function (container){ 
$(document.body).on('mousedown.select2.' + container.id, function (e){ 
var $target = $(_AN_Read_target('target', e)); 
var $select = $target.closest('.select2'); 
var $all = $('.select2.select2-container--open'); 
$all.each(function (){ 
if (this == $select[0]) { 
return ; 
} 
var $element = Utils.GetData(this, 'element'); 
$element.select2('close'); 
} 
); 
} 
); 
} 
; 
BaseSelection.prototype._detachCloseHandler = function (container){ 
$(document.body).off('mousedown.select2.' + container.id); 
} 
; 
BaseSelection.prototype.position = function ($selection, $container){ 
var $selectionContainer = $container.find('.selection'); 
$selectionContainer.append($selection); 
} 
; 
BaseSelection.prototype.destroy = function (){ 
this._detachCloseHandler(this.container); 
} 
; 
BaseSelection.prototype.update = function (data){ 
throw new Error('The `update` method must be defined in child classes.')
} 
; 
BaseSelection.prototype.isEnabled = function (){ 
return !this.isDisabled(); 
} 
; 
BaseSelection.prototype.isDisabled = function (){ 
return this.options.get('disabled'); 
} 
; 
return BaseSelection; 
} 
); 
S2.define('select2/selection/single', ['jquery', './base', '../utils', '../keys'] , function ($, BaseSelection, Utils, KEYS){ 
function SingleSelection(){ 
SingleSelection.__super__.constructor.apply(this, arguments); 
} 
Utils.Extend(SingleSelection, BaseSelection); 
SingleSelection.prototype.render = function (){ 
var $selection = SingleSelection.__super__.render.call(this); 
$selection[0].classList.add('select2-selection--single'); 
$selection.html('<span class="select2-selection__rendered"></span>' + '<span class="select2-selection__arrow" role="presentation">' + '<b role="presentation"></b>' + '</span>'); 
return $selection; 
} 
; 
SingleSelection.prototype.bind = function (container, $container){ 
var self = this; 
SingleSelection.__super__.bind.apply(this, arguments); 
var id = container.id + '-container'; 
this.$selection.find('.select2-selection__rendered').attr('id', id).attr('role', 'textbox').attr('aria-readonly', 'true'); 
this.$selection.attr('aria-labelledby', id); 
this.$selection.attr('aria-controls', id); 
this.$selection.on('mousedown', function (evt){ 
if (evt.which !== 1) { 
return ; 
} 
self.trigger('toggle', { 
originalEvent: evt}
); 
} 
); 
this.$selection.on('focus', function (evt){ 
} 
); 
this.$selection.on('blur', function (evt){ 
} 
); 
container.on('focus', function (evt){ 
if (!container.isOpen()) { 
self.$selection.trigger('focus'); 
} 
} 
); 
} 
; 
SingleSelection.prototype.clear = function (){ 
var $rendered = this.$selection.find('.select2-selection__rendered'); 
$rendered.empty(); 
$rendered.removeAttr('title'); 
} 
; 
SingleSelection.prototype.display = function (data, container){ 
var template = this.options.get('templateSelection'); 
var escapeMarkup = this.options.get('escapeMarkup'); 
return escapeMarkup(template(data, container)); 
} 
; 
SingleSelection.prototype.selectionContainer = function (){ 
return $('<span></span>'); 
} 
; 
SingleSelection.prototype.update = function (data){ 
if (_AN_Read_length('length', data) === 0) { 
_AN_Call_clear('clear', this); 
return ; 
} 
var selection = data[0]; 
var $rendered = this.$selection.find('.select2-selection__rendered'); 
var formatted = this.display(selection, $rendered); 
$rendered.empty().append(formatted); 
var title = selection.title || selection.text; 
if (title) { 
$rendered.attr('title', title); 
} 
 else { 
$rendered.removeAttr('title'); 
} 
} 
; 
return SingleSelection; 
} 
); 
S2.define('select2/selection/multiple', ['jquery', './base', '../utils'] , function ($, BaseSelection, Utils){ 
function MultipleSelection($element, options){ 
MultipleSelection.__super__.constructor.apply(this, arguments); 
} 
Utils.Extend(MultipleSelection, BaseSelection); 
MultipleSelection.prototype.render = function (){ 
var $selection = MultipleSelection.__super__.render.call(this); 
$selection[0].classList.add('select2-selection--multiple'); 
$selection.html('<ul class="select2-selection__rendered"></ul>'); 
return $selection; 
} 
; 
MultipleSelection.prototype.bind = function (container, $container){ 
var self = this; 
MultipleSelection.__super__.bind.apply(this, arguments); 
var id = container.id + '-container'; 
this.$selection.find('.select2-selection__rendered').attr('id', id); 
this.$selection.on('click', function (evt){ 
self.trigger('toggle', { 
originalEvent: evt}
); 
} 
); 
this.$selection.on('click', '.select2-selection__choice__remove', function (evt){ 
if (self.isDisabled()) { 
return ; 
} 
var $remove = $(this); 
var $selection = $remove.parent(); 
var data = Utils.GetData($selection[0], 'data'); 
self.trigger('unselect', { 
originalEvent: evt,
data: data}
); 
} 
); 
this.$selection.on('keydown', '.select2-selection__choice__remove', function (evt){ 
if (self.isDisabled()) { 
return ; 
} 
evt.stopPropagation(); 
} 
); 
} 
; 
MultipleSelection.prototype.clear = function (){ 
var $rendered = this.$selection.find('.select2-selection__rendered'); 
$rendered.empty(); 
$rendered.removeAttr('title'); 
} 
; 
MultipleSelection.prototype.display = function (data, container){ 
var template = this.options.get('templateSelection'); 
var escapeMarkup = this.options.get('escapeMarkup'); 
return escapeMarkup(template(data, container)); 
} 
; 
MultipleSelection.prototype.selectionContainer = function (){ 
var $container = $('<li class="select2-selection__choice">' + '<button type="button" class="select2-selection__choice__remove" ' + 'tabindex="-1">' + '<span aria-hidden="true">&times;</span>' + '</button>' + '<span class="select2-selection__choice__display"></span>' + '</li>'); 
return $container; 
} 
; 
MultipleSelection.prototype.update = function (data){ 
_AN_Call_clear('clear', this); 
if (_AN_Read_length('length', data) === 0) { 
return ; 
} 
var $selections = [] ; 
var selectionIdPrefix = this.$selection.find('.select2-selection__rendered').attr('id') + '-choice-'; 
for (var d = 0; 
d < _AN_Read_length('length', data); d++ ){ 
var selection = data[d]; 
var $selection = this.selectionContainer(); 
var formatted = this.display(selection, $selection); 
var selectionId = selectionIdPrefix + Utils.generateChars(4) + '-'; 
if (selection.id) { 
selectionId += selection.id; 
} 
 else { 
selectionId += Utils.generateChars(4); 
} 
$selection.find('.select2-selection__choice__display').append(formatted).attr('id', selectionId); 
var title = selection.title || selection.text; 
if (title) { 
$selection.attr('title', title); 
} 
var removeItem = this.options.get('translations').get('removeItem'); 
var $remove = $selection.find('.select2-selection__choice__remove'); 
$remove.attr('title', removeItem()); 
$remove.attr('aria-label', removeItem()); 
$remove.attr('aria-describedby', selectionId); 
Utils.StoreData($selection[0], 'data', selection); 
$selections.push($selection); 
} 
var $rendered = this.$selection.find('.select2-selection__rendered'); 
$rendered.append($selections); 
} 
; 
return MultipleSelection; 
} 
); 
S2.define('select2/selection/placeholder', [] , function (){ 
function Placeholder(decorated, $element, options){ 
this.placeholder = this.normalizePlaceholder(options.get('placeholder')); 
decorated.call(this, $element, options); 
} 
Placeholder.prototype.normalizePlaceholder = function (_, placeholder){ 
if (typeof placeholder === 'string') { 
placeholder = { 
id: '',
text: placeholder}
; 
} 
return placeholder; 
} 
; 
Placeholder.prototype.createPlaceholder = function (decorated, placeholder){ 
var $placeholder = this.selectionContainer(); 
$placeholder.html(this.display(placeholder)); 
$placeholder[0].classList.add('select2-selection__placeholder'); 
$placeholder[0].classList.remove('select2-selection__choice'); 
var placeholderTitle = placeholder.title || placeholder.text || $placeholder.text(); 
this.$selection.find('.select2-selection__rendered').attr('title', placeholderTitle); 
return $placeholder; 
} 
; 
Placeholder.prototype.update = function (decorated, data){ 
var singlePlaceholder = (_AN_Read_length('length', data) == 1 && data[0].id != this.placeholder.id); 
var multipleSelections = _AN_Read_length('length', data) > 1; 
if (multipleSelections || singlePlaceholder) { 
return decorated.call(this, data); 
} 
_AN_Call_clear('clear', this); 
var $placeholder = this.createPlaceholder(this.placeholder); 
this.$selection.find('.select2-selection__rendered').append($placeholder); 
} 
; 
return Placeholder; 
} 
); 
S2.define('select2/selection/allowClear', ['jquery', '../keys', '../utils'] , function ($, KEYS, Utils){ 
function AllowClear(){ 
} 
AllowClear.prototype.bind = function (decorated, container, $container){ 
var self = this; 
decorated.call(this, container, $container); 
if (this.placeholder == null ) { 
if (this.options.get('debug') && window.console && console.error) { 
console.error('Select2: The `allowClear` option should be used in combination ' + 'with the `placeholder` option.'); 
} 
} 
this.$selection.on('mousedown', '.select2-selection__clear', function (evt){ 
self._handleClear(evt); 
} 
); 
container.on('keypress', function (evt){ 
self._handleKeyboardClear(evt, container); 
} 
); 
} 
; 
AllowClear.prototype._handleClear = function (_, evt){ 
if (this.isDisabled()) { 
return ; 
} 
var $clear = this.$selection.find('.select2-selection__clear'); 
if (_AN_Read_length('length', $clear) === 0) { 
return ; 
} 
evt.stopPropagation(); 
var data = Utils.GetData($clear[0], 'data'); 
var previousVal = this.$element.val(); 
this.$element.val(this.placeholder.id); 
var unselectData = { 
data: data}
; 
this.trigger('clear', unselectData); 
if (unselectData.prevented) { 
this.$element.val(previousVal); 
return ; 
} 
for (var d = 0; 
d < _AN_Read_length('length', data); d++ ){ 
unselectData = { 
data: data[d]}
; 
this.trigger('unselect', unselectData); 
if (unselectData.prevented) { 
this.$element.val(previousVal); 
return ; 
} 
} 
this.$element.trigger('input').trigger('change'); 
this.trigger('toggle', { 
}
); 
} 
; 
AllowClear.prototype._handleKeyboardClear = function (_, evt, container){ 
if (container.isOpen()) { 
return ; 
} 
if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) { 
this._handleClear(evt); 
} 
} 
; 
AllowClear.prototype.update = function (decorated, data){ 
decorated.call(this, data); 
this.$selection.find('.select2-selection__clear').remove(); 
this.$selection[0].classList.remove('select2-selection--clearable'); 
if (_AN_Read_length('length', this.$selection.find('.select2-selection__placeholder')) > 0 || _AN_Read_length('length', data) === 0) { 
return ; 
} 
var selectionId = this.$selection.find('.select2-selection__rendered').attr('id'); 
var removeAll = this.options.get('translations').get('removeAllItems'); 
var $remove = $('<button type="button" class="select2-selection__clear" tabindex="-1">' + '<span aria-hidden="true">&times;</span>' + '</button>'); 
$remove.attr('title', removeAll()); 
$remove.attr('aria-label', removeAll()); 
$remove.attr('aria-describedby', selectionId); 
Utils.StoreData($remove[0], 'data', data); 
this.$selection.prepend($remove); 
this.$selection[0].classList.add('select2-selection--clearable'); 
} 
; 
return AllowClear; 
} 
); 
S2.define('select2/selection/search', ['jquery', '../utils', '../keys'] , function ($, Utils, KEYS){ 
function Search(decorated, $element, options){ 
decorated.call(this, $element, options); 
} 
Search.prototype.render = function (decorated){ 
var searchLabel = this.options.get('translations').get('search'); 
var $search = $('<span class="select2-search select2-search--inline">' + '<textarea class="select2-search__field"' + ' type="search" tabindex="-1"' + ' autocorrect="off" autocapitalize="none"' + ' spellcheck="false" role="searchbox" aria-autocomplete="list" >' + '</textarea>' + '</span>'); 
this.$searchContainer = $search; 
this.$search = $search.find('textarea'); 
this.$search.prop('autocomplete', this.options.get('autocomplete')); 
this.$search.attr('aria-label', searchLabel()); 
var $rendered = decorated.call(this); 
this._transferTabIndex(); 
$rendered.append(this.$searchContainer); 
return $rendered; 
} 
; 
Search.prototype.bind = function (decorated, container, $container){ 
var self = this; 
var resultsId = container.id + '-results'; 
var selectionId = container.id + '-container'; 
decorated.call(this, container, $container); 
self.$search.attr('aria-describedby', selectionId); 
container.on('open', function (){ 
self.$search.attr('aria-controls', resultsId); 
self.$search.trigger('focus'); 
} 
); 
container.on('close', function (){ 
self.$search.val(''); 
self.resizeSearch(); 
self.$search.removeAttr('aria-controls'); 
self.$search.removeAttr('aria-activedescendant'); 
self.$search.trigger('focus'); 
} 
); 
container.on('enable', function (){ 
self.$search.prop('disabled', false ); 
self._transferTabIndex(); 
} 
); 
container.on('disable', function (){ 
self.$search.prop('disabled', true ); 
} 
); 
container.on('focus', function (evt){ 
self.$search.trigger('focus'); 
} 
); 
container.on('results:focus', function (params){ 
if (params.data._resultId) { 
self.$search.attr('aria-activedescendant', params.data._resultId); 
} 
 else { 
self.$search.removeAttr('aria-activedescendant'); 
} 
} 
); 
this.$selection.on('focusin', '.select2-search--inline', function (evt){ 
self.trigger('focus', evt); 
} 
); 
this.$selection.on('focusout', '.select2-search--inline', function (evt){ 
self._handleBlur(evt); 
} 
); 
this.$selection.on('keydown', '.select2-search--inline', function (evt){ 
evt.stopPropagation(); 
self.trigger('keypress', evt); 
self._keyUpPrevented = evt.isDefaultPrevented(); 
var key = evt.which; 
if (key === KEYS.BACKSPACE && self.$search.val() === '') { 
var $previousChoice = self.$selection.find('.select2-selection__choice').last(); 
if (_AN_Read_length('length', $previousChoice) > 0) { 
var item = Utils.GetData($previousChoice[0], 'data'); 
self.searchRemoveChoice(item); 
evt.preventDefault(); 
} 
} 
} 
); 
this.$selection.on('click', '.select2-search--inline', function (evt){ 
if (self.$search.val()) { 
evt.stopPropagation(); 
} 
} 
); 
var msie = document.documentMode; 
var disableInputEvents = msie && msie <= 11; 
this.$selection.on('input.searchcheck', '.select2-search--inline', function (evt){ 
if (disableInputEvents) { 
self.$selection.off('input.search input.searchcheck'); 
return ; 
} 
self.$selection.off('keyup.search'); 
} 
); 
this.$selection.on('keyup.search input.search', '.select2-search--inline', function (evt){ 
if (disableInputEvents && evt.type === 'input') { 
self.$selection.off('input.search input.searchcheck'); 
return ; 
} 
var key = evt.which; 
if (key == KEYS.SHIFT || key == KEYS.CTRL || key == KEYS.ALT) { 
return ; 
} 
if (key == KEYS.TAB) { 
return ; 
} 
self.handleSearch(evt); 
} 
); 
} 
; 
Search.prototype._transferTabIndex = function (decorated){ 
this.$search.attr('tabindex', this.$selection.attr('tabindex')); 
this.$selection.attr('tabindex', '-1'); 
} 
; 
Search.prototype.createPlaceholder = function (decorated, placeholder){ 
this.$search.attr('placeholder', placeholder.text); 
} 
; 
Search.prototype.update = function (decorated, data){ 
var searchHadFocus = this.$search[0] == document.activeElement; 
this.$search.attr('placeholder', ''); 
decorated.call(this, data); 
this.resizeSearch(); 
if (searchHadFocus) { 
this.$search.trigger('focus'); 
} 
} 
; 
Search.prototype.handleSearch = function (){ 
this.resizeSearch(); 
if (!this._keyUpPrevented) { 
var input = this.$search.val(); 
this.trigger('query', { 
term: input}
); 
} 
this._keyUpPrevented = false ; 
} 
; 
Search.prototype.searchRemoveChoice = function (decorated, item){ 
this.trigger('unselect', { 
data: item}
); 
this.$search.val(item.text); 
this.handleSearch(); 
} 
; 
Search.prototype.resizeSearch = function (){ 
this.$search.css('width', '25px'); 
var width = '100%'; 
if (this.$search.attr('placeholder') === '') { 
var minimumWidth = _AN_Read_length('length', this.$search.val()) + 1; 
width = (minimumWidth * 0.75) + 'em'; 
} 
this.$search.css('width', width); 
} 
; 
return Search; 
} 
); 
S2.define('select2/selection/selectionCss', ['../utils'] , function (Utils){ 
function SelectionCSS(){ 
} 
SelectionCSS.prototype.render = function (decorated){ 
var $selection = decorated.call(this); 
var selectionCssClass = this.options.get('selectionCssClass') || ''; 
if (selectionCssClass.indexOf(':all:') !== -1) { 
selectionCssClass = _AN_Call_replace('replace', selectionCssClass, ':all:', ''); 
Utils.copyNonInternalCssClasses($selection[0], this.$element[0]); 
} 
$selection.addClass(selectionCssClass); 
return $selection; 
} 
; 
return SelectionCSS; 
} 
); 
S2.define('select2/selection/eventRelay', ['jquery'] , function ($){ 
function EventRelay(){ 
} 
EventRelay.prototype.bind = function (decorated, container, $container){ 
var self = this; 
var relayEvents = ['open', 'opening', 'close', 'closing', 'select', 'selecting', 'unselect', 'unselecting', 'clear', 'clearing'] ; 
var preventableEvents = ['opening', 'closing', 'selecting', 'unselecting', 'clearing'] ; 
decorated.call(this, container, $container); 
container.on('*', function (name, params){ 
if (relayEvents.indexOf(name) === -1) { 
return ; 
} 
params = params || { 
}
; 
var evt = $.Event('select2:' + name, { 
params: params}
); 
self.$element.trigger(evt); 
if (preventableEvents.indexOf(name) === -1) { 
return ; 
} 
params.prevented = evt.isDefaultPrevented(); 
} 
); 
} 
; 
return EventRelay; 
} 
); 
S2.define('select2/translation', ['jquery', 'require'] , function ($, require){ 
function Translation(dict){ 
this.dict = dict || { 
}
; 
} 
Translation.prototype.all = function (){ 
return this.dict; 
} 
; 
Translation.prototype.get = function (key){ 
return this.dict[key]; 
} 
; 
Translation.prototype.extend = function (translation){ 
this.dict = $.extend({ 
}
, translation.all(), this.dict); 
} 
; 
Translation._cache = { 
}
; 
Translation.loadPath = function (path){ 
if (!(path in Translation._cache)) { 
var translations = require(path); 
Translation._cache[path] = translations; 
} 
return new Translation(Translation._cache[path]); 
} 
; 
return Translation; 
} 
); 
S2.define('select2/diacritics', [] , function (){ 
var diacritics = { 
'\u24B6': 'A',
'\uFF21': 'A',
'\u00C0': 'A',
'\u00C1': 'A',
'\u00C2': 'A',
'\u1EA6': 'A',
'\u1EA4': 'A',
'\u1EAA': 'A',
'\u1EA8': 'A',
'\u00C3': 'A',
'\u0100': 'A',
'\u0102': 'A',
'\u1EB0': 'A',
'\u1EAE': 'A',
'\u1EB4': 'A',
'\u1EB2': 'A',
'\u0226': 'A',
'\u01E0': 'A',
'\u00C4': 'A',
'\u01DE': 'A',
'\u1EA2': 'A',
'\u00C5': 'A',
'\u01FA': 'A',
'\u01CD': 'A',
'\u0200': 'A',
'\u0202': 'A',
'\u1EA0': 'A',
'\u1EAC': 'A',
'\u1EB6': 'A',
'\u1E00': 'A',
'\u0104': 'A',
'\u023A': 'A',
'\u2C6F': 'A',
'\uA732': 'AA',
'\u00C6': 'AE',
'\u01FC': 'AE',
'\u01E2': 'AE',
'\uA734': 'AO',
'\uA736': 'AU',
'\uA738': 'AV',
'\uA73A': 'AV',
'\uA73C': 'AY',
'\u24B7': 'B',
'\uFF22': 'B',
'\u1E02': 'B',
'\u1E04': 'B',
'\u1E06': 'B',
'\u0243': 'B',
'\u0182': 'B',
'\u0181': 'B',
'\u24B8': 'C',
'\uFF23': 'C',
'\u0106': 'C',
'\u0108': 'C',
'\u010A': 'C',
'\u010C': 'C',
'\u00C7': 'C',
'\u1E08': 'C',
'\u0187': 'C',
'\u023B': 'C',
'\uA73E': 'C',
'\u24B9': 'D',
'\uFF24': 'D',
'\u1E0A': 'D',
'\u010E': 'D',
'\u1E0C': 'D',
'\u1E10': 'D',
'\u1E12': 'D',
'\u1E0E': 'D',
'\u0110': 'D',
'\u018B': 'D',
'\u018A': 'D',
'\u0189': 'D',
'\uA779': 'D',
'\u01F1': 'DZ',
'\u01C4': 'DZ',
'\u01F2': 'Dz',
'\u01C5': 'Dz',
'\u24BA': 'E',
'\uFF25': 'E',
'\u00C8': 'E',
'\u00C9': 'E',
'\u00CA': 'E',
'\u1EC0': 'E',
'\u1EBE': 'E',
'\u1EC4': 'E',
'\u1EC2': 'E',
'\u1EBC': 'E',
'\u0112': 'E',
'\u1E14': 'E',
'\u1E16': 'E',
'\u0114': 'E',
'\u0116': 'E',
'\u00CB': 'E',
'\u1EBA': 'E',
'\u011A': 'E',
'\u0204': 'E',
'\u0206': 'E',
'\u1EB8': 'E',
'\u1EC6': 'E',
'\u0228': 'E',
'\u1E1C': 'E',
'\u0118': 'E',
'\u1E18': 'E',
'\u1E1A': 'E',
'\u0190': 'E',
'\u018E': 'E',
'\u24BB': 'F',
'\uFF26': 'F',
'\u1E1E': 'F',
'\u0191': 'F',
'\uA77B': 'F',
'\u24BC': 'G',
'\uFF27': 'G',
'\u01F4': 'G',
'\u011C': 'G',
'\u1E20': 'G',
'\u011E': 'G',
'\u0120': 'G',
'\u01E6': 'G',
'\u0122': 'G',
'\u01E4': 'G',
'\u0193': 'G',
'\uA7A0': 'G',
'\uA77D': 'G',
'\uA77E': 'G',
'\u24BD': 'H',
'\uFF28': 'H',
'\u0124': 'H',
'\u1E22': 'H',
'\u1E26': 'H',
'\u021E': 'H',
'\u1E24': 'H',
'\u1E28': 'H',
'\u1E2A': 'H',
'\u0126': 'H',
'\u2C67': 'H',
'\u2C75': 'H',
'\uA78D': 'H',
'\u24BE': 'I',
'\uFF29': 'I',
'\u00CC': 'I',
'\u00CD': 'I',
'\u00CE': 'I',
'\u0128': 'I',
'\u012A': 'I',
'\u012C': 'I',
'\u0130': 'I',
'\u00CF': 'I',
'\u1E2E': 'I',
'\u1EC8': 'I',
'\u01CF': 'I',
'\u0208': 'I',
'\u020A': 'I',
'\u1ECA': 'I',
'\u012E': 'I',
'\u1E2C': 'I',
'\u0197': 'I',
'\u24BF': 'J',
'\uFF2A': 'J',
'\u0134': 'J',
'\u0248': 'J',
'\u24C0': 'K',
'\uFF2B': 'K',
'\u1E30': 'K',
'\u01E8': 'K',
'\u1E32': 'K',
'\u0136': 'K',
'\u1E34': 'K',
'\u0198': 'K',
'\u2C69': 'K',
'\uA740': 'K',
'\uA742': 'K',
'\uA744': 'K',
'\uA7A2': 'K',
'\u24C1': 'L',
'\uFF2C': 'L',
'\u013F': 'L',
'\u0139': 'L',
'\u013D': 'L',
'\u1E36': 'L',
'\u1E38': 'L',
'\u013B': 'L',
'\u1E3C': 'L',
'\u1E3A': 'L',
'\u0141': 'L',
'\u023D': 'L',
'\u2C62': 'L',
'\u2C60': 'L',
'\uA748': 'L',
'\uA746': 'L',
'\uA780': 'L',
'\u01C7': 'LJ',
'\u01C8': 'Lj',
'\u24C2': 'M',
'\uFF2D': 'M',
'\u1E3E': 'M',
'\u1E40': 'M',
'\u1E42': 'M',
'\u2C6E': 'M',
'\u019C': 'M',
'\u24C3': 'N',
'\uFF2E': 'N',
'\u01F8': 'N',
'\u0143': 'N',
'\u00D1': 'N',
'\u1E44': 'N',
'\u0147': 'N',
'\u1E46': 'N',
'\u0145': 'N',
'\u1E4A': 'N',
'\u1E48': 'N',
'\u0220': 'N',
'\u019D': 'N',
'\uA790': 'N',
'\uA7A4': 'N',
'\u01CA': 'NJ',
'\u01CB': 'Nj',
'\u24C4': 'O',
'\uFF2F': 'O',
'\u00D2': 'O',
'\u00D3': 'O',
'\u00D4': 'O',
'\u1ED2': 'O',
'\u1ED0': 'O',
'\u1ED6': 'O',
'\u1ED4': 'O',
'\u00D5': 'O',
'\u1E4C': 'O',
'\u022C': 'O',
'\u1E4E': 'O',
'\u014C': 'O',
'\u1E50': 'O',
'\u1E52': 'O',
'\u014E': 'O',
'\u022E': 'O',
'\u0230': 'O',
'\u00D6': 'O',
'\u022A': 'O',
'\u1ECE': 'O',
'\u0150': 'O',
'\u01D1': 'O',
'\u020C': 'O',
'\u020E': 'O',
'\u01A0': 'O',
'\u1EDC': 'O',
'\u1EDA': 'O',
'\u1EE0': 'O',
'\u1EDE': 'O',
'\u1EE2': 'O',
'\u1ECC': 'O',
'\u1ED8': 'O',
'\u01EA': 'O',
'\u01EC': 'O',
'\u00D8': 'O',
'\u01FE': 'O',
'\u0186': 'O',
'\u019F': 'O',
'\uA74A': 'O',
'\uA74C': 'O',
'\u0152': 'OE',
'\u01A2': 'OI',
'\uA74E': 'OO',
'\u0222': 'OU',
'\u24C5': 'P',
'\uFF30': 'P',
'\u1E54': 'P',
'\u1E56': 'P',
'\u01A4': 'P',
'\u2C63': 'P',
'\uA750': 'P',
'\uA752': 'P',
'\uA754': 'P',
'\u24C6': 'Q',
'\uFF31': 'Q',
'\uA756': 'Q',
'\uA758': 'Q',
'\u024A': 'Q',
'\u24C7': 'R',
'\uFF32': 'R',
'\u0154': 'R',
'\u1E58': 'R',
'\u0158': 'R',
'\u0210': 'R',
'\u0212': 'R',
'\u1E5A': 'R',
'\u1E5C': 'R',
'\u0156': 'R',
'\u1E5E': 'R',
'\u024C': 'R',
'\u2C64': 'R',
'\uA75A': 'R',
'\uA7A6': 'R',
'\uA782': 'R',
'\u24C8': 'S',
'\uFF33': 'S',
'\u1E9E': 'S',
'\u015A': 'S',
'\u1E64': 'S',
'\u015C': 'S',
'\u1E60': 'S',
'\u0160': 'S',
'\u1E66': 'S',
'\u1E62': 'S',
'\u1E68': 'S',
'\u0218': 'S',
'\u015E': 'S',
'\u2C7E': 'S',
'\uA7A8': 'S',
'\uA784': 'S',
'\u24C9': 'T',
'\uFF34': 'T',
'\u1E6A': 'T',
'\u0164': 'T',
'\u1E6C': 'T',
'\u021A': 'T',
'\u0162': 'T',
'\u1E70': 'T',
'\u1E6E': 'T',
'\u0166': 'T',
'\u01AC': 'T',
'\u01AE': 'T',
'\u023E': 'T',
'\uA786': 'T',
'\uA728': 'TZ',
'\u24CA': 'U',
'\uFF35': 'U',
'\u00D9': 'U',
'\u00DA': 'U',
'\u00DB': 'U',
'\u0168': 'U',
'\u1E78': 'U',
'\u016A': 'U',
'\u1E7A': 'U',
'\u016C': 'U',
'\u00DC': 'U',
'\u01DB': 'U',
'\u01D7': 'U',
'\u01D5': 'U',
'\u01D9': 'U',
'\u1EE6': 'U',
'\u016E': 'U',
'\u0170': 'U',
'\u01D3': 'U',
'\u0214': 'U',
'\u0216': 'U',
'\u01AF': 'U',
'\u1EEA': 'U',
'\u1EE8': 'U',
'\u1EEE': 'U',
'\u1EEC': 'U',
'\u1EF0': 'U',
'\u1EE4': 'U',
'\u1E72': 'U',
'\u0172': 'U',
'\u1E76': 'U',
'\u1E74': 'U',
'\u0244': 'U',
'\u24CB': 'V',
'\uFF36': 'V',
'\u1E7C': 'V',
'\u1E7E': 'V',
'\u01B2': 'V',
'\uA75E': 'V',
'\u0245': 'V',
'\uA760': 'VY',
'\u24CC': 'W',
'\uFF37': 'W',
'\u1E80': 'W',
'\u1E82': 'W',
'\u0174': 'W',
'\u1E86': 'W',
'\u1E84': 'W',
'\u1E88': 'W',
'\u2C72': 'W',
'\u24CD': 'X',
'\uFF38': 'X',
'\u1E8A': 'X',
'\u1E8C': 'X',
'\u24CE': 'Y',
'\uFF39': 'Y',
'\u1EF2': 'Y',
'\u00DD': 'Y',
'\u0176': 'Y',
'\u1EF8': 'Y',
'\u0232': 'Y',
'\u1E8E': 'Y',
'\u0178': 'Y',
'\u1EF6': 'Y',
'\u1EF4': 'Y',
'\u01B3': 'Y',
'\u024E': 'Y',
'\u1EFE': 'Y',
'\u24CF': 'Z',
'\uFF3A': 'Z',
'\u0179': 'Z',
'\u1E90': 'Z',
'\u017B': 'Z',
'\u017D': 'Z',
'\u1E92': 'Z',
'\u1E94': 'Z',
'\u01B5': 'Z',
'\u0224': 'Z',
'\u2C7F': 'Z',
'\u2C6B': 'Z',
'\uA762': 'Z',
'\u24D0': 'a',
'\uFF41': 'a',
'\u1E9A': 'a',
'\u00E0': 'a',
'\u00E1': 'a',
'\u00E2': 'a',
'\u1EA7': 'a',
'\u1EA5': 'a',
'\u1EAB': 'a',
'\u1EA9': 'a',
'\u00E3': 'a',
'\u0101': 'a',
'\u0103': 'a',
'\u1EB1': 'a',
'\u1EAF': 'a',
'\u1EB5': 'a',
'\u1EB3': 'a',
'\u0227': 'a',
'\u01E1': 'a',
'\u00E4': 'a',
'\u01DF': 'a',
'\u1EA3': 'a',
'\u00E5': 'a',
'\u01FB': 'a',
'\u01CE': 'a',
'\u0201': 'a',
'\u0203': 'a',
'\u1EA1': 'a',
'\u1EAD': 'a',
'\u1EB7': 'a',
'\u1E01': 'a',
'\u0105': 'a',
'\u2C65': 'a',
'\u0250': 'a',
'\uA733': 'aa',
'\u00E6': 'ae',
'\u01FD': 'ae',
'\u01E3': 'ae',
'\uA735': 'ao',
'\uA737': 'au',
'\uA739': 'av',
'\uA73B': 'av',
'\uA73D': 'ay',
'\u24D1': 'b',
'\uFF42': 'b',
'\u1E03': 'b',
'\u1E05': 'b',
'\u1E07': 'b',
'\u0180': 'b',
'\u0183': 'b',
'\u0253': 'b',
'\u24D2': 'c',
'\uFF43': 'c',
'\u0107': 'c',
'\u0109': 'c',
'\u010B': 'c',
'\u010D': 'c',
'\u00E7': 'c',
'\u1E09': 'c',
'\u0188': 'c',
'\u023C': 'c',
'\uA73F': 'c',
'\u2184': 'c',
'\u24D3': 'd',
'\uFF44': 'd',
'\u1E0B': 'd',
'\u010F': 'd',
'\u1E0D': 'd',
'\u1E11': 'd',
'\u1E13': 'd',
'\u1E0F': 'd',
'\u0111': 'd',
'\u018C': 'd',
'\u0256': 'd',
'\u0257': 'd',
'\uA77A': 'd',
'\u01F3': 'dz',
'\u01C6': 'dz',
'\u24D4': 'e',
'\uFF45': 'e',
'\u00E8': 'e',
'\u00E9': 'e',
'\u00EA': 'e',
'\u1EC1': 'e',
'\u1EBF': 'e',
'\u1EC5': 'e',
'\u1EC3': 'e',
'\u1EBD': 'e',
'\u0113': 'e',
'\u1E15': 'e',
'\u1E17': 'e',
'\u0115': 'e',
'\u0117': 'e',
'\u00EB': 'e',
'\u1EBB': 'e',
'\u011B': 'e',
'\u0205': 'e',
'\u0207': 'e',
'\u1EB9': 'e',
'\u1EC7': 'e',
'\u0229': 'e',
'\u1E1D': 'e',
'\u0119': 'e',
'\u1E19': 'e',
'\u1E1B': 'e',
'\u0247': 'e',
'\u025B': 'e',
'\u01DD': 'e',
'\u24D5': 'f',
'\uFF46': 'f',
'\u1E1F': 'f',
'\u0192': 'f',
'\uA77C': 'f',
'\u24D6': 'g',
'\uFF47': 'g',
'\u01F5': 'g',
'\u011D': 'g',
'\u1E21': 'g',
'\u011F': 'g',
'\u0121': 'g',
'\u01E7': 'g',
'\u0123': 'g',
'\u01E5': 'g',
'\u0260': 'g',
'\uA7A1': 'g',
'\u1D79': 'g',
'\uA77F': 'g',
'\u24D7': 'h',
'\uFF48': 'h',
'\u0125': 'h',
'\u1E23': 'h',
'\u1E27': 'h',
'\u021F': 'h',
'\u1E25': 'h',
'\u1E29': 'h',
'\u1E2B': 'h',
'\u1E96': 'h',
'\u0127': 'h',
'\u2C68': 'h',
'\u2C76': 'h',
'\u0265': 'h',
'\u0195': 'hv',
'\u24D8': 'i',
'\uFF49': 'i',
'\u00EC': 'i',
'\u00ED': 'i',
'\u00EE': 'i',
'\u0129': 'i',
'\u012B': 'i',
'\u012D': 'i',
'\u00EF': 'i',
'\u1E2F': 'i',
'\u1EC9': 'i',
'\u01D0': 'i',
'\u0209': 'i',
'\u020B': 'i',
'\u1ECB': 'i',
'\u012F': 'i',
'\u1E2D': 'i',
'\u0268': 'i',
'\u0131': 'i',
'\u24D9': 'j',
'\uFF4A': 'j',
'\u0135': 'j',
'\u01F0': 'j',
'\u0249': 'j',
'\u24DA': 'k',
'\uFF4B': 'k',
'\u1E31': 'k',
'\u01E9': 'k',
'\u1E33': 'k',
'\u0137': 'k',
'\u1E35': 'k',
'\u0199': 'k',
'\u2C6A': 'k',
'\uA741': 'k',
'\uA743': 'k',
'\uA745': 'k',
'\uA7A3': 'k',
'\u24DB': 'l',
'\uFF4C': 'l',
'\u0140': 'l',
'\u013A': 'l',
'\u013E': 'l',
'\u1E37': 'l',
'\u1E39': 'l',
'\u013C': 'l',
'\u1E3D': 'l',
'\u1E3B': 'l',
'\u017F': 'l',
'\u0142': 'l',
'\u019A': 'l',
'\u026B': 'l',
'\u2C61': 'l',
'\uA749': 'l',
'\uA781': 'l',
'\uA747': 'l',
'\u01C9': 'lj',
'\u24DC': 'm',
'\uFF4D': 'm',
'\u1E3F': 'm',
'\u1E41': 'm',
'\u1E43': 'm',
'\u0271': 'm',
'\u026F': 'm',
'\u24DD': 'n',
'\uFF4E': 'n',
'\u01F9': 'n',
'\u0144': 'n',
'\u00F1': 'n',
'\u1E45': 'n',
'\u0148': 'n',
'\u1E47': 'n',
'\u0146': 'n',
'\u1E4B': 'n',
'\u1E49': 'n',
'\u019E': 'n',
'\u0272': 'n',
'\u0149': 'n',
'\uA791': 'n',
'\uA7A5': 'n',
'\u01CC': 'nj',
'\u24DE': 'o',
'\uFF4F': 'o',
'\u00F2': 'o',
'\u00F3': 'o',
'\u00F4': 'o',
'\u1ED3': 'o',
'\u1ED1': 'o',
'\u1ED7': 'o',
'\u1ED5': 'o',
'\u00F5': 'o',
'\u1E4D': 'o',
'\u022D': 'o',
'\u1E4F': 'o',
'\u014D': 'o',
'\u1E51': 'o',
'\u1E53': 'o',
'\u014F': 'o',
'\u022F': 'o',
'\u0231': 'o',
'\u00F6': 'o',
'\u022B': 'o',
'\u1ECF': 'o',
'\u0151': 'o',
'\u01D2': 'o',
'\u020D': 'o',
'\u020F': 'o',
'\u01A1': 'o',
'\u1EDD': 'o',
'\u1EDB': 'o',
'\u1EE1': 'o',
'\u1EDF': 'o',
'\u1EE3': 'o',
'\u1ECD': 'o',
'\u1ED9': 'o',
'\u01EB': 'o',
'\u01ED': 'o',
'\u00F8': 'o',
'\u01FF': 'o',
'\u0254': 'o',
'\uA74B': 'o',
'\uA74D': 'o',
'\u0275': 'o',
'\u0153': 'oe',
'\u01A3': 'oi',
'\u0223': 'ou',
'\uA74F': 'oo',
'\u24DF': 'p',
'\uFF50': 'p',
'\u1E55': 'p',
'\u1E57': 'p',
'\u01A5': 'p',
'\u1D7D': 'p',
'\uA751': 'p',
'\uA753': 'p',
'\uA755': 'p',
'\u24E0': 'q',
'\uFF51': 'q',
'\u024B': 'q',
'\uA757': 'q',
'\uA759': 'q',
'\u24E1': 'r',
'\uFF52': 'r',
'\u0155': 'r',
'\u1E59': 'r',
'\u0159': 'r',
'\u0211': 'r',
'\u0213': 'r',
'\u1E5B': 'r',
'\u1E5D': 'r',
'\u0157': 'r',
'\u1E5F': 'r',
'\u024D': 'r',
'\u027D': 'r',
'\uA75B': 'r',
'\uA7A7': 'r',
'\uA783': 'r',
'\u24E2': 's',
'\uFF53': 's',
'\u00DF': 's',
'\u015B': 's',
'\u1E65': 's',
'\u015D': 's',
'\u1E61': 's',
'\u0161': 's',
'\u1E67': 's',
'\u1E63': 's',
'\u1E69': 's',
'\u0219': 's',
'\u015F': 's',
'\u023F': 's',
'\uA7A9': 's',
'\uA785': 's',
'\u1E9B': 's',
'\u24E3': 't',
'\uFF54': 't',
'\u1E6B': 't',
'\u1E97': 't',
'\u0165': 't',
'\u1E6D': 't',
'\u021B': 't',
'\u0163': 't',
'\u1E71': 't',
'\u1E6F': 't',
'\u0167': 't',
'\u01AD': 't',
'\u0288': 't',
'\u2C66': 't',
'\uA787': 't',
'\uA729': 'tz',
'\u24E4': 'u',
'\uFF55': 'u',
'\u00F9': 'u',
'\u00FA': 'u',
'\u00FB': 'u',
'\u0169': 'u',
'\u1E79': 'u',
'\u016B': 'u',
'\u1E7B': 'u',
'\u016D': 'u',
'\u00FC': 'u',
'\u01DC': 'u',
'\u01D8': 'u',
'\u01D6': 'u',
'\u01DA': 'u',
'\u1EE7': 'u',
'\u016F': 'u',
'\u0171': 'u',
'\u01D4': 'u',
'\u0215': 'u',
'\u0217': 'u',
'\u01B0': 'u',
'\u1EEB': 'u',
'\u1EE9': 'u',
'\u1EEF': 'u',
'\u1EED': 'u',
'\u1EF1': 'u',
'\u1EE5': 'u',
'\u1E73': 'u',
'\u0173': 'u',
'\u1E77': 'u',
'\u1E75': 'u',
'\u0289': 'u',
'\u24E5': 'v',
'\uFF56': 'v',
'\u1E7D': 'v',
'\u1E7F': 'v',
'\u028B': 'v',
'\uA75F': 'v',
'\u028C': 'v',
'\uA761': 'vy',
'\u24E6': 'w',
'\uFF57': 'w',
'\u1E81': 'w',
'\u1E83': 'w',
'\u0175': 'w',
'\u1E87': 'w',
'\u1E85': 'w',
'\u1E98': 'w',
'\u1E89': 'w',
'\u2C73': 'w',
'\u24E7': 'x',
'\uFF58': 'x',
'\u1E8B': 'x',
'\u1E8D': 'x',
'\u24E8': 'y',
'\uFF59': 'y',
'\u1EF3': 'y',
'\u00FD': 'y',
'\u0177': 'y',
'\u1EF9': 'y',
'\u0233': 'y',
'\u1E8F': 'y',
'\u00FF': 'y',
'\u1EF7': 'y',
'\u1E99': 'y',
'\u1EF5': 'y',
'\u01B4': 'y',
'\u024F': 'y',
'\u1EFF': 'y',
'\u24E9': 'z',
'\uFF5A': 'z',
'\u017A': 'z',
'\u1E91': 'z',
'\u017C': 'z',
'\u017E': 'z',
'\u1E93': 'z',
'\u1E95': 'z',
'\u01B6': 'z',
'\u0225': 'z',
'\u0240': 'z',
'\u2C6C': 'z',
'\uA763': 'z',
'\u0386': '\u0391',
'\u0388': '\u0395',
'\u0389': '\u0397',
'\u038A': '\u0399',
'\u03AA': '\u0399',
'\u038C': '\u039F',
'\u038E': '\u03A5',
'\u03AB': '\u03A5',
'\u038F': '\u03A9',
'\u03AC': '\u03B1',
'\u03AD': '\u03B5',
'\u03AE': '\u03B7',
'\u03AF': '\u03B9',
'\u03CA': '\u03B9',
'\u0390': '\u03B9',
'\u03CC': '\u03BF',
'\u03CD': '\u03C5',
'\u03CB': '\u03C5',
'\u03B0': '\u03C5',
'\u03CE': '\u03C9',
'\u03C2': '\u03C3',
'\u2019': '\''}
; 
return diacritics; 
} 
); 
S2.define('select2/data/base', ['../utils'] , function (Utils){ 
function BaseAdapter($element, options){ 
BaseAdapter.__super__.constructor.call(this); 
} 
Utils.Extend(BaseAdapter, Utils.Observable); 
BaseAdapter.prototype.current = function (callback){ 
throw new Error('The `current` method must be defined in child classes.')
} 
; 
BaseAdapter.prototype.query = function (params, callback){ 
throw new Error('The `query` method must be defined in child classes.')
} 
; 
BaseAdapter.prototype.bind = function (container, $container){ 
} 
; 
BaseAdapter.prototype.destroy = function (){ 
} 
; 
BaseAdapter.prototype.generateResultId = function (container, data){ 
var id = container.id + '-result-'; 
id += Utils.generateChars(4); 
if (data.id != null ) { 
id += '-' + data.id.toString(); 
} 
 else { 
id += '-' + Utils.generateChars(4); 
} 
return id; 
} 
; 
return BaseAdapter; 
} 
); 
S2.define('select2/data/select', ['./base', '../utils', 'jquery'] , function (BaseAdapter, Utils, $){ 
function SelectAdapter($element, options){ 
this.$element = $element; 
this.options = options; 
SelectAdapter.__super__.constructor.call(this); 
} 
Utils.Extend(SelectAdapter, BaseAdapter); 
SelectAdapter.prototype.current = function (callback){ 
var self = this; 
var data = Array.prototype.map.call(this.$element[0].querySelectorAll(':checked'), function (selectedElement){ 
return self.item($(selectedElement)); 
} 
); 
callback(data); 
} 
; 
SelectAdapter.prototype.select = function (data){ 
var self = this; 
data.selected = true ; 
if (data.element != null  && data.element.tagName.toLowerCase() === 'option') { 
data.element.selected = true ; 
this.$element.trigger('input').trigger('change'); 
return ; 
} 
if (this.$element.prop('multiple')) { 
this.current(function (currentData){ 
var val = [] ; 
data = [data] ; 
data.push.apply(data, currentData); 
for (var d = 0; 
d < _AN_Read_length('length', data); d++ ){ 
var id = data[d].id; 
if (val.indexOf(id) === -1) { 
val.push(id); 
} 
} 
self.$element.val(val); 
self.$element.trigger('input').trigger('change'); 
} 
); 
} 
 else { 
var val = data.id; 
this.$element.val(val); 
this.$element.trigger('input').trigger('change'); 
} 
} 
; 
SelectAdapter.prototype.unselect = function (data){ 
var self = this; 
if (!this.$element.prop('multiple')) { 
return ; 
} 
data.selected = false ; 
if (data.element != null  && data.element.tagName.toLowerCase() === 'option') { 
data.element.selected = false ; 
this.$element.trigger('input').trigger('change'); 
return ; 
} 
this.current(function (currentData){ 
var val = [] ; 
for (var d = 0; 
d < _AN_Read_length('length', currentData); d++ ){ 
var id = currentData[d].id; 
if (id !== data.id && val.indexOf(id) === -1) { 
val.push(id); 
} 
} 
self.$element.val(val); 
self.$element.trigger('input').trigger('change'); 
} 
); 
} 
; 
SelectAdapter.prototype.bind = function (container, $container){ 
var self = this; 
this.container = container; 
container.on('select', function (params){ 
self.select(params.data); 
} 
); 
container.on('unselect', function (params){ 
self.unselect(params.data); 
} 
); 
} 
; 
SelectAdapter.prototype.destroy = function (){ 
this.$element.find('*').each(function (){ 
Utils.RemoveData(this); 
} 
); 
} 
; 
SelectAdapter.prototype.query = function (params, callback){ 
var data = [] ; 
var self = this; 
var $options = this.$element.children(); 
$options.each(function (){ 
if (this.tagName.toLowerCase() !== 'option' && this.tagName.toLowerCase() !== 'optgroup') { 
return ; 
} 
var $option = $(this); 
var option = self.item($option); 
var matches = self.matches(params, option); 
if (matches !== null ) { 
data.push(matches); 
} 
} 
); 
callback({ 
results: data}
); 
} 
; 
SelectAdapter.prototype.addOptions = function ($options){ 
this.$element.append($options); 
} 
; 
SelectAdapter.prototype.option = function (data){ 
var option; 
if (data.children) { 
option = _AN_Call_createelement('createElement', document, 'optgroup'); 
option.label = data.text; 
} 
 else { 
option = _AN_Call_createelement('createElement', document, 'option'); 
if (option.textContent !== undefined) { 
option.textContent = data.text; 
} 
 else { 
option.innerText = data.text; 
} 
} 
if (data.id !== undefined) { 
option.value = data.id; 
} 
if (data.disabled) { 
option.disabled = true ; 
} 
if (data.selected) { 
option.selected = true ; 
} 
if (data.title) { 
option.title = data.title; 
} 
var normalizedData = this._normalizeItem(data); 
normalizedData.element = option; 
Utils.StoreData(option, 'data', normalizedData); 
return $(option); 
} 
; 
SelectAdapter.prototype.item = function ($option){ 
var data = { 
}
; 
data = Utils.GetData($option[0], 'data'); 
if (data != null ) { 
return data; 
} 
var option = $option[0]; 
if (option.tagName.toLowerCase() === 'option') { 
data = { 
id: $option.val(),
text: $option.text(),
disabled: $option.prop('disabled'),
selected: $option.prop('selected'),
title: $option.prop('title')}
; 
} 
 else if (option.tagName.toLowerCase() === 'optgroup') { 
data = { 
text: $option.prop('label'),
children: [] ,
title: $option.prop('title')}
; 
var $children = $option.children('option'); 
var children = [] ; 
for (var c = 0; 
c < _AN_Read_length('length', $children); c++ ){ 
var $child = $($children[c]); 
var child = this.item($child); 
children.push(child); 
} 
data.children = children; 
} 
data = this._normalizeItem(data); 
data.element = $option[0]; 
Utils.StoreData($option[0], 'data', data); 
return data; 
} 
; 
SelectAdapter.prototype._normalizeItem = function (item){ 
if (item !== Object(item)) { 
item = { 
id: item,
text: item}
; 
} 
item = $.extend({ 
}
, { 
text: ''}
, item); 
var defaults = { 
selected: false ,
disabled: false }
; 
if (item.id != null ) { 
item.id = item.id.toString(); 
} 
if (item.text != null ) { 
_AN_Write_text('text', item, false , item.text.toString()); 
} 
if (item._resultId == null  && item.id && this.container != null ) { 
item._resultId = this.generateResultId(this.container, item); 
} 
return $.extend({ 
}
, defaults, item); 
} 
; 
SelectAdapter.prototype.matches = function (params, data){ 
var matcher = this.options.get('matcher'); 
return matcher(params, data); 
} 
; 
return SelectAdapter; 
} 
); 
S2.define('select2/data/array', ['./select', '../utils', 'jquery'] , function (SelectAdapter, Utils, $){ 
function ArrayAdapter($element, options){ 
this._dataToConvert = options.get('data') || [] ; 
ArrayAdapter.__super__.constructor.call(this, $element, options); 
} 
Utils.Extend(ArrayAdapter, SelectAdapter); 
ArrayAdapter.prototype.bind = function (container, $container){ 
ArrayAdapter.__super__.bind.call(this, container, $container); 
this.addOptions(this.convertToOptions(this._dataToConvert)); 
} 
; 
ArrayAdapter.prototype.select = function (data){ 
var $option = this.$element.find('option').filter(function (i, elm){ 
return elm.value == data.id.toString(); 
} 
); 
if (_AN_Read_length('length', $option) === 0) { 
$option = this.option(data); 
this.addOptions($option); 
} 
ArrayAdapter.__super__.select.call(this, data); 
} 
; 
ArrayAdapter.prototype.convertToOptions = function (data){ 
var self = this; 
var $existing = this.$element.find('option'); 
var existingIds = $existing.map(function (){ 
return self.item($(this)).id; 
} 
).get(); 
var $options = [] ; 
function onlyItem(item){ 
return function (){ 
return $(this).val() == item.id; 
} 
; 
} 
for (var d = 0; 
d < _AN_Read_length('length', data); d++ ){ 
var item = this._normalizeItem(data[d]); 
if (existingIds.indexOf(item.id) >= 0) { 
var $existingOption = $existing.filter(onlyItem(item)); 
var existingData = this.item($existingOption); 
var newData = $.extend(true , { 
}
, item, existingData); 
var $newOption = this.option(newData); 
$existingOption.replaceWith($newOption); 
continue ; 
} 
var $option = this.option(item); 
if (item.children) { 
var $children = this.convertToOptions(item.children); 
$option.append($children); 
} 
$options.push($option); 
} 
return $options; 
} 
; 
return ArrayAdapter; 
} 
); 
S2.define('select2/data/ajax', ['./array', '../utils', 'jquery'] , function (ArrayAdapter, Utils, $){ 
function AjaxAdapter($element, options){ 
this.ajaxOptions = this._applyDefaults(options.get('ajax')); 
if (this.ajaxOptions.processResults != null ) { 
this.processResults = this.ajaxOptions.processResults; 
} 
AjaxAdapter.__super__.constructor.call(this, $element, options); 
} 
Utils.Extend(AjaxAdapter, ArrayAdapter); 
AjaxAdapter.prototype._applyDefaults = function (options){ 
var defaults = { 
data: function (params){ 
return $.extend({ 
}
, params, { 
q: params.term}
); 
} 
,
transport: function (params, success, failure){ 
var $request = $.ajax(params); 
$request.then(success); 
$request.fail(failure); 
return $request; 
} 
}
; 
return $.extend({ 
}
, defaults, options, true ); 
} 
; 
AjaxAdapter.prototype.processResults = function (results){ 
return results; 
} 
; 
AjaxAdapter.prototype.query = function (params, callback){ 
var matches = [] ; 
var self = this; 
if (this._request != null ) { 
if (typeof this._request.abort === 'function') { 
this._request.abort(); 
} 
this._request = null ; 
} 
var options = $.extend({ 
type: 'GET'}
, this.ajaxOptions); 
if (typeof _AN_Read_url('url', options) === 'function') { 
_AN_Write_url('url', options, false , _AN_Read_url('url', options).call(this.$element, params)); 
} 
if (typeof options.data === 'function') { 
options.data = options.data.call(this.$element, params); 
} 
function request(){ 
var $request = options.transport(options, function (data){ 
var results = self.processResults(data, params); 
if (self.options.get('debug') && window.console && console.error) { 
if (!results || !results.results || !Array.isArray(results.results)) { 
console.error('Select2: The AJAX results did not return an array in the ' + '`results` key of the response.'); 
} 
} 
callback(results); 
} 
, function (){ 
if ('status' in $request && ($request.status === 0 || $request.status === '0')) { 
return ; 
} 
self.trigger('results:message', { 
message: 'errorLoading'}
); 
} 
); 
self._request = $request; 
} 
if (this.ajaxOptions.delay && params.term != null ) { 
if (this._queryTimeout) { 
window.clearTimeout(this._queryTimeout); 
} 
this._queryTimeout = _AN_Call_settimeout('setTimeout', window, request, this.ajaxOptions.delay); 
} 
 else { 
request(); 
} 
} 
; 
return AjaxAdapter; 
} 
); 
S2.define('select2/data/tags', ['jquery'] , function ($){ 
function Tags(decorated, $element, options){ 
var tags = options.get('tags'); 
var createTag = options.get('createTag'); 
if (createTag !== undefined) { 
this.createTag = createTag; 
} 
var insertTag = options.get('insertTag'); 
if (insertTag !== undefined) { 
this.insertTag = insertTag; 
} 
decorated.call(this, $element, options); 
if (Array.isArray(tags)) { 
for (var t = 0; 
t < _AN_Read_length('length', tags); t++ ){ 
var tag = tags[t]; 
var item = this._normalizeItem(tag); 
var $option = this.option(item); 
this.$element.append($option); 
} 
} 
} 
Tags.prototype.query = function (decorated, params, callback){ 
var self = this; 
this._removeOldTags(); 
if (params.term == null  || params.page != null ) { 
decorated.call(this, params, callback); 
return ; 
} 
function wrapper(obj, child){ 
var data = obj.results; 
for (var i = 0; 
i < _AN_Read_length('length', data); i++ ){ 
var option = data[i]; 
var checkChildren = (option.children != null  && !wrapper({ 
results: option.children}
, true )); 
var optionText = (option.text || '').toUpperCase(); 
var paramsTerm = (params.term || '').toUpperCase(); 
var checkText = optionText === paramsTerm; 
if (checkText || checkChildren) { 
if (child) { 
return false ; 
} 
obj.data = data; 
callback(obj); 
return ; 
} 
} 
if (child) { 
return true ; 
} 
var tag = self.createTag(params); 
if (tag != null ) { 
var $option = self.option(tag); 
$option.attr('data-select2-tag', 'true'); 
self.addOptions([$option] ); 
self.insertTag(data, tag); 
} 
obj.results = data; 
callback(obj); 
} 
decorated.call(this, params, wrapper); 
} 
; 
Tags.prototype.createTag = function (decorated, params){ 
if (params.term == null ) { 
return null ; 
} 
var term = params.term.trim(); 
if (term === '') { 
return null ; 
} 
return { 
id: term,
text: term}
; 
} 
; 
Tags.prototype.insertTag = function (_, data, tag){ 
data.unshift(tag); 
} 
; 
Tags.prototype._removeOldTags = function (_){ 
var $options = this.$element.find('option[data-select2-tag]'); 
$options.each(function (){ 
if (this.selected) { 
return ; 
} 
$(this).remove(); 
} 
); 
} 
; 
return Tags; 
} 
); 
S2.define('select2/data/tokenizer', ['jquery'] , function ($){ 
function Tokenizer(decorated, $element, options){ 
var tokenizer = options.get('tokenizer'); 
if (tokenizer !== undefined) { 
this.tokenizer = tokenizer; 
} 
decorated.call(this, $element, options); 
} 
Tokenizer.prototype.bind = function (decorated, container, $container){ 
decorated.call(this, container, $container); 
this.$search = container.dropdown.$search || container.selection.$search || $container.find('.select2-search__field'); 
} 
; 
Tokenizer.prototype.query = function (decorated, params, callback){ 
var self = this; 
function createAndSelect(data){ 
var item = self._normalizeItem(data); 
var $existingOptions = self.$element.find('option').filter(function (){ 
return $(this).val() === item.id; 
} 
); 
if (!_AN_Read_length('length', $existingOptions)) { 
var $option = self.option(item); 
$option.attr('data-select2-tag', true ); 
self._removeOldTags(); 
self.addOptions([$option] ); 
} 
select(item); 
} 
function select(data){ 
self.trigger('select', { 
data: data}
); 
} 
params.term = params.term || ''; 
var tokenData = this.tokenizer(params, this.options, createAndSelect); 
if (tokenData.term !== params.term) { 
if (this.$search.length) { 
this.$search.val(tokenData.term); 
this.$search.trigger('focus'); 
} 
params.term = tokenData.term; 
} 
decorated.call(this, params, callback); 
} 
; 
Tokenizer.prototype.tokenizer = function (_, params, options, callback){ 
var separators = options.get('tokenSeparators') || [] ; 
var term = params.term; 
var i = 0; 
var createTag = this.createTag || function (params){ 
return { 
id: params.term,
text: params.term}
; 
} 
; 
while (i < _AN_Read_length('length', term)){ 
var termChar = term[i]; 
if (separators.indexOf(termChar) === -1) { 
i++ ; 
continue ; 
} 
var part = term.substr(0, i); 
var partParams = $.extend({ 
}
, params, { 
term: part}
); 
var data = createTag(partParams); 
if (data == null ) { 
i++ ; 
continue ; 
} 
callback(data); 
term = term.substr(i + 1) || ''; 
i = 0; 
} 
return { 
term: term}
; 
} 
; 
return Tokenizer; 
} 
); 
S2.define('select2/data/minimumInputLength', [] , function (){ 
function MinimumInputLength(decorated, $e, options){ 
this.minimumInputLength = options.get('minimumInputLength'); 
decorated.call(this, $e, options); 
} 
MinimumInputLength.prototype.query = function (decorated, params, callback){ 
params.term = params.term || ''; 
if (_AN_Read_length('length', params.term) < this.minimumInputLength) { 
this.trigger('results:message', { 
message: 'inputTooShort',
args: { 
minimum: this.minimumInputLength,
input: params.term,
params: params}
}
); 
return ; 
} 
decorated.call(this, params, callback); 
} 
; 
return MinimumInputLength; 
} 
); 
S2.define('select2/data/maximumInputLength', [] , function (){ 
function MaximumInputLength(decorated, $e, options){ 
this.maximumInputLength = options.get('maximumInputLength'); 
decorated.call(this, $e, options); 
} 
MaximumInputLength.prototype.query = function (decorated, params, callback){ 
params.term = params.term || ''; 
if (this.maximumInputLength > 0 && _AN_Read_length('length', params.term) > this.maximumInputLength) { 
this.trigger('results:message', { 
message: 'inputTooLong',
args: { 
maximum: this.maximumInputLength,
input: params.term,
params: params}
}
); 
return ; 
} 
decorated.call(this, params, callback); 
} 
; 
return MaximumInputLength; 
} 
); 
S2.define('select2/data/maximumSelectionLength', [] , function (){ 
function MaximumSelectionLength(decorated, $e, options){ 
this.maximumSelectionLength = options.get('maximumSelectionLength'); 
decorated.call(this, $e, options); 
} 
MaximumSelectionLength.prototype.bind = function (decorated, container, $container){ 
var self = this; 
decorated.call(this, container, $container); 
container.on('select', function (){ 
self._checkIfMaximumSelected(); 
} 
); 
} 
; 
MaximumSelectionLength.prototype.query = function (decorated, params, callback){ 
var self = this; 
this._checkIfMaximumSelected(function (){ 
decorated.call(self, params, callback); 
} 
); 
} 
; 
MaximumSelectionLength.prototype._checkIfMaximumSelected = function (_, successCallback){ 
var self = this; 
this.current(function (currentData){ 
var count = currentData != null ? _AN_Read_length('length', currentData): 0; 
if (self.maximumSelectionLength > 0 && count >= self.maximumSelectionLength) { 
self.trigger('results:message', { 
message: 'maximumSelected',
args: { 
maximum: self.maximumSelectionLength}
}
); 
return ; 
} 
if (successCallback) { 
successCallback(); 
} 
} 
); 
} 
; 
return MaximumSelectionLength; 
} 
); 
S2.define('select2/dropdown', ['jquery', './utils'] , function ($, Utils){ 
function Dropdown($element, options){ 
this.$element = $element; 
this.options = options; 
Dropdown.__super__.constructor.call(this); 
} 
Utils.Extend(Dropdown, Utils.Observable); 
Dropdown.prototype.render = function (){ 
var $dropdown = $('<span class="select2-dropdown">' + '<span class="select2-results"></span>' + '</span>'); 
$dropdown.attr('dir', this.options.get('dir')); 
this.$dropdown = $dropdown; 
return $dropdown; 
} 
; 
Dropdown.prototype.bind = function (){ 
} 
; 
Dropdown.prototype.position = function ($dropdown, $container){ 
} 
; 
Dropdown.prototype.destroy = function (){ 
this.$dropdown.remove(); 
} 
; 
return Dropdown; 
} 
); 
S2.define('select2/dropdown/search', ['jquery'] , function ($){ 
function Search(){ 
} 
Search.prototype.render = function (decorated){ 
var $rendered = decorated.call(this); 
var searchLabel = this.options.get('translations').get('search'); 
var $search = $('<span class="select2-search select2-search--dropdown">' + '<input class="select2-search__field" type="search" tabindex="-1"' + ' autocorrect="off" autocapitalize="none"' + ' spellcheck="false" role="searchbox" aria-autocomplete="list" />' + '</span>'); 
this.$searchContainer = $search; 
this.$search = $search.find('input'); 
this.$search.prop('autocomplete', this.options.get('autocomplete')); 
this.$search.attr('aria-label', searchLabel()); 
$rendered.prepend($search); 
return $rendered; 
} 
; 
Search.prototype.bind = function (decorated, container, $container){ 
var self = this; 
var resultsId = container.id + '-results'; 
decorated.call(this, container, $container); 
this.$search.on('keydown', function (evt){ 
self.trigger('keypress', evt); 
self._keyUpPrevented = evt.isDefaultPrevented(); 
} 
); 
this.$search.on('input', function (evt){ 
$(this).off('keyup'); 
} 
); 
this.$search.on('keyup input', function (evt){ 
self.handleSearch(evt); 
} 
); 
container.on('open', function (){ 
self.$search.attr('tabindex', 0); 
self.$search.attr('aria-controls', resultsId); 
self.$search.trigger('focus'); 
_AN_Call_settimeout('setTimeout', window, function (){ 
self.$search.trigger('focus'); 
} 
, 0); 
} 
); 
container.on('close', function (){ 
self.$search.attr('tabindex', -1); 
self.$search.removeAttr('aria-controls'); 
self.$search.removeAttr('aria-activedescendant'); 
self.$search.val(''); 
self.$search.trigger('blur'); 
} 
); 
container.on('focus', function (){ 
if (!container.isOpen()) { 
self.$search.trigger('focus'); 
} 
} 
); 
container.on('results:all', function (params){ 
if (params.query.term == null  || params.query.term === '') { 
var showSearch = self.showSearch(params); 
if (showSearch) { 
self.$searchContainer[0].classList.remove('select2-search--hide'); 
} 
 else { 
self.$searchContainer[0].classList.add('select2-search--hide'); 
} 
} 
} 
); 
container.on('results:focus', function (params){ 
if (params.data._resultId) { 
self.$search.attr('aria-activedescendant', params.data._resultId); 
} 
 else { 
self.$search.removeAttr('aria-activedescendant'); 
} 
} 
); 
} 
; 
Search.prototype.handleSearch = function (evt){ 
if (!this._keyUpPrevented) { 
var input = this.$search.val(); 
this.trigger('query', { 
term: input}
); 
} 
this._keyUpPrevented = false ; 
} 
; 
Search.prototype.showSearch = function (_, params){ 
return true ; 
} 
; 
return Search; 
} 
); 
S2.define('select2/dropdown/hidePlaceholder', [] , function (){ 
function HidePlaceholder(decorated, $element, options, dataAdapter){ 
this.placeholder = this.normalizePlaceholder(options.get('placeholder')); 
decorated.call(this, $element, options, dataAdapter); 
} 
HidePlaceholder.prototype.append = function (decorated, data){ 
data.results = this.removePlaceholder(data.results); 
decorated.call(this, data); 
} 
; 
HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder){ 
if (typeof placeholder === 'string') { 
placeholder = { 
id: '',
text: placeholder}
; 
} 
return placeholder; 
} 
; 
HidePlaceholder.prototype.removePlaceholder = function (_, data){ 
var modifiedData = data.slice(0); 
for (var d = _AN_Read_length('length', data) - 1; 
d >= 0; d-- ){ 
var item = data[d]; 
if (this.placeholder.id === item.id) { 
modifiedData.splice(d, 1); 
} 
} 
return modifiedData; 
} 
; 
return HidePlaceholder; 
} 
); 
S2.define('select2/dropdown/infiniteScroll', ['jquery'] , function ($){ 
function InfiniteScroll(decorated, $element, options, dataAdapter){ 
this.lastParams = { 
}
; 
decorated.call(this, $element, options, dataAdapter); 
this.$loadingMore = this.createLoadingMore(); 
this.loading = false ; 
} 
InfiniteScroll.prototype.append = function (decorated, data){ 
this.$loadingMore.remove(); 
this.loading = false ; 
decorated.call(this, data); 
if (this.showLoadingMore(data)) { 
this.$results.append(this.$loadingMore); 
this.loadMoreIfNeeded(); 
} 
} 
; 
InfiniteScroll.prototype.bind = function (decorated, container, $container){ 
var self = this; 
decorated.call(this, container, $container); 
container.on('query', function (params){ 
self.lastParams = params; 
self.loading = true ; 
} 
); 
container.on('query:append', function (params){ 
self.lastParams = params; 
self.loading = true ; 
} 
); 
this.$results.on('scroll', this.loadMoreIfNeeded.bind(this)); 
} 
; 
InfiniteScroll.prototype.loadMoreIfNeeded = function (){ 
var isLoadMoreVisible = $.contains(document.documentElement, this.$loadingMore[0]); 
if (this.loading || !isLoadMoreVisible) { 
return ; 
} 
var currentOffset = this.$results.offset().top + this.$results.outerHeight(false ); 
var loadingMoreOffset = this.$loadingMore.offset().top + this.$loadingMore.outerHeight(false ); 
if (currentOffset + 50 >= loadingMoreOffset) { 
this.loadMore(); 
} 
} 
; 
InfiniteScroll.prototype.loadMore = function (){ 
this.loading = true ; 
var params = $.extend({ 
}
, { 
page: 1}
, this.lastParams); 
params.page++ ; 
this.trigger('query:append', params); 
} 
; 
InfiniteScroll.prototype.showLoadingMore = function (_, data){ 
return data.pagination && data.pagination.more; 
} 
; 
InfiniteScroll.prototype.createLoadingMore = function (){ 
var $option = $('<li ' + 'class="select2-results__option select2-results__option--load-more"' + 'role="option" aria-disabled="true"></li>'); 
var message = this.options.get('translations').get('loadingMore'); 
$option.html(message(this.lastParams)); 
return $option; 
} 
; 
return InfiniteScroll; 
} 
); 
S2.define('select2/dropdown/attachBody', ['jquery', '../utils'] , function ($, Utils){ 
function AttachBody(decorated, $element, options){ 
this.$dropdownParent = $(options.get('dropdownParent') || document.body); 
decorated.call(this, $element, options); 
} 
AttachBody.prototype.bind = function (decorated, container, $container){ 
var self = this; 
decorated.call(this, container, $container); 
container.on('open', function (){ 
self._showDropdown(); 
self._attachPositioningHandler(container); 
self._bindContainerResultHandlers(container); 
} 
); 
container.on('close', function (){ 
self._hideDropdown(); 
self._detachPositioningHandler(container); 
} 
); 
this.$dropdownContainer.on('mousedown', function (evt){ 
evt.stopPropagation(); 
} 
); 
} 
; 
AttachBody.prototype.destroy = function (decorated){ 
decorated.call(this); 
this.$dropdownContainer.remove(); 
} 
; 
AttachBody.prototype.position = function (decorated, $dropdown, $container){ 
$dropdown.attr('class', $container.attr('class')); 
$dropdown[0].classList.remove('select2'); 
$dropdown[0].classList.add('select2-container--open'); 
$dropdown.css({ 
position: 'absolute',
top: -999999}
); 
this.$container = $container; 
} 
; 
AttachBody.prototype.render = function (decorated){ 
var $container = $('<span></span>'); 
var $dropdown = decorated.call(this); 
$container.append($dropdown); 
this.$dropdownContainer = $container; 
return $container; 
} 
; 
AttachBody.prototype._hideDropdown = function (decorated){ 
this.$dropdownContainer.detach(); 
} 
; 
AttachBody.prototype._bindContainerResultHandlers = function (decorated, container){ 
if (this._containerResultsHandlersBound) { 
return ; 
} 
var self = this; 
container.on('results:all', function (){ 
self._positionDropdown(); 
self._resizeDropdown(); 
} 
); 
container.on('results:append', function (){ 
self._positionDropdown(); 
self._resizeDropdown(); 
} 
); 
container.on('results:message', function (){ 
self._positionDropdown(); 
self._resizeDropdown(); 
} 
); 
container.on('select', function (){ 
self._positionDropdown(); 
self._resizeDropdown(); 
} 
); 
container.on('unselect', function (){ 
self._positionDropdown(); 
self._resizeDropdown(); 
} 
); 
this._containerResultsHandlersBound = true ; 
} 
; 
AttachBody.prototype._attachPositioningHandler = function (decorated, container){ 
var self = this; 
var scrollEvent = 'scroll.select2.' + container.id; 
var resizeEvent = 'resize.select2.' + container.id; 
var orientationEvent = 'orientationchange.select2.' + container.id; 
var $watchers = this.$container.parents().filter(Utils.hasScroll); 
$watchers.each(function (){ 
Utils.StoreData(this, 'select2-scroll-position', { 
x: $(this).scrollLeft(),
y: $(this).scrollTop()}
); 
} 
); 
$watchers.on(scrollEvent, function (ev){ 
var position = Utils.GetData(this, 'select2-scroll-position'); 
$(this).scrollTop(position.y); 
} 
); 
$(window).on(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent, function (e){ 
self._positionDropdown(); 
self._resizeDropdown(); 
} 
); 
} 
; 
AttachBody.prototype._detachPositioningHandler = function (decorated, container){ 
var scrollEvent = 'scroll.select2.' + container.id; 
var resizeEvent = 'resize.select2.' + container.id; 
var orientationEvent = 'orientationchange.select2.' + container.id; 
var $watchers = this.$container.parents().filter(Utils.hasScroll); 
$watchers.off(scrollEvent); 
$(window).off(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent); 
} 
; 
AttachBody.prototype._positionDropdown = function (){ 
var $window = $(window); 
var isCurrentlyAbove = this.$dropdown[0].classList.contains('select2-dropdown--above'); 
var isCurrentlyBelow = this.$dropdown[0].classList.contains('select2-dropdown--below'); 
var newDirection = null ; 
var offset = this.$container.offset(); 
offset.bottom = offset.top + this.$container.outerHeight(false ); 
var container = { 
height: this.$container.outerHeight(false )}
; 
container.top = offset.top; 
container.bottom = offset.top + container.height; 
var dropdown = { 
height: this.$dropdown.outerHeight(false )}
; 
var viewport = { 
top: $window.scrollTop(),
bottom: $window.scrollTop() + $window.height()}
; 
var enoughRoomAbove = viewport.top < (offset.top - dropdown.height); 
var enoughRoomBelow = viewport.bottom > (offset.bottom + dropdown.height); 
var css = { 
left: offset.left,
top: container.bottom}
; 
var $offsetParent = this.$dropdownParent; 
if ($offsetParent.css('position') === 'static') { 
$offsetParent = $offsetParent.offsetParent(); 
} 
var parentOffset = { 
top: 0,
left: 0}
; 
if ($.contains(document.body, $offsetParent[0]) || $offsetParent[0].isConnected) { 
parentOffset = $offsetParent.offset(); 
} 
css.top -= parentOffset.top; 
css.left -= parentOffset.left; 
if (!isCurrentlyAbove && !isCurrentlyBelow) { 
newDirection = 'below'; 
} 
if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) { 
newDirection = 'above'; 
} 
 else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) { 
newDirection = 'below'; 
} 
if (newDirection == 'above' || (isCurrentlyAbove && newDirection !== 'below')) { 
css.top = container.top - parentOffset.top - dropdown.height; 
} 
if (newDirection != null ) { 
this.$dropdown[0].classList.remove('select2-dropdown--below'); 
this.$dropdown[0].classList.remove('select2-dropdown--above'); 
this.$dropdown[0].classList.add('select2-dropdown--' + newDirection); 
this.$container[0].classList.remove('select2-container--below'); 
this.$container[0].classList.remove('select2-container--above'); 
this.$container[0].classList.add('select2-container--' + newDirection); 
} 
this.$dropdownContainer.css(css); 
} 
; 
AttachBody.prototype._resizeDropdown = function (){ 
var css = { 
width: this.$container.outerWidth(false ) + 'px'}
; 
if (this.options.get('dropdownAutoWidth')) { 
css.minWidth = css.width; 
css.position = 'relative'; 
css.width = 'auto'; 
} 
this.$dropdown.css(css); 
} 
; 
AttachBody.prototype._showDropdown = function (decorated){ 
this.$dropdownContainer.appendTo(this.$dropdownParent); 
this._positionDropdown(); 
this._resizeDropdown(); 
} 
; 
return AttachBody; 
} 
); 
S2.define('select2/dropdown/minimumResultsForSearch', [] , function (){ 
function countResults(data){ 
var count = 0; 
for (var d = 0; 
d < _AN_Read_length('length', data); d++ ){ 
var item = data[d]; 
if (item.children) { 
count += countResults(item.children); 
} 
 else { 
count++ ; 
} 
} 
return count; 
} 
function MinimumResultsForSearch(decorated, $element, options, dataAdapter){ 
this.minimumResultsForSearch = options.get('minimumResultsForSearch'); 
if (this.minimumResultsForSearch < 0) { 
this.minimumResultsForSearch = Infinity; 
} 
decorated.call(this, $element, options, dataAdapter); 
} 
MinimumResultsForSearch.prototype.showSearch = function (decorated, params){ 
if (countResults(params.data.results) < this.minimumResultsForSearch) { 
return false ; 
} 
return decorated.call(this, params); 
} 
; 
return MinimumResultsForSearch; 
} 
); 
S2.define('select2/dropdown/selectOnClose', ['../utils'] , function (Utils){ 
function SelectOnClose(){ 
} 
SelectOnClose.prototype.bind = function (decorated, container, $container){ 
var self = this; 
decorated.call(this, container, $container); 
container.on('close', function (params){ 
self._handleSelectOnClose(params); 
} 
); 
} 
; 
SelectOnClose.prototype._handleSelectOnClose = function (_, params){ 
if (params && params.originalSelect2Event != null ) { 
var event = params.originalSelect2Event; 
if (event._type === 'select' || event._type === 'unselect') { 
return ; 
} 
} 
var $highlightedResults = this.getHighlightedResults(); 
if (_AN_Read_length('length', $highlightedResults) < 1) { 
return ; 
} 
var data = Utils.GetData($highlightedResults[0], 'data'); 
if ((data.element != null  && data.element.selected) || (data.element == null  && data.selected)) { 
return ; 
} 
this.trigger('select', { 
data: data}
); 
} 
; 
return SelectOnClose; 
} 
); 
S2.define('select2/dropdown/closeOnSelect', [] , function (){ 
function CloseOnSelect(){ 
} 
CloseOnSelect.prototype.bind = function (decorated, container, $container){ 
var self = this; 
decorated.call(this, container, $container); 
container.on('select', function (evt){ 
self._selectTriggered(evt); 
} 
); 
container.on('unselect', function (evt){ 
self._selectTriggered(evt); 
} 
); 
} 
; 
CloseOnSelect.prototype._selectTriggered = function (_, evt){ 
var originalEvent = evt.originalEvent; 
if (originalEvent && (originalEvent.ctrlKey || originalEvent.metaKey)) { 
return ; 
} 
this.trigger('close', { 
originalEvent: originalEvent,
originalSelect2Event: evt}
); 
} 
; 
return CloseOnSelect; 
} 
); 
S2.define('select2/dropdown/dropdownCss', ['../utils'] , function (Utils){ 
function DropdownCSS(){ 
} 
DropdownCSS.prototype.render = function (decorated){ 
var $dropdown = decorated.call(this); 
var dropdownCssClass = this.options.get('dropdownCssClass') || ''; 
if (dropdownCssClass.indexOf(':all:') !== -1) { 
dropdownCssClass = _AN_Call_replace('replace', dropdownCssClass, ':all:', ''); 
Utils.copyNonInternalCssClasses($dropdown[0], this.$element[0]); 
} 
$dropdown.addClass(dropdownCssClass); 
return $dropdown; 
} 
; 
return DropdownCSS; 
} 
); 
S2.define('select2/dropdown/tagsSearchHighlight', ['../utils'] , function (Utils){ 
function TagsSearchHighlight(){ 
} 
TagsSearchHighlight.prototype.highlightFirstItem = function (decorated){ 
var $options = this.$results.find('.select2-results__option--selectable' + ':not(.select2-results__option--selected)'); 
if (_AN_Read_length('length', $options) > 0) { 
var $firstOption = $options.first(); 
var data = Utils.GetData($firstOption[0], 'data'); 
var firstElement = data.element; 
if (firstElement && firstElement.getAttribute) { 
if (_AN_Call_getattribute('getAttribute', firstElement, 'data-select2-tag') === 'true') { 
$firstOption.trigger('mouseenter'); 
return ; 
} 
} 
} 
decorated.call(this); 
} 
; 
return TagsSearchHighlight; 
} 
); 
S2.define('select2/i18n/en', [] , function (){ 
return { 
errorLoading: function (){ 
return 'The results could not be loaded.'; 
} 
,
inputTooLong: function (args){ 
var overChars = _AN_Read_length('length', args.input) - args.maximum; 
var message = 'Please delete ' + overChars + ' character'; 
if (overChars != 1) { 
message += 's'; 
} 
return message; 
} 
,
inputTooShort: function (args){ 
var remainingChars = args.minimum - _AN_Read_length('length', args.input); 
var message = 'Please enter ' + remainingChars + ' or more characters'; 
return message; 
} 
,
loadingMore: function (){ 
return 'Loading more results…'; 
} 
,
maximumSelected: function (args){ 
var message = 'You can only select ' + args.maximum + ' item'; 
if (args.maximum != 1) { 
message += 's'; 
} 
return message; 
} 
,
noResults: function (){ 
return 'No results found'; 
} 
,
searching: function (){ 
return 'Searching…'; 
} 
,
removeAllItems: function (){ 
return 'Remove all items'; 
} 
,
removeItem: function (){ 
return 'Remove item'; 
} 
,
search: function (){ 
return 'Search'; 
} 
}
; 
} 
); 
S2.define('select2/defaults', ['jquery', './results', './selection/single', './selection/multiple', './selection/placeholder', './selection/allowClear', './selection/search', './selection/selectionCss', './selection/eventRelay', './utils', './translation', './diacritics', './data/select', './data/array', './data/ajax', './data/tags', './data/tokenizer', './data/minimumInputLength', './data/maximumInputLength', './data/maximumSelectionLength', './dropdown', './dropdown/search', './dropdown/hidePlaceholder', './dropdown/infiniteScroll', './dropdown/attachBody', './dropdown/minimumResultsForSearch', './dropdown/selectOnClose', './dropdown/closeOnSelect', './dropdown/dropdownCss', './dropdown/tagsSearchHighlight', './i18n/en'] , function ($, ResultsList, SingleSelection, MultipleSelection, Placeholder, AllowClear, SelectionSearch, SelectionCSS, EventRelay, Utils, Translation, DIACRITICS, SelectData, ArrayData, AjaxData, Tags, Tokenizer, MinimumInputLength, MaximumInputLength, MaximumSelectionLength, Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll, AttachBody, MinimumResultsForSearch, SelectOnClose, CloseOnSelect, DropdownCSS, TagsSearchHighlight, EnglishTranslation){ 
function Defaults(){ 
this.reset(); 
} 
Defaults.prototype.apply = function (options){ 
options = $.extend(true , { 
}
, this.defaults, options); 
if (options.dataAdapter == null ) { 
if (options.ajax != null ) { 
options.dataAdapter = AjaxData; 
} 
 else if (options.data != null ) { 
options.dataAdapter = ArrayData; 
} 
 else { 
options.dataAdapter = SelectData; 
} 
if (options.minimumInputLength > 0) { 
options.dataAdapter = Utils.Decorate(options.dataAdapter, MinimumInputLength); 
} 
if (options.maximumInputLength > 0) { 
options.dataAdapter = Utils.Decorate(options.dataAdapter, MaximumInputLength); 
} 
if (options.maximumSelectionLength > 0) { 
options.dataAdapter = Utils.Decorate(options.dataAdapter, MaximumSelectionLength); 
} 
if (options.tags) { 
options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags); 
} 
if (options.tokenSeparators != null  || options.tokenizer != null ) { 
options.dataAdapter = Utils.Decorate(options.dataAdapter, Tokenizer); 
} 
} 
if (options.resultsAdapter == null ) { 
options.resultsAdapter = ResultsList; 
if (options.ajax != null ) { 
options.resultsAdapter = Utils.Decorate(options.resultsAdapter, InfiniteScroll); 
} 
if (options.placeholder != null ) { 
options.resultsAdapter = Utils.Decorate(options.resultsAdapter, HidePlaceholder); 
} 
if (options.selectOnClose) { 
options.resultsAdapter = Utils.Decorate(options.resultsAdapter, SelectOnClose); 
} 
if (options.tags) { 
options.resultsAdapter = Utils.Decorate(options.resultsAdapter, TagsSearchHighlight); 
} 
} 
if (options.dropdownAdapter == null ) { 
if (options.multiple) { 
options.dropdownAdapter = Dropdown; 
} 
 else { 
var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch); 
options.dropdownAdapter = SearchableDropdown; 
} 
if (options.minimumResultsForSearch !== 0) { 
options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, MinimumResultsForSearch); 
} 
if (options.closeOnSelect) { 
options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, CloseOnSelect); 
} 
if (options.dropdownCssClass != null ) { 
options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, DropdownCSS); 
} 
options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, AttachBody); 
} 
if (options.selectionAdapter == null ) { 
if (options.multiple) { 
options.selectionAdapter = MultipleSelection; 
} 
 else { 
options.selectionAdapter = SingleSelection; 
} 
if (options.placeholder != null ) { 
options.selectionAdapter = Utils.Decorate(options.selectionAdapter, Placeholder); 
} 
if (options.allowClear) { 
options.selectionAdapter = Utils.Decorate(options.selectionAdapter, AllowClear); 
} 
if (options.multiple) { 
options.selectionAdapter = Utils.Decorate(options.selectionAdapter, SelectionSearch); 
} 
if (options.selectionCssClass != null ) { 
options.selectionAdapter = Utils.Decorate(options.selectionAdapter, SelectionCSS); 
} 
options.selectionAdapter = Utils.Decorate(options.selectionAdapter, EventRelay); 
} 
options.language = this._resolveLanguage(options.language); 
options.language.push('en'); 
var uniqueLanguages = [] ; 
for (var l = 0; 
l < _AN_Read_length('length', options.language); l++ ){ 
var language = options.language[l]; 
if (uniqueLanguages.indexOf(language) === -1) { 
uniqueLanguages.push(language); 
} 
} 
options.language = uniqueLanguages; 
options.translations = this._processTranslations(options.language, options.debug); 
return options; 
} 
; 
Defaults.prototype.reset = function (){ 
function stripDiacritics(text){ 
function match(a){ 
return DIACRITICS[a] || a; 
} 
return _AN_Call_replace('replace', text, /[^\u0000-\u007E]/g, match); 
} 
function matcher(params, data){ 
if (params.term == null  || params.term.trim() === '') { 
return data; 
} 
if (data.children && _AN_Read_length('length', data.children) > 0) { 
var match = $.extend(true , { 
}
, data); 
for (var c = _AN_Read_length('length', data.children) - 1; 
c >= 0; c-- ){ 
var child = data.children[c]; 
var matches = matcher(params, child); 
if (matches == null ) { 
match.children.splice(c, 1); 
} 
} 
if (_AN_Read_length('length', match.children) > 0) { 
return match; 
} 
return matcher(params, match); 
} 
var original = stripDiacritics(data.text).toUpperCase(); 
var term = stripDiacritics(params.term).toUpperCase(); 
if (original.indexOf(term) > -1) { 
return data; 
} 
return null ; 
} 
this.defaults = { 
amdLanguageBase: './i18n/',
autocomplete: 'off',
closeOnSelect: true ,
debug: false ,
dropdownAutoWidth: false ,
escapeMarkup: Utils.escapeMarkup,
language: { 
}
,
matcher: matcher,
minimumInputLength: 0,
maximumInputLength: 0,
maximumSelectionLength: 0,
minimumResultsForSearch: 0,
selectOnClose: false ,
scrollAfterSelect: false ,
sorter: function (data){ 
return data; 
} 
,
templateResult: function (result){ 
return result.text; 
} 
,
templateSelection: function (selection){ 
return selection.text; 
} 
,
theme: 'default',
width: 'resolve'}
; 
} 
; 
Defaults.prototype.applyFromElement = function (options, $element){ 
var optionLanguage = options.language; 
var defaultLanguage = this.defaults.language; 
var elementLanguage = $element.prop('lang'); 
var parentLanguage = $element.closest('[lang]').prop('lang'); 
var languages = Array.prototype.concat.call(this._resolveLanguage(elementLanguage), this._resolveLanguage(optionLanguage), this._resolveLanguage(defaultLanguage), this._resolveLanguage(parentLanguage)); 
options.language = languages; 
return options; 
} 
; 
Defaults.prototype._resolveLanguage = function (language){ 
if (!language) { 
return [] ; 
} 
if ($.isEmptyObject(language)) { 
return [] ; 
} 
if ($.isPlainObject(language)) { 
return [language] ; 
} 
var languages; 
if (!Array.isArray(language)) { 
languages = [language] ; 
} 
 else { 
languages = language; 
} 
var resolvedLanguages = [] ; 
for (var l = 0; 
l < _AN_Read_length('length', languages); l++ ){ 
resolvedLanguages.push(languages[l]); 
if (typeof languages[l] === 'string' && languages[l].indexOf('-') > 0) { 
var languageParts = languages[l].split('-'); 
var baseLanguage = languageParts[0]; 
resolvedLanguages.push(baseLanguage); 
} 
} 
return resolvedLanguages; 
} 
; 
Defaults.prototype._processTranslations = function (languages, debug){ 
var translations = new Translation(); 
for (var l = 0; 
l < _AN_Read_length('length', languages); l++ ){ 
var languageData = new Translation(); 
var language = languages[l]; 
if (typeof language === 'string') { 
try { 
languageData = Translation.loadPath(language); 
} 
catch (e) { 
try { 
language = this.defaults.amdLanguageBase + language; 
languageData = Translation.loadPath(language); 
} 
catch (ex) { 
if (debug && window.console && console.warn) { 
console.warn('Select2: The language file for "' + language + '" could ' + 'not be automatically loaded. A fallback will be used instead.'); 
} 
} 
} 
} 
 else if ($.isPlainObject(language)) { 
languageData = new Translation(language); 
} 
 else { 
languageData = language; 
} 
translations.extend(languageData); 
} 
return translations; 
} 
; 
Defaults.prototype.set = function (key, value){ 
var camelKey = $.camelCase(key); 
var data = { 
}
; 
data[camelKey] = value; 
var convertedData = Utils._convertData(data); 
$.extend(true , this.defaults, convertedData); 
} 
; 
var defaults = new Defaults(); 
return defaults; 
} 
); 
S2.define('select2/options', ['jquery', './defaults', './utils'] , function ($, Defaults, Utils){ 
function Options(options, $element){ 
this.options = options; 
if ($element != null ) { 
this.fromElement($element); 
} 
if ($element != null ) { 
this.options = Defaults.applyFromElement(this.options, $element); 
} 
this.options = Defaults.apply(this.options); 
} 
Options.prototype.fromElement = function ($e){ 
var excludedData = ['select2'] ; 
if (this.options.multiple == null ) { 
this.options.multiple = $e.prop('multiple'); 
} 
if (this.options.disabled == null ) { 
this.options.disabled = $e.prop('disabled'); 
} 
if (this.options.autocomplete == null  && $e.prop('autocomplete')) { 
this.options.autocomplete = $e.prop('autocomplete'); 
} 
if (this.options.dir == null ) { 
if ($e.prop('dir')) { 
this.options.dir = $e.prop('dir'); 
} 
 else if ($e.closest('[dir]').prop('dir')) { 
this.options.dir = $e.closest('[dir]').prop('dir'); 
} 
 else { 
this.options.dir = 'ltr'; 
} 
} 
$e.prop('disabled', this.options.disabled); 
$e.prop('multiple', this.options.multiple); 
if (Utils.GetData($e[0], 'select2Tags')) { 
if (this.options.debug && window.console && console.warn) { 
console.warn('Select2: The `data-select2-tags` attribute has been changed to ' + 'use the `data-data` and `data-tags="true"` attributes and will be ' + 'removed in future versions of Select2.'); 
} 
Utils.StoreData($e[0], 'data', Utils.GetData($e[0], 'select2Tags')); 
Utils.StoreData($e[0], 'tags', true ); 
} 
if (Utils.GetData($e[0], 'ajaxUrl')) { 
if (this.options.debug && window.console && console.warn) { 
console.warn('Select2: The `data-ajax-url` attribute has been changed to ' + '`data-ajax--url` and support for the old attribute will be removed' + ' in future versions of Select2.'); 
} 
$e.attr('ajax--url', Utils.GetData($e[0], 'ajaxUrl')); 
Utils.StoreData($e[0], 'ajax-Url', Utils.GetData($e[0], 'ajaxUrl')); 
} 
var dataset = { 
}
; 
function upperCaseLetter(_, letter){ 
return letter.toUpperCase(); 
} 
for (var attr = 0; 
attr < _AN_Read_length('length', $e[0].attributes); attr++ ){ 
var attributeName = $e[0].attributes[attr].name; 
var prefix = 'data-'; 
if (attributeName.substr(0, _AN_Read_length('length', prefix)) == prefix) { 
var dataName = attributeName.substring(_AN_Read_length('length', prefix)); 
var dataValue = Utils.GetData($e[0], dataName); 
var camelDataName = _AN_Call_replace('replace', dataName, /-([a-z])/g, upperCaseLetter); 
dataset[camelDataName] = dataValue; 
} 
} 
if ($.fn.jquery && $.fn.jquery.substr(0, 2) == '1.' && $e[0].dataset) { 
dataset = $.extend(true , { 
}
, $e[0].dataset, dataset); 
} 
var data = $.extend(true , { 
}
, Utils.GetData($e[0]), dataset); 
data = Utils._convertData(data); 
for (var key in data){ 
if (excludedData.indexOf(key) > -1) { 
continue ; 
} 
if ($.isPlainObject(this.options[key])) { 
$.extend(this.options[key], data[key]); 
} 
 else { 
this.options[key] = data[key]; 
} 
} 
return this; 
} 
; 
Options.prototype.get = function (key){ 
return this.options[key]; 
} 
; 
Options.prototype.set = function (key, val){ 
this.options[key] = val; 
} 
; 
return Options; 
} 
); 
S2.define('select2/core', ['jquery', './options', './utils', './keys'] , function ($, Options, Utils, KEYS){ 
var Select2 = function ($element, options){ 
if (Utils.GetData($element[0], 'select2') != null ) { 
Utils.GetData($element[0], 'select2').destroy(); 
} 
this.$element = $element; 
this.id = this._generateId($element); 
options = options || { 
}
; 
this.options = new Options(options, $element); 
Select2.__super__.constructor.call(this); 
var tabindex = $element.attr('tabindex') || 0; 
Utils.StoreData($element[0], 'old-tabindex', tabindex); 
$element.attr('tabindex', '-1'); 
var DataAdapter = this.options.get('dataAdapter'); 
this.dataAdapter = new DataAdapter($element, this.options); 
var $container = this.render(); 
this._placeContainer($container); 
var SelectionAdapter = this.options.get('selectionAdapter'); 
this.selection = new SelectionAdapter($element, this.options); 
this.$selection = this.selection.render(); 
this.selection.position(this.$selection, $container); 
var DropdownAdapter = this.options.get('dropdownAdapter'); 
this.dropdown = new DropdownAdapter($element, this.options); 
this.$dropdown = this.dropdown.render(); 
this.dropdown.position(this.$dropdown, $container); 
var ResultsAdapter = this.options.get('resultsAdapter'); 
this.results = new ResultsAdapter($element, this.options, this.dataAdapter); 
this.$results = this.results.render(); 
this.results.position(this.$results, this.$dropdown); 
var self = this; 
this._bindAdapters(); 
this._registerDomEvents(); 
this._registerDataEvents(); 
this._registerSelectionEvents(); 
this._registerDropdownEvents(); 
this._registerResultsEvents(); 
this._registerEvents(); 
this.dataAdapter.current(function (initialData){ 
self.trigger('selection:update', { 
data: initialData}
); 
} 
); 
$element[0].classList.add('select2-hidden-accessible'); 
$element.attr('aria-hidden', 'true'); 
this._syncAttributes(); 
Utils.StoreData($element[0], 'select2', this); 
$element.data('select2', this); 
} 
; 
Utils.Extend(Select2, Utils.Observable); 
Select2.prototype._generateId = function ($element){ 
var id = ''; 
if ($element.attr('id') != null ) { 
id = $element.attr('id'); 
} 
 else if ($element.attr('name') != null ) { 
id = $element.attr('name') + '-' + Utils.generateChars(2); 
} 
 else { 
id = Utils.generateChars(4); 
} 
id = _AN_Call_replace('replace', id, /(:|\.|\[|\]|,)/g, ''); 
id = 'select2-' + id; 
return id; 
} 
; 
Select2.prototype._placeContainer = function ($container){ 
$container.insertAfter(this.$element); 
var width = this._resolveWidth(this.$element, this.options.get('width')); 
if (width != null ) { 
$container.css('width', width); 
} 
} 
; 
Select2.prototype._resolveWidth = function ($element, method){ 
var WIDTH = /^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i; 
if (method == 'resolve') { 
var styleWidth = this._resolveWidth($element, 'style'); 
if (styleWidth != null ) { 
return styleWidth; 
} 
return this._resolveWidth($element, 'element'); 
} 
if (method == 'element') { 
var elementWidth = $element.outerWidth(false ); 
if (elementWidth <= 0) { 
return 'auto'; 
} 
return elementWidth + 'px'; 
} 
if (method == 'style') { 
var style = $element.attr('style'); 
if (typeof (style) !== 'string') { 
return null ; 
} 
var attrs = style.split(';'); 
for (var i = 0, l = _AN_Read_length('length', attrs); 
i < l; i = i + 1){ 
var attr = _AN_Call_replace('replace', attrs[i], /\s/g, ''); 
var matches = attr.match(WIDTH); 
if (matches !== null  && _AN_Read_length('length', matches) >= 1) { 
return matches[1]; 
} 
} 
return null ; 
} 
if (method == 'computedstyle') { 
var computedStyle = window.getComputedStyle($element[0]); 
return computedStyle.width; 
} 
return method; 
} 
; 
Select2.prototype._bindAdapters = function (){ 
this.dataAdapter.bind(this, this.$container); 
this.selection.bind(this, this.$container); 
this.dropdown.bind(this, this.$container); 
this.results.bind(this, this.$container); 
} 
; 
Select2.prototype._registerDomEvents = function (){ 
var self = this; 
this.$element.on('change.select2', function (){ 
self.dataAdapter.current(function (data){ 
self.trigger('selection:update', { 
data: data}
); 
} 
); 
} 
); 
this.$element.on('focus.select2', function (evt){ 
self.trigger('focus', evt); 
} 
); 
this._syncA = Utils.bind(this._syncAttributes, this); 
this._syncS = Utils.bind(this._syncSubtree, this); 
this._observer = new window.MutationObserver(function (mutations){ 
self._syncA(); 
self._syncS(mutations); 
} 
); 
this._observer.observe(this.$element[0], { 
attributes: true ,
childList: true ,
subtree: false }
); 
} 
; 
Select2.prototype._registerDataEvents = function (){ 
var self = this; 
this.dataAdapter.on('*', function (name, params){ 
self.trigger(name, params); 
} 
); 
} 
; 
Select2.prototype._registerSelectionEvents = function (){ 
var self = this; 
var nonRelayEvents = ['toggle', 'focus'] ; 
this.selection.on('toggle', function (){ 
self.toggleDropdown(); 
} 
); 
this.selection.on('focus', function (params){ 
self.focus(params); 
} 
); 
this.selection.on('*', function (name, params){ 
if (nonRelayEvents.indexOf(name) !== -1) { 
return ; 
} 
self.trigger(name, params); 
} 
); 
} 
; 
Select2.prototype._registerDropdownEvents = function (){ 
var self = this; 
this.dropdown.on('*', function (name, params){ 
self.trigger(name, params); 
} 
); 
} 
; 
Select2.prototype._registerResultsEvents = function (){ 
var self = this; 
this.results.on('*', function (name, params){ 
self.trigger(name, params); 
} 
); 
} 
; 
Select2.prototype._registerEvents = function (){ 
var self = this; 
this.on('open', function (){ 
self.$container[0].classList.add('select2-container--open'); 
} 
); 
this.on('close', function (){ 
self.$container[0].classList.remove('select2-container--open'); 
} 
); 
this.on('enable', function (){ 
self.$container[0].classList.remove('select2-container--disabled'); 
} 
); 
this.on('disable', function (){ 
self.$container[0].classList.add('select2-container--disabled'); 
} 
); 
this.on('blur', function (){ 
self.$container[0].classList.remove('select2-container--focus'); 
} 
); 
this.on('query', function (params){ 
if (!self.isOpen()) { 
self.trigger('open', { 
}
); 
} 
this.dataAdapter.query(params, function (data){ 
self.trigger('results:all', { 
data: data,
query: params}
); 
} 
); 
} 
); 
this.on('query:append', function (params){ 
this.dataAdapter.query(params, function (data){ 
self.trigger('results:append', { 
data: data,
query: params}
); 
} 
); 
} 
); 
this.on('keypress', function (evt){ 
var key = evt.which; 
if (self.isOpen()) { 
if (key === KEYS.ESC || (key === KEYS.UP && evt.altKey)) { 
self.close(evt); 
evt.preventDefault(); 
} 
 else if (key === KEYS.ENTER || key === KEYS.TAB) { 
self.trigger('results:select', { 
}
); 
evt.preventDefault(); 
} 
 else if ((key === KEYS.SPACE && evt.ctrlKey)) { 
self.trigger('results:toggle', { 
}
); 
evt.preventDefault(); 
} 
 else if (key === KEYS.UP) { 
self.trigger('results:previous', { 
}
); 
evt.preventDefault(); 
} 
 else if (key === KEYS.DOWN) { 
self.trigger('results:next', { 
}
); 
evt.preventDefault(); 
} 
} 
 else { 
if (key === KEYS.ENTER || key === KEYS.SPACE || (key === KEYS.DOWN && evt.altKey)) { 
_AN_Call_open('open', self); 
evt.preventDefault(); 
} 
} 
} 
); 
} 
; 
Select2.prototype._syncAttributes = function (){ 
this.options.set('disabled', this.$element.prop('disabled')); 
if (this.isDisabled()) { 
if (this.isOpen()) { 
this.close(); 
} 
this.trigger('disable', { 
}
); 
} 
 else { 
this.trigger('enable', { 
}
); 
} 
} 
; 
Select2.prototype._isChangeMutation = function (mutations){ 
var self = this; 
if (mutations.addedNodes && _AN_Read_length('length', mutations.addedNodes) > 0) { 
for (var n = 0; 
n < _AN_Read_length('length', mutations.addedNodes); n++ ){ 
var node = mutations.addedNodes[n]; 
if (node.selected) { 
return true ; 
} 
} 
} 
 else if (mutations.removedNodes && _AN_Read_length('length', mutations.removedNodes) > 0) { 
return true ; 
} 
 else if (Array.isArray(mutations)) { 
return mutations.some(function (mutation){ 
return self._isChangeMutation(mutation); 
} 
); 
} 
return false ; 
} 
; 
Select2.prototype._syncSubtree = function (mutations){ 
var changed = this._isChangeMutation(mutations); 
var self = this; 
if (changed) { 
this.dataAdapter.current(function (currentData){ 
self.trigger('selection:update', { 
data: currentData}
); 
} 
); 
} 
} 
; 
Select2.prototype.trigger = function (name, args){ 
var actualTrigger = Select2.__super__.trigger; 
var preTriggerMap = { 
'open': 'opening',
'close': 'closing',
'select': 'selecting',
'unselect': 'unselecting',
'clear': 'clearing'}
; 
if (args === undefined) { 
args = { 
}
; 
} 
if (name in preTriggerMap) { 
var preTriggerName = preTriggerMap[name]; 
var preTriggerArgs = { 
prevented: false ,
name: name,
args: args}
; 
actualTrigger.call(this, preTriggerName, preTriggerArgs); 
if (preTriggerArgs.prevented) { 
args.prevented = true ; 
return ; 
} 
} 
actualTrigger.call(this, name, args); 
} 
; 
Select2.prototype.toggleDropdown = function (){ 
if (this.isDisabled()) { 
return ; 
} 
if (this.isOpen()) { 
this.close(); 
} 
 else { 
_AN_Call_open('open', this); 
} 
} 
; 
Select2.prototype.open = function (){ 
if (this.isOpen()) { 
return ; 
} 
if (this.isDisabled()) { 
return ; 
} 
this.trigger('query', { 
}
); 
} 
; 
Select2.prototype.close = function (evt){ 
if (!this.isOpen()) { 
return ; 
} 
this.trigger('close', { 
originalEvent: evt}
); 
} 
; 
Select2.prototype.isEnabled = function (){ 
return !this.isDisabled(); 
} 
; 
Select2.prototype.isDisabled = function (){ 
return this.options.get('disabled'); 
} 
; 
Select2.prototype.isOpen = function (){ 
return this.$container[0].classList.contains('select2-container--open'); 
} 
; 
Select2.prototype.hasFocus = function (){ 
return this.$container[0].classList.contains('select2-container--focus'); 
} 
; 
Select2.prototype.focus = function (data){ 
if (this.hasFocus()) { 
return ; 
} 
this.$container[0].classList.add('select2-container--focus'); 
this.trigger('focus', { 
}
); 
} 
; 
Select2.prototype.enable = function (args){ 
if (this.options.get('debug') && window.console && console.warn) { 
console.warn('Select2: The `select2("enable")` method has been deprecated and will' + ' be removed in later Select2 versions. Use $element.prop("disabled")' + ' instead.'); 
} 
if (args == null  || _AN_Read_length('length', args) === 0) { 
args = [true ] ; 
} 
var disabled = !args[0]; 
this.$element.prop('disabled', disabled); 
} 
; 
Select2.prototype.data = function (){ 
if (this.options.get('debug') && _AN_Read_length('length', arguments) > 0 && window.console && console.warn) { 
console.warn('Select2: Data can no longer be set using `select2("data")`. You ' + 'should consider setting the value instead using `$element.val()`.'); 
} 
var data = [] ; 
this.dataAdapter.current(function (currentData){ 
data = currentData; 
} 
); 
return data; 
} 
; 
Select2.prototype.val = function (args){ 
if (this.options.get('debug') && window.console && console.warn) { 
console.warn('Select2: The `select2("val")` method has been deprecated and will be' + ' removed in later Select2 versions. Use $element.val() instead.'); 
} 
if (args == null  || _AN_Read_length('length', args) === 0) { 
return this.$element.val(); 
} 
var newVal = args[0]; 
if (Array.isArray(newVal)) { 
newVal = newVal.map(function (obj){ 
return obj.toString(); 
} 
); 
} 
this.$element.val(newVal).trigger('input').trigger('change'); 
} 
; 
Select2.prototype.destroy = function (){ 
Utils.RemoveData(this.$container[0]); 
this.$container.remove(); 
this._observer.disconnect(); 
this._observer = null ; 
this._syncA = null ; 
this._syncS = null ; 
this.$element.off('.select2'); 
this.$element.attr('tabindex', Utils.GetData(this.$element[0], 'old-tabindex')); 
this.$element[0].classList.remove('select2-hidden-accessible'); 
this.$element.attr('aria-hidden', 'false'); 
Utils.RemoveData(this.$element[0]); 
this.$element.removeData('select2'); 
this.dataAdapter.destroy(); 
this.selection.destroy(); 
this.dropdown.destroy(); 
this.results.destroy(); 
this.dataAdapter = null ; 
this.selection = null ; 
this.dropdown = null ; 
this.results = null ; 
} 
; 
Select2.prototype.render = function (){ 
var $container = $('<span class="select2 select2-container">' + '<span class="selection"></span>' + '<span class="dropdown-wrapper" aria-hidden="true"></span>' + '</span>'); 
$container.attr('dir', this.options.get('dir')); 
this.$container = $container; 
this.$container[0].classList.add('select2-container--' + this.options.get('theme')); 
Utils.StoreData($container[0], 'element', this.$element); 
return $container; 
} 
; 
return Select2; 
} 
); 
S2.define('jquery-mousewheel', ['jquery'] , function ($){ 
return $; 
} 
); 
S2.define('jquery.select2', ['jquery', 'jquery-mousewheel', './select2/core', './select2/defaults', './select2/utils'] , function ($, _, Select2, Defaults, Utils){ 
if ($.fn.select2 == null ) { 
var thisMethods = ['open', 'close', 'destroy'] ; 
$.fn.select2 = function (options){ 
options = options || { 
}
; 
if (typeof options === 'object') { 
this.each(function (){ 
var instanceOptions = $.extend(true , { 
}
, options); 
var instance = new Select2($(this), instanceOptions); 
} 
); 
return this; 
} 
 else if (typeof options === 'string') { 
var ret; 
var args = Array.prototype.slice.call(arguments, 1); 
this.each(function (){ 
var instance = Utils.GetData(this, 'select2'); 
if (instance == null  && window.console && console.error) { 
console.error('The select2(\'' + options + '\') method was called on an ' + 'element that is not using Select2.'); 
} 
ret = instance[options].apply(instance, args); 
} 
); 
if (thisMethods.indexOf(options) > -1) { 
return this; 
} 
return ret; 
} 
 else { 
throw new Error('Invalid arguments for Select2: ' + options)
} 
} 
; 
} 
if ($.fn.select2.defaults == null ) { 
$.fn.select2.defaults = Defaults; 
} 
return Select2; 
} 
); 
return { 
define: S2.define,
require: S2.require}
; 
} 
()); 
var select2 = S2.require('jquery.select2'); 
jQuery.fn.select2.amd = S2; 
return select2; 
} 
));