Difference between revisions of "Team:Toulouse-INSA-UPS/Team"

Line 56: Line 56:
 
{{Template:Toulouse-INSA-UPS/CONTENT-END}}
 
{{Template:Toulouse-INSA-UPS/CONTENT-END}}
 
{{Template:Toulouse-INSA-UPS/FOOTER}}
 
{{Template:Toulouse-INSA-UPS/FOOTER}}
<html>
 
<script type="text/javascript" class="jquery_js">
 
 
/*!
 
* jQuery JavaScript Library v3.3.1
 
* https://jquery.com/
 
*
 
* Includes Sizzle.js
 
* https://sizzlejs.com/
 
*
 
* Copyright JS Foundation and other contributors
 
* Released under the MIT license
 
* https://jquery.org/license
 
*
 
* Date: 2018-01-20T17:24Z
 
*/
 
( function( global, factory ) {
 
 
"use strict";
 
 
if ( typeof module === "object" && typeof module.exports === "object" ) {
 
 
// For CommonJS and CommonJS-like environments where a proper `window`
 
// is present, execute the factory and get jQuery.
 
// For environments that do not have a `window` with a `document`
 
// (such as Node.js), expose a factory as module.exports.
 
// This accentuates the need for the creation of a real `window`.
 
// e.g. var jQuery = require("jquery")(window);
 
// See ticket #14549 for more info.
 
module.exports = global.document ?
 
factory( global, true ) :
 
function( w ) {
 
if ( !w.document ) {
 
throw new Error( "jQuery requires a window with a document" );
 
}
 
return factory( w );
 
};
 
} else {
 
factory( global );
 
}
 
 
// Pass this if window is not defined yet
 
} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
 
 
// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
 
// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
 
// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
 
// enough that all such attempts are guarded in a try block.
 
"use strict";
 
 
var arr = [];
 
 
var document = window.document;
 
 
var getProto = Object.getPrototypeOf;
 
 
var slice = arr.slice;
 
 
var concat = arr.concat;
 
 
var push = arr.push;
 
 
var indexOf = arr.indexOf;
 
 
var class2type = {};
 
 
var toString = class2type.toString;
 
 
var hasOwn = class2type.hasOwnProperty;
 
 
var fnToString = hasOwn.toString;
 
 
var ObjectFunctionString = fnToString.call( Object );
 
 
var support = {};
 
 
var isFunction = function isFunction( obj ) {
 
 
      // Support: Chrome <=57, Firefox <=52
 
      // In some browsers, typeof returns "function" for HTML <object> elements
 
      // (i.e., `typeof document.createElement( "object" ) === "function"`).
 
      // We don't want to classify *any* DOM node as a function.
 
      return typeof obj === "function" && typeof obj.nodeType !== "number";
 
  };
 
 
 
var isWindow = function isWindow( obj ) {
 
return obj != null && obj === obj.window;
 
};
 
 
 
 
 
var preservedScriptAttributes = {
 
type: true,
 
src: true,
 
noModule: true
 
};
 
 
function DOMEval( code, doc, node ) {
 
doc = doc || document;
 
 
var i,
 
script = doc.createElement( "script" );
 
 
script.text = code;
 
if ( node ) {
 
for ( i in preservedScriptAttributes ) {
 
if ( node[ i ] ) {
 
script[ i ] = node[ i ];
 
}
 
}
 
}
 
doc.head.appendChild( script ).parentNode.removeChild( script );
 
}
 
 
 
function toType( obj ) {
 
if ( obj == null ) {
 
return obj + "";
 
}
 
 
// Support: Android <=2.3 only (functionish RegExp)
 
return typeof obj === "object" || typeof obj === "function" ?
 
class2type[ toString.call( obj ) ] || "object" :
 
typeof obj;
 
}
 
/* global Symbol */
 
// Defining this global in .eslintrc.json would create a danger of using the global
 
// unguarded in another place, it seems safer to define global only for this module
 
 
 
 
var
 
version = "3.3.1",
 
 
// Define a local copy of jQuery
 
jQuery = function( selector, context ) {
 
 
// The jQuery object is actually just the init constructor 'enhanced'
 
// Need init if jQuery is called (just allow error to be thrown if not included)
 
return new jQuery.fn.init( selector, context );
 
},
 
 
// Support: Android <=4.0 only
 
// Make sure we trim BOM and NBSP
 
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
 
 
jQuery.fn = jQuery.prototype = {
 
 
// The current version of jQuery being used
 
jquery: version,
 
 
constructor: jQuery,
 
 
// The default length of a jQuery object is 0
 
length: 0,
 
 
toArray: function() {
 
return slice.call( this );
 
},
 
 
// Get the Nth element in the matched element set OR
 
// Get the whole matched element set as a clean array
 
get: function( num ) {
 
 
// Return all the elements in a clean array
 
if ( num == null ) {
 
return slice.call( this );
 
}
 
 
// Return just the one element from the set
 
return num < 0 ? this[ num + this.length ] : this[ num ];
 
},
 
 
// Take an array of elements and push it onto the stack
 
// (returning the new matched element set)
 
pushStack: function( elems ) {
 
 
// Build a new jQuery matched element set
 
var ret = jQuery.merge( this.constructor(), elems );
 
 
// Add the old object onto the stack (as a reference)
 
ret.prevObject = this;
 
 
// Return the newly-formed element set
 
return ret;
 
},
 
 
// Execute a callback for every element in the matched set.
 
each: function( callback ) {
 
return jQuery.each( this, callback );
 
},
 
 
map: function( callback ) {
 
return this.pushStack( jQuery.map( this, function( elem, i ) {
 
return callback.call( elem, i, elem );
 
} ) );
 
},
 
 
slice: function() {
 
return this.pushStack( slice.apply( this, arguments ) );
 
},
 
 
first: function() {
 
return this.eq( 0 );
 
},
 
 
last: function() {
 
return this.eq( -1 );
 
},
 
 
eq: function( i ) {
 
var len = this.length,
 
j = +i + ( i < 0 ? len : 0 );
 
return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
 
},
 
 
end: function() {
 
return this.prevObject || this.constructor();
 
},
 
 
// For internal use only.
 
// Behaves like an Array's method, not like a jQuery method.
 
push: push,
 
sort: arr.sort,
 
splice: arr.splice
 
};
 
 
jQuery.extend = jQuery.fn.extend = function() {
 
var options, name, src, copy, copyIsArray, clone,
 
target = arguments[ 0 ] || {},
 
i = 1,
 
length = arguments.length,
 
deep = false;
 
 
// Handle a deep copy situation
 
if ( typeof target === "boolean" ) {
 
deep = target;
 
 
// Skip the boolean and the target
 
target = arguments[ i ] || {};
 
i++;
 
}
 
 
// Handle case when target is a string or something (possible in deep copy)
 
if ( typeof target !== "object" && !isFunction( target ) ) {
 
target = {};
 
}
 
 
// Extend jQuery itself if only one argument is passed
 
if ( i === length ) {
 
target = this;
 
i--;
 
}
 
 
for ( ; i < length; i++ ) {
 
 
// Only deal with non-null/undefined values
 
if ( ( options = arguments[ i ] ) != null ) {
 
 
// Extend the base object
 
for ( name in options ) {
 
src = target[ name ];
 
copy = options[ name ];
 
 
// Prevent never-ending loop
 
if ( target === copy ) {
 
continue;
 
}
 
 
// Recurse if we're merging plain objects or arrays
 
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
 
( copyIsArray = Array.isArray( copy ) ) ) ) {
 
 
if ( copyIsArray ) {
 
copyIsArray = false;
 
clone = src && Array.isArray( src ) ? src : [];
 
 
} else {
 
clone = src && jQuery.isPlainObject( src ) ? src : {};
 
}
 
 
// Never move original objects, clone them
 
target[ name ] = jQuery.extend( deep, clone, copy );
 
 
// Don't bring in undefined values
 
} else if ( copy !== undefined ) {
 
target[ name ] = copy;
 
}
 
}
 
}
 
}
 
 
// Return the modified object
 
return target;
 
};
 
 
jQuery.extend( {
 
 
// Unique for each copy of jQuery on the page
 
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
 
 
// Assume jQuery is ready without the ready module
 
isReady: true,
 
 
error: function( msg ) {
 
throw new Error( msg );
 
},
 
 
noop: function() {},
 
 
isPlainObject: function( obj ) {
 
var proto, Ctor;
 
 
// Detect obvious negatives
 
// Use toString instead of jQuery.type to catch host objects
 
if ( !obj || toString.call( obj ) !== "[object Object]" ) {
 
return false;
 
}
 
 
proto = getProto( obj );
 
 
// Objects with no prototype (e.g., `Object.create( null )`) are plain
 
if ( !proto ) {
 
return true;
 
}
 
 
// Objects with prototype are plain iff they were constructed by a global Object function
 
Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
 
return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
 
},
 
 
isEmptyObject: function( obj ) {
 
 
/* eslint-disable no-unused-vars */
 
// See https://github.com/eslint/eslint/issues/6125
 
var name;
 
 
for ( name in obj ) {
 
return false;
 
}
 
return true;
 
},
 
 
// Evaluates a script in a global context
 
globalEval: function( code ) {
 
DOMEval( code );
 
},
 
 
each: function( obj, callback ) {
 
var length, i = 0;
 
 
if ( isArrayLike( obj ) ) {
 
length = obj.length;
 
for ( ; i < length; i++ ) {
 
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 
break;
 
}
 
}
 
} else {
 
for ( i in obj ) {
 
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 
break;
 
}
 
}
 
}
 
 
return obj;
 
},
 
 
// Support: Android <=4.0 only
 
trim: function( text ) {
 
return text == null ?
 
"" :
 
( text + "" ).replace( rtrim, "" );
 
},
 
 
// results is for internal usage only
 
makeArray: function( arr, results ) {
 
var ret = results || [];
 
 
if ( arr != null ) {
 
if ( isArrayLike( Object( arr ) ) ) {
 
jQuery.merge( ret,
 
typeof arr === "string" ?
 
[ arr ] : arr
 
);
 
} else {
 
push.call( ret, arr );
 
}
 
}
 
 
return ret;
 
},
 
 
inArray: function( elem, arr, i ) {
 
return arr == null ? -1 : indexOf.call( arr, elem, i );
 
},
 
 
// Support: Android <=4.0 only, PhantomJS 1 only
 
// push.apply(_, arraylike) throws on ancient WebKit
 
merge: function( first, second ) {
 
var len = +second.length,
 
j = 0,
 
i = first.length;
 
 
for ( ; j < len; j++ ) {
 
first[ i++ ] = second[ j ];
 
}
 
 
first.length = i;
 
 
return first;
 
},
 
 
grep: function( elems, callback, invert ) {
 
var callbackInverse,
 
matches = [],
 
i = 0,
 
length = elems.length,
 
callbackExpect = !invert;
 
 
// Go through the array, only saving the items
 
// that pass the validator function
 
for ( ; i < length; i++ ) {
 
callbackInverse = !callback( elems[ i ], i );
 
if ( callbackInverse !== callbackExpect ) {
 
matches.push( elems[ i ] );
 
}
 
}
 
 
return matches;
 
},
 
 
// arg is for internal usage only
 
map: function( elems, callback, arg ) {
 
var length, value,
 
i = 0,
 
ret = [];
 
 
// Go through the array, translating each of the items to their new values
 
if ( isArrayLike( elems ) ) {
 
length = elems.length;
 
for ( ; i < length; i++ ) {
 
value = callback( elems[ i ], i, arg );
 
 
if ( value != null ) {
 
ret.push( value );
 
}
 
}
 
 
// Go through every key on the object,
 
} else {
 
for ( i in elems ) {
 
value = callback( elems[ i ], i, arg );
 
 
if ( value != null ) {
 
ret.push( value );
 
}
 
}
 
}
 
 
// Flatten any nested arrays
 
return concat.apply( [], ret );
 
},
 
 
// A global GUID counter for objects
 
guid: 1,
 
 
// jQuery.support is not used in Core but other projects attach their
 
// properties to it so it needs to exist.
 
support: support
 
} );
 
 
if ( typeof Symbol === "function" ) {
 
jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
 
}
 
 
// Populate the class2type map
 
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
 
function( i, name ) {
 
class2type[ "[object " + name + "]" ] = name.toLowerCase();
 
} );
 
 
function isArrayLike( obj ) {
 
 
// Support: real iOS 8.2 only (not reproducible in simulator)
 
// `in` check used to prevent JIT error (gh-2145)
 
// hasOwn isn't used here due to false negatives
 
// regarding Nodelist length in IE
 
var length = !!obj && "length" in obj && obj.length,
 
type = toType( obj );
 
 
if ( isFunction( obj ) || isWindow( obj ) ) {
 
return false;
 
}
 
 
return type === "array" || length === 0 ||
 
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
 
}
 
var Sizzle =
 
/*!
 
* Sizzle CSS Selector Engine v2.3.3
 
* https://sizzlejs.com/
 
*
 
* Copyright jQuery Foundation and other contributors
 
* Released under the MIT license
 
* http://jquery.org/license
 
*
 
* Date: 2016-08-08
 
*/
 
(function( window ) {
 
 
var i,
 
support,
 
Expr,
 
getText,
 
isXML,
 
tokenize,
 
compile,
 
select,
 
outermostContext,
 
sortInput,
 
hasDuplicate,
 
 
// Local document vars
 
setDocument,
 
document,
 
docElem,
 
documentIsHTML,
 
rbuggyQSA,
 
rbuggyMatches,
 
matches,
 
contains,
 
 
// Instance-specific data
 
expando = "sizzle" + 1 * new Date(),
 
preferredDoc = window.document,
 
dirruns = 0,
 
done = 0,
 
classCache = createCache(),
 
tokenCache = createCache(),
 
compilerCache = createCache(),
 
sortOrder = function( a, b ) {
 
if ( a === b ) {
 
hasDuplicate = true;
 
}
 
return 0;
 
},
 
 
// Instance methods
 
hasOwn = ({}).hasOwnProperty,
 
arr = [],
 
pop = arr.pop,
 
push_native = arr.push,
 
push = arr.push,
 
slice = arr.slice,
 
// Use a stripped-down indexOf as it's faster than native
 
// https://jsperf.com/thor-indexof-vs-for/5
 
indexOf = function( list, elem ) {
 
var i = 0,
 
len = list.length;
 
for ( ; i < len; i++ ) {
 
if ( list[i] === elem ) {
 
return i;
 
}
 
}
 
return -1;
 
},
 
 
booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
 
 
// Regular expressions
 
 
// http://www.w3.org/TR/css3-selectors/#whitespace
 
whitespace = "[\\x20\\t\\r\\n\\f]",
 
 
// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
 
identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
 
 
// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
 
attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
 
// Operator (capture 2)
 
"*([*^$|!~]?=)" + whitespace +
 
// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
 
"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
 
"*\\]",
 
 
pseudos = ":(" + identifier + ")(?:\\((" +
 
// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
 
// 1. quoted (capture 3; capture 4 or capture 5)
 
"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
 
// 2. simple (capture 6)
 
"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
 
// 3. anything else (capture 2)
 
".*" +
 
")\\)|)",
 
 
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
 
rwhitespace = new RegExp( whitespace + "+", "g" ),
 
rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
 
 
rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
 
rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
 
 
rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
 
 
rpseudo = new RegExp( pseudos ),
 
ridentifier = new RegExp( "^" + identifier + "$" ),
 
 
matchExpr = {
 
"ID": new RegExp( "^#(" + identifier + ")" ),
 
"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
 
"TAG": new RegExp( "^(" + identifier + "|[*])" ),
 
"ATTR": new RegExp( "^" + attributes ),
 
"PSEUDO": new RegExp( "^" + pseudos ),
 
"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
 
"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
 
"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
 
"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
 
// For use in libraries implementing .is()
 
// We use this for POS matching in `select`
 
"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
 
whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
 
},
 
 
rinputs = /^(?:input|select|textarea|button)$/i,
 
rheader = /^h\d$/i,
 
 
rnative = /^[^{]+\{\s*\[native \w/,
 
 
// Easily-parseable/retrievable ID or TAG or CLASS selectors
 
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
 
 
rsibling = /[+~]/,
 
 
// CSS escapes
 
// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
 
runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
 
funescape = function( _, escaped, escapedWhitespace ) {
 
var high = "0x" + escaped - 0x10000;
 
// NaN means non-codepoint
 
// Support: Firefox<24
 
// Workaround erroneous numeric interpretation of +"0x"
 
return high !== high || escapedWhitespace ?
 
escaped :
 
high < 0 ?
 
// BMP codepoint
 
String.fromCharCode( high + 0x10000 ) :
 
// Supplemental Plane codepoint (surrogate pair)
 
String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
 
},
 
 
// CSS string/identifier serialization
 
// https://drafts.csswg.org/cssom/#common-serializing-idioms
 
rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
 
fcssescape = function( ch, asCodePoint ) {
 
if ( asCodePoint ) {
 
 
// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
 
if ( ch === "\0" ) {
 
return "\uFFFD";
 
}
 
 
// Control characters and (dependent upon position) numbers get escaped as code points
 
return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
 
}
 
 
// Other potentially-special ASCII characters get backslash-escaped
 
return "\\" + ch;
 
},
 
 
// Used for iframes
 
// See setDocument()
 
// Removing the function wrapper causes a "Permission Denied"
 
// error in IE
 
unloadHandler = function() {
 
setDocument();
 
},
 
 
disabledAncestor = addCombinator(
 
function( elem ) {
 
return elem.disabled === true && ("form" in elem || "label" in elem);
 
},
 
{ dir: "parentNode", next: "legend" }
 
);
 
 
// Optimize for push.apply( _, NodeList )
 
try {
 
push.apply(
 
(arr = slice.call( preferredDoc.childNodes )),
 
preferredDoc.childNodes
 
);
 
// Support: Android<4.0
 
// Detect silently failing push.apply
 
arr[ preferredDoc.childNodes.length ].nodeType;
 
} catch ( e ) {
 
push = { apply: arr.length ?
 
 
// Leverage slice if possible
 
function( target, els ) {
 
push_native.apply( target, slice.call(els) );
 
} :
 
 
// Support: IE<9
 
// Otherwise append directly
 
function( target, els ) {
 
var j = target.length,
 
i = 0;
 
// Can't trust NodeList.length
 
while ( (target[j++] = els[i++]) ) {}
 
target.length = j - 1;
 
}
 
};
 
}
 
 
function Sizzle( selector, context, results, seed ) {
 
var m, i, elem, nid, match, groups, newSelector,
 
newContext = context && context.ownerDocument,
 
 
// nodeType defaults to 9, since context defaults to document
 
nodeType = context ? context.nodeType : 9;
 
 
results = results || [];
 
 
// Return early from calls with invalid selector or context
 
if ( typeof selector !== "string" || !selector ||
 
nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
 
 
return results;
 
}
 
 
// Try to shortcut find operations (as opposed to filters) in HTML documents
 
if ( !seed ) {
 
 
if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
 
setDocument( context );
 
}
 
context = context || document;
 
 
if ( documentIsHTML ) {
 
 
// If the selector is sufficiently simple, try using a "get*By*" DOM method
 
// (excepting DocumentFragment context, where the methods don't exist)
 
if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
 
 
// ID selector
 
if ( (m = match[1]) ) {
 
 
// Document context
 
if ( nodeType === 9 ) {
 
if ( (elem = context.getElementById( m )) ) {
 
 
// Support: IE, Opera, Webkit
 
// TODO: identify versions
 
// getElementById can match elements by name instead of ID
 
if ( elem.id === m ) {
 
results.push( elem );
 
return results;
 
}
 
} else {
 
return results;
 
}
 
 
// Element context
 
} else {
 
 
// Support: IE, Opera, Webkit
 
// TODO: identify versions
 
// getElementById can match elements by name instead of ID
 
if ( newContext && (elem = newContext.getElementById( m )) &&
 
contains( context, elem ) &&
 
elem.id === m ) {
 
 
results.push( elem );
 
return results;
 
}
 
}
 
 
// Type selector
 
} else if ( match[2] ) {
 
push.apply( results, context.getElementsByTagName( selector ) );
 
return results;
 
 
// Class selector
 
} else if ( (m = match[3]) && support.getElementsByClassName &&
 
context.getElementsByClassName ) {
 
 
push.apply( results, context.getElementsByClassName( m ) );
 
return results;
 
}
 
}
 
 
// Take advantage of querySelectorAll
 
if ( support.qsa &&
 
!compilerCache[ selector + " " ] &&
 
(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
 
 
if ( nodeType !== 1 ) {
 
newContext = context;
 
newSelector = selector;
 
 
// qSA looks outside Element context, which is not what we want
 
// Thanks to Andrew Dupont for this workaround technique
 
// Support: IE <=8
 
// Exclude object elements
 
} else if ( context.nodeName.toLowerCase() !== "object" ) {
 
 
// Capture the context ID, setting it first if necessary
 
if ( (nid = context.getAttribute( "id" )) ) {
 
nid = nid.replace( rcssescape, fcssescape );
 
} else {
 
context.setAttribute( "id", (nid = expando) );
 
}
 
 
// Prefix every selector in the list
 
groups = tokenize( selector );
 
i = groups.length;
 
while ( i-- ) {
 
groups[i] = "#" + nid + " " + toSelector( groups[i] );
 
}
 
newSelector = groups.join( "," );
 
 
// Expand context for sibling selectors
 
newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
 
context;
 
}
 
 
if ( newSelector ) {
 
try {
 
push.apply( results,
 
newContext.querySelectorAll( newSelector )
 
);
 
return results;
 
} catch ( qsaError ) {
 
} finally {
 
if ( nid === expando ) {
 
context.removeAttribute( "id" );
 
}
 
}
 
}
 
}
 
}
 
}
 
 
// All others
 
return select( selector.replace( rtrim, "$1" ), context, results, seed );
 
}
 
 
/**
 
* Create key-value caches of limited size
 
* @returns {function(string, object)} Returns the Object data after storing it on itself with
 
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
 
* deleting the oldest entry
 
*/
 
function createCache() {
 
var keys = [];
 
 
function cache( key, value ) {
 
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
 
if ( keys.push( key + " " ) > Expr.cacheLength ) {
 
// Only keep the most recent entries
 
delete cache[ keys.shift() ];
 
}
 
return (cache[ key + " " ] = value);
 
}
 
return cache;
 
}
 
 
/**
 
* Mark a function for special use by Sizzle
 
* @param {Function} fn The function to mark
 
*/
 
function markFunction( fn ) {
 
fn[ expando ] = true;
 
return fn;
 
}
 
 
/**
 
* Support testing using an element
 
* @param {Function} fn Passed the created element and returns a boolean result
 
*/
 
function assert( fn ) {
 
var el = document.createElement("fieldset");
 
 
try {
 
return !!fn( el );
 
} catch (e) {
 
return false;
 
} finally {
 
// Remove from its parent by default
 
if ( el.parentNode ) {
 
el.parentNode.removeChild( el );
 
}
 
// release memory in IE
 
el = null;
 
}
 
}
 
 
/**
 
* Adds the same handler for all of the specified attrs
 
* @param {String} attrs Pipe-separated list of attributes
 
* @param {Function} handler The method that will be applied
 
*/
 
function addHandle( attrs, handler ) {
 
var arr = attrs.split("|"),
 
i = arr.length;
 
 
while ( i-- ) {
 
Expr.attrHandle[ arr[i] ] = handler;
 
}
 
}
 
 
/**
 
* Checks document order of two siblings
 
* @param {Element} a
 
* @param {Element} b
 
* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
 
*/
 
function siblingCheck( a, b ) {
 
var cur = b && a,
 
diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
 
a.sourceIndex - b.sourceIndex;
 
 
// Use IE sourceIndex if available on both nodes
 
if ( diff ) {
 
return diff;
 
}
 
 
// Check if b follows a
 
if ( cur ) {
 
while ( (cur = cur.nextSibling) ) {
 
if ( cur === b ) {
 
return -1;
 
}
 
}
 
}
 
 
return a ? 1 : -1;
 
}
 
 
/**
 
* Returns a function to use in pseudos for input types
 
* @param {String} type
 
*/
 
function createInputPseudo( type ) {
 
return function( elem ) {
 
var name = elem.nodeName.toLowerCase();
 
return name === "input" && elem.type === type;
 
};
 
}
 
 
/**
 
* Returns a function to use in pseudos for buttons
 
* @param {String} type
 
*/
 
function createButtonPseudo( type ) {
 
return function( elem ) {
 
var name = elem.nodeName.toLowerCase();
 
return (name === "input" || name === "button") && elem.type === type;
 
};
 
}
 
 
/**
 
* Returns a function to use in pseudos for :enabled/:disabled
 
* @param {Boolean} disabled true for :disabled; false for :enabled
 
*/
 
function createDisabledPseudo( disabled ) {
 
 
// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
 
return function( elem ) {
 
 
// Only certain elements can match :enabled or :disabled
 
// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
 
// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
 
if ( "form" in elem ) {
 
 
// Check for inherited disabledness on relevant non-disabled elements:
 
// * listed form-associated elements in a disabled fieldset
 
//  https://html.spec.whatwg.org/multipage/forms.html#category-listed
 
//  https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
 
// * option elements in a disabled optgroup
 
//  https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
 
// All such elements have a "form" property.
 
if ( elem.parentNode && elem.disabled === false ) {
 
 
// Option elements defer to a parent optgroup if present
 
if ( "label" in elem ) {
 
if ( "label" in elem.parentNode ) {
 
return elem.parentNode.disabled === disabled;
 
} else {
 
return elem.disabled === disabled;
 
}
 
}
 
 
// Support: IE 6 - 11
 
// Use the isDisabled shortcut property to check for disabled fieldset ancestors
 
return elem.isDisabled === disabled ||
 
 
// Where there is no isDisabled, check manually
 
/* jshint -W018 */
 
elem.isDisabled !== !disabled &&
 
disabledAncestor( elem ) === disabled;
 
}
 
 
return elem.disabled === disabled;
 
 
// Try to winnow out elements that can't be disabled before trusting the disabled property.
 
// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
 
// even exist on them, let alone have a boolean value.
 
} else if ( "label" in elem ) {
 
return elem.disabled === disabled;
 
}
 
 
// Remaining elements are neither :enabled nor :disabled
 
return false;
 
};
 
}
 
 
/**
 
* Returns a function to use in pseudos for positionals
 
* @param {Function} fn
 
*/
 
function createPositionalPseudo( fn ) {
 
return markFunction(function( argument ) {
 
argument = +argument;
 
return markFunction(function( seed, matches ) {
 
var j,
 
matchIndexes = fn( [], seed.length, argument ),
 
i = matchIndexes.length;
 
 
// Match elements found at the specified indexes
 
while ( i-- ) {
 
if ( seed[ (j = matchIndexes[i]) ] ) {
 
seed[j] = !(matches[j] = seed[j]);
 
}
 
}
 
});
 
});
 
}
 
 
/**
 
* Checks a node for validity as a Sizzle context
 
* @param {Element|Object=} context
 
* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
 
*/
 
function testContext( context ) {
 
return context && typeof context.getElementsByTagName !== "undefined" && context;
 
}
 
 
// Expose support vars for convenience
 
support = Sizzle.support = {};
 
 
/**
 
* Detects XML nodes
 
* @param {Element|Object} elem An element or a document
 
* @returns {Boolean} True iff elem is a non-HTML XML node
 
*/
 
isXML = Sizzle.isXML = function( elem ) {
 
// documentElement is verified for cases where it doesn't yet exist
 
// (such as loading iframes in IE - #4833)
 
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
 
return documentElement ? documentElement.nodeName !== "HTML" : false;
 
};
 
 
/**
 
* Sets document-related variables once based on the current document
 
* @param {Element|Object} [doc] An element or document object to use to set the document
 
* @returns {Object} Returns the current document
 
*/
 
setDocument = Sizzle.setDocument = function( node ) {
 
var hasCompare, subWindow,
 
doc = node ? node.ownerDocument || node : preferredDoc;
 
 
// Return early if doc is invalid or already selected
 
if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
 
return document;
 
}
 
 
// Update global variables
 
document = doc;
 
docElem = document.documentElement;
 
documentIsHTML = !isXML( document );
 
 
// Support: IE 9-11, Edge
 
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
 
if ( preferredDoc !== document &&
 
(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
 
 
// Support: IE 11, Edge
 
if ( subWindow.addEventListener ) {
 
subWindow.addEventListener( "unload", unloadHandler, false );
 
 
// Support: IE 9 - 10 only
 
} else if ( subWindow.attachEvent ) {
 
subWindow.attachEvent( "onunload", unloadHandler );
 
}
 
}
 
 
/* Attributes
 
---------------------------------------------------------------------- */
 
 
// Support: IE<8
 
// Verify that getAttribute really returns attributes and not properties
 
// (excepting IE8 booleans)
 
support.attributes = assert(function( el ) {
 
el.className = "i";
 
return !el.getAttribute("className");
 
});
 
 
/* getElement(s)By*
 
---------------------------------------------------------------------- */
 
 
// Check if getElementsByTagName("*") returns only elements
 
support.getElementsByTagName = assert(function( el ) {
 
el.appendChild( document.createComment("") );
 
return !el.getElementsByTagName("*").length;
 
});
 
 
// Support: IE<9
 
support.getElementsByClassName = rnative.test( document.getElementsByClassName );
 
 
// Support: IE<10
 
// Check if getElementById returns elements by name
 
// The broken getElementById methods don't pick up programmatically-set names,
 
// so use a roundabout getElementsByName test
 
support.getById = assert(function( el ) {
 
docElem.appendChild( el ).id = expando;
 
return !document.getElementsByName || !document.getElementsByName( expando ).length;
 
});
 
 
// ID filter and find
 
if ( support.getById ) {
 
Expr.filter["ID"] = function( id ) {
 
var attrId = id.replace( runescape, funescape );
 
return function( elem ) {
 
return elem.getAttribute("id") === attrId;
 
};
 
};
 
Expr.find["ID"] = function( id, context ) {
 
if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
 
var elem = context.getElementById( id );
 
return elem ? [ elem ] : [];
 
}
 
};
 
} else {
 
Expr.filter["ID"] =  function( id ) {
 
var attrId = id.replace( runescape, funescape );
 
return function( elem ) {
 
var node = typeof elem.getAttributeNode !== "undefined" &&
 
elem.getAttributeNode("id");
 
return node && node.value === attrId;
 
};
 
};
 
 
// Support: IE 6 - 7 only
 
// getElementById is not reliable as a find shortcut
 
Expr.find["ID"] = function( id, context ) {
 
if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
 
var node, i, elems,
 
elem = context.getElementById( id );
 
 
if ( elem ) {
 
 
// Verify the id attribute
 
node = elem.getAttributeNode("id");
 
if ( node && node.value === id ) {
 
return [ elem ];
 
}
 
 
// Fall back on getElementsByName
 
elems = context.getElementsByName( id );
 
i = 0;
 
while ( (elem = elems[i++]) ) {
 
node = elem.getAttributeNode("id");
 
if ( node && node.value === id ) {
 
return [ elem ];
 
}
 
}
 
}
 
 
return [];
 
}
 
};
 
}
 
 
// Tag
 
Expr.find["TAG"] = support.getElementsByTagName ?
 
function( tag, context ) {
 
if ( typeof context.getElementsByTagName !== "undefined" ) {
 
return context.getElementsByTagName( tag );
 
 
// DocumentFragment nodes don't have gEBTN
 
} else if ( support.qsa ) {
 
return context.querySelectorAll( tag );
 
}
 
} :
 
 
function( tag, context ) {
 
var elem,
 
tmp = [],
 
i = 0,
 
// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
 
results = context.getElementsByTagName( tag );
 
 
// Filter out possible comments
 
if ( tag === "*" ) {
 
while ( (elem = results[i++]) ) {
 
if ( elem.nodeType === 1 ) {
 
tmp.push( elem );
 
}
 
}
 
 
return tmp;
 
}
 
return results;
 
};
 
 
// Class
 
Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
 
if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
 
return context.getElementsByClassName( className );
 
}
 
};
 
 
/* QSA/matchesSelector
 
---------------------------------------------------------------------- */
 
 
// QSA and matchesSelector support
 
 
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
 
rbuggyMatches = [];
 
 
// qSa(:focus) reports false when true (Chrome 21)
 
// We allow this because of a bug in IE8/9 that throws an error
 
// whenever `document.activeElement` is accessed on an iframe
 
// So, we allow :focus to pass through QSA all the time to avoid the IE error
 
// See https://bugs.jquery.com/ticket/13378
 
rbuggyQSA = [];
 
 
if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
 
// Build QSA regex
 
// Regex strategy adopted from Diego Perini
 
assert(function( el ) {
 
// Select is set to empty string on purpose
 
// This is to test IE's treatment of not explicitly
 
// setting a boolean content attribute,
 
// since its presence should be enough
 
// https://bugs.jquery.com/ticket/12359
 
docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
 
"<select id='" + expando + "-\r\\' msallowcapture=''>" +
 
"<option selected=''></option></select>";
 
 
// Support: IE8, Opera 11-12.16
 
// Nothing should be selected when empty strings follow ^= or $= or *=
 
// The test attribute must be unknown in Opera but "safe" for WinRT
 
// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
 
if ( el.querySelectorAll("[msallowcapture^='']").length ) {
 
rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
 
}
 
 
// Support: IE8
 
// Boolean attributes and "value" are not treated correctly
 
if ( !el.querySelectorAll("[selected]").length ) {
 
rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
 
}
 
 
// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
 
if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
 
rbuggyQSA.push("~=");
 
}
 
 
// Webkit/Opera - :checked should return selected option elements
 
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
 
// IE8 throws error here and will not see later tests
 
if ( !el.querySelectorAll(":checked").length ) {
 
rbuggyQSA.push(":checked");
 
}
 
 
// Support: Safari 8+, iOS 8+
 
// https://bugs.webkit.org/show_bug.cgi?id=136851
 
// In-page `selector#id sibling-combinator selector` fails
 
if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
 
rbuggyQSA.push(".#.+[+~]");
 
}
 
});
 
 
assert(function( el ) {
 
el.innerHTML = "<a href='' disabled='disabled'></a>" +
 
"<select disabled='disabled'><option/></select>";
 
 
// Support: Windows 8 Native Apps
 
// The type and name attributes are restricted during .innerHTML assignment
 
var input = document.createElement("input");
 
input.setAttribute( "type", "hidden" );
 
el.appendChild( input ).setAttribute( "name", "D" );
 
 
// Support: IE8
 
// Enforce case-sensitivity of name attribute
 
if ( el.querySelectorAll("[name=d]").length ) {
 
rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
 
}
 
 
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
 
// IE8 throws error here and will not see later tests
 
if ( el.querySelectorAll(":enabled").length !== 2 ) {
 
rbuggyQSA.push( ":enabled", ":disabled" );
 
}
 
 
// Support: IE9-11+
 
// IE's :disabled selector does not pick up the children of disabled fieldsets
 
docElem.appendChild( el ).disabled = true;
 
if ( el.querySelectorAll(":disabled").length !== 2 ) {
 
rbuggyQSA.push( ":enabled", ":disabled" );
 
}
 
 
// Opera 10-11 does not throw on post-comma invalid pseudos
 
el.querySelectorAll("*,:x");
 
rbuggyQSA.push(",.*:");
 
});
 
}
 
 
if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
 
docElem.webkitMatchesSelector ||
 
docElem.mozMatchesSelector ||
 
docElem.oMatchesSelector ||
 
docElem.msMatchesSelector) )) ) {
 
 
assert(function( el ) {
 
// Check to see if it's possible to do matchesSelector
 
// on a disconnected node (IE 9)
 
support.disconnectedMatch = matches.call( el, "*" );
 
 
// This should fail with an exception
 
// Gecko does not error, returns false instead
 
matches.call( el, "[s!='']:x" );
 
rbuggyMatches.push( "!=", pseudos );
 
});
 
}
 
 
rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
 
rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
 
 
/* Contains
 
---------------------------------------------------------------------- */
 
hasCompare = rnative.test( docElem.compareDocumentPosition );
 
 
// Element contains another
 
// Purposefully self-exclusive
 
// As in, an element does not contain itself
 
contains = hasCompare || rnative.test( docElem.contains ) ?
 
function( a, b ) {
 
var adown = a.nodeType === 9 ? a.documentElement : a,
 
bup = b && b.parentNode;
 
return a === bup || !!( bup && bup.nodeType === 1 && (
 
adown.contains ?
 
adown.contains( bup ) :
 
a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
 
));
 
} :
 
function( a, b ) {
 
if ( b ) {
 
while ( (b = b.parentNode) ) {
 
if ( b === a ) {
 
return true;
 
}
 
}
 
}
 
return false;
 
};
 
 
/* Sorting
 
---------------------------------------------------------------------- */
 
 
// Document order sorting
 
sortOrder = hasCompare ?
 
function( a, b ) {
 
 
// Flag for duplicate removal
 
if ( a === b ) {
 
hasDuplicate = true;
 
return 0;
 
}
 
 
// Sort on method existence if only one input has compareDocumentPosition
 
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
 
if ( compare ) {
 
return compare;
 
}
 
 
// Calculate position if both inputs belong to the same document
 
compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
 
a.compareDocumentPosition( b ) :
 
 
// Otherwise we know they are disconnected
 
1;
 
 
// Disconnected nodes
 
if ( compare & 1 ||
 
(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
 
 
// Choose the first element that is related to our preferred document
 
if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
 
return -1;
 
}
 
if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
 
return 1;
 
}
 
 
// Maintain original order
 
return sortInput ?
 
( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
 
0;
 
}
 
 
return compare & 4 ? -1 : 1;
 
} :
 
function( a, b ) {
 
// Exit early if the nodes are identical
 
if ( a === b ) {
 
hasDuplicate = true;
 
return 0;
 
}
 
 
var cur,
 
i = 0,
 
aup = a.parentNode,
 
bup = b.parentNode,
 
ap = [ a ],
 
bp = [ b ];
 
 
// Parentless nodes are either documents or disconnected
 
if ( !aup || !bup ) {
 
return a === document ? -1 :
 
b === document ? 1 :
 
aup ? -1 :
 
bup ? 1 :
 
sortInput ?
 
( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
 
0;
 
 
// If the nodes are siblings, we can do a quick check
 
} else if ( aup === bup ) {
 
return siblingCheck( a, b );
 
}
 
 
// Otherwise we need full lists of their ancestors for comparison
 
cur = a;
 
while ( (cur = cur.parentNode) ) {
 
ap.unshift( cur );
 
}
 
cur = b;
 
while ( (cur = cur.parentNode) ) {
 
bp.unshift( cur );
 
}
 
 
// Walk down the tree looking for a discrepancy
 
while ( ap[i] === bp[i] ) {
 
i++;
 
}
 
 
return i ?
 
// Do a sibling check if the nodes have a common ancestor
 
siblingCheck( ap[i], bp[i] ) :
 
 
// Otherwise nodes in our document sort first
 
ap[i] === preferredDoc ? -1 :
 
bp[i] === preferredDoc ? 1 :
 
0;
 
};
 
 
return document;
 
};
 
 
Sizzle.matches = function( expr, elements ) {
 
return Sizzle( expr, null, null, elements );
 
};
 
 
Sizzle.matchesSelector = function( elem, expr ) {
 
// Set document vars if needed
 
if ( ( elem.ownerDocument || elem ) !== document ) {
 
setDocument( elem );
 
}
 
 
// Make sure that attribute selectors are quoted
 
expr = expr.replace( rattributeQuotes, "='$1']" );
 
 
if ( support.matchesSelector && documentIsHTML &&
 
!compilerCache[ expr + " " ] &&
 
( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
 
( !rbuggyQSA    || !rbuggyQSA.test( expr ) ) ) {
 
 
try {
 
var ret = matches.call( elem, expr );
 
 
// IE 9's matchesSelector returns false on disconnected nodes
 
if ( ret || support.disconnectedMatch ||
 
// As well, disconnected nodes are said to be in a document
 
// fragment in IE 9
 
elem.document && elem.document.nodeType !== 11 ) {
 
return ret;
 
}
 
} catch (e) {}
 
}
 
 
return Sizzle( expr, document, null, [ elem ] ).length > 0;
 
};
 
 
Sizzle.contains = function( context, elem ) {
 
// Set document vars if needed
 
if ( ( context.ownerDocument || context ) !== document ) {
 
setDocument( context );
 
}
 
return contains( context, elem );
 
};
 
 
Sizzle.attr = function( elem, name ) {
 
// Set document vars if needed
 
if ( ( elem.ownerDocument || elem ) !== document ) {
 
setDocument( elem );
 
}
 
 
var fn = Expr.attrHandle[ name.toLowerCase() ],
 
// Don't get fooled by Object.prototype properties (jQuery #13807)
 
val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
 
fn( elem, name, !documentIsHTML ) :
 
undefined;
 
 
return val !== undefined ?
 
val :
 
support.attributes || !documentIsHTML ?
 
elem.getAttribute( name ) :
 
(val = elem.getAttributeNode(name)) && val.specified ?
 
val.value :
 
null;
 
};
 
 
Sizzle.escape = function( sel ) {
 
return (sel + "").replace( rcssescape, fcssescape );
 
};
 
 
Sizzle.error = function( msg ) {
 
throw new Error( "Syntax error, unrecognized expression: " + msg );
 
};
 
 
/**
 
* Document sorting and removing duplicates
 
* @param {ArrayLike} results
 
*/
 
Sizzle.uniqueSort = function( results ) {
 
var elem,
 
duplicates = [],
 
j = 0,
 
i = 0;
 
 
// Unless we *know* we can detect duplicates, assume their presence
 
hasDuplicate = !support.detectDuplicates;
 
sortInput = !support.sortStable && results.slice( 0 );
 
results.sort( sortOrder );
 
 
if ( hasDuplicate ) {
 
while ( (elem = results[i++]) ) {
 
if ( elem === results[ i ] ) {
 
j = duplicates.push( i );
 
}
 
}
 
while ( j-- ) {
 
results.splice( duplicates[ j ], 1 );
 
}
 
}
 
 
// Clear input after sorting to release objects
 
// See https://github.com/jquery/sizzle/pull/225
 
sortInput = null;
 
 
return results;
 
};
 
 
/**
 
* Utility function for retrieving the text value of an array of DOM nodes
 
* @param {Array|Element} elem
 
*/
 
getText = Sizzle.getText = function( elem ) {
 
var node,
 
ret = "",
 
i = 0,
 
nodeType = elem.nodeType;
 
 
if ( !nodeType ) {
 
// If no nodeType, this is expected to be an array
 
while ( (node = elem[i++]) ) {
 
// Do not traverse comment nodes
 
ret += getText( node );
 
}
 
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
 
// Use textContent for elements
 
// innerText usage removed for consistency of new lines (jQuery #11153)
 
if ( typeof elem.textContent === "string" ) {
 
return elem.textContent;
 
} else {
 
// Traverse its children
 
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
 
ret += getText( elem );
 
}
 
}
 
} else if ( nodeType === 3 || nodeType === 4 ) {
 
return elem.nodeValue;
 
}
 
// Do not include comment or processing instruction nodes
 
 
return ret;
 
};
 
 
Expr = Sizzle.selectors = {
 
 
// Can be adjusted by the user
 
cacheLength: 50,
 
 
createPseudo: markFunction,
 
 
match: matchExpr,
 
 
attrHandle: {},
 
 
find: {},
 
 
relative: {
 
">": { dir: "parentNode", first: true },
 
" ": { dir: "parentNode" },
 
"+": { dir: "previousSibling", first: true },
 
"~": { dir: "previousSibling" }
 
},
 
 
preFilter: {
 
"ATTR": function( match ) {
 
match[1] = match[1].replace( runescape, funescape );
 
 
// Move the given value to match[3] whether quoted or unquoted
 
match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
 
 
if ( match[2] === "~=" ) {
 
match[3] = " " + match[3] + " ";
 
}
 
 
return match.slice( 0, 4 );
 
},
 
 
"CHILD": function( match ) {
 
/* matches from matchExpr["CHILD"]
 
1 type (only|nth|...)
 
2 what (child|of-type)
 
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
 
4 xn-component of xn+y argument ([+-]?\d*n|)
 
5 sign of xn-component
 
6 x of xn-component
 
7 sign of y-component
 
8 y of y-component
 
*/
 
match[1] = match[1].toLowerCase();
 
 
if ( match[1].slice( 0, 3 ) === "nth" ) {
 
// nth-* requires argument
 
if ( !match[3] ) {
 
Sizzle.error( match[0] );
 
}
 
 
// numeric x and y parameters for Expr.filter.CHILD
 
// remember that false/true cast respectively to 0/1
 
match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
 
match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
 
 
// other types prohibit arguments
 
} else if ( match[3] ) {
 
Sizzle.error( match[0] );
 
}
 
 
return match;
 
},
 
 
"PSEUDO": function( match ) {
 
var excess,
 
unquoted = !match[6] && match[2];
 
 
if ( matchExpr["CHILD"].test( match[0] ) ) {
 
return null;
 
}
 
 
// Accept quoted arguments as-is
 
if ( match[3] ) {
 
match[2] = match[4] || match[5] || "";
 
 
// Strip excess characters from unquoted arguments
 
} else if ( unquoted && rpseudo.test( unquoted ) &&
 
// Get excess from tokenize (recursively)
 
(excess = tokenize( unquoted, true )) &&
 
// advance to the next closing parenthesis
 
(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
 
 
// excess is a negative index
 
match[0] = match[0].slice( 0, excess );
 
match[2] = unquoted.slice( 0, excess );
 
}
 
 
// Return only captures needed by the pseudo filter method (type and argument)
 
return match.slice( 0, 3 );
 
}
 
},
 
 
filter: {
 
 
"TAG": function( nodeNameSelector ) {
 
var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
 
return nodeNameSelector === "*" ?
 
function() { return true; } :
 
function( elem ) {
 
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
 
};
 
},
 
 
"CLASS": function( className ) {
 
var pattern = classCache[ className + " " ];
 
 
return pattern ||
 
(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
 
classCache( className, function( elem ) {
 
return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
 
});
 
},
 
 
"ATTR": function( name, operator, check ) {
 
return function( elem ) {
 
var result = Sizzle.attr( elem, name );
 
 
if ( result == null ) {
 
return operator === "!=";
 
}
 
if ( !operator ) {
 
return true;
 
}
 
 
result += "";
 
 
return operator === "=" ? result === check :
 
operator === "!=" ? result !== check :
 
operator === "^=" ? check && result.indexOf( check ) === 0 :
 
operator === "*=" ? check && result.indexOf( check ) > -1 :
 
operator === "$=" ? check && result.slice( -check.length ) === check :
 
operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
 
operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
 
false;
 
};
 
},
 
 
"CHILD": function( type, what, argument, first, last ) {
 
var simple = type.slice( 0, 3 ) !== "nth",
 
forward = type.slice( -4 ) !== "last",
 
ofType = what === "of-type";
 
 
return first === 1 && last === 0 ?
 
 
// Shortcut for :nth-*(n)
 
function( elem ) {
 
return !!elem.parentNode;
 
} :
 
 
function( elem, context, xml ) {
 
var cache, uniqueCache, outerCache, node, nodeIndex, start,
 
dir = simple !== forward ? "nextSibling" : "previousSibling",
 
parent = elem.parentNode,
 
name = ofType && elem.nodeName.toLowerCase(),
 
useCache = !xml && !ofType,
 
diff = false;
 
 
if ( parent ) {
 
 
// :(first|last|only)-(child|of-type)
 
if ( simple ) {
 
while ( dir ) {
 
node = elem;
 
while ( (node = node[ dir ]) ) {
 
if ( ofType ?
 
node.nodeName.toLowerCase() === name :
 
node.nodeType === 1 ) {
 
 
return false;
 
}
 
}
 
// Reverse direction for :only-* (if we haven't yet done so)
 
start = dir = type === "only" && !start && "nextSibling";
 
}
 
return true;
 
}
 
 
start = [ forward ? parent.firstChild : parent.lastChild ];
 
 
// non-xml :nth-child(...) stores cache data on `parent`
 
if ( forward && useCache ) {
 
 
// Seek `elem` from a previously-cached index
 
 
// ...in a gzip-friendly way
 
node = parent;
 
outerCache = node[ expando ] || (node[ expando ] = {});
 
 
// Support: IE <9 only
 
// Defend against cloned attroperties (jQuery gh-1709)
 
uniqueCache = outerCache[ node.uniqueID ] ||
 
(outerCache[ node.uniqueID ] = {});
 
 
cache = uniqueCache[ type ] || [];
 
nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
 
diff = nodeIndex && cache[ 2 ];
 
node = nodeIndex && parent.childNodes[ nodeIndex ];
 
 
while ( (node = ++nodeIndex && node && node[ dir ] ||
 
 
// Fallback to seeking `elem` from the start
 
(diff = nodeIndex = 0) || start.pop()) ) {
 
 
// When found, cache indexes on `parent` and break
 
if ( node.nodeType === 1 && ++diff && node === elem ) {
 
uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
 
break;
 
}
 
}
 
 
} else {
 
// Use previously-cached element index if available
 
if ( useCache ) {
 
// ...in a gzip-friendly way
 
node = elem;
 
outerCache = node[ expando ] || (node[ expando ] = {});
 
 
// Support: IE <9 only
 
// Defend against cloned attroperties (jQuery gh-1709)
 
uniqueCache = outerCache[ node.uniqueID ] ||
 
(outerCache[ node.uniqueID ] = {});
 
 
cache = uniqueCache[ type ] || [];
 
nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
 
diff = nodeIndex;
 
}
 
 
// xml :nth-child(...)
 
// or :nth-last-child(...) or :nth(-last)?-of-type(...)
 
if ( diff === false ) {
 
// Use the same loop as above to seek `elem` from the start
 
while ( (node = ++nodeIndex && node && node[ dir ] ||
 
(diff = nodeIndex = 0) || start.pop()) ) {
 
 
if ( ( ofType ?
 
node.nodeName.toLowerCase() === name :
 
node.nodeType === 1 ) &&
 
++diff ) {
 
 
// Cache the index of each encountered element
 
if ( useCache ) {
 
outerCache = node[ expando ] || (node[ expando ] = {});
 
 
// Support: IE <9 only
 
// Defend against cloned attroperties (jQuery gh-1709)
 
uniqueCache = outerCache[ node.uniqueID ] ||
 
(outerCache[ node.uniqueID ] = {});
 
 
uniqueCache[ type ] = [ dirruns, diff ];
 
}
 
 
if ( node === elem ) {
 
break;
 
}
 
}
 
}
 
}
 
}
 
 
// Incorporate the offset, then check against cycle size
 
diff -= last;
 
return diff === first || ( diff % first === 0 && diff / first >= 0 );
 
}
 
};
 
},
 
 
"PSEUDO": function( pseudo, argument ) {
 
// pseudo-class names are case-insensitive
 
// http://www.w3.org/TR/selectors/#pseudo-classes
 
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
 
// Remember that setFilters inherits from pseudos
 
var args,
 
fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
 
Sizzle.error( "unsupported pseudo: " + pseudo );
 
 
// The user may use createPseudo to indicate that
 
// arguments are needed to create the filter function
 
// just as Sizzle does
 
if ( fn[ expando ] ) {
 
return fn( argument );
 
}
 
 
// But maintain support for old signatures
 
if ( fn.length > 1 ) {
 
args = [ pseudo, pseudo, "", argument ];
 
return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
 
markFunction(function( seed, matches ) {
 
var idx,
 
matched = fn( seed, argument ),
 
i = matched.length;
 
while ( i-- ) {
 
idx = indexOf( seed, matched[i] );
 
seed[ idx ] = !( matches[ idx ] = matched[i] );
 
}
 
}) :
 
function( elem ) {
 
return fn( elem, 0, args );
 
};
 
}
 
 
return fn;
 
}
 
},
 
 
pseudos: {
 
// Potentially complex pseudos
 
"not": markFunction(function( selector ) {
 
// Trim the selector passed to compile
 
// to avoid treating leading and trailing
 
// spaces as combinators
 
var input = [],
 
results = [],
 
matcher = compile( selector.replace( rtrim, "$1" ) );
 
 
return matcher[ expando ] ?
 
markFunction(function( seed, matches, context, xml ) {
 
var elem,
 
unmatched = matcher( seed, null, xml, [] ),
 
i = seed.length;
 
 
// Match elements unmatched by `matcher`
 
while ( i-- ) {
 
if ( (elem = unmatched[i]) ) {
 
seed[i] = !(matches[i] = elem);
 
}
 
}
 
}) :
 
function( elem, context, xml ) {
 
input[0] = elem;
 
matcher( input, null, xml, results );
 
// Don't keep the element (issue #299)
 
input[0] = null;
 
return !results.pop();
 
};
 
}),
 
 
"has": markFunction(function( selector ) {
 
return function( elem ) {
 
return Sizzle( selector, elem ).length > 0;
 
};
 
}),
 
 
"contains": markFunction(function( text ) {
 
text = text.replace( runescape, funescape );
 
return function( elem ) {
 
return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
 
};
 
}),
 
 
// "Whether an element is represented by a :lang() selector
 
// is based solely on the element's language value
 
// being equal to the identifier C,
 
// or beginning with the identifier C immediately followed by "-".
 
// The matching of C against the element's language value is performed case-insensitively.
 
// The identifier C does not have to be a valid language name."
 
// http://www.w3.org/TR/selectors/#lang-pseudo
 
"lang": markFunction( function( lang ) {
 
// lang value must be a valid identifier
 
if ( !ridentifier.test(lang || "") ) {
 
Sizzle.error( "unsupported lang: " + lang );
 
}
 
lang = lang.replace( runescape, funescape ).toLowerCase();
 
return function( elem ) {
 
var elemLang;
 
do {
 
if ( (elemLang = documentIsHTML ?
 
elem.lang :
 
elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
 
 
elemLang = elemLang.toLowerCase();
 
return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
 
}
 
} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
 
return false;
 
};
 
}),
 
 
// Miscellaneous
 
"target": function( elem ) {
 
var hash = window.location && window.location.hash;
 
return hash && hash.slice( 1 ) === elem.id;
 
},
 
 
"root": function( elem ) {
 
return elem === docElem;
 
},
 
 
"focus": function( elem ) {
 
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
 
},
 
 
// Boolean properties
 
"enabled": createDisabledPseudo( false ),
 
"disabled": createDisabledPseudo( true ),
 
 
"checked": function( elem ) {
 
// In CSS3, :checked should return both checked and selected elements
 
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
 
var nodeName = elem.nodeName.toLowerCase();
 
return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
 
},
 
 
"selected": function( elem ) {
 
// Accessing this property makes selected-by-default
 
// options in Safari work properly
 
if ( elem.parentNode ) {
 
elem.parentNode.selectedIndex;
 
}
 
 
return elem.selected === true;
 
},
 
 
// Contents
 
"empty": function( elem ) {
 
// http://www.w3.org/TR/selectors/#empty-pseudo
 
// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
 
//  but not by others (comment: 8; processing instruction: 7; etc.)
 
// nodeType < 6 works because attributes (2) do not appear as children
 
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
 
if ( elem.nodeType < 6 ) {
 
return false;
 
}
 
}
 
return true;
 
},
 
 
"parent": function( elem ) {
 
return !Expr.pseudos["empty"]( elem );
 
},
 
 
// Element/input types
 
"header": function( elem ) {
 
return rheader.test( elem.nodeName );
 
},
 
 
"input": function( elem ) {
 
return rinputs.test( elem.nodeName );
 
},
 
 
"button": function( elem ) {
 
var name = elem.nodeName.toLowerCase();
 
return name === "input" && elem.type === "button" || name === "button";
 
},
 
 
"text": function( elem ) {
 
var attr;
 
return elem.nodeName.toLowerCase() === "input" &&
 
elem.type === "text" &&
 
 
// Support: IE<8
 
// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
 
( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
 
},
 
 
// Position-in-collection
 
"first": createPositionalPseudo(function() {
 
return [ 0 ];
 
}),
 
 
"last": createPositionalPseudo(function( matchIndexes, length ) {
 
return [ length - 1 ];
 
}),
 
 
"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
 
return [ argument < 0 ? argument + length : argument ];
 
}),
 
 
"even": createPositionalPseudo(function( matchIndexes, length ) {
 
var i = 0;
 
for ( ; i < length; i += 2 ) {
 
matchIndexes.push( i );
 
}
 
return matchIndexes;
 
}),
 
 
"odd": createPositionalPseudo(function( matchIndexes, length ) {
 
var i = 1;
 
for ( ; i < length; i += 2 ) {
 
matchIndexes.push( i );
 
}
 
return matchIndexes;
 
}),
 
 
"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
 
var i = argument < 0 ? argument + length : argument;
 
for ( ; --i >= 0; ) {
 
matchIndexes.push( i );
 
}
 
return matchIndexes;
 
}),
 
 
"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
 
var i = argument < 0 ? argument + length : argument;
 
for ( ; ++i < length; ) {
 
matchIndexes.push( i );
 
}
 
return matchIndexes;
 
})
 
}
 
};
 
 
Expr.pseudos["nth"] = Expr.pseudos["eq"];
 
 
// Add button/input type pseudos
 
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
 
Expr.pseudos[ i ] = createInputPseudo( i );
 
}
 
for ( i in { submit: true, reset: true } ) {
 
Expr.pseudos[ i ] = createButtonPseudo( i );
 
}
 
 
// Easy API for creating new setFilters
 
function setFilters() {}
 
setFilters.prototype = Expr.filters = Expr.pseudos;
 
Expr.setFilters = new setFilters();
 
 
tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
 
var matched, match, tokens, type,
 
soFar, groups, preFilters,
 
cached = tokenCache[ selector + " " ];
 
 
if ( cached ) {
 
return parseOnly ? 0 : cached.slice( 0 );
 
}
 
 
soFar = selector;
 
groups = [];
 
preFilters = Expr.preFilter;
 
 
while ( soFar ) {
 
 
// Comma and first run
 
if ( !matched || (match = rcomma.exec( soFar )) ) {
 
if ( match ) {
 
// Don't consume trailing commas as valid
 
soFar = soFar.slice( match[0].length ) || soFar;
 
}
 
groups.push( (tokens = []) );
 
}
 
 
matched = false;
 
 
// Combinators
 
if ( (match = rcombinators.exec( soFar )) ) {
 
matched = match.shift();
 
tokens.push({
 
value: matched,
 
// Cast descendant combinators to space
 
type: match[0].replace( rtrim, " " )
 
});
 
soFar = soFar.slice( matched.length );
 
}
 
 
// Filters
 
for ( type in Expr.filter ) {
 
if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
 
(match = preFilters[ type ]( match ))) ) {
 
matched = match.shift();
 
tokens.push({
 
value: matched,
 
type: type,
 
matches: match
 
});
 
soFar = soFar.slice( matched.length );
 
}
 
}
 
 
if ( !matched ) {
 
break;
 
}
 
}
 
 
// Return the length of the invalid excess
 
// if we're just parsing
 
// Otherwise, throw an error or return tokens
 
return parseOnly ?
 
soFar.length :
 
soFar ?
 
Sizzle.error( selector ) :
 
// Cache the tokens
 
tokenCache( selector, groups ).slice( 0 );
 
};
 
 
function toSelector( tokens ) {
 
var i = 0,
 
len = tokens.length,
 
selector = "";
 
for ( ; i < len; i++ ) {
 
selector += tokens[i].value;
 
}
 
return selector;
 
}
 
 
function addCombinator( matcher, combinator, base ) {
 
var dir = combinator.dir,
 
skip = combinator.next,
 
key = skip || dir,
 
checkNonElements = base && key === "parentNode",
 
doneName = done++;
 
 
return combinator.first ?
 
// Check against closest ancestor/preceding element
 
function( elem, context, xml ) {
 
while ( (elem = elem[ dir ]) ) {
 
if ( elem.nodeType === 1 || checkNonElements ) {
 
return matcher( elem, context, xml );
 
}
 
}
 
return false;
 
} :
 
 
// Check against all ancestor/preceding elements
 
function( elem, context, xml ) {
 
var oldCache, uniqueCache, outerCache,
 
newCache = [ dirruns, doneName ];
 
 
// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
 
if ( xml ) {
 
while ( (elem = elem[ dir ]) ) {
 
if ( elem.nodeType === 1 || checkNonElements ) {
 
if ( matcher( elem, context, xml ) ) {
 
return true;
 
}
 
}
 
}
 
} else {
 
while ( (elem = elem[ dir ]) ) {
 
if ( elem.nodeType === 1 || checkNonElements ) {
 
outerCache = elem[ expando ] || (elem[ expando ] = {});
 
 
// Support: IE <9 only
 
// Defend against cloned attroperties (jQuery gh-1709)
 
uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
 
 
if ( skip && skip === elem.nodeName.toLowerCase() ) {
 
elem = elem[ dir ] || elem;
 
} else if ( (oldCache = uniqueCache[ key ]) &&
 
oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
 
 
// Assign to newCache so results back-propagate to previous elements
 
return (newCache[ 2 ] = oldCache[ 2 ]);
 
} else {
 
// Reuse newcache so results back-propagate to previous elements
 
uniqueCache[ key ] = newCache;
 
 
// A match means we're done; a fail means we have to keep checking
 
if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
 
return true;
 
}
 
}
 
}
 
}
 
}
 
return false;
 
};
 
}
 
 
function elementMatcher( matchers ) {
 
return matchers.length > 1 ?
 
function( elem, context, xml ) {
 
var i = matchers.length;
 
while ( i-- ) {
 
if ( !matchers[i]( elem, context, xml ) ) {
 
return false;
 
}
 
}
 
return true;
 
} :
 
matchers[0];
 
}
 
 
function multipleContexts( selector, contexts, results ) {
 
var i = 0,
 
len = contexts.length;
 
for ( ; i < len; i++ ) {
 
Sizzle( selector, contexts[i], results );
 
}
 
return results;
 
}
 
 
function condense( unmatched, map, filter, context, xml ) {
 
var elem,
 
newUnmatched = [],
 
i = 0,
 
len = unmatched.length,
 
mapped = map != null;
 
 
for ( ; i < len; i++ ) {
 
if ( (elem = unmatched[i]) ) {
 
if ( !filter || filter( elem, context, xml ) ) {
 
newUnmatched.push( elem );
 
if ( mapped ) {
 
map.push( i );
 
}
 
}
 
}
 
}
 
 
return newUnmatched;
 
}
 
 
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
 
if ( postFilter && !postFilter[ expando ] ) {
 
postFilter = setMatcher( postFilter );
 
}
 
if ( postFinder && !postFinder[ expando ] ) {
 
postFinder = setMatcher( postFinder, postSelector );
 
}
 
return markFunction(function( seed, results, context, xml ) {
 
var temp, i, elem,
 
preMap = [],
 
postMap = [],
 
preexisting = results.length,
 
 
// Get initial elements from seed or context
 
elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
 
 
// Prefilter to get matcher input, preserving a map for seed-results synchronization
 
matcherIn = preFilter && ( seed || !selector ) ?
 
condense( elems, preMap, preFilter, context, xml ) :
 
elems,
 
 
matcherOut = matcher ?
 
// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
 
postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
 
 
// ...intermediate processing is necessary
 
[] :
 
 
// ...otherwise use results directly
 
results :
 
matcherIn;
 
 
// Find primary matches
 
if ( matcher ) {
 
matcher( matcherIn, matcherOut, context, xml );
 
}
 
 
// Apply postFilter
 
if ( postFilter ) {
 
temp = condense( matcherOut, postMap );
 
postFilter( temp, [], context, xml );
 
 
// Un-match failing elements by moving them back to matcherIn
 
i = temp.length;
 
while ( i-- ) {
 
if ( (elem = temp[i]) ) {
 
matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
 
}
 
}
 
}
 
 
if ( seed ) {
 
if ( postFinder || preFilter ) {
 
if ( postFinder ) {
 
// Get the final matcherOut by condensing this intermediate into postFinder contexts
 
temp = [];
 
i = matcherOut.length;
 
while ( i-- ) {
 
if ( (elem = matcherOut[i]) ) {
 
// Restore matcherIn since elem is not yet a final match
 
temp.push( (matcherIn[i] = elem) );
 
}
 
}
 
postFinder( null, (matcherOut = []), temp, xml );
 
}
 
 
// Move matched elements from seed to results to keep them synchronized
 
i = matcherOut.length;
 
while ( i-- ) {
 
if ( (elem = matcherOut[i]) &&
 
(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
 
 
seed[temp] = !(results[temp] = elem);
 
}
 
}
 
}
 
 
// Add elements to results, through postFinder if defined
 
} else {
 
matcherOut = condense(
 
matcherOut === results ?
 
matcherOut.splice( preexisting, matcherOut.length ) :
 
matcherOut
 
);
 
if ( postFinder ) {
 
postFinder( null, results, matcherOut, xml );
 
} else {
 
push.apply( results, matcherOut );
 
}
 
}
 
});
 
}
 
 
function matcherFromTokens( tokens ) {
 
var checkContext, matcher, j,
 
len = tokens.length,
 
leadingRelative = Expr.relative[ tokens[0].type ],
 
implicitRelative = leadingRelative || Expr.relative[" "],
 
i = leadingRelative ? 1 : 0,
 
 
// The foundational matcher ensures that elements are reachable from top-level context(s)
 
matchContext = addCombinator( function( elem ) {
 
return elem === checkContext;
 
}, implicitRelative, true ),
 
matchAnyContext = addCombinator( function( elem ) {
 
return indexOf( checkContext, elem ) > -1;
 
}, implicitRelative, true ),
 
matchers = [ function( elem, context, xml ) {
 
var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
 
(checkContext = context).nodeType ?
 
matchContext( elem, context, xml ) :
 
matchAnyContext( elem, context, xml ) );
 
// Avoid hanging onto element (issue #299)
 
checkContext = null;
 
return ret;
 
} ];
 
 
for ( ; i < len; i++ ) {
 
if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
 
matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
 
} else {
 
matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
 
 
// Return special upon seeing a positional matcher
 
if ( matcher[ expando ] ) {
 
// Find the next relative operator (if any) for proper handling
 
j = ++i;
 
for ( ; j < len; j++ ) {
 
if ( Expr.relative[ tokens[j].type ] ) {
 
break;
 
}
 
}
 
return setMatcher(
 
i > 1 && elementMatcher( matchers ),
 
i > 1 && toSelector(
 
// If the preceding token was a descendant combinator, insert an implicit any-element `*`
 
tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
 
).replace( rtrim, "$1" ),
 
matcher,
 
i < j && matcherFromTokens( tokens.slice( i, j ) ),
 
j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
 
j < len && toSelector( tokens )
 
);
 
}
 
matchers.push( matcher );
 
}
 
}
 
 
return elementMatcher( matchers );
 
}
 
 
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
 
var bySet = setMatchers.length > 0,
 
byElement = elementMatchers.length > 0,
 
superMatcher = function( seed, context, xml, results, outermost ) {
 
var elem, j, matcher,
 
matchedCount = 0,
 
i = "0",
 
unmatched = seed && [],
 
setMatched = [],
 
contextBackup = outermostContext,
 
// We must always have either seed elements or outermost context
 
elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
 
// Use integer dirruns iff this is the outermost matcher
 
dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
 
len = elems.length;
 
 
if ( outermost ) {
 
outermostContext = context === document || context || outermost;
 
}
 
 
// Add elements passing elementMatchers directly to results
 
// Support: IE<9, Safari
 
// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
 
for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
 
if ( byElement && elem ) {
 
j = 0;
 
if ( !context && elem.ownerDocument !== document ) {
 
setDocument( elem );
 
xml = !documentIsHTML;
 
}
 
while ( (matcher = elementMatchers[j++]) ) {
 
if ( matcher( elem, context || document, xml) ) {
 
results.push( elem );
 
break;
 
}
 
}
 
if ( outermost ) {
 
dirruns = dirrunsUnique;
 
}
 
}
 
 
// Track unmatched elements for set filters
 
if ( bySet ) {
 
// They will have gone through all possible matchers
 
if ( (elem = !matcher && elem) ) {
 
matchedCount--;
 
}
 
 
// Lengthen the array for every element, matched or not
 
if ( seed ) {
 
unmatched.push( elem );
 
}
 
}
 
}
 
 
// `i` is now the count of elements visited above, and adding it to `matchedCount`
 
// makes the latter nonnegative.
 
matchedCount += i;
 
 
// Apply set filters to unmatched elements
 
// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
 
// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
 
// no element matchers and no seed.
 
// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
 
// case, which will result in a "00" `matchedCount` that differs from `i` but is also
 
// numerically zero.
 
if ( bySet && i !== matchedCount ) {
 
j = 0;
 
while ( (matcher = setMatchers[j++]) ) {
 
matcher( unmatched, setMatched, context, xml );
 
}
 
 
if ( seed ) {
 
// Reintegrate element matches to eliminate the need for sorting
 
if ( matchedCount > 0 ) {
 
while ( i-- ) {
 
if ( !(unmatched[i] || setMatched[i]) ) {
 
setMatched[i] = pop.call( results );
 
}
 
}
 
}
 
 
// Discard index placeholder values to get only actual matches
 
setMatched = condense( setMatched );
 
}
 
 
// Add matches to results
 
push.apply( results, setMatched );
 
 
// Seedless set matches succeeding multiple successful matchers stipulate sorting
 
if ( outermost && !seed && setMatched.length > 0 &&
 
( matchedCount + setMatchers.length ) > 1 ) {
 
 
Sizzle.uniqueSort( results );
 
}
 
}
 
 
// Override manipulation of globals by nested matchers
 
if ( outermost ) {
 
dirruns = dirrunsUnique;
 
outermostContext = contextBackup;
 
}
 
 
return unmatched;
 
};
 
 
return bySet ?
 
markFunction( superMatcher ) :
 
superMatcher;
 
}
 
 
compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
 
var i,
 
setMatchers = [],
 
elementMatchers = [],
 
cached = compilerCache[ selector + " " ];
 
 
if ( !cached ) {
 
// Generate a function of recursive functions that can be used to check each element
 
if ( !match ) {
 
match = tokenize( selector );
 
}
 
i = match.length;
 
while ( i-- ) {
 
cached = matcherFromTokens( match[i] );
 
if ( cached[ expando ] ) {
 
setMatchers.push( cached );
 
} else {
 
elementMatchers.push( cached );
 
}
 
}
 
 
// Cache the compiled function
 
cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
 
 
// Save selector and tokenization
 
cached.selector = selector;
 
}
 
return cached;
 
};
 
 
/**
 
* A low-level selection function that works with Sizzle's compiled
 
*  selector functions
 
* @param {String|Function} selector A selector or a pre-compiled
 
*  selector function built with Sizzle.compile
 
* @param {Element} context
 
* @param {Array} [results]
 
* @param {Array} [seed] A set of elements to match against
 
*/
 
select = Sizzle.select = function( selector, context, results, seed ) {
 
var i, tokens, token, type, find,
 
compiled = typeof selector === "function" && selector,
 
match = !seed && tokenize( (selector = compiled.selector || selector) );
 
 
results = results || [];
 
 
// Try to minimize operations if there is only one selector in the list and no seed
 
// (the latter of which guarantees us context)
 
if ( match.length === 1 ) {
 
 
// Reduce context if the leading compound selector is an ID
 
tokens = match[0] = match[0].slice( 0 );
 
if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
 
context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
 
 
context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
 
if ( !context ) {
 
return results;
 
 
// Precompiled matchers will still verify ancestry, so step up a level
 
} else if ( compiled ) {
 
context = context.parentNode;
 
}
 
 
selector = selector.slice( tokens.shift().value.length );
 
}
 
 
// Fetch a seed set for right-to-left matching
 
i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
 
while ( i-- ) {
 
token = tokens[i];
 
 
// Abort if we hit a combinator
 
if ( Expr.relative[ (type = token.type) ] ) {
 
break;
 
}
 
if ( (find = Expr.find[ type ]) ) {
 
// Search, expanding context for leading sibling combinators
 
if ( (seed = find(
 
token.matches[0].replace( runescape, funescape ),
 
rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
 
)) ) {
 
 
// If seed is empty or no tokens remain, we can return early
 
tokens.splice( i, 1 );
 
selector = seed.length && toSelector( tokens );
 
if ( !selector ) {
 
push.apply( results, seed );
 
return results;
 
}
 
 
break;
 
}
 
}
 
}
 
}
 
 
// Compile and execute a filtering function if one is not provided
 
// Provide `match` to avoid retokenization if we modified the selector above
 
( compiled || compile( selector, match ) )(
 
seed,
 
context,
 
!documentIsHTML,
 
results,
 
!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
 
);
 
return results;
 
};
 
 
// One-time assignments
 
 
// Sort stability
 
support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
 
 
// Support: Chrome 14-35+
 
// Always assume duplicates if they aren't passed to the comparison function
 
support.detectDuplicates = !!hasDuplicate;
 
 
// Initialize against the default document
 
setDocument();
 
 
// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
 
// Detached nodes confoundingly follow *each other*
 
support.sortDetached = assert(function( el ) {
 
// Should return 1, but returns 4 (following)
 
return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
 
});
 
 
// Support: IE<8
 
// Prevent attribute/property "interpolation"
 
// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
 
if ( !assert(function( el ) {
 
el.innerHTML = "<a href='#'></a>";
 
return el.firstChild.getAttribute("href") === "#" ;
 
}) ) {
 
addHandle( "type|href|height|width", function( elem, name, isXML ) {
 
if ( !isXML ) {
 
return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
 
}
 
});
 
}
 
 
// Support: IE<9
 
// Use defaultValue in place of getAttribute("value")
 
if ( !support.attributes || !assert(function( el ) {
 
el.innerHTML = "<input/>";
 
el.firstChild.setAttribute( "value", "" );
 
return el.firstChild.getAttribute( "value" ) === "";
 
}) ) {
 
addHandle( "value", function( elem, name, isXML ) {
 
if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
 
return elem.defaultValue;
 
}
 
});
 
}
 
 
// Support: IE<9
 
// Use getAttributeNode to fetch booleans when getAttribute lies
 
if ( !assert(function( el ) {
 
return el.getAttribute("disabled") == null;
 
}) ) {
 
addHandle( booleans, function( elem, name, isXML ) {
 
var val;
 
if ( !isXML ) {
 
return elem[ name ] === true ? name.toLowerCase() :
 
(val = elem.getAttributeNode( name )) && val.specified ?
 
val.value :
 
null;
 
}
 
});
 
}
 
 
return Sizzle;
 
 
})( window );
 
 
 
 
jQuery.find = Sizzle;
 
jQuery.expr = Sizzle.selectors;
 
 
// Deprecated
 
jQuery.expr[ ":" ] = jQuery.expr.pseudos;
 
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
 
jQuery.text = Sizzle.getText;
 
jQuery.isXMLDoc = Sizzle.isXML;
 
jQuery.contains = Sizzle.contains;
 
jQuery.escapeSelector = Sizzle.escape;
 
 
 
 
 
var dir = function( elem, dir, until ) {
 
var matched = [],
 
truncate = until !== undefined;
 
 
while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
 
if ( elem.nodeType === 1 ) {
 
if ( truncate && jQuery( elem ).is( until ) ) {
 
break;
 
}
 
matched.push( elem );
 
}
 
}
 
return matched;
 
};
 
 
 
var siblings = function( n, elem ) {
 
var matched = [];
 
 
for ( ; n; n = n.nextSibling ) {
 
if ( n.nodeType === 1 && n !== elem ) {
 
matched.push( n );
 
}
 
}
 
 
return matched;
 
};
 
 
 
var rneedsContext = jQuery.expr.match.needsContext;
 
 
 
 
function nodeName( elem, name ) {
 
 
  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
 
 
};
 
var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
 
 
 
 
// Implement the identical functionality for filter and not
 
function winnow( elements, qualifier, not ) {
 
if ( isFunction( qualifier ) ) {
 
return jQuery.grep( elements, function( elem, i ) {
 
return !!qualifier.call( elem, i, elem ) !== not;
 
} );
 
}
 
 
// Single element
 
if ( qualifier.nodeType ) {
 
return jQuery.grep( elements, function( elem ) {
 
return ( elem === qualifier ) !== not;
 
} );
 
}
 
 
// Arraylike of elements (jQuery, arguments, Array)
 
if ( typeof qualifier !== "string" ) {
 
return jQuery.grep( elements, function( elem ) {
 
return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
 
} );
 
}
 
 
// Filtered directly for both simple and complex selectors
 
return jQuery.filter( qualifier, elements, not );
 
}
 
 
jQuery.filter = function( expr, elems, not ) {
 
var elem = elems[ 0 ];
 
 
if ( not ) {
 
expr = ":not(" + expr + ")";
 
}
 
 
if ( elems.length === 1 && elem.nodeType === 1 ) {
 
return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
 
}
 
 
return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
 
return elem.nodeType === 1;
 
} ) );
 
};
 
 
jQuery.fn.extend( {
 
find: function( selector ) {
 
var i, ret,
 
len = this.length,
 
self = this;
 
 
if ( typeof selector !== "string" ) {
 
return this.pushStack( jQuery( selector ).filter( function() {
 
for ( i = 0; i < len; i++ ) {
 
if ( jQuery.contains( self[ i ], this ) ) {
 
return true;
 
}
 
}
 
} ) );
 
}
 
 
ret = this.pushStack( [] );
 
 
for ( i = 0; i < len; i++ ) {
 
jQuery.find( selector, self[ i ], ret );
 
}
 
 
return len > 1 ? jQuery.uniqueSort( ret ) : ret;
 
},
 
filter: function( selector ) {
 
return this.pushStack( winnow( this, selector || [], false ) );
 
},
 
not: function( selector ) {
 
return this.pushStack( winnow( this, selector || [], true ) );
 
},
 
is: function( selector ) {
 
return !!winnow(
 
this,
 
 
// If this is a positional/relative selector, check membership in the returned set
 
// so $("p:first").is("p:last") won't return true for a doc with two "p".
 
typeof selector === "string" && rneedsContext.test( selector ) ?
 
jQuery( selector ) :
 
selector || [],
 
false
 
).length;
 
}
 
} );
 
 
 
// Initialize a jQuery object
 
 
 
// A central reference to the root jQuery(document)
 
var rootjQuery,
 
 
// A simple way to check for HTML strings
 
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
 
// Strict HTML recognition (#11290: must start with <)
 
// Shortcut simple #id case for speed
 
rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
 
 
init = jQuery.fn.init = function( selector, context, root ) {
 
var match, elem;
 
 
// HANDLE: $(""), $(null), $(undefined), $(false)
 
if ( !selector ) {
 
return this;
 
}
 
 
// Method init() accepts an alternate rootjQuery
 
// so migrate can support jQuery.sub (gh-2101)
 
root = root || rootjQuery;
 
 
// Handle HTML strings
 
if ( typeof selector === "string" ) {
 
if ( selector[ 0 ] === "<" &&
 
selector[ selector.length - 1 ] === ">" &&
 
selector.length >= 3 ) {
 
 
// Assume that strings that start and end with <> are HTML and skip the regex check
 
match = [ null, selector, null ];
 
 
} else {
 
match = rquickExpr.exec( selector );
 
}
 
 
// Match html or make sure no context is specified for #id
 
if ( match && ( match[ 1 ] || !context ) ) {
 
 
// HANDLE: $(html) -> $(array)
 
if ( match[ 1 ] ) {
 
context = context instanceof jQuery ? context[ 0 ] : context;
 
 
// Option to run scripts is true for back-compat
 
// Intentionally let the error be thrown if parseHTML is not present
 
jQuery.merge( this, jQuery.parseHTML(
 
match[ 1 ],
 
context && context.nodeType ? context.ownerDocument || context : document,
 
true
 
) );
 
 
// HANDLE: $(html, props)
 
if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
 
for ( match in context ) {
 
 
// Properties of context are called as methods if possible
 
if ( isFunction( this[ match ] ) ) {
 
this[ match ]( context[ match ] );
 
 
// ...and otherwise set as attributes
 
} else {
 
this.attr( match, context[ match ] );
 
}
 
}
 
}
 
 
return this;
 
 
// HANDLE: $(#id)
 
} else {
 
elem = document.getElementById( match[ 2 ] );
 
 
if ( elem ) {
 
 
// Inject the element directly into the jQuery object
 
this[ 0 ] = elem;
 
this.length = 1;
 
}
 
return this;
 
}
 
 
// HANDLE: $(expr, $(...))
 
} else if ( !context || context.jquery ) {
 
return ( context || root ).find( selector );
 
 
// HANDLE: $(expr, context)
 
// (which is just equivalent to: $(context).find(expr)
 
} else {
 
return this.constructor( context ).find( selector );
 
}
 
 
// HANDLE: $(DOMElement)
 
} else if ( selector.nodeType ) {
 
this[ 0 ] = selector;
 
this.length = 1;
 
return this;
 
 
// HANDLE: $(function)
 
// Shortcut for document ready
 
} else if ( isFunction( selector ) ) {
 
return root.ready !== undefined ?
 
root.ready( selector ) :
 
 
// Execute immediately if ready is not present
 
selector( jQuery );
 
}
 
 
return jQuery.makeArray( selector, this );
 
};
 
 
// Give the init function the jQuery prototype for later instantiation
 
init.prototype = jQuery.fn;
 
 
// Initialize central reference
 
rootjQuery = jQuery( document );
 
 
 
var rparentsprev = /^(?:parents|prev(?:Until|All))/,
 
 
// Methods guaranteed to produce a unique set when starting from a unique set
 
guaranteedUnique = {
 
children: true,
 
contents: true,
 
next: true,
 
prev: true
 
};
 
 
jQuery.fn.extend( {
 
has: function( target ) {
 
var targets = jQuery( target, this ),
 
l = targets.length;
 
 
return this.filter( function() {
 
var i = 0;
 
for ( ; i < l; i++ ) {
 
if ( jQuery.contains( this, targets[ i ] ) ) {
 
return true;
 
}
 
}
 
} );
 
},
 
 
closest: function( selectors, context ) {
 
var cur,
 
i = 0,
 
l = this.length,
 
matched = [],
 
targets = typeof selectors !== "string" && jQuery( selectors );
 
 
// Positional selectors never match, since there's no _selection_ context
 
if ( !rneedsContext.test( selectors ) ) {
 
for ( ; i < l; i++ ) {
 
for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
 
 
// Always skip document fragments
 
if ( cur.nodeType < 11 && ( targets ?
 
targets.index( cur ) > -1 :
 
 
// Don't pass non-elements to Sizzle
 
cur.nodeType === 1 &&
 
jQuery.find.matchesSelector( cur, selectors ) ) ) {
 
 
matched.push( cur );
 
break;
 
}
 
}
 
}
 
}
 
 
return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
 
},
 
 
// Determine the position of an element within the set
 
index: function( elem ) {
 
 
// No argument, return index in parent
 
if ( !elem ) {
 
return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
 
}
 
 
// Index in selector
 
if ( typeof elem === "string" ) {
 
return indexOf.call( jQuery( elem ), this[ 0 ] );
 
}
 
 
// Locate the position of the desired element
 
return indexOf.call( this,
 
 
// If it receives a jQuery object, the first element is used
 
elem.jquery ? elem[ 0 ] : elem
 
);
 
},
 
 
add: function( selector, context ) {
 
return this.pushStack(
 
jQuery.uniqueSort(
 
jQuery.merge( this.get(), jQuery( selector, context ) )
 
)
 
);
 
},
 
 
addBack: function( selector ) {
 
return this.add( selector == null ?
 
this.prevObject : this.prevObject.filter( selector )
 
);
 
}
 
} );
 
 
function sibling( cur, dir ) {
 
while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
 
return cur;
 
}
 
 
jQuery.each( {
 
parent: function( elem ) {
 
var parent = elem.parentNode;
 
return parent && parent.nodeType !== 11 ? parent : null;
 
},
 
parents: function( elem ) {
 
return dir( elem, "parentNode" );
 
},
 
parentsUntil: function( elem, i, until ) {
 
return dir( elem, "parentNode", until );
 
},
 
next: function( elem ) {
 
return sibling( elem, "nextSibling" );
 
},
 
prev: function( elem ) {
 
return sibling( elem, "previousSibling" );
 
},
 
nextAll: function( elem ) {
 
return dir( elem, "nextSibling" );
 
},
 
prevAll: function( elem ) {
 
return dir( elem, "previousSibling" );
 
},
 
nextUntil: function( elem, i, until ) {
 
return dir( elem, "nextSibling", until );
 
},
 
prevUntil: function( elem, i, until ) {
 
return dir( elem, "previousSibling", until );
 
},
 
siblings: function( elem ) {
 
return siblings( ( elem.parentNode || {} ).firstChild, elem );
 
},
 
children: function( elem ) {
 
return siblings( elem.firstChild );
 
},
 
contents: function( elem ) {
 
        if ( nodeName( elem, "iframe" ) ) {
 
            return elem.contentDocument;
 
        }
 
 
        // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
 
        // Treat the template element as a regular one in browsers that
 
        // don't support it.
 
        if ( nodeName( elem, "template" ) ) {
 
            elem = elem.content || elem;
 
        }
 
 
        return jQuery.merge( [], elem.childNodes );
 
}
 
}, function( name, fn ) {
 
jQuery.fn[ name ] = function( until, selector ) {
 
var matched = jQuery.map( this, fn, until );
 
 
if ( name.slice( -5 ) !== "Until" ) {
 
selector = until;
 
}
 
 
if ( selector && typeof selector === "string" ) {
 
matched = jQuery.filter( selector, matched );
 
}
 
 
if ( this.length > 1 ) {
 
 
// Remove duplicates
 
if ( !guaranteedUnique[ name ] ) {
 
jQuery.uniqueSort( matched );
 
}
 
 
// Reverse order for parents* and prev-derivatives
 
if ( rparentsprev.test( name ) ) {
 
matched.reverse();
 
}
 
}
 
 
return this.pushStack( matched );
 
};
 
} );
 
var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
 
 
 
 
// Convert String-formatted options into Object-formatted ones
 
function createOptions( options ) {
 
var object = {};
 
jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
 
object[ flag ] = true;
 
} );
 
return object;
 
}
 
 
/*
 
* Create a callback list using the following parameters:
 
*
 
* options: an optional list of space-separated options that will change how
 
* the callback list behaves or a more traditional option object
 
*
 
* By default a callback list will act like an event callback list and can be
 
* "fired" multiple times.
 
*
 
* Possible options:
 
*
 
* once: will ensure the callback list can only be fired once (like a Deferred)
 
*
 
* memory: will keep track of previous values and will call any callback added
 
* after the list has been fired right away with the latest "memorized"
 
* values (like a Deferred)
 
*
 
* unique: will ensure a callback can only be added once (no duplicate in the list)
 
*
 
* stopOnFalse: interrupt callings when a callback returns false
 
*
 
*/
 
jQuery.Callbacks = function( options ) {
 
 
// Convert options from String-formatted to Object-formatted if needed
 
// (we check in cache first)
 
options = typeof options === "string" ?
 
createOptions( options ) :
 
jQuery.extend( {}, options );
 
 
var // Flag to know if list is currently firing
 
firing,
 
 
// Last fire value for non-forgettable lists
 
memory,
 
 
// Flag to know if list was already fired
 
fired,
 
 
// Flag to prevent firing
 
locked,
 
 
// Actual callback list
 
list = [],
 
 
// Queue of execution data for repeatable lists
 
queue = [],
 
 
// Index of currently firing callback (modified by add/remove as needed)
 
firingIndex = -1,
 
 
// Fire callbacks
 
fire = function() {
 
 
// Enforce single-firing
 
locked = locked || options.once;
 
 
// Execute callbacks for all pending executions,
 
// respecting firingIndex overrides and runtime changes
 
fired = firing = true;
 
for ( ; queue.length; firingIndex = -1 ) {
 
memory = queue.shift();
 
while ( ++firingIndex < list.length ) {
 
 
// Run callback and check for early termination
 
if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
 
options.stopOnFalse ) {
 
 
// Jump to end and forget the data so .add doesn't re-fire
 
firingIndex = list.length;
 
memory = false;
 
}
 
}
 
}
 
 
// Forget the data if we're done with it
 
if ( !options.memory ) {
 
memory = false;
 
}
 
 
firing = false;
 
 
// Clean up if we're done firing for good
 
if ( locked ) {
 
 
// Keep an empty list if we have data for future add calls
 
if ( memory ) {
 
list = [];
 
 
// Otherwise, this object is spent
 
} else {
 
list = "";
 
}
 
}
 
},
 
 
// Actual Callbacks object
 
self = {
 
 
// Add a callback or a collection of callbacks to the list
 
add: function() {
 
if ( list ) {
 
 
// If we have memory from a past run, we should fire after adding
 
if ( memory && !firing ) {
 
firingIndex = list.length - 1;
 
queue.push( memory );
 
}
 
 
( function add( args ) {
 
jQuery.each( args, function( _, arg ) {
 
if ( isFunction( arg ) ) {
 
if ( !options.unique || !self.has( arg ) ) {
 
list.push( arg );
 
}
 
} else if ( arg && arg.length && toType( arg ) !== "string" ) {
 
 
// Inspect recursively
 
add( arg );
 
}
 
} );
 
} )( arguments );
 
 
if ( memory && !firing ) {
 
fire();
 
}
 
}
 
return this;
 
},
 
 
// Remove a callback from the list
 
remove: function() {
 
jQuery.each( arguments, function( _, arg ) {
 
var index;
 
while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
 
list.splice( index, 1 );
 
 
// Handle firing indexes
 
if ( index <= firingIndex ) {
 
firingIndex--;
 
}
 
}
 
} );
 
return this;
 
},
 
 
// Check if a given callback is in the list.
 
// If no argument is given, return whether or not list has callbacks attached.
 
has: function( fn ) {
 
return fn ?
 
jQuery.inArray( fn, list ) > -1 :
 
list.length > 0;
 
},
 
 
// Remove all callbacks from the list
 
empty: function() {
 
if ( list ) {
 
list = [];
 
}
 
return this;
 
},
 
 
// Disable .fire and .add
 
// Abort any current/pending executions
 
// Clear all callbacks and values
 
disable: function() {
 
locked = queue = [];
 
list = memory = "";
 
return this;
 
},
 
disabled: function() {
 
return !list;
 
},
 
 
// Disable .fire
 
// Also disable .add unless we have memory (since it would have no effect)
 
// Abort any pending executions
 
lock: function() {
 
locked = queue = [];
 
if ( !memory && !firing ) {
 
list = memory = "";
 
}
 
return this;
 
},
 
locked: function() {
 
return !!locked;
 
},
 
 
// Call all callbacks with the given context and arguments
 
fireWith: function( context, args ) {
 
if ( !locked ) {
 
args = args || [];
 
args = [ context, args.slice ? args.slice() : args ];
 
queue.push( args );
 
if ( !firing ) {
 
fire();
 
}
 
}
 
return this;
 
},
 
 
// Call all the callbacks with the given arguments
 
fire: function() {
 
self.fireWith( this, arguments );
 
return this;
 
},
 
 
// To know if the callbacks have already been called at least once
 
fired: function() {
 
return !!fired;
 
}
 
};
 
 
return self;
 
};
 
 
 
function Identity( v ) {
 
return v;
 
}
 
function Thrower( ex ) {
 
throw ex;
 
}
 
 
function adoptValue( value, resolve, reject, noValue ) {
 
var method;
 
 
try {
 
 
// Check for promise aspect first to privilege synchronous behavior
 
if ( value && isFunction( ( method = value.promise ) ) ) {
 
method.call( value ).done( resolve ).fail( reject );
 
 
// Other thenables
 
} else if ( value && isFunction( ( method = value.then ) ) ) {
 
method.call( value, resolve, reject );
 
 
// Other non-thenables
 
} else {
 
 
// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
 
// * false: [ value ].slice( 0 ) => resolve( value )
 
// * true: [ value ].slice( 1 ) => resolve()
 
resolve.apply( undefined, [ value ].slice( noValue ) );
 
}
 
 
// For Promises/A+, convert exceptions into rejections
 
// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
 
// Deferred#then to conditionally suppress rejection.
 
} catch ( value ) {
 
 
// Support: Android 4.0 only
 
// Strict mode functions invoked without .call/.apply get global-object context
 
reject.apply( undefined, [ value ] );
 
}
 
}
 
 
jQuery.extend( {
 
 
Deferred: function( func ) {
 
var tuples = [
 
 
// action, add listener, callbacks,
 
// ... .then handlers, argument index, [final state]
 
[ "notify", "progress", jQuery.Callbacks( "memory" ),
 
jQuery.Callbacks( "memory" ), 2 ],
 
[ "resolve", "done", jQuery.Callbacks( "once memory" ),
 
jQuery.Callbacks( "once memory" ), 0, "resolved" ],
 
[ "reject", "fail", jQuery.Callbacks( "once memory" ),
 
jQuery.Callbacks( "once memory" ), 1, "rejected" ]
 
],
 
state = "pending",
 
promise = {
 
state: function() {
 
return state;
 
},
 
always: function() {
 
deferred.done( arguments ).fail( arguments );
 
return this;
 
},
 
"catch": function( fn ) {
 
return promise.then( null, fn );
 
},
 
 
// Keep pipe for back-compat
 
pipe: function( /* fnDone, fnFail, fnProgress */ ) {
 
var fns = arguments;
 
 
return jQuery.Deferred( function( newDefer ) {
 
jQuery.each( tuples, function( i, tuple ) {
 
 
// Map tuples (progress, done, fail) to arguments (done, fail, progress)
 
var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
 
 
// deferred.progress(function() { bind to newDefer or newDefer.notify })
 
// deferred.done(function() { bind to newDefer or newDefer.resolve })
 
// deferred.fail(function() { bind to newDefer or newDefer.reject })
 
deferred[ tuple[ 1 ] ]( function() {
 
var returned = fn && fn.apply( this, arguments );
 
if ( returned && isFunction( returned.promise ) ) {
 
returned.promise()
 
.progress( newDefer.notify )
 
.done( newDefer.resolve )
 
.fail( newDefer.reject );
 
} else {
 
newDefer[ tuple[ 0 ] + "With" ](
 
this,
 
fn ? [ returned ] : arguments
 
);
 
}
 
} );
 
} );
 
fns = null;
 
} ).promise();
 
},
 
then: function( onFulfilled, onRejected, onProgress ) {
 
var maxDepth = 0;
 
function resolve( depth, deferred, handler, special ) {
 
return function() {
 
var that = this,
 
args = arguments,
 
mightThrow = function() {
 
var returned, then;
 
 
// Support: Promises/A+ section 2.3.3.3.3
 
// https://promisesaplus.com/#point-59
 
// Ignore double-resolution attempts
 
if ( depth < maxDepth ) {
 
return;
 
}
 
 
returned = handler.apply( that, args );
 
 
// Support: Promises/A+ section 2.3.1
 
// https://promisesaplus.com/#point-48
 
if ( returned === deferred.promise() ) {
 
throw new TypeError( "Thenable self-resolution" );
 
}
 
 
// Support: Promises/A+ sections 2.3.3.1, 3.5
 
// https://promisesaplus.com/#point-54
 
// https://promisesaplus.com/#point-75
 
// Retrieve `then` only once
 
then = returned &&
 
 
// Support: Promises/A+ section 2.3.4
 
// https://promisesaplus.com/#point-64
 
// Only check objects and functions for thenability
 
( typeof returned === "object" ||
 
typeof returned === "function" ) &&
 
returned.then;
 
 
// Handle a returned thenable
 
if ( isFunction( then ) ) {
 
 
// Special processors (notify) just wait for resolution
 
if ( special ) {
 
then.call(
 
returned,
 
resolve( maxDepth, deferred, Identity, special ),
 
resolve( maxDepth, deferred, Thrower, special )
 
);
 
 
// Normal processors (resolve) also hook into progress
 
} else {
 
 
// ...and disregard older resolution values
 
maxDepth++;
 
 
then.call(
 
returned,
 
resolve( maxDepth, deferred, Identity, special ),
 
resolve( maxDepth, deferred, Thrower, special ),
 
resolve( maxDepth, deferred, Identity,
 
deferred.notifyWith )
 
);
 
}
 
 
// Handle all other returned values
 
} else {
 
 
// Only substitute handlers pass on context
 
// and multiple values (non-spec behavior)
 
if ( handler !== Identity ) {
 
that = undefined;
 
args = [ returned ];
 
}
 
 
// Process the value(s)
 
// Default process is resolve
 
( special || deferred.resolveWith )( that, args );
 
}
 
},
 
 
// Only normal processors (resolve) catch and reject exceptions
 
process = special ?
 
mightThrow :
 
function() {
 
try {
 
mightThrow();
 
} catch ( e ) {
 
 
if ( jQuery.Deferred.exceptionHook ) {
 
jQuery.Deferred.exceptionHook( e,
 
process.stackTrace );
 
}
 
 
// Support: Promises/A+ section 2.3.3.3.4.1
 
// https://promisesaplus.com/#point-61
 
// Ignore post-resolution exceptions
 
if ( depth + 1 >= maxDepth ) {
 
 
// Only substitute handlers pass on context
 
// and multiple values (non-spec behavior)
 
if ( handler !== Thrower ) {
 
that = undefined;
 
args = [ e ];
 
}
 
 
deferred.rejectWith( that, args );
 
}
 
}
 
};
 
 
// Support: Promises/A+ section 2.3.3.3.1
 
// https://promisesaplus.com/#point-57
 
// Re-resolve promises immediately to dodge false rejection from
 
// subsequent errors
 
if ( depth ) {
 
process();
 
} else {
 
 
// Call an optional hook to record the stack, in case of exception
 
// since it's otherwise lost when execution goes async
 
if ( jQuery.Deferred.getStackHook ) {
 
process.stackTrace = jQuery.Deferred.getStackHook();
 
}
 
window.setTimeout( process );
 
}
 
};
 
}
 
 
return jQuery.Deferred( function( newDefer ) {
 
 
// progress_handlers.add( ... )
 
tuples[ 0 ][ 3 ].add(
 
resolve(
 
0,
 
newDefer,
 
isFunction( onProgress ) ?
 
onProgress :
 
Identity,
 
newDefer.notifyWith
 
)
 
);
 
 
// fulfilled_handlers.add( ... )
 
tuples[ 1 ][ 3 ].add(
 
resolve(
 
0,
 
newDefer,
 
isFunction( onFulfilled ) ?
 
onFulfilled :
 
Identity
 
)
 
);
 
 
// rejected_handlers.add( ... )
 
tuples[ 2 ][ 3 ].add(
 
resolve(
 
0,
 
newDefer,
 
isFunction( onRejected ) ?
 
onRejected :
 
Thrower
 
)
 
);
 
} ).promise();
 
},
 
 
// Get a promise for this deferred
 
// If obj is provided, the promise aspect is added to the object
 
promise: function( obj ) {
 
return obj != null ? jQuery.extend( obj, promise ) : promise;
 
}
 
},
 
deferred = {};
 
 
// Add list-specific methods
 
jQuery.each( tuples, function( i, tuple ) {
 
var list = tuple[ 2 ],
 
stateString = tuple[ 5 ];
 
 
// promise.progress = list.add
 
// promise.done = list.add
 
// promise.fail = list.add
 
promise[ tuple[ 1 ] ] = list.add;
 
 
// Handle state
 
if ( stateString ) {
 
list.add(
 
function() {
 
 
// state = "resolved" (i.e., fulfilled)
 
// state = "rejected"
 
state = stateString;
 
},
 
 
// rejected_callbacks.disable
 
// fulfilled_callbacks.disable
 
tuples[ 3 - i ][ 2 ].disable,
 
 
// rejected_handlers.disable
 
// fulfilled_handlers.disable
 
tuples[ 3 - i ][ 3 ].disable,
 
 
// progress_callbacks.lock
 
tuples[ 0 ][ 2 ].lock,
 
 
// progress_handlers.lock
 
tuples[ 0 ][ 3 ].lock
 
);
 
}
 
 
// progress_handlers.fire
 
// fulfilled_handlers.fire
 
// rejected_handlers.fire
 
list.add( tuple[ 3 ].fire );
 
 
// deferred.notify = function() { deferred.notifyWith(...) }
 
// deferred.resolve = function() { deferred.resolveWith(...) }
 
// deferred.reject = function() { deferred.rejectWith(...) }
 
deferred[ tuple[ 0 ] ] = function() {
 
deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
 
return this;
 
};
 
 
// deferred.notifyWith = list.fireWith
 
// deferred.resolveWith = list.fireWith
 
// deferred.rejectWith = list.fireWith
 
deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
 
} );
 
 
// Make the deferred a promise
 
promise.promise( deferred );
 
 
// Call given func if any
 
if ( func ) {
 
func.call( deferred, deferred );
 
}
 
 
// All done!
 
return deferred;
 
},
 
 
// Deferred helper
 
when: function( singleValue ) {
 
var
 
 
// count of uncompleted subordinates
 
remaining = arguments.length,
 
 
// count of unprocessed arguments
 
i = remaining,
 
 
// subordinate fulfillment data
 
resolveContexts = Array( i ),
 
resolveValues = slice.call( arguments ),
 
 
// the master Deferred
 
master = jQuery.Deferred(),
 
 
// subordinate callback factory
 
updateFunc = function( i ) {
 
return function( value ) {
 
resolveContexts[ i ] = this;
 
resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
 
if ( !( --remaining ) ) {
 
master.resolveWith( resolveContexts, resolveValues );
 
}
 
};
 
};
 
 
// Single- and empty arguments are adopted like Promise.resolve
 
if ( remaining <= 1 ) {
 
adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
 
!remaining );
 
 
// Use .then() to unwrap secondary thenables (cf. gh-3000)
 
if ( master.state() === "pending" ||
 
isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
 
 
return master.then();
 
}
 
}
 
 
// Multiple arguments are aggregated like Promise.all array elements
 
while ( i-- ) {
 
adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
 
}
 
 
return master.promise();
 
}
 
} );
 
 
 
// These usually indicate a programmer mistake during development,
 
// warn about them ASAP rather than swallowing them by default.
 
var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
 
 
jQuery.Deferred.exceptionHook = function( error, stack ) {
 
 
// Support: IE 8 - 9 only
 
// Console exists when dev tools are open, which can happen at any time
 
if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
 
window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
 
}
 
};
 
 
 
 
 
jQuery.readyException = function( error ) {
 
window.setTimeout( function() {
 
throw error;
 
} );
 
};
 
 
 
 
 
// The deferred used on DOM ready
 
var readyList = jQuery.Deferred();
 
 
jQuery.fn.ready = function( fn ) {
 
 
readyList
 
.then( fn )
 
 
// Wrap jQuery.readyException in a function so that the lookup
 
// happens at the time of error handling instead of callback
 
// registration.
 
.catch( function( error ) {
 
jQuery.readyException( error );
 
} );
 
 
return this;
 
};
 
 
jQuery.extend( {
 
 
// Is the DOM ready to be used? Set to true once it occurs.
 
isReady: false,
 
 
// A counter to track how many items to wait for before
 
// the ready event fires. See #6781
 
readyWait: 1,
 
 
// Handle when the DOM is ready
 
ready: function( wait ) {
 
 
// Abort if there are pending holds or we're already ready
 
if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
 
return;
 
}
 
 
// Remember that the DOM is ready
 
jQuery.isReady = true;
 
 
// If a normal DOM Ready event fired, decrement, and wait if need be
 
if ( wait !== true && --jQuery.readyWait > 0 ) {
 
return;
 
}
 
 
// If there are functions bound, to execute
 
readyList.resolveWith( document, [ jQuery ] );
 
}
 
} );
 
 
jQuery.ready.then = readyList.then;
 
 
// The ready event handler and self cleanup method
 
function completed() {
 
document.removeEventListener( "DOMContentLoaded", completed );
 
window.removeEventListener( "load", completed );
 
jQuery.ready();
 
}
 
 
// Catch cases where $(document).ready() is called
 
// after the browser event has already occurred.
 
// Support: IE <=9 - 10 only
 
// Older IE sometimes signals "interactive" too soon
 
if ( document.readyState === "complete" ||
 
( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
 
 
// Handle it asynchronously to allow scripts the opportunity to delay ready
 
window.setTimeout( jQuery.ready );
 
 
} else {
 
 
// Use the handy event callback
 
document.addEventListener( "DOMContentLoaded", completed );
 
 
// A fallback to window.onload, that will always work
 
window.addEventListener( "load", completed );
 
}
 
 
 
 
 
// Multifunctional method to get and set values of a collection
 
// The value/s can optionally be executed if it's a function
 
var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
 
var i = 0,
 
len = elems.length,
 
bulk = key == null;
 
 
// Sets many values
 
if ( toType( key ) === "object" ) {
 
chainable = true;
 
for ( i in key ) {
 
access( elems, fn, i, key[ i ], true, emptyGet, raw );
 
}
 
 
// Sets one value
 
} else if ( value !== undefined ) {
 
chainable = true;
 
 
if ( !isFunction( value ) ) {
 
raw = true;
 
}
 
 
if ( bulk ) {
 
 
// Bulk operations run against the entire set
 
if ( raw ) {
 
fn.call( elems, value );
 
fn = null;
 
 
// ...except when executing function values
 
} else {
 
bulk = fn;
 
fn = function( elem, key, value ) {
 
return bulk.call( jQuery( elem ), value );
 
};
 
}
 
}
 
 
if ( fn ) {
 
for ( ; i < len; i++ ) {
 
fn(
 
elems[ i ], key, raw ?
 
value :
 
value.call( elems[ i ], i, fn( elems[ i ], key ) )
 
);
 
}
 
}
 
}
 
 
if ( chainable ) {
 
return elems;
 
}
 
 
// Gets
 
if ( bulk ) {
 
return fn.call( elems );
 
}
 
 
return len ? fn( elems[ 0 ], key ) : emptyGet;
 
};
 
 
 
// Matches dashed string for camelizing
 
var rmsPrefix = /^-ms-/,
 
rdashAlpha = /-([a-z])/g;
 
 
// Used by camelCase as callback to replace()
 
function fcamelCase( all, letter ) {
 
return letter.toUpperCase();
 
}
 
 
// Convert dashed to camelCase; used by the css and data modules
 
// Support: IE <=9 - 11, Edge 12 - 15
 
// Microsoft forgot to hump their vendor prefix (#9572)
 
function camelCase( string ) {
 
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
 
}
 
var acceptData = function( owner ) {
 
 
// Accepts only:
 
//  - Node
 
//    - Node.ELEMENT_NODE
 
//    - Node.DOCUMENT_NODE
 
//  - Object
 
//    - Any
 
return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
 
};
 
 
 
 
 
function Data() {
 
this.expando = jQuery.expando + Data.uid++;
 
}
 
 
Data.uid = 1;
 
 
Data.prototype = {
 
 
cache: function( owner ) {
 
 
// Check if the owner object already has a cache
 
var value = owner[ this.expando ];
 
 
// If not, create one
 
if ( !value ) {
 
value = {};
 
 
// We can accept data for non-element nodes in modern browsers,
 
// but we should not, see #8335.
 
// Always return an empty object.
 
if ( acceptData( owner ) ) {
 
 
// If it is a node unlikely to be stringify-ed or looped over
 
// use plain assignment
 
if ( owner.nodeType ) {
 
owner[ this.expando ] = value;
 
 
// Otherwise secure it in a non-enumerable property
 
// configurable must be true to allow the property to be
 
// deleted when data is removed
 
} else {
 
Object.defineProperty( owner, this.expando, {
 
value: value,
 
configurable: true
 
} );
 
}
 
}
 
}
 
 
return value;
 
},
 
set: function( owner, data, value ) {
 
var prop,
 
cache = this.cache( owner );
 
 
// Handle: [ owner, key, value ] args
 
// Always use camelCase key (gh-2257)
 
if ( typeof data === "string" ) {
 
cache[ camelCase( data ) ] = value;
 
 
// Handle: [ owner, { properties } ] args
 
} else {
 
 
// Copy the properties one-by-one to the cache object
 
for ( prop in data ) {
 
cache[ camelCase( prop ) ] = data[ prop ];
 
}
 
}
 
return cache;
 
},
 
get: function( owner, key ) {
 
return key === undefined ?
 
this.cache( owner ) :
 
 
// Always use camelCase key (gh-2257)
 
owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
 
},
 
access: function( owner, key, value ) {
 
 
// In cases where either:
 
//
 
//  1. No key was specified
 
//  2. A string key was specified, but no value provided
 
//
 
// Take the "read" path and allow the get method to determine
 
// which value to return, respectively either:
 
//
 
//  1. The entire cache object
 
//  2. The data stored at the key
 
//
 
if ( key === undefined ||
 
( ( key && typeof key === "string" ) && value === undefined ) ) {
 
 
return this.get( owner, key );
 
}
 
 
// When the key is not a string, or both a key and value
 
// are specified, set or extend (existing objects) with either:
 
//
 
//  1. An object of properties
 
//  2. A key and value
 
//
 
this.set( owner, key, value );
 
 
// Since the "set" path can have two possible entry points
 
// return the expected data based on which path was taken[*]
 
return value !== undefined ? value : key;
 
},
 
remove: function( owner, key ) {
 
var i,
 
cache = owner[ this.expando ];
 
 
if ( cache === undefined ) {
 
return;
 
}
 
 
if ( key !== undefined ) {
 
 
// Support array or space separated string of keys
 
if ( Array.isArray( key ) ) {
 
 
// If key is an array of keys...
 
// We always set camelCase keys, so remove that.
 
key = key.map( camelCase );
 
} else {
 
key = camelCase( key );
 
 
// If a key with the spaces exists, use it.
 
// Otherwise, create an array by matching non-whitespace
 
key = key in cache ?
 
[ key ] :
 
( key.match( rnothtmlwhite ) || [] );
 
}
 
 
i = key.length;
 
 
while ( i-- ) {
 
delete cache[ key[ i ] ];
 
}
 
}
 
 
// Remove the expando if there's no more data
 
if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
 
 
// Support: Chrome <=35 - 45
 
// Webkit & Blink performance suffers when deleting properties
 
// from DOM nodes, so set to undefined instead
 
// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
 
if ( owner.nodeType ) {
 
owner[ this.expando ] = undefined;
 
} else {
 
delete owner[ this.expando ];
 
}
 
}
 
},
 
hasData: function( owner ) {
 
var cache = owner[ this.expando ];
 
return cache !== undefined && !jQuery.isEmptyObject( cache );
 
}
 
};
 
var dataPriv = new Data();
 
 
var dataUser = new Data();
 
 
 
 
// Implementation Summary
 
//
 
// 1. Enforce API surface and semantic compatibility with 1.9.x branch
 
// 2. Improve the module's maintainability by reducing the storage
 
// paths to a single mechanism.
 
// 3. Use the same single mechanism to support "private" and "user" data.
 
// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
 
// 5. Avoid exposing implementation details on user objects (eg. expando properties)
 
// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
 
 
var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
 
rmultiDash = /[A-Z]/g;
 
 
function getData( data ) {
 
if ( data === "true" ) {
 
return true;
 
}
 
 
if ( data === "false" ) {
 
return false;
 
}
 
 
if ( data === "null" ) {
 
return null;
 
}
 
 
// Only convert to a number if it doesn't change the string
 
if ( data === +data + "" ) {
 
return +data;
 
}
 
 
if ( rbrace.test( data ) ) {
 
return JSON.parse( data );
 
}
 
 
return data;
 
}
 
 
function dataAttr( elem, key, data ) {
 
var name;
 
 
// If nothing was found internally, try to fetch any
 
// data from the HTML5 data-* attribute
 
if ( data === undefined && elem.nodeType === 1 ) {
 
name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
 
data = elem.getAttribute( name );
 
 
if ( typeof data === "string" ) {
 
try {
 
data = getData( data );
 
} catch ( e ) {}
 
 
// Make sure we set the data so it isn't changed later
 
dataUser.set( elem, key, data );
 
} else {
 
data = undefined;
 
}
 
}
 
return data;
 
}
 
 
jQuery.extend( {
 
hasData: function( elem ) {
 
return dataUser.hasData( elem ) || dataPriv.hasData( elem );
 
},
 
 
data: function( elem, name, data ) {
 
return dataUser.access( elem, name, data );
 
},
 
 
removeData: function( elem, name ) {
 
dataUser.remove( elem, name );
 
},
 
 
// TODO: Now that all calls to _data and _removeData have been replaced
 
// with direct calls to dataPriv methods, these can be deprecated.
 
_data: function( elem, name, data ) {
 
return dataPriv.access( elem, name, data );
 
},
 
 
_removeData: function( elem, name ) {
 
dataPriv.remove( elem, name );
 
}
 
} );
 
 
jQuery.fn.extend( {
 
data: function( key, value ) {
 
var i, name, data,
 
elem = this[ 0 ],
 
attrs = elem && elem.attributes;
 
 
// Gets all values
 
if ( key === undefined ) {
 
if ( this.length ) {
 
data = dataUser.get( elem );
 
 
if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
 
i = attrs.length;
 
while ( i-- ) {
 
 
// Support: IE 11 only
 
// The attrs elements can be null (#14894)
 
if ( attrs[ i ] ) {
 
name = attrs[ i ].name;
 
if ( name.indexOf( "data-" ) === 0 ) {
 
name = camelCase( name.slice( 5 ) );
 
dataAttr( elem, name, data[ name ] );
 
}
 
}
 
}
 
dataPriv.set( elem, "hasDataAttrs", true );
 
}
 
}
 
 
return data;
 
}
 
 
// Sets multiple values
 
if ( typeof key === "object" ) {
 
return this.each( function() {
 
dataUser.set( this, key );
 
} );
 
}
 
 
return access( this, function( value ) {
 
var data;
 
 
// The calling jQuery object (element matches) is not empty
 
// (and therefore has an element appears at this[ 0 ]) and the
 
// `value` parameter was not undefined. An empty jQuery object
 
// will result in `undefined` for elem = this[ 0 ] which will
 
// throw an exception if an attempt to read a data cache is made.
 
if ( elem && value === undefined ) {
 
 
// Attempt to get data from the cache
 
// The key will always be camelCased in Data
 
data = dataUser.get( elem, key );
 
if ( data !== undefined ) {
 
return data;
 
}
 
 
// Attempt to "discover" the data in
 
// HTML5 custom data-* attrs
 
data = dataAttr( elem, key );
 
if ( data !== undefined ) {
 
return data;
 
}
 
 
// We tried really hard, but the data doesn't exist.
 
return;
 
}
 
 
// Set the data...
 
this.each( function() {
 
 
// We always store the camelCased key
 
dataUser.set( this, key, value );
 
} );
 
}, null, value, arguments.length > 1, null, true );
 
},
 
 
removeData: function( key ) {
 
return this.each( function() {
 
dataUser.remove( this, key );
 
} );
 
}
 
} );
 
 
 
jQuery.extend( {
 
queue: function( elem, type, data ) {
 
var queue;
 
 
if ( elem ) {
 
type = ( type || "fx" ) + "queue";
 
queue = dataPriv.get( elem, type );
 
 
// Speed up dequeue by getting out quickly if this is just a lookup
 
if ( data ) {
 
if ( !queue || Array.isArray( data ) ) {
 
queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
 
} else {
 
queue.push( data );
 
}
 
}
 
return queue || [];
 
}
 
},
 
 
dequeue: function( elem, type ) {
 
type = type || "fx";
 
 
var queue = jQuery.queue( elem, type ),
 
startLength = queue.length,
 
fn = queue.shift(),
 
hooks = jQuery._queueHooks( elem, type ),
 
next = function() {
 
jQuery.dequeue( elem, type );
 
};
 
 
// If the fx queue is dequeued, always remove the progress sentinel
 
if ( fn === "inprogress" ) {
 
fn = queue.shift();
 
startLength--;
 
}
 
 
if ( fn ) {
 
 
// Add a progress sentinel to prevent the fx queue from being
 
// automatically dequeued
 
if ( type === "fx" ) {
 
queue.unshift( "inprogress" );
 
}
 
 
// Clear up the last queue stop function
 
delete hooks.stop;
 
fn.call( elem, next, hooks );
 
}
 
 
if ( !startLength && hooks ) {
 
hooks.empty.fire();
 
}
 
},
 
 
// Not public - generate a queueHooks object, or return the current one
 
_queueHooks: function( elem, type ) {
 
var key = type + "queueHooks";
 
return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
 
empty: jQuery.Callbacks( "once memory" ).add( function() {
 
dataPriv.remove( elem, [ type + "queue", key ] );
 
} )
 
} );
 
}
 
} );
 
 
jQuery.fn.extend( {
 
queue: function( type, data ) {
 
var setter = 2;
 
 
if ( typeof type !== "string" ) {
 
data = type;
 
type = "fx";
 
setter--;
 
}
 
 
if ( arguments.length < setter ) {
 
return jQuery.queue( this[ 0 ], type );
 
}
 
 
return data === undefined ?
 
this :
 
this.each( function() {
 
var queue = jQuery.queue( this, type, data );
 
 
// Ensure a hooks for this queue
 
jQuery._queueHooks( this, type );
 
 
if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
 
jQuery.dequeue( this, type );
 
}
 
} );
 
},
 
dequeue: function( type ) {
 
return this.each( function() {
 
jQuery.dequeue( this, type );
 
} );
 
},
 
clearQueue: function( type ) {
 
return this.queue( type || "fx", [] );
 
},
 
 
// Get a promise resolved when queues of a certain type
 
// are emptied (fx is the type by default)
 
promise: function( type, obj ) {
 
var tmp,
 
count = 1,
 
defer = jQuery.Deferred(),
 
elements = this,
 
i = this.length,
 
resolve = function() {
 
if ( !( --count ) ) {
 
defer.resolveWith( elements, [ elements ] );
 
}
 
};
 
 
if ( typeof type !== "string" ) {
 
obj = type;
 
type = undefined;
 
}
 
type = type || "fx";
 
 
while ( i-- ) {
 
tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
 
if ( tmp && tmp.empty ) {
 
count++;
 
tmp.empty.add( resolve );
 
}
 
}
 
resolve();
 
return defer.promise( obj );
 
}
 
} );
 
var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
 
 
var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
 
 
 
var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
 
 
var isHiddenWithinTree = function( elem, el ) {
 
 
// isHiddenWithinTree might be called from jQuery#filter function;
 
// in that case, element will be second argument
 
elem = el || elem;
 
 
// Inline style trumps all
 
return elem.style.display === "none" ||
 
elem.style.display === "" &&
 
 
// Otherwise, check computed style
 
// Support: Firefox <=43 - 45
 
// Disconnected elements can have computed display: none, so first confirm that elem is
 
// in the document.
 
jQuery.contains( elem.ownerDocument, elem ) &&
 
 
jQuery.css( elem, "display" ) === "none";
 
};
 
 
var swap = function( elem, options, callback, args ) {
 
var ret, name,
 
old = {};
 
 
// Remember the old values, and insert the new ones
 
for ( name in options ) {
 
old[ name ] = elem.style[ name ];
 
elem.style[ name ] = options[ name ];
 
}
 
 
ret = callback.apply( elem, args || [] );
 
 
// Revert the old values
 
for ( name in options ) {
 
elem.style[ name ] = old[ name ];
 
}
 
 
return ret;
 
};
 
 
 
 
 
function adjustCSS( elem, prop, valueParts, tween ) {
 
var adjusted, scale,
 
maxIterations = 20,
 
currentValue = tween ?
 
function() {
 
return tween.cur();
 
} :
 
function() {
 
return jQuery.css( elem, prop, "" );
 
},
 
initial = currentValue(),
 
unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
 
 
// Starting value computation is required for potential unit mismatches
 
initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
 
rcssNum.exec( jQuery.css( elem, prop ) );
 
 
if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
 
 
// Support: Firefox <=54
 
// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
 
initial = initial / 2;
 
 
// Trust units reported by jQuery.css
 
unit = unit || initialInUnit[ 3 ];
 
 
// Iteratively approximate from a nonzero starting point
 
initialInUnit = +initial || 1;
 
 
while ( maxIterations-- ) {
 
 
// Evaluate and update our best guess (doubling guesses that zero out).
 
// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
 
jQuery.style( elem, prop, initialInUnit + unit );
 
if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
 
maxIterations = 0;
 
}
 
initialInUnit = initialInUnit / scale;
 
 
}
 
 
initialInUnit = initialInUnit * 2;
 
jQuery.style( elem, prop, initialInUnit + unit );
 
 
// Make sure we update the tween properties later on
 
valueParts = valueParts || [];
 
}
 
 
if ( valueParts ) {
 
initialInUnit = +initialInUnit || +initial || 0;
 
 
// Apply relative offset (+=/-=) if specified
 
adjusted = valueParts[ 1 ] ?
 
initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
 
+valueParts[ 2 ];
 
if ( tween ) {
 
tween.unit = unit;
 
tween.start = initialInUnit;
 
tween.end = adjusted;
 
}
 
}
 
return adjusted;
 
}
 
 
 
var defaultDisplayMap = {};
 
 
function getDefaultDisplay( elem ) {
 
var temp,
 
doc = elem.ownerDocument,
 
nodeName = elem.nodeName,
 
display = defaultDisplayMap[ nodeName ];
 
 
if ( display ) {
 
return display;
 
}
 
 
temp = doc.body.appendChild( doc.createElement( nodeName ) );
 
display = jQuery.css( temp, "display" );
 
 
temp.parentNode.removeChild( temp );
 
 
if ( display === "none" ) {
 
display = "block";
 
}
 
defaultDisplayMap[ nodeName ] = display;
 
 
return display;
 
}
 
 
function showHide( elements, show ) {
 
var display, elem,
 
values = [],
 
index = 0,
 
length = elements.length;
 
 
// Determine new display value for elements that need to change
 
for ( ; index < length; index++ ) {
 
elem = elements[ index ];
 
if ( !elem.style ) {
 
continue;
 
}
 
 
display = elem.style.display;
 
if ( show ) {
 
 
// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
 
// check is required in this first loop unless we have a nonempty display value (either
 
// inline or about-to-be-restored)
 
if ( display === "none" ) {
 
values[ index ] = dataPriv.get( elem, "display" ) || null;
 
if ( !values[ index ] ) {
 
elem.style.display = "";
 
}
 
}
 
if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
 
values[ index ] = getDefaultDisplay( elem );
 
}
 
} else {
 
if ( display !== "none" ) {
 
values[ index ] = "none";
 
 
// Remember what we're overwriting
 
dataPriv.set( elem, "display", display );
 
}
 
}
 
}
 
 
// Set the display of the elements in a second loop to avoid constant reflow
 
for ( index = 0; index < length; index++ ) {
 
if ( values[ index ] != null ) {
 
elements[ index ].style.display = values[ index ];
 
}
 
}
 
 
return elements;
 
}
 
 
jQuery.fn.extend( {
 
show: function() {
 
return showHide( this, true );
 
},
 
hide: function() {
 
return showHide( this );
 
},
 
toggle: function( state ) {
 
if ( typeof state === "boolean" ) {
 
return state ? this.show() : this.hide();
 
}
 
 
return this.each( function() {
 
if ( isHiddenWithinTree( this ) ) {
 
jQuery( this ).show();
 
} else {
 
jQuery( this ).hide();
 
}
 
} );
 
}
 
} );
 
var rcheckableType = ( /^(?:checkbox|radio)$/i );
 
 
var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
 
 
var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
 
 
 
 
// We have to close these tags to support XHTML (#13200)
 
var wrapMap = {
 
 
// Support: IE <=9 only
 
option: [ 1, "<select multiple='multiple'>", "</select>" ],
 
 
// XHTML parsers do not magically insert elements in the
 
// same way that tag soup parsers do. So we cannot shorten
 
// this by omitting <tbody> or other required elements.
 
thead: [ 1, "<table>", "</table>" ],
 
col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
 
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
 
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
 
 
_default: [ 0, "", "" ]
 
};
 
 
// Support: IE <=9 only
 
wrapMap.optgroup = wrapMap.option;
 
 
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
 
wrapMap.th = wrapMap.td;
 
 
 
function getAll( context, tag ) {
 
 
// Support: IE <=9 - 11 only
 
// Use typeof to avoid zero-argument method invocation on host objects (#15151)
 
var ret;
 
 
if ( typeof context.getElementsByTagName !== "undefined" ) {
 
ret = context.getElementsByTagName( tag || "*" );
 
 
} else if ( typeof context.querySelectorAll !== "undefined" ) {
 
ret = context.querySelectorAll( tag || "*" );
 
 
} else {
 
ret = [];
 
}
 
 
if ( tag === undefined || tag && nodeName( context, tag ) ) {
 
return jQuery.merge( [ context ], ret );
 
}
 
 
return ret;
 
}
 
 
 
// Mark scripts as having already been evaluated
 
function setGlobalEval( elems, refElements ) {
 
var i = 0,
 
l = elems.length;
 
 
for ( ; i < l; i++ ) {
 
dataPriv.set(
 
elems[ i ],
 
"globalEval",
 
!refElements || dataPriv.get( refElements[ i ], "globalEval" )
 
);
 
}
 
}
 
 
 
var rhtml = /<|&#?\w+;/;
 
 
function buildFragment( elems, context, scripts, selection, ignored ) {
 
var elem, tmp, tag, wrap, contains, j,
 
fragment = context.createDocumentFragment(),
 
nodes = [],
 
i = 0,
 
l = elems.length;
 
 
for ( ; i < l; i++ ) {
 
elem = elems[ i ];
 
 
if ( elem || elem === 0 ) {
 
 
// Add nodes directly
 
if ( toType( elem ) === "object" ) {
 
 
// Support: Android <=4.0 only, PhantomJS 1 only
 
// push.apply(_, arraylike) throws on ancient WebKit
 
jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
 
 
// Convert non-html into a text node
 
} else if ( !rhtml.test( elem ) ) {
 
nodes.push( context.createTextNode( elem ) );
 
 
// Convert html into DOM nodes
 
} else {
 
tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
 
 
// Deserialize a standard representation
 
tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
 
wrap = wrapMap[ tag ] || wrapMap._default;
 
tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
 
 
// Descend through wrappers to the right content
 
j = wrap[ 0 ];
 
while ( j-- ) {
 
tmp = tmp.lastChild;
 
}
 
 
// Support: Android <=4.0 only, PhantomJS 1 only
 
// push.apply(_, arraylike) throws on ancient WebKit
 
jQuery.merge( nodes, tmp.childNodes );
 
 
// Remember the top-level container
 
tmp = fragment.firstChild;
 
 
// Ensure the created nodes are orphaned (#12392)
 
tmp.textContent = "";
 
}
 
}
 
}
 
 
// Remove wrapper from fragment
 
fragment.textContent = "";
 
 
i = 0;
 
while ( ( elem = nodes[ i++ ] ) ) {
 
 
// Skip elements already in the context collection (trac-4087)
 
if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
 
if ( ignored ) {
 
ignored.push( elem );
 
}
 
continue;
 
}
 
 
contains = jQuery.contains( elem.ownerDocument, elem );
 
 
// Append to fragment
 
tmp = getAll( fragment.appendChild( elem ), "script" );
 
 
// Preserve script evaluation history
 
if ( contains ) {
 
setGlobalEval( tmp );
 
}
 
 
// Capture executables
 
if ( scripts ) {
 
j = 0;
 
while ( ( elem = tmp[ j++ ] ) ) {
 
if ( rscriptType.test( elem.type || "" ) ) {
 
scripts.push( elem );
 
}
 
}
 
}
 
}
 
 
return fragment;
 
}
 
 
 
( function() {
 
var fragment = document.createDocumentFragment(),
 
div = fragment.appendChild( document.createElement( "div" ) ),
 
input = document.createElement( "input" );
 
 
// Support: Android 4.0 - 4.3 only
 
// Check state lost if the name is set (#11217)
 
// Support: Windows Web Apps (WWA)
 
// `name` and `type` must use .setAttribute for WWA (#14901)
 
input.setAttribute( "type", "radio" );
 
input.setAttribute( "checked", "checked" );
 
input.setAttribute( "name", "t" );
 
 
div.appendChild( input );
 
 
// Support: Android <=4.1 only
 
// Older WebKit doesn't clone checked state correctly in fragments
 
support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
 
 
// Support: IE <=11 only
 
// Make sure textarea (and checkbox) defaultValue is properly cloned
 
div.innerHTML = "<textarea>x</textarea>";
 
support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
 
} )();
 
var documentElement = document.documentElement;
 
 
 
 
var
 
rkeyEvent = /^key/,
 
rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
 
rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
 
 
function returnTrue() {
 
return true;
 
}
 
 
function returnFalse() {
 
return false;
 
}
 
 
// Support: IE <=9 only
 
// See #13393 for more info
 
function safeActiveElement() {
 
try {
 
return document.activeElement;
 
} catch ( err ) { }
 
}
 
 
function on( elem, types, selector, data, fn, one ) {
 
var origFn, type;
 
 
// Types can be a map of types/handlers
 
if ( typeof types === "object" ) {
 
 
// ( types-Object, selector, data )
 
if ( typeof selector !== "string" ) {
 
 
// ( types-Object, data )
 
data = data || selector;
 
selector = undefined;
 
}
 
for ( type in types ) {
 
on( elem, type, selector, data, types[ type ], one );
 
}
 
return elem;
 
}
 
 
if ( data == null && fn == null ) {
 
 
// ( types, fn )
 
fn = selector;
 
data = selector = undefined;
 
} else if ( fn == null ) {
 
if ( typeof selector === "string" ) {
 
 
// ( types, selector, fn )
 
fn = data;
 
data = undefined;
 
} else {
 
 
// ( types, data, fn )
 
fn = data;
 
data = selector;
 
selector = undefined;
 
}
 
}
 
if ( fn === false ) {
 
fn = returnFalse;
 
} else if ( !fn ) {
 
return elem;
 
}
 
 
if ( one === 1 ) {
 
origFn = fn;
 
fn = function( event ) {
 
 
// Can use an empty set, since event contains the info
 
jQuery().off( event );
 
return origFn.apply( this, arguments );
 
};
 
 
// Use same guid so caller can remove using origFn
 
fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
 
}
 
return elem.each( function() {
 
jQuery.event.add( this, types, fn, data, selector );
 
} );
 
}
 
 
/*
 
* Helper functions for managing events -- not part of the public interface.
 
* Props to Dean Edwards' addEvent library for many of the ideas.
 
*/
 
jQuery.event = {
 
 
global: {},
 
 
add: function( elem, types, handler, data, selector ) {
 
 
var handleObjIn, eventHandle, tmp,
 
events, t, handleObj,
 
special, handlers, type, namespaces, origType,
 
elemData = dataPriv.get( elem );
 
 
// Don't attach events to noData or text/comment nodes (but allow plain objects)
 
if ( !elemData ) {
 
return;
 
}
 
 
// Caller can pass in an object of custom data in lieu of the handler
 
if ( handler.handler ) {
 
handleObjIn = handler;
 
handler = handleObjIn.handler;
 
selector = handleObjIn.selector;
 
}
 
 
// Ensure that invalid selectors throw exceptions at attach time
 
// Evaluate against documentElement in case elem is a non-element node (e.g., document)
 
if ( selector ) {
 
jQuery.find.matchesSelector( documentElement, selector );
 
}
 
 
// Make sure that the handler has a unique ID, used to find/remove it later
 
if ( !handler.guid ) {
 
handler.guid = jQuery.guid++;
 
}
 
 
// Init the element's event structure and main handler, if this is the first
 
if ( !( events = elemData.events ) ) {
 
events = elemData.events = {};
 
}
 
if ( !( eventHandle = elemData.handle ) ) {
 
eventHandle = elemData.handle = function( e ) {
 
 
// Discard the second event of a jQuery.event.trigger() and
 
// when an event is called after a page has unloaded
 
return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
 
jQuery.event.dispatch.apply( elem, arguments ) : undefined;
 
};
 
}
 
 
// Handle multiple events separated by a space
 
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
 
t = types.length;
 
while ( t-- ) {
 
tmp = rtypenamespace.exec( types[ t ] ) || [];
 
type = origType = tmp[ 1 ];
 
namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
 
 
// There *must* be a type, no attaching namespace-only handlers
 
if ( !type ) {
 
continue;
 
}
 
 
// If event changes its type, use the special event handlers for the changed type
 
special = jQuery.event.special[ type ] || {};
 
 
// If selector defined, determine special event api type, otherwise given type
 
type = ( selector ? special.delegateType : special.bindType ) || type;
 
 
// Update special based on newly reset type
 
special = jQuery.event.special[ type ] || {};
 
 
// handleObj is passed to all event handlers
 
handleObj = jQuery.extend( {
 
type: type,
 
origType: origType,
 
data: data,
 
handler: handler,
 
guid: handler.guid,
 
selector: selector,
 
needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
 
namespace: namespaces.join( "." )
 
}, handleObjIn );
 
 
// Init the event handler queue if we're the first
 
if ( !( handlers = events[ type ] ) ) {
 
handlers = events[ type ] = [];
 
handlers.delegateCount = 0;
 
 
// Only use addEventListener if the special events handler returns false
 
if ( !special.setup ||
 
special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
 
 
if ( elem.addEventListener ) {
 
elem.addEventListener( type, eventHandle );
 
}
 
}
 
}
 
 
if ( special.add ) {
 
special.add.call( elem, handleObj );
 
 
if ( !handleObj.handler.guid ) {
 
handleObj.handler.guid = handler.guid;
 
}
 
}
 
 
// Add to the element's handler list, delegates in front
 
if ( selector ) {
 
handlers.splice( handlers.delegateCount++, 0, handleObj );
 
} else {
 
handlers.push( handleObj );
 
}
 
 
// Keep track of which events have ever been used, for event optimization
 
jQuery.event.global[ type ] = true;
 
}
 
 
},
 
 
// Detach an event or set of events from an element
 
remove: function( elem, types, handler, selector, mappedTypes ) {
 
 
var j, origCount, tmp,
 
events, t, handleObj,
 
special, handlers, type, namespaces, origType,
 
elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
 
 
if ( !elemData || !( events = elemData.events ) ) {
 
return;
 
}
 
 
// Once for each type.namespace in types; type may be omitted
 
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
 
t = types.length;
 
while ( t-- ) {
 
tmp = rtypenamespace.exec( types[ t ] ) || [];
 
type = origType = tmp[ 1 ];
 
namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
 
 
// Unbind all events (on this namespace, if provided) for the element
 
if ( !type ) {
 
for ( type in events ) {
 
jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
 
}
 
continue;
 
}
 
 
special = jQuery.event.special[ type ] || {};
 
type = ( selector ? special.delegateType : special.bindType ) || type;
 
handlers = events[ type ] || [];
 
tmp = tmp[ 2 ] &&
 
new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
 
 
// Remove matching events
 
origCount = j = handlers.length;
 
while ( j-- ) {
 
handleObj = handlers[ j ];
 
 
if ( ( mappedTypes || origType === handleObj.origType ) &&
 
( !handler || handler.guid === handleObj.guid ) &&
 
( !tmp || tmp.test( handleObj.namespace ) ) &&
 
( !selector || selector === handleObj.selector ||
 
selector === "**" && handleObj.selector ) ) {
 
handlers.splice( j, 1 );
 
 
if ( handleObj.selector ) {
 
handlers.delegateCount--;
 
}
 
if ( special.remove ) {
 
special.remove.call( elem, handleObj );
 
}
 
}
 
}
 
 
// Remove generic event handler if we removed something and no more handlers exist
 
// (avoids potential for endless recursion during removal of special event handlers)
 
if ( origCount && !handlers.length ) {
 
if ( !special.teardown ||
 
special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
 
 
jQuery.removeEvent( elem, type, elemData.handle );
 
}
 
 
delete events[ type ];
 
}
 
}
 
 
// Remove data and the expando if it's no longer used
 
if ( jQuery.isEmptyObject( events ) ) {
 
dataPriv.remove( elem, "handle events" );
 
}
 
},
 
 
dispatch: function( nativeEvent ) {
 
 
// Make a writable jQuery.Event from the native event object
 
var event = jQuery.event.fix( nativeEvent );
 
 
var i, j, ret, matched, handleObj, handlerQueue,
 
args = new Array( arguments.length ),
 
handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
 
special = jQuery.event.special[ event.type ] || {};
 
 
// Use the fix-ed jQuery.Event rather than the (read-only) native event
 
args[ 0 ] = event;
 
 
for ( i = 1; i < arguments.length; i++ ) {
 
args[ i ] = arguments[ i ];
 
}
 
 
event.delegateTarget = this;
 
 
// Call the preDispatch hook for the mapped type, and let it bail if desired
 
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
 
return;
 
}
 
 
// Determine handlers
 
handlerQueue = jQuery.event.handlers.call( this, event, handlers );
 
 
// Run delegates first; they may want to stop propagation beneath us
 
i = 0;
 
while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
 
event.currentTarget = matched.elem;
 
 
j = 0;
 
while ( ( handleObj = matched.handlers[ j++ ] ) &&
 
!event.isImmediatePropagationStopped() ) {
 
 
// Triggered event must either 1) have no namespace, or 2) have namespace(s)
 
// a subset or equal to those in the bound event (both can have no namespace).
 
if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
 
 
event.handleObj = handleObj;
 
event.data = handleObj.data;
 
 
ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
 
handleObj.handler ).apply( matched.elem, args );
 
 
if ( ret !== undefined ) {
 
if ( ( event.result = ret ) === false ) {
 
event.preventDefault();
 
event.stopPropagation();
 
}
 
}
 
}
 
}
 
}
 
 
// Call the postDispatch hook for the mapped type
 
if ( special.postDispatch ) {
 
special.postDispatch.call( this, event );
 
}
 
 
return event.result;
 
},
 
 
handlers: function( event, handlers ) {
 
var i, handleObj, sel, matchedHandlers, matchedSelectors,
 
handlerQueue = [],
 
delegateCount = handlers.delegateCount,
 
cur = event.target;
 
 
// Find delegate handlers
 
if ( delegateCount &&
 
 
// Support: IE <=9
 
// Black-hole SVG <use> instance trees (trac-13180)
 
cur.nodeType &&
 
 
// Support: Firefox <=42
 
// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
 
// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
 
// Support: IE 11 only
 
// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
 
!( event.type === "click" && event.button >= 1 ) ) {
 
 
for ( ; cur !== this; cur = cur.parentNode || this ) {
 
 
// Don't check non-elements (#13208)
 
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
 
if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
 
matchedHandlers = [];
 
matchedSelectors = {};
 
for ( i = 0; i < delegateCount; i++ ) {
 
handleObj = handlers[ i ];
 
 
// Don't conflict with Object.prototype properties (#13203)
 
sel = handleObj.selector + " ";
 
 
if ( matchedSelectors[ sel ] === undefined ) {
 
matchedSelectors[ sel ] = handleObj.needsContext ?
 
jQuery( sel, this ).index( cur ) > -1 :
 
jQuery.find( sel, this, null, [ cur ] ).length;
 
}
 
if ( matchedSelectors[ sel ] ) {
 
matchedHandlers.push( handleObj );
 
}
 
}
 
if ( matchedHandlers.length ) {
 
handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
 
}
 
}
 
}
 
}
 
 
// Add the remaining (directly-bound) handlers
 
cur = this;
 
if ( delegateCount < handlers.length ) {
 
handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
 
}
 
 
return handlerQueue;
 
},
 
 
addProp: function( name, hook ) {
 
Object.defineProperty( jQuery.Event.prototype, name, {
 
enumerable: true,
 
configurable: true,
 
 
get: isFunction( hook ) ?
 
function() {
 
if ( this.originalEvent ) {
 
return hook( this.originalEvent );
 
}
 
} :
 
function() {
 
if ( this.originalEvent ) {
 
return this.originalEvent[ name ];
 
}
 
},
 
 
set: function( value ) {
 
Object.defineProperty( this, name, {
 
enumerable: true,
 
configurable: true,
 
writable: true,
 
value: value
 
} );
 
}
 
} );
 
},
 
 
fix: function( originalEvent ) {
 
return originalEvent[ jQuery.expando ] ?
 
originalEvent :
 
new jQuery.Event( originalEvent );
 
},
 
 
special: {
 
load: {
 
 
// Prevent triggered image.load events from bubbling to window.load
 
noBubble: true
 
},
 
focus: {
 
 
// Fire native event if possible so blur/focus sequence is correct
 
trigger: function() {
 
if ( this !== safeActiveElement() && this.focus ) {
 
this.focus();
 
return false;
 
}
 
},
 
delegateType: "focusin"
 
},
 
blur: {
 
trigger: function() {
 
if ( this === safeActiveElement() && this.blur ) {
 
this.blur();
 
return false;
 
}
 
},
 
delegateType: "focusout"
 
},
 
click: {
 
 
// For checkbox, fire native event so checked state will be right
 
trigger: function() {
 
if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
 
this.click();
 
return false;
 
}
 
},
 
 
// For cross-browser consistency, don't fire native .click() on links
 
_default: function( event ) {
 
return nodeName( event.target, "a" );
 
}
 
},
 
 
beforeunload: {
 
postDispatch: function( event ) {
 
 
// Support: Firefox 20+
 
// Firefox doesn't alert if the returnValue field is not set.
 
if ( event.result !== undefined && event.originalEvent ) {
 
event.originalEvent.returnValue = event.result;
 
}
 
}
 
}
 
}
 
};
 
 
jQuery.removeEvent = function( elem, type, handle ) {
 
 
// This "if" is needed for plain objects
 
if ( elem.removeEventListener ) {
 
elem.removeEventListener( type, handle );
 
}
 
};
 
 
jQuery.Event = function( src, props ) {
 
 
// Allow instantiation without the 'new' keyword
 
if ( !( this instanceof jQuery.Event ) ) {
 
return new jQuery.Event( src, props );
 
}
 
 
// Event object
 
if ( src && src.type ) {
 
this.originalEvent = src;
 
this.type = src.type;
 
 
// Events bubbling up the document may have been marked as prevented
 
// by a handler lower down the tree; reflect the correct value.
 
this.isDefaultPrevented = src.defaultPrevented ||
 
src.defaultPrevented === undefined &&
 
 
// Support: Android <=2.3 only
 
src.returnValue === false ?
 
returnTrue :
 
returnFalse;
 
 
// Create target properties
 
// Support: Safari <=6 - 7 only
 
// Target should not be a text node (#504, #13143)
 
this.target = ( src.target && src.target.nodeType === 3 ) ?
 
src.target.parentNode :
 
src.target;
 
 
this.currentTarget = src.currentTarget;
 
this.relatedTarget = src.relatedTarget;
 
 
// Event type
 
} else {
 
this.type = src;
 
}
 
 
// Put explicitly provided properties onto the event object
 
if ( props ) {
 
jQuery.extend( this, props );
 
}
 
 
// Create a timestamp if incoming event doesn't have one
 
this.timeStamp = src && src.timeStamp || Date.now();
 
 
// Mark it as fixed
 
this[ jQuery.expando ] = true;
 
};
 
 
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
 
// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
 
jQuery.Event.prototype = {
 
constructor: jQuery.Event,
 
isDefaultPrevented: returnFalse,
 
isPropagationStopped: returnFalse,
 
isImmediatePropagationStopped: returnFalse,
 
isSimulated: false,
 
 
preventDefault: function() {
 
var e = this.originalEvent;
 
 
this.isDefaultPrevented = returnTrue;
 
 
if ( e && !this.isSimulated ) {
 
e.preventDefault();
 
}
 
},
 
stopPropagation: function() {
 
var e = this.originalEvent;
 
 
this.isPropagationStopped = returnTrue;
 
 
if ( e && !this.isSimulated ) {
 
e.stopPropagation();
 
}
 
},
 
stopImmediatePropagation: function() {
 
var e = this.originalEvent;
 
 
this.isImmediatePropagationStopped = returnTrue;
 
 
if ( e && !this.isSimulated ) {
 
e.stopImmediatePropagation();
 
}
 
 
this.stopPropagation();
 
}
 
};
 
 
// Includes all common event props including KeyEvent and MouseEvent specific props
 
jQuery.each( {
 
altKey: true,
 
bubbles: true,
 
cancelable: true,
 
changedTouches: true,
 
ctrlKey: true,
 
detail: true,
 
eventPhase: true,
 
metaKey: true,
 
pageX: true,
 
pageY: true,
 
shiftKey: true,
 
view: true,
 
"char": true,
 
charCode: true,
 
key: true,
 
keyCode: true,
 
button: true,
 
buttons: true,
 
clientX: true,
 
clientY: true,
 
offsetX: true,
 
offsetY: true,
 
pointerId: true,
 
pointerType: true,
 
screenX: true,
 
screenY: true,
 
targetTouches: true,
 
toElement: true,
 
touches: true,
 
 
which: function( event ) {
 
var button = event.button;
 
 
// Add which for key events
 
if ( event.which == null && rkeyEvent.test( event.type ) ) {
 
return event.charCode != null ? event.charCode : event.keyCode;
 
}
 
 
// Add which for click: 1 === left; 2 === middle; 3 === right
 
if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
 
if ( button & 1 ) {
 
return 1;
 
}
 
 
if ( button & 2 ) {
 
return 3;
 
}
 
 
if ( button & 4 ) {
 
return 2;
 
}
 
 
return 0;
 
}
 
 
return event.which;
 
}
 
}, jQuery.event.addProp );
 
 
// Create mouseenter/leave events using mouseover/out and event-time checks
 
// so that event delegation works in jQuery.
 
// Do the same for pointerenter/pointerleave and pointerover/pointerout
 
//
 
// Support: Safari 7 only
 
// Safari sends mouseenter too often; see:
 
// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
 
// for the description of the bug (it existed in older Chrome versions as well).
 
jQuery.each( {
 
mouseenter: "mouseover",
 
mouseleave: "mouseout",
 
pointerenter: "pointerover",
 
pointerleave: "pointerout"
 
}, function( orig, fix ) {
 
jQuery.event.special[ orig ] = {
 
delegateType: fix,
 
bindType: fix,
 
 
handle: function( event ) {
 
var ret,
 
target = this,
 
related = event.relatedTarget,
 
handleObj = event.handleObj;
 
 
// For mouseenter/leave call the handler if related is outside the target.
 
// NB: No relatedTarget if the mouse left/entered the browser window
 
if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
 
event.type = handleObj.origType;
 
ret = handleObj.handler.apply( this, arguments );
 
event.type = fix;
 
}
 
return ret;
 
}
 
};
 
} );
 
 
jQuery.fn.extend( {
 
 
on: function( types, selector, data, fn ) {
 
return on( this, types, selector, data, fn );
 
},
 
one: function( types, selector, data, fn ) {
 
return on( this, types, selector, data, fn, 1 );
 
},
 
off: function( types, selector, fn ) {
 
var handleObj, type;
 
if ( types && types.preventDefault && types.handleObj ) {
 
 
// ( event )  dispatched jQuery.Event
 
handleObj = types.handleObj;
 
jQuery( types.delegateTarget ).off(
 
handleObj.namespace ?
 
handleObj.origType + "." + handleObj.namespace :
 
handleObj.origType,
 
handleObj.selector,
 
handleObj.handler
 
);
 
return this;
 
}
 
if ( typeof types === "object" ) {
 
 
// ( types-object [, selector] )
 
for ( type in types ) {
 
this.off( type, selector, types[ type ] );
 
}
 
return this;
 
}
 
if ( selector === false || typeof selector === "function" ) {
 
 
// ( types [, fn] )
 
fn = selector;
 
selector = undefined;
 
}
 
if ( fn === false ) {
 
fn = returnFalse;
 
}
 
return this.each( function() {
 
jQuery.event.remove( this, types, fn, selector );
 
} );
 
}
 
} );
 
 
 
var
 
 
/* eslint-disable max-len */
 
 
// See https://github.com/eslint/eslint/issues/3229
 
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
 
 
/* eslint-enable */
 
 
// Support: IE <=10 - 11, Edge 12 - 13 only
 
// In IE/Edge using regex groups here causes severe slowdowns.
 
// See https://connect.microsoft.com/IE/feedback/details/1736512/
 
rnoInnerhtml = /<script|<style|<link/i,
 
 
// checked="checked" or checked
 
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
 
rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
 
 
// Prefer a tbody over its parent table for containing new rows
 
function manipulationTarget( elem, content ) {
 
if ( nodeName( elem, "table" ) &&
 
nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
 
 
return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
 
}
 
 
return elem;
 
}
 
 
// Replace/restore the type attribute of script elements for safe DOM manipulation
 
function disableScript( elem ) {
 
elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
 
return elem;
 
}
 
function restoreScript( elem ) {
 
if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
 
elem.type = elem.type.slice( 5 );
 
} else {
 
elem.removeAttribute( "type" );
 
}
 
 
return elem;
 
}
 
 
function cloneCopyEvent( src, dest ) {
 
var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
 
 
if ( dest.nodeType !== 1 ) {
 
return;
 
}
 
 
// 1. Copy private data: events, handlers, etc.
 
if ( dataPriv.hasData( src ) ) {
 
pdataOld = dataPriv.access( src );
 
pdataCur = dataPriv.set( dest, pdataOld );
 
events = pdataOld.events;
 
 
if ( events ) {
 
delete pdataCur.handle;
 
pdataCur.events = {};
 
 
for ( type in events ) {
 
for ( i = 0, l = events[ type ].length; i < l; i++ ) {
 
jQuery.event.add( dest, type, events[ type ][ i ] );
 
}
 
}
 
}
 
}
 
 
// 2. Copy user data
 
if ( dataUser.hasData( src ) ) {
 
udataOld = dataUser.access( src );
 
udataCur = jQuery.extend( {}, udataOld );
 
 
dataUser.set( dest, udataCur );
 
}
 
}
 
 
// Fix IE bugs, see support tests
 
function fixInput( src, dest ) {
 
var nodeName = dest.nodeName.toLowerCase();
 
 
// Fails to persist the checked state of a cloned checkbox or radio button.
 
if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
 
dest.checked = src.checked;
 
 
// Fails to return the selected option to the default selected state when cloning options
 
} else if ( nodeName === "input" || nodeName === "textarea" ) {
 
dest.defaultValue = src.defaultValue;
 
}
 
}
 
 
function domManip( collection, args, callback, ignored ) {
 
 
// Flatten any nested arrays
 
args = concat.apply( [], args );
 
 
var fragment, first, scripts, hasScripts, node, doc,
 
i = 0,
 
l = collection.length,
 
iNoClone = l - 1,
 
value = args[ 0 ],
 
valueIsFunction = isFunction( value );
 
 
// We can't cloneNode fragments that contain checked, in WebKit
 
if ( valueIsFunction ||
 
( l > 1 && typeof value === "string" &&
 
!support.checkClone && rchecked.test( value ) ) ) {
 
return collection.each( function( index ) {
 
var self = collection.eq( index );
 
if ( valueIsFunction ) {
 
args[ 0 ] = value.call( this, index, self.html() );
 
}
 
domManip( self, args, callback, ignored );
 
} );
 
}
 
 
if ( l ) {
 
fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
 
first = fragment.firstChild;
 
 
if ( fragment.childNodes.length === 1 ) {
 
fragment = first;
 
}
 
 
// Require either new content or an interest in ignored elements to invoke the callback
 
if ( first || ignored ) {
 
scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
 
hasScripts = scripts.length;
 
 
// Use the original fragment for the last item
 
// instead of the first because it can end up
 
// being emptied incorrectly in certain situations (#8070).
 
for ( ; i < l; i++ ) {
 
node = fragment;
 
 
if ( i !== iNoClone ) {
 
node = jQuery.clone( node, true, true );
 
 
// Keep references to cloned scripts for later restoration
 
if ( hasScripts ) {
 
 
// Support: Android <=4.0 only, PhantomJS 1 only
 
// push.apply(_, arraylike) throws on ancient WebKit
 
jQuery.merge( scripts, getAll( node, "script" ) );
 
}
 
}
 
 
callback.call( collection[ i ], node, i );
 
}
 
 
if ( hasScripts ) {
 
doc = scripts[ scripts.length - 1 ].ownerDocument;
 
 
// Reenable scripts
 
jQuery.map( scripts, restoreScript );
 
 
// Evaluate executable scripts on first document insertion
 
for ( i = 0; i < hasScripts; i++ ) {
 
node = scripts[ i ];
 
if ( rscriptType.test( node.type || "" ) &&
 
!dataPriv.access( node, "globalEval" ) &&
 
jQuery.contains( doc, node ) ) {
 
 
if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
 
 
// Optional AJAX dependency, but won't run scripts if not present
 
if ( jQuery._evalUrl ) {
 
jQuery._evalUrl( node.src );
 
}
 
} else {
 
DOMEval( node.textContent.replace( rcleanScript, "" ), doc, node );
 
}
 
}
 
}
 
}
 
}
 
}
 
 
return collection;
 
}
 
 
function remove( elem, selector, keepData ) {
 
var node,
 
nodes = selector ? jQuery.filter( selector, elem ) : elem,
 
i = 0;
 
 
for ( ; ( node = nodes[ i ] ) != null; i++ ) {
 
if ( !keepData && node.nodeType === 1 ) {
 
jQuery.cleanData( getAll( node ) );
 
}
 
 
if ( node.parentNode ) {
 
if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
 
setGlobalEval( getAll( node, "script" ) );
 
}
 
node.parentNode.removeChild( node );
 
}
 
}
 
 
return elem;
 
}
 
 
jQuery.extend( {
 
htmlPrefilter: function( html ) {
 
return html.replace( rxhtmlTag, "<$1></$2>" );
 
},
 
 
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
 
var i, l, srcElements, destElements,
 
clone = elem.cloneNode( true ),
 
inPage = jQuery.contains( elem.ownerDocument, elem );
 
 
// Fix IE cloning issues
 
if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
 
!jQuery.isXMLDoc( elem ) ) {
 
 
// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
 
destElements = getAll( clone );
 
srcElements = getAll( elem );
 
 
for ( i = 0, l = srcElements.length; i < l; i++ ) {
 
fixInput( srcElements[ i ], destElements[ i ] );
 
}
 
}
 
 
// Copy the events from the original to the clone
 
if ( dataAndEvents ) {
 
if ( deepDataAndEvents ) {
 
srcElements = srcElements || getAll( elem );
 
destElements = destElements || getAll( clone );
 
 
for ( i = 0, l = srcElements.length; i < l; i++ ) {
 
cloneCopyEvent( srcElements[ i ], destElements[ i ] );
 
}
 
} else {
 
cloneCopyEvent( elem, clone );
 
}
 
}
 
 
// Preserve script evaluation history
 
destElements = getAll( clone, "script" );
 
if ( destElements.length > 0 ) {
 
setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
 
}
 
 
// Return the cloned set
 
return clone;
 
},
 
 
cleanData: function( elems ) {
 
var data, elem, type,
 
special = jQuery.event.special,
 
i = 0;
 
 
for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
 
if ( acceptData( elem ) ) {
 
if ( ( data = elem[ dataPriv.expando ] ) ) {
 
if ( data.events ) {
 
for ( type in data.events ) {
 
if ( special[ type ] ) {
 
jQuery.event.remove( elem, type );
 
 
// This is a shortcut to avoid jQuery.event.remove's overhead
 
} else {
 
jQuery.removeEvent( elem, type, data.handle );
 
}
 
}
 
}
 
 
// Support: Chrome <=35 - 45+
 
// Assign undefined instead of using delete, see Data#remove
 
elem[ dataPriv.expando ] = undefined;
 
}
 
if ( elem[ dataUser.expando ] ) {
 
 
// Support: Chrome <=35 - 45+
 
// Assign undefined instead of using delete, see Data#remove
 
elem[ dataUser.expando ] = undefined;
 
}
 
}
 
}
 
}
 
} );
 
 
jQuery.fn.extend( {
 
detach: function( selector ) {
 
return remove( this, selector, true );
 
},
 
 
remove: function( selector ) {
 
return remove( this, selector );
 
},
 
 
text: function( value ) {
 
return access( this, function( value ) {
 
return value === undefined ?
 
jQuery.text( this ) :
 
this.empty().each( function() {
 
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 
this.textContent = value;
 
}
 
} );
 
}, null, value, arguments.length );
 
},
 
 
append: function() {
 
return domManip( this, arguments, function( elem ) {
 
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 
var target = manipulationTarget( this, elem );
 
target.appendChild( elem );
 
}
 
} );
 
},
 
 
prepend: function() {
 
return domManip( this, arguments, function( elem ) {
 
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 
var target = manipulationTarget( this, elem );
 
target.insertBefore( elem, target.firstChild );
 
}
 
} );
 
},
 
 
before: function() {
 
return domManip( this, arguments, function( elem ) {
 
if ( this.parentNode ) {
 
this.parentNode.insertBefore( elem, this );
 
}
 
} );
 
},
 
 
after: function() {
 
return domManip( this, arguments, function( elem ) {
 
if ( this.parentNode ) {
 
this.parentNode.insertBefore( elem, this.nextSibling );
 
}
 
} );
 
},
 
 
empty: function() {
 
var elem,
 
i = 0;
 
 
for ( ; ( elem = this[ i ] ) != null; i++ ) {
 
if ( elem.nodeType === 1 ) {
 
 
// Prevent memory leaks
 
jQuery.cleanData( getAll( elem, false ) );
 
 
// Remove any remaining nodes
 
elem.textContent = "";
 
}
 
}
 
 
return this;
 
},
 
 
clone: function( dataAndEvents, deepDataAndEvents ) {
 
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
 
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
 
 
return this.map( function() {
 
return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
 
} );
 
},
 
 
html: function( value ) {
 
return access( this, function( value ) {
 
var elem = this[ 0 ] || {},
 
i = 0,
 
l = this.length;
 
 
if ( value === undefined && elem.nodeType === 1 ) {
 
return elem.innerHTML;
 
}
 
 
// See if we can take a shortcut and just use innerHTML
 
if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
 
!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
 
 
value = jQuery.htmlPrefilter( value );
 
 
try {
 
for ( ; i < l; i++ ) {
 
elem = this[ i ] || {};
 
 
// Remove element nodes and prevent memory leaks
 
if ( elem.nodeType === 1 ) {
 
jQuery.cleanData( getAll( elem, false ) );
 
elem.innerHTML = value;
 
}
 
}
 
 
elem = 0;
 
 
// If using innerHTML throws an exception, use the fallback method
 
} catch ( e ) {}
 
}
 
 
if ( elem ) {
 
this.empty().append( value );
 
}
 
}, null, value, arguments.length );
 
},
 
 
replaceWith: function() {
 
var ignored = [];
 
 
// Make the changes, replacing each non-ignored context element with the new content
 
return domManip( this, arguments, function( elem ) {
 
var parent = this.parentNode;
 
 
if ( jQuery.inArray( this, ignored ) < 0 ) {
 
jQuery.cleanData( getAll( this ) );
 
if ( parent ) {
 
parent.replaceChild( elem, this );
 
}
 
}
 
 
// Force callback invocation
 
}, ignored );
 
}
 
} );
 
 
jQuery.each( {
 
appendTo: "append",
 
prependTo: "prepend",
 
insertBefore: "before",
 
insertAfter: "after",
 
replaceAll: "replaceWith"
 
}, function( name, original ) {
 
jQuery.fn[ name ] = function( selector ) {
 
var elems,
 
ret = [],
 
insert = jQuery( selector ),
 
last = insert.length - 1,
 
i = 0;
 
 
for ( ; i <= last; i++ ) {
 
elems = i === last ? this : this.clone( true );
 
jQuery( insert[ i ] )[ original ]( elems );
 
 
// Support: Android <=4.0 only, PhantomJS 1 only
 
// .get() because push.apply(_, arraylike) throws on ancient WebKit
 
push.apply( ret, elems.get() );
 
}
 
 
return this.pushStack( ret );
 
};
 
} );
 
var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
 
 
var getStyles = function( elem ) {
 
 
// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
 
// IE throws on elements created in popups
 
// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
 
var view = elem.ownerDocument.defaultView;
 
 
if ( !view || !view.opener ) {
 
view = window;
 
}
 
 
return view.getComputedStyle( elem );
 
};
 
 
var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
 
 
 
 
( function() {
 
 
// Executing both pixelPosition & boxSizingReliable tests require only one layout
 
// so they're executed at the same time to save the second computation.
 
function computeStyleTests() {
 
 
// This is a singleton, we need to execute it only once
 
if ( !div ) {
 
return;
 
}
 
 
container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
 
"margin-top:1px;padding:0;border:0";
 
div.style.cssText =
 
"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
 
"margin:auto;border:1px;padding:1px;" +
 
"width:60%;top:1%";
 
documentElement.appendChild( container ).appendChild( div );
 
 
var divStyle = window.getComputedStyle( div );
 
pixelPositionVal = divStyle.top !== "1%";
 
 
// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
 
reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
 
 
// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
 
// Some styles come back with percentage values, even though they shouldn't
 
div.style.right = "60%";
 
pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
 
 
// Support: IE 9 - 11 only
 
// Detect misreporting of content dimensions for box-sizing:border-box elements
 
boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
 
 
// Support: IE 9 only
 
// Detect overflow:scroll screwiness (gh-3699)
 
div.style.position = "absolute";
 
scrollboxSizeVal = div.offsetWidth === 36 || "absolute";
 
 
documentElement.removeChild( container );
 
 
// Nullify the div so it wouldn't be stored in the memory and
 
// it will also be a sign that checks already performed
 
div = null;
 
}
 
 
function roundPixelMeasures( measure ) {
 
return Math.round( parseFloat( measure ) );
 
}
 
 
var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
 
reliableMarginLeftVal,
 
container = document.createElement( "div" ),
 
div = document.createElement( "div" );
 
 
// Finish early in limited (non-browser) environments
 
if ( !div.style ) {
 
return;
 
}
 
 
// Support: IE <=9 - 11 only
 
// Style of cloned element affects source element cloned (#8908)
 
div.style.backgroundClip = "content-box";
 
div.cloneNode( true ).style.backgroundClip = "";
 
support.clearCloneStyle = div.style.backgroundClip === "content-box";
 
 
jQuery.extend( support, {
 
boxSizingReliable: function() {
 
computeStyleTests();
 
return boxSizingReliableVal;
 
},
 
pixelBoxStyles: function() {
 
computeStyleTests();
 
return pixelBoxStylesVal;
 
},
 
pixelPosition: function() {
 
computeStyleTests();
 
return pixelPositionVal;
 
},
 
reliableMarginLeft: function() {
 
computeStyleTests();
 
return reliableMarginLeftVal;
 
},
 
scrollboxSize: function() {
 
computeStyleTests();
 
return scrollboxSizeVal;
 
}
 
} );
 
} )();
 
 
 
function curCSS( elem, name, computed ) {
 
var width, minWidth, maxWidth, ret,
 
 
// Support: Firefox 51+
 
// Retrieving style before computed somehow
 
// fixes an issue with getting wrong values
 
// on detached elements
 
style = elem.style;
 
 
computed = computed || getStyles( elem );
 
 
// getPropertyValue is needed for:
 
//  .css('filter') (IE 9 only, #12537)
 
//  .css('--customProperty) (#3144)
 
if ( computed ) {
 
ret = computed.getPropertyValue( name ) || computed[ name ];
 
 
if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
 
ret = jQuery.style( elem, name );
 
}
 
 
// A tribute to the "awesome hack by Dean Edwards"
 
// Android Browser returns percentage for some values,
 
// but width seems to be reliably pixels.
 
// This is against the CSSOM draft spec:
 
// https://drafts.csswg.org/cssom/#resolved-values
 
if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
 
 
// Remember the original values
 
width = style.width;
 
minWidth = style.minWidth;
 
maxWidth = style.maxWidth;
 
 
// Put in the new values to get a computed value out
 
style.minWidth = style.maxWidth = style.width = ret;
 
ret = computed.width;
 
 
// Revert the changed values
 
style.width = width;
 
style.minWidth = minWidth;
 
style.maxWidth = maxWidth;
 
}
 
}
 
 
return ret !== undefined ?
 
 
// Support: IE <=9 - 11 only
 
// IE returns zIndex value as an integer.
 
ret + "" :
 
ret;
 
}
 
 
 
function addGetHookIf( conditionFn, hookFn ) {
 
 
// Define the hook, we'll check on the first run if it's really needed.
 
return {
 
get: function() {
 
if ( conditionFn() ) {
 
 
// Hook not needed (or it's not possible to use it due
 
// to missing dependency), remove it.
 
delete this.get;
 
return;
 
}
 
 
// Hook needed; redefine it so that the support test is not executed again.
 
return ( this.get = hookFn ).apply( this, arguments );
 
}
 
};
 
}
 
 
 
var
 
 
// Swappable if display is none or starts with table
 
// except "table", "table-cell", or "table-caption"
 
// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
 
rdisplayswap = /^(none|table(?!-c[ea]).+)/,
 
rcustomProp = /^--/,
 
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
 
cssNormalTransform = {
 
letterSpacing: "0",
 
fontWeight: "400"
 
},
 
 
cssPrefixes = [ "Webkit", "Moz", "ms" ],
 
emptyStyle = document.createElement( "div" ).style;
 
 
// Return a css property mapped to a potentially vendor prefixed property
 
function vendorPropName( name ) {
 
 
// Shortcut for names that are not vendor prefixed
 
if ( name in emptyStyle ) {
 
return name;
 
}
 
 
// Check for vendor prefixed names
 
var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
 
i = cssPrefixes.length;
 
 
while ( i-- ) {
 
name = cssPrefixes[ i ] + capName;
 
if ( name in emptyStyle ) {
 
return name;
 
}
 
}
 
}
 
 
// Return a property mapped along what jQuery.cssProps suggests or to
 
// a vendor prefixed property.
 
function finalPropName( name ) {
 
var ret = jQuery.cssProps[ name ];
 
if ( !ret ) {
 
ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
 
}
 
return ret;
 
}
 
 
function setPositiveNumber( elem, value, subtract ) {
 
 
// Any relative (+/-) values have already been
 
// normalized at this point
 
var matches = rcssNum.exec( value );
 
return matches ?
 
 
// Guard against undefined "subtract", e.g., when used as in cssHooks
 
Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
 
value;
 
}
 
 
function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
 
var i = dimension === "width" ? 1 : 0,
 
extra = 0,
 
delta = 0;
 
 
// Adjustment may not be necessary
 
if ( box === ( isBorderBox ? "border" : "content" ) ) {
 
return 0;
 
}
 
 
for ( ; i < 4; i += 2 ) {
 
 
// Both box models exclude margin
 
if ( box === "margin" ) {
 
delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
 
}
 
 
// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
 
if ( !isBorderBox ) {
 
 
// Add padding
 
delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 
 
// For "border" or "margin", add border
 
if ( box !== "padding" ) {
 
delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 
 
// But still keep track of it otherwise
 
} else {
 
extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 
}
 
 
// If we get here with a border-box (content + padding + border), we're seeking "content" or
 
// "padding" or "margin"
 
} else {
 
 
// For "content", subtract padding
 
if ( box === "content" ) {
 
delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 
}
 
 
// For "content" or "padding", subtract border
 
if ( box !== "margin" ) {
 
delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 
}
 
}
 
}
 
 
// Account for positive content-box scroll gutter when requested by providing computedVal
 
if ( !isBorderBox && computedVal >= 0 ) {
 
 
// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
 
// Assuming integer scroll gutter, subtract the rest and round down
 
delta += Math.max( 0, Math.ceil(
 
elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
 
computedVal -
 
delta -
 
extra -
 
0.5
 
) );
 
}
 
 
return delta;
 
}
 
 
function getWidthOrHeight( elem, dimension, extra ) {
 
 
// Start with computed style
 
var styles = getStyles( elem ),
 
val = curCSS( elem, dimension, styles ),
 
isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
 
valueIsBorderBox = isBorderBox;
 
 
// Support: Firefox <=54
 
// Return a confounding non-pixel value or feign ignorance, as appropriate.
 
if ( rnumnonpx.test( val ) ) {
 
if ( !extra ) {
 
return val;
 
}
 
val = "auto";
 
}
 
 
// Check for style in case a browser which returns unreliable values
 
// for getComputedStyle silently falls back to the reliable elem.style
 
valueIsBorderBox = valueIsBorderBox &&
 
( support.boxSizingReliable() || val === elem.style[ dimension ] );
 
 
// Fall back to offsetWidth/offsetHeight when value is "auto"
 
// This happens for inline elements with no explicit setting (gh-3571)
 
// Support: Android <=4.1 - 4.3 only
 
// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
 
if ( val === "auto" ||
 
!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) {
 
 
val = elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ];
 
 
// offsetWidth/offsetHeight provide border-box values
 
valueIsBorderBox = true;
 
}
 
 
// Normalize "" and auto
 
val = parseFloat( val ) || 0;
 
 
// Adjust for the element's box model
 
return ( val +
 
boxModelAdjustment(
 
elem,
 
dimension,
 
extra || ( isBorderBox ? "border" : "content" ),
 
valueIsBorderBox,
 
styles,
 
 
// Provide the current computed size to request scroll gutter calculation (gh-3589)
 
val
 
)
 
) + "px";
 
}
 
 
jQuery.extend( {
 
 
// Add in style property hooks for overriding the default
 
// behavior of getting and setting a style property
 
cssHooks: {
 
opacity: {
 
get: function( elem, computed ) {
 
if ( computed ) {
 
 
// We should always get a number back from opacity
 
var ret = curCSS( elem, "opacity" );
 
return ret === "" ? "1" : ret;
 
}
 
}
 
}
 
},
 
 
// Don't automatically add "px" to these possibly-unitless properties
 
cssNumber: {
 
"animationIterationCount": true,
 
"columnCount": true,
 
"fillOpacity": true,
 
"flexGrow": true,
 
"flexShrink": true,
 
"fontWeight": true,
 
"lineHeight": true,
 
"opacity": true,
 
"order": true,
 
"orphans": true,
 
"widows": true,
 
"zIndex": true,
 
"zoom": true
 
},
 
 
// Add in properties whose names you wish to fix before
 
// setting or getting the value
 
cssProps: {},
 
 
// Get and set the style property on a DOM Node
 
style: function( elem, name, value, extra ) {
 
 
// Don't set styles on text and comment nodes
 
if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
 
return;
 
}
 
 
// Make sure that we're working with the right name
 
var ret, type, hooks,
 
origName = camelCase( name ),
 
isCustomProp = rcustomProp.test( name ),
 
style = elem.style;
 
 
// Make sure that we're working with the right name. We don't
 
// want to query the value if it is a CSS custom property
 
// since they are user-defined.
 
if ( !isCustomProp ) {
 
name = finalPropName( origName );
 
}
 
 
// Gets hook for the prefixed version, then unprefixed version
 
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 
 
// Check if we're setting a value
 
if ( value !== undefined ) {
 
type = typeof value;
 
 
// Convert "+=" or "-=" to relative numbers (#7345)
 
if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
 
value = adjustCSS( elem, name, ret );
 
 
// Fixes bug #9237
 
type = "number";
 
}
 
 
// Make sure that null and NaN values aren't set (#7116)
 
if ( value == null || value !== value ) {
 
return;
 
}
 
 
// If a number was passed in, add the unit (except for certain CSS properties)
 
if ( type === "number" ) {
 
value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
 
}
 
 
// background-* props affect original clone's values
 
if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
 
style[ name ] = "inherit";
 
}
 
 
// If a hook was provided, use that value, otherwise just set the specified value
 
if ( !hooks || !( "set" in hooks ) ||
 
( value = hooks.set( elem, value, extra ) ) !== undefined ) {
 
 
if ( isCustomProp ) {
 
style.setProperty( name, value );
 
} else {
 
style[ name ] = value;
 
}
 
}
 
 
} else {
 
 
// If a hook was provided get the non-computed value from there
 
if ( hooks && "get" in hooks &&
 
( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
 
 
return ret;
 
}
 
 
// Otherwise just get the value from the style object
 
return style[ name ];
 
}
 
},
 
 
css: function( elem, name, extra, styles ) {
 
var val, num, hooks,
 
origName = camelCase( name ),
 
isCustomProp = rcustomProp.test( name );
 
 
// Make sure that we're working with the right name. We don't
 
// want to modify the value if it is a CSS custom property
 
// since they are user-defined.
 
if ( !isCustomProp ) {
 
name = finalPropName( origName );
 
}
 
 
// Try prefixed name followed by the unprefixed name
 
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 
 
// If a hook was provided get the computed value from there
 
if ( hooks && "get" in hooks ) {
 
val = hooks.get( elem, true, extra );
 
}
 
 
// Otherwise, if a way to get the computed value exists, use that
 
if ( val === undefined ) {
 
val = curCSS( elem, name, styles );
 
}
 
 
// Convert "normal" to computed value
 
if ( val === "normal" && name in cssNormalTransform ) {
 
val = cssNormalTransform[ name ];
 
}
 
 
// Make numeric if forced or a qualifier was provided and val looks numeric
 
if ( extra === "" || extra ) {
 
num = parseFloat( val );
 
return extra === true || isFinite( num ) ? num || 0 : val;
 
}
 
 
return val;
 
}
 
} );
 
 
jQuery.each( [ "height", "width" ], function( i, dimension ) {
 
jQuery.cssHooks[ dimension ] = {
 
get: function( elem, computed, extra ) {
 
if ( computed ) {
 
 
// Certain elements can have dimension info if we invisibly show them
 
// but it must have a current display style that would benefit
 
return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
 
 
// Support: Safari 8+
 
// Table columns in Safari have non-zero offsetWidth & zero
 
// getBoundingClientRect().width unless display is changed.
 
// Support: IE <=11 only
 
// Running getBoundingClientRect on a disconnected node
 
// in IE throws an error.
 
( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
 
swap( elem, cssShow, function() {
 
return getWidthOrHeight( elem, dimension, extra );
 
} ) :
 
getWidthOrHeight( elem, dimension, extra );
 
}
 
},
 
 
set: function( elem, value, extra ) {
 
var matches,
 
styles = getStyles( elem ),
 
isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
 
subtract = extra && boxModelAdjustment(
 
elem,
 
dimension,
 
extra,
 
isBorderBox,
 
styles
 
);
 
 
// Account for unreliable border-box dimensions by comparing offset* to computed and
 
// faking a content-box to get border and padding (gh-3699)
 
if ( isBorderBox && support.scrollboxSize() === styles.position ) {
 
subtract -= Math.ceil(
 
elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
 
parseFloat( styles[ dimension ] ) -
 
boxModelAdjustment( elem, dimension, "border", false, styles ) -
 
0.5
 
);
 
}
 
 
// Convert to pixels if value adjustment is needed
 
if ( subtract && ( matches = rcssNum.exec( value ) ) &&
 
( matches[ 3 ] || "px" ) !== "px" ) {
 
 
elem.style[ dimension ] = value;
 
value = jQuery.css( elem, dimension );
 
}
 
 
return setPositiveNumber( elem, value, subtract );
 
}
 
};
 
} );
 
 
jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
 
function( elem, computed ) {
 
if ( computed ) {
 
return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
 
elem.getBoundingClientRect().left -
 
swap( elem, { marginLeft: 0 }, function() {
 
return elem.getBoundingClientRect().left;
 
} )
 
) + "px";
 
}
 
}
 
);
 
 
// These hooks are used by animate to expand properties
 
jQuery.each( {
 
margin: "",
 
padding: "",
 
border: "Width"
 
}, function( prefix, suffix ) {
 
jQuery.cssHooks[ prefix + suffix ] = {
 
expand: function( value ) {
 
var i = 0,
 
expanded = {},
 
 
// Assumes a single number if not a string
 
parts = typeof value === "string" ? value.split( " " ) : [ value ];
 
 
for ( ; i < 4; i++ ) {
 
expanded[ prefix + cssExpand[ i ] + suffix ] =
 
parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
 
}
 
 
return expanded;
 
}
 
};
 
 
if ( prefix !== "margin" ) {
 
jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
 
}
 
} );
 
 
jQuery.fn.extend( {
 
css: function( name, value ) {
 
return access( this, function( elem, name, value ) {
 
var styles, len,
 
map = {},
 
i = 0;
 
 
if ( Array.isArray( name ) ) {
 
styles = getStyles( elem );
 
len = name.length;
 
 
for ( ; i < len; i++ ) {
 
map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
 
}
 
 
return map;
 
}
 
 
return value !== undefined ?
 
jQuery.style( elem, name, value ) :
 
jQuery.css( elem, name );
 
}, name, value, arguments.length > 1 );
 
}
 
} );
 
 
 
function Tween( elem, options, prop, end, easing ) {
 
return new Tween.prototype.init( elem, options, prop, end, easing );
 
}
 
jQuery.Tween = Tween;
 
 
Tween.prototype = {
 
constructor: Tween,
 
init: function( elem, options, prop, end, easing, unit ) {
 
this.elem = elem;
 
this.prop = prop;
 
this.easing = easing || jQuery.easing._default;
 
this.options = options;
 
this.start = this.now = this.cur();
 
this.end = end;
 
this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
 
},
 
cur: function() {
 
var hooks = Tween.propHooks[ this.prop ];
 
 
return hooks && hooks.get ?
 
hooks.get( this ) :
 
Tween.propHooks._default.get( this );
 
},
 
run: function( percent ) {
 
var eased,
 
hooks = Tween.propHooks[ this.prop ];
 
 
if ( this.options.duration ) {
 
this.pos = eased = jQuery.easing[ this.easing ](
 
percent, this.options.duration * percent, 0, 1, this.options.duration
 
);
 
} else {
 
this.pos = eased = percent;
 
}
 
this.now = ( this.end - this.start ) * eased + this.start;
 
 
if ( this.options.step ) {
 
this.options.step.call( this.elem, this.now, this );
 
}
 
 
if ( hooks && hooks.set ) {
 
hooks.set( this );
 
} else {
 
Tween.propHooks._default.set( this );
 
}
 
return this;
 
}
 
};
 
 
Tween.prototype.init.prototype = Tween.prototype;
 
 
Tween.propHooks = {
 
_default: {
 
get: function( tween ) {
 
var result;
 
 
// Use a property on the element directly when it is not a DOM element,
 
// or when there is no matching style property that exists.
 
if ( tween.elem.nodeType !== 1 ||
 
tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
 
return tween.elem[ tween.prop ];
 
}
 
 
// Passing an empty string as a 3rd parameter to .css will automatically
 
// attempt a parseFloat and fallback to a string if the parse fails.
 
// Simple values such as "10px" are parsed to Float;
 
// complex values such as "rotate(1rad)" are returned as-is.
 
result = jQuery.css( tween.elem, tween.prop, "" );
 
 
// Empty strings, null, undefined and "auto" are converted to 0.
 
return !result || result === "auto" ? 0 : result;
 
},
 
set: function( tween ) {
 
 
// Use step hook for back compat.
 
// Use cssHook if its there.
 
// Use .style if available and use plain properties where available.
 
if ( jQuery.fx.step[ tween.prop ] ) {
 
jQuery.fx.step[ tween.prop ]( tween );
 
} else if ( tween.elem.nodeType === 1 &&
 
( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
 
jQuery.cssHooks[ tween.prop ] ) ) {
 
jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
 
} else {
 
tween.elem[ tween.prop ] = tween.now;
 
}
 
}
 
}
 
};
 
 
// Support: IE <=9 only
 
// Panic based approach to setting things on disconnected nodes
 
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
 
set: function( tween ) {
 
if ( tween.elem.nodeType && tween.elem.parentNode ) {
 
tween.elem[ tween.prop ] = tween.now;
 
}
 
}
 
};
 
 
jQuery.easing = {
 
linear: function( p ) {
 
return p;
 
},
 
swing: function( p ) {
 
return 0.5 - Math.cos( p * Math.PI ) / 2;
 
},
 
_default: "swing"
 
};
 
 
jQuery.fx = Tween.prototype.init;
 
 
// Back compat <1.8 extension point
 
jQuery.fx.step = {};
 
 
 
 
 
var
 
fxNow, inProgress,
 
rfxtypes = /^(?:toggle|show|hide)$/,
 
rrun = /queueHooks$/;
 
 
function schedule() {
 
if ( inProgress ) {
 
if ( document.hidden === false && window.requestAnimationFrame ) {
 
window.requestAnimationFrame( schedule );
 
} else {
 
window.setTimeout( schedule, jQuery.fx.interval );
 
}
 
 
jQuery.fx.tick();
 
}
 
}
 
 
// Animations created synchronously will run synchronously
 
function createFxNow() {
 
window.setTimeout( function() {
 
fxNow = undefined;
 
} );
 
return ( fxNow = Date.now() );
 
}
 
 
// Generate parameters to create a standard animation
 
function genFx( type, includeWidth ) {
 
var which,
 
i = 0,
 
attrs = { height: type };
 
 
// If we include width, step value is 1 to do all cssExpand values,
 
// otherwise step value is 2 to skip over Left and Right
 
includeWidth = includeWidth ? 1 : 0;
 
for ( ; i < 4; i += 2 - includeWidth ) {
 
which = cssExpand[ i ];
 
attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
 
}
 
 
if ( includeWidth ) {
 
attrs.opacity = attrs.width = type;
 
}
 
 
return attrs;
 
}
 
 
function createTween( value, prop, animation ) {
 
var tween,
 
collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
 
index = 0,
 
length = collection.length;
 
for ( ; index < length; index++ ) {
 
if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
 
 
// We're done with this property
 
return tween;
 
}
 
}
 
}
 
 
function defaultPrefilter( elem, props, opts ) {
 
var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
 
isBox = "width" in props || "height" in props,
 
anim = this,
 
orig = {},
 
style = elem.style,
 
hidden = elem.nodeType && isHiddenWithinTree( elem ),
 
dataShow = dataPriv.get( elem, "fxshow" );
 
 
// Queue-skipping animations hijack the fx hooks
 
if ( !opts.queue ) {
 
hooks = jQuery._queueHooks( elem, "fx" );
 
if ( hooks.unqueued == null ) {
 
hooks.unqueued = 0;
 
oldfire = hooks.empty.fire;
 
hooks.empty.fire = function() {
 
if ( !hooks.unqueued ) {
 
oldfire();
 
}
 
};
 
}
 
hooks.unqueued++;
 
 
anim.always( function() {
 
 
// Ensure the complete handler is called before this completes
 
anim.always( function() {
 
hooks.unqueued--;
 
if ( !jQuery.queue( elem, "fx" ).length ) {
 
hooks.empty.fire();
 
}
 
} );
 
} );
 
}
 
 
// Detect show/hide animations
 
for ( prop in props ) {
 
value = props[ prop ];
 
if ( rfxtypes.test( value ) ) {
 
delete props[ prop ];
 
toggle = toggle || value === "toggle";
 
if ( value === ( hidden ? "hide" : "show" ) ) {
 
 
// Pretend to be hidden if this is a "show" and
 
// there is still data from a stopped show/hide
 
if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
 
hidden = true;
 
 
// Ignore all other no-op show/hide data
 
} else {
 
continue;
 
}
 
}
 
orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
 
}
 
}
 
 
// Bail out if this is a no-op like .hide().hide()
 
propTween = !jQuery.isEmptyObject( props );
 
if ( !propTween && jQuery.isEmptyObject( orig ) ) {
 
return;
 
}
 
 
// Restrict "overflow" and "display" styles during box animations
 
if ( isBox && elem.nodeType === 1 ) {
 
 
// Support: IE <=9 - 11, Edge 12 - 15
 
// Record all 3 overflow attributes because IE does not infer the shorthand
 
// from identically-valued overflowX and overflowY and Edge just mirrors
 
// the overflowX value there.
 
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
 
 
// Identify a display type, preferring old show/hide data over the CSS cascade
 
restoreDisplay = dataShow && dataShow.display;
 
if ( restoreDisplay == null ) {
 
restoreDisplay = dataPriv.get( elem, "display" );
 
}
 
display = jQuery.css( elem, "display" );
 
if ( display === "none" ) {
 
if ( restoreDisplay ) {
 
display = restoreDisplay;
 
} else {
 
 
// Get nonempty value(s) by temporarily forcing visibility
 
showHide( [ elem ], true );
 
restoreDisplay = elem.style.display || restoreDisplay;
 
display = jQuery.css( elem, "display" );
 
showHide( [ elem ] );
 
}
 
}
 
 
// Animate inline elements as inline-block
 
if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
 
if ( jQuery.css( elem, "float" ) === "none" ) {
 
 
// Restore the original display value at the end of pure show/hide animations
 
if ( !propTween ) {
 
anim.done( function() {
 
style.display = restoreDisplay;
 
} );
 
if ( restoreDisplay == null ) {
 
display = style.display;
 
restoreDisplay = display === "none" ? "" : display;
 
}
 
}
 
style.display = "inline-block";
 
}
 
}
 
}
 
 
if ( opts.overflow ) {
 
style.overflow = "hidden";
 
anim.always( function() {
 
style.overflow = opts.overflow[ 0 ];
 
style.overflowX = opts.overflow[ 1 ];
 
style.overflowY = opts.overflow[ 2 ];
 
} );
 
}
 
 
// Implement show/hide animations
 
propTween = false;
 
for ( prop in orig ) {
 
 
// General show/hide setup for this element animation
 
if ( !propTween ) {
 
if ( dataShow ) {
 
if ( "hidden" in dataShow ) {
 
hidden = dataShow.hidden;
 
}
 
} else {
 
dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
 
}
 
 
// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
 
if ( toggle ) {
 
dataShow.hidden = !hidden;
 
}
 
 
// Show elements before animating them
 
if ( hidden ) {
 
showHide( [ elem ], true );
 
}
 
 
/* eslint-disable no-loop-func */
 
 
anim.done( function() {
 
 
/* eslint-enable no-loop-func */
 
 
// The final step of a "hide" animation is actually hiding the element
 
if ( !hidden ) {
 
showHide( [ elem ] );
 
}
 
dataPriv.remove( elem, "fxshow" );
 
for ( prop in orig ) {
 
jQuery.style( elem, prop, orig[ prop ] );
 
}
 
} );
 
}
 
 
// Per-property setup
 
propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
 
if ( !( prop in dataShow ) ) {
 
dataShow[ prop ] = propTween.start;
 
if ( hidden ) {
 
propTween.end = propTween.start;
 
propTween.start = 0;
 
}
 
}
 
}
 
}
 
 
function propFilter( props, specialEasing ) {
 
var index, name, easing, value, hooks;
 
 
// camelCase, specialEasing and expand cssHook pass
 
for ( index in props ) {
 
name = camelCase( index );
 
easing = specialEasing[ name ];
 
value = props[ index ];
 
if ( Array.isArray( value ) ) {
 
easing = value[ 1 ];
 
value = props[ index ] = value[ 0 ];
 
}
 
 
if ( index !== name ) {
 
props[ name ] = value;
 
delete props[ index ];
 
}
 
 
hooks = jQuery.cssHooks[ name ];
 
if ( hooks && "expand" in hooks ) {
 
value = hooks.expand( value );
 
delete props[ name ];
 
 
// Not quite $.extend, this won't overwrite existing keys.
 
// Reusing 'index' because we have the correct "name"
 
for ( index in value ) {
 
if ( !( index in props ) ) {
 
props[ index ] = value[ index ];
 
specialEasing[ index ] = easing;
 
}
 
}
 
} else {
 
specialEasing[ name ] = easing;
 
}
 
}
 
}
 
 
function Animation( elem, properties, options ) {
 
var result,
 
stopped,
 
index = 0,
 
length = Animation.prefilters.length,
 
deferred = jQuery.Deferred().always( function() {
 
 
// Don't match elem in the :animated selector
 
delete tick.elem;
 
} ),
 
tick = function() {
 
if ( stopped ) {
 
return false;
 
}
 
var currentTime = fxNow || createFxNow(),
 
remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
 
 
// Support: Android 2.3 only
 
// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
 
temp = remaining / animation.duration || 0,
 
percent = 1 - temp,
 
index = 0,
 
length = animation.tweens.length;
 
 
for ( ; index < length; index++ ) {
 
animation.tweens[ index ].run( percent );
 
}
 
 
deferred.notifyWith( elem, [ animation, percent, remaining ] );
 
 
// If there's more to do, yield
 
if ( percent < 1 && length ) {
 
return remaining;
 
}
 
 
// If this was an empty animation, synthesize a final progress notification
 
if ( !length ) {
 
deferred.notifyWith( elem, [ animation, 1, 0 ] );
 
}
 
 
// Resolve the animation and report its conclusion
 
deferred.resolveWith( elem, [ animation ] );
 
return false;
 
},
 
animation = deferred.promise( {
 
elem: elem,
 
props: jQuery.extend( {}, properties ),
 
opts: jQuery.extend( true, {
 
specialEasing: {},
 
easing: jQuery.easing._default
 
}, options ),
 
originalProperties: properties,
 
originalOptions: options,
 
startTime: fxNow || createFxNow(),
 
duration: options.duration,
 
tweens: [],
 
createTween: function( prop, end ) {
 
var tween = jQuery.Tween( elem, animation.opts, prop, end,
 
animation.opts.specialEasing[ prop ] || animation.opts.easing );
 
animation.tweens.push( tween );
 
return tween;
 
},
 
stop: function( gotoEnd ) {
 
var index = 0,
 
 
// If we are going to the end, we want to run all the tweens
 
// otherwise we skip this part
 
length = gotoEnd ? animation.tweens.length : 0;
 
if ( stopped ) {
 
return this;
 
}
 
stopped = true;
 
for ( ; index < length; index++ ) {
 
animation.tweens[ index ].run( 1 );
 
}
 
 
// Resolve when we played the last frame; otherwise, reject
 
if ( gotoEnd ) {
 
deferred.notifyWith( elem, [ animation, 1, 0 ] );
 
deferred.resolveWith( elem, [ animation, gotoEnd ] );
 
} else {
 
deferred.rejectWith( elem, [ animation, gotoEnd ] );
 
}
 
return this;
 
}
 
} ),
 
props = animation.props;
 
 
propFilter( props, animation.opts.specialEasing );
 
 
for ( ; index < length; index++ ) {
 
result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
 
if ( result ) {
 
if ( isFunction( result.stop ) ) {
 
jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
 
result.stop.bind( result );
 
}
 
return result;
 
}
 
}
 
 
jQuery.map( props, createTween, animation );
 
 
if ( isFunction( animation.opts.start ) ) {
 
animation.opts.start.call( elem, animation );
 
}
 
 
// Attach callbacks from options
 
animation
 
.progress( animation.opts.progress )
 
.done( animation.opts.done, animation.opts.complete )
 
.fail( animation.opts.fail )
 
.always( animation.opts.always );
 
 
jQuery.fx.timer(
 
jQuery.extend( tick, {
 
elem: elem,
 
anim: animation,
 
queue: animation.opts.queue
 
} )
 
);
 
 
return animation;
 
}
 
 
jQuery.Animation = jQuery.extend( Animation, {
 
 
tweeners: {
 
"*": [ function( prop, value ) {
 
var tween = this.createTween( prop, value );
 
adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
 
return tween;
 
} ]
 
},
 
 
tweener: function( props, callback ) {
 
if ( isFunction( props ) ) {
 
callback = props;
 
props = [ "*" ];
 
} else {
 
props = props.match( rnothtmlwhite );
 
}
 
 
var prop,
 
index = 0,
 
length = props.length;
 
 
for ( ; index < length; index++ ) {
 
prop = props[ index ];
 
Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
 
Animation.tweeners[ prop ].unshift( callback );
 
}
 
},
 
 
prefilters: [ defaultPrefilter ],
 
 
prefilter: function( callback, prepend ) {
 
if ( prepend ) {
 
Animation.prefilters.unshift( callback );
 
} else {
 
Animation.prefilters.push( callback );
 
}
 
}
 
} );
 
 
jQuery.speed = function( speed, easing, fn ) {
 
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
 
complete: fn || !fn && easing ||
 
isFunction( speed ) && speed,
 
duration: speed,
 
easing: fn && easing || easing && !isFunction( easing ) && easing
 
};
 
 
// Go to the end state if fx are off
 
if ( jQuery.fx.off ) {
 
opt.duration = 0;
 
 
} else {
 
if ( typeof opt.duration !== "number" ) {
 
if ( opt.duration in jQuery.fx.speeds ) {
 
opt.duration = jQuery.fx.speeds[ opt.duration ];
 
 
} else {
 
opt.duration = jQuery.fx.speeds._default;
 
}
 
}
 
}
 
 
// Normalize opt.queue - true/undefined/null -> "fx"
 
if ( opt.queue == null || opt.queue === true ) {
 
opt.queue = "fx";
 
}
 
 
// Queueing
 
opt.old = opt.complete;
 
 
opt.complete = function() {
 
if ( isFunction( opt.old ) ) {
 
opt.old.call( this );
 
}
 
 
if ( opt.queue ) {
 
jQuery.dequeue( this, opt.queue );
 
}
 
};
 
 
return opt;
 
};
 
 
jQuery.fn.extend( {
 
fadeTo: function( speed, to, easing, callback ) {
 
 
// Show any hidden elements after setting opacity to 0
 
return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
 
 
// Animate to the value specified
 
.end().animate( { opacity: to }, speed, easing, callback );
 
},
 
animate: function( prop, speed, easing, callback ) {
 
var empty = jQuery.isEmptyObject( prop ),
 
optall = jQuery.speed( speed, easing, callback ),
 
doAnimation = function() {
 
 
// Operate on a copy of prop so per-property easing won't be lost
 
var anim = Animation( this, jQuery.extend( {}, prop ), optall );
 
 
// Empty animations, or finishing resolves immediately
 
if ( empty || dataPriv.get( this, "finish" ) ) {
 
anim.stop( true );
 
}
 
};
 
doAnimation.finish = doAnimation;
 
 
return empty || optall.queue === false ?
 
this.each( doAnimation ) :
 
this.queue( optall.queue, doAnimation );
 
},
 
stop: function( type, clearQueue, gotoEnd ) {
 
var stopQueue = function( hooks ) {
 
var stop = hooks.stop;
 
delete hooks.stop;
 
stop( gotoEnd );
 
};
 
 
if ( typeof type !== "string" ) {
 
gotoEnd = clearQueue;
 
clearQueue = type;
 
type = undefined;
 
}
 
if ( clearQueue && type !== false ) {
 
this.queue( type || "fx", [] );
 
}
 
 
return this.each( function() {
 
var dequeue = true,
 
index = type != null && type + "queueHooks",
 
timers = jQuery.timers,
 
data = dataPriv.get( this );
 
 
if ( index ) {
 
if ( data[ index ] && data[ index ].stop ) {
 
stopQueue( data[ index ] );
 
}
 
} else {
 
for ( index in data ) {
 
if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
 
stopQueue( data[ index ] );
 
}
 
}
 
}
 
 
for ( index = timers.length; index--; ) {
 
if ( timers[ index ].elem === this &&
 
( type == null || timers[ index ].queue === type ) ) {
 
 
timers[ index ].anim.stop( gotoEnd );
 
dequeue = false;
 
timers.splice( index, 1 );
 
}
 
}
 
 
// Start the next in the queue if the last step wasn't forced.
 
// Timers currently will call their complete callbacks, which
 
// will dequeue but only if they were gotoEnd.
 
if ( dequeue || !gotoEnd ) {
 
jQuery.dequeue( this, type );
 
}
 
} );
 
},
 
finish: function( type ) {
 
if ( type !== false ) {
 
type = type || "fx";
 
}
 
return this.each( function() {
 
var index,
 
data = dataPriv.get( this ),
 
queue = data[ type + "queue" ],
 
hooks = data[ type + "queueHooks" ],
 
timers = jQuery.timers,
 
length = queue ? queue.length : 0;
 
 
// Enable finishing flag on private data
 
data.finish = true;
 
 
// Empty the queue first
 
jQuery.queue( this, type, [] );
 
 
if ( hooks && hooks.stop ) {
 
hooks.stop.call( this, true );
 
}
 
 
// Look for any active animations, and finish them
 
for ( index = timers.length; index--; ) {
 
if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
 
timers[ index ].anim.stop( true );
 
timers.splice( index, 1 );
 
}
 
}
 
 
// Look for any animations in the old queue and finish them
 
for ( index = 0; index < length; index++ ) {
 
if ( queue[ index ] && queue[ index ].finish ) {
 
queue[ index ].finish.call( this );
 
}
 
}
 
 
// Turn off finishing flag
 
delete data.finish;
 
} );
 
}
 
} );
 
 
jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
 
var cssFn = jQuery.fn[ name ];
 
jQuery.fn[ name ] = function( speed, easing, callback ) {
 
return speed == null || typeof speed === "boolean" ?
 
cssFn.apply( this, arguments ) :
 
this.animate( genFx( name, true ), speed, easing, callback );
 
};
 
} );
 
 
// Generate shortcuts for custom animations
 
jQuery.each( {
 
slideDown: genFx( "show" ),
 
slideUp: genFx( "hide" ),
 
slideToggle: genFx( "toggle" ),
 
fadeIn: { opacity: "show" },
 
fadeOut: { opacity: "hide" },
 
fadeToggle: { opacity: "toggle" }
 
}, function( name, props ) {
 
jQuery.fn[ name ] = function( speed, easing, callback ) {
 
return this.animate( props, speed, easing, callback );
 
};
 
} );
 
 
jQuery.timers = [];
 
jQuery.fx.tick = function() {
 
var timer,
 
i = 0,
 
timers = jQuery.timers;
 
 
fxNow = Date.now();
 
 
for ( ; i < timers.length; i++ ) {
 
timer = timers[ i ];
 
 
// Run the timer and safely remove it when done (allowing for external removal)
 
if ( !timer() && timers[ i ] === timer ) {
 
timers.splice( i--, 1 );
 
}
 
}
 
 
if ( !timers.length ) {
 
jQuery.fx.stop();
 
}
 
fxNow = undefined;
 
};
 
 
jQuery.fx.timer = function( timer ) {
 
jQuery.timers.push( timer );
 
jQuery.fx.start();
 
};
 
 
jQuery.fx.interval = 13;
 
jQuery.fx.start = function() {
 
if ( inProgress ) {
 
return;
 
}
 
 
inProgress = true;
 
schedule();
 
};
 
 
jQuery.fx.stop = function() {
 
inProgress = null;
 
};
 
 
jQuery.fx.speeds = {
 
slow: 600,
 
fast: 200,
 
 
// Default speed
 
_default: 400
 
};
 
 
 
// Based off of the plugin by Clint Helfers, with permission.
 
// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
 
jQuery.fn.delay = function( time, type ) {
 
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
 
type = type || "fx";
 
 
return this.queue( type, function( next, hooks ) {
 
var timeout = window.setTimeout( next, time );
 
hooks.stop = function() {
 
window.clearTimeout( timeout );
 
};
 
} );
 
};
 
 
 
( function() {
 
var input = document.createElement( "input" ),
 
select = document.createElement( "select" ),
 
opt = select.appendChild( document.createElement( "option" ) );
 
 
input.type = "checkbox";
 
 
// Support: Android <=4.3 only
 
// Default value for a checkbox should be "on"
 
support.checkOn = input.value !== "";
 
 
// Support: IE <=11 only
 
// Must access selectedIndex to make default options select
 
support.optSelected = opt.selected;
 
 
// Support: IE <=11 only
 
// An input loses its value after becoming a radio
 
input = document.createElement( "input" );
 
input.value = "t";
 
input.type = "radio";
 
support.radioValue = input.value === "t";
 
} )();
 
 
 
var boolHook,
 
attrHandle = jQuery.expr.attrHandle;
 
 
jQuery.fn.extend( {
 
attr: function( name, value ) {
 
return access( this, jQuery.attr, name, value, arguments.length > 1 );
 
},
 
 
removeAttr: function( name ) {
 
return this.each( function() {
 
jQuery.removeAttr( this, name );
 
} );
 
}
 
} );
 
 
jQuery.extend( {
 
attr: function( elem, name, value ) {
 
var ret, hooks,
 
nType = elem.nodeType;
 
 
// Don't get/set attributes on text, comment and attribute nodes
 
if ( nType === 3 || nType === 8 || nType === 2 ) {
 
return;
 
}
 
 
// Fallback to prop when attributes are not supported
 
if ( typeof elem.getAttribute === "undefined" ) {
 
return jQuery.prop( elem, name, value );
 
}
 
 
// Attribute hooks are determined by the lowercase version
 
// Grab necessary hook if one is defined
 
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
 
hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
 
( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
 
}
 
 
if ( value !== undefined ) {
 
if ( value === null ) {
 
jQuery.removeAttr( elem, name );
 
return;
 
}
 
 
if ( hooks && "set" in hooks &&
 
( ret = hooks.set( elem, value, name ) ) !== undefined ) {
 
return ret;
 
}
 
 
elem.setAttribute( name, value + "" );
 
return value;
 
}
 
 
if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
 
return ret;
 
}
 
 
ret = jQuery.find.attr( elem, name );
 
 
// Non-existent attributes return null, we normalize to undefined
 
return ret == null ? undefined : ret;
 
},
 
 
attrHooks: {
 
type: {
 
set: function( elem, value ) {
 
if ( !support.radioValue && value === "radio" &&
 
nodeName( elem, "input" ) ) {
 
var val = elem.value;
 
elem.setAttribute( "type", value );
 
if ( val ) {
 
elem.value = val;
 
}
 
return value;
 
}
 
}
 
}
 
},
 
 
removeAttr: function( elem, value ) {
 
var name,
 
i = 0,
 
 
// Attribute names can contain non-HTML whitespace characters
 
// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
 
attrNames = value && value.match( rnothtmlwhite );
 
 
if ( attrNames && elem.nodeType === 1 ) {
 
while ( ( name = attrNames[ i++ ] ) ) {
 
elem.removeAttribute( name );
 
}
 
}
 
}
 
} );
 
 
// Hooks for boolean attributes
 
boolHook = {
 
set: function( elem, value, name ) {
 
if ( value === false ) {
 
 
// Remove boolean attributes when set to false
 
jQuery.removeAttr( elem, name );
 
} else {
 
elem.setAttribute( name, name );
 
}
 
return name;
 
}
 
};
 
 
jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
 
var getter = attrHandle[ name ] || jQuery.find.attr;
 
 
attrHandle[ name ] = function( elem, name, isXML ) {
 
var ret, handle,
 
lowercaseName = name.toLowerCase();
 
 
if ( !isXML ) {
 
 
// Avoid an infinite loop by temporarily removing this function from the getter
 
handle = attrHandle[ lowercaseName ];
 
attrHandle[ lowercaseName ] = ret;
 
ret = getter( elem, name, isXML ) != null ?
 
lowercaseName :
 
null;
 
attrHandle[ lowercaseName ] = handle;
 
}
 
return ret;
 
};
 
} );
 
 
 
 
 
var rfocusable = /^(?:input|select|textarea|button)$/i,
 
rclickable = /^(?:a|area)$/i;
 
 
jQuery.fn.extend( {
 
prop: function( name, value ) {
 
return access( this, jQuery.prop, name, value, arguments.length > 1 );
 
},
 
 
removeProp: function( name ) {
 
return this.each( function() {
 
delete this[ jQuery.propFix[ name ] || name ];
 
} );
 
}
 
} );
 
 
jQuery.extend( {
 
prop: function( elem, name, value ) {
 
var ret, hooks,
 
nType = elem.nodeType;
 
 
// Don't get/set properties on text, comment and attribute nodes
 
if ( nType === 3 || nType === 8 || nType === 2 ) {
 
return;
 
}
 
 
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
 
 
// Fix name and attach hooks
 
name = jQuery.propFix[ name ] || name;
 
hooks = jQuery.propHooks[ name ];
 
}
 
 
if ( value !== undefined ) {
 
if ( hooks && "set" in hooks &&
 
( ret = hooks.set( elem, value, name ) ) !== undefined ) {
 
return ret;
 
}
 
 
return ( elem[ name ] = value );
 
}
 
 
if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
 
return ret;
 
}
 
 
return elem[ name ];
 
},
 
 
propHooks: {
 
tabIndex: {
 
get: function( elem ) {
 
 
// Support: IE <=9 - 11 only
 
// elem.tabIndex doesn't always return the
 
// correct value when it hasn't been explicitly set
 
// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
 
// Use proper attribute retrieval(#12072)
 
var tabindex = jQuery.find.attr( elem, "tabindex" );
 
 
if ( tabindex ) {
 
return parseInt( tabindex, 10 );
 
}
 
 
if (
 
rfocusable.test( elem.nodeName ) ||
 
rclickable.test( elem.nodeName ) &&
 
elem.href
 
) {
 
return 0;
 
}
 
 
return -1;
 
}
 
}
 
},
 
 
propFix: {
 
"for": "htmlFor",
 
"class": "className"
 
}
 
} );
 
 
// Support: IE <=11 only
 
// Accessing the selectedIndex property
 
// forces the browser to respect setting selected
 
// on the option
 
// The getter ensures a default option is selected
 
// when in an optgroup
 
// eslint rule "no-unused-expressions" is disabled for this code
 
// since it considers such accessions noop
 
if ( !support.optSelected ) {
 
jQuery.propHooks.selected = {
 
get: function( elem ) {
 
 
/* eslint no-unused-expressions: "off" */
 
 
var parent = elem.parentNode;
 
if ( parent && parent.parentNode ) {
 
parent.parentNode.selectedIndex;
 
}
 
return null;
 
},
 
set: function( elem ) {
 
 
/* eslint no-unused-expressions: "off" */
 
 
var parent = elem.parentNode;
 
if ( parent ) {
 
parent.selectedIndex;
 
 
if ( parent.parentNode ) {
 
parent.parentNode.selectedIndex;
 
}
 
}
 
}
 
};
 
}
 
 
jQuery.each( [
 
"tabIndex",
 
"readOnly",
 
"maxLength",
 
"cellSpacing",
 
"cellPadding",
 
"rowSpan",
 
"colSpan",
 
"useMap",
 
"frameBorder",
 
"contentEditable"
 
], function() {
 
jQuery.propFix[ this.toLowerCase() ] = this;
 
} );
 
 
 
 
 
// Strip and collapse whitespace according to HTML spec
 
// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
 
function stripAndCollapse( value ) {
 
var tokens = value.match( rnothtmlwhite ) || [];
 
return tokens.join( " " );
 
}
 
 
 
function getClass( elem ) {
 
return elem.getAttribute && elem.getAttribute( "class" ) || "";
 
}
 
 
function classesToArray( value ) {
 
if ( Array.isArray( value ) ) {
 
return value;
 
}
 
if ( typeof value === "string" ) {
 
return value.match( rnothtmlwhite ) || [];
 
}
 
return [];
 
}
 
 
jQuery.fn.extend( {
 
addClass: function( value ) {
 
var classes, elem, cur, curValue, clazz, j, finalValue,
 
i = 0;
 
 
if ( isFunction( value ) ) {
 
return this.each( function( j ) {
 
jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
 
} );
 
}
 
 
classes = classesToArray( value );
 
 
if ( classes.length ) {
 
while ( ( elem = this[ i++ ] ) ) {
 
curValue = getClass( elem );
 
cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
 
 
if ( cur ) {
 
j = 0;
 
while ( ( clazz = classes[ j++ ] ) ) {
 
if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
 
cur += clazz + " ";
 
}
 
}
 
 
// Only assign if different to avoid unneeded rendering.
 
finalValue = stripAndCollapse( cur );
 
if ( curValue !== finalValue ) {
 
elem.setAttribute( "class", finalValue );
 
}
 
}
 
}
 
}
 
 
return this;
 
},
 
 
removeClass: function( value ) {
 
var classes, elem, cur, curValue, clazz, j, finalValue,
 
i = 0;
 
 
if ( isFunction( value ) ) {
 
return this.each( function( j ) {
 
jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
 
} );
 
}
 
 
if ( !arguments.length ) {
 
return this.attr( "class", "" );
 
}
 
 
classes = classesToArray( value );
 
 
if ( classes.length ) {
 
while ( ( elem = this[ i++ ] ) ) {
 
curValue = getClass( elem );
 
 
// This expression is here for better compressibility (see addClass)
 
cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
 
 
if ( cur ) {
 
j = 0;
 
while ( ( clazz = classes[ j++ ] ) ) {
 
 
// Remove *all* instances
 
while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
 
cur = cur.replace( " " + clazz + " ", " " );
 
}
 
}
 
 
// Only assign if different to avoid unneeded rendering.
 
finalValue = stripAndCollapse( cur );
 
if ( curValue !== finalValue ) {
 
elem.setAttribute( "class", finalValue );
 
}
 
}
 
}
 
}
 
 
return this;
 
},
 
 
toggleClass: function( value, stateVal ) {
 
var type = typeof value,
 
isValidValue = type === "string" || Array.isArray( value );
 
 
if ( typeof stateVal === "boolean" && isValidValue ) {
 
return stateVal ? this.addClass( value ) : this.removeClass( value );
 
}
 
 
if ( isFunction( value ) ) {
 
return this.each( function( i ) {
 
jQuery( this ).toggleClass(
 
value.call( this, i, getClass( this ), stateVal ),
 
stateVal
 
);
 
} );
 
}
 
 
return this.each( function() {
 
var className, i, self, classNames;
 
 
if ( isValidValue ) {
 
 
// Toggle individual class names
 
i = 0;
 
self = jQuery( this );
 
classNames = classesToArray( value );
 
 
while ( ( className = classNames[ i++ ] ) ) {
 
 
// Check each className given, space separated list
 
if ( self.hasClass( className ) ) {
 
self.removeClass( className );
 
} else {
 
self.addClass( className );
 
}
 
}
 
 
// Toggle whole class name
 
} else if ( value === undefined || type === "boolean" ) {
 
className = getClass( this );
 
if ( className ) {
 
 
// Store className if set
 
dataPriv.set( this, "__className__", className );
 
}
 
 
// If the element has a class name or if we're passed `false`,
 
// then remove the whole classname (if there was one, the above saved it).
 
// Otherwise bring back whatever was previously saved (if anything),
 
// falling back to the empty string if nothing was stored.
 
if ( this.setAttribute ) {
 
this.setAttribute( "class",
 
className || value === false ?
 
"" :
 
dataPriv.get( this, "__className__" ) || ""
 
);
 
}
 
}
 
} );
 
},
 
 
hasClass: function( selector ) {
 
var className, elem,
 
i = 0;
 
 
className = " " + selector + " ";
 
while ( ( elem = this[ i++ ] ) ) {
 
if ( elem.nodeType === 1 &&
 
( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
 
return true;
 
}
 
}
 
 
return false;
 
}
 
} );
 
 
 
 
 
var rreturn = /\r/g;
 
 
jQuery.fn.extend( {
 
val: function( value ) {
 
var hooks, ret, valueIsFunction,
 
elem = this[ 0 ];
 
 
if ( !arguments.length ) {
 
if ( elem ) {
 
hooks = jQuery.valHooks[ elem.type ] ||
 
jQuery.valHooks[ elem.nodeName.toLowerCase() ];
 
 
if ( hooks &&
 
"get" in hooks &&
 
( ret = hooks.get( elem, "value" ) ) !== undefined
 
) {
 
return ret;
 
}
 
 
ret = elem.value;
 
 
// Handle most common string cases
 
if ( typeof ret === "string" ) {
 
return ret.replace( rreturn, "" );
 
}
 
 
// Handle cases where value is null/undef or number
 
return ret == null ? "" : ret;
 
}
 
 
return;
 
}
 
 
valueIsFunction = isFunction( value );
 
 
return this.each( function( i ) {
 
var val;
 
 
if ( this.nodeType !== 1 ) {
 
return;
 
}
 
 
if ( valueIsFunction ) {
 
val = value.call( this, i, jQuery( this ).val() );
 
} else {
 
val = value;
 
}
 
 
// Treat null/undefined as ""; convert numbers to string
 
if ( val == null ) {
 
val = "";
 
 
} else if ( typeof val === "number" ) {
 
val += "";
 
 
} else if ( Array.isArray( val ) ) {
 
val = jQuery.map( val, function( value ) {
 
return value == null ? "" : value + "";
 
} );
 
}
 
 
hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
 
 
// If set returns undefined, fall back to normal setting
 
if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
 
this.value = val;
 
}
 
} );
 
}
 
} );
 
 
jQuery.extend( {
 
valHooks: {
 
option: {
 
get: function( elem ) {
 
 
var val = jQuery.find.attr( elem, "value" );
 
return val != null ?
 
val :
 
 
// Support: IE <=10 - 11 only
 
// option.text throws exceptions (#14686, #14858)
 
// Strip and collapse whitespace
 
// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
 
stripAndCollapse( jQuery.text( elem ) );
 
}
 
},
 
select: {
 
get: function( elem ) {
 
var value, option, i,
 
options = elem.options,
 
index = elem.selectedIndex,
 
one = elem.type === "select-one",
 
values = one ? null : [],
 
max = one ? index + 1 : options.length;
 
 
if ( index < 0 ) {
 
i = max;
 
 
} else {
 
i = one ? index : 0;
 
}
 
 
// Loop through all the selected options
 
for ( ; i < max; i++ ) {
 
option = options[ i ];
 
 
// Support: IE <=9 only
 
// IE8-9 doesn't update selected after form reset (#2551)
 
if ( ( option.selected || i === index ) &&
 
 
// Don't return options that are disabled or in a disabled optgroup
 
!option.disabled &&
 
( !option.parentNode.disabled ||
 
!nodeName( option.parentNode, "optgroup" ) ) ) {
 
 
// Get the specific value for the option
 
value = jQuery( option ).val();
 
 
// We don't need an array for one selects
 
if ( one ) {
 
return value;
 
}
 
 
// Multi-Selects return an array
 
values.push( value );
 
}
 
}
 
 
return values;
 
},
 
 
set: function( elem, value ) {
 
var optionSet, option,
 
options = elem.options,
 
values = jQuery.makeArray( value ),
 
i = options.length;
 
 
while ( i-- ) {
 
option = options[ i ];
 
 
/* eslint-disable no-cond-assign */
 
 
if ( option.selected =
 
jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
 
) {
 
optionSet = true;
 
}
 
 
/* eslint-enable no-cond-assign */
 
}
 
 
// Force browsers to behave consistently when non-matching value is set
 
if ( !optionSet ) {
 
elem.selectedIndex = -1;
 
}
 
return values;
 
}
 
}
 
}
 
} );
 
 
// Radios and checkboxes getter/setter
 
jQuery.each( [ "radio", "checkbox" ], function() {
 
jQuery.valHooks[ this ] = {
 
set: function( elem, value ) {
 
if ( Array.isArray( value ) ) {
 
return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
 
}
 
}
 
};
 
if ( !support.checkOn ) {
 
jQuery.valHooks[ this ].get = function( elem ) {
 
return elem.getAttribute( "value" ) === null ? "on" : elem.value;
 
};
 
}
 
} );
 
 
 
 
 
// Return jQuery for attributes-only inclusion
 
 
 
support.focusin = "onfocusin" in window;
 
 
 
var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
 
stopPropagationCallback = function( e ) {
 
e.stopPropagation();
 
};
 
 
jQuery.extend( jQuery.event, {
 
 
trigger: function( event, data, elem, onlyHandlers ) {
 
 
var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
 
eventPath = [ elem || document ],
 
type = hasOwn.call( event, "type" ) ? event.type : event,
 
namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
 
 
cur = lastElement = tmp = elem = elem || document;
 
 
// Don't do events on text and comment nodes
 
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
 
return;
 
}
 
 
// focus/blur morphs to focusin/out; ensure we're not firing them right now
 
if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
 
return;
 
}
 
 
if ( type.indexOf( "." ) > -1 ) {
 
 
// Namespaced trigger; create a regexp to match event type in handle()
 
namespaces = type.split( "." );
 
type = namespaces.shift();
 
namespaces.sort();
 
}
 
ontype = type.indexOf( ":" ) < 0 && "on" + type;
 
 
// Caller can pass in a jQuery.Event object, Object, or just an event type string
 
event = event[ jQuery.expando ] ?
 
event :
 
new jQuery.Event( type, typeof event === "object" && event );
 
 
// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
 
event.isTrigger = onlyHandlers ? 2 : 3;
 
event.namespace = namespaces.join( "." );
 
event.rnamespace = event.namespace ?
 
new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
 
null;
 
 
// Clean up the event in case it is being reused
 
event.result = undefined;
 
if ( !event.target ) {
 
event.target = elem;
 
}
 
 
// Clone any incoming data and prepend the event, creating the handler arg list
 
data = data == null ?
 
[ event ] :
 
jQuery.makeArray( data, [ event ] );
 
 
// Allow special events to draw outside the lines
 
special = jQuery.event.special[ type ] || {};
 
if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
 
return;
 
}
 
 
// Determine event propagation path in advance, per W3C events spec (#9951)
 
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
 
if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
 
 
bubbleType = special.delegateType || type;
 
if ( !rfocusMorph.test( bubbleType + type ) ) {
 
cur = cur.parentNode;
 
}
 
for ( ; cur; cur = cur.parentNode ) {
 
eventPath.push( cur );
 
tmp = cur;
 
}
 
 
// Only add window if we got to document (e.g., not plain obj or detached DOM)
 
if ( tmp === ( elem.ownerDocument || document ) ) {
 
eventPath.push( tmp.defaultView || tmp.parentWindow || window );
 
}
 
}
 
 
// Fire handlers on the event path
 
i = 0;
 
while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
 
lastElement = cur;
 
event.type = i > 1 ?
 
bubbleType :
 
special.bindType || type;
 
 
// jQuery handler
 
handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
 
dataPriv.get( cur, "handle" );
 
if ( handle ) {
 
handle.apply( cur, data );
 
}
 
 
// Native handler
 
handle = ontype && cur[ ontype ];
 
if ( handle && handle.apply && acceptData( cur ) ) {
 
event.result = handle.apply( cur, data );
 
if ( event.result === false ) {
 
event.preventDefault();
 
}
 
}
 
}
 
event.type = type;
 
 
// If nobody prevented the default action, do it now
 
if ( !onlyHandlers && !event.isDefaultPrevented() ) {
 
 
if ( ( !special._default ||
 
special._default.apply( eventPath.pop(), data ) === false ) &&
 
acceptData( elem ) ) {
 
 
// Call a native DOM method on the target with the same name as the event.
 
// Don't do default actions on window, that's where global variables be (#6170)
 
if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
 
 
// Don't re-trigger an onFOO event when we call its FOO() method
 
tmp = elem[ ontype ];
 
 
if ( tmp ) {
 
elem[ ontype ] = null;
 
}
 
 
// Prevent re-triggering of the same event, since we already bubbled it above
 
jQuery.event.triggered = type;
 
 
if ( event.isPropagationStopped() ) {
 
lastElement.addEventListener( type, stopPropagationCallback );
 
}
 
 
elem[ type ]();
 
 
if ( event.isPropagationStopped() ) {
 
lastElement.removeEventListener( type, stopPropagationCallback );
 
}
 
 
jQuery.event.triggered = undefined;
 
 
if ( tmp ) {
 
elem[ ontype ] = tmp;
 
}
 
}
 
}
 
}
 
 
return event.result;
 
},
 
 
// Piggyback on a donor event to simulate a different one
 
// Used only for `focus(in | out)` events
 
simulate: function( type, elem, event ) {
 
var e = jQuery.extend(
 
new jQuery.Event(),
 
event,
 
{
 
type: type,
 
isSimulated: true
 
}
 
);
 
 
jQuery.event.trigger( e, null, elem );
 
}
 
 
} );
 
 
jQuery.fn.extend( {
 
 
trigger: function( type, data ) {
 
return this.each( function() {
 
jQuery.event.trigger( type, data, this );
 
} );
 
},
 
triggerHandler: function( type, data ) {
 
var elem = this[ 0 ];
 
if ( elem ) {
 
return jQuery.event.trigger( type, data, elem, true );
 
}
 
}
 
} );
 
 
 
// Support: Firefox <=44
 
// Firefox doesn't have focus(in | out) events
 
// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
 
//
 
// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
 
// focus(in | out) events fire after focus & blur events,
 
// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
 
// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
 
if ( !support.focusin ) {
 
jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
 
 
// Attach a single capturing handler on the document while someone wants focusin/focusout
 
var handler = function( event ) {
 
jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
 
};
 
 
jQuery.event.special[ fix ] = {
 
setup: function() {
 
var doc = this.ownerDocument || this,
 
attaches = dataPriv.access( doc, fix );
 
 
if ( !attaches ) {
 
doc.addEventListener( orig, handler, true );
 
}
 
dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
 
},
 
teardown: function() {
 
var doc = this.ownerDocument || this,
 
attaches = dataPriv.access( doc, fix ) - 1;
 
 
if ( !attaches ) {
 
doc.removeEventListener( orig, handler, true );
 
dataPriv.remove( doc, fix );
 
 
} else {
 
dataPriv.access( doc, fix, attaches );
 
}
 
}
 
};
 
} );
 
}
 
var location = window.location;
 
 
var nonce = Date.now();
 
 
var rquery = ( /\?/ );
 
 
 
 
// Cross-browser xml parsing
 
jQuery.parseXML = function( data ) {
 
var xml;
 
if ( !data || typeof data !== "string" ) {
 
return null;
 
}
 
 
// Support: IE 9 - 11 only
 
// IE throws on parseFromString with invalid input.
 
try {
 
xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
 
} catch ( e ) {
 
xml = undefined;
 
}
 
 
if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
 
jQuery.error( "Invalid XML: " + data );
 
}
 
return xml;
 
};
 
 
 
var
 
rbracket = /\[\]$/,
 
rCRLF = /\r?\n/g,
 
rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
 
rsubmittable = /^(?:input|select|textarea|keygen)/i;
 
 
function buildParams( prefix, obj, traditional, add ) {
 
var name;
 
 
if ( Array.isArray( obj ) ) {
 
 
// Serialize array item.
 
jQuery.each( obj, function( i, v ) {
 
if ( traditional || rbracket.test( prefix ) ) {
 
 
// Treat each array item as a scalar.
 
add( prefix, v );
 
 
} else {
 
 
// Item is non-scalar (array or object), encode its numeric index.
 
buildParams(
 
prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
 
v,
 
traditional,
 
add
 
);
 
}
 
} );
 
 
} else if ( !traditional && toType( obj ) === "object" ) {
 
 
// Serialize object item.
 
for ( name in obj ) {
 
buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
 
}
 
 
} else {
 
 
// Serialize scalar item.
 
add( prefix, obj );
 
}
 
}
 
 
// Serialize an array of form elements or a set of
 
// key/values into a query string
 
jQuery.param = function( a, traditional ) {
 
var prefix,
 
s = [],
 
add = function( key, valueOrFunction ) {
 
 
// If value is a function, invoke it and use its return value
 
var value = isFunction( valueOrFunction ) ?
 
valueOrFunction() :
 
valueOrFunction;
 
 
s[ s.length ] = encodeURIComponent( key ) + "=" +
 
encodeURIComponent( value == null ? "" : value );
 
};
 
 
// If an array was passed in, assume that it is an array of form elements.
 
if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
 
 
// Serialize the form elements
 
jQuery.each( a, function() {
 
add( this.name, this.value );
 
} );
 
 
} else {
 
 
// If traditional, encode the "old" way (the way 1.3.2 or older
 
// did it), otherwise encode params recursively.
 
for ( prefix in a ) {
 
buildParams( prefix, a[ prefix ], traditional, add );
 
}
 
}
 
 
// Return the resulting serialization
 
return s.join( "&" );
 
};
 
 
jQuery.fn.extend( {
 
serialize: function() {
 
return jQuery.param( this.serializeArray() );
 
},
 
serializeArray: function() {
 
return this.map( function() {
 
 
// Can add propHook for "elements" to filter or add form elements
 
var elements = jQuery.prop( this, "elements" );
 
return elements ? jQuery.makeArray( elements ) : this;
 
} )
 
.filter( function() {
 
var type = this.type;
 
 
// Use .is( ":disabled" ) so that fieldset[disabled] works
 
return this.name && !jQuery( this ).is( ":disabled" ) &&
 
rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
 
( this.checked || !rcheckableType.test( type ) );
 
} )
 
.map( function( i, elem ) {
 
var val = jQuery( this ).val();
 
 
if ( val == null ) {
 
return null;
 
}
 
 
if ( Array.isArray( val ) ) {
 
return jQuery.map( val, function( val ) {
 
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
 
} );
 
}
 
 
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
 
} ).get();
 
}
 
} );
 
 
 
var
 
r20 = /%20/g,
 
rhash = /#.*$/,
 
rantiCache = /([?&])_=[^&]*/,
 
rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
 
 
// #7653, #8125, #8152: local protocol detection
 
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
 
rnoContent = /^(?:GET|HEAD)$/,
 
rprotocol = /^\/\//,
 
 
/* Prefilters
 
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
 
* 2) These are called:
 
*    - BEFORE asking for a transport
 
*    - AFTER param serialization (s.data is a string if s.processData is true)
 
* 3) key is the dataType
 
* 4) the catchall symbol "*" can be used
 
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
 
*/
 
prefilters = {},
 
 
/* Transports bindings
 
* 1) key is the dataType
 
* 2) the catchall symbol "*" can be used
 
* 3) selection will start with transport dataType and THEN go to "*" if needed
 
*/
 
transports = {},
 
 
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
 
allTypes = "*/".concat( "*" ),
 
 
// Anchor tag for parsing the document origin
 
originAnchor = document.createElement( "a" );
 
originAnchor.href = location.href;
 
 
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
 
function addToPrefiltersOrTransports( structure ) {
 
 
// dataTypeExpression is optional and defaults to "*"
 
return function( dataTypeExpression, func ) {
 
 
if ( typeof dataTypeExpression !== "string" ) {
 
func = dataTypeExpression;
 
dataTypeExpression = "*";
 
}
 
 
var dataType,
 
i = 0,
 
dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
 
 
if ( isFunction( func ) ) {
 
 
// For each dataType in the dataTypeExpression
 
while ( ( dataType = dataTypes[ i++ ] ) ) {
 
 
// Prepend if requested
 
if ( dataType[ 0 ] === "+" ) {
 
dataType = dataType.slice( 1 ) || "*";
 
( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
 
 
// Otherwise append
 
} else {
 
( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
 
}
 
}
 
}
 
};
 
}
 
 
// Base inspection function for prefilters and transports
 
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
 
 
var inspected = {},
 
seekingTransport = ( structure === transports );
 
 
function inspect( dataType ) {
 
var selected;
 
inspected[ dataType ] = true;
 
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
 
var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
 
if ( typeof dataTypeOrTransport === "string" &&
 
!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
 
 
options.dataTypes.unshift( dataTypeOrTransport );
 
inspect( dataTypeOrTransport );
 
return false;
 
} else if ( seekingTransport ) {
 
return !( selected = dataTypeOrTransport );
 
}
 
} );
 
return selected;
 
}
 
 
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
 
}
 
 
// A special extend for ajax options
 
// that takes "flat" options (not to be deep extended)
 
// Fixes #9887
 
function ajaxExtend( target, src ) {
 
var key, deep,
 
flatOptions = jQuery.ajaxSettings.flatOptions || {};
 
 
for ( key in src ) {
 
if ( src[ key ] !== undefined ) {
 
( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
 
}
 
}
 
if ( deep ) {
 
jQuery.extend( true, target, deep );
 
}
 
 
return target;
 
}
 
 
/* Handles responses to an ajax request:
 
* - finds the right dataType (mediates between content-type and expected dataType)
 
* - returns the corresponding response
 
*/
 
function ajaxHandleResponses( s, jqXHR, responses ) {
 
 
var ct, type, finalDataType, firstDataType,
 
contents = s.contents,
 
dataTypes = s.dataTypes;
 
 
// Remove auto dataType and get content-type in the process
 
while ( dataTypes[ 0 ] === "*" ) {
 
dataTypes.shift();
 
if ( ct === undefined ) {
 
ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
 
}
 
}
 
 
// Check if we're dealing with a known content-type
 
if ( ct ) {
 
for ( type in contents ) {
 
if ( contents[ type ] && contents[ type ].test( ct ) ) {
 
dataTypes.unshift( type );
 
break;
 
}
 
}
 
}
 
 
// Check to see if we have a response for the expected dataType
 
if ( dataTypes[ 0 ] in responses ) {
 
finalDataType = dataTypes[ 0 ];
 
} else {
 
 
// Try convertible dataTypes
 
for ( type in responses ) {
 
if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
 
finalDataType = type;
 
break;
 
}
 
if ( !firstDataType ) {
 
firstDataType = type;
 
}
 
}
 
 
// Or just use first one
 
finalDataType = finalDataType || firstDataType;
 
}
 
 
// If we found a dataType
 
// We add the dataType to the list if needed
 
// and return the corresponding response
 
if ( finalDataType ) {
 
if ( finalDataType !== dataTypes[ 0 ] ) {
 
dataTypes.unshift( finalDataType );
 
}
 
return responses[ finalDataType ];
 
}
 
}
 
 
/* Chain conversions given the request and the original response
 
* Also sets the responseXXX fields on the jqXHR instance
 
*/
 
function ajaxConvert( s, response, jqXHR, isSuccess ) {
 
var conv2, current, conv, tmp, prev,
 
converters = {},
 
 
// Work with a copy of dataTypes in case we need to modify it for conversion
 
dataTypes = s.dataTypes.slice();
 
 
// Create converters map with lowercased keys
 
if ( dataTypes[ 1 ] ) {
 
for ( conv in s.converters ) {
 
converters[ conv.toLowerCase() ] = s.converters[ conv ];
 
}
 
}
 
 
current = dataTypes.shift();
 
 
// Convert to each sequential dataType
 
while ( current ) {
 
 
if ( s.responseFields[ current ] ) {
 
jqXHR[ s.responseFields[ current ] ] = response;
 
}
 
 
// Apply the dataFilter if provided
 
if ( !prev && isSuccess && s.dataFilter ) {
 
response = s.dataFilter( response, s.dataType );
 
}
 
 
prev = current;
 
current = dataTypes.shift();
 
 
if ( current ) {
 
 
// There's only work to do if current dataType is non-auto
 
if ( current === "*" ) {
 
 
current = prev;
 
 
// Convert response if prev dataType is non-auto and differs from current
 
} else if ( prev !== "*" && prev !== current ) {
 
 
// Seek a direct converter
 
conv = converters[ prev + " " + current ] || converters[ "* " + current ];
 
 
// If none found, seek a pair
 
if ( !conv ) {
 
for ( conv2 in converters ) {
 
 
// If conv2 outputs current
 
tmp = conv2.split( " " );
 
if ( tmp[ 1 ] === current ) {
 
 
// If prev can be converted to accepted input
 
conv = converters[ prev + " " + tmp[ 0 ] ] ||
 
converters[ "* " + tmp[ 0 ] ];
 
if ( conv ) {
 
 
// Condense equivalence converters
 
if ( conv === true ) {
 
conv = converters[ conv2 ];
 
 
// Otherwise, insert the intermediate dataType
 
} else if ( converters[ conv2 ] !== true ) {
 
current = tmp[ 0 ];
 
dataTypes.unshift( tmp[ 1 ] );
 
}
 
break;
 
}
 
}
 
}
 
}
 
 
// Apply converter (if not an equivalence)
 
if ( conv !== true ) {
 
 
// Unless errors are allowed to bubble, catch and return them
 
if ( conv && s.throws ) {
 
response = conv( response );
 
} else {
 
try {
 
response = conv( response );
 
} catch ( e ) {
 
return {
 
state: "parsererror",
 
error: conv ? e : "No conversion from " + prev + " to " + current
 
};
 
}
 
}
 
}
 
}
 
}
 
}
 
 
return { state: "success", data: response };
 
}
 
 
jQuery.extend( {
 
 
// Counter for holding the number of active queries
 
active: 0,
 
 
// Last-Modified header cache for next request
 
lastModified: {},
 
etag: {},
 
 
ajaxSettings: {
 
url: location.href,
 
type: "GET",
 
isLocal: rlocalProtocol.test( location.protocol ),
 
global: true,
 
processData: true,
 
async: true,
 
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
 
 
/*
 
timeout: 0,
 
data: null,
 
dataType: null,
 
username: null,
 
password: null,
 
cache: null,
 
throws: false,
 
traditional: false,
 
headers: {},
 
*/
 
 
accepts: {
 
"*": allTypes,
 
text: "text/plain",
 
html: "text/html",
 
xml: "application/xml, text/xml",
 
json: "application/json, text/javascript"
 
},
 
 
contents: {
 
xml: /\bxml\b/,
 
html: /\bhtml/,
 
json: /\bjson\b/
 
},
 
 
responseFields: {
 
xml: "responseXML",
 
text: "responseText",
 
json: "responseJSON"
 
},
 
 
// Data converters
 
// Keys separate source (or catchall "*") and destination types with a single space
 
converters: {
 
 
// Convert anything to text
 
"* text": String,
 
 
// Text to html (true = no transformation)
 
"text html": true,
 
 
// Evaluate text as a json expression
 
"text json": JSON.parse,
 
 
// Parse text as xml
 
"text xml": jQuery.parseXML
 
},
 
 
// For options that shouldn't be deep extended:
 
// you can add your own custom options here if
 
// and when you create one that shouldn't be
 
// deep extended (see ajaxExtend)
 
flatOptions: {
 
url: true,
 
context: true
 
}
 
},
 
 
// Creates a full fledged settings object into target
 
// with both ajaxSettings and settings fields.
 
// If target is omitted, writes into ajaxSettings.
 
ajaxSetup: function( target, settings ) {
 
return settings ?
 
 
// Building a settings object
 
ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
 
 
// Extending ajaxSettings
 
ajaxExtend( jQuery.ajaxSettings, target );
 
},
 
 
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
 
ajaxTransport: addToPrefiltersOrTransports( transports ),
 
 
// Main method
 
ajax: function( url, options ) {
 
 
// If url is an object, simulate pre-1.5 signature
 
if ( typeof url === "object" ) {
 
options = url;
 
url = undefined;
 
}
 
 
// Force options to be an object
 
options = options || {};
 
 
var transport,
 
 
// URL without anti-cache param
 
cacheURL,
 
 
// Response headers
 
responseHeadersString,
 
responseHeaders,
 
 
// timeout handle
 
timeoutTimer,
 
 
// Url cleanup var
 
urlAnchor,
 
 
// Request state (becomes false upon send and true upon completion)
 
completed,
 
 
// To know if global events are to be dispatched
 
fireGlobals,
 
 
// Loop variable
 
i,
 
 
// uncached part of the url
 
uncached,
 
 
// Create the final options object
 
s = jQuery.ajaxSetup( {}, options ),
 
 
// Callbacks context
 
callbackContext = s.context || s,
 
 
// Context for global events is callbackContext if it is a DOM node or jQuery collection
 
globalEventContext = s.context &&
 
( callbackContext.nodeType || callbackContext.jquery ) ?
 
jQuery( callbackContext ) :
 
jQuery.event,
 
 
// Deferreds
 
deferred = jQuery.Deferred(),
 
completeDeferred = jQuery.Callbacks( "once memory" ),
 
 
// Status-dependent callbacks
 
statusCode = s.statusCode || {},
 
 
// Headers (they are sent all at once)
 
requestHeaders = {},
 
requestHeadersNames = {},
 
 
// Default abort message
 
strAbort = "canceled",
 
 
// Fake xhr
 
jqXHR = {
 
readyState: 0,
 
 
// Builds headers hashtable if needed
 
getResponseHeader: function( key ) {
 
var match;
 
if ( completed ) {
 
if ( !responseHeaders ) {
 
responseHeaders = {};
 
while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
 
responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
 
}
 
}
 
match = responseHeaders[ key.toLowerCase() ];
 
}
 
return match == null ? null : match;
 
},
 
 
// Raw string
 
getAllResponseHeaders: function() {
 
return completed ? responseHeadersString : null;
 
},
 
 
// Caches the header
 
setRequestHeader: function( name, value ) {
 
if ( completed == null ) {
 
name = requestHeadersNames[ name.toLowerCase() ] =
 
requestHeadersNames[ name.toLowerCase() ] || name;
 
requestHeaders[ name ] = value;
 
}
 
return this;
 
},
 
 
// Overrides response content-type header
 
overrideMimeType: function( type ) {
 
if ( completed == null ) {
 
s.mimeType = type;
 
}
 
return this;
 
},
 
 
// Status-dependent callbacks
 
statusCode: function( map ) {
 
var code;
 
if ( map ) {
 
if ( completed ) {
 
 
// Execute the appropriate callbacks
 
jqXHR.always( map[ jqXHR.status ] );
 
} else {
 
 
// Lazy-add the new callbacks in a way that preserves old ones
 
for ( code in map ) {
 
statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
 
}
 
}
 
}
 
return this;
 
},
 
 
// Cancel the request
 
abort: function( statusText ) {
 
var finalText = statusText || strAbort;
 
if ( transport ) {
 
transport.abort( finalText );
 
}
 
done( 0, finalText );
 
return this;
 
}
 
};
 
 
// Attach deferreds
 
deferred.promise( jqXHR );
 
 
// Add protocol if not provided (prefilters might expect it)
 
// Handle falsy url in the settings object (#10093: consistency with old signature)
 
// We also use the url parameter if available
 
s.url = ( ( url || s.url || location.href ) + "" )
 
.replace( rprotocol, location.protocol + "//" );
 
 
// Alias method option to type as per ticket #12004
 
s.type = options.method || options.type || s.method || s.type;
 
 
// Extract dataTypes list
 
s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
 
 
// A cross-domain request is in order when the origin doesn't match the current origin.
 
if ( s.crossDomain == null ) {
 
urlAnchor = document.createElement( "a" );
 
 
// Support: IE <=8 - 11, Edge 12 - 15
 
// IE throws exception on accessing the href property if url is malformed,
 
// e.g. http://example.com:80x/
 
try {
 
urlAnchor.href = s.url;
 
 
// Support: IE <=8 - 11 only
 
// Anchor's host property isn't correctly set when s.url is relative
 
urlAnchor.href = urlAnchor.href;
 
s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
 
urlAnchor.protocol + "//" + urlAnchor.host;
 
} catch ( e ) {
 
 
// If there is an error parsing the URL, assume it is crossDomain,
 
// it can be rejected by the transport if it is invalid
 
s.crossDomain = true;
 
}
 
}
 
 
// Convert data if not already a string
 
if ( s.data && s.processData && typeof s.data !== "string" ) {
 
s.data = jQuery.param( s.data, s.traditional );
 
}
 
 
// Apply prefilters
 
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
 
 
// If request was aborted inside a prefilter, stop there
 
if ( completed ) {
 
return jqXHR;
 
}
 
 
// We can fire global events as of now if asked to
 
// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
 
fireGlobals = jQuery.event && s.global;
 
 
// Watch for a new set of requests
 
if ( fireGlobals && jQuery.active++ === 0 ) {
 
jQuery.event.trigger( "ajaxStart" );
 
}
 
 
// Uppercase the type
 
s.type = s.type.toUpperCase();
 
 
// Determine if request has content
 
s.hasContent = !rnoContent.test( s.type );
 
 
// Save the URL in case we're toying with the If-Modified-Since
 
// and/or If-None-Match header later on
 
// Remove hash to simplify url manipulation
 
cacheURL = s.url.replace( rhash, "" );
 
 
// More options handling for requests with no content
 
if ( !s.hasContent ) {
 
 
// Remember the hash so we can put it back
 
uncached = s.url.slice( cacheURL.length );
 
 
// If data is available and should be processed, append data to url
 
if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
 
cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
 
 
// #9682: remove data so that it's not used in an eventual retry
 
delete s.data;
 
}
 
 
// Add or update anti-cache param if needed
 
if ( s.cache === false ) {
 
cacheURL = cacheURL.replace( rantiCache, "$1" );
 
uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
 
}
 
 
// Put hash and anti-cache on the URL that will be requested (gh-1732)
 
s.url = cacheURL + uncached;
 
 
// Change '%20' to '+' if this is encoded form body content (gh-2658)
 
} else if ( s.data && s.processData &&
 
( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
 
s.data = s.data.replace( r20, "+" );
 
}
 
 
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
 
if ( s.ifModified ) {
 
if ( jQuery.lastModified[ cacheURL ] ) {
 
jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
 
}
 
if ( jQuery.etag[ cacheURL ] ) {
 
jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
 
}
 
}
 
 
// Set the correct header, if data is being sent
 
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
 
jqXHR.setRequestHeader( "Content-Type", s.contentType );
 
}
 
 
// Set the Accepts header for the server, depending on the dataType
 
jqXHR.setRequestHeader(
 
"Accept",
 
s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
 
s.accepts[ s.dataTypes[ 0 ] ] +
 
( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
 
s.accepts[ "*" ]
 
);
 
 
// Check for headers option
 
for ( i in s.headers ) {
 
jqXHR.setRequestHeader( i, s.headers[ i ] );
 
}
 
 
// Allow custom headers/mimetypes and early abort
 
if ( s.beforeSend &&
 
( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
 
 
// Abort if not done already and return
 
return jqXHR.abort();
 
}
 
 
// Aborting is no longer a cancellation
 
strAbort = "abort";
 
 
// Install callbacks on deferreds
 
completeDeferred.add( s.complete );
 
jqXHR.done( s.success );
 
jqXHR.fail( s.error );
 
 
// Get transport
 
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
 
 
// If no transport, we auto-abort
 
if ( !transport ) {
 
done( -1, "No Transport" );
 
} else {
 
jqXHR.readyState = 1;
 
 
// Send global event
 
if ( fireGlobals ) {
 
globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
 
}
 
 
// If request was aborted inside ajaxSend, stop there
 
if ( completed ) {
 
return jqXHR;
 
}
 
 
// Timeout
 
if ( s.async && s.timeout > 0 ) {
 
timeoutTimer = window.setTimeout( function() {
 
jqXHR.abort( "timeout" );
 
}, s.timeout );
 
}
 
 
try {
 
completed = false;
 
transport.send( requestHeaders, done );
 
} catch ( e ) {
 
 
// Rethrow post-completion exceptions
 
if ( completed ) {
 
throw e;
 
}
 
 
// Propagate others as results
 
done( -1, e );
 
}
 
}
 
 
// Callback for when everything is done
 
function done( status, nativeStatusText, responses, headers ) {
 
var isSuccess, success, error, response, modified,
 
statusText = nativeStatusText;
 
 
// Ignore repeat invocations
 
if ( completed ) {
 
return;
 
}
 
 
completed = true;
 
 
// Clear timeout if it exists
 
if ( timeoutTimer ) {
 
window.clearTimeout( timeoutTimer );
 
}
 
 
// Dereference transport for early garbage collection
 
// (no matter how long the jqXHR object will be used)
 
transport = undefined;
 
 
// Cache response headers
 
responseHeadersString = headers || "";
 
 
// Set readyState
 
jqXHR.readyState = status > 0 ? 4 : 0;
 
 
// Determine if successful
 
isSuccess = status >= 200 && status < 300 || status === 304;
 
 
// Get response data
 
if ( responses ) {
 
response = ajaxHandleResponses( s, jqXHR, responses );
 
}
 
 
// Convert no matter what (that way responseXXX fields are always set)
 
response = ajaxConvert( s, response, jqXHR, isSuccess );
 
 
// If successful, handle type chaining
 
if ( isSuccess ) {
 
 
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
 
if ( s.ifModified ) {
 
modified = jqXHR.getResponseHeader( "Last-Modified" );
 
if ( modified ) {
 
jQuery.lastModified[ cacheURL ] = modified;
 
}
 
modified = jqXHR.getResponseHeader( "etag" );
 
if ( modified ) {
 
jQuery.etag[ cacheURL ] = modified;
 
}
 
}
 
 
// if no content
 
if ( status === 204 || s.type === "HEAD" ) {
 
statusText = "nocontent";
 
 
// if not modified
 
} else if ( status === 304 ) {
 
statusText = "notmodified";
 
 
// If we have data, let's convert it
 
} else {
 
statusText = response.state;
 
success = response.data;
 
error = response.error;
 
isSuccess = !error;
 
}
 
} else {
 
 
// Extract error from statusText and normalize for non-aborts
 
error = statusText;
 
if ( status || !statusText ) {
 
statusText = "error";
 
if ( status < 0 ) {
 
status = 0;
 
}
 
}
 
}
 
 
// Set data for the fake xhr object
 
jqXHR.status = status;
 
jqXHR.statusText = ( nativeStatusText || statusText ) + "";
 
 
// Success/Error
 
if ( isSuccess ) {
 
deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
 
} else {
 
deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
 
}
 
 
// Status-dependent callbacks
 
jqXHR.statusCode( statusCode );
 
statusCode = undefined;
 
 
if ( fireGlobals ) {
 
globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
 
[ jqXHR, s, isSuccess ? success : error ] );
 
}
 
 
// Complete
 
completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
 
 
if ( fireGlobals ) {
 
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
 
 
// Handle the global AJAX counter
 
if ( !( --jQuery.active ) ) {
 
jQuery.event.trigger( "ajaxStop" );
 
}
 
}
 
}
 
 
return jqXHR;
 
},
 
 
getJSON: function( url, data, callback ) {
 
return jQuery.get( url, data, callback, "json" );
 
},
 
 
getScript: function( url, callback ) {
 
return jQuery.get( url, undefined, callback, "script" );
 
}
 
} );
 
 
jQuery.each( [ "get", "post" ], function( i, method ) {
 
jQuery[ method ] = function( url, data, callback, type ) {
 
 
// Shift arguments if data argument was omitted
 
if ( isFunction( data ) ) {
 
type = type || callback;
 
callback = data;
 
data = undefined;
 
}
 
 
// The url can be an options object (which then must have .url)
 
return jQuery.ajax( jQuery.extend( {
 
url: url,
 
type: method,
 
dataType: type,
 
data: data,
 
success: callback
 
}, jQuery.isPlainObject( url ) && url ) );
 
};
 
} );
 
 
 
jQuery._evalUrl = function( url ) {
 
return jQuery.ajax( {
 
url: url,
 
 
// Make this explicit, since user can override this through ajaxSetup (#11264)
 
type: "GET",
 
dataType: "script",
 
cache: true,
 
async: false,
 
global: false,
 
"throws": true
 
} );
 
};
 
 
 
jQuery.fn.extend( {
 
wrapAll: function( html ) {
 
var wrap;
 
 
if ( this[ 0 ] ) {
 
if ( isFunction( html ) ) {
 
html = html.call( this[ 0 ] );
 
}
 
 
// The elements to wrap the target around
 
wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
 
 
if ( this[ 0 ].parentNode ) {
 
wrap.insertBefore( this[ 0 ] );
 
}
 
 
wrap.map( function() {
 
var elem = this;
 
 
while ( elem.firstElementChild ) {
 
elem = elem.firstElementChild;
 
}
 
 
return elem;
 
} ).append( this );
 
}
 
 
return this;
 
},
 
 
wrapInner: function( html ) {
 
if ( isFunction( html ) ) {
 
return this.each( function( i ) {
 
jQuery( this ).wrapInner( html.call( this, i ) );
 
} );
 
}
 
 
return this.each( function() {
 
var self = jQuery( this ),
 
contents = self.contents();
 
 
if ( contents.length ) {
 
contents.wrapAll( html );
 
 
} else {
 
self.append( html );
 
}
 
} );
 
},
 
 
wrap: function( html ) {
 
var htmlIsFunction = isFunction( html );
 
 
return this.each( function( i ) {
 
jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
 
} );
 
},
 
 
unwrap: function( selector ) {
 
this.parent( selector ).not( "body" ).each( function() {
 
jQuery( this ).replaceWith( this.childNodes );
 
} );
 
return this;
 
}
 
} );
 
 
 
jQuery.expr.pseudos.hidden = function( elem ) {
 
return !jQuery.expr.pseudos.visible( elem );
 
};
 
jQuery.expr.pseudos.visible = function( elem ) {
 
return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
 
};
 
 
 
 
 
jQuery.ajaxSettings.xhr = function() {
 
try {
 
return new window.XMLHttpRequest();
 
} catch ( e ) {}
 
};
 
 
var xhrSuccessStatus = {
 
 
// File protocol always yields status code 0, assume 200
 
0: 200,
 
 
// Support: IE <=9 only
 
// #1450: sometimes IE returns 1223 when it should be 204
 
1223: 204
 
},
 
xhrSupported = jQuery.ajaxSettings.xhr();
 
 
support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
 
support.ajax = xhrSupported = !!xhrSupported;
 
 
jQuery.ajaxTransport( function( options ) {
 
var callback, errorCallback;
 
 
// Cross domain only allowed if supported through XMLHttpRequest
 
if ( support.cors || xhrSupported && !options.crossDomain ) {
 
return {
 
send: function( headers, complete ) {
 
var i,
 
xhr = options.xhr();
 
 
xhr.open(
 
options.type,
 
options.url,
 
options.async,
 
options.username,
 
options.password
 
);
 
 
// Apply custom fields if provided
 
if ( options.xhrFields ) {
 
for ( i in options.xhrFields ) {
 
xhr[ i ] = options.xhrFields[ i ];
 
}
 
}
 
 
// Override mime type if needed
 
if ( options.mimeType && xhr.overrideMimeType ) {
 
xhr.overrideMimeType( options.mimeType );
 
}
 
 
// X-Requested-With header
 
// For cross-domain requests, seeing as conditions for a preflight are
 
// akin to a jigsaw puzzle, we simply never set it to be sure.
 
// (it can always be set on a per-request basis or even using ajaxSetup)
 
// For same-domain requests, won't change header if already provided.
 
if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
 
headers[ "X-Requested-With" ] = "XMLHttpRequest";
 
}
 
 
// Set headers
 
for ( i in headers ) {
 
xhr.setRequestHeader( i, headers[ i ] );
 
}
 
 
// Callback
 
callback = function( type ) {
 
return function() {
 
if ( callback ) {
 
callback = errorCallback = xhr.onload =
 
xhr.onerror = xhr.onabort = xhr.ontimeout =
 
xhr.onreadystatechange = null;
 
 
if ( type === "abort" ) {
 
xhr.abort();
 
} else if ( type === "error" ) {
 
 
// Support: IE <=9 only
 
// On a manual native abort, IE9 throws
 
// errors on any property access that is not readyState
 
if ( typeof xhr.status !== "number" ) {
 
complete( 0, "error" );
 
} else {
 
complete(
 
 
// File: protocol always yields status 0; see #8605, #14207
 
xhr.status,
 
xhr.statusText
 
);
 
}
 
} else {
 
complete(
 
xhrSuccessStatus[ xhr.status ] || xhr.status,
 
xhr.statusText,
 
 
// Support: IE <=9 only
 
// IE9 has no XHR2 but throws on binary (trac-11426)
 
// For XHR2 non-text, let the caller handle it (gh-2498)
 
( xhr.responseType || "text" ) !== "text"  ||
 
typeof xhr.responseText !== "string" ?
 
{ binary: xhr.response } :
 
{ text: xhr.responseText },
 
xhr.getAllResponseHeaders()
 
);
 
}
 
}
 
};
 
};
 
 
// Listen to events
 
xhr.onload = callback();
 
errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
 
 
// Support: IE 9 only
 
// Use onreadystatechange to replace onabort
 
// to handle uncaught aborts
 
if ( xhr.onabort !== undefined ) {
 
xhr.onabort = errorCallback;
 
} else {
 
xhr.onreadystatechange = function() {
 
 
// Check readyState before timeout as it changes
 
if ( xhr.readyState === 4 ) {
 
 
// Allow onerror to be called first,
 
// but that will not handle a native abort
 
// Also, save errorCallback to a variable
 
// as xhr.onerror cannot be accessed
 
window.setTimeout( function() {
 
if ( callback ) {
 
errorCallback();
 
}
 
} );
 
}
 
};
 
}
 
 
// Create the abort callback
 
callback = callback( "abort" );
 
 
try {
 
 
// Do send the request (this may raise an exception)
 
xhr.send( options.hasContent && options.data || null );
 
} catch ( e ) {
 
 
// #14683: Only rethrow if this hasn't been notified as an error yet
 
if ( callback ) {
 
throw e;
 
}
 
}
 
},
 
 
abort: function() {
 
if ( callback ) {
 
callback();
 
}
 
}
 
};
 
}
 
} );
 
 
 
 
 
// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
 
jQuery.ajaxPrefilter( function( s ) {
 
if ( s.crossDomain ) {
 
s.contents.script = false;
 
}
 
} );
 
 
// Install script dataType
 
jQuery.ajaxSetup( {
 
accepts: {
 
script: "text/javascript, application/javascript, " +
 
"application/ecmascript, application/x-ecmascript"
 
},
 
contents: {
 
script: /\b(?:java|ecma)script\b/
 
},
 
converters: {
 
"text script": function( text ) {
 
jQuery.globalEval( text );
 
return text;
 
}
 
}
 
} );
 
 
// Handle cache's special case and crossDomain
 
jQuery.ajaxPrefilter( "script", function( s ) {
 
if ( s.cache === undefined ) {
 
s.cache = false;
 
}
 
if ( s.crossDomain ) {
 
s.type = "GET";
 
}
 
} );
 
 
// Bind script tag hack transport
 
jQuery.ajaxTransport( "script", function( s ) {
 
 
// This transport only deals with cross domain requests
 
if ( s.crossDomain ) {
 
var script, callback;
 
return {
 
send: function( _, complete ) {
 
script = jQuery( "<script>" ).prop( {
 
charset: s.scriptCharset,
 
src: s.url
 
} ).on(
 
"load error",
 
callback = function( evt ) {
 
script.remove();
 
callback = null;
 
if ( evt ) {
 
complete( evt.type === "error" ? 404 : 200, evt.type );
 
}
 
}
 
);
 
 
// Use native DOM manipulation to avoid our domManip AJAX trickery
 
document.head.appendChild( script[ 0 ] );
 
},
 
abort: function() {
 
if ( callback ) {
 
callback();
 
}
 
}
 
};
 
}
 
} );
 
 
 
 
 
var oldCallbacks = [],
 
rjsonp = /(=)\?(?=&|$)|\?\?/;
 
 
// Default jsonp settings
 
jQuery.ajaxSetup( {
 
jsonp: "callback",
 
jsonpCallback: function() {
 
var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
 
this[ callback ] = true;
 
return callback;
 
}
 
} );
 
 
// Detect, normalize options and install callbacks for jsonp requests
 
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
 
 
var callbackName, overwritten, responseContainer,
 
jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
 
"url" :
 
typeof s.data === "string" &&
 
( s.contentType || "" )
 
.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
 
rjsonp.test( s.data ) && "data"
 
);
 
 
// Handle iff the expected data type is "jsonp" or we have a parameter to set
 
if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
 
 
// Get callback name, remembering preexisting value associated with it
 
callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
 
s.jsonpCallback() :
 
s.jsonpCallback;
 
 
// Insert callback into url or form data
 
if ( jsonProp ) {
 
s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
 
} else if ( s.jsonp !== false ) {
 
s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
 
}
 
 
// Use data converter to retrieve json after script execution
 
s.converters[ "script json" ] = function() {
 
if ( !responseContainer ) {
 
jQuery.error( callbackName + " was not called" );
 
}
 
return responseContainer[ 0 ];
 
};
 
 
// Force json dataType
 
s.dataTypes[ 0 ] = "json";
 
 
// Install callback
 
overwritten = window[ callbackName ];
 
window[ callbackName ] = function() {
 
responseContainer = arguments;
 
};
 
 
// Clean-up function (fires after converters)
 
jqXHR.always( function() {
 
 
// If previous value didn't exist - remove it
 
if ( overwritten === undefined ) {
 
jQuery( window ).removeProp( callbackName );
 
 
// Otherwise restore preexisting value
 
} else {
 
window[ callbackName ] = overwritten;
 
}
 
 
// Save back as free
 
if ( s[ callbackName ] ) {
 
 
// Make sure that re-using the options doesn't screw things around
 
s.jsonpCallback = originalSettings.jsonpCallback;
 
 
// Save the callback name for future use
 
oldCallbacks.push( callbackName );
 
}
 
 
// Call if it was a function and we have a response
 
if ( responseContainer && isFunction( overwritten ) ) {
 
overwritten( responseContainer[ 0 ] );
 
}
 
 
responseContainer = overwritten = undefined;
 
} );
 
 
// Delegate to script
 
return "script";
 
}
 
} );
 
 
 
 
 
// Support: Safari 8 only
 
// In Safari 8 documents created via document.implementation.createHTMLDocument
 
// collapse sibling forms: the second one becomes a child of the first one.
 
// Because of that, this security measure has to be disabled in Safari 8.
 
// https://bugs.webkit.org/show_bug.cgi?id=137337
 
support.createHTMLDocument = ( function() {
 
var body = document.implementation.createHTMLDocument( "" ).body;
 
body.innerHTML = "<form></form><form></form>";
 
return body.childNodes.length === 2;
 
} )();
 
 
 
// Argument "data" should be string of html
 
// context (optional): If specified, the fragment will be created in this context,
 
// defaults to document
 
// keepScripts (optional): If true, will include scripts passed in the html string
 
jQuery.parseHTML = function( data, context, keepScripts ) {
 
if ( typeof data !== "string" ) {
 
return [];
 
}
 
if ( typeof context === "boolean" ) {
 
keepScripts = context;
 
context = false;
 
}
 
 
var base, parsed, scripts;
 
 
if ( !context ) {
 
 
// Stop scripts or inline event handlers from being executed immediately
 
// by using document.implementation
 
if ( support.createHTMLDocument ) {
 
context = document.implementation.createHTMLDocument( "" );
 
 
// Set the base href for the created document
 
// so any parsed elements with URLs
 
// are based on the document's URL (gh-2965)
 
base = context.createElement( "base" );
 
base.href = document.location.href;
 
context.head.appendChild( base );
 
} else {
 
context = document;
 
}
 
}
 
 
parsed = rsingleTag.exec( data );
 
scripts = !keepScripts && [];
 
 
// Single tag
 
if ( parsed ) {
 
return [ context.createElement( parsed[ 1 ] ) ];
 
}
 
 
parsed = buildFragment( [ data ], context, scripts );
 
 
if ( scripts && scripts.length ) {
 
jQuery( scripts ).remove();
 
}
 
 
return jQuery.merge( [], parsed.childNodes );
 
};
 
 
 
/**
 
* Load a url into a page
 
*/
 
jQuery.fn.load = function( url, params, callback ) {
 
var selector, type, response,
 
self = this,
 
off = url.indexOf( " " );
 
 
if ( off > -1 ) {
 
selector = stripAndCollapse( url.slice( off ) );
 
url = url.slice( 0, off );
 
}
 
 
// If it's a function
 
if ( isFunction( params ) ) {
 
 
// We assume that it's the callback
 
callback = params;
 
params = undefined;
 
 
// Otherwise, build a param string
 
} else if ( params && typeof params === "object" ) {
 
type = "POST";
 
}
 
 
// If we have elements to modify, make the request
 
if ( self.length > 0 ) {
 
jQuery.ajax( {
 
url: url,
 
 
// If "type" variable is undefined, then "GET" method will be used.
 
// Make value of this field explicit since
 
// user can override it through ajaxSetup method
 
type: type || "GET",
 
dataType: "html",
 
data: params
 
} ).done( function( responseText ) {
 
 
// Save response for use in complete callback
 
response = arguments;
 
 
self.html( selector ?
 
 
// If a selector was specified, locate the right elements in a dummy div
 
// Exclude scripts to avoid IE 'Permission Denied' errors
 
jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
 
 
// Otherwise use the full result
 
responseText );
 
 
// If the request succeeds, this function gets "data", "status", "jqXHR"
 
// but they are ignored because response was set above.
 
// If it fails, this function gets "jqXHR", "status", "error"
 
} ).always( callback && function( jqXHR, status ) {
 
self.each( function() {
 
callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
 
} );
 
} );
 
}
 
 
return this;
 
};
 
 
 
 
 
// Attach a bunch of functions for handling common AJAX events
 
jQuery.each( [
 
"ajaxStart",
 
"ajaxStop",
 
"ajaxComplete",
 
"ajaxError",
 
"ajaxSuccess",
 
"ajaxSend"
 
], function( i, type ) {
 
jQuery.fn[ type ] = function( fn ) {
 
return this.on( type, fn );
 
};
 
} );
 
 
 
 
 
jQuery.expr.pseudos.animated = function( elem ) {
 
return jQuery.grep( jQuery.timers, function( fn ) {
 
return elem === fn.elem;
 
} ).length;
 
};
 
 
 
 
 
jQuery.offset = {
 
setOffset: function( elem, options, i ) {
 
var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
 
position = jQuery.css( elem, "position" ),
 
curElem = jQuery( elem ),
 
props = {};
 
 
// Set position first, in-case top/left are set even on static elem
 
if ( position === "static" ) {
 
elem.style.position = "relative";
 
}
 
 
curOffset = curElem.offset();
 
curCSSTop = jQuery.css( elem, "top" );
 
curCSSLeft = jQuery.css( elem, "left" );
 
calculatePosition = ( position === "absolute" || position === "fixed" ) &&
 
( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
 
 
// Need to be able to calculate position if either
 
// top or left is auto and position is either absolute or fixed
 
if ( calculatePosition ) {
 
curPosition = curElem.position();
 
curTop = curPosition.top;
 
curLeft = curPosition.left;
 
 
} else {
 
curTop = parseFloat( curCSSTop ) || 0;
 
curLeft = parseFloat( curCSSLeft ) || 0;
 
}
 
 
if ( isFunction( options ) ) {
 
 
// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
 
options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
 
}
 
 
if ( options.top != null ) {
 
props.top = ( options.top - curOffset.top ) + curTop;
 
}
 
if ( options.left != null ) {
 
props.left = ( options.left - curOffset.left ) + curLeft;
 
}
 
 
if ( "using" in options ) {
 
options.using.call( elem, props );
 
 
} else {
 
curElem.css( props );
 
}
 
}
 
};
 
 
jQuery.fn.extend( {
 
 
// offset() relates an element's border box to the document origin
 
offset: function( options ) {
 
 
// Preserve chaining for setter
 
if ( arguments.length ) {
 
return options === undefined ?
 
this :
 
this.each( function( i ) {
 
jQuery.offset.setOffset( this, options, i );
 
} );
 
}
 
 
var rect, win,
 
elem = this[ 0 ];
 
 
if ( !elem ) {
 
return;
 
}
 
 
// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
 
// Support: IE <=11 only
 
// Running getBoundingClientRect on a
 
// disconnected node in IE throws an error
 
if ( !elem.getClientRects().length ) {
 
return { top: 0, left: 0 };
 
}
 
 
// Get document-relative position by adding viewport scroll to viewport-relative gBCR
 
rect = elem.getBoundingClientRect();
 
win = elem.ownerDocument.defaultView;
 
return {
 
top: rect.top + win.pageYOffset,
 
left: rect.left + win.pageXOffset
 
};
 
},
 
 
// position() relates an element's margin box to its offset parent's padding box
 
// This corresponds to the behavior of CSS absolute positioning
 
position: function() {
 
if ( !this[ 0 ] ) {
 
return;
 
}
 
 
var offsetParent, offset, doc,
 
elem = this[ 0 ],
 
parentOffset = { top: 0, left: 0 };
 
 
// position:fixed elements are offset from the viewport, which itself always has zero offset
 
if ( jQuery.css( elem, "position" ) === "fixed" ) {
 
 
// Assume position:fixed implies availability of getBoundingClientRect
 
offset = elem.getBoundingClientRect();
 
 
} else {
 
offset = this.offset();
 
 
// Account for the *real* offset parent, which can be the document or its root element
 
// when a statically positioned element is identified
 
doc = elem.ownerDocument;
 
offsetParent = elem.offsetParent || doc.documentElement;
 
while ( offsetParent &&
 
( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
 
jQuery.css( offsetParent, "position" ) === "static" ) {
 
 
offsetParent = offsetParent.parentNode;
 
}
 
if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
 
 
// Incorporate borders into its offset, since they are outside its content origin
 
parentOffset = jQuery( offsetParent ).offset();
 
parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
 
parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
 
}
 
}
 
 
// Subtract parent offsets and element margins
 
return {
 
top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
 
left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
 
};
 
},
 
 
// This method will return documentElement in the following cases:
 
// 1) For the element inside the iframe without offsetParent, this method will return
 
//    documentElement of the parent window
 
// 2) For the hidden or detached element
 
// 3) For body or html element, i.e. in case of the html node - it will return itself
 
//
 
// but those exceptions were never presented as a real life use-cases
 
// and might be considered as more preferable results.
 
//
 
// This logic, however, is not guaranteed and can change at any point in the future
 
offsetParent: function() {
 
return this.map( function() {
 
var offsetParent = this.offsetParent;
 
 
while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
 
offsetParent = offsetParent.offsetParent;
 
}
 
 
return offsetParent || documentElement;
 
} );
 
}
 
} );
 
 
// Create scrollLeft and scrollTop methods
 
jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
 
var top = "pageYOffset" === prop;
 
 
jQuery.fn[ method ] = function( val ) {
 
return access( this, function( elem, method, val ) {
 
 
// Coalesce documents and windows
 
var win;
 
if ( isWindow( elem ) ) {
 
win = elem;
 
} else if ( elem.nodeType === 9 ) {
 
win = elem.defaultView;
 
}
 
 
if ( val === undefined ) {
 
return win ? win[ prop ] : elem[ method ];
 
}
 
 
if ( win ) {
 
win.scrollTo(
 
!top ? val : win.pageXOffset,
 
top ? val : win.pageYOffset
 
);
 
 
} else {
 
elem[ method ] = val;
 
}
 
}, method, val, arguments.length );
 
};
 
} );
 
 
// Support: Safari <=7 - 9.1, Chrome <=37 - 49
 
// Add the top/left cssHooks using jQuery.fn.position
 
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
 
// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
 
// getComputedStyle returns percent when specified for top/left/bottom/right;
 
// rather than make the css module depend on the offset module, just check for it here
 
jQuery.each( [ "top", "left" ], function( i, prop ) {
 
jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
 
function( elem, computed ) {
 
if ( computed ) {
 
computed = curCSS( elem, prop );
 
 
// If curCSS returns percentage, fallback to offset
 
return rnumnonpx.test( computed ) ?
 
jQuery( elem ).position()[ prop ] + "px" :
 
computed;
 
}
 
}
 
);
 
} );
 
 
 
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
 
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
 
jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
 
function( defaultExtra, funcName ) {
 
 
// Margin is only for outerHeight, outerWidth
 
jQuery.fn[ funcName ] = function( margin, value ) {
 
var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
 
extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
 
 
return access( this, function( elem, type, value ) {
 
var doc;
 
 
if ( isWindow( elem ) ) {
 
 
// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
 
return funcName.indexOf( "outer" ) === 0 ?
 
elem[ "inner" + name ] :
 
elem.document.documentElement[ "client" + name ];
 
}
 
 
// Get document width or height
 
if ( elem.nodeType === 9 ) {
 
doc = elem.documentElement;
 
 
// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
 
// whichever is greatest
 
return Math.max(
 
elem.body[ "scroll" + name ], doc[ "scroll" + name ],
 
elem.body[ "offset" + name ], doc[ "offset" + name ],
 
doc[ "client" + name ]
 
);
 
}
 
 
return value === undefined ?
 
 
// Get width or height on the element, requesting but not forcing parseFloat
 
jQuery.css( elem, type, extra ) :
 
 
// Set width or height on the element
 
jQuery.style( elem, type, value, extra );
 
}, type, chainable ? margin : undefined, chainable );
 
};
 
} );
 
} );
 
 
 
jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
 
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
 
"change select submit keydown keypress keyup contextmenu" ).split( " " ),
 
function( i, name ) {
 
 
// Handle event binding
 
jQuery.fn[ name ] = function( data, fn ) {
 
return arguments.length > 0 ?
 
this.on( name, null, data, fn ) :
 
this.trigger( name );
 
};
 
} );
 
 
jQuery.fn.extend( {
 
hover: function( fnOver, fnOut ) {
 
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
 
}
 
} );
 
 
 
 
 
jQuery.fn.extend( {
 
 
bind: function( types, data, fn ) {
 
return this.on( types, null, data, fn );
 
},
 
unbind: function( types, fn ) {
 
return this.off( types, null, fn );
 
},
 
 
delegate: function( selector, types, data, fn ) {
 
return this.on( types, selector, data, fn );
 
},
 
undelegate: function( selector, types, fn ) {
 
 
// ( namespace ) or ( selector, types [, fn] )
 
return arguments.length === 1 ?
 
this.off( selector, "**" ) :
 
this.off( types, selector || "**", fn );
 
}
 
} );
 
 
// Bind a function to a context, optionally partially applying any
 
// arguments.
 
// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
 
// However, it is not slated for removal any time soon
 
jQuery.proxy = function( fn, context ) {
 
var tmp, args, proxy;
 
 
if ( typeof context === "string" ) {
 
tmp = fn[ context ];
 
context = fn;
 
fn = tmp;
 
}
 
 
// Quick check to determine if target is callable, in the spec
 
// this throws a TypeError, but we will just return undefined.
 
if ( !isFunction( fn ) ) {
 
return undefined;
 
}
 
 
// Simulated bind
 
args = slice.call( arguments, 2 );
 
proxy = function() {
 
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
 
};
 
 
// Set the guid of unique handler to the same of original handler, so it can be removed
 
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
 
 
return proxy;
 
};
 
 
jQuery.holdReady = function( hold ) {
 
if ( hold ) {
 
jQuery.readyWait++;
 
} else {
 
jQuery.ready( true );
 
}
 
};
 
jQuery.isArray = Array.isArray;
 
jQuery.parseJSON = JSON.parse;
 
jQuery.nodeName = nodeName;
 
jQuery.isFunction = isFunction;
 
jQuery.isWindow = isWindow;
 
jQuery.camelCase = camelCase;
 
jQuery.type = toType;
 
 
jQuery.now = Date.now;
 
 
jQuery.isNumeric = function( obj ) {
 
 
// As of jQuery 3.0, isNumeric is limited to
 
// strings and numbers (primitives or objects)
 
// that can be coerced to finite numbers (gh-2662)
 
var type = jQuery.type( obj );
 
return ( type === "number" || type === "string" ) &&
 
 
// parseFloat NaNs numeric-cast false positives ("")
 
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
 
// subtraction forces infinities to NaN
 
!isNaN( obj - parseFloat( obj ) );
 
};
 
 
 
 
 
// Register as a named AMD module, since jQuery can be concatenated with other
 
// files that may use define, but not via a proper concatenation script that
 
// understands anonymous AMD modules. A named AMD is safest and most robust
 
// way to register. Lowercase jquery is used because AMD module names are
 
// derived from file names, and jQuery is normally delivered in a lowercase
 
// file name. Do this after creating the global so that if an AMD module wants
 
// to call noConflict to hide this version of jQuery, it will work.
 
 
// Note that for maximum portability, libraries that are not jQuery should
 
// declare themselves as anonymous modules, and avoid setting a global if an
 
// AMD loader is present. jQuery is a special case. For more information, see
 
// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
 
 
if ( typeof define === "function" && define.amd ) {
 
define( "jquery", [], function() {
 
return jQuery;
 
} );
 
}
 
 
 
 
 
var
 
 
// Map over jQuery in case of overwrite
 
_jQuery = window.jQuery,
 
 
// Map over the $ in case of overwrite
 
_$ = window.$;
 
 
jQuery.noConflict = function( deep ) {
 
if ( window.$ === jQuery ) {
 
window.$ = _$;
 
}
 
 
if ( deep && window.jQuery === jQuery ) {
 
window.jQuery = _jQuery;
 
}
 
 
return jQuery;
 
};
 
 
// Expose jQuery and $ identifiers, even in AMD
 
// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
 
// and CommonJS for browser emulators (#13566)
 
if ( !noGlobal ) {
 
window.jQuery = window.$ = jQuery;
 
}
 
 
 
 
 
return jQuery;
 
} );
 
</script>
 
</html>
 
 
{{Template:Toulouse-INSA-UPS/BS-JS}}
 
{{Template:Toulouse-INSA-UPS/BS-JS}}
 
{{Template:Toulouse-INSA-UPS/JQ-JS}}
 
{{Template:Toulouse-INSA-UPS/JQ-JS}}

Revision as of 14:15, 21 August 2018

/*!

* Bootstrap v4.1.3 (https://getbootstrap.com/)
* Copyright 2011-2018 The Bootstrap Authors
* Copyright 2011-2018 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
*/
root {
 --blue: #007bff;
 --indigo: #6610f2;
 --purple: #6f42c1;
 --pink: #e83e8c;
 --red: #dc3545;
 --orange: #fd7e14;
 --yellow: #ffc107;
 --green: #28a745;
 --teal: #20c997;
 --cyan: #17a2b8;
 --white: #fff;
 --gray: #6c757d;
 --gray-dark: #343a40;
 --primary: #007bff;
 --secondary: #6c757d;
 --success: #28a745;
 --info: #17a2b8;
 --warning: #ffc107;
 --danger: #dc3545;
 --light: #f8f9fa;
 --dark: #343a40;
 --breakpoint-xs: 0;
 --breakpoint-sm: 576px;
 --breakpoint-md: 768px;
 --breakpoint-lg: 992px;
 --breakpoint-xl: 1200px;
 --font-family-sans-serif: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
 --font-family-monospace: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;

}

  • ,
    before,
    after {
 box-sizing: border-box;

}

html {

 font-family: sans-serif;
 line-height: 1.15;
 -webkit-text-size-adjust: 100%;
 -ms-text-size-adjust: 100%;
 -ms-overflow-style: scrollbar;
 -webkit-tap-highlight-color: rgba(0, 0, 0, 0);

}

@-ms-viewport {

 width: device-width;

}

article, aside, figcaption, figure, footer, header, hgroup, main, nav, section {

 display: block;

}

body {

 margin: 0;
 font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
 font-size: 1rem;
 font-weight: 400;
 line-height: 1.5;
 color: #212529;
 text-align: left;
 background-color: #fff;

}

[tabindex="-1"]:focus {

 outline: 0 !important;

}

hr {

 box-sizing: content-box;
 height: 0;
 overflow: visible;

}

h1, h2, h3, h4, h5, h6 {

 margin-top: 0;
 margin-bottom: 0.5rem;

}

p {

 margin-top: 0;
 margin-bottom: 1rem;

}

abbr[title], abbr[data-original-title] {

 text-decoration: underline;
 -webkit-text-decoration: underline dotted;
 text-decoration: underline dotted;
 cursor: help;
 border-bottom: 0;

}

address {

 margin-bottom: 1rem;
 font-style: normal;
 line-height: inherit;

}

ol, ul, dl {

 margin-top: 0;
 margin-bottom: 1rem;

}

ol ol, ul ul, ol ul, ul ol {

 margin-bottom: 0;

}

dt {

 font-weight: 700;

}

dd {

 margin-bottom: .5rem;
 margin-left: 0;

}

blockquote {

 margin: 0 0 1rem;

}

dfn {

 font-style: italic;

}

b, strong {

 font-weight: bolder;

}

small {

 font-size: 80%;

}

sub, sup {

 position: relative;
 font-size: 75%;
 line-height: 0;
 vertical-align: baseline;

}

sub {

 bottom: -.25em;

}

sup {

 top: -.5em;

}

a {

 color: #007bff;
 text-decoration: none;
 background-color: transparent;
 -webkit-text-decoration-skip: objects;

}

a:hover {

 color: #0056b3;
 text-decoration: underline;

}

a:not([href]):not([tabindex]) {

 color: inherit;
 text-decoration: none;

}

a:not([href]):not([tabindex]):hover, a:not([href]):not([tabindex]):focus {

 color: inherit;
 text-decoration: none;

}

a:not([href]):not([tabindex]):focus {

 outline: 0;

}

pre, code, kbd, samp {

 font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
 font-size: 1em;

}

pre {

 margin-top: 0;
 margin-bottom: 1rem;
 overflow: auto;
 -ms-overflow-style: scrollbar;

}

figure {

 margin: 0 0 1rem;

}

img {

 vertical-align: middle;
 border-style: none;

}

svg {

 overflow: hidden;
 vertical-align: middle;

}

table {

 border-collapse: collapse;

}

caption {

 padding-top: 0.75rem;
 padding-bottom: 0.75rem;
 color: #6c757d;
 text-align: left;
 caption-side: bottom;

}

th {

 text-align: inherit;

}

label {

 display: inline-block;
 margin-bottom: 0.5rem;

}

button {

 border-radius: 0;

}

button:focus {

 outline: 1px dotted;
 outline: 5px auto -webkit-focus-ring-color;

}

input, button, select, optgroup, textarea {

 margin: 0;
 font-family: inherit;
 font-size: inherit;
 line-height: inherit;

}

button, input {

 overflow: visible;

}

button, select {

 text-transform: none;

}

button, html [type="button"], [type="reset"], [type="submit"] {

 -webkit-appearance: button;

}

button::-moz-focus-inner, [type="button"]::-moz-focus-inner, [type="reset"]::-moz-focus-inner, [type="submit"]::-moz-focus-inner {

 padding: 0;
 border-style: none;

}

input[type="radio"], input[type="checkbox"] {

 box-sizing: border-box;
 padding: 0;

}

input[type="date"], input[type="time"], input[type="datetime-local"], input[type="month"] {

 -webkit-appearance: listbox;

}

textarea {

 overflow: auto;
 resize: vertical;

}

fieldset {

 min-width: 0;
 padding: 0;
 margin: 0;
 border: 0;

}

legend {

 display: block;
 width: 100%;
 max-width: 100%;
 padding: 0;
 margin-bottom: .5rem;
 font-size: 1.5rem;
 line-height: inherit;
 color: inherit;
 white-space: normal;

}

progress {

 vertical-align: baseline;

}

[type="number"]::-webkit-inner-spin-button, [type="number"]::-webkit-outer-spin-button {

 height: auto;

}

[type="search"] {

 outline-offset: -2px;
 -webkit-appearance: none;

}

[type="search"]::-webkit-search-cancel-button, [type="search"]::-webkit-search-decoration {

 -webkit-appearance: none;

}

-webkit-file-upload-button {
 font: inherit;
 -webkit-appearance: button;

}

output {

 display: inline-block;

}

summary {

 display: list-item;
 cursor: pointer;

}

template {

 display: none;

}

[hidden] {

 display: none !important;

}

h1, h2, h3, h4, h5, h6, .h1, .h2, .h3, .h4, .h5, .h6 {

 margin-bottom: 0.5rem;
 font-family: inherit;
 font-weight: 500;
 line-height: 1.2;
 color: inherit;

}

h1, .h1 {

 font-size: 2.5rem;

}

h2, .h2 {

 font-size: 2rem;

}

h3, .h3 {

 font-size: 1.75rem;

}

h4, .h4 {

 font-size: 1.5rem;

}

h5, .h5 {

 font-size: 1.25rem;

}

h6, .h6 {

 font-size: 1rem;

}

.lead {

 font-size: 1.25rem;
 font-weight: 300;

}

.display-1 {

 font-size: 6rem;
 font-weight: 300;
 line-height: 1.2;

}

.display-2 {

 font-size: 5.5rem;
 font-weight: 300;
 line-height: 1.2;

}

.display-3 {

 font-size: 4.5rem;
 font-weight: 300;
 line-height: 1.2;

}

.display-4 {

 font-size: 3.5rem;
 font-weight: 300;
 line-height: 1.2;

}

hr {

 margin-top: 1rem;
 margin-bottom: 1rem;
 border: 0;
 border-top: 1px solid rgba(0, 0, 0, 0.1);

}

small, .small {

 font-size: 80%;
 font-weight: 400;

}

mark, .mark {

 padding: 0.2em;
 background-color: #fcf8e3;

}

.list-unstyled {

 padding-left: 0;
 list-style: none;

}

.list-inline {

 padding-left: 0;
 list-style: none;

}

.list-inline-item {

 display: inline-block;

}

.list-inline-item:not(:last-child) {

 margin-right: 0.5rem;

}

.initialism {

 font-size: 90%;
 text-transform: uppercase;

}

.blockquote {

 margin-bottom: 1rem;
 font-size: 1.25rem;

}

.blockquote-footer {

 display: block;
 font-size: 80%;
 color: #6c757d;

}

.blockquote-footer::before {

 content: "\2014 \00A0";

}

.img-fluid {

 max-width: 100%;
 height: auto;

}

.img-thumbnail {

 padding: 0.25rem;
 background-color: #fff;
 border: 1px solid #dee2e6;
 border-radius: 0.25rem;
 max-width: 100%;
 height: auto;

}

.figure {

 display: inline-block;

}

.figure-img {

 margin-bottom: 0.5rem;
 line-height: 1;

}

.figure-caption {

 font-size: 90%;
 color: #6c757d;

}

code {

 font-size: 87.5%;
 color: #e83e8c;
 word-break: break-word;

}

a > code {

 color: inherit;

}

kbd {

 padding: 0.2rem 0.4rem;
 font-size: 87.5%;
 color: #fff;
 background-color: #212529;
 border-radius: 0.2rem;

}

kbd kbd {

 padding: 0;
 font-size: 100%;
 font-weight: 700;

}

pre {

 display: block;
 font-size: 87.5%;
 color: #212529;

}

pre code {

 font-size: inherit;
 color: inherit;
 word-break: normal;

}

.pre-scrollable {

 max-height: 340px;
 overflow-y: scroll;

}

.container {

 width: 100%;
 padding-right: 15px;
 padding-left: 15px;
 margin-right: auto;
 margin-left: auto;

}

@media (min-width: 576px) {

 .container {
   max-width: 540px;
 }

}

@media (min-width: 768px) {

 .container {
   max-width: 720px;
 }

}

@media (min-width: 992px) {

 .container {
   max-width: 960px;
 }

}

@media (min-width: 1200px) {

 .container {
   max-width: 1140px;
 }

}

.container-fluid {

 width: 100%;
 padding-right: 15px;
 padding-left: 15px;
 margin-right: auto;
 margin-left: auto;

}

.row {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 margin-right: -15px;
 margin-left: -15px;

}

.no-gutters {

 margin-right: 0;
 margin-left: 0;

}

.no-gutters > .col, .no-gutters > [class*="col-"] {

 padding-right: 0;
 padding-left: 0;

}

.col-1, .col-2, .col-3, .col-4, .col-5, .col-6, .col-7, .col-8, .col-9, .col-10, .col-11, .col-12, .col, .col-auto, .col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12, .col-sm, .col-sm-auto, .col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12, .col-md, .col-md-auto, .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12, .col-lg, .col-lg-auto, .col-xl-1, .col-xl-2, .col-xl-3, .col-xl-4, .col-xl-5, .col-xl-6, .col-xl-7, .col-xl-8, .col-xl-9, .col-xl-10, .col-xl-11, .col-xl-12, .col-xl, .col-xl-auto {

 position: relative;
 width: 100%;
 min-height: 1px;
 padding-right: 15px;
 padding-left: 15px;

}

.col {

 -ms-flex-preferred-size: 0;
 flex-basis: 0;
 -ms-flex-positive: 1;
 flex-grow: 1;
 max-width: 100%;

}

.col-auto {

 -ms-flex: 0 0 auto;
 flex: 0 0 auto;
 width: auto;
 max-width: none;

}

.col-1 {

 -ms-flex: 0 0 8.333333%;
 flex: 0 0 8.333333%;
 max-width: 8.333333%;

}

.col-2 {

 -ms-flex: 0 0 16.666667%;
 flex: 0 0 16.666667%;
 max-width: 16.666667%;

}

.col-3 {

 -ms-flex: 0 0 25%;
 flex: 0 0 25%;
 max-width: 25%;

}

.col-4 {

 -ms-flex: 0 0 33.333333%;
 flex: 0 0 33.333333%;
 max-width: 33.333333%;

}

.col-5 {

 -ms-flex: 0 0 41.666667%;
 flex: 0 0 41.666667%;
 max-width: 41.666667%;

}

.col-6 {

 -ms-flex: 0 0 50%;
 flex: 0 0 50%;
 max-width: 50%;

}

.col-7 {

 -ms-flex: 0 0 58.333333%;
 flex: 0 0 58.333333%;
 max-width: 58.333333%;

}

.col-8 {

 -ms-flex: 0 0 66.666667%;
 flex: 0 0 66.666667%;
 max-width: 66.666667%;

}

.col-9 {

 -ms-flex: 0 0 75%;
 flex: 0 0 75%;
 max-width: 75%;

}

.col-10 {

 -ms-flex: 0 0 83.333333%;
 flex: 0 0 83.333333%;
 max-width: 83.333333%;

}

.col-11 {

 -ms-flex: 0 0 91.666667%;
 flex: 0 0 91.666667%;
 max-width: 91.666667%;

}

.col-12 {

 -ms-flex: 0 0 100%;
 flex: 0 0 100%;
 max-width: 100%;

}

.order-first {

 -ms-flex-order: -1;
 order: -1;

}

.order-last {

 -ms-flex-order: 13;
 order: 13;

}

.order-0 {

 -ms-flex-order: 0;
 order: 0;

}

.order-1 {

 -ms-flex-order: 1;
 order: 1;

}

.order-2 {

 -ms-flex-order: 2;
 order: 2;

}

.order-3 {

 -ms-flex-order: 3;
 order: 3;

}

.order-4 {

 -ms-flex-order: 4;
 order: 4;

}

.order-5 {

 -ms-flex-order: 5;
 order: 5;

}

.order-6 {

 -ms-flex-order: 6;
 order: 6;

}

.order-7 {

 -ms-flex-order: 7;
 order: 7;

}

.order-8 {

 -ms-flex-order: 8;
 order: 8;

}

.order-9 {

 -ms-flex-order: 9;
 order: 9;

}

.order-10 {

 -ms-flex-order: 10;
 order: 10;

}

.order-11 {

 -ms-flex-order: 11;
 order: 11;

}

.order-12 {

 -ms-flex-order: 12;
 order: 12;

}

.offset-1 {

 margin-left: 8.333333%;

}

.offset-2 {

 margin-left: 16.666667%;

}

.offset-3 {

 margin-left: 25%;

}

.offset-4 {

 margin-left: 33.333333%;

}

.offset-5 {

 margin-left: 41.666667%;

}

.offset-6 {

 margin-left: 50%;

}

.offset-7 {

 margin-left: 58.333333%;

}

.offset-8 {

 margin-left: 66.666667%;

}

.offset-9 {

 margin-left: 75%;

}

.offset-10 {

 margin-left: 83.333333%;

}

.offset-11 {

 margin-left: 91.666667%;

}

@media (min-width: 576px) {

 .col-sm {
   -ms-flex-preferred-size: 0;
   flex-basis: 0;
   -ms-flex-positive: 1;
   flex-grow: 1;
   max-width: 100%;
 }
 .col-sm-auto {
   -ms-flex: 0 0 auto;
   flex: 0 0 auto;
   width: auto;
   max-width: none;
 }
 .col-sm-1 {
   -ms-flex: 0 0 8.333333%;
   flex: 0 0 8.333333%;
   max-width: 8.333333%;
 }
 .col-sm-2 {
   -ms-flex: 0 0 16.666667%;
   flex: 0 0 16.666667%;
   max-width: 16.666667%;
 }
 .col-sm-3 {
   -ms-flex: 0 0 25%;
   flex: 0 0 25%;
   max-width: 25%;
 }
 .col-sm-4 {
   -ms-flex: 0 0 33.333333%;
   flex: 0 0 33.333333%;
   max-width: 33.333333%;
 }
 .col-sm-5 {
   -ms-flex: 0 0 41.666667%;
   flex: 0 0 41.666667%;
   max-width: 41.666667%;
 }
 .col-sm-6 {
   -ms-flex: 0 0 50%;
   flex: 0 0 50%;
   max-width: 50%;
 }
 .col-sm-7 {
   -ms-flex: 0 0 58.333333%;
   flex: 0 0 58.333333%;
   max-width: 58.333333%;
 }
 .col-sm-8 {
   -ms-flex: 0 0 66.666667%;
   flex: 0 0 66.666667%;
   max-width: 66.666667%;
 }
 .col-sm-9 {
   -ms-flex: 0 0 75%;
   flex: 0 0 75%;
   max-width: 75%;
 }
 .col-sm-10 {
   -ms-flex: 0 0 83.333333%;
   flex: 0 0 83.333333%;
   max-width: 83.333333%;
 }
 .col-sm-11 {
   -ms-flex: 0 0 91.666667%;
   flex: 0 0 91.666667%;
   max-width: 91.666667%;
 }
 .col-sm-12 {
   -ms-flex: 0 0 100%;
   flex: 0 0 100%;
   max-width: 100%;
 }
 .order-sm-first {
   -ms-flex-order: -1;
   order: -1;
 }
 .order-sm-last {
   -ms-flex-order: 13;
   order: 13;
 }
 .order-sm-0 {
   -ms-flex-order: 0;
   order: 0;
 }
 .order-sm-1 {
   -ms-flex-order: 1;
   order: 1;
 }
 .order-sm-2 {
   -ms-flex-order: 2;
   order: 2;
 }
 .order-sm-3 {
   -ms-flex-order: 3;
   order: 3;
 }
 .order-sm-4 {
   -ms-flex-order: 4;
   order: 4;
 }
 .order-sm-5 {
   -ms-flex-order: 5;
   order: 5;
 }
 .order-sm-6 {
   -ms-flex-order: 6;
   order: 6;
 }
 .order-sm-7 {
   -ms-flex-order: 7;
   order: 7;
 }
 .order-sm-8 {
   -ms-flex-order: 8;
   order: 8;
 }
 .order-sm-9 {
   -ms-flex-order: 9;
   order: 9;
 }
 .order-sm-10 {
   -ms-flex-order: 10;
   order: 10;
 }
 .order-sm-11 {
   -ms-flex-order: 11;
   order: 11;
 }
 .order-sm-12 {
   -ms-flex-order: 12;
   order: 12;
 }
 .offset-sm-0 {
   margin-left: 0;
 }
 .offset-sm-1 {
   margin-left: 8.333333%;
 }
 .offset-sm-2 {
   margin-left: 16.666667%;
 }
 .offset-sm-3 {
   margin-left: 25%;
 }
 .offset-sm-4 {
   margin-left: 33.333333%;
 }
 .offset-sm-5 {
   margin-left: 41.666667%;
 }
 .offset-sm-6 {
   margin-left: 50%;
 }
 .offset-sm-7 {
   margin-left: 58.333333%;
 }
 .offset-sm-8 {
   margin-left: 66.666667%;
 }
 .offset-sm-9 {
   margin-left: 75%;
 }
 .offset-sm-10 {
   margin-left: 83.333333%;
 }
 .offset-sm-11 {
   margin-left: 91.666667%;
 }

}

@media (min-width: 768px) {

 .col-md {
   -ms-flex-preferred-size: 0;
   flex-basis: 0;
   -ms-flex-positive: 1;
   flex-grow: 1;
   max-width: 100%;
 }
 .col-md-auto {
   -ms-flex: 0 0 auto;
   flex: 0 0 auto;
   width: auto;
   max-width: none;
 }
 .col-md-1 {
   -ms-flex: 0 0 8.333333%;
   flex: 0 0 8.333333%;
   max-width: 8.333333%;
 }
 .col-md-2 {
   -ms-flex: 0 0 16.666667%;
   flex: 0 0 16.666667%;
   max-width: 16.666667%;
 }
 .col-md-3 {
   -ms-flex: 0 0 25%;
   flex: 0 0 25%;
   max-width: 25%;
 }
 .col-md-4 {
   -ms-flex: 0 0 33.333333%;
   flex: 0 0 33.333333%;
   max-width: 33.333333%;
 }
 .col-md-5 {
   -ms-flex: 0 0 41.666667%;
   flex: 0 0 41.666667%;
   max-width: 41.666667%;
 }
 .col-md-6 {
   -ms-flex: 0 0 50%;
   flex: 0 0 50%;
   max-width: 50%;
 }
 .col-md-7 {
   -ms-flex: 0 0 58.333333%;
   flex: 0 0 58.333333%;
   max-width: 58.333333%;
 }
 .col-md-8 {
   -ms-flex: 0 0 66.666667%;
   flex: 0 0 66.666667%;
   max-width: 66.666667%;
 }
 .col-md-9 {
   -ms-flex: 0 0 75%;
   flex: 0 0 75%;
   max-width: 75%;
 }
 .col-md-10 {
   -ms-flex: 0 0 83.333333%;
   flex: 0 0 83.333333%;
   max-width: 83.333333%;
 }
 .col-md-11 {
   -ms-flex: 0 0 91.666667%;
   flex: 0 0 91.666667%;
   max-width: 91.666667%;
 }
 .col-md-12 {
   -ms-flex: 0 0 100%;
   flex: 0 0 100%;
   max-width: 100%;
 }
 .order-md-first {
   -ms-flex-order: -1;
   order: -1;
 }
 .order-md-last {
   -ms-flex-order: 13;
   order: 13;
 }
 .order-md-0 {
   -ms-flex-order: 0;
   order: 0;
 }
 .order-md-1 {
   -ms-flex-order: 1;
   order: 1;
 }
 .order-md-2 {
   -ms-flex-order: 2;
   order: 2;
 }
 .order-md-3 {
   -ms-flex-order: 3;
   order: 3;
 }
 .order-md-4 {
   -ms-flex-order: 4;
   order: 4;
 }
 .order-md-5 {
   -ms-flex-order: 5;
   order: 5;
 }
 .order-md-6 {
   -ms-flex-order: 6;
   order: 6;
 }
 .order-md-7 {
   -ms-flex-order: 7;
   order: 7;
 }
 .order-md-8 {
   -ms-flex-order: 8;
   order: 8;
 }
 .order-md-9 {
   -ms-flex-order: 9;
   order: 9;
 }
 .order-md-10 {
   -ms-flex-order: 10;
   order: 10;
 }
 .order-md-11 {
   -ms-flex-order: 11;
   order: 11;
 }
 .order-md-12 {
   -ms-flex-order: 12;
   order: 12;
 }
 .offset-md-0 {
   margin-left: 0;
 }
 .offset-md-1 {
   margin-left: 8.333333%;
 }
 .offset-md-2 {
   margin-left: 16.666667%;
 }
 .offset-md-3 {
   margin-left: 25%;
 }
 .offset-md-4 {
   margin-left: 33.333333%;
 }
 .offset-md-5 {
   margin-left: 41.666667%;
 }
 .offset-md-6 {
   margin-left: 50%;
 }
 .offset-md-7 {
   margin-left: 58.333333%;
 }
 .offset-md-8 {
   margin-left: 66.666667%;
 }
 .offset-md-9 {
   margin-left: 75%;
 }
 .offset-md-10 {
   margin-left: 83.333333%;
 }
 .offset-md-11 {
   margin-left: 91.666667%;
 }

}

@media (min-width: 992px) {

 .col-lg {
   -ms-flex-preferred-size: 0;
   flex-basis: 0;
   -ms-flex-positive: 1;
   flex-grow: 1;
   max-width: 100%;
 }
 .col-lg-auto {
   -ms-flex: 0 0 auto;
   flex: 0 0 auto;
   width: auto;
   max-width: none;
 }
 .col-lg-1 {
   -ms-flex: 0 0 8.333333%;
   flex: 0 0 8.333333%;
   max-width: 8.333333%;
 }
 .col-lg-2 {
   -ms-flex: 0 0 16.666667%;
   flex: 0 0 16.666667%;
   max-width: 16.666667%;
 }
 .col-lg-3 {
   -ms-flex: 0 0 25%;
   flex: 0 0 25%;
   max-width: 25%;
 }
 .col-lg-4 {
   -ms-flex: 0 0 33.333333%;
   flex: 0 0 33.333333%;
   max-width: 33.333333%;
 }
 .col-lg-5 {
   -ms-flex: 0 0 41.666667%;
   flex: 0 0 41.666667%;
   max-width: 41.666667%;
 }
 .col-lg-6 {
   -ms-flex: 0 0 50%;
   flex: 0 0 50%;
   max-width: 50%;
 }
 .col-lg-7 {
   -ms-flex: 0 0 58.333333%;
   flex: 0 0 58.333333%;
   max-width: 58.333333%;
 }
 .col-lg-8 {
   -ms-flex: 0 0 66.666667%;
   flex: 0 0 66.666667%;
   max-width: 66.666667%;
 }
 .col-lg-9 {
   -ms-flex: 0 0 75%;
   flex: 0 0 75%;
   max-width: 75%;
 }
 .col-lg-10 {
   -ms-flex: 0 0 83.333333%;
   flex: 0 0 83.333333%;
   max-width: 83.333333%;
 }
 .col-lg-11 {
   -ms-flex: 0 0 91.666667%;
   flex: 0 0 91.666667%;
   max-width: 91.666667%;
 }
 .col-lg-12 {
   -ms-flex: 0 0 100%;
   flex: 0 0 100%;
   max-width: 100%;
 }
 .order-lg-first {
   -ms-flex-order: -1;
   order: -1;
 }
 .order-lg-last {
   -ms-flex-order: 13;
   order: 13;
 }
 .order-lg-0 {
   -ms-flex-order: 0;
   order: 0;
 }
 .order-lg-1 {
   -ms-flex-order: 1;
   order: 1;
 }
 .order-lg-2 {
   -ms-flex-order: 2;
   order: 2;
 }
 .order-lg-3 {
   -ms-flex-order: 3;
   order: 3;
 }
 .order-lg-4 {
   -ms-flex-order: 4;
   order: 4;
 }
 .order-lg-5 {
   -ms-flex-order: 5;
   order: 5;
 }
 .order-lg-6 {
   -ms-flex-order: 6;
   order: 6;
 }
 .order-lg-7 {
   -ms-flex-order: 7;
   order: 7;
 }
 .order-lg-8 {
   -ms-flex-order: 8;
   order: 8;
 }
 .order-lg-9 {
   -ms-flex-order: 9;
   order: 9;
 }
 .order-lg-10 {
   -ms-flex-order: 10;
   order: 10;
 }
 .order-lg-11 {
   -ms-flex-order: 11;
   order: 11;
 }
 .order-lg-12 {
   -ms-flex-order: 12;
   order: 12;
 }
 .offset-lg-0 {
   margin-left: 0;
 }
 .offset-lg-1 {
   margin-left: 8.333333%;
 }
 .offset-lg-2 {
   margin-left: 16.666667%;
 }
 .offset-lg-3 {
   margin-left: 25%;
 }
 .offset-lg-4 {
   margin-left: 33.333333%;
 }
 .offset-lg-5 {
   margin-left: 41.666667%;
 }
 .offset-lg-6 {
   margin-left: 50%;
 }
 .offset-lg-7 {
   margin-left: 58.333333%;
 }
 .offset-lg-8 {
   margin-left: 66.666667%;
 }
 .offset-lg-9 {
   margin-left: 75%;
 }
 .offset-lg-10 {
   margin-left: 83.333333%;
 }
 .offset-lg-11 {
   margin-left: 91.666667%;
 }

}

@media (min-width: 1200px) {

 .col-xl {
   -ms-flex-preferred-size: 0;
   flex-basis: 0;
   -ms-flex-positive: 1;
   flex-grow: 1;
   max-width: 100%;
 }
 .col-xl-auto {
   -ms-flex: 0 0 auto;
   flex: 0 0 auto;
   width: auto;
   max-width: none;
 }
 .col-xl-1 {
   -ms-flex: 0 0 8.333333%;
   flex: 0 0 8.333333%;
   max-width: 8.333333%;
 }
 .col-xl-2 {
   -ms-flex: 0 0 16.666667%;
   flex: 0 0 16.666667%;
   max-width: 16.666667%;
 }
 .col-xl-3 {
   -ms-flex: 0 0 25%;
   flex: 0 0 25%;
   max-width: 25%;
 }
 .col-xl-4 {
   -ms-flex: 0 0 33.333333%;
   flex: 0 0 33.333333%;
   max-width: 33.333333%;
 }
 .col-xl-5 {
   -ms-flex: 0 0 41.666667%;
   flex: 0 0 41.666667%;
   max-width: 41.666667%;
 }
 .col-xl-6 {
   -ms-flex: 0 0 50%;
   flex: 0 0 50%;
   max-width: 50%;
 }
 .col-xl-7 {
   -ms-flex: 0 0 58.333333%;
   flex: 0 0 58.333333%;
   max-width: 58.333333%;
 }
 .col-xl-8 {
   -ms-flex: 0 0 66.666667%;
   flex: 0 0 66.666667%;
   max-width: 66.666667%;
 }
 .col-xl-9 {
   -ms-flex: 0 0 75%;
   flex: 0 0 75%;
   max-width: 75%;
 }
 .col-xl-10 {
   -ms-flex: 0 0 83.333333%;
   flex: 0 0 83.333333%;
   max-width: 83.333333%;
 }
 .col-xl-11 {
   -ms-flex: 0 0 91.666667%;
   flex: 0 0 91.666667%;
   max-width: 91.666667%;
 }
 .col-xl-12 {
   -ms-flex: 0 0 100%;
   flex: 0 0 100%;
   max-width: 100%;
 }
 .order-xl-first {
   -ms-flex-order: -1;
   order: -1;
 }
 .order-xl-last {
   -ms-flex-order: 13;
   order: 13;
 }
 .order-xl-0 {
   -ms-flex-order: 0;
   order: 0;
 }
 .order-xl-1 {
   -ms-flex-order: 1;
   order: 1;
 }
 .order-xl-2 {
   -ms-flex-order: 2;
   order: 2;
 }
 .order-xl-3 {
   -ms-flex-order: 3;
   order: 3;
 }
 .order-xl-4 {
   -ms-flex-order: 4;
   order: 4;
 }
 .order-xl-5 {
   -ms-flex-order: 5;
   order: 5;
 }
 .order-xl-6 {
   -ms-flex-order: 6;
   order: 6;
 }
 .order-xl-7 {
   -ms-flex-order: 7;
   order: 7;
 }
 .order-xl-8 {
   -ms-flex-order: 8;
   order: 8;
 }
 .order-xl-9 {
   -ms-flex-order: 9;
   order: 9;
 }
 .order-xl-10 {
   -ms-flex-order: 10;
   order: 10;
 }
 .order-xl-11 {
   -ms-flex-order: 11;
   order: 11;
 }
 .order-xl-12 {
   -ms-flex-order: 12;
   order: 12;
 }
 .offset-xl-0 {
   margin-left: 0;
 }
 .offset-xl-1 {
   margin-left: 8.333333%;
 }
 .offset-xl-2 {
   margin-left: 16.666667%;
 }
 .offset-xl-3 {
   margin-left: 25%;
 }
 .offset-xl-4 {
   margin-left: 33.333333%;
 }
 .offset-xl-5 {
   margin-left: 41.666667%;
 }
 .offset-xl-6 {
   margin-left: 50%;
 }
 .offset-xl-7 {
   margin-left: 58.333333%;
 }
 .offset-xl-8 {
   margin-left: 66.666667%;
 }
 .offset-xl-9 {
   margin-left: 75%;
 }
 .offset-xl-10 {
   margin-left: 83.333333%;
 }
 .offset-xl-11 {
   margin-left: 91.666667%;
 }

}

.table {

 width: 100%;
 margin-bottom: 1rem;
 background-color: transparent;

}

.table th, .table td {

 padding: 0.75rem;
 vertical-align: top;
 border-top: 1px solid #dee2e6;

}

.table thead th {

 vertical-align: bottom;
 border-bottom: 2px solid #dee2e6;

}

.table tbody + tbody {

 border-top: 2px solid #dee2e6;

}

.table .table {

 background-color: #fff;

}

.table-sm th, .table-sm td {

 padding: 0.3rem;

}

.table-bordered {

 border: 1px solid #dee2e6;

}

.table-bordered th, .table-bordered td {

 border: 1px solid #dee2e6;

}

.table-bordered thead th, .table-bordered thead td {

 border-bottom-width: 2px;

}

.table-borderless th, .table-borderless td, .table-borderless thead th, .table-borderless tbody + tbody {

 border: 0;

}

.table-striped tbody tr:nth-of-type(odd) {

 background-color: rgba(0, 0, 0, 0.05);

}

.table-hover tbody tr:hover {

 background-color: rgba(0, 0, 0, 0.075);

}

.table-primary, .table-primary > th, .table-primary > td {

 background-color: #b8daff;

}

.table-hover .table-primary:hover {

 background-color: #9fcdff;

}

.table-hover .table-primary:hover > td, .table-hover .table-primary:hover > th {

 background-color: #9fcdff;

}

.table-secondary, .table-secondary > th, .table-secondary > td {

 background-color: #d6d8db;

}

.table-hover .table-secondary:hover {

 background-color: #c8cbcf;

}

.table-hover .table-secondary:hover > td, .table-hover .table-secondary:hover > th {

 background-color: #c8cbcf;

}

.table-success, .table-success > th, .table-success > td {

 background-color: #c3e6cb;

}

.table-hover .table-success:hover {

 background-color: #b1dfbb;

}

.table-hover .table-success:hover > td, .table-hover .table-success:hover > th {

 background-color: #b1dfbb;

}

.table-info, .table-info > th, .table-info > td {

 background-color: #bee5eb;

}

.table-hover .table-info:hover {

 background-color: #abdde5;

}

.table-hover .table-info:hover > td, .table-hover .table-info:hover > th {

 background-color: #abdde5;

}

.table-warning, .table-warning > th, .table-warning > td {

 background-color: #ffeeba;

}

.table-hover .table-warning:hover {

 background-color: #ffe8a1;

}

.table-hover .table-warning:hover > td, .table-hover .table-warning:hover > th {

 background-color: #ffe8a1;

}

.table-danger, .table-danger > th, .table-danger > td {

 background-color: #f5c6cb;

}

.table-hover .table-danger:hover {

 background-color: #f1b0b7;

}

.table-hover .table-danger:hover > td, .table-hover .table-danger:hover > th {

 background-color: #f1b0b7;

}

.table-light, .table-light > th, .table-light > td {

 background-color: #fdfdfe;

}

.table-hover .table-light:hover {

 background-color: #ececf6;

}

.table-hover .table-light:hover > td, .table-hover .table-light:hover > th {

 background-color: #ececf6;

}

.table-dark, .table-dark > th, .table-dark > td {

 background-color: #c6c8ca;

}

.table-hover .table-dark:hover {

 background-color: #b9bbbe;

}

.table-hover .table-dark:hover > td, .table-hover .table-dark:hover > th {

 background-color: #b9bbbe;

}

.table-active, .table-active > th, .table-active > td {

 background-color: rgba(0, 0, 0, 0.075);

}

.table-hover .table-active:hover {

 background-color: rgba(0, 0, 0, 0.075);

}

.table-hover .table-active:hover > td, .table-hover .table-active:hover > th {

 background-color: rgba(0, 0, 0, 0.075);

}

.table .thead-dark th {

 color: #fff;
 background-color: #212529;
 border-color: #32383e;

}

.table .thead-light th {

 color: #495057;
 background-color: #e9ecef;
 border-color: #dee2e6;

}

.table-dark {

 color: #fff;
 background-color: #212529;

}

.table-dark th, .table-dark td, .table-dark thead th {

 border-color: #32383e;

}

.table-dark.table-bordered {

 border: 0;

}

.table-dark.table-striped tbody tr:nth-of-type(odd) {

 background-color: rgba(255, 255, 255, 0.05);

}

.table-dark.table-hover tbody tr:hover {

 background-color: rgba(255, 255, 255, 0.075);

}

@media (max-width: 575.98px) {

 .table-responsive-sm {
   display: block;
   width: 100%;
   overflow-x: auto;
   -webkit-overflow-scrolling: touch;
   -ms-overflow-style: -ms-autohiding-scrollbar;
 }
 .table-responsive-sm > .table-bordered {
   border: 0;
 }

}

@media (max-width: 767.98px) {

 .table-responsive-md {
   display: block;
   width: 100%;
   overflow-x: auto;
   -webkit-overflow-scrolling: touch;
   -ms-overflow-style: -ms-autohiding-scrollbar;
 }
 .table-responsive-md > .table-bordered {
   border: 0;
 }

}

@media (max-width: 991.98px) {

 .table-responsive-lg {
   display: block;
   width: 100%;
   overflow-x: auto;
   -webkit-overflow-scrolling: touch;
   -ms-overflow-style: -ms-autohiding-scrollbar;
 }
 .table-responsive-lg > .table-bordered {
   border: 0;
 }

}

@media (max-width: 1199.98px) {

 .table-responsive-xl {
   display: block;
   width: 100%;
   overflow-x: auto;
   -webkit-overflow-scrolling: touch;
   -ms-overflow-style: -ms-autohiding-scrollbar;
 }
 .table-responsive-xl > .table-bordered {
   border: 0;
 }

}

.table-responsive {

 display: block;
 width: 100%;
 overflow-x: auto;
 -webkit-overflow-scrolling: touch;
 -ms-overflow-style: -ms-autohiding-scrollbar;

}

.table-responsive > .table-bordered {

 border: 0;

}

.form-control {

 display: block;
 width: 100%;
 height: calc(2.25rem + 2px);
 padding: 0.375rem 0.75rem;
 font-size: 1rem;
 line-height: 1.5;
 color: #495057;
 background-color: #fff;
 background-clip: padding-box;
 border: 1px solid #ced4da;
 border-radius: 0.25rem;
 transition: border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;

}

@media screen and (prefers-reduced-motion: reduce) {

 .form-control {
   transition: none;
 }

}

.form-control::-ms-expand {

 background-color: transparent;
 border: 0;

}

.form-control:focus {

 color: #495057;
 background-color: #fff;
 border-color: #80bdff;
 outline: 0;
 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.form-control::-webkit-input-placeholder {

 color: #6c757d;
 opacity: 1;

}

.form-control::-moz-placeholder {

 color: #6c757d;
 opacity: 1;

}

.form-control:-ms-input-placeholder {

 color: #6c757d;
 opacity: 1;

}

.form-control::-ms-input-placeholder {

 color: #6c757d;
 opacity: 1;

}

.form-control::placeholder {

 color: #6c757d;
 opacity: 1;

}

.form-control:disabled, .form-control[readonly] {

 background-color: #e9ecef;
 opacity: 1;

}

select.form-control:focus::-ms-value {

 color: #495057;
 background-color: #fff;

}

.form-control-file, .form-control-range {

 display: block;
 width: 100%;

}

.col-form-label {

 padding-top: calc(0.375rem + 1px);
 padding-bottom: calc(0.375rem + 1px);
 margin-bottom: 0;
 font-size: inherit;
 line-height: 1.5;

}

.col-form-label-lg {

 padding-top: calc(0.5rem + 1px);
 padding-bottom: calc(0.5rem + 1px);
 font-size: 1.25rem;
 line-height: 1.5;

}

.col-form-label-sm {

 padding-top: calc(0.25rem + 1px);
 padding-bottom: calc(0.25rem + 1px);
 font-size: 0.875rem;
 line-height: 1.5;

}

.form-control-plaintext {

 display: block;
 width: 100%;
 padding-top: 0.375rem;
 padding-bottom: 0.375rem;
 margin-bottom: 0;
 line-height: 1.5;
 color: #212529;
 background-color: transparent;
 border: solid transparent;
 border-width: 1px 0;

}

.form-control-plaintext.form-control-sm, .form-control-plaintext.form-control-lg {

 padding-right: 0;
 padding-left: 0;

}

.form-control-sm {

 height: calc(1.8125rem + 2px);
 padding: 0.25rem 0.5rem;
 font-size: 0.875rem;
 line-height: 1.5;
 border-radius: 0.2rem;

}

.form-control-lg {

 height: calc(2.875rem + 2px);
 padding: 0.5rem 1rem;
 font-size: 1.25rem;
 line-height: 1.5;
 border-radius: 0.3rem;

}

select.form-control[size], select.form-control[multiple] {

 height: auto;

}

textarea.form-control {

 height: auto;

}

.form-group {

 margin-bottom: 1rem;

}

.form-text {

 display: block;
 margin-top: 0.25rem;

}

.form-row {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 margin-right: -5px;
 margin-left: -5px;

}

.form-row > .col, .form-row > [class*="col-"] {

 padding-right: 5px;
 padding-left: 5px;

}

.form-check {

 position: relative;
 display: block;
 padding-left: 1.25rem;

}

.form-check-input {

 position: absolute;
 margin-top: 0.3rem;
 margin-left: -1.25rem;

}

.form-check-input:disabled ~ .form-check-label {

 color: #6c757d;

}

.form-check-label {

 margin-bottom: 0;

}

.form-check-inline {

 display: -ms-inline-flexbox;
 display: inline-flex;
 -ms-flex-align: center;
 align-items: center;
 padding-left: 0;
 margin-right: 0.75rem;

}

.form-check-inline .form-check-input {

 position: static;
 margin-top: 0;
 margin-right: 0.3125rem;
 margin-left: 0;

}

.valid-feedback {

 display: none;
 width: 100%;
 margin-top: 0.25rem;
 font-size: 80%;
 color: #28a745;

}

.valid-tooltip {

 position: absolute;
 top: 100%;
 z-index: 5;
 display: none;
 max-width: 100%;
 padding: 0.25rem 0.5rem;
 margin-top: .1rem;
 font-size: 0.875rem;
 line-height: 1.5;
 color: #fff;
 background-color: rgba(40, 167, 69, 0.9);
 border-radius: 0.25rem;

}

.was-validated .form-control:valid, .form-control.is-valid, .was-validated .custom-select:valid, .custom-select.is-valid {

 border-color: #28a745;

}

.was-validated .form-control:valid:focus, .form-control.is-valid:focus, .was-validated .custom-select:valid:focus, .custom-select.is-valid:focus {

 border-color: #28a745;
 box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25);

}

.was-validated .form-control:valid ~ .valid-feedback, .was-validated .form-control:valid ~ .valid-tooltip, .form-control.is-valid ~ .valid-feedback, .form-control.is-valid ~ .valid-tooltip, .was-validated .custom-select:valid ~ .valid-feedback, .was-validated .custom-select:valid ~ .valid-tooltip, .custom-select.is-valid ~ .valid-feedback, .custom-select.is-valid ~ .valid-tooltip {

 display: block;

}

.was-validated .form-control-file:valid ~ .valid-feedback, .was-validated .form-control-file:valid ~ .valid-tooltip, .form-control-file.is-valid ~ .valid-feedback, .form-control-file.is-valid ~ .valid-tooltip {

 display: block;

}

.was-validated .form-check-input:valid ~ .form-check-label, .form-check-input.is-valid ~ .form-check-label {

 color: #28a745;

}

.was-validated .form-check-input:valid ~ .valid-feedback, .was-validated .form-check-input:valid ~ .valid-tooltip, .form-check-input.is-valid ~ .valid-feedback, .form-check-input.is-valid ~ .valid-tooltip {

 display: block;

}

.was-validated .custom-control-input:valid ~ .custom-control-label, .custom-control-input.is-valid ~ .custom-control-label {

 color: #28a745;

}

.was-validated .custom-control-input:valid ~ .custom-control-label::before, .custom-control-input.is-valid ~ .custom-control-label::before {

 background-color: #71dd8a;

}

.was-validated .custom-control-input:valid ~ .valid-feedback, .was-validated .custom-control-input:valid ~ .valid-tooltip, .custom-control-input.is-valid ~ .valid-feedback, .custom-control-input.is-valid ~ .valid-tooltip {

 display: block;

}

.was-validated .custom-control-input:valid:checked ~ .custom-control-label::before, .custom-control-input.is-valid:checked ~ .custom-control-label::before {

 background-color: #34ce57;

}

.was-validated .custom-control-input:valid:focus ~ .custom-control-label::before, .custom-control-input.is-valid:focus ~ .custom-control-label::before {

 box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(40, 167, 69, 0.25);

}

.was-validated .custom-file-input:valid ~ .custom-file-label, .custom-file-input.is-valid ~ .custom-file-label {

 border-color: #28a745;

}

.was-validated .custom-file-input:valid ~ .custom-file-label::after, .custom-file-input.is-valid ~ .custom-file-label::after {

 border-color: inherit;

}

.was-validated .custom-file-input:valid ~ .valid-feedback, .was-validated .custom-file-input:valid ~ .valid-tooltip, .custom-file-input.is-valid ~ .valid-feedback, .custom-file-input.is-valid ~ .valid-tooltip {

 display: block;

}

.was-validated .custom-file-input:valid:focus ~ .custom-file-label, .custom-file-input.is-valid:focus ~ .custom-file-label {

 box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25);

}

.invalid-feedback {

 display: none;
 width: 100%;
 margin-top: 0.25rem;
 font-size: 80%;
 color: #dc3545;

}

.invalid-tooltip {

 position: absolute;
 top: 100%;
 z-index: 5;
 display: none;
 max-width: 100%;
 padding: 0.25rem 0.5rem;
 margin-top: .1rem;
 font-size: 0.875rem;
 line-height: 1.5;
 color: #fff;
 background-color: rgba(220, 53, 69, 0.9);
 border-radius: 0.25rem;

}

.was-validated .form-control:invalid, .form-control.is-invalid, .was-validated .custom-select:invalid, .custom-select.is-invalid {

 border-color: #dc3545;

}

.was-validated .form-control:invalid:focus, .form-control.is-invalid:focus, .was-validated .custom-select:invalid:focus, .custom-select.is-invalid:focus {

 border-color: #dc3545;
 box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25);

}

.was-validated .form-control:invalid ~ .invalid-feedback, .was-validated .form-control:invalid ~ .invalid-tooltip, .form-control.is-invalid ~ .invalid-feedback, .form-control.is-invalid ~ .invalid-tooltip, .was-validated .custom-select:invalid ~ .invalid-feedback, .was-validated .custom-select:invalid ~ .invalid-tooltip, .custom-select.is-invalid ~ .invalid-feedback, .custom-select.is-invalid ~ .invalid-tooltip {

 display: block;

}

.was-validated .form-control-file:invalid ~ .invalid-feedback, .was-validated .form-control-file:invalid ~ .invalid-tooltip, .form-control-file.is-invalid ~ .invalid-feedback, .form-control-file.is-invalid ~ .invalid-tooltip {

 display: block;

}

.was-validated .form-check-input:invalid ~ .form-check-label, .form-check-input.is-invalid ~ .form-check-label {

 color: #dc3545;

}

.was-validated .form-check-input:invalid ~ .invalid-feedback, .was-validated .form-check-input:invalid ~ .invalid-tooltip, .form-check-input.is-invalid ~ .invalid-feedback, .form-check-input.is-invalid ~ .invalid-tooltip {

 display: block;

}

.was-validated .custom-control-input:invalid ~ .custom-control-label, .custom-control-input.is-invalid ~ .custom-control-label {

 color: #dc3545;

}

.was-validated .custom-control-input:invalid ~ .custom-control-label::before, .custom-control-input.is-invalid ~ .custom-control-label::before {

 background-color: #efa2a9;

}

.was-validated .custom-control-input:invalid ~ .invalid-feedback, .was-validated .custom-control-input:invalid ~ .invalid-tooltip, .custom-control-input.is-invalid ~ .invalid-feedback, .custom-control-input.is-invalid ~ .invalid-tooltip {

 display: block;

}

.was-validated .custom-control-input:invalid:checked ~ .custom-control-label::before, .custom-control-input.is-invalid:checked ~ .custom-control-label::before {

 background-color: #e4606d;

}

.was-validated .custom-control-input:invalid:focus ~ .custom-control-label::before, .custom-control-input.is-invalid:focus ~ .custom-control-label::before {

 box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(220, 53, 69, 0.25);

}

.was-validated .custom-file-input:invalid ~ .custom-file-label, .custom-file-input.is-invalid ~ .custom-file-label {

 border-color: #dc3545;

}

.was-validated .custom-file-input:invalid ~ .custom-file-label::after, .custom-file-input.is-invalid ~ .custom-file-label::after {

 border-color: inherit;

}

.was-validated .custom-file-input:invalid ~ .invalid-feedback, .was-validated .custom-file-input:invalid ~ .invalid-tooltip, .custom-file-input.is-invalid ~ .invalid-feedback, .custom-file-input.is-invalid ~ .invalid-tooltip {

 display: block;

}

.was-validated .custom-file-input:invalid:focus ~ .custom-file-label, .custom-file-input.is-invalid:focus ~ .custom-file-label {

 box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25);

}

.form-inline {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-flow: row wrap;
 flex-flow: row wrap;
 -ms-flex-align: center;
 align-items: center;

}

.form-inline .form-check {

 width: 100%;

}

@media (min-width: 576px) {

 .form-inline label {
   display: -ms-flexbox;
   display: flex;
   -ms-flex-align: center;
   align-items: center;
   -ms-flex-pack: center;
   justify-content: center;
   margin-bottom: 0;
 }
 .form-inline .form-group {
   display: -ms-flexbox;
   display: flex;
   -ms-flex: 0 0 auto;
   flex: 0 0 auto;
   -ms-flex-flow: row wrap;
   flex-flow: row wrap;
   -ms-flex-align: center;
   align-items: center;
   margin-bottom: 0;
 }
 .form-inline .form-control {
   display: inline-block;
   width: auto;
   vertical-align: middle;
 }
 .form-inline .form-control-plaintext {
   display: inline-block;
 }
 .form-inline .input-group,
 .form-inline .custom-select {
   width: auto;
 }
 .form-inline .form-check {
   display: -ms-flexbox;
   display: flex;
   -ms-flex-align: center;
   align-items: center;
   -ms-flex-pack: center;
   justify-content: center;
   width: auto;
   padding-left: 0;
 }
 .form-inline .form-check-input {
   position: relative;
   margin-top: 0;
   margin-right: 0.25rem;
   margin-left: 0;
 }
 .form-inline .custom-control {
   -ms-flex-align: center;
   align-items: center;
   -ms-flex-pack: center;
   justify-content: center;
 }
 .form-inline .custom-control-label {
   margin-bottom: 0;
 }

}

.btn {

 display: inline-block;
 font-weight: 400;
 text-align: center;
 white-space: nowrap;
 vertical-align: middle;
 -webkit-user-select: none;
 -moz-user-select: none;
 -ms-user-select: none;
 user-select: none;
 border: 1px solid transparent;
 padding: 0.375rem 0.75rem;
 font-size: 1rem;
 line-height: 1.5;
 border-radius: 0.25rem;
 transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;

}

@media screen and (prefers-reduced-motion: reduce) {

 .btn {
   transition: none;
 }

}

.btn:hover, .btn:focus {

 text-decoration: none;

}

.btn:focus, .btn.focus {

 outline: 0;
 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.btn.disabled, .btn:disabled {

 opacity: 0.65;

}

.btn:not(:disabled):not(.disabled) {

 cursor: pointer;

}

a.btn.disabled, fieldset:disabled a.btn {

 pointer-events: none;

}

.btn-primary {

 color: #fff;
 background-color: #007bff;
 border-color: #007bff;

}

.btn-primary:hover {

 color: #fff;
 background-color: #0069d9;
 border-color: #0062cc;

}

.btn-primary:focus, .btn-primary.focus {

 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5);

}

.btn-primary.disabled, .btn-primary:disabled {

 color: #fff;
 background-color: #007bff;
 border-color: #007bff;

}

.btn-primary:not(:disabled):not(.disabled):active, .btn-primary:not(:disabled):not(.disabled).active, .show > .btn-primary.dropdown-toggle {

 color: #fff;
 background-color: #0062cc;
 border-color: #005cbf;

}

.btn-primary:not(:disabled):not(.disabled):active:focus, .btn-primary:not(:disabled):not(.disabled).active:focus, .show > .btn-primary.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5);

}

.btn-secondary {

 color: #fff;
 background-color: #6c757d;
 border-color: #6c757d;

}

.btn-secondary:hover {

 color: #fff;
 background-color: #5a6268;
 border-color: #545b62;

}

.btn-secondary:focus, .btn-secondary.focus {

 box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5);

}

.btn-secondary.disabled, .btn-secondary:disabled {

 color: #fff;
 background-color: #6c757d;
 border-color: #6c757d;

}

.btn-secondary:not(:disabled):not(.disabled):active, .btn-secondary:not(:disabled):not(.disabled).active, .show > .btn-secondary.dropdown-toggle {

 color: #fff;
 background-color: #545b62;
 border-color: #4e555b;

}

.btn-secondary:not(:disabled):not(.disabled):active:focus, .btn-secondary:not(:disabled):not(.disabled).active:focus, .show > .btn-secondary.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5);

}

.btn-success {

 color: #fff;
 background-color: #28a745;
 border-color: #28a745;

}

.btn-success:hover {

 color: #fff;
 background-color: #218838;
 border-color: #1e7e34;

}

.btn-success:focus, .btn-success.focus {

 box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5);

}

.btn-success.disabled, .btn-success:disabled {

 color: #fff;
 background-color: #28a745;
 border-color: #28a745;

}

.btn-success:not(:disabled):not(.disabled):active, .btn-success:not(:disabled):not(.disabled).active, .show > .btn-success.dropdown-toggle {

 color: #fff;
 background-color: #1e7e34;
 border-color: #1c7430;

}

.btn-success:not(:disabled):not(.disabled):active:focus, .btn-success:not(:disabled):not(.disabled).active:focus, .show > .btn-success.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5);

}

.btn-info {

 color: #fff;
 background-color: #17a2b8;
 border-color: #17a2b8;

}

.btn-info:hover {

 color: #fff;
 background-color: #138496;
 border-color: #117a8b;

}

.btn-info:focus, .btn-info.focus {

 box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5);

}

.btn-info.disabled, .btn-info:disabled {

 color: #fff;
 background-color: #17a2b8;
 border-color: #17a2b8;

}

.btn-info:not(:disabled):not(.disabled):active, .btn-info:not(:disabled):not(.disabled).active, .show > .btn-info.dropdown-toggle {

 color: #fff;
 background-color: #117a8b;
 border-color: #10707f;

}

.btn-info:not(:disabled):not(.disabled):active:focus, .btn-info:not(:disabled):not(.disabled).active:focus, .show > .btn-info.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5);

}

.btn-warning {

 color: #212529;
 background-color: #ffc107;
 border-color: #ffc107;

}

.btn-warning:hover {

 color: #212529;
 background-color: #e0a800;
 border-color: #d39e00;

}

.btn-warning:focus, .btn-warning.focus {

 box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5);

}

.btn-warning.disabled, .btn-warning:disabled {

 color: #212529;
 background-color: #ffc107;
 border-color: #ffc107;

}

.btn-warning:not(:disabled):not(.disabled):active, .btn-warning:not(:disabled):not(.disabled).active, .show > .btn-warning.dropdown-toggle {

 color: #212529;
 background-color: #d39e00;
 border-color: #c69500;

}

.btn-warning:not(:disabled):not(.disabled):active:focus, .btn-warning:not(:disabled):not(.disabled).active:focus, .show > .btn-warning.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5);

}

.btn-danger {

 color: #fff;
 background-color: #dc3545;
 border-color: #dc3545;

}

.btn-danger:hover {

 color: #fff;
 background-color: #c82333;
 border-color: #bd2130;

}

.btn-danger:focus, .btn-danger.focus {

 box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5);

}

.btn-danger.disabled, .btn-danger:disabled {

 color: #fff;
 background-color: #dc3545;
 border-color: #dc3545;

}

.btn-danger:not(:disabled):not(.disabled):active, .btn-danger:not(:disabled):not(.disabled).active, .show > .btn-danger.dropdown-toggle {

 color: #fff;
 background-color: #bd2130;
 border-color: #b21f2d;

}

.btn-danger:not(:disabled):not(.disabled):active:focus, .btn-danger:not(:disabled):not(.disabled).active:focus, .show > .btn-danger.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5);

}

.btn-light {

 color: #212529;
 background-color: #f8f9fa;
 border-color: #f8f9fa;

}

.btn-light:hover {

 color: #212529;
 background-color: #e2e6ea;
 border-color: #dae0e5;

}

.btn-light:focus, .btn-light.focus {

 box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5);

}

.btn-light.disabled, .btn-light:disabled {

 color: #212529;
 background-color: #f8f9fa;
 border-color: #f8f9fa;

}

.btn-light:not(:disabled):not(.disabled):active, .btn-light:not(:disabled):not(.disabled).active, .show > .btn-light.dropdown-toggle {

 color: #212529;
 background-color: #dae0e5;
 border-color: #d3d9df;

}

.btn-light:not(:disabled):not(.disabled):active:focus, .btn-light:not(:disabled):not(.disabled).active:focus, .show > .btn-light.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5);

}

.btn-dark {

 color: #fff;
 background-color: #343a40;
 border-color: #343a40;

}

.btn-dark:hover {

 color: #fff;
 background-color: #23272b;
 border-color: #1d2124;

}

.btn-dark:focus, .btn-dark.focus {

 box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5);

}

.btn-dark.disabled, .btn-dark:disabled {

 color: #fff;
 background-color: #343a40;
 border-color: #343a40;

}

.btn-dark:not(:disabled):not(.disabled):active, .btn-dark:not(:disabled):not(.disabled).active, .show > .btn-dark.dropdown-toggle {

 color: #fff;
 background-color: #1d2124;
 border-color: #171a1d;

}

.btn-dark:not(:disabled):not(.disabled):active:focus, .btn-dark:not(:disabled):not(.disabled).active:focus, .show > .btn-dark.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5);

}

.btn-outline-primary {

 color: #007bff;
 background-color: transparent;
 background-image: none;
 border-color: #007bff;

}

.btn-outline-primary:hover {

 color: #fff;
 background-color: #007bff;
 border-color: #007bff;

}

.btn-outline-primary:focus, .btn-outline-primary.focus {

 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5);

}

.btn-outline-primary.disabled, .btn-outline-primary:disabled {

 color: #007bff;
 background-color: transparent;

}

.btn-outline-primary:not(:disabled):not(.disabled):active, .btn-outline-primary:not(:disabled):not(.disabled).active, .show > .btn-outline-primary.dropdown-toggle {

 color: #fff;
 background-color: #007bff;
 border-color: #007bff;

}

.btn-outline-primary:not(:disabled):not(.disabled):active:focus, .btn-outline-primary:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-primary.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.5);

}

.btn-outline-secondary {

 color: #6c757d;
 background-color: transparent;
 background-image: none;
 border-color: #6c757d;

}

.btn-outline-secondary:hover {

 color: #fff;
 background-color: #6c757d;
 border-color: #6c757d;

}

.btn-outline-secondary:focus, .btn-outline-secondary.focus {

 box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5);

}

.btn-outline-secondary.disabled, .btn-outline-secondary:disabled {

 color: #6c757d;
 background-color: transparent;

}

.btn-outline-secondary:not(:disabled):not(.disabled):active, .btn-outline-secondary:not(:disabled):not(.disabled).active, .show > .btn-outline-secondary.dropdown-toggle {

 color: #fff;
 background-color: #6c757d;
 border-color: #6c757d;

}

.btn-outline-secondary:not(:disabled):not(.disabled):active:focus, .btn-outline-secondary:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-secondary.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(108, 117, 125, 0.5);

}

.btn-outline-success {

 color: #28a745;
 background-color: transparent;
 background-image: none;
 border-color: #28a745;

}

.btn-outline-success:hover {

 color: #fff;
 background-color: #28a745;
 border-color: #28a745;

}

.btn-outline-success:focus, .btn-outline-success.focus {

 box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5);

}

.btn-outline-success.disabled, .btn-outline-success:disabled {

 color: #28a745;
 background-color: transparent;

}

.btn-outline-success:not(:disabled):not(.disabled):active, .btn-outline-success:not(:disabled):not(.disabled).active, .show > .btn-outline-success.dropdown-toggle {

 color: #fff;
 background-color: #28a745;
 border-color: #28a745;

}

.btn-outline-success:not(:disabled):not(.disabled):active:focus, .btn-outline-success:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-success.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.5);

}

.btn-outline-info {

 color: #17a2b8;
 background-color: transparent;
 background-image: none;
 border-color: #17a2b8;

}

.btn-outline-info:hover {

 color: #fff;
 background-color: #17a2b8;
 border-color: #17a2b8;

}

.btn-outline-info:focus, .btn-outline-info.focus {

 box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5);

}

.btn-outline-info.disabled, .btn-outline-info:disabled {

 color: #17a2b8;
 background-color: transparent;

}

.btn-outline-info:not(:disabled):not(.disabled):active, .btn-outline-info:not(:disabled):not(.disabled).active, .show > .btn-outline-info.dropdown-toggle {

 color: #fff;
 background-color: #17a2b8;
 border-color: #17a2b8;

}

.btn-outline-info:not(:disabled):not(.disabled):active:focus, .btn-outline-info:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-info.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(23, 162, 184, 0.5);

}

.btn-outline-warning {

 color: #ffc107;
 background-color: transparent;
 background-image: none;
 border-color: #ffc107;

}

.btn-outline-warning:hover {

 color: #212529;
 background-color: #ffc107;
 border-color: #ffc107;

}

.btn-outline-warning:focus, .btn-outline-warning.focus {

 box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5);

}

.btn-outline-warning.disabled, .btn-outline-warning:disabled {

 color: #ffc107;
 background-color: transparent;

}

.btn-outline-warning:not(:disabled):not(.disabled):active, .btn-outline-warning:not(:disabled):not(.disabled).active, .show > .btn-outline-warning.dropdown-toggle {

 color: #212529;
 background-color: #ffc107;
 border-color: #ffc107;

}

.btn-outline-warning:not(:disabled):not(.disabled):active:focus, .btn-outline-warning:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-warning.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(255, 193, 7, 0.5);

}

.btn-outline-danger {

 color: #dc3545;
 background-color: transparent;
 background-image: none;
 border-color: #dc3545;

}

.btn-outline-danger:hover {

 color: #fff;
 background-color: #dc3545;
 border-color: #dc3545;

}

.btn-outline-danger:focus, .btn-outline-danger.focus {

 box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5);

}

.btn-outline-danger.disabled, .btn-outline-danger:disabled {

 color: #dc3545;
 background-color: transparent;

}

.btn-outline-danger:not(:disabled):not(.disabled):active, .btn-outline-danger:not(:disabled):not(.disabled).active, .show > .btn-outline-danger.dropdown-toggle {

 color: #fff;
 background-color: #dc3545;
 border-color: #dc3545;

}

.btn-outline-danger:not(:disabled):not(.disabled):active:focus, .btn-outline-danger:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-danger.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.5);

}

.btn-outline-light {

 color: #f8f9fa;
 background-color: transparent;
 background-image: none;
 border-color: #f8f9fa;

}

.btn-outline-light:hover {

 color: #212529;
 background-color: #f8f9fa;
 border-color: #f8f9fa;

}

.btn-outline-light:focus, .btn-outline-light.focus {

 box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5);

}

.btn-outline-light.disabled, .btn-outline-light:disabled {

 color: #f8f9fa;
 background-color: transparent;

}

.btn-outline-light:not(:disabled):not(.disabled):active, .btn-outline-light:not(:disabled):not(.disabled).active, .show > .btn-outline-light.dropdown-toggle {

 color: #212529;
 background-color: #f8f9fa;
 border-color: #f8f9fa;

}

.btn-outline-light:not(:disabled):not(.disabled):active:focus, .btn-outline-light:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-light.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(248, 249, 250, 0.5);

}

.btn-outline-dark {

 color: #343a40;
 background-color: transparent;
 background-image: none;
 border-color: #343a40;

}

.btn-outline-dark:hover {

 color: #fff;
 background-color: #343a40;
 border-color: #343a40;

}

.btn-outline-dark:focus, .btn-outline-dark.focus {

 box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5);

}

.btn-outline-dark.disabled, .btn-outline-dark:disabled {

 color: #343a40;
 background-color: transparent;

}

.btn-outline-dark:not(:disabled):not(.disabled):active, .btn-outline-dark:not(:disabled):not(.disabled).active, .show > .btn-outline-dark.dropdown-toggle {

 color: #fff;
 background-color: #343a40;
 border-color: #343a40;

}

.btn-outline-dark:not(:disabled):not(.disabled):active:focus, .btn-outline-dark:not(:disabled):not(.disabled).active:focus, .show > .btn-outline-dark.dropdown-toggle:focus {

 box-shadow: 0 0 0 0.2rem rgba(52, 58, 64, 0.5);

}

.btn-link {

 font-weight: 400;
 color: #007bff;
 background-color: transparent;

}

.btn-link:hover {

 color: #0056b3;
 text-decoration: underline;
 background-color: transparent;
 border-color: transparent;

}

.btn-link:focus, .btn-link.focus {

 text-decoration: underline;
 border-color: transparent;
 box-shadow: none;

}

.btn-link:disabled, .btn-link.disabled {

 color: #6c757d;
 pointer-events: none;

}

.btn-lg, .btn-group-lg > .btn {

 padding: 0.5rem 1rem;
 font-size: 1.25rem;
 line-height: 1.5;
 border-radius: 0.3rem;

}

.btn-sm, .btn-group-sm > .btn {

 padding: 0.25rem 0.5rem;
 font-size: 0.875rem;
 line-height: 1.5;
 border-radius: 0.2rem;

}

.btn-block {

 display: block;
 width: 100%;

}

.btn-block + .btn-block {

 margin-top: 0.5rem;

}

input[type="submit"].btn-block, input[type="reset"].btn-block, input[type="button"].btn-block {

 width: 100%;

}

.fade {

 transition: opacity 0.15s linear;

}

@media screen and (prefers-reduced-motion: reduce) {

 .fade {
   transition: none;
 }

}

.fade:not(.show) {

 opacity: 0;

}

.collapse:not(.show) {

 display: none;

}

.collapsing {

 position: relative;
 height: 0;
 overflow: hidden;
 transition: height 0.35s ease;

}

@media screen and (prefers-reduced-motion: reduce) {

 .collapsing {
   transition: none;
 }

}

.dropup, .dropright, .dropdown, .dropleft {

 position: relative;

}

.dropdown-toggle::after {

 display: inline-block;
 width: 0;
 height: 0;
 margin-left: 0.255em;
 vertical-align: 0.255em;
 content: "";
 border-top: 0.3em solid;
 border-right: 0.3em solid transparent;
 border-bottom: 0;
 border-left: 0.3em solid transparent;

}

.dropdown-toggle:empty::after {

 margin-left: 0;

}

.dropdown-menu {

 position: absolute;
 top: 100%;
 left: 0;
 z-index: 1000;
 display: none;
 float: left;
 min-width: 10rem;
 padding: 0.5rem 0;
 margin: 0.125rem 0 0;
 font-size: 1rem;
 color: #212529;
 text-align: left;
 list-style: none;
 background-color: #fff;
 background-clip: padding-box;
 border: 1px solid rgba(0, 0, 0, 0.15);
 border-radius: 0.25rem;

}

.dropdown-menu-right {

 right: 0;
 left: auto;

}

.dropup .dropdown-menu {

 top: auto;
 bottom: 100%;
 margin-top: 0;
 margin-bottom: 0.125rem;

}

.dropup .dropdown-toggle::after {

 display: inline-block;
 width: 0;
 height: 0;
 margin-left: 0.255em;
 vertical-align: 0.255em;
 content: "";
 border-top: 0;
 border-right: 0.3em solid transparent;
 border-bottom: 0.3em solid;
 border-left: 0.3em solid transparent;

}

.dropup .dropdown-toggle:empty::after {

 margin-left: 0;

}

.dropright .dropdown-menu {

 top: 0;
 right: auto;
 left: 100%;
 margin-top: 0;
 margin-left: 0.125rem;

}

.dropright .dropdown-toggle::after {

 display: inline-block;
 width: 0;
 height: 0;
 margin-left: 0.255em;
 vertical-align: 0.255em;
 content: "";
 border-top: 0.3em solid transparent;
 border-right: 0;
 border-bottom: 0.3em solid transparent;
 border-left: 0.3em solid;

}

.dropright .dropdown-toggle:empty::after {

 margin-left: 0;

}

.dropright .dropdown-toggle::after {

 vertical-align: 0;

}

.dropleft .dropdown-menu {

 top: 0;
 right: 100%;
 left: auto;
 margin-top: 0;
 margin-right: 0.125rem;

}

.dropleft .dropdown-toggle::after {

 display: inline-block;
 width: 0;
 height: 0;
 margin-left: 0.255em;
 vertical-align: 0.255em;
 content: "";

}

.dropleft .dropdown-toggle::after {

 display: none;

}

.dropleft .dropdown-toggle::before {

 display: inline-block;
 width: 0;
 height: 0;
 margin-right: 0.255em;
 vertical-align: 0.255em;
 content: "";
 border-top: 0.3em solid transparent;
 border-right: 0.3em solid;
 border-bottom: 0.3em solid transparent;

}

.dropleft .dropdown-toggle:empty::after {

 margin-left: 0;

}

.dropleft .dropdown-toggle::before {

 vertical-align: 0;

}

.dropdown-menu[x-placement^="top"], .dropdown-menu[x-placement^="right"], .dropdown-menu[x-placement^="bottom"], .dropdown-menu[x-placement^="left"] {

 right: auto;
 bottom: auto;

}

.dropdown-divider {

 height: 0;
 margin: 0.5rem 0;
 overflow: hidden;
 border-top: 1px solid #e9ecef;

}

.dropdown-item {

 display: block;
 width: 100%;
 padding: 0.25rem 1.5rem;
 clear: both;
 font-weight: 400;
 color: #212529;
 text-align: inherit;
 white-space: nowrap;
 background-color: transparent;
 border: 0;

}

.dropdown-item:hover, .dropdown-item:focus {

 color: #16181b;
 text-decoration: none;
 background-color: #f8f9fa;

}

.dropdown-item.active, .dropdown-item:active {

 color: #fff;
 text-decoration: none;
 background-color: #007bff;

}

.dropdown-item.disabled, .dropdown-item:disabled {

 color: #6c757d;
 background-color: transparent;

}

.dropdown-menu.show {

 display: block;

}

.dropdown-header {

 display: block;
 padding: 0.5rem 1.5rem;
 margin-bottom: 0;
 font-size: 0.875rem;
 color: #6c757d;
 white-space: nowrap;

}

.dropdown-item-text {

 display: block;
 padding: 0.25rem 1.5rem;
 color: #212529;

}

.btn-group, .btn-group-vertical {

 position: relative;
 display: -ms-inline-flexbox;
 display: inline-flex;
 vertical-align: middle;

}

.btn-group > .btn, .btn-group-vertical > .btn {

 position: relative;
 -ms-flex: 0 1 auto;
 flex: 0 1 auto;

}

.btn-group > .btn:hover, .btn-group-vertical > .btn:hover {

 z-index: 1;

}

.btn-group > .btn:focus, .btn-group > .btn:active, .btn-group > .btn.active, .btn-group-vertical > .btn:focus, .btn-group-vertical > .btn:active, .btn-group-vertical > .btn.active {

 z-index: 1;

}

.btn-group .btn + .btn, .btn-group .btn + .btn-group, .btn-group .btn-group + .btn, .btn-group .btn-group + .btn-group, .btn-group-vertical .btn + .btn, .btn-group-vertical .btn + .btn-group, .btn-group-vertical .btn-group + .btn, .btn-group-vertical .btn-group + .btn-group {

 margin-left: -1px;

}

.btn-toolbar {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 -ms-flex-pack: start;
 justify-content: flex-start;

}

.btn-toolbar .input-group {

 width: auto;

}

.btn-group > .btn:first-child {

 margin-left: 0;

}

.btn-group > .btn:not(:last-child):not(.dropdown-toggle), .btn-group > .btn-group:not(:last-child) > .btn {

 border-top-right-radius: 0;
 border-bottom-right-radius: 0;

}

.btn-group > .btn:not(:first-child), .btn-group > .btn-group:not(:first-child) > .btn {

 border-top-left-radius: 0;
 border-bottom-left-radius: 0;

}

.dropdown-toggle-split {

 padding-right: 0.5625rem;
 padding-left: 0.5625rem;

}

.dropdown-toggle-split::after, .dropup .dropdown-toggle-split::after, .dropright .dropdown-toggle-split::after {

 margin-left: 0;

}

.dropleft .dropdown-toggle-split::before {

 margin-right: 0;

}

.btn-sm + .dropdown-toggle-split, .btn-group-sm > .btn + .dropdown-toggle-split {

 padding-right: 0.375rem;
 padding-left: 0.375rem;

}

.btn-lg + .dropdown-toggle-split, .btn-group-lg > .btn + .dropdown-toggle-split {

 padding-right: 0.75rem;
 padding-left: 0.75rem;

}

.btn-group-vertical {

 -ms-flex-direction: column;
 flex-direction: column;
 -ms-flex-align: start;
 align-items: flex-start;
 -ms-flex-pack: center;
 justify-content: center;

}

.btn-group-vertical .btn, .btn-group-vertical .btn-group {

 width: 100%;

}

.btn-group-vertical > .btn + .btn, .btn-group-vertical > .btn + .btn-group, .btn-group-vertical > .btn-group + .btn, .btn-group-vertical > .btn-group + .btn-group {

 margin-top: -1px;
 margin-left: 0;

}

.btn-group-vertical > .btn:not(:last-child):not(.dropdown-toggle), .btn-group-vertical > .btn-group:not(:last-child) > .btn {

 border-bottom-right-radius: 0;
 border-bottom-left-radius: 0;

}

.btn-group-vertical > .btn:not(:first-child), .btn-group-vertical > .btn-group:not(:first-child) > .btn {

 border-top-left-radius: 0;
 border-top-right-radius: 0;

}

.btn-group-toggle > .btn, .btn-group-toggle > .btn-group > .btn {

 margin-bottom: 0;

}

.btn-group-toggle > .btn input[type="radio"], .btn-group-toggle > .btn input[type="checkbox"], .btn-group-toggle > .btn-group > .btn input[type="radio"], .btn-group-toggle > .btn-group > .btn input[type="checkbox"] {

 position: absolute;
 clip: rect(0, 0, 0, 0);
 pointer-events: none;

}

.input-group {

 position: relative;
 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 -ms-flex-align: stretch;
 align-items: stretch;
 width: 100%;

}

.input-group > .form-control, .input-group > .custom-select, .input-group > .custom-file {

 position: relative;
 -ms-flex: 1 1 auto;
 flex: 1 1 auto;
 width: 1%;
 margin-bottom: 0;

}

.input-group > .form-control + .form-control, .input-group > .form-control + .custom-select, .input-group > .form-control + .custom-file, .input-group > .custom-select + .form-control, .input-group > .custom-select + .custom-select, .input-group > .custom-select + .custom-file, .input-group > .custom-file + .form-control, .input-group > .custom-file + .custom-select, .input-group > .custom-file + .custom-file {

 margin-left: -1px;

}

.input-group > .form-control:focus, .input-group > .custom-select:focus, .input-group > .custom-file .custom-file-input:focus ~ .custom-file-label {

 z-index: 3;

}

.input-group > .custom-file .custom-file-input:focus {

 z-index: 4;

}

.input-group > .form-control:not(:last-child), .input-group > .custom-select:not(:last-child) {

 border-top-right-radius: 0;
 border-bottom-right-radius: 0;

}

.input-group > .form-control:not(:first-child), .input-group > .custom-select:not(:first-child) {

 border-top-left-radius: 0;
 border-bottom-left-radius: 0;

}

.input-group > .custom-file {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: center;
 align-items: center;

}

.input-group > .custom-file:not(:last-child) .custom-file-label, .input-group > .custom-file:not(:last-child) .custom-file-label::after {

 border-top-right-radius: 0;
 border-bottom-right-radius: 0;

}

.input-group > .custom-file:not(:first-child) .custom-file-label {

 border-top-left-radius: 0;
 border-bottom-left-radius: 0;

}

.input-group-prepend, .input-group-append {

 display: -ms-flexbox;
 display: flex;

}

.input-group-prepend .btn, .input-group-append .btn {

 position: relative;
 z-index: 2;

}

.input-group-prepend .btn + .btn, .input-group-prepend .btn + .input-group-text, .input-group-prepend .input-group-text + .input-group-text, .input-group-prepend .input-group-text + .btn, .input-group-append .btn + .btn, .input-group-append .btn + .input-group-text, .input-group-append .input-group-text + .input-group-text, .input-group-append .input-group-text + .btn {

 margin-left: -1px;

}

.input-group-prepend {

 margin-right: -1px;

}

.input-group-append {

 margin-left: -1px;

}

.input-group-text {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: center;
 align-items: center;
 padding: 0.375rem 0.75rem;
 margin-bottom: 0;
 font-size: 1rem;
 font-weight: 400;
 line-height: 1.5;
 color: #495057;
 text-align: center;
 white-space: nowrap;
 background-color: #e9ecef;
 border: 1px solid #ced4da;
 border-radius: 0.25rem;

}

.input-group-text input[type="radio"], .input-group-text input[type="checkbox"] {

 margin-top: 0;

}

.input-group-lg > .form-control, .input-group-lg > .input-group-prepend > .input-group-text, .input-group-lg > .input-group-append > .input-group-text, .input-group-lg > .input-group-prepend > .btn, .input-group-lg > .input-group-append > .btn {

 height: calc(2.875rem + 2px);
 padding: 0.5rem 1rem;
 font-size: 1.25rem;
 line-height: 1.5;
 border-radius: 0.3rem;

}

.input-group-sm > .form-control, .input-group-sm > .input-group-prepend > .input-group-text, .input-group-sm > .input-group-append > .input-group-text, .input-group-sm > .input-group-prepend > .btn, .input-group-sm > .input-group-append > .btn {

 height: calc(1.8125rem + 2px);
 padding: 0.25rem 0.5rem;
 font-size: 0.875rem;
 line-height: 1.5;
 border-radius: 0.2rem;

}

.input-group > .input-group-prepend > .btn, .input-group > .input-group-prepend > .input-group-text, .input-group > .input-group-append:not(:last-child) > .btn, .input-group > .input-group-append:not(:last-child) > .input-group-text, .input-group > .input-group-append:last-child > .btn:not(:last-child):not(.dropdown-toggle), .input-group > .input-group-append:last-child > .input-group-text:not(:last-child) {

 border-top-right-radius: 0;
 border-bottom-right-radius: 0;

}

.input-group > .input-group-append > .btn, .input-group > .input-group-append > .input-group-text, .input-group > .input-group-prepend:not(:first-child) > .btn, .input-group > .input-group-prepend:not(:first-child) > .input-group-text, .input-group > .input-group-prepend:first-child > .btn:not(:first-child), .input-group > .input-group-prepend:first-child > .input-group-text:not(:first-child) {

 border-top-left-radius: 0;
 border-bottom-left-radius: 0;

}

.custom-control {

 position: relative;
 display: block;
 min-height: 1.5rem;
 padding-left: 1.5rem;

}

.custom-control-inline {

 display: -ms-inline-flexbox;
 display: inline-flex;
 margin-right: 1rem;

}

.custom-control-input {

 position: absolute;
 z-index: -1;
 opacity: 0;

}

.custom-control-input:checked ~ .custom-control-label::before {

 color: #fff;
 background-color: #007bff;

}

.custom-control-input:focus ~ .custom-control-label::before {

 box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.custom-control-input:active ~ .custom-control-label::before {

 color: #fff;
 background-color: #b3d7ff;

}

.custom-control-input:disabled ~ .custom-control-label {

 color: #6c757d;

}

.custom-control-input:disabled ~ .custom-control-label::before {

 background-color: #e9ecef;

}

.custom-control-label {

 position: relative;
 margin-bottom: 0;

}

.custom-control-label::before {

 position: absolute;
 top: 0.25rem;
 left: -1.5rem;
 display: block;
 width: 1rem;
 height: 1rem;
 pointer-events: none;
 content: "";
 -webkit-user-select: none;
 -moz-user-select: none;
 -ms-user-select: none;
 user-select: none;
 background-color: #dee2e6;

}

.custom-control-label::after {

 position: absolute;
 top: 0.25rem;
 left: -1.5rem;
 display: block;
 width: 1rem;
 height: 1rem;
 content: "";
 background-repeat: no-repeat;
 background-position: center center;
 background-size: 50% 50%;

}

.custom-checkbox .custom-control-label::before {

 border-radius: 0.25rem;

}

.custom-checkbox .custom-control-input:checked ~ .custom-control-label::before {

 background-color: #007bff;

}

.custom-checkbox .custom-control-input:checked ~ .custom-control-label::after {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26 2.974 7.25 8 2.193z'/%3E%3C/svg%3E");

}

.custom-checkbox .custom-control-input:indeterminate ~ .custom-control-label::before {

 background-color: #007bff;

}

.custom-checkbox .custom-control-input:indeterminate ~ .custom-control-label::after {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 4 4'%3E%3Cpath stroke='%23fff' d='M0 2h4'/%3E%3C/svg%3E");

}

.custom-checkbox .custom-control-input:disabled:checked ~ .custom-control-label::before {

 background-color: rgba(0, 123, 255, 0.5);

}

.custom-checkbox .custom-control-input:disabled:indeterminate ~ .custom-control-label::before {

 background-color: rgba(0, 123, 255, 0.5);

}

.custom-radio .custom-control-label::before {

 border-radius: 50%;

}

.custom-radio .custom-control-input:checked ~ .custom-control-label::before {

 background-color: #007bff;

}

.custom-radio .custom-control-input:checked ~ .custom-control-label::after {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%23fff'/%3E%3C/svg%3E");

}

.custom-radio .custom-control-input:disabled:checked ~ .custom-control-label::before {

 background-color: rgba(0, 123, 255, 0.5);

}

.custom-select {

 display: inline-block;
 width: 100%;
 height: calc(2.25rem + 2px);
 padding: 0.375rem 1.75rem 0.375rem 0.75rem;
 line-height: 1.5;
 color: #495057;
 vertical-align: middle;
 background: #fff url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 4 5'%3E%3Cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3E%3C/svg%3E") no-repeat right 0.75rem center;
 background-size: 8px 10px;
 border: 1px solid #ced4da;
 border-radius: 0.25rem;
 -webkit-appearance: none;
 -moz-appearance: none;
 appearance: none;

}

.custom-select:focus {

 border-color: #80bdff;
 outline: 0;
 box-shadow: 0 0 0 0.2rem rgba(128, 189, 255, 0.5);

}

.custom-select:focus::-ms-value {

 color: #495057;
 background-color: #fff;

}

.custom-select[multiple], .custom-select[size]:not([size="1"]) {

 height: auto;
 padding-right: 0.75rem;
 background-image: none;

}

.custom-select:disabled {

 color: #6c757d;
 background-color: #e9ecef;

}

.custom-select::-ms-expand {

 opacity: 0;

}

.custom-select-sm {

 height: calc(1.8125rem + 2px);
 padding-top: 0.375rem;
 padding-bottom: 0.375rem;
 font-size: 75%;

}

.custom-select-lg {

 height: calc(2.875rem + 2px);
 padding-top: 0.375rem;
 padding-bottom: 0.375rem;
 font-size: 125%;

}

.custom-file {

 position: relative;
 display: inline-block;
 width: 100%;
 height: calc(2.25rem + 2px);
 margin-bottom: 0;

}

.custom-file-input {

 position: relative;
 z-index: 2;
 width: 100%;
 height: calc(2.25rem + 2px);
 margin: 0;
 opacity: 0;

}

.custom-file-input:focus ~ .custom-file-label {

 border-color: #80bdff;
 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.custom-file-input:focus ~ .custom-file-label::after {

 border-color: #80bdff;

}

.custom-file-input:disabled ~ .custom-file-label {

 background-color: #e9ecef;

}

.custom-file-input:lang(en) ~ .custom-file-label::after {

 content: "Browse";

}

.custom-file-label {

 position: absolute;
 top: 0;
 right: 0;
 left: 0;
 z-index: 1;
 height: calc(2.25rem + 2px);
 padding: 0.375rem 0.75rem;
 line-height: 1.5;
 color: #495057;
 background-color: #fff;
 border: 1px solid #ced4da;
 border-radius: 0.25rem;

}

.custom-file-label::after {

 position: absolute;
 top: 0;
 right: 0;
 bottom: 0;
 z-index: 3;
 display: block;
 height: 2.25rem;
 padding: 0.375rem 0.75rem;
 line-height: 1.5;
 color: #495057;
 content: "Browse";
 background-color: #e9ecef;
 border-left: 1px solid #ced4da;
 border-radius: 0 0.25rem 0.25rem 0;

}

.custom-range {

 width: 100%;
 padding-left: 0;
 background-color: transparent;
 -webkit-appearance: none;
 -moz-appearance: none;
 appearance: none;

}

.custom-range:focus {

 outline: none;

}

.custom-range:focus::-webkit-slider-thumb {

 box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.custom-range:focus::-moz-range-thumb {

 box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.custom-range:focus::-ms-thumb {

 box-shadow: 0 0 0 1px #fff, 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.custom-range::-moz-focus-outer {

 border: 0;

}

.custom-range::-webkit-slider-thumb {

 width: 1rem;
 height: 1rem;
 margin-top: -0.25rem;
 background-color: #007bff;
 border: 0;
 border-radius: 1rem;
 transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
 -webkit-appearance: none;
 appearance: none;

}

@media screen and (prefers-reduced-motion: reduce) {

 .custom-range::-webkit-slider-thumb {
   transition: none;
 }

}

.custom-range::-webkit-slider-thumb:active {

 background-color: #b3d7ff;

}

.custom-range::-webkit-slider-runnable-track {

 width: 100%;
 height: 0.5rem;
 color: transparent;
 cursor: pointer;
 background-color: #dee2e6;
 border-color: transparent;
 border-radius: 1rem;

}

.custom-range::-moz-range-thumb {

 width: 1rem;
 height: 1rem;
 background-color: #007bff;
 border: 0;
 border-radius: 1rem;
 transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
 -moz-appearance: none;
 appearance: none;

}

@media screen and (prefers-reduced-motion: reduce) {

 .custom-range::-moz-range-thumb {
   transition: none;
 }

}

.custom-range::-moz-range-thumb:active {

 background-color: #b3d7ff;

}

.custom-range::-moz-range-track {

 width: 100%;
 height: 0.5rem;
 color: transparent;
 cursor: pointer;
 background-color: #dee2e6;
 border-color: transparent;
 border-radius: 1rem;

}

.custom-range::-ms-thumb {

 width: 1rem;
 height: 1rem;
 margin-top: 0;
 margin-right: 0.2rem;
 margin-left: 0.2rem;
 background-color: #007bff;
 border: 0;
 border-radius: 1rem;
 transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
 appearance: none;

}

@media screen and (prefers-reduced-motion: reduce) {

 .custom-range::-ms-thumb {
   transition: none;
 }

}

.custom-range::-ms-thumb:active {

 background-color: #b3d7ff;

}

.custom-range::-ms-track {

 width: 100%;
 height: 0.5rem;
 color: transparent;
 cursor: pointer;
 background-color: transparent;
 border-color: transparent;
 border-width: 0.5rem;

}

.custom-range::-ms-fill-lower {

 background-color: #dee2e6;
 border-radius: 1rem;

}

.custom-range::-ms-fill-upper {

 margin-right: 15px;
 background-color: #dee2e6;
 border-radius: 1rem;

}

.custom-control-label::before, .custom-file-label, .custom-select {

 transition: background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;

}

@media screen and (prefers-reduced-motion: reduce) {

 .custom-control-label::before,
 .custom-file-label,
 .custom-select {
   transition: none;
 }

}

.nav {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 padding-left: 0;
 margin-bottom: 0;
 list-style: none;

}

.nav-link {

 display: block;
 padding: 0.5rem 1rem;

}

.nav-link:hover, .nav-link:focus {

 text-decoration: none;

}

.nav-link.disabled {

 color: #6c757d;

}

.nav-tabs {

 border-bottom: 1px solid #dee2e6;

}

.nav-tabs .nav-item {

 margin-bottom: -1px;

}

.nav-tabs .nav-link {

 border: 1px solid transparent;
 border-top-left-radius: 0.25rem;
 border-top-right-radius: 0.25rem;

}

.nav-tabs .nav-link:hover, .nav-tabs .nav-link:focus {

 border-color: #e9ecef #e9ecef #dee2e6;

}

.nav-tabs .nav-link.disabled {

 color: #6c757d;
 background-color: transparent;
 border-color: transparent;

}

.nav-tabs .nav-link.active, .nav-tabs .nav-item.show .nav-link {

 color: #495057;
 background-color: #fff;
 border-color: #dee2e6 #dee2e6 #fff;

}

.nav-tabs .dropdown-menu {

 margin-top: -1px;
 border-top-left-radius: 0;
 border-top-right-radius: 0;

}

.nav-pills .nav-link {

 border-radius: 0.25rem;

}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {

 color: #fff;
 background-color: #007bff;

}

.nav-fill .nav-item {

 -ms-flex: 1 1 auto;
 flex: 1 1 auto;
 text-align: center;

}

.nav-justified .nav-item {

 -ms-flex-preferred-size: 0;
 flex-basis: 0;
 -ms-flex-positive: 1;
 flex-grow: 1;
 text-align: center;

}

.tab-content > .tab-pane {

 display: none;

}

.tab-content > .active {

 display: block;

}

.navbar {

 position: relative;
 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 -ms-flex-align: center;
 align-items: center;
 -ms-flex-pack: justify;
 justify-content: space-between;
 padding: 0.5rem 1rem;

}

.navbar > .container, .navbar > .container-fluid {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 -ms-flex-align: center;
 align-items: center;
 -ms-flex-pack: justify;
 justify-content: space-between;

}

.navbar-brand {

 display: inline-block;
 padding-top: 0.3125rem;
 padding-bottom: 0.3125rem;
 margin-right: 1rem;
 font-size: 1.25rem;
 line-height: inherit;
 white-space: nowrap;

}

.navbar-brand:hover, .navbar-brand:focus {

 text-decoration: none;

}

.navbar-nav {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;
 padding-left: 0;
 margin-bottom: 0;
 list-style: none;

}

.navbar-nav .nav-link {

 padding-right: 0;
 padding-left: 0;

}

.navbar-nav .dropdown-menu {

 position: static;
 float: none;

}

.navbar-text {

 display: inline-block;
 padding-top: 0.5rem;
 padding-bottom: 0.5rem;

}

.navbar-collapse {

 -ms-flex-preferred-size: 100%;
 flex-basis: 100%;
 -ms-flex-positive: 1;
 flex-grow: 1;
 -ms-flex-align: center;
 align-items: center;

}

.navbar-toggler {

 padding: 0.25rem 0.75rem;
 font-size: 1.25rem;
 line-height: 1;
 background-color: transparent;
 border: 1px solid transparent;
 border-radius: 0.25rem;

}

.navbar-toggler:hover, .navbar-toggler:focus {

 text-decoration: none;

}

.navbar-toggler:not(:disabled):not(.disabled) {

 cursor: pointer;

}

.navbar-toggler-icon {

 display: inline-block;
 width: 1.5em;
 height: 1.5em;
 vertical-align: middle;
 content: "";
 background: no-repeat center center;
 background-size: 100% 100%;

}

@media (max-width: 575.98px) {

 .navbar-expand-sm > .container,
 .navbar-expand-sm > .container-fluid {
   padding-right: 0;
   padding-left: 0;
 }

}

@media (min-width: 576px) {

 .navbar-expand-sm {
   -ms-flex-flow: row nowrap;
   flex-flow: row nowrap;
   -ms-flex-pack: start;
   justify-content: flex-start;
 }
 .navbar-expand-sm .navbar-nav {
   -ms-flex-direction: row;
   flex-direction: row;
 }
 .navbar-expand-sm .navbar-nav .dropdown-menu {
   position: absolute;
 }
 .navbar-expand-sm .navbar-nav .nav-link {
   padding-right: 0.5rem;
   padding-left: 0.5rem;
 }
 .navbar-expand-sm > .container,
 .navbar-expand-sm > .container-fluid {
   -ms-flex-wrap: nowrap;
   flex-wrap: nowrap;
 }
 .navbar-expand-sm .navbar-collapse {
   display: -ms-flexbox !important;
   display: flex !important;
   -ms-flex-preferred-size: auto;
   flex-basis: auto;
 }
 .navbar-expand-sm .navbar-toggler {
   display: none;
 }

}

@media (max-width: 767.98px) {

 .navbar-expand-md > .container,
 .navbar-expand-md > .container-fluid {
   padding-right: 0;
   padding-left: 0;
 }

}

@media (min-width: 768px) {

 .navbar-expand-md {
   -ms-flex-flow: row nowrap;
   flex-flow: row nowrap;
   -ms-flex-pack: start;
   justify-content: flex-start;
 }
 .navbar-expand-md .navbar-nav {
   -ms-flex-direction: row;
   flex-direction: row;
 }
 .navbar-expand-md .navbar-nav .dropdown-menu {
   position: absolute;
 }
 .navbar-expand-md .navbar-nav .nav-link {
   padding-right: 0.5rem;
   padding-left: 0.5rem;
 }
 .navbar-expand-md > .container,
 .navbar-expand-md > .container-fluid {
   -ms-flex-wrap: nowrap;
   flex-wrap: nowrap;
 }
 .navbar-expand-md .navbar-collapse {
   display: -ms-flexbox !important;
   display: flex !important;
   -ms-flex-preferred-size: auto;
   flex-basis: auto;
 }
 .navbar-expand-md .navbar-toggler {
   display: none;
 }

}

@media (max-width: 991.98px) {

 .navbar-expand-lg > .container,
 .navbar-expand-lg > .container-fluid {
   padding-right: 0;
   padding-left: 0;
 }

}

@media (min-width: 992px) {

 .navbar-expand-lg {
   -ms-flex-flow: row nowrap;
   flex-flow: row nowrap;
   -ms-flex-pack: start;
   justify-content: flex-start;
 }
 .navbar-expand-lg .navbar-nav {
   -ms-flex-direction: row;
   flex-direction: row;
 }
 .navbar-expand-lg .navbar-nav .dropdown-menu {
   position: absolute;
 }
 .navbar-expand-lg .navbar-nav .nav-link {
   padding-right: 0.5rem;
   padding-left: 0.5rem;
 }
 .navbar-expand-lg > .container,
 .navbar-expand-lg > .container-fluid {
   -ms-flex-wrap: nowrap;
   flex-wrap: nowrap;
 }
 .navbar-expand-lg .navbar-collapse {
   display: -ms-flexbox !important;
   display: flex !important;
   -ms-flex-preferred-size: auto;
   flex-basis: auto;
 }
 .navbar-expand-lg .navbar-toggler {
   display: none;
 }

}

@media (max-width: 1199.98px) {

 .navbar-expand-xl > .container,
 .navbar-expand-xl > .container-fluid {
   padding-right: 0;
   padding-left: 0;
 }

}

@media (min-width: 1200px) {

 .navbar-expand-xl {
   -ms-flex-flow: row nowrap;
   flex-flow: row nowrap;
   -ms-flex-pack: start;
   justify-content: flex-start;
 }
 .navbar-expand-xl .navbar-nav {
   -ms-flex-direction: row;
   flex-direction: row;
 }
 .navbar-expand-xl .navbar-nav .dropdown-menu {
   position: absolute;
 }
 .navbar-expand-xl .navbar-nav .nav-link {
   padding-right: 0.5rem;
   padding-left: 0.5rem;
 }
 .navbar-expand-xl > .container,
 .navbar-expand-xl > .container-fluid {
   -ms-flex-wrap: nowrap;
   flex-wrap: nowrap;
 }
 .navbar-expand-xl .navbar-collapse {
   display: -ms-flexbox !important;
   display: flex !important;
   -ms-flex-preferred-size: auto;
   flex-basis: auto;
 }
 .navbar-expand-xl .navbar-toggler {
   display: none;
 }

}

.navbar-expand {

 -ms-flex-flow: row nowrap;
 flex-flow: row nowrap;
 -ms-flex-pack: start;
 justify-content: flex-start;

}

.navbar-expand > .container, .navbar-expand > .container-fluid {

 padding-right: 0;
 padding-left: 0;

}

.navbar-expand .navbar-nav {

 -ms-flex-direction: row;
 flex-direction: row;

}

.navbar-expand .navbar-nav .dropdown-menu {

 position: absolute;

}

.navbar-expand .navbar-nav .nav-link {

 padding-right: 0.5rem;
 padding-left: 0.5rem;

}

.navbar-expand > .container, .navbar-expand > .container-fluid {

 -ms-flex-wrap: nowrap;
 flex-wrap: nowrap;

}

.navbar-expand .navbar-collapse {

 display: -ms-flexbox !important;
 display: flex !important;
 -ms-flex-preferred-size: auto;
 flex-basis: auto;

}

.navbar-expand .navbar-toggler {

 display: none;

}

.navbar-light .navbar-brand {

 color: rgba(0, 0, 0, 0.9);

}

.navbar-light .navbar-brand:hover, .navbar-light .navbar-brand:focus {

 color: rgba(0, 0, 0, 0.9);

}

.navbar-light .navbar-nav .nav-link {

 color: rgba(0, 0, 0, 0.5);

}

.navbar-light .navbar-nav .nav-link:hover, .navbar-light .navbar-nav .nav-link:focus {

 color: rgba(0, 0, 0, 0.7);

}

.navbar-light .navbar-nav .nav-link.disabled {

 color: rgba(0, 0, 0, 0.3);

}

.navbar-light .navbar-nav .show > .nav-link, .navbar-light .navbar-nav .active > .nav-link, .navbar-light .navbar-nav .nav-link.show, .navbar-light .navbar-nav .nav-link.active {

 color: rgba(0, 0, 0, 0.9);

}

.navbar-light .navbar-toggler {

 color: rgba(0, 0, 0, 0.5);
 border-color: rgba(0, 0, 0, 0.1);

}

.navbar-light .navbar-toggler-icon {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg viewBox='0 0 30 30' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath stroke='rgba(0, 0, 0, 0.5)' stroke-width='2' stroke-linecap='round' stroke-miterlimit='10' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E");

}

.navbar-light .navbar-text {

 color: rgba(0, 0, 0, 0.5);

}

.navbar-light .navbar-text a {

 color: rgba(0, 0, 0, 0.9);

}

.navbar-light .navbar-text a:hover, .navbar-light .navbar-text a:focus {

 color: rgba(0, 0, 0, 0.9);

}

.navbar-dark .navbar-brand {

 color: #fff;

}

.navbar-dark .navbar-brand:hover, .navbar-dark .navbar-brand:focus {

 color: #fff;

}

.navbar-dark .navbar-nav .nav-link {

 color: rgba(255, 255, 255, 0.5);

}

.navbar-dark .navbar-nav .nav-link:hover, .navbar-dark .navbar-nav .nav-link:focus {

 color: rgba(255, 255, 255, 0.75);

}

.navbar-dark .navbar-nav .nav-link.disabled {

 color: rgba(255, 255, 255, 0.25);

}

.navbar-dark .navbar-nav .show > .nav-link, .navbar-dark .navbar-nav .active > .nav-link, .navbar-dark .navbar-nav .nav-link.show, .navbar-dark .navbar-nav .nav-link.active {

 color: #fff;

}

.navbar-dark .navbar-toggler {

 color: rgba(255, 255, 255, 0.5);
 border-color: rgba(255, 255, 255, 0.1);

}

.navbar-dark .navbar-toggler-icon {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg viewBox='0 0 30 30' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath stroke='rgba(255, 255, 255, 0.5)' stroke-width='2' stroke-linecap='round' stroke-miterlimit='10' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E");

}

.navbar-dark .navbar-text {

 color: rgba(255, 255, 255, 0.5);

}

.navbar-dark .navbar-text a {

 color: #fff;

}

.navbar-dark .navbar-text a:hover, .navbar-dark .navbar-text a:focus {

 color: #fff;

}

.card {

 position: relative;
 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;
 min-width: 0;
 word-wrap: break-word;
 background-color: #F0F0F0;
 background-clip: border-box;
 border: 1px solid rgba(0, 0, 0, 0.125);
 border-radius: 0.25rem;

}

.card > hr {

 margin-right: 0;
 margin-left: 0;

}

.card > .list-group:first-child .list-group-item:first-child {

 border-top-left-radius: 0.25rem;
 border-top-right-radius: 0.25rem;

}

.card > .list-group:last-child .list-group-item:last-child {

 border-bottom-right-radius: 0.25rem;
 border-bottom-left-radius: 0.25rem;

}

.card-body {

 -ms-flex: 1 1 auto;
 flex: 1 1 auto;
 padding: 1.25rem;

}

.card-title {

 margin-bottom: 0.75rem;

}

.card-subtitle {

 margin-top: -0.375rem;
 margin-bottom: 0;

}

.card-text:last-child {

 margin-bottom: 0;

}

.card-link:hover {

 text-decoration: none;

}

.card-link + .card-link {

 margin-left: 1.25rem;

}

.card-header {

 padding: 0.75rem 1.25rem;
 margin-bottom: 0;
 background-color: rgba(0, 0, 0, 0.03);
 border-bottom: 1px solid rgba(0, 0, 0, 0.125);

}

.card-header:first-child {

 border-radius: calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0;

}

.card-header + .list-group .list-group-item:first-child {

 border-top: 0;

}

.card-footer {

 padding: 0.75rem 1.25rem;
 background-color: rgba(0, 0, 0, 0.03);
 border-top: 1px solid rgba(0, 0, 0, 0.125);

}

.card-footer:last-child {

 border-radius: 0 0 calc(0.25rem - 1px) calc(0.25rem - 1px);

}

.card-header-tabs {

 margin-right: -0.625rem;
 margin-bottom: -0.75rem;
 margin-left: -0.625rem;
 border-bottom: 0;

}

.card-header-pills {

 margin-right: -0.625rem;
 margin-left: -0.625rem;

}

.card-img-overlay {

 position: absolute;
 top: 0;
 right: 0;
 bottom: 0;
 left: 0;
 padding: 1.25rem;

}

.card-img {

 width: 80%;
 border-radius: calc(0.25rem - 1px);

}

.card-img-top {

 width: 100%;
 border-top-left-radius: calc(0.25rem - 1px);
 border-top-right-radius: calc(0.25rem - 1px);

}

.card-img-bottom {

 width: 100%;
 border-bottom-right-radius: calc(0.25rem - 1px);
 border-bottom-left-radius: calc(0.25rem - 1px);

}

.card-deck {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;

}

.card-deck .card {

 margin-bottom: 15px;

}

@media (min-width: 576px) {

 .card-deck {
   -ms-flex-flow: row wrap;
   flex-flow: row wrap;
   margin-right: -15px;
   margin-left: -15px;
 }
 .card-deck .card {
   display: -ms-flexbox;
   display: flex;
   -ms-flex: 1 0 0%;
   flex: 1 0 0%;
   -ms-flex-direction: column;
   flex-direction: column;
   margin-right: 15px;
   margin-bottom: 0;
   margin-left: 15px;
 }

}

.card-group {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;

}

.card-group > .card {

 margin-bottom: 15px;

}

@media (min-width: 576px) {

 .card-group {
   -ms-flex-flow: row wrap;
   flex-flow: row wrap;
 }
 .card-group > .card {
   -ms-flex: 1 0 0%;
   flex: 1 0 0%;
   margin-bottom: 0;
 }
 .card-group > .card + .card {
   margin-left: 0;
   border-left: 0;
 }
 .card-group > .card:first-child {
   border-top-right-radius: 0;
   border-bottom-right-radius: 0;
 }
 .card-group > .card:first-child .card-img-top,
 .card-group > .card:first-child .card-header {
   border-top-right-radius: 0;
 }
 .card-group > .card:first-child .card-img-bottom,
 .card-group > .card:first-child .card-footer {
   border-bottom-right-radius: 0;
 }
 .card-group > .card:last-child {
   border-top-left-radius: 0;
   border-bottom-left-radius: 0;
 }
 .card-group > .card:last-child .card-img-top,
 .card-group > .card:last-child .card-header {
   border-top-left-radius: 0;
 }
 .card-group > .card:last-child .card-img-bottom,
 .card-group > .card:last-child .card-footer {
   border-bottom-left-radius: 0;
 }
 .card-group > .card:only-child {
   border-radius: 0.25rem;
 }
 .card-group > .card:only-child .card-img-top,
 .card-group > .card:only-child .card-header {
   border-top-left-radius: 0.25rem;
   border-top-right-radius: 0.25rem;
 }
 .card-group > .card:only-child .card-img-bottom,
 .card-group > .card:only-child .card-footer {
   border-bottom-right-radius: 0.25rem;
   border-bottom-left-radius: 0.25rem;
 }
 .card-group > .card:not(:first-child):not(:last-child):not(:only-child) {
   border-radius: 0;
 }
 .card-group > .card:not(:first-child):not(:last-child):not(:only-child) .card-img-top,
 .card-group > .card:not(:first-child):not(:last-child):not(:only-child) .card-img-bottom,
 .card-group > .card:not(:first-child):not(:last-child):not(:only-child) .card-header,
 .card-group > .card:not(:first-child):not(:last-child):not(:only-child) .card-footer {
   border-radius: 0;
 }

}

.card-columns .card {

 margin-bottom: 0.75rem;

}

@media (min-width: 576px) {

 .card-columns {
   -webkit-column-count: 3;
   -moz-column-count: 3;
   column-count: 3;
   -webkit-column-gap: 1.25rem;
   -moz-column-gap: 1.25rem;
   column-gap: 1.25rem;
   orphans: 1;
   widows: 1;
 }
 .card-columns .card {
   display: inline-block;
   width: 100%;
 }

}

.accordion .card:not(:first-of-type):not(:last-of-type) {

 border-bottom: 0;
 border-radius: 0;

}

.accordion .card:not(:first-of-type) .card-header:first-child {

 border-radius: 0;

}

.accordion .card:first-of-type {

 border-bottom: 0;
 border-bottom-right-radius: 0;
 border-bottom-left-radius: 0;

}

.accordion .card:last-of-type {

 border-top-left-radius: 0;
 border-top-right-radius: 0;

}

.breadcrumb {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-wrap: wrap;
 flex-wrap: wrap;
 padding: 0.75rem 1rem;
 margin-bottom: 1rem;
 list-style: none;
 background-color: #e9ecef;
 border-radius: 0.25rem;

}

.breadcrumb-item + .breadcrumb-item {

 padding-left: 0.5rem;

}

.breadcrumb-item + .breadcrumb-item::before {

 display: inline-block;
 padding-right: 0.5rem;
 color: #6c757d;
 content: "/";

}

.breadcrumb-item + .breadcrumb-item:hover::before {

 text-decoration: underline;

}

.breadcrumb-item + .breadcrumb-item:hover::before {

 text-decoration: none;

}

.breadcrumb-item.active {

 color: #6c757d;

}

.pagination {

 display: -ms-flexbox;
 display: flex;
 padding-left: 0;
 list-style: none;
 border-radius: 0.25rem;

}

.page-link {

 position: relative;
 display: block;
 padding: 0.5rem 0.75rem;
 margin-left: -1px;
 line-height: 1.25;
 color: #007bff;
 background-color: #fff;
 border: 1px solid #dee2e6;

}

.page-link:hover {

 z-index: 2;
 color: #0056b3;
 text-decoration: none;
 background-color: #e9ecef;
 border-color: #dee2e6;

}

.page-link:focus {

 z-index: 2;
 outline: 0;
 box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);

}

.page-link:not(:disabled):not(.disabled) {

 cursor: pointer;

}

.page-item:first-child .page-link {

 margin-left: 0;
 border-top-left-radius: 0.25rem;
 border-bottom-left-radius: 0.25rem;

}

.page-item:last-child .page-link {

 border-top-right-radius: 0.25rem;
 border-bottom-right-radius: 0.25rem;

}

.page-item.active .page-link {

 z-index: 1;
 color: #fff;
 background-color: #007bff;
 border-color: #007bff;

}

.page-item.disabled .page-link {

 color: #6c757d;
 pointer-events: none;
 cursor: auto;
 background-color: #fff;
 border-color: #dee2e6;

}

.pagination-lg .page-link {

 padding: 0.75rem 1.5rem;
 font-size: 1.25rem;
 line-height: 1.5;

}

.pagination-lg .page-item:first-child .page-link {

 border-top-left-radius: 0.3rem;
 border-bottom-left-radius: 0.3rem;

}

.pagination-lg .page-item:last-child .page-link {

 border-top-right-radius: 0.3rem;
 border-bottom-right-radius: 0.3rem;

}

.pagination-sm .page-link {

 padding: 0.25rem 0.5rem;
 font-size: 0.875rem;
 line-height: 1.5;

}

.pagination-sm .page-item:first-child .page-link {

 border-top-left-radius: 0.2rem;
 border-bottom-left-radius: 0.2rem;

}

.pagination-sm .page-item:last-child .page-link {

 border-top-right-radius: 0.2rem;
 border-bottom-right-radius: 0.2rem;

}

.badge {

 display: inline-block;
 padding: 0.25em 0.4em;
 font-size: 75%;
 font-weight: 700;
 line-height: 1;
 text-align: center;
 white-space: nowrap;
 vertical-align: baseline;
 border-radius: 0.25rem;

}

.badge:empty {

 display: none;

}

.btn .badge {

 position: relative;
 top: -1px;

}

.badge-pill {

 padding-right: 0.6em;
 padding-left: 0.6em;
 border-radius: 10rem;

}

.badge-primary {

 color: #fff;
 background-color: #007bff;

}

.badge-primary[href]:hover, .badge-primary[href]:focus {

 color: #fff;
 text-decoration: none;
 background-color: #0062cc;

}

.badge-secondary {

 color: #fff;
 background-color: #6c757d;

}

.badge-secondary[href]:hover, .badge-secondary[href]:focus {

 color: #fff;
 text-decoration: none;
 background-color: #545b62;

}

.badge-success {

 color: #fff;
 background-color: #28a745;

}

.badge-success[href]:hover, .badge-success[href]:focus {

 color: #fff;
 text-decoration: none;
 background-color: #1e7e34;

}

.badge-info {

 color: #fff;
 background-color: #17a2b8;

}

.badge-info[href]:hover, .badge-info[href]:focus {

 color: #fff;
 text-decoration: none;
 background-color: #117a8b;

}

.badge-warning {

 color: #212529;
 background-color: #ffc107;

}

.badge-warning[href]:hover, .badge-warning[href]:focus {

 color: #212529;
 text-decoration: none;
 background-color: #d39e00;

}

.badge-danger {

 color: #fff;
 background-color: #dc3545;

}

.badge-danger[href]:hover, .badge-danger[href]:focus {

 color: #fff;
 text-decoration: none;
 background-color: #bd2130;

}

.badge-light {

 color: #212529;
 background-color: #f8f9fa;

}

.badge-light[href]:hover, .badge-light[href]:focus {

 color: #212529;
 text-decoration: none;
 background-color: #dae0e5;

}

.badge-dark {

 color: #fff;
 background-color: #343a40;

}

.badge-dark[href]:hover, .badge-dark[href]:focus {

 color: #fff;
 text-decoration: none;
 background-color: #1d2124;

}

.jumbotron {

 padding: 2rem 1rem;
 margin-bottom: 2rem;
 background-color: #e9ecef;
 border-radius: 0.3rem;

}

@media (min-width: 576px) {

 .jumbotron {
   padding: 4rem 2rem;
 }

}

.jumbotron-fluid {

 padding-right: 0;
 padding-left: 0;
 border-radius: 0;

}

.alert {

 position: relative;
 padding: 0.75rem 1.25rem;
 margin-bottom: 1rem;
 border: 1px solid transparent;
 border-radius: 0.25rem;

}

.alert-heading {

 color: inherit;

}

.alert-link {

 font-weight: 700;

}

.alert-dismissible {

 padding-right: 4rem;

}

.alert-dismissible .close {

 position: absolute;
 top: 0;
 right: 0;
 padding: 0.75rem 1.25rem;
 color: inherit;

}

.alert-primary {

 color: #004085;
 background-color: #cce5ff;
 border-color: #b8daff;

}

.alert-primary hr {

 border-top-color: #9fcdff;

}

.alert-primary .alert-link {

 color: #002752;

}

.alert-secondary {

 color: #383d41;
 background-color: #e2e3e5;
 border-color: #d6d8db;

}

.alert-secondary hr {

 border-top-color: #c8cbcf;

}

.alert-secondary .alert-link {

 color: #202326;

}

.alert-success {

 color: #155724;
 background-color: #d4edda;
 border-color: #c3e6cb;

}

.alert-success hr {

 border-top-color: #b1dfbb;

}

.alert-success .alert-link {

 color: #0b2e13;

}

.alert-info {

 color: #0c5460;
 background-color: #d1ecf1;
 border-color: #bee5eb;

}

.alert-info hr {

 border-top-color: #abdde5;

}

.alert-info .alert-link {

 color: #062c33;

}

.alert-warning {

 color: #856404;
 background-color: #fff3cd;
 border-color: #ffeeba;

}

.alert-warning hr {

 border-top-color: #ffe8a1;

}

.alert-warning .alert-link {

 color: #533f03;

}

.alert-danger {

 color: #721c24;
 background-color: #f8d7da;
 border-color: #f5c6cb;

}

.alert-danger hr {

 border-top-color: #f1b0b7;

}

.alert-danger .alert-link {

 color: #491217;

}

.alert-light {

 color: #818182;
 background-color: #fefefe;
 border-color: #fdfdfe;

}

.alert-light hr {

 border-top-color: #ececf6;

}

.alert-light .alert-link {

 color: #686868;

}

.alert-dark {

 color: #1b1e21;
 background-color: #d6d8d9;
 border-color: #c6c8ca;

}

.alert-dark hr {

 border-top-color: #b9bbbe;

}

.alert-dark .alert-link {

 color: #040505;

}

@-webkit-keyframes progress-bar-stripes {

 from {
   background-position: 1rem 0;
 }
 to {
   background-position: 0 0;
 }

}

@keyframes progress-bar-stripes {

 from {
   background-position: 1rem 0;
 }
 to {
   background-position: 0 0;
 }

}

.progress {

 display: -ms-flexbox;
 display: flex;
 height: 1rem;
 overflow: hidden;
 font-size: 0.75rem;
 background-color: #e9ecef;
 border-radius: 0.25rem;

}

.progress-bar {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;
 -ms-flex-pack: center;
 justify-content: center;
 color: #fff;
 text-align: center;
 white-space: nowrap;
 background-color: #007bff;
 transition: width 0.6s ease;

}

@media screen and (prefers-reduced-motion: reduce) {

 .progress-bar {
   transition: none;
 }

}

.progress-bar-striped {

 background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
 background-size: 1rem 1rem;

}

.progress-bar-animated {

 -webkit-animation: progress-bar-stripes 1s linear infinite;
 animation: progress-bar-stripes 1s linear infinite;

}

.media {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: start;
 align-items: flex-start;

}

.media-body {

 -ms-flex: 1;
 flex: 1;

}

.list-group {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;
 padding-left: 0;
 margin-bottom: 0;

}

.list-group-item-action {

 width: 100%;
 color: #495057;
 text-align: inherit;

}

.list-group-item-action:hover, .list-group-item-action:focus {

 color: #495057;
 text-decoration: none;
 background-color: #f8f9fa;

}

.list-group-item-action:active {

 color: #212529;
 background-color: #e9ecef;

}

.list-group-item {

 position: relative;
 display: block;
 padding: 0.75rem 1.25rem;
 margin-bottom: -1px;
 background-color: #fff;
 border: 1px solid rgba(0, 0, 0, 0.125);

}

.list-group-item:first-child {

 border-top-left-radius: 0.25rem;
 border-top-right-radius: 0.25rem;

}

.list-group-item:last-child {

 margin-bottom: 0;
 border-bottom-right-radius: 0.25rem;
 border-bottom-left-radius: 0.25rem;

}

.list-group-item:hover, .list-group-item:focus {

 z-index: 1;
 text-decoration: none;

}

.list-group-item.disabled, .list-group-item:disabled {

 color: #6c757d;
 background-color: #fff;

}

.list-group-item.active {

 z-index: 2;
 color: #fff;
 background-color: #007bff;
 border-color: #007bff;

}

.list-group-flush .list-group-item {

 border-right: 0;
 border-left: 0;
 border-radius: 0;

}

.list-group-flush:first-child .list-group-item:first-child {

 border-top: 0;

}

.list-group-flush:last-child .list-group-item:last-child {

 border-bottom: 0;

}

.list-group-item-primary {

 color: #004085;
 background-color: #b8daff;

}

.list-group-item-primary.list-group-item-action:hover, .list-group-item-primary.list-group-item-action:focus {

 color: #004085;
 background-color: #9fcdff;

}

.list-group-item-primary.list-group-item-action.active {

 color: #fff;
 background-color: #004085;
 border-color: #004085;

}

.list-group-item-secondary {

 color: #383d41;
 background-color: #d6d8db;

}

.list-group-item-secondary.list-group-item-action:hover, .list-group-item-secondary.list-group-item-action:focus {

 color: #383d41;
 background-color: #c8cbcf;

}

.list-group-item-secondary.list-group-item-action.active {

 color: #fff;
 background-color: #383d41;
 border-color: #383d41;

}

.list-group-item-success {

 color: #155724;
 background-color: #c3e6cb;

}

.list-group-item-success.list-group-item-action:hover, .list-group-item-success.list-group-item-action:focus {

 color: #155724;
 background-color: #b1dfbb;

}

.list-group-item-success.list-group-item-action.active {

 color: #fff;
 background-color: #155724;
 border-color: #155724;

}

.list-group-item-info {

 color: #0c5460;
 background-color: #bee5eb;

}

.list-group-item-info.list-group-item-action:hover, .list-group-item-info.list-group-item-action:focus {

 color: #0c5460;
 background-color: #abdde5;

}

.list-group-item-info.list-group-item-action.active {

 color: #fff;
 background-color: #0c5460;
 border-color: #0c5460;

}

.list-group-item-warning {

 color: #856404;
 background-color: #ffeeba;

}

.list-group-item-warning.list-group-item-action:hover, .list-group-item-warning.list-group-item-action:focus {

 color: #856404;
 background-color: #ffe8a1;

}

.list-group-item-warning.list-group-item-action.active {

 color: #fff;
 background-color: #856404;
 border-color: #856404;

}

.list-group-item-danger {

 color: #721c24;
 background-color: #f5c6cb;

}

.list-group-item-danger.list-group-item-action:hover, .list-group-item-danger.list-group-item-action:focus {

 color: #721c24;
 background-color: #f1b0b7;

}

.list-group-item-danger.list-group-item-action.active {

 color: #fff;
 background-color: #721c24;
 border-color: #721c24;

}

.list-group-item-light {

 color: #818182;
 background-color: #fdfdfe;

}

.list-group-item-light.list-group-item-action:hover, .list-group-item-light.list-group-item-action:focus {

 color: #818182;
 background-color: #ececf6;

}

.list-group-item-light.list-group-item-action.active {

 color: #fff;
 background-color: #818182;
 border-color: #818182;

}

.list-group-item-dark {

 color: #1b1e21;
 background-color: #c6c8ca;

}

.list-group-item-dark.list-group-item-action:hover, .list-group-item-dark.list-group-item-action:focus {

 color: #1b1e21;
 background-color: #b9bbbe;

}

.list-group-item-dark.list-group-item-action.active {

 color: #fff;
 background-color: #1b1e21;
 border-color: #1b1e21;

}

.close {

 float: right;
 font-size: 1.5rem;
 font-weight: 700;
 line-height: 1;
 color: #000;
 text-shadow: 0 1px 0 #fff;
 opacity: .5;

}

.close:not(:disabled):not(.disabled) {

 cursor: pointer;

}

.close:not(:disabled):not(.disabled):hover, .close:not(:disabled):not(.disabled):focus {

 color: #000;
 text-decoration: none;
 opacity: .75;

}

button.close {

 padding: 0;
 background-color: transparent;
 border: 0;
 -webkit-appearance: none;

}

.modal-open {

 overflow: hidden;

}

.modal-open .modal {

 overflow-x: hidden;
 overflow-y: auto;

}

.modal {

 position: fixed;
 top: 0;
 right: 0;
 bottom: 0;
 left: 0;
 z-index: 1050;
 display: none;
 overflow: hidden;
 outline: 0;

}

.modal-dialog {

 position: relative;
 width: auto;
 margin: 0.5rem;
 pointer-events: none;

}

.modal.fade .modal-dialog {

 transition: -webkit-transform 0.3s ease-out;
 transition: transform 0.3s ease-out;
 transition: transform 0.3s ease-out, -webkit-transform 0.3s ease-out;
 -webkit-transform: translate(0, -25%);
 transform: translate(0, -25%);

}

@media screen and (prefers-reduced-motion: reduce) {

 .modal.fade .modal-dialog {
   transition: none;
 }

}

.modal.show .modal-dialog {

 -webkit-transform: translate(0, 0);
 transform: translate(0, 0);

}

.modal-dialog-centered {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: center;
 align-items: center;
 min-height: calc(100% - (0.5rem * 2));

}

.modal-dialog-centered::before {

 display: block;
 height: calc(100vh - (0.5rem * 2));
 content: "";

}

.modal-content {

 position: relative;
 display: -ms-flexbox;
 display: flex;
 -ms-flex-direction: column;
 flex-direction: column;
 width: 100%;
 pointer-events: auto;
 background-color: #fff;
 background-clip: padding-box;
 border: 1px solid rgba(0, 0, 0, 0.2);
 border-radius: 0.3rem;
 outline: 0;

}

.modal-backdrop {

 position: fixed;
 top: 0;
 right: 0;
 bottom: 0;
 left: 0;
 z-index: 1040;
 background-color: #000;

}

.modal-backdrop.fade {

 opacity: 0;

}

.modal-backdrop.show {

 opacity: 0.5;

}

.modal-header {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: start;
 align-items: flex-start;
 -ms-flex-pack: justify;
 justify-content: space-between;
 padding: 1rem;
 border-bottom: 1px solid #e9ecef;
 border-top-left-radius: 0.3rem;
 border-top-right-radius: 0.3rem;

}

.modal-header .close {

 padding: 1rem;
 margin: -1rem -1rem -1rem auto;

}

.modal-title {

 margin-bottom: 0;
 line-height: 1.5;

}

.modal-body {

 position: relative;
 -ms-flex: 1 1 auto;
 flex: 1 1 auto;
 padding: 1rem;

}

.modal-footer {

 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: center;
 align-items: center;
 -ms-flex-pack: end;
 justify-content: flex-end;
 padding: 1rem;
 border-top: 1px solid #e9ecef;

}

.modal-footer > :not(:first-child) {

 margin-left: .25rem;

}

.modal-footer > :not(:last-child) {

 margin-right: .25rem;

}

.modal-scrollbar-measure {

 position: absolute;
 top: -9999px;
 width: 50px;
 height: 50px;
 overflow: scroll;

}

@media (min-width: 576px) {

 .modal-dialog {
   max-width: 500px;
   margin: 1.75rem auto;
 }
 .modal-dialog-centered {
   min-height: calc(100% - (1.75rem * 2));
 }
 .modal-dialog-centered::before {
   height: calc(100vh - (1.75rem * 2));
 }
 .modal-sm {
   max-width: 300px;
 }

}

@media (min-width: 992px) {

 .modal-lg {
   max-width: 800px;
 }

}

.tooltip {

 position: absolute;
 z-index: 1070;
 display: block;
 margin: 0;
 font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
 font-style: normal;
 font-weight: 400;
 line-height: 1.5;
 text-align: left;
 text-align: start;
 text-decoration: none;
 text-shadow: none;
 text-transform: none;
 letter-spacing: normal;
 word-break: normal;
 word-spacing: normal;
 white-space: normal;
 line-break: auto;
 font-size: 0.875rem;
 word-wrap: break-word;
 opacity: 0;

}

.tooltip.show {

 opacity: 0.9;

}

.tooltip .arrow {

 position: absolute;
 display: block;
 width: 0.8rem;
 height: 0.4rem;

}

.tooltip .arrow::before {

 position: absolute;
 content: "";
 border-color: transparent;
 border-style: solid;

}

.bs-tooltip-top, .bs-tooltip-auto[x-placement^="top"] {

 padding: 0.4rem 0;

}

.bs-tooltip-top .arrow, .bs-tooltip-auto[x-placement^="top"] .arrow {

 bottom: 0;

}

.bs-tooltip-top .arrow::before, .bs-tooltip-auto[x-placement^="top"] .arrow::before {

 top: 0;
 border-width: 0.4rem 0.4rem 0;
 border-top-color: #000;

}

.bs-tooltip-right, .bs-tooltip-auto[x-placement^="right"] {

 padding: 0 0.4rem;

}

.bs-tooltip-right .arrow, .bs-tooltip-auto[x-placement^="right"] .arrow {

 left: 0;
 width: 0.4rem;
 height: 0.8rem;

}

.bs-tooltip-right .arrow::before, .bs-tooltip-auto[x-placement^="right"] .arrow::before {

 right: 0;
 border-width: 0.4rem 0.4rem 0.4rem 0;
 border-right-color: #000;

}

.bs-tooltip-bottom, .bs-tooltip-auto[x-placement^="bottom"] {

 padding: 0.4rem 0;

}

.bs-tooltip-bottom .arrow, .bs-tooltip-auto[x-placement^="bottom"] .arrow {

 top: 0;

}

.bs-tooltip-bottom .arrow::before, .bs-tooltip-auto[x-placement^="bottom"] .arrow::before {

 bottom: 0;
 border-width: 0 0.4rem 0.4rem;
 border-bottom-color: #000;

}

.bs-tooltip-left, .bs-tooltip-auto[x-placement^="left"] {

 padding: 0 0.4rem;

}

.bs-tooltip-left .arrow, .bs-tooltip-auto[x-placement^="left"] .arrow {

 right: 0;
 width: 0.4rem;
 height: 0.8rem;

}

.bs-tooltip-left .arrow::before, .bs-tooltip-auto[x-placement^="left"] .arrow::before {

 left: 0;
 border-width: 0.4rem 0 0.4rem 0.4rem;
 border-left-color: #000;

}

.tooltip-inner {

 max-width: 200px;
 padding: 0.25rem 0.5rem;
 color: #fff;
 text-align: center;
 background-color: #000;
 border-radius: 0.25rem;

}

.popover {

 position: absolute;
 top: 0;
 left: 0;
 z-index: 1060;
 display: block;
 max-width: 276px;
 font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
 font-style: normal;
 font-weight: 400;
 line-height: 1.5;
 text-align: left;
 text-align: start;
 text-decoration: none;
 text-shadow: none;
 text-transform: none;
 letter-spacing: normal;
 word-break: normal;
 word-spacing: normal;
 white-space: normal;
 line-break: auto;
 font-size: 0.875rem;
 word-wrap: break-word;
 background-color: #fff;
 background-clip: padding-box;
 border: 1px solid rgba(0, 0, 0, 0.2);
 border-radius: 0.3rem;

}

.popover .arrow {

 position: absolute;
 display: block;
 width: 1rem;
 height: 0.5rem;
 margin: 0 0.3rem;

}

.popover .arrow::before, .popover .arrow::after {

 position: absolute;
 display: block;
 content: "";
 border-color: transparent;
 border-style: solid;

}

.bs-popover-top, .bs-popover-auto[x-placement^="top"] {

 margin-bottom: 0.5rem;

}

.bs-popover-top .arrow, .bs-popover-auto[x-placement^="top"] .arrow {

 bottom: calc((0.5rem + 1px) * -1);

}

.bs-popover-top .arrow::before, .bs-popover-auto[x-placement^="top"] .arrow::before, .bs-popover-top .arrow::after, .bs-popover-auto[x-placement^="top"] .arrow::after {

 border-width: 0.5rem 0.5rem 0;

}

.bs-popover-top .arrow::before, .bs-popover-auto[x-placement^="top"] .arrow::before {

 bottom: 0;
 border-top-color: rgba(0, 0, 0, 0.25);

}


.bs-popover-top .arrow::after, .bs-popover-auto[x-placement^="top"] .arrow::after {

 bottom: 1px;
 border-top-color: #fff;

}

.bs-popover-right, .bs-popover-auto[x-placement^="right"] {

 margin-left: 0.5rem;

}

.bs-popover-right .arrow, .bs-popover-auto[x-placement^="right"] .arrow {

 left: calc((0.5rem + 1px) * -1);
 width: 0.5rem;
 height: 1rem;
 margin: 0.3rem 0;

}

.bs-popover-right .arrow::before, .bs-popover-auto[x-placement^="right"] .arrow::before, .bs-popover-right .arrow::after, .bs-popover-auto[x-placement^="right"] .arrow::after {

 border-width: 0.5rem 0.5rem 0.5rem 0;

}

.bs-popover-right .arrow::before, .bs-popover-auto[x-placement^="right"] .arrow::before {

 left: 0;
 border-right-color: rgba(0, 0, 0, 0.25);

}


.bs-popover-right .arrow::after, .bs-popover-auto[x-placement^="right"] .arrow::after {

 left: 1px;
 border-right-color: #fff;

}

.bs-popover-bottom, .bs-popover-auto[x-placement^="bottom"] {

 margin-top: 0.5rem;

}

.bs-popover-bottom .arrow, .bs-popover-auto[x-placement^="bottom"] .arrow {

 top: calc((0.5rem + 1px) * -1);

}

.bs-popover-bottom .arrow::before, .bs-popover-auto[x-placement^="bottom"] .arrow::before, .bs-popover-bottom .arrow::after, .bs-popover-auto[x-placement^="bottom"] .arrow::after {

 border-width: 0 0.5rem 0.5rem 0.5rem;

}

.bs-popover-bottom .arrow::before, .bs-popover-auto[x-placement^="bottom"] .arrow::before {

 top: 0;
 border-bottom-color: rgba(0, 0, 0, 0.25);

}


.bs-popover-bottom .arrow::after, .bs-popover-auto[x-placement^="bottom"] .arrow::after {

 top: 1px;
 border-bottom-color: #fff;

}

.bs-popover-bottom .popover-header::before, .bs-popover-auto[x-placement^="bottom"] .popover-header::before {

 position: absolute;
 top: 0;
 left: 50%;
 display: block;
 width: 1rem;
 margin-left: -0.5rem;
 content: "";
 border-bottom: 1px solid #f7f7f7;

}

.bs-popover-left, .bs-popover-auto[x-placement^="left"] {

 margin-right: 0.5rem;

}

.bs-popover-left .arrow, .bs-popover-auto[x-placement^="left"] .arrow {

 right: calc((0.5rem + 1px) * -1);
 width: 0.5rem;
 height: 1rem;
 margin: 0.3rem 0;

}

.bs-popover-left .arrow::before, .bs-popover-auto[x-placement^="left"] .arrow::before, .bs-popover-left .arrow::after, .bs-popover-auto[x-placement^="left"] .arrow::after {

 border-width: 0.5rem 0 0.5rem 0.5rem;

}

.bs-popover-left .arrow::before, .bs-popover-auto[x-placement^="left"] .arrow::before {

 right: 0;
 border-left-color: rgba(0, 0, 0, 0.25);

}


.bs-popover-left .arrow::after, .bs-popover-auto[x-placement^="left"] .arrow::after {

 right: 1px;
 border-left-color: #fff;

}

.popover-header {

 padding: 0.5rem 0.75rem;
 margin-bottom: 0;
 font-size: 1rem;
 color: inherit;
 background-color: #f7f7f7;
 border-bottom: 1px solid #ebebeb;
 border-top-left-radius: calc(0.3rem - 1px);
 border-top-right-radius: calc(0.3rem - 1px);

}

.popover-header:empty {

 display: none;

}

.popover-body {

 padding: 0.5rem 0.75rem;
 color: #212529;

}

.carousel {

 position: relative;

}

.carousel-inner {

 position: relative;
 width: 100%;
 overflow: hidden;

}

.carousel-item {

 position: relative;
 display: none;
 -ms-flex-align: center;
 align-items: center;
 width: 100%;
 -webkit-backface-visibility: hidden;
 backface-visibility: hidden;
 -webkit-perspective: 1000px;
 perspective: 1000px;

}

.carousel-item.active, .carousel-item-next, .carousel-item-prev {

 display: block;
 transition: -webkit-transform 0.6s ease;
 transition: transform 0.6s ease;
 transition: transform 0.6s ease, -webkit-transform 0.6s ease;

}

@media screen and (prefers-reduced-motion: reduce) {

 .carousel-item.active,
 .carousel-item-next,
 .carousel-item-prev {
   transition: none;
 }

}

.carousel-item-next, .carousel-item-prev {

 position: absolute;
 top: 0;

}

.carousel-item-next.carousel-item-left, .carousel-item-prev.carousel-item-right {

 -webkit-transform: translateX(0);
 transform: translateX(0);

}

@supports ((-webkit-transform-style: preserve-3d) or (transform-style: preserve-3d)) {

 .carousel-item-next.carousel-item-left,
 .carousel-item-prev.carousel-item-right {
   -webkit-transform: translate3d(0, 0, 0);
   transform: translate3d(0, 0, 0);
 }

}

.carousel-item-next, .active.carousel-item-right {

 -webkit-transform: translateX(100%);
 transform: translateX(100%);

}

@supports ((-webkit-transform-style: preserve-3d) or (transform-style: preserve-3d)) {

 .carousel-item-next,
 .active.carousel-item-right {
   -webkit-transform: translate3d(100%, 0, 0);
   transform: translate3d(100%, 0, 0);
 }

}

.carousel-item-prev, .active.carousel-item-left {

 -webkit-transform: translateX(-100%);
 transform: translateX(-100%);

}

@supports ((-webkit-transform-style: preserve-3d) or (transform-style: preserve-3d)) {

 .carousel-item-prev,
 .active.carousel-item-left {
   -webkit-transform: translate3d(-100%, 0, 0);
   transform: translate3d(-100%, 0, 0);
 }

}

.carousel-fade .carousel-item {

 opacity: 0;
 transition-duration: .6s;
 transition-property: opacity;

}

.carousel-fade .carousel-item.active, .carousel-fade .carousel-item-next.carousel-item-left, .carousel-fade .carousel-item-prev.carousel-item-right {

 opacity: 1;

}

.carousel-fade .active.carousel-item-left, .carousel-fade .active.carousel-item-right {

 opacity: 0;

}

.carousel-fade .carousel-item-next, .carousel-fade .carousel-item-prev, .carousel-fade .carousel-item.active, .carousel-fade .active.carousel-item-left, .carousel-fade .active.carousel-item-prev {

 -webkit-transform: translateX(0);
 transform: translateX(0);

}

@supports ((-webkit-transform-style: preserve-3d) or (transform-style: preserve-3d)) {

 .carousel-fade .carousel-item-next,
 .carousel-fade .carousel-item-prev,
 .carousel-fade .carousel-item.active,
 .carousel-fade .active.carousel-item-left,
 .carousel-fade .active.carousel-item-prev {
   -webkit-transform: translate3d(0, 0, 0);
   transform: translate3d(0, 0, 0);
 }

}

.carousel-control-prev, .carousel-control-next {

 position: absolute;
 top: 0;
 bottom: 0;
 display: -ms-flexbox;
 display: flex;
 -ms-flex-align: center;
 align-items: center;
 -ms-flex-pack: center;
 justify-content: center;
 width: 15%;
 color: #fff;
 text-align: center;
 opacity: 0.5;

}

.carousel-control-prev:hover, .carousel-control-prev:focus, .carousel-control-next:hover, .carousel-control-next:focus {

 color: #fff;
 text-decoration: none;
 outline: 0;
 opacity: .9;

}

.carousel-control-prev {

 left: 0;

}

.carousel-control-next {

 right: 0;

}

.carousel-control-prev-icon, .carousel-control-next-icon {

 display: inline-block;
 width: 20px;
 height: 20px;
 background: transparent no-repeat center center;
 background-size: 100% 100%;

}

.carousel-control-prev-icon {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' viewBox='0 0 8 8'%3E%3Cpath d='M5.25 0l-4 4 4 4 1.5-1.5-2.5-2.5 2.5-2.5-1.5-1.5z'/%3E%3C/svg%3E");

}

.carousel-control-next-icon {

 background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' viewBox='0 0 8 8'%3E%3Cpath d='M2.75 0l-1.5 1.5 2.5 2.5-2.5 2.5 1.5 1.5 4-4-4-4z'/%3E%3C/svg%3E");

}

.carousel-indicators {

 position: absolute;
 right: 0;
 bottom: 10px;
 left: 0;
 z-index: 15;
 display: -ms-flexbox;
 display: flex;
 -ms-flex-pack: center;
 justify-content: center;
 padding-left: 0;
 margin-right: 15%;
 margin-left: 15%;
 list-style: none;

}

.carousel-indicators li {

 position: relative;
 -ms-flex: 0 1 auto;
 flex: 0 1 auto;
 width: 30px;
 height: 3px;
 margin-right: 3px;
 margin-left: 3px;
 text-indent: -999px;
 cursor: pointer;
 background-color: rgba(255, 255, 255, 0.5);

}

.carousel-indicators li::before {

 position: absolute;
 top: -10px;
 left: 0;
 display: inline-block;
 width: 100%;
 height: 10px;
 content: "";

}

.carousel-indicators li::after {

 position: absolute;
 bottom: -10px;
 left: 0;
 display: inline-block;
 width: 100%;
 height: 10px;
 content: "";

}

.carousel-indicators .active {

 background-color: #fff;

}

.carousel-caption {

 position: absolute;
 right: 15%;
 bottom: 20px;
 left: 15%;
 z-index: 10;
 padding-top: 20px;
 padding-bottom: 20px;
 color: #fff;
 text-align: center;

}

.align-baseline {

 vertical-align: baseline !important;

}

.align-top {

 vertical-align: top !important;

}

.align-middle {

 vertical-align: middle !important;

}

.align-bottom {

 vertical-align: bottom !important;

}

.align-text-bottom {

 vertical-align: text-bottom !important;

}

.align-text-top {

 vertical-align: text-top !important;

}

.bg-primary {

 background-color: #007bff !important;

}

a.bg-primary:hover, a.bg-primary:focus, button.bg-primary:hover, button.bg-primary:focus {

 background-color: #0062cc !important;

}

.bg-secondary {

 background-color: #6c757d !important;

}

a.bg-secondary:hover, a.bg-secondary:focus, button.bg-secondary:hover, button.bg-secondary:focus {

 background-color: #545b62 !important;

}

.bg-success {

 background-color: #28a745 !important;

}

a.bg-success:hover, a.bg-success:focus, button.bg-success:hover, button.bg-success:focus {

 background-color: #1e7e34 !important;

}

.bg-info {

 background-color: #17a2b8 !important;

}

a.bg-info:hover, a.bg-info:focus, button.bg-info:hover, button.bg-info:focus {

 background-color: #117a8b !important;

}

.bg-warning {

 background-color: #ffc107 !important;

}

a.bg-warning:hover, a.bg-warning:focus, button.bg-warning:hover, button.bg-warning:focus {

 background-color: #d39e00 !important;

}

.bg-danger {

 background-color: #dc3545 !important;

}

a.bg-danger:hover, a.bg-danger:focus, button.bg-danger:hover, button.bg-danger:focus {

 background-color: #bd2130 !important;

}

.bg-light {

 background-color: #f8f9fa !important;

}

a.bg-light:hover, a.bg-light:focus, button.bg-light:hover, button.bg-light:focus {

 background-color: #dae0e5 !important;

}

.bg-dark {

 background-color: #343a40 !important;

}

a.bg-dark:hover, a.bg-dark:focus, button.bg-dark:hover, button.bg-dark:focus {

 background-color: #1d2124 !important;

}

.bg-white {

 background-color: #fff !important;

}

.bg-transparent {

 background-color: transparent !important;

}

.border {

 border: 1px solid #dee2e6 !important;

}

.border-top {

 border-top: 1px solid #dee2e6 !important;

}

.border-right {

 border-right: 1px solid #dee2e6 !important;

}

.border-bottom {

 border-bottom: 1px solid #dee2e6 !important;

}

.border-left {

 border-left: 1px solid #dee2e6 !important;

}

.border-0 {

 border: 0 !important;

}

.border-top-0 {

 border-top: 0 !important;

}

.border-right-0 {

 border-right: 0 !important;

}

.border-bottom-0 {

 border-bottom: 0 !important;

}

.border-left-0 {

 border-left: 0 !important;

}

.border-primary {

 border-color: #007bff !important;

}

.border-secondary {

 border-color: #6c757d !important;

}

.border-success {

 border-color: #28a745 !important;

}

.border-info {

 border-color: #17a2b8 !important;

}

.border-warning {

 border-color: #ffc107 !important;

}

.border-danger {

 border-color: #dc3545 !important;

}

.border-light {

 border-color: #f8f9fa !important;

}

.border-dark {

 border-color: #343a40 !important;

}

.border-white {

 border-color: #fff !important;

}

.rounded {

 border-radius: 0.25rem !important;

}

.rounded-top {

 border-top-left-radius: 0.25rem !important;
 border-top-right-radius: 0.25rem !important;

}

.rounded-right {

 border-top-right-radius: 0.25rem !important;
 border-bottom-right-radius: 0.25rem !important;

}

.rounded-bottom {

 border-bottom-right-radius: 0.25rem !important;
 border-bottom-left-radius: 0.25rem !important;

}

.rounded-left {

 border-top-left-radius: 0.25rem !important;
 border-bottom-left-radius: 0.25rem !important;

}

.rounded-circle {

 border-radius: 50% !important;

}

.rounded-0 {

 border-radius: 0 !important;

}

.clearfix::after {

 display: block;
 clear: both;
 content: "";

}

.d-none {

 display: none !important;

}

.d-inline {

 display: inline !important;

}

.d-inline-block {

 display: inline-block !important;

}

.d-block {

 display: block !important;

}

.d-table {

 display: table !important;

}

.d-table-row {

 display: table-row !important;

}

.d-table-cell {

 display: table-cell !important;

}

.d-flex {

 display: -ms-flexbox !important;
 display: flex !important;

}

.d-inline-flex {

 display: -ms-inline-flexbox !important;
 display: inline-flex !important;

}

@media (min-width: 576px) {

 .d-sm-none {
   display: none !important;
 }
 .d-sm-inline {
   display: inline !important;
 }
 .d-sm-inline-block {
   display: inline-block !important;
 }
 .d-sm-block {
   display: block !important;
 }
 .d-sm-table {
   display: table !important;
 }
 .d-sm-table-row {
   display: table-row !important;
 }
 .d-sm-table-cell {
   display: table-cell !important;
 }
 .d-sm-flex {
   display: -ms-flexbox !important;
   display: flex !important;
 }
 .d-sm-inline-flex {
   display: -ms-inline-flexbox !important;
   display: inline-flex !important;
 }

}

@media (min-width: 768px) {

 .d-md-none {
   display: none !important;
 }
 .d-md-inline {
   display: inline !important;
 }
 .d-md-inline-block {
   display: inline-block !important;
 }
 .d-md-block {
   display: block !important;
 }
 .d-md-table {
   display: table !important;
 }
 .d-md-table-row {
   display: table-row !important;
 }
 .d-md-table-cell {
   display: table-cell !important;
 }
 .d-md-flex {
   display: -ms-flexbox !important;
   display: flex !important;
 }
 .d-md-inline-flex {
   display: -ms-inline-flexbox !important;
   display: inline-flex !important;
 }

}

@media (min-width: 992px) {

 .d-lg-none {
   display: none !important;
 }
 .d-lg-inline {
   display: inline !important;
 }
 .d-lg-inline-block {
   display: inline-block !important;
 }
 .d-lg-block {
   display: block !important;
 }
 .d-lg-table {
   display: table !important;
 }
 .d-lg-table-row {
   display: table-row !important;
 }
 .d-lg-table-cell {
   display: table-cell !important;
 }
 .d-lg-flex {
   display: -ms-flexbox !important;
   display: flex !important;
 }
 .d-lg-inline-flex {
   display: -ms-inline-flexbox !important;
   display: inline-flex !important;
 }

}

@media (min-width: 1200px) {

 .d-xl-none {
   display: none !important;
 }
 .d-xl-inline {
   display: inline !important;
 }
 .d-xl-inline-block {
   display: inline-block !important;
 }
 .d-xl-block {
   display: block !important;
 }
 .d-xl-table {
   display: table !important;
 }
 .d-xl-table-row {
   display: table-row !important;
 }
 .d-xl-table-cell {
   display: table-cell !important;
 }
 .d-xl-flex {
   display: -ms-flexbox !important;
   display: flex !important;
 }
 .d-xl-inline-flex {
   display: -ms-inline-flexbox !important;
   display: inline-flex !important;
 }

}

@media print {

 .d-print-none {
   display: none !important;
 }
 .d-print-inline {
   display: inline !important;
 }
 .d-print-inline-block {
   display: inline-block !important;
 }
 .d-print-block {
   display: block !important;
 }
 .d-print-table {
   display: table !important;
 }
 .d-print-table-row {
   display: table-row !important;
 }
 .d-print-table-cell {
   display: table-cell !important;
 }
 .d-print-flex {
   display: -ms-flexbox !important;
   display: flex !important;
 }
 .d-print-inline-flex {
   display: -ms-inline-flexbox !important;
   display: inline-flex !important;
 }

}

.embed-responsive {

 position: relative;
 display: block;
 width: 100%;
 padding: 0;
 overflow: hidden;

}

.embed-responsive::before {

 display: block;
 content: "";

}

.embed-responsive .embed-responsive-item, .embed-responsive iframe, .embed-responsive embed, .embed-responsive object, .embed-responsive video {

 position: absolute;
 top: 0;
 bottom: 0;
 left: 0;
 width: 100%;
 height: 100%;
 border: 0;

}

.embed-responsive-21by9::before {

 padding-top: 42.857143%;

}

.embed-responsive-16by9::before {

 padding-top: 56.25%;

}

.embed-responsive-4by3::before {

 padding-top: 75%;

}

.embed-responsive-1by1::before {

 padding-top: 100%;

}

.flex-row {

 -ms-flex-direction: row !important;
 flex-direction: row !important;

}

.flex-column {

 -ms-flex-direction: column !important;
 flex-direction: column !important;

}

.flex-row-reverse {

 -ms-flex-direction: row-reverse !important;
 flex-direction: row-reverse !important;

}

.flex-column-reverse {

 -ms-flex-direction: column-reverse !important;
 flex-direction: column-reverse !important;

}

.flex-wrap {

 -ms-flex-wrap: wrap !important;
 flex-wrap: wrap !important;

}

.flex-nowrap {

 -ms-flex-wrap: nowrap !important;
 flex-wrap: nowrap !important;

}

.flex-wrap-reverse {

 -ms-flex-wrap: wrap-reverse !important;
 flex-wrap: wrap-reverse !important;

}

.flex-fill {

 -ms-flex: 1 1 auto !important;
 flex: 1 1 auto !important;

}

.flex-grow-0 {

 -ms-flex-positive: 0 !important;
 flex-grow: 0 !important;

}

.flex-grow-1 {

 -ms-flex-positive: 1 !important;
 flex-grow: 1 !important;

}

.flex-shrink-0 {

 -ms-flex-negative: 0 !important;
 flex-shrink: 0 !important;

}

.flex-shrink-1 {

 -ms-flex-negative: 1 !important;
 flex-shrink: 1 !important;

}

.justify-content-start {

 -ms-flex-pack: start !important;
 justify-content: flex-start !important;

}

.justify-content-end {

 -ms-flex-pack: end !important;
 justify-content: flex-end !important;

}

.justify-content-center {

 -ms-flex-pack: center !important;
 justify-content: center !important;

}

.justify-content-between {

 -ms-flex-pack: justify !important;
 justify-content: space-between !important;

}

.justify-content-around {

 -ms-flex-pack: distribute !important;
 justify-content: space-around !important;

}

.align-items-start {

 -ms-flex-align: start !important;
 align-items: flex-start !important;

}

.align-items-end {

 -ms-flex-align: end !important;
 align-items: flex-end !important;

}

.align-items-center {

 -ms-flex-align: center !important;
 align-items: center !important;

}

.align-items-baseline {

 -ms-flex-align: baseline !important;
 align-items: baseline !important;

}

.align-items-stretch {

 -ms-flex-align: stretch !important;
 align-items: stretch !important;

}

.align-content-start {

 -ms-flex-line-pack: start !important;
 align-content: flex-start !important;

}

.align-content-end {

 -ms-flex-line-pack: end !important;
 align-content: flex-end !important;

}

.align-content-center {

 -ms-flex-line-pack: center !important;
 align-content: center !important;

}

.align-content-between {

 -ms-flex-line-pack: justify !important;
 align-content: space-between !important;

}

.align-content-around {

 -ms-flex-line-pack: distribute !important;
 align-content: space-around !important;

}

.align-content-stretch {

 -ms-flex-line-pack: stretch !important;
 align-content: stretch !important;

}

.align-self-auto {

 -ms-flex-item-align: auto !important;
 align-self: auto !important;

}

.align-self-start {

 -ms-flex-item-align: start !important;
 align-self: flex-start !important;

}

.align-self-end {

 -ms-flex-item-align: end !important;
 align-self: flex-end !important;

}

.align-self-center {

 -ms-flex-item-align: center !important;
 align-self: center !important;

}

.align-self-baseline {

 -ms-flex-item-align: baseline !important;
 align-self: baseline !important;

}

.align-self-stretch {

 -ms-flex-item-align: stretch !important;
 align-self: stretch !important;

}

@media (min-width: 576px) {

 .flex-sm-row {
   -ms-flex-direction: row !important;
   flex-direction: row !important;
 }
 .flex-sm-column {
   -ms-flex-direction: column !important;
   flex-direction: column !important;
 }
 .flex-sm-row-reverse {
   -ms-flex-direction: row-reverse !important;
   flex-direction: row-reverse !important;
 }
 .flex-sm-column-reverse {
   -ms-flex-direction: column-reverse !important;
   flex-direction: column-reverse !important;
 }
 .flex-sm-wrap {
   -ms-flex-wrap: wrap !important;
   flex-wrap: wrap !important;
 }
 .flex-sm-nowrap {
   -ms-flex-wrap: nowrap !important;
   flex-wrap: nowrap !important;
 }
 .flex-sm-wrap-reverse {
   -ms-flex-wrap: wrap-reverse !important;
   flex-wrap: wrap-reverse !important;
 }
 .flex-sm-fill {
   -ms-flex: 1 1 auto !important;
   flex: 1 1 auto !important;
 }
 .flex-sm-grow-0 {
   -ms-flex-positive: 0 !important;
   flex-grow: 0 !important;
 }
 .flex-sm-grow-1 {
   -ms-flex-positive: 1 !important;
   flex-grow: 1 !important;
 }
 .flex-sm-shrink-0 {
   -ms-flex-negative: 0 !important;
   flex-shrink: 0 !important;
 }
 .flex-sm-shrink-1 {
   -ms-flex-negative: 1 !important;
   flex-shrink: 1 !important;
 }
 .justify-content-sm-start {
   -ms-flex-pack: start !important;
   justify-content: flex-start !important;
 }
 .justify-content-sm-end {
   -ms-flex-pack: end !important;
   justify-content: flex-end !important;
 }
 .justify-content-sm-center {
   -ms-flex-pack: center !important;
   justify-content: center !important;
 }
 .justify-content-sm-between {
   -ms-flex-pack: justify !important;
   justify-content: space-between !important;
 }
 .justify-content-sm-around {
   -ms-flex-pack: distribute !important;
   justify-content: space-around !important;
 }
 .align-items-sm-start {
   -ms-flex-align: start !important;
   align-items: flex-start !important;
 }
 .align-items-sm-end {
   -ms-flex-align: end !important;
   align-items: flex-end !important;
 }
 .align-items-sm-center {
   -ms-flex-align: center !important;
   align-items: center !important;
 }
 .align-items-sm-baseline {
   -ms-flex-align: baseline !important;
   align-items: baseline !important;
 }
 .align-items-sm-stretch {
   -ms-flex-align: stretch !important;
   align-items: stretch !important;
 }
 .align-content-sm-start {
   -ms-flex-line-pack: start !important;
   align-content: flex-start !important;
 }
 .align-content-sm-end {
   -ms-flex-line-pack: end !important;
   align-content: flex-end !important;
 }
 .align-content-sm-center {
   -ms-flex-line-pack: center !important;
   align-content: center !important;
 }
 .align-content-sm-between {
   -ms-flex-line-pack: justify !important;
   align-content: space-between !important;
 }
 .align-content-sm-around {
   -ms-flex-line-pack: distribute !important;
   align-content: space-around !important;
 }
 .align-content-sm-stretch {
   -ms-flex-line-pack: stretch !important;
   align-content: stretch !important;
 }
 .align-self-sm-auto {
   -ms-flex-item-align: auto !important;
   align-self: auto !important;
 }
 .align-self-sm-start {
   -ms-flex-item-align: start !important;
   align-self: flex-start !important;
 }
 .align-self-sm-end {
   -ms-flex-item-align: end !important;
   align-self: flex-end !important;
 }
 .align-self-sm-center {
   -ms-flex-item-align: center !important;
   align-self: center !important;
 }
 .align-self-sm-baseline {
   -ms-flex-item-align: baseline !important;
   align-self: baseline !important;
 }
 .align-self-sm-stretch {
   -ms-flex-item-align: stretch !important;
   align-self: stretch !important;
 }

}

@media (min-width: 768px) {

 .flex-md-row {
   -ms-flex-direction: row !important;
   flex-direction: row !important;
 }
 .flex-md-column {
   -ms-flex-direction: column !important;
   flex-direction: column !important;
 }
 .flex-md-row-reverse {
   -ms-flex-direction: row-reverse !important;
   flex-direction: row-reverse !important;
 }
 .flex-md-column-reverse {
   -ms-flex-direction: column-reverse !important;
   flex-direction: column-reverse !important;
 }
 .flex-md-wrap {
   -ms-flex-wrap: wrap !important;
   flex-wrap: wrap !important;
 }
 .flex-md-nowrap {
   -ms-flex-wrap: nowrap !important;
   flex-wrap: nowrap !important;
 }
 .flex-md-wrap-reverse {
   -ms-flex-wrap: wrap-reverse !important;
   flex-wrap: wrap-reverse !important;
 }
 .flex-md-fill {
   -ms-flex: 1 1 auto !important;
   flex: 1 1 auto !important;
 }
 .flex-md-grow-0 {
   -ms-flex-positive: 0 !important;
   flex-grow: 0 !important;
 }
 .flex-md-grow-1 {
   -ms-flex-positive: 1 !important;
   flex-grow: 1 !important;
 }
 .flex-md-shrink-0 {
   -ms-flex-negative: 0 !important;
   flex-shrink: 0 !important;
 }
 .flex-md-shrink-1 {
   -ms-flex-negative: 1 !important;
   flex-shrink: 1 !important;
 }
 .justify-content-md-start {
   -ms-flex-pack: start !important;
   justify-content: flex-start !important;
 }
 .justify-content-md-end {
   -ms-flex-pack: end !important;
   justify-content: flex-end !important;
 }
 .justify-content-md-center {
   -ms-flex-pack: center !important;
   justify-content: center !important;
 }
 .justify-content-md-between {
   -ms-flex-pack: justify !important;
   justify-content: space-between !important;
 }
 .justify-content-md-around {
   -ms-flex-pack: distribute !important;
   justify-content: space-around !important;
 }
 .align-items-md-start {
   -ms-flex-align: start !important;
   align-items: flex-start !important;
 }
 .align-items-md-end {
   -ms-flex-align: end !important;
   align-items: flex-end !important;
 }
 .align-items-md-center {
   -ms-flex-align: center !important;
   align-items: center !important;
 }
 .align-items-md-baseline {
   -ms-flex-align: baseline !important;
   align-items: baseline !important;
 }
 .align-items-md-stretch {
   -ms-flex-align: stretch !important;
   align-items: stretch !important;
 }
 .align-content-md-start {
   -ms-flex-line-pack: start !important;
   align-content: flex-start !important;
 }
 .align-content-md-end {
   -ms-flex-line-pack: end !important;
   align-content: flex-end !important;
 }
 .align-content-md-center {
   -ms-flex-line-pack: center !important;
   align-content: center !important;
 }
 .align-content-md-between {
   -ms-flex-line-pack: justify !important;
   align-content: space-between !important;
 }
 .align-content-md-around {
   -ms-flex-line-pack: distribute !important;
   align-content: space-around !important;
 }
 .align-content-md-stretch {
   -ms-flex-line-pack: stretch !important;
   align-content: stretch !important;
 }
 .align-self-md-auto {
   -ms-flex-item-align: auto !important;
   align-self: auto !important;
 }
 .align-self-md-start {
   -ms-flex-item-align: start !important;
   align-self: flex-start !important;
 }
 .align-self-md-end {
   -ms-flex-item-align: end !important;
   align-self: flex-end !important;
 }
 .align-self-md-center {
   -ms-flex-item-align: center !important;
   align-self: center !important;
 }
 .align-self-md-baseline {
   -ms-flex-item-align: baseline !important;
   align-self: baseline !important;
 }
 .align-self-md-stretch {
   -ms-flex-item-align: stretch !important;
   align-self: stretch !important;
 }

}

@media (min-width: 992px) {

 .flex-lg-row {
   -ms-flex-direction: row !important;
   flex-direction: row !important;
 }
 .flex-lg-column {
   -ms-flex-direction: column !important;
   flex-direction: column !important;
 }
 .flex-lg-row-reverse {
   -ms-flex-direction: row-reverse !important;
   flex-direction: row-reverse !important;
 }
 .flex-lg-column-reverse {
   -ms-flex-direction: column-reverse !important;
   flex-direction: column-reverse !important;
 }
 .flex-lg-wrap {
   -ms-flex-wrap: wrap !important;
   flex-wrap: wrap !important;
 }
 .flex-lg-nowrap {
   -ms-flex-wrap: nowrap !important;
   flex-wrap: nowrap !important;
 }
 .flex-lg-wrap-reverse {
   -ms-flex-wrap: wrap-reverse !important;
   flex-wrap: wrap-reverse !important;
 }
 .flex-lg-fill {
   -ms-flex: 1 1 auto !important;
   flex: 1 1 auto !important;
 }
 .flex-lg-grow-0 {
   -ms-flex-positive: 0 !important;
   flex-grow: 0 !important;
 }
 .flex-lg-grow-1 {
   -ms-flex-positive: 1 !important;
   flex-grow: 1 !important;
 }
 .flex-lg-shrink-0 {
   -ms-flex-negative: 0 !important;
   flex-shrink: 0 !important;
 }
 .flex-lg-shrink-1 {
   -ms-flex-negative: 1 !important;
   flex-shrink: 1 !important;
 }
 .justify-content-lg-start {
   -ms-flex-pack: start !important;
   justify-content: flex-start !important;
 }
 .justify-content-lg-end {
   -ms-flex-pack: end !important;
   justify-content: flex-end !important;
 }
 .justify-content-lg-center {
   -ms-flex-pack: center !important;
   justify-content: center !important;
 }
 .justify-content-lg-between {
   -ms-flex-pack: justify !important;
   justify-content: space-between !important;
 }
 .justify-content-lg-around {
   -ms-flex-pack: distribute !important;
   justify-content: space-around !important;
 }
 .align-items-lg-start {
   -ms-flex-align: start !important;
   align-items: flex-start !important;
 }
 .align-items-lg-end {
   -ms-flex-align: end !important;
   align-items: flex-end !important;
 }
 .align-items-lg-center {
   -ms-flex-align: center !important;
   align-items: center !important;
 }
 .align-items-lg-baseline {
   -ms-flex-align: baseline !important;
   align-items: baseline !important;
 }
 .align-items-lg-stretch {
   -ms-flex-align: stretch !important;
   align-items: stretch !important;
 }
 .align-content-lg-start {
   -ms-flex-line-pack: start !important;
   align-content: flex-start !important;
 }
 .align-content-lg-end {
   -ms-flex-line-pack: end !important;
   align-content: flex-end !important;
 }
 .align-content-lg-center {
   -ms-flex-line-pack: center !important;
   align-content: center !important;
 }
 .align-content-lg-between {
   -ms-flex-line-pack: justify !important;
   align-content: space-between !important;
 }
 .align-content-lg-around {
   -ms-flex-line-pack: distribute !important;
   align-content: space-around !important;
 }
 .align-content-lg-stretch {
   -ms-flex-line-pack: stretch !important;
   align-content: stretch !important;
 }
 .align-self-lg-auto {
   -ms-flex-item-align: auto !important;
   align-self: auto !important;
 }
 .align-self-lg-start {
   -ms-flex-item-align: start !important;
   align-self: flex-start !important;
 }
 .align-self-lg-end {
   -ms-flex-item-align: end !important;
   align-self: flex-end !important;
 }
 .align-self-lg-center {
   -ms-flex-item-align: center !important;
   align-self: center !important;
 }
 .align-self-lg-baseline {
   -ms-flex-item-align: baseline !important;
   align-self: baseline !important;
 }
 .align-self-lg-stretch {
   -ms-flex-item-align: stretch !important;
   align-self: stretch !important;
 }

}

@media (min-width: 1200px) {

 .flex-xl-row {
   -ms-flex-direction: row !important;
   flex-direction: row !important;
 }
 .flex-xl-column {
   -ms-flex-direction: column !important;
   flex-direction: column !important;
 }
 .flex-xl-row-reverse {
   -ms-flex-direction: row-reverse !important;
   flex-direction: row-reverse !important;
 }
 .flex-xl-column-reverse {
   -ms-flex-direction: column-reverse !important;
   flex-direction: column-reverse !important;
 }
 .flex-xl-wrap {
   -ms-flex-wrap: wrap !important;
   flex-wrap: wrap !important;
 }
 .flex-xl-nowrap {
   -ms-flex-wrap: nowrap !important;
   flex-wrap: nowrap !important;
 }
 .flex-xl-wrap-reverse {
   -ms-flex-wrap: wrap-reverse !important;
   flex-wrap: wrap-reverse !important;
 }
 .flex-xl-fill {
   -ms-flex: 1 1 auto !important;
   flex: 1 1 auto !important;
 }
 .flex-xl-grow-0 {
   -ms-flex-positive: 0 !important;
   flex-grow: 0 !important;
 }
 .flex-xl-grow-1 {
   -ms-flex-positive: 1 !important;
   flex-grow: 1 !important;
 }
 .flex-xl-shrink-0 {
   -ms-flex-negative: 0 !important;
   flex-shrink: 0 !important;
 }
 .flex-xl-shrink-1 {
   -ms-flex-negative: 1 !important;
   flex-shrink: 1 !important;
 }
 .justify-content-xl-start {
   -ms-flex-pack: start !important;
   justify-content: flex-start !important;
 }
 .justify-content-xl-end {
   -ms-flex-pack: end !important;
   justify-content: flex-end !important;
 }
 .justify-content-xl-center {
   -ms-flex-pack: center !important;
   justify-content: center !important;
 }
 .justify-content-xl-between {
   -ms-flex-pack: justify !important;
   justify-content: space-between !important;
 }
 .justify-content-xl-around {
   -ms-flex-pack: distribute !important;
   justify-content: space-around !important;
 }
 .align-items-xl-start {
   -ms-flex-align: start !important;
   align-items: flex-start !important;
 }
 .align-items-xl-end {
   -ms-flex-align: end !important;
   align-items: flex-end !important;
 }
 .align-items-xl-center {
   -ms-flex-align: center !important;
   align-items: center !important;
 }
 .align-items-xl-baseline {
   -ms-flex-align: baseline !important;
   align-items: baseline !important;
 }
 .align-items-xl-stretch {
   -ms-flex-align: stretch !important;
   align-items: stretch !important;
 }
 .align-content-xl-start {
   -ms-flex-line-pack: start !important;
   align-content: flex-start !important;
 }
 .align-content-xl-end {
   -ms-flex-line-pack: end !important;
   align-content: flex-end !important;
 }
 .align-content-xl-center {
   -ms-flex-line-pack: center !important;
   align-content: center !important;
 }
 .align-content-xl-between {
   -ms-flex-line-pack: justify !important;
   align-content: space-between !important;
 }
 .align-content-xl-around {
   -ms-flex-line-pack: distribute !important;
   align-content: space-around !important;
 }
 .align-content-xl-stretch {
   -ms-flex-line-pack: stretch !important;
   align-content: stretch !important;
 }
 .align-self-xl-auto {
   -ms-flex-item-align: auto !important;
   align-self: auto !important;
 }
 .align-self-xl-start {
   -ms-flex-item-align: start !important;
   align-self: flex-start !important;
 }
 .align-self-xl-end {
   -ms-flex-item-align: end !important;
   align-self: flex-end !important;
 }
 .align-self-xl-center {
   -ms-flex-item-align: center !important;
   align-self: center !important;
 }
 .align-self-xl-baseline {
   -ms-flex-item-align: baseline !important;
   align-self: baseline !important;
 }
 .align-self-xl-stretch {
   -ms-flex-item-align: stretch !important;
   align-self: stretch !important;
 }

}

.float-left {

 float: left !important;

}

.float-right {

 float: right !important;

}

.float-none {

 float: none !important;

}

@media (min-width: 576px) {

 .float-sm-left {
   float: left !important;
 }
 .float-sm-right {
   float: right !important;
 }
 .float-sm-none {
   float: none !important;
 }

}

@media (min-width: 768px) {

 .float-md-left {
   float: left !important;
 }
 .float-md-right {
   float: right !important;
 }
 .float-md-none {
   float: none !important;
 }

}

@media (min-width: 992px) {

 .float-lg-left {
   float: left !important;
 }
 .float-lg-right {
   float: right !important;
 }
 .float-lg-none {
   float: none !important;
 }

}

@media (min-width: 1200px) {

 .float-xl-left {
   float: left !important;
 }
 .float-xl-right {
   float: right !important;
 }
 .float-xl-none {
   float: none !important;
 }

}

.position-static {

 position: static !important;

}

.position-relative {

 position: relative !important;

}

.position-absolute {

 position: absolute !important;

}

.position-fixed {

 position: fixed !important;

}

.position-sticky {

 position: -webkit-sticky !important;
 position: sticky !important;

}

.fixed-top {

 position: fixed;
 top: 0;
 right: 0;
 left: 0;
 z-index: 1030;

}

.fixed-bottom {

 position: fixed;
 right: 0;
 bottom: 0;
 left: 0;
 z-index: 1030;

}

@supports ((position: -webkit-sticky) or (position: sticky)) {

 .sticky-top {
   position: -webkit-sticky;
   position: sticky;
   top: 0;
   z-index: 1020;
 }

}

.sr-only {

 position: absolute;
 width: 1px;
 height: 1px;
 padding: 0;
 overflow: hidden;
 clip: rect(0, 0, 0, 0);
 white-space: nowrap;
 border: 0;

}

.sr-only-focusable:active, .sr-only-focusable:focus {

 position: static;
 width: auto;
 height: auto;
 overflow: visible;
 clip: auto;
 white-space: normal;

}

.shadow-sm {

 box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075) !important;

}

.shadow {

 box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15) !important;

}

.shadow-lg {

 box-shadow: 0 1rem 3rem rgba(0, 0, 0, 0.175) !important;

}

.shadow-none {

 box-shadow: none !important;

}

.w-25 {

 width: 25% !important;

}

.w-50 {

 width: 50% !important;

}

.w-75 {

 width: 75% !important;

}

.w-100 {

 width: 100% !important;

}

.w-auto {

 width: auto !important;

}

.h-25 {

 height: 25% !important;

}

.h-50 {

 height: 50% !important;

}

.h-75 {

 height: 75% !important;

}

.h-100 {

 height: 100% !important;

}

.h-auto {

 height: auto !important;

}

.mw-100 {

 max-width: 100% !important;

}

.mh-100 {

 max-height: 100% !important;

}

.m-0 {

 margin: 0 !important;

}

.mt-0, .my-0 {

 margin-top: 0 !important;

}

.mr-0, .mx-0 {

 margin-right: 0 !important;

}

.mb-0, .my-0 {

 margin-bottom: 0 !important;

}

.ml-0, .mx-0 {

 margin-left: 0 !important;

}

.m-1 {

 margin: 0.25rem !important;

}

.mt-1, .my-1 {

 margin-top: 0.25rem !important;

}

.mr-1, .mx-1 {

 margin-right: 0.25rem !important;

}

.mb-1, .my-1 {

 margin-bottom: 0.25rem !important;

}

.ml-1, .mx-1 {

 margin-left: 0.25rem !important;

}

.m-2 {

 margin: 0.5rem !important;

}

.mt-2, .my-2 {

 margin-top: 0.5rem !important;

}

.mr-2, .mx-2 {

 margin-right: 0.5rem !important;

}

.mb-2, .my-2 {

 margin-bottom: 0.5rem !important;

}

.ml-2, .mx-2 {

 margin-left: 0.5rem !important;

}

.m-3 {

 margin: 1rem !important;

}

.mt-3, .my-3 {

 margin-top: 1rem !important;

}

.mr-3, .mx-3 {

 margin-right: 1rem !important;

}

.mb-3, .my-3 {

 margin-bottom: 1rem !important;

}

.ml-3, .mx-3 {

 margin-left: 1rem !important;

}

.m-4 {

 margin: 1.5rem !important;

}

.mt-4, .my-4 {

 margin-top: 1.5rem !important;

}

.mr-4, .mx-4 {

 margin-right: 1.5rem !important;

}

.mb-4, .my-4 {

 margin-bottom: 1.5rem !important;

}

.ml-4, .mx-4 {

 margin-left: 1.5rem !important;

}

.m-5 {

 margin: 3rem !important;

}

.mt-5, .my-5 {

 margin-top: 3rem !important;

}

.mr-5, .mx-5 {

 margin-right: 3rem !important;

}

.mb-5, .my-5 {

 margin-bottom: 3rem !important;

}

.ml-5, .mx-5 {

 margin-left: 3rem !important;

}

.p-0 {

 padding: 0 !important;

}

.pt-0, .py-0 {

 padding-top: 0 !important;

}

.pr-0, .px-0 {

 padding-right: 0 !important;

}

.pb-0, .py-0 {

 padding-bottom: 0 !important;

}

.pl-0, .px-0 {

 padding-left: 0 !important;

}

.p-1 {

 padding: 0.25rem !important;

}

.pt-1, .py-1 {

 padding-top: 0.25rem !important;

}

.pr-1, .px-1 {

 padding-right: 0.25rem !important;

}

.pb-1, .py-1 {

 padding-bottom: 0.25rem !important;

}

.pl-1, .px-1 {

 padding-left: 0.25rem !important;

}

.p-2 {

 padding: 0.5rem !important;

}

.pt-2, .py-2 {

 padding-top: 0.5rem !important;

}

.pr-2, .px-2 {

 padding-right: 0.5rem !important;

}

.pb-2, .py-2 {

 padding-bottom: 0.5rem !important;

}

.pl-2, .px-2 {

 padding-left: 0.5rem !important;

}

.p-3 {

 padding: 1rem !important;

}

.pt-3, .py-3 {

 padding-top: 1rem !important;

}

.pr-3, .px-3 {

 padding-right: 1rem !important;

}

.pb-3, .py-3 {

 padding-bottom: 1rem !important;

}

.pl-3, .px-3 {

 padding-left: 1rem !important;

}

.p-4 {

 padding: 1.5rem !important;

}

.pt-4, .py-4 {

 padding-top: 1.5rem !important;

}

.pr-4, .px-4 {

 padding-right: 1.5rem !important;

}

.pb-4, .py-4 {

 padding-bottom: 1.5rem !important;

}

.pl-4, .px-4 {

 padding-left: 1.5rem !important;

}

.p-5 {

 padding: 3rem !important;

}

.pt-5, .py-5 {

 padding-top: 3rem !important;

}

.pr-5, .px-5 {

 padding-right: 3rem !important;

}

.pb-5, .py-5 {

 padding-bottom: 3rem !important;

}

.pl-5, .px-5 {

 padding-left: 3rem !important;

}

.m-auto {

 margin: auto !important;

}

.mt-auto, .my-auto {

 margin-top: auto !important;

}

.mr-auto, .mx-auto {

 margin-right: auto !important;

}

.mb-auto, .my-auto {

 margin-bottom: auto !important;

}

.ml-auto, .mx-auto {

 margin-left: auto !important;

}

@media (min-width: 576px) {

 .m-sm-0 {
   margin: 0 !important;
 }
 .mt-sm-0,
 .my-sm-0 {
   margin-top: 0 !important;
 }
 .mr-sm-0,
 .mx-sm-0 {
   margin-right: 0 !important;
 }
 .mb-sm-0,
 .my-sm-0 {
   margin-bottom: 0 !important;
 }
 .ml-sm-0,
 .mx-sm-0 {
   margin-left: 0 !important;
 }
 .m-sm-1 {
   margin: 0.25rem !important;
 }
 .mt-sm-1,
 .my-sm-1 {
   margin-top: 0.25rem !important;
 }
 .mr-sm-1,
 .mx-sm-1 {
   margin-right: 0.25rem !important;
 }
 .mb-sm-1,
 .my-sm-1 {
   margin-bottom: 0.25rem !important;
 }
 .ml-sm-1,
 .mx-sm-1 {
   margin-left: 0.25rem !important;
 }
 .m-sm-2 {
   margin: 0.5rem !important;
 }
 .mt-sm-2,
 .my-sm-2 {
   margin-top: 0.5rem !important;
 }
 .mr-sm-2,
 .mx-sm-2 {
   margin-right: 0.5rem !important;
 }
 .mb-sm-2,
 .my-sm-2 {
   margin-bottom: 0.5rem !important;
 }
 .ml-sm-2,
 .mx-sm-2 {
   margin-left: 0.5rem !important;
 }
 .m-sm-3 {
   margin: 1rem !important;
 }
 .mt-sm-3,
 .my-sm-3 {
   margin-top: 1rem !important;
 }
 .mr-sm-3,
 .mx-sm-3 {
   margin-right: 1rem !important;
 }
 .mb-sm-3,
 .my-sm-3 {
   margin-bottom: 1rem !important;
 }
 .ml-sm-3,
 .mx-sm-3 {
   margin-left: 1rem !important;
 }
 .m-sm-4 {
   margin: 1.5rem !important;
 }
 .mt-sm-4,
 .my-sm-4 {
   margin-top: 1.5rem !important;
 }
 .mr-sm-4,
 .mx-sm-4 {
   margin-right: 1.5rem !important;
 }
 .mb-sm-4,
 .my-sm-4 {
   margin-bottom: 1.5rem !important;
 }
 .ml-sm-4,
 .mx-sm-4 {
   margin-left: 1.5rem !important;
 }
 .m-sm-5 {
   margin: 3rem !important;
 }
 .mt-sm-5,
 .my-sm-5 {
   margin-top: 3rem !important;
 }
 .mr-sm-5,
 .mx-sm-5 {
   margin-right: 3rem !important;
 }
 .mb-sm-5,
 .my-sm-5 {
   margin-bottom: 3rem !important;
 }
 .ml-sm-5,
 .mx-sm-5 {
   margin-left: 3rem !important;
 }
 .p-sm-0 {
   padding: 0 !important;
 }
 .pt-sm-0,
 .py-sm-0 {
   padding-top: 0 !important;
 }
 .pr-sm-0,
 .px-sm-0 {
   padding-right: 0 !important;
 }
 .pb-sm-0,
 .py-sm-0 {
   padding-bottom: 0 !important;
 }
 .pl-sm-0,
 .px-sm-0 {
   padding-left: 0 !important;
 }
 .p-sm-1 {
   padding: 0.25rem !important;
 }
 .pt-sm-1,
 .py-sm-1 {
   padding-top: 0.25rem !important;
 }
 .pr-sm-1,
 .px-sm-1 {
   padding-right: 0.25rem !important;
 }
 .pb-sm-1,
 .py-sm-1 {
   padding-bottom: 0.25rem !important;
 }
 .pl-sm-1,
 .px-sm-1 {
   padding-left: 0.25rem !important;
 }
 .p-sm-2 {
   padding: 0.5rem !important;
 }
 .pt-sm-2,
 .py-sm-2 {
   padding-top: 0.5rem !important;
 }
 .pr-sm-2,
 .px-sm-2 {
   padding-right: 0.5rem !important;
 }
 .pb-sm-2,
 .py-sm-2 {
   padding-bottom: 0.5rem !important;
 }
 .pl-sm-2,
 .px-sm-2 {
   padding-left: 0.5rem !important;
 }
 .p-sm-3 {
   padding: 1rem !important;
 }
 .pt-sm-3,
 .py-sm-3 {
   padding-top: 1rem !important;
 }
 .pr-sm-3,
 .px-sm-3 {
   padding-right: 1rem !important;
 }
 .pb-sm-3,
 .py-sm-3 {
   padding-bottom: 1rem !important;
 }
 .pl-sm-3,
 .px-sm-3 {
   padding-left: 1rem !important;
 }
 .p-sm-4 {
   padding: 1.5rem !important;
 }
 .pt-sm-4,
 .py-sm-4 {
   padding-top: 1.5rem !important;
 }
 .pr-sm-4,
 .px-sm-4 {
   padding-right: 1.5rem !important;
 }
 .pb-sm-4,
 .py-sm-4 {
   padding-bottom: 1.5rem !important;
 }
 .pl-sm-4,
 .px-sm-4 {
   padding-left: 1.5rem !important;
 }
 .p-sm-5 {
   padding: 3rem !important;
 }
 .pt-sm-5,
 .py-sm-5 {
   padding-top: 3rem !important;
 }
 .pr-sm-5,
 .px-sm-5 {
   padding-right: 3rem !important;
 }
 .pb-sm-5,
 .py-sm-5 {
   padding-bottom: 3rem !important;
 }
 .pl-sm-5,
 .px-sm-5 {
   padding-left: 3rem !important;
 }
 .m-sm-auto {
   margin: auto !important;
 }
 .mt-sm-auto,
 .my-sm-auto {
   margin-top: auto !important;
 }
 .mr-sm-auto,
 .mx-sm-auto {
   margin-right: auto !important;
 }
 .mb-sm-auto,
 .my-sm-auto {
   margin-bottom: auto !important;
 }
 .ml-sm-auto,
 .mx-sm-auto {
   margin-left: auto !important;
 }

}

@media (min-width: 768px) {

 .m-md-0 {
   margin: 0 !important;
 }
 .mt-md-0,
 .my-md-0 {
   margin-top: 0 !important;
 }
 .mr-md-0,
 .mx-md-0 {
   margin-right: 0 !important;
 }
 .mb-md-0,
 .my-md-0 {
   margin-bottom: 0 !important;
 }
 .ml-md-0,
 .mx-md-0 {
   margin-left: 0 !important;
 }
 .m-md-1 {
   margin: 0.25rem !important;
 }
 .mt-md-1,
 .my-md-1 {
   margin-top: 0.25rem !important;
 }
 .mr-md-1,
 .mx-md-1 {
   margin-right: 0.25rem !important;
 }
 .mb-md-1,
 .my-md-1 {
   margin-bottom: 0.25rem !important;
 }
 .ml-md-1,
 .mx-md-1 {
   margin-left: 0.25rem !important;
 }
 .m-md-2 {
   margin: 0.5rem !important;
 }
 .mt-md-2,
 .my-md-2 {
   margin-top: 0.5rem !important;
 }
 .mr-md-2,
 .mx-md-2 {
   margin-right: 0.5rem !important;
 }
 .mb-md-2,
 .my-md-2 {
   margin-bottom: 0.5rem !important;
 }
 .ml-md-2,
 .mx-md-2 {
   margin-left: 0.5rem !important;
 }
 .m-md-3 {
   margin: 1rem !important;
 }
 .mt-md-3,
 .my-md-3 {
   margin-top: 1rem !important;
 }
 .mr-md-3,
 .mx-md-3 {
   margin-right: 1rem !important;
 }
 .mb-md-3,
 .my-md-3 {
   margin-bottom: 1rem !important;
 }
 .ml-md-3,
 .mx-md-3 {
   margin-left: 1rem !important;
 }
 .m-md-4 {
   margin: 1.5rem !important;
 }
 .mt-md-4,
 .my-md-4 {
   margin-top: 1.5rem !important;
 }
 .mr-md-4,
 .mx-md-4 {
   margin-right: 1.5rem !important;
 }
 .mb-md-4,
 .my-md-4 {
   margin-bottom: 1.5rem !important;
 }
 .ml-md-4,
 .mx-md-4 {
   margin-left: 1.5rem !important;
 }
 .m-md-5 {
   margin: 3rem !important;
 }
 .mt-md-5,
 .my-md-5 {
   margin-top: 3rem !important;
 }
 .mr-md-5,
 .mx-md-5 {
   margin-right: 3rem !important;
 }
 .mb-md-5,
 .my-md-5 {
   margin-bottom: 3rem !important;
 }
 .ml-md-5,
 .mx-md-5 {
   margin-left: 3rem !important;
 }
 .p-md-0 {
   padding: 0 !important;
 }
 .pt-md-0,
 .py-md-0 {
   padding-top: 0 !important;
 }
 .pr-md-0,
 .px-md-0 {
   padding-right: 0 !important;
 }
 .pb-md-0,
 .py-md-0 {
   padding-bottom: 0 !important;
 }
 .pl-md-0,
 .px-md-0 {
   padding-left: 0 !important;
 }
 .p-md-1 {
   padding: 0.25rem !important;
 }
 .pt-md-1,
 .py-md-1 {
   padding-top: 0.25rem !important;
 }
 .pr-md-1,
 .px-md-1 {
   padding-right: 0.25rem !important;
 }
 .pb-md-1,
 .py-md-1 {
   padding-bottom: 0.25rem !important;
 }
 .pl-md-1,
 .px-md-1 {
   padding-left: 0.25rem !important;
 }
 .p-md-2 {
   padding: 0.5rem !important;
 }
 .pt-md-2,
 .py-md-2 {
   padding-top: 0.5rem !important;
 }
 .pr-md-2,
 .px-md-2 {
   padding-right: 0.5rem !important;
 }
 .pb-md-2,
 .py-md-2 {
   padding-bottom: 0.5rem !important;
 }
 .pl-md-2,
 .px-md-2 {
   padding-left: 0.5rem !important;
 }
 .p-md-3 {
   padding: 1rem !important;
 }
 .pt-md-3,
 .py-md-3 {
   padding-top: 1rem !important;
 }
 .pr-md-3,
 .px-md-3 {
   padding-right: 1rem !important;
 }
 .pb-md-3,
 .py-md-3 {
   padding-bottom: 1rem !important;
 }
 .pl-md-3,
 .px-md-3 {
   padding-left: 1rem !important;
 }
 .p-md-4 {
   padding: 1.5rem !important;
 }
 .pt-md-4,
 .py-md-4 {
   padding-top: 1.5rem !important;
 }
 .pr-md-4,
 .px-md-4 {
   padding-right: 1.5rem !important;
 }
 .pb-md-4,
 .py-md-4 {
   padding-bottom: 1.5rem !important;
 }
 .pl-md-4,
 .px-md-4 {
   padding-left: 1.5rem !important;
 }
 .p-md-5 {
   padding: 3rem !important;
 }
 .pt-md-5,
 .py-md-5 {
   padding-top: 3rem !important;
 }
 .pr-md-5,
 .px-md-5 {
   padding-right: 3rem !important;
 }
 .pb-md-5,
 .py-md-5 {
   padding-bottom: 3rem !important;
 }
 .pl-md-5,
 .px-md-5 {
   padding-left: 3rem !important;
 }
 .m-md-auto {
   margin: auto !important;
 }
 .mt-md-auto,
 .my-md-auto {
   margin-top: auto !important;
 }
 .mr-md-auto,
 .mx-md-auto {
   margin-right: auto !important;
 }
 .mb-md-auto,
 .my-md-auto {
   margin-bottom: auto !important;
 }
 .ml-md-auto,
 .mx-md-auto {
   margin-left: auto !important;
 }

}

@media (min-width: 992px) {

 .m-lg-0 {
   margin: 0 !important;
 }
 .mt-lg-0,
 .my-lg-0 {
   margin-top: 0 !important;
 }
 .mr-lg-0,
 .mx-lg-0 {
   margin-right: 0 !important;
 }
 .mb-lg-0,
 .my-lg-0 {
   margin-bottom: 0 !important;
 }
 .ml-lg-0,
 .mx-lg-0 {
   margin-left: 0 !important;
 }
 .m-lg-1 {
   margin: 0.25rem !important;
 }
 .mt-lg-1,
 .my-lg-1 {
   margin-top: 0.25rem !important;
 }
 .mr-lg-1,
 .mx-lg-1 {
   margin-right: 0.25rem !important;
 }
 .mb-lg-1,
 .my-lg-1 {
   margin-bottom: 0.25rem !important;
 }
 .ml-lg-1,
 .mx-lg-1 {
   margin-left: 0.25rem !important;
 }
 .m-lg-2 {
   margin: 0.5rem !important;
 }
 .mt-lg-2,
 .my-lg-2 {
   margin-top: 0.5rem !important;
 }
 .mr-lg-2,
 .mx-lg-2 {
   margin-right: 0.5rem !important;
 }
 .mb-lg-2,
 .my-lg-2 {
   margin-bottom: 0.5rem !important;
 }
 .ml-lg-2,
 .mx-lg-2 {
   margin-left: 0.5rem !important;
 }
 .m-lg-3 {
   margin: 1rem !important;
 }
 .mt-lg-3,
 .my-lg-3 {
   margin-top: 1rem !important;
 }
 .mr-lg-3,
 .mx-lg-3 {
   margin-right: 1rem !important;
 }
 .mb-lg-3,
 .my-lg-3 {
   margin-bottom: 1rem !important;
 }
 .ml-lg-3,
 .mx-lg-3 {
   margin-left: 1rem !important;
 }
 .m-lg-4 {
   margin: 1.5rem !important;
 }
 .mt-lg-4,
 .my-lg-4 {
   margin-top: 1.5rem !important;
 }
 .mr-lg-4,
 .mx-lg-4 {
   margin-right: 1.5rem !important;
 }
 .mb-lg-4,
 .my-lg-4 {
   margin-bottom: 1.5rem !important;
 }
 .ml-lg-4,
 .mx-lg-4 {
   margin-left: 1.5rem !important;
 }
 .m-lg-5 {
   margin: 3rem !important;
 }
 .mt-lg-5,
 .my-lg-5 {
   margin-top: 3rem !important;
 }
 .mr-lg-5,
 .mx-lg-5 {
   margin-right: 3rem !important;
 }
 .mb-lg-5,
 .my-lg-5 {
   margin-bottom: 3rem !important;
 }
 .ml-lg-5,
 .mx-lg-5 {
   margin-left: 3rem !important;
 }
 .p-lg-0 {
   padding: 0 !important;
 }
 .pt-lg-0,
 .py-lg-0 {
   padding-top: 0 !important;
 }
 .pr-lg-0,
 .px-lg-0 {
   padding-right: 0 !important;
 }
 .pb-lg-0,
 .py-lg-0 {
   padding-bottom: 0 !important;
 }
 .pl-lg-0,
 .px-lg-0 {
   padding-left: 0 !important;
 }
 .p-lg-1 {
   padding: 0.25rem !important;
 }
 .pt-lg-1,
 .py-lg-1 {
   padding-top: 0.25rem !important;
 }
 .pr-lg-1,
 .px-lg-1 {
   padding-right: 0.25rem !important;
 }
 .pb-lg-1,
 .py-lg-1 {
   padding-bottom: 0.25rem !important;
 }
 .pl-lg-1,
 .px-lg-1 {
   padding-left: 0.25rem !important;
 }
 .p-lg-2 {
   padding: 0.5rem !important;
 }
 .pt-lg-2,
 .py-lg-2 {
   padding-top: 0.5rem !important;
 }
 .pr-lg-2,
 .px-lg-2 {
   padding-right: 0.5rem !important;
 }
 .pb-lg-2,
 .py-lg-2 {
   padding-bottom: 0.5rem !important;
 }
 .pl-lg-2,
 .px-lg-2 {
   padding-left: 0.5rem !important;
 }
 .p-lg-3 {
   padding: 1rem !important;
 }
 .pt-lg-3,
 .py-lg-3 {
   padding-top: 1rem !important;
 }
 .pr-lg-3,
 .px-lg-3 {
   padding-right: 1rem !important;
 }
 .pb-lg-3,
 .py-lg-3 {
   padding-bottom: 1rem !important;
 }
 .pl-lg-3,
 .px-lg-3 {
   padding-left: 1rem !important;
 }
 .p-lg-4 {
   padding: 1.5rem !important;
 }
 .pt-lg-4,
 .py-lg-4 {
   padding-top: 1.5rem !important;
 }
 .pr-lg-4,
 .px-lg-4 {
   padding-right: 1.5rem !important;
 }
 .pb-lg-4,
 .py-lg-4 {
   padding-bottom: 1.5rem !important;
 }
 .pl-lg-4,
 .px-lg-4 {
   padding-left: 1.5rem !important;
 }
 .p-lg-5 {
   padding: 3rem !important;
 }
 .pt-lg-5,
 .py-lg-5 {
   padding-top: 3rem !important;
 }
 .pr-lg-5,
 .px-lg-5 {
   padding-right: 3rem !important;
 }
 .pb-lg-5,
 .py-lg-5 {
   padding-bottom: 3rem !important;
 }
 .pl-lg-5,
 .px-lg-5 {
   padding-left: 3rem !important;
 }
 .m-lg-auto {
   margin: auto !important;
 }
 .mt-lg-auto,
 .my-lg-auto {
   margin-top: auto !important;
 }
 .mr-lg-auto,
 .mx-lg-auto {
   margin-right: auto !important;
 }
 .mb-lg-auto,
 .my-lg-auto {
   margin-bottom: auto !important;
 }
 .ml-lg-auto,
 .mx-lg-auto {
   margin-left: auto !important;
 }

}

@media (min-width: 1200px) {

 .m-xl-0 {
   margin: 0 !important;
 }
 .mt-xl-0,
 .my-xl-0 {
   margin-top: 0 !important;
 }
 .mr-xl-0,
 .mx-xl-0 {
   margin-right: 0 !important;
 }
 .mb-xl-0,
 .my-xl-0 {
   margin-bottom: 0 !important;
 }
 .ml-xl-0,
 .mx-xl-0 {
   margin-left: 0 !important;
 }
 .m-xl-1 {
   margin: 0.25rem !important;
 }
 .mt-xl-1,
 .my-xl-1 {
   margin-top: 0.25rem !important;
 }
 .mr-xl-1,
 .mx-xl-1 {
   margin-right: 0.25rem !important;
 }
 .mb-xl-1,
 .my-xl-1 {
   margin-bottom: 0.25rem !important;
 }
 .ml-xl-1,
 .mx-xl-1 {
   margin-left: 0.25rem !important;
 }
 .m-xl-2 {
   margin: 0.5rem !important;
 }
 .mt-xl-2,
 .my-xl-2 {
   margin-top: 0.5rem !important;
 }
 .mr-xl-2,
 .mx-xl-2 {
   margin-right: 0.5rem !important;
 }
 .mb-xl-2,
 .my-xl-2 {
   margin-bottom: 0.5rem !important;
 }
 .ml-xl-2,
 .mx-xl-2 {
   margin-left: 0.5rem !important;
 }
 .m-xl-3 {
   margin: 1rem !important;
 }
 .mt-xl-3,
 .my-xl-3 {
   margin-top: 1rem !important;
 }
 .mr-xl-3,
 .mx-xl-3 {
   margin-right: 1rem !important;
 }
 .mb-xl-3,
 .my-xl-3 {
   margin-bottom: 1rem !important;
 }
 .ml-xl-3,
 .mx-xl-3 {
   margin-left: 1rem !important;
 }
 .m-xl-4 {
   margin: 1.5rem !important;
 }
 .mt-xl-4,
 .my-xl-4 {
   margin-top: 1.5rem !important;
 }
 .mr-xl-4,
 .mx-xl-4 {
   margin-right: 1.5rem !important;
 }
 .mb-xl-4,
 .my-xl-4 {
   margin-bottom: 1.5rem !important;
 }
 .ml-xl-4,
 .mx-xl-4 {
   margin-left: 1.5rem !important;
 }
 .m-xl-5 {
   margin: 3rem !important;
 }
 .mt-xl-5,
 .my-xl-5 {
   margin-top: 3rem !important;
 }
 .mr-xl-5,
 .mx-xl-5 {
   margin-right: 3rem !important;
 }
 .mb-xl-5,
 .my-xl-5 {
   margin-bottom: 3rem !important;
 }
 .ml-xl-5,
 .mx-xl-5 {
   margin-left: 3rem !important;
 }
 .p-xl-0 {
   padding: 0 !important;
 }
 .pt-xl-0,
 .py-xl-0 {
   padding-top: 0 !important;
 }
 .pr-xl-0,
 .px-xl-0 {
   padding-right: 0 !important;
 }
 .pb-xl-0,
 .py-xl-0 {
   padding-bottom: 0 !important;
 }
 .pl-xl-0,
 .px-xl-0 {
   padding-left: 0 !important;
 }
 .p-xl-1 {
   padding: 0.25rem !important;
 }
 .pt-xl-1,
 .py-xl-1 {
   padding-top: 0.25rem !important;
 }
 .pr-xl-1,
 .px-xl-1 {
   padding-right: 0.25rem !important;
 }
 .pb-xl-1,
 .py-xl-1 {
   padding-bottom: 0.25rem !important;
 }
 .pl-xl-1,
 .px-xl-1 {
   padding-left: 0.25rem !important;
 }
 .p-xl-2 {
   padding: 0.5rem !important;
 }
 .pt-xl-2,
 .py-xl-2 {
   padding-top: 0.5rem !important;
 }
 .pr-xl-2,
 .px-xl-2 {
   padding-right: 0.5rem !important;
 }
 .pb-xl-2,
 .py-xl-2 {
   padding-bottom: 0.5rem !important;
 }
 .pl-xl-2,
 .px-xl-2 {
   padding-left: 0.5rem !important;
 }
 .p-xl-3 {
   padding: 1rem !important;
 }
 .pt-xl-3,
 .py-xl-3 {
   padding-top: 1rem !important;
 }
 .pr-xl-3,
 .px-xl-3 {
   padding-right: 1rem !important;
 }
 .pb-xl-3,
 .py-xl-3 {
   padding-bottom: 1rem !important;
 }
 .pl-xl-3,
 .px-xl-3 {
   padding-left: 1rem !important;
 }
 .p-xl-4 {
   padding: 1.5rem !important;
 }
 .pt-xl-4,
 .py-xl-4 {
   padding-top: 1.5rem !important;
 }
 .pr-xl-4,
 .px-xl-4 {
   padding-right: 1.5rem !important;
 }
 .pb-xl-4,
 .py-xl-4 {
   padding-bottom: 1.5rem !important;
 }
 .pl-xl-4,
 .px-xl-4 {
   padding-left: 1.5rem !important;
 }
 .p-xl-5 {
   padding: 3rem !important;
 }
 .pt-xl-5,
 .py-xl-5 {
   padding-top: 3rem !important;
 }
 .pr-xl-5,
 .px-xl-5 {
   padding-right: 3rem !important;
 }
 .pb-xl-5,
 .py-xl-5 {
   padding-bottom: 3rem !important;
 }
 .pl-xl-5,
 .px-xl-5 {
   padding-left: 3rem !important;
 }
 .m-xl-auto {
   margin: auto !important;
 }
 .mt-xl-auto,
 .my-xl-auto {
   margin-top: auto !important;
 }
 .mr-xl-auto,
 .mx-xl-auto {
   margin-right: auto !important;
 }
 .mb-xl-auto,
 .my-xl-auto {
   margin-bottom: auto !important;
 }
 .ml-xl-auto,
 .mx-xl-auto {
   margin-left: auto !important;
 }

}

.text-monospace {

 font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;

}

.text-justify {

 text-align: justify !important;

}

.text-nowrap {

 white-space: nowrap !important;

}

.text-truncate {

 overflow: hidden;
 text-overflow: ellipsis;
 white-space: nowrap;

}

.text-left {

 text-align: left !important;

}

.text-right {

 text-align: right !important;

}

.text-center {

 text-align: center !important;

}

@media (min-width: 576px) {

 .text-sm-left {
   text-align: left !important;
 }
 .text-sm-right {
   text-align: right !important;
 }
 .text-sm-center {
   text-align: center !important;
 }

}

@media (min-width: 768px) {

 .text-md-left {
   text-align: left !important;
 }
 .text-md-right {
   text-align: right !important;
 }
 .text-md-center {
   text-align: center !important;
 }

}

@media (min-width: 992px) {

 .text-lg-left {
   text-align: left !important;
 }
 .text-lg-right {
   text-align: right !important;
 }
 .text-lg-center {
   text-align: center !important;
 }

}

@media (min-width: 1200px) {

 .text-xl-left {
   text-align: left !important;
 }
 .text-xl-right {
   text-align: right !important;
 }
 .text-xl-center {
   text-align: center !important;
 }

}

.text-lowercase {

 text-transform: lowercase !important;

}

.text-uppercase {

 text-transform: uppercase !important;

}

.text-capitalize {

 text-transform: capitalize !important;

}

.font-weight-light {

 font-weight: 300 !important;

}

.font-weight-normal {

 font-weight: 400 !important;

}

.font-weight-bold {

 font-weight: 700 !important;

}

.font-italic {

 font-style: italic !important;

}

.text-white {

 color: #fff !important;

}

.text-primary {

 color: #007bff !important;

}

a.text-primary:hover, a.text-primary:focus {

 color: #0062cc !important;

}

.text-secondary {

 color: #6c757d !important;

}

a.text-secondary:hover, a.text-secondary:focus {

 color: #545b62 !important;

}

.text-success {

 color: #28a745 !important;

}

a.text-success:hover, a.text-success:focus {

 color: #1e7e34 !important;

}

.text-info {

 color: #17a2b8 !important;

}

a.text-info:hover, a.text-info:focus {

 color: #117a8b !important;

}

.text-warning {

 color: #ffc107 !important;

}

a.text-warning:hover, a.text-warning:focus {

 color: #d39e00 !important;

}

.text-danger {

 color: #dc3545 !important;

}

a.text-danger:hover, a.text-danger:focus {

 color: #bd2130 !important;

}

.text-light {

 color: #f8f9fa !important;

}

a.text-light:hover, a.text-light:focus {

 color: #dae0e5 !important;

}

.text-dark {

 color: #343a40 !important;

}

a.text-dark:hover, a.text-dark:focus {

 color: #1d2124 !important;

}

.text-body {

 color: #212529 !important;

}

.text-muted {

 color: #6c757d !important;

}

.text-black-50 {

 color: rgba(0, 0, 0, 0.5) !important;

}

.text-white-50 {

 color: rgba(255, 255, 255, 0.5) !important;

}

.text-hide {

 font: 0/0 a;
 color: transparent;
 text-shadow: none;
 background-color: transparent;
 border: 0;

}

.visible {

 visibility: visible !important;

}

.invisible {

 visibility: hidden !important;

}

@media print {

 *,
 *::before,
 *::after {
   text-shadow: none !important;
   box-shadow: none !important;
 }
 a:not(.btn) {
   text-decoration: underline;
 }
 abbr[title]::after {
   content: " (" attr(title) ")";
 }
 pre {
   white-space: pre-wrap !important;
 }
 pre,
 blockquote {
   border: 1px solid #adb5bd;
   page-break-inside: avoid;
 }
 thead {
   display: table-header-group;
 }
 tr,
 img {
   page-break-inside: avoid;
 }
 p,
 h2,
 h3 {
   orphans: 3;
   widows: 3;
 }
 h2,
 h3 {
   page-break-after: avoid;
 }
 @page {
   size: a3;
 }
 body {
   min-width: 992px !important;
 }
 .container {
   min-width: 992px !important;
 }
 .navbar {
   display: none;
 }
 .badge {
   border: 1px solid #000;
 }
 .table {
   border-collapse: collapse !important;
 }
 .table td,
 .table th {
   background-color: #fff !important;
 }
 .table-bordered th,
 .table-bordered td {
   border: 1px solid #dee2e6 !important;
 }
 .table-dark {
   color: inherit;
 }
 .table-dark th,
 .table-dark td,
 .table-dark thead th,
 .table-dark tbody + tbody {
   border-color: #dee2e6;
 }
 .table .thead-dark th {
   color: inherit;
   border-color: #dee2e6;
 }

} /*# sourceMappingURL=bootstrap.css.map *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* CSS for the iGEM 2018 Team : Toulouse INSA-UPS Creator : Yohann CHARREIRE--KIRBACH (Sentiare) Editors : Sentiare Last Update : Thu 06/09/18 @ 10:55

                                                                             */

/**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/


/**//*OVERRIDE DEFAULT CSS*//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* This section is for removing the default iGEM CSS

* It should be complete, but i maybe missed something
*/
  1. HQ_page, #content {

width:100%; padding:0; margin:0; }

  1. mw-content-text p:first-child {

margin:0; padding:0; }

a#top { height:0; }

  1. top_title, #top_title div, #top_title h1 #firstHeading {

visibility:hidden !important; height:0 !important; margin:0 !important; padding:0 !important; }

  1. globalWrapper {

padding-bottom:0;

       font-size: 100%;

}

.mw-content-ltr ul, .mw-content-rtl .mw-content-ltr ul { margin:0; }

li { margin-bottom:0; }

/**//*CSS of the iGEM menu *//**//**//**//**//**//**//**//**//**//**//**//*****/ /* The iGEM black menu doesn't match his background spacer

* This CSS just increase his size by 2px to make them both match in height.
*/
  1. top_menu_14 {

height:18px; /*Now it matches his own spacer height*/ }

/**//*IMAGES*//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//****/ /**//*Team Logo*//**/ .img_team_logo { height:3.5rem; width:auto; }

.center_img{

   display: block;
   margin-left: auto;
   margin-right: auto;
   position: relative;

}

.rotate { position: relative; z-index: auto; margin-top: auto; padding-top:auto; margin-left: auto; padding-left:auto; -webkit-transform: rotate(-90deg);

   -moz-transform: rotate(-90deg);
   -o-transform: rotate(-90deg);
   -ms-transform: rotate(-90deg);
   transform: rotate(-90deg);

}

/**//*The text of the logo*//**/ a.navbar-brand { font-size:1.5rem; }

/**//*In Page Documents*//**//**//**//**//**//**//**//**//**//**//**//**//*****/ /* This section is about the different elements around the document reader in our

* page. Remember : NO IFRAME!!!
*/

/**//*PDF*//**/ .black-pdf-spacer { width:100%; height:1rem; background-color:#3F3F3F;

}

/**//* GENERAL *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//*****/ /* This section is mainly about title and text padding, margin and size

*/

body, html { position:relative width:100%; height:auto; }

  1. CONTENT h1, .collapse h1 {

margin-top:3rem !important; margin-bottom:0rem !important; }

  1. CONTENT h2, .collapse h2 {

margin-top:0rem !important; margin-bottom:0rem !important; padding:0.34rem 0 0.17rem 0; }

  1. CONTENT h3, .collapse h3{

margin-top:1rem !important; margin-bottom:0rem !important; }

.heavy {

   font-weight: 600;

}

  1. MENU {

top:18px; font-size:1rem; }

a.dropdown-item { color:black !important; }

p { /*General*/ font-size:1rem !important; }

h3 { font-size:1.5rem; }

h4 { font-size:1.25rem; }

h5, h6 { font-size:1rem; }

.list { position: relative; margin-top: -15px; padding-top: 1px;

   margin-bottom: 20px;

padding-bottom: 1px;

     }

div.cd-timeline__content p, div.cd-timeline__content a, div.cd-timeline__content span, div.cd-timeline__content { /*Timeline font*/ font-size:1rem; }

  1. DISCLAIMER p { /*FOOTER font*/

font-size:0.7rem; }

/**//*columns*//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//****/

.bicolumn {

   -webkit-column-count:2;
   -moz-column-count: 2;
   column-count: 2;

}

.tricolumn {

   -webkit-columns:3; 
   -moz-columns: 3; 
   columns: 3;

}

.quadricolumn {

   -webkit-columns:4;
   -moz-columns: 4;
   columns: 4;

}

div.imgtxtcenter {

   min-height: 800px;
   display: table-cell;
   vertical-align: middle;
   background-color:yellow;

}

/**//* BANNER *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* #BANNER refers to the picture on the top of the page.

* It uses media queries.
*/

.img_banner { width:100%; height:auto; margin:0; padding:0; z-index:1000; }

  1. BANNER {

margin:0; padding:0; overflow: hidden; }

@media screen and (min-width:100px) and (max-width:576px) { #BANNER { height:70px; } }

@media screen and (min-width:577px) and (max-width:768px) { #BANNER { height:140px; } }

@media screen and (min-width:769px) and (max-width:992px) { #BANNER { height:150px; } }

@media screen and (min-width:993px) and (max-width:1200px) { #BANNER { height:190px; } }

@media screen and (min-width:1201px) { #BANNER { height:230px; } }

/**//* HR BANNERS *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* Is it a banner, is it a hr ? No it's a picture which acts like a hr.

*/

div.hr_img { width:100%; height:5rem; overflow:hidden; }

img.hr_img { width:100%; }

/**//* HR *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* I love hr. So here's their very own section

*/

h1~hr { margin-top:0rem; margin-bottom:3rem; }

h2~hr { margin-top:0rem; margin-bottom:2rem; }

h3~hr { margin-top:0rem; margin-bottom:1rem; }

a.dropdown-item~hr { margin-bottom:0.5rem; margin-top:0.5rem; }

hr { padding:0; }

/**//*NAV ICONS*//**//**//**//**//**//**//**//**//**//**//**//**//**//**//*****/ /* Everything related with the ugly little nav icons on the left of the screen

*/

a.ico { padding:0.5rem 0.5rem; }

img.ico { max-width:3rem; height:auto; }

  1. NAV_ICON_BAR ul li img.ico:hover {

-webkit-filter : opacity(60%); filter : opacity(60%); }

  1. NAV_ICON_BAR ul li img.ico.filter-alpha-50:hover {

-webkit-filter : opacity(50%); filter : opacity(50%); }

  1. NAV_ICON_BAR {

bottom:1rem; }

/**//* FOOTER *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* Everything that is only in the footer and has CSS is in this section

*/
  1. FOOTER_CONTENT {

margin:1.6rem }

/**//* Anchors *//**/ a.footer { text-decoration:underline; }

a.footer:link, a.footer:visited { color:#f8f9fa; }

a.footer:hover, a.footer:active { color:#d8d9da; }

/**//* SPONSORS *//**/ p.sponsor { margin-bottom:0; }

/**//* CAROUSEL *//**//**//**//**//**//**//**//**//**//**//**//**//**//**//****/ /* The carousel should soon be removed, remove this section too.

*/
  1. PLACEHOLDER {

overflow:hidden; z-index:1000; position:relative; width:100%; height:100vh; }

/**//*"EXTENDED" BOOTSTRAP*//**//**//**//**//**//**//**//**//**//**//**//**//**/ /* Just some classes that Bootstrap doesn't have but looks like they are bootstrap

* classes.
*/

.corner-bottom { border-bottom-left-radius : 0 !important; border-bottom-right-radius : 0 !important; }

@media screen and (min-width:993px) { .corner-lg-bottom { border-bottom-left-radius : 0 !important; border-bottom-right-radius : 0 !important; } }

.corner-top { border-top-left-radius : 0 !important; border-top-right-radius : 0 !important; }

@media screen and (min-width:993px) { .corner-lg-top { border-top-left-radius : 0 !important; border-top-right-radius : 0 !important; } }

.corner-left { border-top-left-radius : 0 !important; border-bottom-left-radius : 0 !important; }

.corner-right { border-top-right-radius : 0 !important; border-bottom-right-radius : 0 !important; }

.corner-all { border-top-right-radius : 0 !important; border-bottom-right-radius : 0 !important; border-top-left-radius : 0 !important; border-bottom-left-radius : 0 !important; }

.picture-of-someone { height:18rem !important; width:18rem !important; }

.card-of-picture { width:18rem !important; }

.sticky-bottom {

   position: -webkit-sticky; /* For compatibility */
   position: sticky;
   bottom: 0;

}

.nav-left-col { display:block; width:16.666667%; max-width:16.666667%; }

/**//*Filters*//**/ .filter-gray { -webkit-filter: grayscale(100%); /* Safari 6.0-9.0 */ filter:grayscale(100%); }

.filter-gray-0 { -webkit-filter: grayscale(0%) !important; /* Safari 6.0-9.0 */ filter:grayscale(0%) !important; }

.filter-gray-25 { -webkit-filter: grayscale(25%); /* Safari 6.0-9.0 */ filter:grayscale(25%); }

.filter-gray-50 { -webkit-filter: grayscale(50%); /* Safari 6.0-9.0 */ filter:grayscale(50%); }

.filter-gray-75 { -webkit-filter: grayscale(75%); /* Safari 6.0-9.0 */ filter:grayscale(75%); }

.filter-gray-90 { -webkit-filter: grayscale(90%); /* Safari 6.0-9.0 */ filter:grayscale(90%); }

.filter-gray-95 { -webkit-filter: grayscale(95%); /* Safari 6.0-9.0 */ filter:grayscale(95%); }

.filter-gray-100 { -webkit-filter: grayscale(100%); /* Safari 6.0-9.0 */ filter:grayscale(100%); }

.filter-reverse { -webkit-filter: invert(100%); /* Safari 6.0-9.0 */ filter: invert(100%); }

.filter-invert { -webkit-filter: invert(100%); /* Safari 6.0-9.0 */ filter: invert(100%); }

.filter-alpha-0 { -webkit-filter : opacity(100%) !important; /* Safari 6.0-9.0 */ filter : opacity(100%) !important; }

.filter-alpha-25 { -webkit-filter : opacity(75%); /* Safari 6.0-9.0 */ filter : opacity(75%); }

.filter-alpha-50 { -webkit-filter : opacity(50%); /* Safari 6.0-9.0 */ filter : opacity(50%); }

.filter-alpha-75 { -webkit-filter : opacity(25%); /* Safari 6.0-9.0 */ filter : opacity(25%); }

.filter-alpha-100 { -webkit-filter : opacity(0%); /* Safari 6.0-9.0 */ filter : opacity(0%); }

.filter-alpha { -webkit-filter : opacity(50%); /* Safari 6.0-9.0 */ filter : opacity(50%); }

/**//*Colors*//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//****/ /* As everyone requests it, wants it, NEEDS IT for some reasons, here's some colors.

* They may change in the futur tho.
*/

/**//*Backgrounds*//**/ .bg-aqua { background-color:#00FCFC !important; }

.bg-neon-blue { background-color:#0056FE !important; }

.bg-neon-green { background-color:#00996D !important; }

.bg-lime { background-color:#79FD00 !important; }

.bg-neon-yellow { background-color:#E1E166 !important; }

.bg-neon-orange { background-color:#FFB400 !important; }

.bg-neon-red { background-color:#EA1B00 !important; }

.bg-neon-purple { background-color:#960096 !important; }

.bg-neon-pink { background-color:#FF1160 !important; }

.bg-neon-white { background-color:#C7C7FD !important; }

/**//*Fonts*//**/ /* I don't like the idee of colorfull text as it's not easy to read.

* But just in case someone crave for it, I have made this.
*/

.font-aqua { color:#00FCFC; }

.font-neon-blue { color:#0056FE; }

.font-neon-green { color:#00996D; }

.font-lime { color:#79FD00; }

.font-neon-yellow { color:#E1E166; }

.font-neon-orange { color:#FFB400; }

.font-neon-red { color:#EA1B00; }

.font-neon-purple { color:#960096; }

.font-neon-pink { color:#FF1160; }

.font-neon-white { color:#C7C7FD; }

/**//*Parallax*//**/ /* That's more cooler than the usual scroll

* (I know there's a mistake with "more cooler")
*/


.parallax { background-attachment:fixed; background-position: top center;

   background-repeat: no-repeat;
   background-size: contain;

}

/* .parallax { background-attachment:fixed;

   background-repeat: no-repeat;
   background-size: contain;

}

  • /

/**//*Tab*//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//**//***/ /* Adjust the color of the active tab

*/

a.btn.nav-link.active, a.btn.nav-link:hover:not(.disabled), a.btn.nav-link:hover:not(:disabled) { background-color: #EC2E0F !important; border-color: #343A40 !important; }

/**//*Anchor bar*//**//**//**//**//**//**//**//**//**//**//**//**//**//**//****/ /* CSS About the gray bar that I don't like.

*/

nav#ANCHOR_BAR div div.navbar-nav a.nav-link { padding-top:0.1rem; padding-bottom:0.1rem; }


/* *** Change cursor to pointer when hovering over an img-thumbnail for the HP page *** */ .img-thumbnail {

   cursor:pointer;

}

Team

In this page you can introduce your team members, instructors, and advisors.

What should this page contain?

  • Include pictures of your teammates, don’t forget instructors and advisors!
  • You can add a small biography or a few words from each team member, to tell us what you like, and what motivated you to participate in iGEM.
  • Take team pictures! Show us your school, your lab and little bit of your city.
  • Remember that image galleries can help you showcase many pictures while saving space.

Inspiration

You can look at what other teams did to get some inspiration!
Here are a few examples:

/*!

 * Bootstrap v4.1.3 (https://getbootstrap.com/)
 * Copyright 2011-2018 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 */

(function (global, factory) {

 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) :
 typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) :
 (factory((global.bootstrap = {}),global.jQuery));

}(this, (function (exports,$) { 'use strict';

 $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
 function _defineProperties(target, props) {
   for (var i = 0; i < props.length; i++) {
     var descriptor = props[i];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor) descriptor.writable = true;
     Object.defineProperty(target, descriptor.key, descriptor);
   }
 }
 function _createClass(Constructor, protoProps, staticProps) {
   if (protoProps) _defineProperties(Constructor.prototype, protoProps);
   if (staticProps) _defineProperties(Constructor, staticProps);
   return Constructor;
 }
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
     obj[key] = value;
   }
   return obj;
 }
 function _objectSpread(target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i] != null ? arguments[i] : {};
     var ownKeys = Object.keys(source);
     if (typeof Object.getOwnPropertySymbols === 'function') {
       ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
         return Object.getOwnPropertyDescriptor(source, sym).enumerable;
       }));
     }
     ownKeys.forEach(function (key) {
       _defineProperty(target, key, source[key]);
     });
   }
   return target;
 }
 function _inheritsLoose(subClass, superClass) {
   subClass.prototype = Object.create(superClass.prototype);
   subClass.prototype.constructor = subClass;
   subClass.__proto__ = superClass;
 }
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): util.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Util = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Private TransitionEnd Helpers
    * ------------------------------------------------------------------------
    */
   var TRANSITION_END = 'transitionend';
   var MAX_UID = 1000000;
   var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
   function toType(obj) {
     return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
   }
   function getSpecialTransitionEndEvent() {
     return {
       bindType: TRANSITION_END,
       delegateType: TRANSITION_END,
       handle: function handle(event) {
         if ($$$1(event.target).is(this)) {
           return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
         }
         return undefined; // eslint-disable-line no-undefined
       }
     };
   }
   function transitionEndEmulator(duration) {
     var _this = this;
     var called = false;
     $$$1(this).one(Util.TRANSITION_END, function () {
       called = true;
     });
     setTimeout(function () {
       if (!called) {
         Util.triggerTransitionEnd(_this);
       }
     }, duration);
     return this;
   }
   function setTransitionEndSupport() {
     $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
     $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
   }
   /**
    * --------------------------------------------------------------------------
    * Public Util Api
    * --------------------------------------------------------------------------
    */


   var Util = {
     TRANSITION_END: 'bsTransitionEnd',
     getUID: function getUID(prefix) {
       do {
         // eslint-disable-next-line no-bitwise
         prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
       } while (document.getElementById(prefix));
       return prefix;
     },
     getSelectorFromElement: function getSelectorFromElement(element) {
       var selector = element.getAttribute('data-target');
       if (!selector || selector === '#') {
         selector = element.getAttribute('href') || ;
       }
       try {
         return document.querySelector(selector) ? selector : null;
       } catch (err) {
         return null;
       }
     },
     getTransitionDurationFromElement: function getTransitionDurationFromElement(element) {
       if (!element) {
         return 0;
       } // Get transition-duration of the element


       var transitionDuration = $$$1(element).css('transition-duration');
       var floatTransitionDuration = parseFloat(transitionDuration); // Return 0 if element or transition duration is not found
       if (!floatTransitionDuration) {
         return 0;
       } // If multiple durations are defined, take the first


       transitionDuration = transitionDuration.split(',')[0];
       return parseFloat(transitionDuration) * MILLISECONDS_MULTIPLIER;
     },
     reflow: function reflow(element) {
       return element.offsetHeight;
     },
     triggerTransitionEnd: function triggerTransitionEnd(element) {
       $$$1(element).trigger(TRANSITION_END);
     },
     // TODO: Remove in v5
     supportsTransitionEnd: function supportsTransitionEnd() {
       return Boolean(TRANSITION_END);
     },
     isElement: function isElement(obj) {
       return (obj[0] || obj).nodeType;
     },
     typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
       for (var property in configTypes) {
         if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
           var expectedTypes = configTypes[property];
           var value = config[property];
           var valueType = value && Util.isElement(value) ? 'element' : toType(value);
           if (!new RegExp(expectedTypes).test(valueType)) {
             throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
           }
         }
       }
     }
   };
   setTransitionEndSupport();
   return Util;
 }($);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): alert.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Alert = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'alert';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.alert';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var Selector = {
     DISMISS: '[data-dismiss="alert"]'
   };
   var Event = {
     CLOSE: "close" + EVENT_KEY,
     CLOSED: "closed" + EVENT_KEY,
     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
   };
   var ClassName = {
     ALERT: 'alert',
     FADE: 'fade',
     SHOW: 'show'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Alert =
   /*#__PURE__*/
   function () {
     function Alert(element) {
       this._element = element;
     } // Getters


     var _proto = Alert.prototype;
     // Public
     _proto.close = function close(element) {
       var rootElement = this._element;
       if (element) {
         rootElement = this._getRootElement(element);
       }
       var customEvent = this._triggerCloseEvent(rootElement);
       if (customEvent.isDefaultPrevented()) {
         return;
       }
       this._removeElement(rootElement);
     };
     _proto.dispose = function dispose() {
       $$$1.removeData(this._element, DATA_KEY);
       this._element = null;
     }; // Private


     _proto._getRootElement = function _getRootElement(element) {
       var selector = Util.getSelectorFromElement(element);
       var parent = false;
       if (selector) {
         parent = document.querySelector(selector);
       }
       if (!parent) {
         parent = $$$1(element).closest("." + ClassName.ALERT)[0];
       }
       return parent;
     };
     _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
       var closeEvent = $$$1.Event(Event.CLOSE);
       $$$1(element).trigger(closeEvent);
       return closeEvent;
     };
     _proto._removeElement = function _removeElement(element) {
       var _this = this;
       $$$1(element).removeClass(ClassName.SHOW);
       if (!$$$1(element).hasClass(ClassName.FADE)) {
         this._destroyElement(element);
         return;
       }
       var transitionDuration = Util.getTransitionDurationFromElement(element);
       $$$1(element).one(Util.TRANSITION_END, function (event) {
         return _this._destroyElement(element, event);
       }).emulateTransitionEnd(transitionDuration);
     };
     _proto._destroyElement = function _destroyElement(element) {
       $$$1(element).detach().trigger(Event.CLOSED).remove();
     }; // Static


     Alert._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var $element = $$$1(this);
         var data = $element.data(DATA_KEY);
         if (!data) {
           data = new Alert(this);
           $element.data(DATA_KEY, data);
         }
         if (config === 'close') {
           data[config](this);
         }
       });
     };
     Alert._handleDismiss = function _handleDismiss(alertInstance) {
       return function (event) {
         if (event) {
           event.preventDefault();
         }
         alertInstance.close(this);
       };
     };
     _createClass(Alert, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }]);
     return Alert;
   }();
   /**
    * ------------------------------------------------------------------------
    * Data Api implementation
    * ------------------------------------------------------------------------
    */


   $$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */
   $$$1.fn[NAME] = Alert._jQueryInterface;
   $$$1.fn[NAME].Constructor = Alert;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Alert._jQueryInterface;
   };
   return Alert;
 }($);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): button.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Button = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'button';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.button';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var ClassName = {
     ACTIVE: 'active',
     BUTTON: 'btn',
     FOCUS: 'focus'
   };
   var Selector = {
     DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
     DATA_TOGGLE: '[data-toggle="buttons"]',
     INPUT: 'input',
     ACTIVE: '.active',
     BUTTON: '.btn'
   };
   var Event = {
     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
     FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY + DATA_API_KEY + " " + ("blur" + EVENT_KEY + DATA_API_KEY)
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Button =
   /*#__PURE__*/
   function () {
     function Button(element) {
       this._element = element;
     } // Getters


     var _proto = Button.prototype;
     // Public
     _proto.toggle = function toggle() {
       var triggerChangeEvent = true;
       var addAriaPressed = true;
       var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
       if (rootElement) {
         var input = this._element.querySelector(Selector.INPUT);
         if (input) {
           if (input.type === 'radio') {
             if (input.checked && this._element.classList.contains(ClassName.ACTIVE)) {
               triggerChangeEvent = false;
             } else {
               var activeElement = rootElement.querySelector(Selector.ACTIVE);
               if (activeElement) {
                 $$$1(activeElement).removeClass(ClassName.ACTIVE);
               }
             }
           }
           if (triggerChangeEvent) {
             if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
               return;
             }
             input.checked = !this._element.classList.contains(ClassName.ACTIVE);
             $$$1(input).trigger('change');
           }
           input.focus();
           addAriaPressed = false;
         }
       }
       if (addAriaPressed) {
         this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName.ACTIVE));
       }
       if (triggerChangeEvent) {
         $$$1(this._element).toggleClass(ClassName.ACTIVE);
       }
     };
     _proto.dispose = function dispose() {
       $$$1.removeData(this._element, DATA_KEY);
       this._element = null;
     }; // Static


     Button._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var data = $$$1(this).data(DATA_KEY);
         if (!data) {
           data = new Button(this);
           $$$1(this).data(DATA_KEY, data);
         }
         if (config === 'toggle') {
           data[config]();
         }
       });
     };
     _createClass(Button, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }]);
     return Button;
   }();
   /**
    * ------------------------------------------------------------------------
    * Data Api implementation
    * ------------------------------------------------------------------------
    */


   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
     event.preventDefault();
     var button = event.target;
     if (!$$$1(button).hasClass(ClassName.BUTTON)) {
       button = $$$1(button).closest(Selector.BUTTON);
     }
     Button._jQueryInterface.call($$$1(button), 'toggle');
   }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
     var button = $$$1(event.target).closest(Selector.BUTTON)[0];
     $$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
   });
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */
   $$$1.fn[NAME] = Button._jQueryInterface;
   $$$1.fn[NAME].Constructor = Button;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Button._jQueryInterface;
   };
   return Button;
 }($);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): carousel.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Carousel = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'carousel';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.carousel';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
   var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
   var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
   var Default = {
     interval: 5000,
     keyboard: true,
     slide: false,
     pause: 'hover',
     wrap: true
   };
   var DefaultType = {
     interval: '(number|boolean)',
     keyboard: 'boolean',
     slide: '(boolean|string)',
     pause: '(string|boolean)',
     wrap: 'boolean'
   };
   var Direction = {
     NEXT: 'next',
     PREV: 'prev',
     LEFT: 'left',
     RIGHT: 'right'
   };
   var Event = {
     SLIDE: "slide" + EVENT_KEY,
     SLID: "slid" + EVENT_KEY,
     KEYDOWN: "keydown" + EVENT_KEY,
     MOUSEENTER: "mouseenter" + EVENT_KEY,
     MOUSELEAVE: "mouseleave" + EVENT_KEY,
     TOUCHEND: "touchend" + EVENT_KEY,
     LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
   };
   var ClassName = {
     CAROUSEL: 'carousel',
     ACTIVE: 'active',
     SLIDE: 'slide',
     RIGHT: 'carousel-item-right',
     LEFT: 'carousel-item-left',
     NEXT: 'carousel-item-next',
     PREV: 'carousel-item-prev',
     ITEM: 'carousel-item'
   };
   var Selector = {
     ACTIVE: '.active',
     ACTIVE_ITEM: '.active.carousel-item',
     ITEM: '.carousel-item',
     NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
     INDICATORS: '.carousel-indicators',
     DATA_SLIDE: '[data-slide], [data-slide-to]',
     DATA_RIDE: '[data-ride="carousel"]'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Carousel =
   /*#__PURE__*/
   function () {
     function Carousel(element, config) {
       this._items = null;
       this._interval = null;
       this._activeElement = null;
       this._isPaused = false;
       this._isSliding = false;
       this.touchTimeout = null;
       this._config = this._getConfig(config);
       this._element = $$$1(element)[0];
       this._indicatorsElement = this._element.querySelector(Selector.INDICATORS);
       this._addEventListeners();
     } // Getters


     var _proto = Carousel.prototype;
     // Public
     _proto.next = function next() {
       if (!this._isSliding) {
         this._slide(Direction.NEXT);
       }
     };
     _proto.nextWhenVisible = function nextWhenVisible() {
       // Don't call next when the page isn't visible
       // or the carousel or its parent isn't visible
       if (!document.hidden && $$$1(this._element).is(':visible') && $$$1(this._element).css('visibility') !== 'hidden') {
         this.next();
       }
     };
     _proto.prev = function prev() {
       if (!this._isSliding) {
         this._slide(Direction.PREV);
       }
     };
     _proto.pause = function pause(event) {
       if (!event) {
         this._isPaused = true;
       }
       if (this._element.querySelector(Selector.NEXT_PREV)) {
         Util.triggerTransitionEnd(this._element);
         this.cycle(true);
       }
       clearInterval(this._interval);
       this._interval = null;
     };
     _proto.cycle = function cycle(event) {
       if (!event) {
         this._isPaused = false;
       }
       if (this._interval) {
         clearInterval(this._interval);
         this._interval = null;
       }
       if (this._config.interval && !this._isPaused) {
         this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
       }
     };
     _proto.to = function to(index) {
       var _this = this;
       this._activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
       var activeIndex = this._getItemIndex(this._activeElement);
       if (index > this._items.length - 1 || index < 0) {
         return;
       }
       if (this._isSliding) {
         $$$1(this._element).one(Event.SLID, function () {
           return _this.to(index);
         });
         return;
       }
       if (activeIndex === index) {
         this.pause();
         this.cycle();
         return;
       }
       var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
       this._slide(direction, this._items[index]);
     };
     _proto.dispose = function dispose() {
       $$$1(this._element).off(EVENT_KEY);
       $$$1.removeData(this._element, DATA_KEY);
       this._items = null;
       this._config = null;
       this._element = null;
       this._interval = null;
       this._isPaused = null;
       this._isSliding = null;
       this._activeElement = null;
       this._indicatorsElement = null;
     }; // Private


     _proto._getConfig = function _getConfig(config) {
       config = _objectSpread({}, Default, config);
       Util.typeCheckConfig(NAME, config, DefaultType);
       return config;
     };
     _proto._addEventListeners = function _addEventListeners() {
       var _this2 = this;
       if (this._config.keyboard) {
         $$$1(this._element).on(Event.KEYDOWN, function (event) {
           return _this2._keydown(event);
         });
       }
       if (this._config.pause === 'hover') {
         $$$1(this._element).on(Event.MOUSEENTER, function (event) {
           return _this2.pause(event);
         }).on(Event.MOUSELEAVE, function (event) {
           return _this2.cycle(event);
         });
         if ('ontouchstart' in document.documentElement) {
           // If it's a touch-enabled device, mouseenter/leave are fired as
           // part of the mouse compatibility events on first tap - the carousel
           // would stop cycling until user tapped out of it;
           // here, we listen for touchend, explicitly pause the carousel
           // (as if it's the second time we tap on it, mouseenter compat event
           // is NOT fired) and after a timeout (to allow for mouse compatibility
           // events to fire) we explicitly restart cycling
           $$$1(this._element).on(Event.TOUCHEND, function () {
             _this2.pause();
             if (_this2.touchTimeout) {
               clearTimeout(_this2.touchTimeout);
             }
             _this2.touchTimeout = setTimeout(function (event) {
               return _this2.cycle(event);
             }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
           });
         }
       }
     };
     _proto._keydown = function _keydown(event) {
       if (/input|textarea/i.test(event.target.tagName)) {
         return;
       }
       switch (event.which) {
         case ARROW_LEFT_KEYCODE:
           event.preventDefault();
           this.prev();
           break;
         case ARROW_RIGHT_KEYCODE:
           event.preventDefault();
           this.next();
           break;
         default:
       }
     };
     _proto._getItemIndex = function _getItemIndex(element) {
       this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector.ITEM)) : [];
       return this._items.indexOf(element);
     };
     _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
       var isNextDirection = direction === Direction.NEXT;
       var isPrevDirection = direction === Direction.PREV;
       var activeIndex = this._getItemIndex(activeElement);
       var lastItemIndex = this._items.length - 1;
       var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
       if (isGoingToWrap && !this._config.wrap) {
         return activeElement;
       }
       var delta = direction === Direction.PREV ? -1 : 1;
       var itemIndex = (activeIndex + delta) % this._items.length;
       return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
     };
     _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
       var targetIndex = this._getItemIndex(relatedTarget);
       var fromIndex = this._getItemIndex(this._element.querySelector(Selector.ACTIVE_ITEM));
       var slideEvent = $$$1.Event(Event.SLIDE, {
         relatedTarget: relatedTarget,
         direction: eventDirectionName,
         from: fromIndex,
         to: targetIndex
       });
       $$$1(this._element).trigger(slideEvent);
       return slideEvent;
     };
     _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
       if (this._indicatorsElement) {
         var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector.ACTIVE));
         $$$1(indicators).removeClass(ClassName.ACTIVE);
         var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
         if (nextIndicator) {
           $$$1(nextIndicator).addClass(ClassName.ACTIVE);
         }
       }
     };
     _proto._slide = function _slide(direction, element) {
       var _this3 = this;
       var activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
       var activeElementIndex = this._getItemIndex(activeElement);
       var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
       var nextElementIndex = this._getItemIndex(nextElement);
       var isCycling = Boolean(this._interval);
       var directionalClassName;
       var orderClassName;
       var eventDirectionName;
       if (direction === Direction.NEXT) {
         directionalClassName = ClassName.LEFT;
         orderClassName = ClassName.NEXT;
         eventDirectionName = Direction.LEFT;
       } else {
         directionalClassName = ClassName.RIGHT;
         orderClassName = ClassName.PREV;
         eventDirectionName = Direction.RIGHT;
       }
       if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
         this._isSliding = false;
         return;
       }
       var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
       if (slideEvent.isDefaultPrevented()) {
         return;
       }
       if (!activeElement || !nextElement) {
         // Some weirdness is happening, so we bail
         return;
       }
       this._isSliding = true;
       if (isCycling) {
         this.pause();
       }
       this._setActiveIndicatorElement(nextElement);
       var slidEvent = $$$1.Event(Event.SLID, {
         relatedTarget: nextElement,
         direction: eventDirectionName,
         from: activeElementIndex,
         to: nextElementIndex
       });
       if ($$$1(this._element).hasClass(ClassName.SLIDE)) {
         $$$1(nextElement).addClass(orderClassName);
         Util.reflow(nextElement);
         $$$1(activeElement).addClass(directionalClassName);
         $$$1(nextElement).addClass(directionalClassName);
         var transitionDuration = Util.getTransitionDurationFromElement(activeElement);
         $$$1(activeElement).one(Util.TRANSITION_END, function () {
           $$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
           $$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
           _this3._isSliding = false;
           setTimeout(function () {
             return $$$1(_this3._element).trigger(slidEvent);
           }, 0);
         }).emulateTransitionEnd(transitionDuration);
       } else {
         $$$1(activeElement).removeClass(ClassName.ACTIVE);
         $$$1(nextElement).addClass(ClassName.ACTIVE);
         this._isSliding = false;
         $$$1(this._element).trigger(slidEvent);
       }
       if (isCycling) {
         this.cycle();
       }
     }; // Static


     Carousel._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var data = $$$1(this).data(DATA_KEY);
         var _config = _objectSpread({}, Default, $$$1(this).data());
         if (typeof config === 'object') {
           _config = _objectSpread({}, _config, config);
         }
         var action = typeof config === 'string' ? config : _config.slide;
         if (!data) {
           data = new Carousel(this, _config);
           $$$1(this).data(DATA_KEY, data);
         }
         if (typeof config === 'number') {
           data.to(config);
         } else if (typeof action === 'string') {
           if (typeof data[action] === 'undefined') {
             throw new TypeError("No method named \"" + action + "\"");
           }
           data[action]();
         } else if (_config.interval) {
           data.pause();
           data.cycle();
         }
       });
     };
     Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
       var selector = Util.getSelectorFromElement(this);
       if (!selector) {
         return;
       }
       var target = $$$1(selector)[0];
       if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
         return;
       }
       var config = _objectSpread({}, $$$1(target).data(), $$$1(this).data());
       var slideIndex = this.getAttribute('data-slide-to');
       if (slideIndex) {
         config.interval = false;
       }
       Carousel._jQueryInterface.call($$$1(target), config);
       if (slideIndex) {
         $$$1(target).data(DATA_KEY).to(slideIndex);
       }
       event.preventDefault();
     };
     _createClass(Carousel, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }, {
       key: "Default",
       get: function get() {
         return Default;
       }
     }]);
     return Carousel;
   }();
   /**
    * ------------------------------------------------------------------------
    * Data Api implementation
    * ------------------------------------------------------------------------
    */


   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
   $$$1(window).on(Event.LOAD_DATA_API, function () {
     var carousels = [].slice.call(document.querySelectorAll(Selector.DATA_RIDE));
     for (var i = 0, len = carousels.length; i < len; i++) {
       var $carousel = $$$1(carousels[i]);
       Carousel._jQueryInterface.call($carousel, $carousel.data());
     }
   });
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */
   $$$1.fn[NAME] = Carousel._jQueryInterface;
   $$$1.fn[NAME].Constructor = Carousel;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Carousel._jQueryInterface;
   };
   return Carousel;
 }($);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): collapse.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Collapse = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'collapse';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.collapse';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var Default = {
     toggle: true,
     parent: 
   };
   var DefaultType = {
     toggle: 'boolean',
     parent: '(string|element)'
   };
   var Event = {
     SHOW: "show" + EVENT_KEY,
     SHOWN: "shown" + EVENT_KEY,
     HIDE: "hide" + EVENT_KEY,
     HIDDEN: "hidden" + EVENT_KEY,
     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
   };
   var ClassName = {
     SHOW: 'show',
     COLLAPSE: 'collapse',
     COLLAPSING: 'collapsing',
     COLLAPSED: 'collapsed'
   };
   var Dimension = {
     WIDTH: 'width',
     HEIGHT: 'height'
   };
   var Selector = {
     ACTIVES: '.show, .collapsing',
     DATA_TOGGLE: '[data-toggle="collapse"]'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Collapse =
   /*#__PURE__*/
   function () {
     function Collapse(element, config) {
       this._isTransitioning = false;
       this._element = element;
       this._config = this._getConfig(config);
       this._triggerArray = $$$1.makeArray(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
       var toggleList = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE));
       for (var i = 0, len = toggleList.length; i < len; i++) {
         var elem = toggleList[i];
         var selector = Util.getSelectorFromElement(elem);
         var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) {
           return foundElem === element;
         });
         if (selector !== null && filterElement.length > 0) {
           this._selector = selector;
           this._triggerArray.push(elem);
         }
       }
       this._parent = this._config.parent ? this._getParent() : null;
       if (!this._config.parent) {
         this._addAriaAndCollapsedClass(this._element, this._triggerArray);
       }
       if (this._config.toggle) {
         this.toggle();
       }
     } // Getters


     var _proto = Collapse.prototype;
     // Public
     _proto.toggle = function toggle() {
       if ($$$1(this._element).hasClass(ClassName.SHOW)) {
         this.hide();
       } else {
         this.show();
       }
     };
     _proto.show = function show() {
       var _this = this;
       if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
         return;
       }
       var actives;
       var activesData;
       if (this._parent) {
         actives = [].slice.call(this._parent.querySelectorAll(Selector.ACTIVES)).filter(function (elem) {
           return elem.getAttribute('data-parent') === _this._config.parent;
         });
         if (actives.length === 0) {
           actives = null;
         }
       }
       if (actives) {
         activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
         if (activesData && activesData._isTransitioning) {
           return;
         }
       }
       var startEvent = $$$1.Event(Event.SHOW);
       $$$1(this._element).trigger(startEvent);
       if (startEvent.isDefaultPrevented()) {
         return;
       }
       if (actives) {
         Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
         if (!activesData) {
           $$$1(actives).data(DATA_KEY, null);
         }
       }
       var dimension = this._getDimension();
       $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
       this._element.style[dimension] = 0;
       if (this._triggerArray.length) {
         $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
       }
       this.setTransitioning(true);
       var complete = function complete() {
         $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
         _this._element.style[dimension] = ;
         _this.setTransitioning(false);
         $$$1(_this._element).trigger(Event.SHOWN);
       };
       var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
       var scrollSize = "scroll" + capitalizedDimension;
       var transitionDuration = Util.getTransitionDurationFromElement(this._element);
       $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
       this._element.style[dimension] = this._element[scrollSize] + "px";
     };
     _proto.hide = function hide() {
       var _this2 = this;
       if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
         return;
       }
       var startEvent = $$$1.Event(Event.HIDE);
       $$$1(this._element).trigger(startEvent);
       if (startEvent.isDefaultPrevented()) {
         return;
       }
       var dimension = this._getDimension();
       this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
       Util.reflow(this._element);
       $$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);
       var triggerArrayLength = this._triggerArray.length;
       if (triggerArrayLength > 0) {
         for (var i = 0; i < triggerArrayLength; i++) {
           var trigger = this._triggerArray[i];
           var selector = Util.getSelectorFromElement(trigger);
           if (selector !== null) {
             var $elem = $$$1([].slice.call(document.querySelectorAll(selector)));
             if (!$elem.hasClass(ClassName.SHOW)) {
               $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
             }
           }
         }
       }
       this.setTransitioning(true);
       var complete = function complete() {
         _this2.setTransitioning(false);
         $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
       };
       this._element.style[dimension] = ;
       var transitionDuration = Util.getTransitionDurationFromElement(this._element);
       $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
     };
     _proto.setTransitioning = function setTransitioning(isTransitioning) {
       this._isTransitioning = isTransitioning;
     };
     _proto.dispose = function dispose() {
       $$$1.removeData(this._element, DATA_KEY);
       this._config = null;
       this._parent = null;
       this._element = null;
       this._triggerArray = null;
       this._isTransitioning = null;
     }; // Private


     _proto._getConfig = function _getConfig(config) {
       config = _objectSpread({}, Default, config);
       config.toggle = Boolean(config.toggle); // Coerce string values
       Util.typeCheckConfig(NAME, config, DefaultType);
       return config;
     };
     _proto._getDimension = function _getDimension() {
       var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
       return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
     };
     _proto._getParent = function _getParent() {
       var _this3 = this;
       var parent = null;
       if (Util.isElement(this._config.parent)) {
         parent = this._config.parent; // It's a jQuery object
         if (typeof this._config.parent.jquery !== 'undefined') {
           parent = this._config.parent[0];
         }
       } else {
         parent = document.querySelector(this._config.parent);
       }
       var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
       var children = [].slice.call(parent.querySelectorAll(selector));
       $$$1(children).each(function (i, element) {
         _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
       });
       return parent;
     };
     _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
       if (element) {
         var isOpen = $$$1(element).hasClass(ClassName.SHOW);
         if (triggerArray.length) {
           $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
         }
       }
     }; // Static


     Collapse._getTargetFromElement = function _getTargetFromElement(element) {
       var selector = Util.getSelectorFromElement(element);
       return selector ? document.querySelector(selector) : null;
     };
     Collapse._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var $this = $$$1(this);
         var data = $this.data(DATA_KEY);
         var _config = _objectSpread({}, Default, $this.data(), typeof config === 'object' && config ? config : {});
         if (!data && _config.toggle && /show|hide/.test(config)) {
           _config.toggle = false;
         }
         if (!data) {
           data = new Collapse(this, _config);
           $this.data(DATA_KEY, data);
         }
         if (typeof config === 'string') {
           if (typeof data[config] === 'undefined') {
             throw new TypeError("No method named \"" + config + "\"");
           }
           data[config]();
         }
       });
     };
     _createClass(Collapse, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }, {
       key: "Default",
       get: function get() {
         return Default;
       }
     }]);
     return Collapse;
   }();
   /**
    * ------------------------------------------------------------------------
    * Data Api implementation
    * ------------------------------------------------------------------------
    */


   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
     // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
     if (event.currentTarget.tagName === 'A') {
       event.preventDefault();
     }
     var $trigger = $$$1(this);
     var selector = Util.getSelectorFromElement(this);
     var selectors = [].slice.call(document.querySelectorAll(selector));
     $$$1(selectors).each(function () {
       var $target = $$$1(this);
       var data = $target.data(DATA_KEY);
       var config = data ? 'toggle' : $trigger.data();
       Collapse._jQueryInterface.call($target, config);
     });
   });
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */
   $$$1.fn[NAME] = Collapse._jQueryInterface;
   $$$1.fn[NAME].Constructor = Collapse;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Collapse._jQueryInterface;
   };
   return Collapse;
 }($);
 /**!
  * @fileOverview Kickass library to create and place poppers near their reference elements.
  * @version 1.14.3
  * @license
  * Copyright (c) 2016 Federico Zivolo and contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
 var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
 var timeoutDuration = 0;
 for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
   if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
     timeoutDuration = 1;
     break;
   }
 }
 function microtaskDebounce(fn) {
   var called = false;
   return function () {
     if (called) {
       return;
     }
     called = true;
     window.Promise.resolve().then(function () {
       called = false;
       fn();
     });
   };
 }
 function taskDebounce(fn) {
   var scheduled = false;
   return function () {
     if (!scheduled) {
       scheduled = true;
       setTimeout(function () {
         scheduled = false;
         fn();
       }, timeoutDuration);
     }
   };
 }
 var supportsMicroTasks = isBrowser && window.Promise;
 /**
 * Create a debounced version of a method, that's asynchronously deferred
 * but called in the minimum time possible.
 *
 * @method
 * @memberof Popper.Utils
 * @argument {Function} fn
 * @returns {Function}
 */
 var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
 /**
  * Check if the given variable is a function
  * @method
  * @memberof Popper.Utils
  * @argument {Any} functionToCheck - variable to check
  * @returns {Boolean} answer to: is a function?
  */
 function isFunction(functionToCheck) {
   var getType = {};
   return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
 }
 /**
  * Get CSS computed property of the given element
  * @method
  * @memberof Popper.Utils
  * @argument {Eement} element
  * @argument {String} property
  */
 function getStyleComputedProperty(element, property) {
   if (element.nodeType !== 1) {
     return [];
   }
   // NOTE: 1 DOM access here
   var css = getComputedStyle(element, null);
   return property ? css[property] : css;
 }
 /**
  * Returns the parentNode or the host of the element
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @returns {Element} parent
  */
 function getParentNode(element) {
   if (element.nodeName === 'HTML') {
     return element;
   }
   return element.parentNode || element.host;
 }
 /**
  * Returns the scrolling parent of the given element
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @returns {Element} scroll parent
  */
 function getScrollParent(element) {
   // Return body, `getScroll` will take care to get the correct `scrollTop` from it
   if (!element) {
     return document.body;
   }
   switch (element.nodeName) {
     case 'HTML':
     case 'BODY':
       return element.ownerDocument.body;
     case '#document':
       return element.body;
   }
   // Firefox want us to check `-x` and `-y` variations as well
   var _getStyleComputedProp = getStyleComputedProperty(element),
       overflow = _getStyleComputedProp.overflow,
       overflowX = _getStyleComputedProp.overflowX,
       overflowY = _getStyleComputedProp.overflowY;
   if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
     return element;
   }
   return getScrollParent(getParentNode(element));
 }
 var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
 var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
 /**
  * Determines if the browser is Internet Explorer
  * @method
  * @memberof Popper.Utils
  * @param {Number} version to check
  * @returns {Boolean} isIE
  */
 function isIE(version) {
   if (version === 11) {
     return isIE11;
   }
   if (version === 10) {
     return isIE10;
   }
   return isIE11 || isIE10;
 }
 /**
  * Returns the offset parent of the given element
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @returns {Element} offset parent
  */
 function getOffsetParent(element) {
   if (!element) {
     return document.documentElement;
   }
   var noOffsetParent = isIE(10) ? document.body : null;
   // NOTE: 1 DOM access here
   var offsetParent = element.offsetParent;
   // Skip hidden elements which don't have an offsetParent
   while (offsetParent === noOffsetParent && element.nextElementSibling) {
     offsetParent = (element = element.nextElementSibling).offsetParent;
   }
   var nodeName = offsetParent && offsetParent.nodeName;
   if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
     return element ? element.ownerDocument.documentElement : document.documentElement;
   }
   // .offsetParent will return the closest TD or TABLE in case
   // no offsetParent is present, I hate this job...
   if (['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
     return getOffsetParent(offsetParent);
   }
   return offsetParent;
 }
 function isOffsetContainer(element) {
   var nodeName = element.nodeName;
   if (nodeName === 'BODY') {
     return false;
   }
   return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
 }
 /**
  * Finds the root node (document, shadowDOM root) of the given element
  * @method
  * @memberof Popper.Utils
  * @argument {Element} node
  * @returns {Element} root node
  */
 function getRoot(node) {
   if (node.parentNode !== null) {
     return getRoot(node.parentNode);
   }
   return node;
 }
 /**
  * Finds the offset parent common to the two provided nodes
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element1
  * @argument {Element} element2
  * @returns {Element} common offset parent
  */
 function findCommonOffsetParent(element1, element2) {
   // This check is needed to avoid errors in case one of the elements isn't defined for any reason
   if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
     return document.documentElement;
   }
   // Here we make sure to give as "start" the element that comes first in the DOM
   var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
   var start = order ? element1 : element2;
   var end = order ? element2 : element1;
   // Get common ancestor container
   var range = document.createRange();
   range.setStart(start, 0);
   range.setEnd(end, 0);
   var commonAncestorContainer = range.commonAncestorContainer;
   // Both nodes are inside #document
   if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
     if (isOffsetContainer(commonAncestorContainer)) {
       return commonAncestorContainer;
     }
     return getOffsetParent(commonAncestorContainer);
   }
   // one of the nodes is inside shadowDOM, find which one
   var element1root = getRoot(element1);
   if (element1root.host) {
     return findCommonOffsetParent(element1root.host, element2);
   } else {
     return findCommonOffsetParent(element1, getRoot(element2).host);
   }
 }
 /**
  * Gets the scroll value of the given element in the given side (top and left)
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @argument {String} side `top` or `left`
  * @returns {number} amount of scrolled pixels
  */
 function getScroll(element) {
   var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
   var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
   var nodeName = element.nodeName;
   if (nodeName === 'BODY' || nodeName === 'HTML') {
     var html = element.ownerDocument.documentElement;
     var scrollingElement = element.ownerDocument.scrollingElement || html;
     return scrollingElement[upperSide];
   }
   return element[upperSide];
 }
 /*
  * Sum or subtract the element scroll values (left and top) from a given rect object
  * @method
  * @memberof Popper.Utils
  * @param {Object} rect - Rect object you want to change
  * @param {HTMLElement} element - The element from the function reads the scroll values
  * @param {Boolean} subtract - set to true if you want to subtract the scroll values
  * @return {Object} rect - The modifier rect object
  */
 function includeScroll(rect, element) {
   var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var scrollTop = getScroll(element, 'top');
   var scrollLeft = getScroll(element, 'left');
   var modifier = subtract ? -1 : 1;
   rect.top += scrollTop * modifier;
   rect.bottom += scrollTop * modifier;
   rect.left += scrollLeft * modifier;
   rect.right += scrollLeft * modifier;
   return rect;
 }
 /*
  * Helper to detect borders of a given element
  * @method
  * @memberof Popper.Utils
  * @param {CSSStyleDeclaration} styles
  * Result of `getStyleComputedProperty` on the given element
  * @param {String} axis - `x` or `y`
  * @return {number} borders - The borders size of the given axis
  */
 function getBordersSize(styles, axis) {
   var sideA = axis === 'x' ? 'Left' : 'Top';
   var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
   return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
 }
 function getSize(axis, body, html, computedStyle) {
   return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? html['offset' + axis] + computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')] + computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')] : 0);
 }
 function getWindowSizes() {
   var body = document.body;
   var html = document.documentElement;
   var computedStyle = isIE(10) && getComputedStyle(html);
   return {
     height: getSize('Height', body, html, computedStyle),
     width: getSize('Width', body, html, computedStyle)
   };
 }
 var classCallCheck = function (instance, Constructor) {
   if (!(instance instanceof Constructor)) {
     throw new TypeError("Cannot call a class as a function");
   }
 };
 var createClass = function () {
   function defineProperties(target, props) {
     for (var i = 0; i < props.length; i++) {
       var descriptor = props[i];
       descriptor.enumerable = descriptor.enumerable || false;
       descriptor.configurable = true;
       if ("value" in descriptor) descriptor.writable = true;
       Object.defineProperty(target, descriptor.key, descriptor);
     }
   }
   return function (Constructor, protoProps, staticProps) {
     if (protoProps) defineProperties(Constructor.prototype, protoProps);
     if (staticProps) defineProperties(Constructor, staticProps);
     return Constructor;
   };
 }();



 var defineProperty = function (obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
     obj[key] = value;
   }
   return obj;
 };
 var _extends = Object.assign || function (target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i];
     for (var key in source) {
       if (Object.prototype.hasOwnProperty.call(source, key)) {
         target[key] = source[key];
       }
     }
   }
   return target;
 };
 /**
  * Given element offsets, generate an output similar to getBoundingClientRect
  * @method
  * @memberof Popper.Utils
  * @argument {Object} offsets
  * @returns {Object} ClientRect like output
  */
 function getClientRect(offsets) {
   return _extends({}, offsets, {
     right: offsets.left + offsets.width,
     bottom: offsets.top + offsets.height
   });
 }
 /**
  * Get bounding client rect of given element
  * @method
  * @memberof Popper.Utils
  * @param {HTMLElement} element
  * @return {Object} client rect
  */
 function getBoundingClientRect(element) {
   var rect = {};
   // IE10 10 FIX: Please, don't ask, the element isn't
   // considered in DOM in some circumstances...
   // This isn't reproducible in IE10 compatibility mode of IE11
   try {
     if (isIE(10)) {
       rect = element.getBoundingClientRect();
       var scrollTop = getScroll(element, 'top');
       var scrollLeft = getScroll(element, 'left');
       rect.top += scrollTop;
       rect.left += scrollLeft;
       rect.bottom += scrollTop;
       rect.right += scrollLeft;
     } else {
       rect = element.getBoundingClientRect();
     }
   } catch (e) {}
   var result = {
     left: rect.left,
     top: rect.top,
     width: rect.right - rect.left,
     height: rect.bottom - rect.top
   };
   // subtract scrollbar size from sizes
   var sizes = element.nodeName === 'HTML' ? getWindowSizes() : {};
   var width = sizes.width || element.clientWidth || result.right - result.left;
   var height = sizes.height || element.clientHeight || result.bottom - result.top;
   var horizScrollbar = element.offsetWidth - width;
   var vertScrollbar = element.offsetHeight - height;
   // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
   // we make this check conditional for performance reasons
   if (horizScrollbar || vertScrollbar) {
     var styles = getStyleComputedProperty(element);
     horizScrollbar -= getBordersSize(styles, 'x');
     vertScrollbar -= getBordersSize(styles, 'y');
     result.width -= horizScrollbar;
     result.height -= vertScrollbar;
   }
   return getClientRect(result);
 }
 function getOffsetRectRelativeToArbitraryNode(children, parent) {
   var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var isIE10 = isIE(10);
   var isHTML = parent.nodeName === 'HTML';
   var childrenRect = getBoundingClientRect(children);
   var parentRect = getBoundingClientRect(parent);
   var scrollParent = getScrollParent(children);
   var styles = getStyleComputedProperty(parent);
   var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
   var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
   // In cases where the parent is fixed, we must ignore negative scroll in offset calc
   if (fixedPosition && parent.nodeName === 'HTML') {
     parentRect.top = Math.max(parentRect.top, 0);
     parentRect.left = Math.max(parentRect.left, 0);
   }
   var offsets = getClientRect({
     top: childrenRect.top - parentRect.top - borderTopWidth,
     left: childrenRect.left - parentRect.left - borderLeftWidth,
     width: childrenRect.width,
     height: childrenRect.height
   });
   offsets.marginTop = 0;
   offsets.marginLeft = 0;
   // Subtract margins of documentElement in case it's being used as parent
   // we do this only on HTML because it's the only element that behaves
   // differently when margins are applied to it. The margins are included in
   // the box of the documentElement, in the other cases not.
   if (!isIE10 && isHTML) {
     var marginTop = parseFloat(styles.marginTop, 10);
     var marginLeft = parseFloat(styles.marginLeft, 10);
     offsets.top -= borderTopWidth - marginTop;
     offsets.bottom -= borderTopWidth - marginTop;
     offsets.left -= borderLeftWidth - marginLeft;
     offsets.right -= borderLeftWidth - marginLeft;
     // Attach marginTop and marginLeft because in some circumstances we may need them
     offsets.marginTop = marginTop;
     offsets.marginLeft = marginLeft;
   }
   if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
     offsets = includeScroll(offsets, parent);
   }
   return offsets;
 }
 function getViewportOffsetRectRelativeToArtbitraryNode(element) {
   var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   var html = element.ownerDocument.documentElement;
   var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
   var width = Math.max(html.clientWidth, window.innerWidth || 0);
   var height = Math.max(html.clientHeight, window.innerHeight || 0);
   var scrollTop = !excludeScroll ? getScroll(html) : 0;
   var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
   var offset = {
     top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
     left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
     width: width,
     height: height
   };
   return getClientRect(offset);
 }
 /**
  * Check if the given element is fixed or is inside a fixed parent
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @argument {Element} customContainer
  * @returns {Boolean} answer to "isFixed?"
  */
 function isFixed(element) {
   var nodeName = element.nodeName;
   if (nodeName === 'BODY' || nodeName === 'HTML') {
     return false;
   }
   if (getStyleComputedProperty(element, 'position') === 'fixed') {
     return true;
   }
   return isFixed(getParentNode(element));
 }
 /**
  * Finds the first parent of an element that has a transformed property defined
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @returns {Element} first transformed parent or documentElement
  */
 function getFixedPositionOffsetParent(element) {
   // This check is needed to avoid errors in case one of the elements isn't defined for any reason
   if (!element || !element.parentElement || isIE()) {
     return document.documentElement;
   }
   var el = element.parentElement;
   while (el && getStyleComputedProperty(el, 'transform') === 'none') {
     el = el.parentElement;
   }
   return el || document.documentElement;
 }
 /**
  * Computed the boundaries limits and return them
  * @method
  * @memberof Popper.Utils
  * @param {HTMLElement} popper
  * @param {HTMLElement} reference
  * @param {number} padding
  * @param {HTMLElement} boundariesElement - Element used to define the boundaries
  * @param {Boolean} fixedPosition - Is in fixed position mode
  * @returns {Object} Coordinates of the boundaries
  */
 function getBoundaries(popper, reference, padding, boundariesElement) {
   var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   // NOTE: 1 DOM access here
   var boundaries = { top: 0, left: 0 };
   var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
   // Handle viewport case
   if (boundariesElement === 'viewport') {
     boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
   } else {
     // Handle other cases based on DOM element used as boundaries
     var boundariesNode = void 0;
     if (boundariesElement === 'scrollParent') {
       boundariesNode = getScrollParent(getParentNode(reference));
       if (boundariesNode.nodeName === 'BODY') {
         boundariesNode = popper.ownerDocument.documentElement;
       }
     } else if (boundariesElement === 'window') {
       boundariesNode = popper.ownerDocument.documentElement;
     } else {
       boundariesNode = boundariesElement;
     }
     var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
     // In case of HTML, we need a different computation
     if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
       var _getWindowSizes = getWindowSizes(),
           height = _getWindowSizes.height,
           width = _getWindowSizes.width;
       boundaries.top += offsets.top - offsets.marginTop;
       boundaries.bottom = height + offsets.top;
       boundaries.left += offsets.left - offsets.marginLeft;
       boundaries.right = width + offsets.left;
     } else {
       // for all the other DOM elements, this one is good
       boundaries = offsets;
     }
   }
   // Add paddings
   boundaries.left += padding;
   boundaries.top += padding;
   boundaries.right -= padding;
   boundaries.bottom -= padding;
   return boundaries;
 }
 function getArea(_ref) {
   var width = _ref.width,
       height = _ref.height;
   return width * height;
 }
 /**
  * Utility used to transform the `auto` placement to the placement with more
  * available space.
  * @method
  * @memberof Popper.Utils
  * @argument {Object} data - The data object generated by update method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
   var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
   if (placement.indexOf('auto') === -1) {
     return placement;
   }
   var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
   var rects = {
     top: {
       width: boundaries.width,
       height: refRect.top - boundaries.top
     },
     right: {
       width: boundaries.right - refRect.right,
       height: boundaries.height
     },
     bottom: {
       width: boundaries.width,
       height: boundaries.bottom - refRect.bottom
     },
     left: {
       width: refRect.left - boundaries.left,
       height: boundaries.height
     }
   };
   var sortedAreas = Object.keys(rects).map(function (key) {
     return _extends({
       key: key
     }, rects[key], {
       area: getArea(rects[key])
     });
   }).sort(function (a, b) {
     return b.area - a.area;
   });
   var filteredAreas = sortedAreas.filter(function (_ref2) {
     var width = _ref2.width,
         height = _ref2.height;
     return width >= popper.clientWidth && height >= popper.clientHeight;
   });
   var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
   var variation = placement.split('-')[1];
   return computedPlacement + (variation ? '-' + variation : );
 }
 /**
  * Get offsets to the reference element
  * @method
  * @memberof Popper.Utils
  * @param {Object} state
  * @param {Element} popper - the popper element
  * @param {Element} reference - the reference element (the popper will be relative to this)
  * @param {Element} fixedPosition - is in fixed position mode
  * @returns {Object} An object containing the offsets which will be applied to the popper
  */
 function getReferenceOffsets(state, popper, reference) {
   var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
   var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
   return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
 }
 /**
  * Get the outer sizes of the given element (offset size + margins)
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element
  * @returns {Object} object containing width and height properties
  */
 function getOuterSizes(element) {
   var styles = getComputedStyle(element);
   var x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);
   var y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);
   var result = {
     width: element.offsetWidth + y,
     height: element.offsetHeight + x
   };
   return result;
 }
 /**
  * Get the opposite placement of the given one
  * @method
  * @memberof Popper.Utils
  * @argument {String} placement
  * @returns {String} flipped placement
  */
 function getOppositePlacement(placement) {
   var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
   return placement.replace(/left|right|bottom|top/g, function (matched) {
     return hash[matched];
   });
 }
 /**
  * Get offsets to the popper
  * @method
  * @memberof Popper.Utils
  * @param {Object} position - CSS position the Popper will get applied
  * @param {HTMLElement} popper - the popper element
  * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
  * @param {String} placement - one of the valid placement options
  * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
  */
 function getPopperOffsets(popper, referenceOffsets, placement) {
   placement = placement.split('-')[0];
   // Get popper node sizes
   var popperRect = getOuterSizes(popper);
   // Add position, width and height to our offsets object
   var popperOffsets = {
     width: popperRect.width,
     height: popperRect.height
   };
   // depending by the popper placement we have to compute its offsets slightly differently
   var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
   var mainSide = isHoriz ? 'top' : 'left';
   var secondarySide = isHoriz ? 'left' : 'top';
   var measurement = isHoriz ? 'height' : 'width';
   var secondaryMeasurement = !isHoriz ? 'height' : 'width';
   popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
   if (placement === secondarySide) {
     popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
   } else {
     popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
   }
   return popperOffsets;
 }
 /**
  * Mimics the `find` method of Array
  * @method
  * @memberof Popper.Utils
  * @argument {Array} arr
  * @argument prop
  * @argument value
  * @returns index or -1
  */
 function find(arr, check) {
   // use native find if supported
   if (Array.prototype.find) {
     return arr.find(check);
   }
   // use `filter` to obtain the same behavior of `find`
   return arr.filter(check)[0];
 }
 /**
  * Return the index of the matching object
  * @method
  * @memberof Popper.Utils
  * @argument {Array} arr
  * @argument prop
  * @argument value
  * @returns index or -1
  */
 function findIndex(arr, prop, value) {
   // use native findIndex if supported
   if (Array.prototype.findIndex) {
     return arr.findIndex(function (cur) {
       return cur[prop] === value;
     });
   }
   // use `find` + `indexOf` if `findIndex` isn't supported
   var match = find(arr, function (obj) {
     return obj[prop] === value;
   });
   return arr.indexOf(match);
 }
 /**
  * Loop trough the list of modifiers and run them in order,
  * each of them will then edit the data object.
  * @method
  * @memberof Popper.Utils
  * @param {dataObject} data
  * @param {Array} modifiers
  * @param {String} ends - Optional modifier name used as stopper
  * @returns {dataObject}
  */
 function runModifiers(modifiers, data, ends) {
   var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
   modifiersToRun.forEach(function (modifier) {
     if (modifier['function']) {
       // eslint-disable-line dot-notation
       console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
     }
     var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
     if (modifier.enabled && isFunction(fn)) {
       // Add properties to offsets to make them a complete clientRect object
       // we do this before each modifier to make sure the previous one doesn't
       // mess with these values
       data.offsets.popper = getClientRect(data.offsets.popper);
       data.offsets.reference = getClientRect(data.offsets.reference);
       data = fn(data, modifier);
     }
   });
   return data;
 }
 /**
  * Updates the position of the popper, computing the new offsets and applying
  * the new style.
* Prefer `scheduleUpdate` over `update` because of performance reasons. * @method * @memberof Popper */ function update() { // if popper is destroyed, don't perform any further update if (this.state.isDestroyed) { return; }
   var data = {
     instance: this,
     styles: {},
     arrowStyles: {},
     attributes: {},
     flipped: false,
     offsets: {}
   };
   // compute reference element offsets
   data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
   // compute auto placement, store placement inside the data object,
   // modifiers will be able to edit `placement` if needed
   // and refer to originalPlacement to know the original value
   data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
   // store the computed placement inside `originalPlacement`
   data.originalPlacement = data.placement;
   data.positionFixed = this.options.positionFixed;
   // compute the popper offsets
   data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
   data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
   // run the modifiers
   data = runModifiers(this.modifiers, data);
   // the first `update` will call `onCreate` callback
   // the other ones will call `onUpdate` callback
   if (!this.state.isCreated) {
     this.state.isCreated = true;
     this.options.onCreate(data);
   } else {
     this.options.onUpdate(data);
   }
 }
 /**
  * Helper used to know if the given modifier is enabled.
  * @method
  * @memberof Popper.Utils
  * @returns {Boolean}
  */
 function isModifierEnabled(modifiers, modifierName) {
   return modifiers.some(function (_ref) {
     var name = _ref.name,
         enabled = _ref.enabled;
     return enabled && name === modifierName;
   });
 }
 /**
  * Get the prefixed supported property name
  * @method
  * @memberof Popper.Utils
  * @argument {String} property (camelCase)
  * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
  */
 function getSupportedPropertyName(property) {
   var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
   var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
   for (var i = 0; i < prefixes.length; i++) {
     var prefix = prefixes[i];
     var toCheck = prefix ?  + prefix + upperProp : property;
     if (typeof document.body.style[toCheck] !== 'undefined') {
       return toCheck;
     }
   }
   return null;
 }
 /**
  * Destroy the popper
  * @method
  * @memberof Popper
  */
 function destroy() {
   this.state.isDestroyed = true;
   // touch DOM only if `applyStyle` modifier is enabled
   if (isModifierEnabled(this.modifiers, 'applyStyle')) {
     this.popper.removeAttribute('x-placement');
     this.popper.style.position = ;
     this.popper.style.top = ;
     this.popper.style.left = ;
     this.popper.style.right = ;
     this.popper.style.bottom = ;
     this.popper.style.willChange = ;
     this.popper.style[getSupportedPropertyName('transform')] = ;
   }
   this.disableEventListeners();
   // remove the popper if user explicity asked for the deletion on destroy
   // do not use `remove` because IE11 doesn't support it
   if (this.options.removeOnDestroy) {
     this.popper.parentNode.removeChild(this.popper);
   }
   return this;
 }
 /**
  * Get the window associated with the element
  * @argument {Element} element
  * @returns {Window}
  */
 function getWindow(element) {
   var ownerDocument = element.ownerDocument;
   return ownerDocument ? ownerDocument.defaultView : window;
 }
 function attachToScrollParents(scrollParent, event, callback, scrollParents) {
   var isBody = scrollParent.nodeName === 'BODY';
   var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
   target.addEventListener(event, callback, { passive: true });
   if (!isBody) {
     attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
   }
   scrollParents.push(target);
 }
 /**
  * Setup needed event listeners used to update the popper position
  * @method
  * @memberof Popper.Utils
  * @private
  */
 function setupEventListeners(reference, options, state, updateBound) {
   // Resize event listener on window
   state.updateBound = updateBound;
   getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
   // Scroll event listener on scroll parents
   var scrollElement = getScrollParent(reference);
   attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
   state.scrollElement = scrollElement;
   state.eventsEnabled = true;
   return state;
 }
 /**
  * It will add resize/scroll events and start recalculating
  * position of the popper element when they are triggered.
  * @method
  * @memberof Popper
  */
 function enableEventListeners() {
   if (!this.state.eventsEnabled) {
     this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
   }
 }
 /**
  * Remove event listeners used to update the popper position
  * @method
  * @memberof Popper.Utils
  * @private
  */
 function removeEventListeners(reference, state) {
   // Remove resize event listener on window
   getWindow(reference).removeEventListener('resize', state.updateBound);
   // Remove scroll event listener on scroll parents
   state.scrollParents.forEach(function (target) {
     target.removeEventListener('scroll', state.updateBound);
   });
   // Reset state
   state.updateBound = null;
   state.scrollParents = [];
   state.scrollElement = null;
   state.eventsEnabled = false;
   return state;
 }
 /**
  * It will remove resize/scroll events and won't recalculate popper position
  * when they are triggered. It also won't trigger onUpdate callback anymore,
  * unless you call `update` method manually.
  * @method
  * @memberof Popper
  */
 function disableEventListeners() {
   if (this.state.eventsEnabled) {
     cancelAnimationFrame(this.scheduleUpdate);
     this.state = removeEventListeners(this.reference, this.state);
   }
 }
 /**
  * Tells if a given input is a number
  * @method
  * @memberof Popper.Utils
  * @param {*} input to check
  * @return {Boolean}
  */
 function isNumeric(n) {
   return n !==  && !isNaN(parseFloat(n)) && isFinite(n);
 }
 /**
  * Set the style to the given popper
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element - Element to apply the style to
  * @argument {Object} styles
  * Object with a list of properties and values which will be applied to the element
  */
 function setStyles(element, styles) {
   Object.keys(styles).forEach(function (prop) {
     var unit = ;
     // add unit if the value is numeric and is one of the following
     if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
       unit = 'px';
     }
     element.style[prop] = styles[prop] + unit;
   });
 }
 /**
  * Set the attributes to the given popper
  * @method
  * @memberof Popper.Utils
  * @argument {Element} element - Element to apply the attributes to
  * @argument {Object} styles
  * Object with a list of properties and values which will be applied to the element
  */
 function setAttributes(element, attributes) {
   Object.keys(attributes).forEach(function (prop) {
     var value = attributes[prop];
     if (value !== false) {
       element.setAttribute(prop, attributes[prop]);
     } else {
       element.removeAttribute(prop);
     }
   });
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by `update` method
  * @argument {Object} data.styles - List of style properties - values to apply to popper element
  * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The same data object
  */
 function applyStyle(data) {
   // any property present in `data.styles` will be applied to the popper,
   // in this way we can make the 3rd party modifiers add custom styles to it
   // Be aware, modifiers could override the properties defined in the previous
   // lines of this modifier!
   setStyles(data.instance.popper, data.styles);
   // any property present in `data.attributes` will be applied to the popper,
   // they will be set as HTML attributes of the element
   setAttributes(data.instance.popper, data.attributes);
   // if arrowElement is defined and arrowStyles has some properties
   if (data.arrowElement && Object.keys(data.arrowStyles).length) {
     setStyles(data.arrowElement, data.arrowStyles);
   }
   return data;
 }
 /**
  * Set the x-placement attribute before everything else because it could be used
  * to add margins to the popper margins needs to be calculated to get the
  * correct popper offsets.
  * @method
  * @memberof Popper.modifiers
  * @param {HTMLElement} reference - The reference element used to position the popper
  * @param {HTMLElement} popper - The HTML element used as popper
  * @param {Object} options - Popper.js options
  */
 function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
   // compute reference element offsets
   var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
   // compute auto placement, store placement inside the data object,
   // modifiers will be able to edit `placement` if needed
   // and refer to originalPlacement to know the original value
   var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
   popper.setAttribute('x-placement', placement);
   // Apply `position` to popper before anything else because
   // without the position applied we can't guarantee correct computations
   setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
   return options;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by `update` method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function computeStyle(data, options) {
   var x = options.x,
       y = options.y;
   var popper = data.offsets.popper;
   // Remove this legacy support in Popper.js v2
   var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
     return modifier.name === 'applyStyle';
   }).gpuAcceleration;
   if (legacyGpuAccelerationOption !== undefined) {
     console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
   }
   var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
   var offsetParent = getOffsetParent(data.instance.popper);
   var offsetParentRect = getBoundingClientRect(offsetParent);
   // Styles
   var styles = {
     position: popper.position
   };
   // Avoid blurry text by using full pixel integers.
   // For pixel-perfect positioning, top/bottom prefers rounded
   // values, while left/right prefers floored values.
   var offsets = {
     left: Math.floor(popper.left),
     top: Math.round(popper.top),
     bottom: Math.round(popper.bottom),
     right: Math.floor(popper.right)
   };
   var sideA = x === 'bottom' ? 'top' : 'bottom';
   var sideB = y === 'right' ? 'left' : 'right';
   // if gpuAcceleration is set to `true` and transform is supported,
   //  we use `translate3d` to apply the position to the popper we
   // automatically use the supported prefixed version if needed
   var prefixedProperty = getSupportedPropertyName('transform');
   // now, let's make a step back and look at this code closely (wtf?)
   // If the content of the popper grows once it's been positioned, it
   // may happen that the popper gets misplaced because of the new content
   // overflowing its reference element
   // To avoid this problem, we provide two options (x and y), which allow
   // the consumer to define the offset origin.
   // If we position a popper on top of a reference element, we can set
   // `x` to `top` to make the popper grow towards its top instead of
   // its bottom.
   var left = void 0,
       top = void 0;
   if (sideA === 'bottom') {
     top = -offsetParentRect.height + offsets.bottom;
   } else {
     top = offsets.top;
   }
   if (sideB === 'right') {
     left = -offsetParentRect.width + offsets.right;
   } else {
     left = offsets.left;
   }
   if (gpuAcceleration && prefixedProperty) {
     styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
     styles[sideA] = 0;
     styles[sideB] = 0;
     styles.willChange = 'transform';
   } else {
     // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
     var invertTop = sideA === 'bottom' ? -1 : 1;
     var invertLeft = sideB === 'right' ? -1 : 1;
     styles[sideA] = top * invertTop;
     styles[sideB] = left * invertLeft;
     styles.willChange = sideA + ', ' + sideB;
   }
   // Attributes
   var attributes = {
     'x-placement': data.placement
   };
   // Update `data` attributes, styles and arrowStyles
   data.attributes = _extends({}, attributes, data.attributes);
   data.styles = _extends({}, styles, data.styles);
   data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
   return data;
 }
 /**
  * Helper used to know if the given modifier depends from another one.
* It checks if the needed modifier is listed and enabled. * @method * @memberof Popper.Utils * @param {Array} modifiers - list of modifiers * @param {String} requestingName - name of requesting modifier * @param {String} requestedName - name of requested modifier * @returns {Boolean} */ function isModifierRequired(modifiers, requestingName, requestedName) { var requesting = find(modifiers, function (_ref) { var name = _ref.name; return name === requestingName; });
   var isRequired = !!requesting && modifiers.some(function (modifier) {
     return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
   });
   if (!isRequired) {
     var _requesting = '`' + requestingName + '`';
     var requested = '`' + requestedName + '`';
     console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
   }
   return isRequired;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by update method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function arrow(data, options) {
   var _data$offsets$arrow;
   // arrow depends on keepTogether in order to work
   if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
     return data;
   }
   var arrowElement = options.element;
   // if arrowElement is a string, suppose it's a CSS selector
   if (typeof arrowElement === 'string') {
     arrowElement = data.instance.popper.querySelector(arrowElement);
     // if arrowElement is not found, don't run the modifier
     if (!arrowElement) {
       return data;
     }
   } else {
     // if the arrowElement isn't a query selector we must check that the
     // provided DOM node is child of its popper node
     if (!data.instance.popper.contains(arrowElement)) {
       console.warn('WARNING: `arrow.element` must be child of its popper element!');
       return data;
     }
   }
   var placement = data.placement.split('-')[0];
   var _data$offsets = data.offsets,
       popper = _data$offsets.popper,
       reference = _data$offsets.reference;
   var isVertical = ['left', 'right'].indexOf(placement) !== -1;
   var len = isVertical ? 'height' : 'width';
   var sideCapitalized = isVertical ? 'Top' : 'Left';
   var side = sideCapitalized.toLowerCase();
   var altSide = isVertical ? 'left' : 'top';
   var opSide = isVertical ? 'bottom' : 'right';
   var arrowElementSize = getOuterSizes(arrowElement)[len];
   //
   // extends keepTogether behavior making sure the popper and its
   // reference have enough pixels in conjuction
   //
   // top/left side
   if (reference[opSide] - arrowElementSize < popper[side]) {
     data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
   }
   // bottom/right side
   if (reference[side] + arrowElementSize > popper[opSide]) {
     data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
   }
   data.offsets.popper = getClientRect(data.offsets.popper);
   // compute center of the popper
   var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
   // Compute the sideValue using the updated popper offsets
   // take popper margin in account because we don't have this info available
   var css = getStyleComputedProperty(data.instance.popper);
   var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);
   var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);
   var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
   // prevent arrowElement from being placed not contiguously to its popper
   sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
   data.arrowElement = arrowElement;
   data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ), _data$offsets$arrow);
   return data;
 }
 /**
  * Get the opposite placement variation of the given one
  * @method
  * @memberof Popper.Utils
  * @argument {String} placement variation
  * @returns {String} flipped placement variation
  */
 function getOppositeVariation(variation) {
   if (variation === 'end') {
     return 'start';
   } else if (variation === 'start') {
     return 'end';
   }
   return variation;
 }
 /**
  * List of accepted placements to use as values of the `placement` option.
* Valid placements are: * - `auto` * - `top` * - `right` * - `bottom` * - `left` * * Each placement can have a variation from this list: * - `-start` * - `-end` * * Variations are interpreted easily if you think of them as the left to right * written languages. Horizontally (`top` and `bottom`), `start` is left and `end` * is right.
* Vertically (`left` and `right`), `start` is top and `end` is bottom. * * Some valid examples are: * - `top-end` (on top of reference, right aligned) * - `right-start` (on right of reference, top aligned) * - `bottom` (on bottom, centered) * - `auto-right` (on the side with more space available, alignment depends by placement) * * @static * @type {Array} * @enum {String} * @readonly * @method placements * @memberof Popper */ var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
 // Get rid of `auto` `auto-start` and `auto-end`
 var validPlacements = placements.slice(3);
 /**
  * Given an initial placement, returns all the subsequent placements
  * clockwise (or counter-clockwise).
  *
  * @method
  * @memberof Popper.Utils
  * @argument {String} placement - A valid placement (it accepts variations)
  * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
  * @returns {Array} placements including their variations
  */
 function clockwise(placement) {
   var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   var index = validPlacements.indexOf(placement);
   var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
   return counter ? arr.reverse() : arr;
 }
 var BEHAVIORS = {
   FLIP: 'flip',
   CLOCKWISE: 'clockwise',
   COUNTERCLOCKWISE: 'counterclockwise'
 };
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by update method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function flip(data, options) {
   // if `inner` modifier is enabled, we can't use the `flip` modifier
   if (isModifierEnabled(data.instance.modifiers, 'inner')) {
     return data;
   }
   if (data.flipped && data.placement === data.originalPlacement) {
     // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
     return data;
   }
   var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
   var placement = data.placement.split('-')[0];
   var placementOpposite = getOppositePlacement(placement);
   var variation = data.placement.split('-')[1] || ;
   var flipOrder = [];
   switch (options.behavior) {
     case BEHAVIORS.FLIP:
       flipOrder = [placement, placementOpposite];
       break;
     case BEHAVIORS.CLOCKWISE:
       flipOrder = clockwise(placement);
       break;
     case BEHAVIORS.COUNTERCLOCKWISE:
       flipOrder = clockwise(placement, true);
       break;
     default:
       flipOrder = options.behavior;
   }
   flipOrder.forEach(function (step, index) {
     if (placement !== step || flipOrder.length === index + 1) {
       return data;
     }
     placement = data.placement.split('-')[0];
     placementOpposite = getOppositePlacement(placement);
     var popperOffsets = data.offsets.popper;
     var refOffsets = data.offsets.reference;
     // using floor because the reference offsets may contain decimals we are not going to consider here
     var floor = Math.floor;
     var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
     var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
     var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
     var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
     var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
     var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
     // flip the variation if required
     var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
     var flippedVariation = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
     if (overlapsRef || overflowsBoundaries || flippedVariation) {
       // this boolean to detect any flip loop
       data.flipped = true;
       if (overlapsRef || overflowsBoundaries) {
         placement = flipOrder[index + 1];
       }
       if (flippedVariation) {
         variation = getOppositeVariation(variation);
       }
       data.placement = placement + (variation ? '-' + variation : );
       // this object contains `position`, we want to preserve it along with
       // any additional property we may add in the future
       data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
       data = runModifiers(data.instance.modifiers, data, 'flip');
     }
   });
   return data;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by update method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function keepTogether(data) {
   var _data$offsets = data.offsets,
       popper = _data$offsets.popper,
       reference = _data$offsets.reference;
   var placement = data.placement.split('-')[0];
   var floor = Math.floor;
   var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
   var side = isVertical ? 'right' : 'bottom';
   var opSide = isVertical ? 'left' : 'top';
   var measurement = isVertical ? 'width' : 'height';
   if (popper[side] < floor(reference[opSide])) {
     data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
   }
   if (popper[opSide] > floor(reference[side])) {
     data.offsets.popper[opSide] = floor(reference[side]);
   }
   return data;
 }
 /**
  * Converts a string containing value + unit into a px value number
  * @function
  * @memberof {modifiers~offset}
  * @private
  * @argument {String} str - Value + unit string
  * @argument {String} measurement - `height` or `width`
  * @argument {Object} popperOffsets
  * @argument {Object} referenceOffsets
  * @returns {Number|String}
  * Value in pixels, or original string if no values were extracted
  */
 function toValue(str, measurement, popperOffsets, referenceOffsets) {
   // separate value from unit
   var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
   var value = +split[1];
   var unit = split[2];
   // If it's not a number it's an operator, I guess
   if (!value) {
     return str;
   }
   if (unit.indexOf('%') === 0) {
     var element = void 0;
     switch (unit) {
       case '%p':
         element = popperOffsets;
         break;
       case '%':
       case '%r':
       default:
         element = referenceOffsets;
     }
     var rect = getClientRect(element);
     return rect[measurement] / 100 * value;
   } else if (unit === 'vh' || unit === 'vw') {
     // if is a vh or vw, we calculate the size based on the viewport
     var size = void 0;
     if (unit === 'vh') {
       size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
     } else {
       size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
     }
     return size / 100 * value;
   } else {
     // if is an explicit pixel unit, we get rid of the unit and keep the value
     // if is an implicit unit, it's px, and we return just the value
     return value;
   }
 }
 /**
  * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
  * @function
  * @memberof {modifiers~offset}
  * @private
  * @argument {String} offset
  * @argument {Object} popperOffsets
  * @argument {Object} referenceOffsets
  * @argument {String} basePlacement
  * @returns {Array} a two cells array with x and y offsets in numbers
  */
 function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
   var offsets = [0, 0];
   // Use height if placement is left or right and index is 0 otherwise use width
   // in this way the first offset will use an axis and the second one
   // will use the other one
   var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
   // Split the offset string to obtain a list of values and operands
   // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
   var fragments = offset.split(/(\+|\-)/).map(function (frag) {
     return frag.trim();
   });
   // Detect if the offset string contains a pair of values or a single one
   // they could be separated by comma or space
   var divider = fragments.indexOf(find(fragments, function (frag) {
     return frag.search(/,|\s/) !== -1;
   }));
   if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
     console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
   }
   // If divider is found, we divide the list of values and operands to divide
   // them by ofset X and Y.
   var splitRegex = /\s*,\s*|\s+/;
   var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
   // Convert the values with units to absolute pixels to allow our computations
   ops = ops.map(function (op, index) {
     // Most of the units rely on the orientation of the popper
     var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
     var mergeWithPrevious = false;
     return op
     // This aggregates any `+` or `-` sign that aren't considered operators
     // e.g.: 10 + +5 => [10, +, +5]
     .reduce(function (a, b) {
       if (a[a.length - 1] ===  && ['+', '-'].indexOf(b) !== -1) {
         a[a.length - 1] = b;
         mergeWithPrevious = true;
         return a;
       } else if (mergeWithPrevious) {
         a[a.length - 1] += b;
         mergeWithPrevious = false;
         return a;
       } else {
         return a.concat(b);
       }
     }, [])
     // Here we convert the string values into number values (in px)
     .map(function (str) {
       return toValue(str, measurement, popperOffsets, referenceOffsets);
     });
   });
   // Loop trough the offsets arrays and execute the operations
   ops.forEach(function (op, index) {
     op.forEach(function (frag, index2) {
       if (isNumeric(frag)) {
         offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
       }
     });
   });
   return offsets;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by update method
  * @argument {Object} options - Modifiers configuration and options
  * @argument {Number|String} options.offset=0
  * The offset value as described in the modifier description
  * @returns {Object} The data object, properly modified
  */
 function offset(data, _ref) {
   var offset = _ref.offset;
   var placement = data.placement,
       _data$offsets = data.offsets,
       popper = _data$offsets.popper,
       reference = _data$offsets.reference;
   var basePlacement = placement.split('-')[0];
   var offsets = void 0;
   if (isNumeric(+offset)) {
     offsets = [+offset, 0];
   } else {
     offsets = parseOffset(offset, popper, reference, basePlacement);
   }
   if (basePlacement === 'left') {
     popper.top += offsets[0];
     popper.left -= offsets[1];
   } else if (basePlacement === 'right') {
     popper.top += offsets[0];
     popper.left += offsets[1];
   } else if (basePlacement === 'top') {
     popper.left += offsets[0];
     popper.top -= offsets[1];
   } else if (basePlacement === 'bottom') {
     popper.left += offsets[0];
     popper.top += offsets[1];
   }
   data.popper = popper;
   return data;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by `update` method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function preventOverflow(data, options) {
   var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
   // If offsetParent is the reference element, we really want to
   // go one step up and use the next offsetParent as reference to
   // avoid to make this modifier completely useless and look like broken
   if (data.instance.reference === boundariesElement) {
     boundariesElement = getOffsetParent(boundariesElement);
   }
   // NOTE: DOM access here
   // resets the popper's position so that the document size can be calculated excluding
   // the size of the popper element itself
   var transformProp = getSupportedPropertyName('transform');
   var popperStyles = data.instance.popper.style; // assignment to help minification
   var top = popperStyles.top,
       left = popperStyles.left,
       transform = popperStyles[transformProp];
   popperStyles.top = ;
   popperStyles.left = ;
   popperStyles[transformProp] = ;
   var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
   // NOTE: DOM access here
   // restores the original style properties after the offsets have been computed
   popperStyles.top = top;
   popperStyles.left = left;
   popperStyles[transformProp] = transform;
   options.boundaries = boundaries;
   var order = options.priority;
   var popper = data.offsets.popper;
   var check = {
     primary: function primary(placement) {
       var value = popper[placement];
       if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
         value = Math.max(popper[placement], boundaries[placement]);
       }
       return defineProperty({}, placement, value);
     },
     secondary: function secondary(placement) {
       var mainSide = placement === 'right' ? 'left' : 'top';
       var value = popper[mainSide];
       if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
         value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
       }
       return defineProperty({}, mainSide, value);
     }
   };
   order.forEach(function (placement) {
     var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
     popper = _extends({}, popper, check[side](placement));
   });
   data.offsets.popper = popper;
   return data;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by `update` method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function shift(data) {
   var placement = data.placement;
   var basePlacement = placement.split('-')[0];
   var shiftvariation = placement.split('-')[1];
   // if shift shiftvariation is specified, run the modifier
   if (shiftvariation) {
     var _data$offsets = data.offsets,
         reference = _data$offsets.reference,
         popper = _data$offsets.popper;
     var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
     var side = isVertical ? 'left' : 'top';
     var measurement = isVertical ? 'width' : 'height';
     var shiftOffsets = {
       start: defineProperty({}, side, reference[side]),
       end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
     };
     data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
   }
   return data;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by update method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function hide(data) {
   if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
     return data;
   }
   var refRect = data.offsets.reference;
   var bound = find(data.instance.modifiers, function (modifier) {
     return modifier.name === 'preventOverflow';
   }).boundaries;
   if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
     // Avoid unnecessary DOM access if visibility hasn't changed
     if (data.hide === true) {
       return data;
     }
     data.hide = true;
     data.attributes['x-out-of-boundaries'] = ;
   } else {
     // Avoid unnecessary DOM access if visibility hasn't changed
     if (data.hide === false) {
       return data;
     }
     data.hide = false;
     data.attributes['x-out-of-boundaries'] = false;
   }
   return data;
 }
 /**
  * @function
  * @memberof Modifiers
  * @argument {Object} data - The data object generated by `update` method
  * @argument {Object} options - Modifiers configuration and options
  * @returns {Object} The data object, properly modified
  */
 function inner(data) {
   var placement = data.placement;
   var basePlacement = placement.split('-')[0];
   var _data$offsets = data.offsets,
       popper = _data$offsets.popper,
       reference = _data$offsets.reference;
   var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
   var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
   popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
   data.placement = getOppositePlacement(placement);
   data.offsets.popper = getClientRect(popper);
   return data;
 }
 /**
  * Modifier function, each modifier can have a function of this type assigned
  * to its `fn` property.
* These functions will be called on each update, this means that you must * make sure they are performant enough to avoid performance bottlenecks. * * @function ModifierFn * @argument {dataObject} data - The data object generated by `update` method * @argument {Object} options - Modifiers configuration and options * @returns {dataObject} The data object, properly modified */
 /**
  * Modifiers are plugins used to alter the behavior of your poppers.
* Popper.js uses a set of 9 modifiers to provide all the basic functionalities * needed by the library. * * Usually you don't want to override the `order`, `fn` and `onLoad` props. * All the other properties are configurations that could be tweaked. * @namespace modifiers */ var modifiers = { /** * Modifier used to shift the popper on the start or end of its reference * element.
* It will read the variation of the `placement` property.
* It can be one either `-end` or `-start`. * @memberof modifiers * @inner */ shift: { /** @prop {number} order=100 - Index used to define the order of execution */ order: 100, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: shift },
   /**
    * The `offset` modifier can shift your popper on both its axis.
    *
    * It accepts the following units:
    * - `px` or unitless, interpreted as pixels
    * - `%` or `%r`, percentage relative to the length of the reference element
    * - `%p`, percentage relative to the length of the popper element
    * - `vw`, CSS viewport width unit
    * - `vh`, CSS viewport height unit
    *
    * For length is intended the main axis relative to the placement of the popper.
* This means that if the placement is `top` or `bottom`, the length will be the * `width`. In case of `left` or `right`, it will be the height. * * You can provide a single value (as `Number` or `String`), or a pair of values * as `String` divided by a comma or one (or more) white spaces.
* The latter is a deprecated method because it leads to confusion and will be * removed in v2.
* Additionally, it accepts additions and subtractions between different units. * Note that multiplications and divisions aren't supported. * * Valid examples are: * ``` * 10 * '10%' * '10, 10' * '10%, 10' * '10 + 10%' * '10 - 5vh + 3%' * '-10px + 5vh, 5px - 6%' * ``` * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap * > with their reference element, unfortunately, you will have to disable the `flip` modifier. * > More on this [reading this issue](https://github.com/FezVrasta/popper.js/issues/373) * * @memberof modifiers * @inner */ offset: { /** @prop {number} order=200 - Index used to define the order of execution */ order: 200, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: offset, /** @prop {Number|String} offset=0 * The offset value as described in the modifier description */ offset: 0 },
   /**
    * Modifier used to prevent the popper from being positioned outside the boundary.
    *
    * An scenario exists where the reference itself is not within the boundaries.
* We can say it has "escaped the boundaries" — or just "escaped".
* In this case we need to decide whether the popper should either: * * - detach from the reference and remain "trapped" in the boundaries, or * - if it should ignore the boundary and "escape with its reference" * * When `escapeWithReference` is set to`true` and reference is completely * outside its boundaries, the popper will overflow (or completely leave) * the boundaries in order to remain attached to the edge of the reference. * * @memberof modifiers * @inner */ preventOverflow: { /** @prop {number} order=300 - Index used to define the order of execution */ order: 300, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: preventOverflow, /** * @prop {Array} [priority=['left','right','top','bottom']] * Popper will try to prevent overflow following these priorities by default, * then, it could overflow on the left and on top of the `boundariesElement` */ priority: ['left', 'right', 'top', 'bottom'], /** * @prop {number} padding=5 * Amount of pixel used to define a minimum distance between the boundaries * and the popper this makes sure the popper has always a little padding * between the edges of its container */ padding: 5, /** * @prop {String|HTMLElement} boundariesElement='scrollParent' * Boundaries used by the modifier, can be `scrollParent`, `window`, * `viewport` or any DOM element. */ boundariesElement: 'scrollParent' },
   /**
    * Modifier used to make sure the reference and its popper stay near eachothers
    * without leaving any gap between the two. Expecially useful when the arrow is
    * enabled and you want to assure it to point to its reference element.
    * It cares only about the first axis, you can still have poppers with margin
    * between the popper and its reference element.
    * @memberof modifiers
    * @inner
    */
   keepTogether: {
     /** @prop {number} order=400 - Index used to define the order of execution */
     order: 400,
     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
     enabled: true,
     /** @prop {ModifierFn} */
     fn: keepTogether
   },
   /**
    * This modifier is used to move the `arrowElement` of the popper to make
    * sure it is positioned between the reference element and its popper element.
    * It will read the outer size of the `arrowElement` node to detect how many
    * pixels of conjuction are needed.
    *
    * It has no effect if no `arrowElement` is provided.
    * @memberof modifiers
    * @inner
    */
   arrow: {
     /** @prop {number} order=500 - Index used to define the order of execution */
     order: 500,
     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
     enabled: true,
     /** @prop {ModifierFn} */
     fn: arrow,
     /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
     element: '[x-arrow]'
   },
   /**
    * Modifier used to flip the popper's placement when it starts to overlap its
    * reference element.
    *
    * Requires the `preventOverflow` modifier before it in order to work.
    *
    * **NOTE:** this modifier will interrupt the current update cycle and will
    * restart it if it detects the need to flip the placement.
    * @memberof modifiers
    * @inner
    */
   flip: {
     /** @prop {number} order=600 - Index used to define the order of execution */
     order: 600,
     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
     enabled: true,
     /** @prop {ModifierFn} */
     fn: flip,
     /**
      * @prop {String|Array} behavior='flip'
      * The behavior used to change the popper's placement. It can be one of
      * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
      * placements (with optional variations).
      */
     behavior: 'flip',
     /**
      * @prop {number} padding=5
      * The popper will flip if it hits the edges of the `boundariesElement`
      */
     padding: 5,
     /**
      * @prop {String|HTMLElement} boundariesElement='viewport'
      * The element which will define the boundaries of the popper position,
      * the popper will never be placed outside of the defined boundaries
      * (except if keepTogether is enabled)
      */
     boundariesElement: 'viewport'
   },
   /**
    * Modifier used to make the popper flow toward the inner of the reference element.
    * By default, when this modifier is disabled, the popper will be placed outside
    * the reference element.
    * @memberof modifiers
    * @inner
    */
   inner: {
     /** @prop {number} order=700 - Index used to define the order of execution */
     order: 700,
     /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
     enabled: false,
     /** @prop {ModifierFn} */
     fn: inner
   },
   /**
    * Modifier used to hide the popper when its reference element is outside of the
    * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
    * be used to hide with a CSS selector the popper when its reference is
    * out of boundaries.
    *
    * Requires the `preventOverflow` modifier before it in order to work.
    * @memberof modifiers
    * @inner
    */
   hide: {
     /** @prop {number} order=800 - Index used to define the order of execution */
     order: 800,
     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
     enabled: true,
     /** @prop {ModifierFn} */
     fn: hide
   },
   /**
    * Computes the style that will be applied to the popper element to gets
    * properly positioned.
    *
    * Note that this modifier will not touch the DOM, it just prepares the styles
    * so that `applyStyle` modifier can apply it. This separation is useful
    * in case you need to replace `applyStyle` with a custom implementation.
    *
    * This modifier has `850` as `order` value to maintain backward compatibility
    * with previous versions of Popper.js. Expect the modifiers ordering method
    * to change in future major versions of the library.
    *
    * @memberof modifiers
    * @inner
    */
   computeStyle: {
     /** @prop {number} order=850 - Index used to define the order of execution */
     order: 850,
     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
     enabled: true,
     /** @prop {ModifierFn} */
     fn: computeStyle,
     /**
      * @prop {Boolean} gpuAcceleration=true
      * If true, it uses the CSS 3d transformation to position the popper.
      * Otherwise, it will use the `top` and `left` properties.
      */
     gpuAcceleration: true,
     /**
      * @prop {string} [x='bottom']
      * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
      * Change this if your popper should grow in a direction different from `bottom`
      */
     x: 'bottom',
     /**
      * @prop {string} [x='left']
      * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
      * Change this if your popper should grow in a direction different from `right`
      */
     y: 'right'
   },
   /**
    * Applies the computed styles to the popper element.
    *
    * All the DOM manipulations are limited to this modifier. This is useful in case
    * you want to integrate Popper.js inside a framework or view library and you
    * want to delegate all the DOM manipulations to it.
    *
    * Note that if you disable this modifier, you must make sure the popper element
    * has its position set to `absolute` before Popper.js can do its work!
    *
    * Just disable this modifier and define you own to achieve the desired effect.
    *
    * @memberof modifiers
    * @inner
    */
   applyStyle: {
     /** @prop {number} order=900 - Index used to define the order of execution */
     order: 900,
     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
     enabled: true,
     /** @prop {ModifierFn} */
     fn: applyStyle,
     /** @prop {Function} */
     onLoad: applyStyleOnLoad,
     /**
      * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
      * @prop {Boolean} gpuAcceleration=true
      * If true, it uses the CSS 3d transformation to position the popper.
      * Otherwise, it will use the `top` and `left` properties.
      */
     gpuAcceleration: undefined
   }
 };
 /**
  * The `dataObject` is an object containing all the informations used by Popper.js
  * this object get passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
  * @name dataObject
  * @property {Object} data.instance The Popper.js instance
  * @property {String} data.placement Placement applied to popper
  * @property {String} data.originalPlacement Placement originally defined on init
  * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
  * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper.
  * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
  * @property {Object} data.styles Any CSS property defined here will be applied to the popper, it expects the JavaScript nomenclature (eg. `marginBottom`)
  * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow, it expects the JavaScript nomenclature (eg. `marginBottom`)
  * @property {Object} data.boundaries Offsets of the popper boundaries
  * @property {Object} data.offsets The measurements of popper, reference and arrow elements.
  * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
  * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
  * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
  */
 /**
  * Default options provided to Popper.js constructor.
* These can be overriden using the `options` argument of Popper.js.
* To override an option, simply pass as 3rd argument an object with the same * structure of this object, example: * ``` * new Popper(ref, pop, { * modifiers: { * preventOverflow: { enabled: false } * } * }) * ``` * @type {Object} * @static * @memberof Popper */ var Defaults = { /** * Popper's placement * @prop {Popper.placements} placement='bottom' */ placement: 'bottom',
   /**
    * Set this to true if you want popper to position it self in 'fixed' mode
    * @prop {Boolean} positionFixed=false
    */
   positionFixed: false,
   /**
    * Whether events (resize, scroll) are initially enabled
    * @prop {Boolean} eventsEnabled=true
    */
   eventsEnabled: true,
   /**
    * Set to true if you want to automatically remove the popper when
    * you call the `destroy` method.
    * @prop {Boolean} removeOnDestroy=false
    */
   removeOnDestroy: false,
   /**
    * Callback called when the popper is created.
* By default, is set to no-op.
* Access Popper.js instance with `data.instance`. * @prop {onCreate} */ onCreate: function onCreate() {},
   /**
    * Callback called when the popper is updated, this callback is not called
    * on the initialization/creation of the popper, but only on subsequent
    * updates.
* By default, is set to no-op.
* Access Popper.js instance with `data.instance`. * @prop {onUpdate} */ onUpdate: function onUpdate() {},
   /**
    * List of modifiers used to modify the offsets before they are applied to the popper.
    * They provide most of the functionalities of Popper.js
    * @prop {modifiers}
    */
   modifiers: modifiers
 };
 /**
  * @callback onCreate
  * @param {dataObject} data
  */
 /**
  * @callback onUpdate
  * @param {dataObject} data
  */
 // Utils
 // Methods
 var Popper = function () {
   /**
    * Create a new Popper.js instance
    * @class Popper
    * @param {HTMLElement|referenceObject} reference - The reference element used to position the popper
    * @param {HTMLElement} popper - The HTML element used as popper.
    * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
    * @return {Object} instance - The generated Popper.js instance
    */
   function Popper(reference, popper) {
     var _this = this;
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     classCallCheck(this, Popper);
     this.scheduleUpdate = function () {
       return requestAnimationFrame(_this.update);
     };
     // make update() debounced, so that it only runs at most once-per-tick
     this.update = debounce(this.update.bind(this));
     // with {} we create a new object with the options inside it
     this.options = _extends({}, Popper.Defaults, options);
     // init state
     this.state = {
       isDestroyed: false,
       isCreated: false,
       scrollParents: []
     };
     // get reference and popper elements (allow jQuery wrappers)
     this.reference = reference && reference.jquery ? reference[0] : reference;
     this.popper = popper && popper.jquery ? popper[0] : popper;
     // Deep merge modifiers options
     this.options.modifiers = {};
     Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
       _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
     });
     // Refactoring modifiers' list (Object => Array)
     this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
       return _extends({
         name: name
       }, _this.options.modifiers[name]);
     })
     // sort the modifiers by order
     .sort(function (a, b) {
       return a.order - b.order;
     });
     // modifiers have the ability to execute arbitrary code when Popper.js get inited
     // such code is executed in the same order of its modifier
     // they could add new properties to their options configuration
     // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
     this.modifiers.forEach(function (modifierOptions) {
       if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
         modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
       }
     });
     // fire the first update to position the popper in the right place
     this.update();
     var eventsEnabled = this.options.eventsEnabled;
     if (eventsEnabled) {
       // setup event listeners, they will take care of update the position in specific situations
       this.enableEventListeners();
     }
     this.state.eventsEnabled = eventsEnabled;
   }
   // We can't use class properties because they don't get listed in the
   // class prototype and break stuff like Sinon stubs


   createClass(Popper, [{
     key: 'update',
     value: function update$$1() {
       return update.call(this);
     }
   }, {
     key: 'destroy',
     value: function destroy$$1() {
       return destroy.call(this);
     }
   }, {
     key: 'enableEventListeners',
     value: function enableEventListeners$$1() {
       return enableEventListeners.call(this);
     }
   }, {
     key: 'disableEventListeners',
     value: function disableEventListeners$$1() {
       return disableEventListeners.call(this);
     }
     /**
      * Schedule an update, it will run on the next UI update available
      * @method scheduleUpdate
      * @memberof Popper
      */


     /**
      * Collection of utilities useful when writing custom modifiers.
      * Starting from version 1.7, this method is available only if you
      * include `popper-utils.js` before `popper.js`.
      *
      * **DEPRECATION**: This way to access PopperUtils is deprecated
      * and will be removed in v2! Use the PopperUtils module directly instead.
      * Due to the high instability of the methods contained in Utils, we can't
      * guarantee them to follow semver. Use them at your own risk!
      * @static
      * @private
      * @type {Object}
      * @deprecated since version 1.8
      * @member Utils
      * @memberof Popper
      */
   }]);
   return Popper;
 }();
 /**
  * The `referenceObject` is an object that provides an interface compatible with Popper.js
  * and lets you use it as replacement of a real DOM node.
* You can use this method to position a popper relatively to a set of coordinates * in case you don't have a DOM node to use as reference. * * ``` * new Popper(referenceObject, popperNode); * ``` * * NB: This feature isn't supported in Internet Explorer 10 * @name referenceObject * @property {Function} data.getBoundingClientRect * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method. * @property {number} data.clientWidth * An ES6 getter that will return the width of the virtual reference element. * @property {number} data.clientHeight * An ES6 getter that will return the height of the virtual reference element. */


 Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
 Popper.placements = placements;
 Popper.Defaults = Defaults;
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): dropdown.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Dropdown = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'dropdown';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.dropdown';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
   var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
   var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
   var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
   var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
   var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
   var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
   var Event = {
     HIDE: "hide" + EVENT_KEY,
     HIDDEN: "hidden" + EVENT_KEY,
     SHOW: "show" + EVENT_KEY,
     SHOWN: "shown" + EVENT_KEY,
     CLICK: "click" + EVENT_KEY,
     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
     KEYDOWN_DATA_API: "keydown" + EVENT_KEY + DATA_API_KEY,
     KEYUP_DATA_API: "keyup" + EVENT_KEY + DATA_API_KEY
   };
   var ClassName = {
     DISABLED: 'disabled',
     SHOW: 'show',
     DROPUP: 'dropup',
     DROPRIGHT: 'dropright',
     DROPLEFT: 'dropleft',
     MENURIGHT: 'dropdown-menu-right',
     MENULEFT: 'dropdown-menu-left',
     POSITION_STATIC: 'position-static'
   };
   var Selector = {
     DATA_TOGGLE: '[data-toggle="dropdown"]',
     FORM_CHILD: '.dropdown form',
     MENU: '.dropdown-menu',
     NAVBAR_NAV: '.navbar-nav',
     VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
   };
   var AttachmentMap = {
     TOP: 'top-start',
     TOPEND: 'top-end',
     BOTTOM: 'bottom-start',
     BOTTOMEND: 'bottom-end',
     RIGHT: 'right-start',
     RIGHTEND: 'right-end',
     LEFT: 'left-start',
     LEFTEND: 'left-end'
   };
   var Default = {
     offset: 0,
     flip: true,
     boundary: 'scrollParent',
     reference: 'toggle',
     display: 'dynamic'
   };
   var DefaultType = {
     offset: '(number|string|function)',
     flip: 'boolean',
     boundary: '(string|element)',
     reference: '(string|element)',
     display: 'string'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Dropdown =
   /*#__PURE__*/
   function () {
     function Dropdown(element, config) {
       this._element = element;
       this._popper = null;
       this._config = this._getConfig(config);
       this._menu = this._getMenuElement();
       this._inNavbar = this._detectNavbar();
       this._addEventListeners();
     } // Getters


     var _proto = Dropdown.prototype;
     // Public
     _proto.toggle = function toggle() {
       if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
         return;
       }
       var parent = Dropdown._getParentFromElement(this._element);
       var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
       Dropdown._clearMenus();
       if (isActive) {
         return;
       }
       var relatedTarget = {
         relatedTarget: this._element
       };
       var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
       $$$1(parent).trigger(showEvent);
       if (showEvent.isDefaultPrevented()) {
         return;
       } // Disable totally Popper.js for Dropdown in Navbar


       if (!this._inNavbar) {
         /**
          * Check for Popper dependency
          * Popper - https://popper.js.org
          */
         if (typeof Popper === 'undefined') {
           throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)');
         }
         var referenceElement = this._element;
         if (this._config.reference === 'parent') {
           referenceElement = parent;
         } else if (Util.isElement(this._config.reference)) {
           referenceElement = this._config.reference; // Check if it's jQuery element
           if (typeof this._config.reference.jquery !== 'undefined') {
             referenceElement = this._config.reference[0];
           }
         } // If boundary is not `scrollParent`, then set position to `static`
         // to allow the menu to "escape" the scroll parent's boundaries
         // https://github.com/twbs/bootstrap/issues/24251


         if (this._config.boundary !== 'scrollParent') {
           $$$1(parent).addClass(ClassName.POSITION_STATIC);
         }
         this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig());
       } // If this is a touch-enabled device we add extra
       // empty mouseover listeners to the body's immediate children;
       // only needed because of broken event delegation on iOS
       // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html


       if ('ontouchstart' in document.documentElement && $$$1(parent).closest(Selector.NAVBAR_NAV).length === 0) {
         $$$1(document.body).children().on('mouseover', null, $$$1.noop);
       }
       this._element.focus();
       this._element.setAttribute('aria-expanded', true);
       $$$1(this._menu).toggleClass(ClassName.SHOW);
       $$$1(parent).toggleClass(ClassName.SHOW).trigger($$$1.Event(Event.SHOWN, relatedTarget));
     };
     _proto.dispose = function dispose() {
       $$$1.removeData(this._element, DATA_KEY);
       $$$1(this._element).off(EVENT_KEY);
       this._element = null;
       this._menu = null;
       if (this._popper !== null) {
         this._popper.destroy();
         this._popper = null;
       }
     };
     _proto.update = function update() {
       this._inNavbar = this._detectNavbar();
       if (this._popper !== null) {
         this._popper.scheduleUpdate();
       }
     }; // Private


     _proto._addEventListeners = function _addEventListeners() {
       var _this = this;
       $$$1(this._element).on(Event.CLICK, function (event) {
         event.preventDefault();
         event.stopPropagation();
         _this.toggle();
       });
     };
     _proto._getConfig = function _getConfig(config) {
       config = _objectSpread({}, this.constructor.Default, $$$1(this._element).data(), config);
       Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
       return config;
     };
     _proto._getMenuElement = function _getMenuElement() {
       if (!this._menu) {
         var parent = Dropdown._getParentFromElement(this._element);
         if (parent) {
           this._menu = parent.querySelector(Selector.MENU);
         }
       }
       return this._menu;
     };
     _proto._getPlacement = function _getPlacement() {
       var $parentDropdown = $$$1(this._element.parentNode);
       var placement = AttachmentMap.BOTTOM; // Handle dropup
       if ($parentDropdown.hasClass(ClassName.DROPUP)) {
         placement = AttachmentMap.TOP;
         if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
           placement = AttachmentMap.TOPEND;
         }
       } else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
         placement = AttachmentMap.RIGHT;
       } else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
         placement = AttachmentMap.LEFT;
       } else if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
         placement = AttachmentMap.BOTTOMEND;
       }
       return placement;
     };
     _proto._detectNavbar = function _detectNavbar() {
       return $$$1(this._element).closest('.navbar').length > 0;
     };
     _proto._getPopperConfig = function _getPopperConfig() {
       var _this2 = this;
       var offsetConf = {};
       if (typeof this._config.offset === 'function') {
         offsetConf.fn = function (data) {
           data.offsets = _objectSpread({}, data.offsets, _this2._config.offset(data.offsets) || {});
           return data;
         };
       } else {
         offsetConf.offset = this._config.offset;
       }
       var popperConfig = {
         placement: this._getPlacement(),
         modifiers: {
           offset: offsetConf,
           flip: {
             enabled: this._config.flip
           },
           preventOverflow: {
             boundariesElement: this._config.boundary
           }
         } // Disable Popper.js if we have a static display
       };
       if (this._config.display === 'static') {
         popperConfig.modifiers.applyStyle = {
           enabled: false
         };
       }
       return popperConfig;
     }; // Static


     Dropdown._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var data = $$$1(this).data(DATA_KEY);
         var _config = typeof config === 'object' ? config : null;
         if (!data) {
           data = new Dropdown(this, _config);
           $$$1(this).data(DATA_KEY, data);
         }
         if (typeof config === 'string') {
           if (typeof data[config] === 'undefined') {
             throw new TypeError("No method named \"" + config + "\"");
           }
           data[config]();
         }
       });
     };
     Dropdown._clearMenus = function _clearMenus(event) {
       if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
         return;
       }
       var toggles = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE));
       for (var i = 0, len = toggles.length; i < len; i++) {
         var parent = Dropdown._getParentFromElement(toggles[i]);
         var context = $$$1(toggles[i]).data(DATA_KEY);
         var relatedTarget = {
           relatedTarget: toggles[i]
         };
         if (event && event.type === 'click') {
           relatedTarget.clickEvent = event;
         }
         if (!context) {
           continue;
         }
         var dropdownMenu = context._menu;
         if (!$$$1(parent).hasClass(ClassName.SHOW)) {
           continue;
         }
         if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $$$1.contains(parent, event.target)) {
           continue;
         }
         var hideEvent = $$$1.Event(Event.HIDE, relatedTarget);
         $$$1(parent).trigger(hideEvent);
         if (hideEvent.isDefaultPrevented()) {
           continue;
         } // If this is a touch-enabled device we remove the extra
         // empty mouseover listeners we added for iOS support


         if ('ontouchstart' in document.documentElement) {
           $$$1(document.body).children().off('mouseover', null, $$$1.noop);
         }
         toggles[i].setAttribute('aria-expanded', 'false');
         $$$1(dropdownMenu).removeClass(ClassName.SHOW);
         $$$1(parent).removeClass(ClassName.SHOW).trigger($$$1.Event(Event.HIDDEN, relatedTarget));
       }
     };
     Dropdown._getParentFromElement = function _getParentFromElement(element) {
       var parent;
       var selector = Util.getSelectorFromElement(element);
       if (selector) {
         parent = document.querySelector(selector);
       }
       return parent || element.parentNode;
     }; // eslint-disable-next-line complexity


     Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
       // If not input/textarea:
       //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
       // If input/textarea:
       //  - If space key => not a dropdown command
       //  - If key is other than escape
       //    - If key is not up or down => not a dropdown command
       //    - If trigger inside the menu => not a dropdown command
       if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $$$1(event.target).closest(Selector.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
         return;
       }
       event.preventDefault();
       event.stopPropagation();
       if (this.disabled || $$$1(this).hasClass(ClassName.DISABLED)) {
         return;
       }
       var parent = Dropdown._getParentFromElement(this);
       var isActive = $$$1(parent).hasClass(ClassName.SHOW);
       if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
         if (event.which === ESCAPE_KEYCODE) {
           var toggle = parent.querySelector(Selector.DATA_TOGGLE);
           $$$1(toggle).trigger('focus');
         }
         $$$1(this).trigger('click');
         return;
       }
       var items = [].slice.call(parent.querySelectorAll(Selector.VISIBLE_ITEMS));
       if (items.length === 0) {
         return;
       }
       var index = items.indexOf(event.target);
       if (event.which === ARROW_UP_KEYCODE && index > 0) {
         // Up
         index--;
       }
       if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
         // Down
         index++;
       }
       if (index < 0) {
         index = 0;
       }
       items[index].focus();
     };
     _createClass(Dropdown, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }, {
       key: "Default",
       get: function get() {
         return Default;
       }
     }, {
       key: "DefaultType",
       get: function get() {
         return DefaultType;
       }
     }]);
     return Dropdown;
   }();
   /**
    * ------------------------------------------------------------------------
    * Data Api implementation
    * ------------------------------------------------------------------------
    */


   $$$1(document).on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA_API + " " + Event.KEYUP_DATA_API, Dropdown._clearMenus).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
     event.preventDefault();
     event.stopPropagation();
     Dropdown._jQueryInterface.call($$$1(this), 'toggle');
   }).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function (e) {
     e.stopPropagation();
   });
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */
   $$$1.fn[NAME] = Dropdown._jQueryInterface;
   $$$1.fn[NAME].Constructor = Dropdown;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Dropdown._jQueryInterface;
   };
   return Dropdown;
 }($, Popper);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): modal.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Modal = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'modal';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.modal';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
   var Default = {
     backdrop: true,
     keyboard: true,
     focus: true,
     show: true
   };
   var DefaultType = {
     backdrop: '(boolean|string)',
     keyboard: 'boolean',
     focus: 'boolean',
     show: 'boolean'
   };
   var Event = {
     HIDE: "hide" + EVENT_KEY,
     HIDDEN: "hidden" + EVENT_KEY,
     SHOW: "show" + EVENT_KEY,
     SHOWN: "shown" + EVENT_KEY,
     FOCUSIN: "focusin" + EVENT_KEY,
     RESIZE: "resize" + EVENT_KEY,
     CLICK_DISMISS: "click.dismiss" + EVENT_KEY,
     KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY,
     MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY,
     MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY,
     CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
   };
   var ClassName = {
     SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
     BACKDROP: 'modal-backdrop',
     OPEN: 'modal-open',
     FADE: 'fade',
     SHOW: 'show'
   };
   var Selector = {
     DIALOG: '.modal-dialog',
     DATA_TOGGLE: '[data-toggle="modal"]',
     DATA_DISMISS: '[data-dismiss="modal"]',
     FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
     STICKY_CONTENT: '.sticky-top'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Modal =
   /*#__PURE__*/
   function () {
     function Modal(element, config) {
       this._config = this._getConfig(config);
       this._element = element;
       this._dialog = element.querySelector(Selector.DIALOG);
       this._backdrop = null;
       this._isShown = false;
       this._isBodyOverflowing = false;
       this._ignoreBackdropClick = false;
       this._scrollbarWidth = 0;
     } // Getters


     var _proto = Modal.prototype;
     // Public
     _proto.toggle = function toggle(relatedTarget) {
       return this._isShown ? this.hide() : this.show(relatedTarget);
     };
     _proto.show = function show(relatedTarget) {
       var _this = this;
       if (this._isTransitioning || this._isShown) {
         return;
       }
       if ($$$1(this._element).hasClass(ClassName.FADE)) {
         this._isTransitioning = true;
       }
       var showEvent = $$$1.Event(Event.SHOW, {
         relatedTarget: relatedTarget
       });
       $$$1(this._element).trigger(showEvent);
       if (this._isShown || showEvent.isDefaultPrevented()) {
         return;
       }
       this._isShown = true;
       this._checkScrollbar();
       this._setScrollbar();
       this._adjustDialog();
       $$$1(document.body).addClass(ClassName.OPEN);
       this._setEscapeEvent();
       this._setResizeEvent();
       $$$1(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, function (event) {
         return _this.hide(event);
       });
       $$$1(this._dialog).on(Event.MOUSEDOWN_DISMISS, function () {
         $$$1(_this._element).one(Event.MOUSEUP_DISMISS, function (event) {
           if ($$$1(event.target).is(_this._element)) {
             _this._ignoreBackdropClick = true;
           }
         });
       });
       this._showBackdrop(function () {
         return _this._showElement(relatedTarget);
       });
     };
     _proto.hide = function hide(event) {
       var _this2 = this;
       if (event) {
         event.preventDefault();
       }
       if (this._isTransitioning || !this._isShown) {
         return;
       }
       var hideEvent = $$$1.Event(Event.HIDE);
       $$$1(this._element).trigger(hideEvent);
       if (!this._isShown || hideEvent.isDefaultPrevented()) {
         return;
       }
       this._isShown = false;
       var transition = $$$1(this._element).hasClass(ClassName.FADE);
       if (transition) {
         this._isTransitioning = true;
       }
       this._setEscapeEvent();
       this._setResizeEvent();
       $$$1(document).off(Event.FOCUSIN);
       $$$1(this._element).removeClass(ClassName.SHOW);
       $$$1(this._element).off(Event.CLICK_DISMISS);
       $$$1(this._dialog).off(Event.MOUSEDOWN_DISMISS);
       if (transition) {
         var transitionDuration = Util.getTransitionDurationFromElement(this._element);
         $$$1(this._element).one(Util.TRANSITION_END, function (event) {
           return _this2._hideModal(event);
         }).emulateTransitionEnd(transitionDuration);
       } else {
         this._hideModal();
       }
     };
     _proto.dispose = function dispose() {
       $$$1.removeData(this._element, DATA_KEY);
       $$$1(window, document, this._element, this._backdrop).off(EVENT_KEY);
       this._config = null;
       this._element = null;
       this._dialog = null;
       this._backdrop = null;
       this._isShown = null;
       this._isBodyOverflowing = null;
       this._ignoreBackdropClick = null;
       this._scrollbarWidth = null;
     };
     _proto.handleUpdate = function handleUpdate() {
       this._adjustDialog();
     }; // Private


     _proto._getConfig = function _getConfig(config) {
       config = _objectSpread({}, Default, config);
       Util.typeCheckConfig(NAME, config, DefaultType);
       return config;
     };
     _proto._showElement = function _showElement(relatedTarget) {
       var _this3 = this;
       var transition = $$$1(this._element).hasClass(ClassName.FADE);
       if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
         // Don't move modal's DOM position
         document.body.appendChild(this._element);
       }
       this._element.style.display = 'block';
       this._element.removeAttribute('aria-hidden');
       this._element.scrollTop = 0;
       if (transition) {
         Util.reflow(this._element);
       }
       $$$1(this._element).addClass(ClassName.SHOW);
       if (this._config.focus) {
         this._enforceFocus();
       }
       var shownEvent = $$$1.Event(Event.SHOWN, {
         relatedTarget: relatedTarget
       });
       var transitionComplete = function transitionComplete() {
         if (_this3._config.focus) {
           _this3._element.focus();
         }
         _this3._isTransitioning = false;
         $$$1(_this3._element).trigger(shownEvent);
       };
       if (transition) {
         var transitionDuration = Util.getTransitionDurationFromElement(this._element);
         $$$1(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration);
       } else {
         transitionComplete();
       }
     };
     _proto._enforceFocus = function _enforceFocus() {
       var _this4 = this;
       $$$1(document).off(Event.FOCUSIN) // Guard against infinite focus loop
       .on(Event.FOCUSIN, function (event) {
         if (document !== event.target && _this4._element !== event.target && $$$1(_this4._element).has(event.target).length === 0) {
           _this4._element.focus();
         }
       });
     };
     _proto._setEscapeEvent = function _setEscapeEvent() {
       var _this5 = this;
       if (this._isShown && this._config.keyboard) {
         $$$1(this._element).on(Event.KEYDOWN_DISMISS, function (event) {
           if (event.which === ESCAPE_KEYCODE) {
             event.preventDefault();
             _this5.hide();
           }
         });
       } else if (!this._isShown) {
         $$$1(this._element).off(Event.KEYDOWN_DISMISS);
       }
     };
     _proto._setResizeEvent = function _setResizeEvent() {
       var _this6 = this;
       if (this._isShown) {
         $$$1(window).on(Event.RESIZE, function (event) {
           return _this6.handleUpdate(event);
         });
       } else {
         $$$1(window).off(Event.RESIZE);
       }
     };
     _proto._hideModal = function _hideModal() {
       var _this7 = this;
       this._element.style.display = 'none';
       this._element.setAttribute('aria-hidden', true);
       this._isTransitioning = false;
       this._showBackdrop(function () {
         $$$1(document.body).removeClass(ClassName.OPEN);
         _this7._resetAdjustments();
         _this7._resetScrollbar();
         $$$1(_this7._element).trigger(Event.HIDDEN);
       });
     };
     _proto._removeBackdrop = function _removeBackdrop() {
       if (this._backdrop) {
         $$$1(this._backdrop).remove();
         this._backdrop = null;
       }
     };
     _proto._showBackdrop = function _showBackdrop(callback) {
       var _this8 = this;
       var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : ;
       if (this._isShown && this._config.backdrop) {
         this._backdrop = document.createElement('div');
         this._backdrop.className = ClassName.BACKDROP;
         if (animate) {
           this._backdrop.classList.add(animate);
         }
         $$$1(this._backdrop).appendTo(document.body);
         $$$1(this._element).on(Event.CLICK_DISMISS, function (event) {
           if (_this8._ignoreBackdropClick) {
             _this8._ignoreBackdropClick = false;
             return;
           }
           if (event.target !== event.currentTarget) {
             return;
           }
           if (_this8._config.backdrop === 'static') {
             _this8._element.focus();
           } else {
             _this8.hide();
           }
         });
         if (animate) {
           Util.reflow(this._backdrop);
         }
         $$$1(this._backdrop).addClass(ClassName.SHOW);
         if (!callback) {
           return;
         }
         if (!animate) {
           callback();
           return;
         }
         var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
         $$$1(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration);
       } else if (!this._isShown && this._backdrop) {
         $$$1(this._backdrop).removeClass(ClassName.SHOW);
         var callbackRemove = function callbackRemove() {
           _this8._removeBackdrop();
           if (callback) {
             callback();
           }
         };
         if ($$$1(this._element).hasClass(ClassName.FADE)) {
           var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
           $$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration);
         } else {
           callbackRemove();
         }
       } else if (callback) {
         callback();
       }
     }; // ----------------------------------------------------------------------
     // the following methods are used to handle overflowing modals
     // todo (fat): these should probably be refactored out of modal.js
     // ----------------------------------------------------------------------


     _proto._adjustDialog = function _adjustDialog() {
       var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
       if (!this._isBodyOverflowing && isModalOverflowing) {
         this._element.style.paddingLeft = this._scrollbarWidth + "px";
       }
       if (this._isBodyOverflowing && !isModalOverflowing) {
         this._element.style.paddingRight = this._scrollbarWidth + "px";
       }
     };
     _proto._resetAdjustments = function _resetAdjustments() {
       this._element.style.paddingLeft = ;
       this._element.style.paddingRight = ;
     };
     _proto._checkScrollbar = function _checkScrollbar() {
       var rect = document.body.getBoundingClientRect();
       this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
       this._scrollbarWidth = this._getScrollbarWidth();
     };
     _proto._setScrollbar = function _setScrollbar() {
       var _this9 = this;
       if (this._isBodyOverflowing) {
         // Note: DOMNode.style.paddingRight returns the actual value or  if not set
         //   while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
         var fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT));
         var stickyContent = [].slice.call(document.querySelectorAll(Selector.STICKY_CONTENT)); // Adjust fixed content padding
         $$$1(fixedContent).each(function (index, element) {
           var actualPadding = element.style.paddingRight;
           var calculatedPadding = $$$1(element).css('padding-right');
           $$$1(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
         }); // Adjust sticky content margin
         $$$1(stickyContent).each(function (index, element) {
           var actualMargin = element.style.marginRight;
           var calculatedMargin = $$$1(element).css('margin-right');
           $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
         }); // Adjust body padding
         var actualPadding = document.body.style.paddingRight;
         var calculatedPadding = $$$1(document.body).css('padding-right');
         $$$1(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
       }
     };
     _proto._resetScrollbar = function _resetScrollbar() {
       // Restore fixed content padding
       var fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT));
       $$$1(fixedContent).each(function (index, element) {
         var padding = $$$1(element).data('padding-right');
         $$$1(element).removeData('padding-right');
         element.style.paddingRight = padding ? padding : ;
       }); // Restore sticky content
       var elements = [].slice.call(document.querySelectorAll("" + Selector.STICKY_CONTENT));
       $$$1(elements).each(function (index, element) {
         var margin = $$$1(element).data('margin-right');
         if (typeof margin !== 'undefined') {
           $$$1(element).css('margin-right', margin).removeData('margin-right');
         }
       }); // Restore body padding
       var padding = $$$1(document.body).data('padding-right');
       $$$1(document.body).removeData('padding-right');
       document.body.style.paddingRight = padding ? padding : ;
     };
     _proto._getScrollbarWidth = function _getScrollbarWidth() {
       // thx d.walsh
       var scrollDiv = document.createElement('div');
       scrollDiv.className = ClassName.SCROLLBAR_MEASURER;
       document.body.appendChild(scrollDiv);
       var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
       document.body.removeChild(scrollDiv);
       return scrollbarWidth;
     }; // Static


     Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
       return this.each(function () {
         var data = $$$1(this).data(DATA_KEY);
         var _config = _objectSpread({}, Default, $$$1(this).data(), typeof config === 'object' && config ? config : {});
         if (!data) {
           data = new Modal(this, _config);
           $$$1(this).data(DATA_KEY, data);
         }
         if (typeof config === 'string') {
           if (typeof data[config] === 'undefined') {
             throw new TypeError("No method named \"" + config + "\"");
           }
           data[config](relatedTarget);
         } else if (_config.show) {
           data.show(relatedTarget);
         }
       });
     };
     _createClass(Modal, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }, {
       key: "Default",
       get: function get() {
         return Default;
       }
     }]);
     return Modal;
   }();
   /**
    * ------------------------------------------------------------------------
    * Data Api implementation
    * ------------------------------------------------------------------------
    */


   $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
     var _this10 = this;
     var target;
     var selector = Util.getSelectorFromElement(this);
     if (selector) {
       target = document.querySelector(selector);
     }
     var config = $$$1(target).data(DATA_KEY) ? 'toggle' : _objectSpread({}, $$$1(target).data(), $$$1(this).data());
     if (this.tagName === 'A' || this.tagName === 'AREA') {
       event.preventDefault();
     }
     var $target = $$$1(target).one(Event.SHOW, function (showEvent) {
       if (showEvent.isDefaultPrevented()) {
         // Only register focus restorer if modal will actually get shown
         return;
       }
       $target.one(Event.HIDDEN, function () {
         if ($$$1(_this10).is(':visible')) {
           _this10.focus();
         }
       });
     });
     Modal._jQueryInterface.call($$$1(target), config, this);
   });
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */
   $$$1.fn[NAME] = Modal._jQueryInterface;
   $$$1.fn[NAME].Constructor = Modal;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Modal._jQueryInterface;
   };
   return Modal;
 }($);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): tooltip.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Tooltip = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'tooltip';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.tooltip';
   var EVENT_KEY = "." + DATA_KEY;
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var CLASS_PREFIX = 'bs-tooltip';
   var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
   var DefaultType = {
     animation: 'boolean',
     template: 'string',
     title: '(string|element|function)',
     trigger: 'string',
     delay: '(number|object)',
     html: 'boolean',
     selector: '(string|boolean)',
     placement: '(string|function)',
     offset: '(number|string)',
     container: '(string|element|boolean)',
     fallbackPlacement: '(string|array)',
     boundary: '(string|element)'
   };
   var AttachmentMap = {
     AUTO: 'auto',
     TOP: 'top',
     RIGHT: 'right',
     BOTTOM: 'bottom',
     LEFT: 'left'
   };
   var Default = {
     animation: true,
template: '
' + '
' + '
',
     trigger: 'hover focus',
     title: ,
     delay: 0,
     html: false,
     selector: false,
     placement: 'top',
     offset: 0,
     container: false,
     fallbackPlacement: 'flip',
     boundary: 'scrollParent'
   };
   var HoverState = {
     SHOW: 'show',
     OUT: 'out'
   };
   var Event = {
     HIDE: "hide" + EVENT_KEY,
     HIDDEN: "hidden" + EVENT_KEY,
     SHOW: "show" + EVENT_KEY,
     SHOWN: "shown" + EVENT_KEY,
     INSERTED: "inserted" + EVENT_KEY,
     CLICK: "click" + EVENT_KEY,
     FOCUSIN: "focusin" + EVENT_KEY,
     FOCUSOUT: "focusout" + EVENT_KEY,
     MOUSEENTER: "mouseenter" + EVENT_KEY,
     MOUSELEAVE: "mouseleave" + EVENT_KEY
   };
   var ClassName = {
     FADE: 'fade',
     SHOW: 'show'
   };
   var Selector = {
     TOOLTIP: '.tooltip',
     TOOLTIP_INNER: '.tooltip-inner',
     ARROW: '.arrow'
   };
   var Trigger = {
     HOVER: 'hover',
     FOCUS: 'focus',
     CLICK: 'click',
     MANUAL: 'manual'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Tooltip =
   /*#__PURE__*/
   function () {
     function Tooltip(element, config) {
       /**
        * Check for Popper dependency
        * Popper - https://popper.js.org
        */
       if (typeof Popper === 'undefined') {
         throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)');
       } // private


       this._isEnabled = true;
       this._timeout = 0;
       this._hoverState = ;
       this._activeTrigger = {};
       this._popper = null; // Protected
       this.element = element;
       this.config = this._getConfig(config);
       this.tip = null;
       this._setListeners();
     } // Getters


     var _proto = Tooltip.prototype;
     // Public
     _proto.enable = function enable() {
       this._isEnabled = true;
     };
     _proto.disable = function disable() {
       this._isEnabled = false;
     };
     _proto.toggleEnabled = function toggleEnabled() {
       this._isEnabled = !this._isEnabled;
     };
     _proto.toggle = function toggle(event) {
       if (!this._isEnabled) {
         return;
       }
       if (event) {
         var dataKey = this.constructor.DATA_KEY;
         var context = $$$1(event.currentTarget).data(dataKey);
         if (!context) {
           context = new this.constructor(event.currentTarget, this._getDelegateConfig());
           $$$1(event.currentTarget).data(dataKey, context);
         }
         context._activeTrigger.click = !context._activeTrigger.click;
         if (context._isWithActiveTrigger()) {
           context._enter(null, context);
         } else {
           context._leave(null, context);
         }
       } else {
         if ($$$1(this.getTipElement()).hasClass(ClassName.SHOW)) {
           this._leave(null, this);
           return;
         }
         this._enter(null, this);
       }
     };
     _proto.dispose = function dispose() {
       clearTimeout(this._timeout);
       $$$1.removeData(this.element, this.constructor.DATA_KEY);
       $$$1(this.element).off(this.constructor.EVENT_KEY);
       $$$1(this.element).closest('.modal').off('hide.bs.modal');
       if (this.tip) {
         $$$1(this.tip).remove();
       }
       this._isEnabled = null;
       this._timeout = null;
       this._hoverState = null;
       this._activeTrigger = null;
       if (this._popper !== null) {
         this._popper.destroy();
       }
       this._popper = null;
       this.element = null;
       this.config = null;
       this.tip = null;
     };
     _proto.show = function show() {
       var _this = this;
       if ($$$1(this.element).css('display') === 'none') {
         throw new Error('Please use show on visible elements');
       }
       var showEvent = $$$1.Event(this.constructor.Event.SHOW);
       if (this.isWithContent() && this._isEnabled) {
         $$$1(this.element).trigger(showEvent);
         var isInTheDom = $$$1.contains(this.element.ownerDocument.documentElement, this.element);
         if (showEvent.isDefaultPrevented() || !isInTheDom) {
           return;
         }
         var tip = this.getTipElement();
         var tipId = Util.getUID(this.constructor.NAME);
         tip.setAttribute('id', tipId);
         this.element.setAttribute('aria-describedby', tipId);
         this.setContent();
         if (this.config.animation) {
           $$$1(tip).addClass(ClassName.FADE);
         }
         var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
         var attachment = this._getAttachment(placement);
         this.addAttachmentClass(attachment);
         var container = this.config.container === false ? document.body : $$$1(document).find(this.config.container);
         $$$1(tip).data(this.constructor.DATA_KEY, this);
         if (!$$$1.contains(this.element.ownerDocument.documentElement, this.tip)) {
           $$$1(tip).appendTo(container);
         }
         $$$1(this.element).trigger(this.constructor.Event.INSERTED);
         this._popper = new Popper(this.element, tip, {
           placement: attachment,
           modifiers: {
             offset: {
               offset: this.config.offset
             },
             flip: {
               behavior: this.config.fallbackPlacement
             },
             arrow: {
               element: Selector.ARROW
             },
             preventOverflow: {
               boundariesElement: this.config.boundary
             }
           },
           onCreate: function onCreate(data) {
             if (data.originalPlacement !== data.placement) {
               _this._handlePopperPlacementChange(data);
             }
           },
           onUpdate: function onUpdate(data) {
             _this._handlePopperPlacementChange(data);
           }
         });
         $$$1(tip).addClass(ClassName.SHOW); // If this is a touch-enabled device we add extra
         // empty mouseover listeners to the body's immediate children;
         // only needed because of broken event delegation on iOS
         // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
         if ('ontouchstart' in document.documentElement) {
           $$$1(document.body).children().on('mouseover', null, $$$1.noop);
         }
         var complete = function complete() {
           if (_this.config.animation) {
             _this._fixTransition();
           }
           var prevHoverState = _this._hoverState;
           _this._hoverState = null;
           $$$1(_this.element).trigger(_this.constructor.Event.SHOWN);
           if (prevHoverState === HoverState.OUT) {
             _this._leave(null, _this);
           }
         };
         if ($$$1(this.tip).hasClass(ClassName.FADE)) {
           var transitionDuration = Util.getTransitionDurationFromElement(this.tip);
           $$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
         } else {
           complete();
         }
       }
     };
     _proto.hide = function hide(callback) {
       var _this2 = this;
       var tip = this.getTipElement();
       var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
       var complete = function complete() {
         if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
           tip.parentNode.removeChild(tip);
         }
         _this2._cleanTipClass();
         _this2.element.removeAttribute('aria-describedby');
         $$$1(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
         if (_this2._popper !== null) {
           _this2._popper.destroy();
         }
         if (callback) {
           callback();
         }
       };
       $$$1(this.element).trigger(hideEvent);
       if (hideEvent.isDefaultPrevented()) {
         return;
       }
       $$$1(tip).removeClass(ClassName.SHOW); // If this is a touch-enabled device we remove the extra
       // empty mouseover listeners we added for iOS support
       if ('ontouchstart' in document.documentElement) {
         $$$1(document.body).children().off('mouseover', null, $$$1.noop);
       }
       this._activeTrigger[Trigger.CLICK] = false;
       this._activeTrigger[Trigger.FOCUS] = false;
       this._activeTrigger[Trigger.HOVER] = false;
       if ($$$1(this.tip).hasClass(ClassName.FADE)) {
         var transitionDuration = Util.getTransitionDurationFromElement(tip);
         $$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
       } else {
         complete();
       }
       this._hoverState = ;
     };
     _proto.update = function update() {
       if (this._popper !== null) {
         this._popper.scheduleUpdate();
       }
     }; // Protected


     _proto.isWithContent = function isWithContent() {
       return Boolean(this.getTitle());
     };
     _proto.addAttachmentClass = function addAttachmentClass(attachment) {
       $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
     };
     _proto.getTipElement = function getTipElement() {
       this.tip = this.tip || $$$1(this.config.template)[0];
       return this.tip;
     };
     _proto.setContent = function setContent() {
       var tip = this.getTipElement();
       this.setElementContent($$$1(tip.querySelectorAll(Selector.TOOLTIP_INNER)), this.getTitle());
       $$$1(tip).removeClass(ClassName.FADE + " " + ClassName.SHOW);
     };
     _proto.setElementContent = function setElementContent($element, content) {
       var html = this.config.html;
       if (typeof content === 'object' && (content.nodeType || content.jquery)) {
         // Content is a DOM node or a jQuery
         if (html) {
           if (!$$$1(content).parent().is($element)) {
             $element.empty().append(content);
           }
         } else {
           $element.text($$$1(content).text());
         }
       } else {
         $element[html ? 'html' : 'text'](content);
       }
     };
     _proto.getTitle = function getTitle() {
       var title = this.element.getAttribute('data-original-title');
       if (!title) {
         title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
       }
       return title;
     }; // Private


     _proto._getAttachment = function _getAttachment(placement) {
       return AttachmentMap[placement.toUpperCase()];
     };
     _proto._setListeners = function _setListeners() {
       var _this3 = this;
       var triggers = this.config.trigger.split(' ');
       triggers.forEach(function (trigger) {
         if (trigger === 'click') {
           $$$1(_this3.element).on(_this3.constructor.Event.CLICK, _this3.config.selector, function (event) {
             return _this3.toggle(event);
           });
         } else if (trigger !== Trigger.MANUAL) {
           var eventIn = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSEENTER : _this3.constructor.Event.FOCUSIN;
           var eventOut = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSELEAVE : _this3.constructor.Event.FOCUSOUT;
           $$$1(_this3.element).on(eventIn, _this3.config.selector, function (event) {
             return _this3._enter(event);
           }).on(eventOut, _this3.config.selector, function (event) {
             return _this3._leave(event);
           });
         }
         $$$1(_this3.element).closest('.modal').on('hide.bs.modal', function () {
           return _this3.hide();
         });
       });
       if (this.config.selector) {
         this.config = _objectSpread({}, this.config, {
           trigger: 'manual',
           selector: 
         });
       } else {
         this._fixTitle();
       }
     };
     _proto._fixTitle = function _fixTitle() {
       var titleType = typeof this.element.getAttribute('data-original-title');
       if (this.element.getAttribute('title') || titleType !== 'string') {
         this.element.setAttribute('data-original-title', this.element.getAttribute('title') || );
         this.element.setAttribute('title', );
       }
     };
     _proto._enter = function _enter(event, context) {
       var dataKey = this.constructor.DATA_KEY;
       context = context || $$$1(event.currentTarget).data(dataKey);
       if (!context) {
         context = new this.constructor(event.currentTarget, this._getDelegateConfig());
         $$$1(event.currentTarget).data(dataKey, context);
       }
       if (event) {
         context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
       }
       if ($$$1(context.getTipElement()).hasClass(ClassName.SHOW) || context._hoverState === HoverState.SHOW) {
         context._hoverState = HoverState.SHOW;
         return;
       }
       clearTimeout(context._timeout);
       context._hoverState = HoverState.SHOW;
       if (!context.config.delay || !context.config.delay.show) {
         context.show();
         return;
       }
       context._timeout = setTimeout(function () {
         if (context._hoverState === HoverState.SHOW) {
           context.show();
         }
       }, context.config.delay.show);
     };
     _proto._leave = function _leave(event, context) {
       var dataKey = this.constructor.DATA_KEY;
       context = context || $$$1(event.currentTarget).data(dataKey);
       if (!context) {
         context = new this.constructor(event.currentTarget, this._getDelegateConfig());
         $$$1(event.currentTarget).data(dataKey, context);
       }
       if (event) {
         context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
       }
       if (context._isWithActiveTrigger()) {
         return;
       }
       clearTimeout(context._timeout);
       context._hoverState = HoverState.OUT;
       if (!context.config.delay || !context.config.delay.hide) {
         context.hide();
         return;
       }
       context._timeout = setTimeout(function () {
         if (context._hoverState === HoverState.OUT) {
           context.hide();
         }
       }, context.config.delay.hide);
     };
     _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
       for (var trigger in this._activeTrigger) {
         if (this._activeTrigger[trigger]) {
           return true;
         }
       }
       return false;
     };
     _proto._getConfig = function _getConfig(config) {
       config = _objectSpread({}, this.constructor.Default, $$$1(this.element).data(), typeof config === 'object' && config ? config : {});
       if (typeof config.delay === 'number') {
         config.delay = {
           show: config.delay,
           hide: config.delay
         };
       }
       if (typeof config.title === 'number') {
         config.title = config.title.toString();
       }
       if (typeof config.content === 'number') {
         config.content = config.content.toString();
       }
       Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
       return config;
     };
     _proto._getDelegateConfig = function _getDelegateConfig() {
       var config = {};
       if (this.config) {
         for (var key in this.config) {
           if (this.constructor.Default[key] !== this.config[key]) {
             config[key] = this.config[key];
           }
         }
       }
       return config;
     };
     _proto._cleanTipClass = function _cleanTipClass() {
       var $tip = $$$1(this.getTipElement());
       var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
       if (tabClass !== null && tabClass.length) {
         $tip.removeClass(tabClass.join());
       }
     };
     _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {
       var popperInstance = popperData.instance;
       this.tip = popperInstance.popper;
       this._cleanTipClass();
       this.addAttachmentClass(this._getAttachment(popperData.placement));
     };
     _proto._fixTransition = function _fixTransition() {
       var tip = this.getTipElement();
       var initConfigAnimation = this.config.animation;
       if (tip.getAttribute('x-placement') !== null) {
         return;
       }
       $$$1(tip).removeClass(ClassName.FADE);
       this.config.animation = false;
       this.hide();
       this.show();
       this.config.animation = initConfigAnimation;
     }; // Static


     Tooltip._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var data = $$$1(this).data(DATA_KEY);
         var _config = typeof config === 'object' && config;
         if (!data && /dispose|hide/.test(config)) {
           return;
         }
         if (!data) {
           data = new Tooltip(this, _config);
           $$$1(this).data(DATA_KEY, data);
         }
         if (typeof config === 'string') {
           if (typeof data[config] === 'undefined') {
             throw new TypeError("No method named \"" + config + "\"");
           }
           data[config]();
         }
       });
     };
     _createClass(Tooltip, null, [{
       key: "VERSION",
       get: function get() {
         return VERSION;
       }
     }, {
       key: "Default",
       get: function get() {
         return Default;
       }
     }, {
       key: "NAME",
       get: function get() {
         return NAME;
       }
     }, {
       key: "DATA_KEY",
       get: function get() {
         return DATA_KEY;
       }
     }, {
       key: "Event",
       get: function get() {
         return Event;
       }
     }, {
       key: "EVENT_KEY",
       get: function get() {
         return EVENT_KEY;
       }
     }, {
       key: "DefaultType",
       get: function get() {
         return DefaultType;
       }
     }]);
     return Tooltip;
   }();
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */


   $$$1.fn[NAME] = Tooltip._jQueryInterface;
   $$$1.fn[NAME].Constructor = Tooltip;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Tooltip._jQueryInterface;
   };
   return Tooltip;
 }($, Popper);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): popover.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var Popover = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'popover';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.popover';
   var EVENT_KEY = "." + DATA_KEY;
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var CLASS_PREFIX = 'bs-popover';
   var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
   var Default = _objectSpread({}, Tooltip.Default, {
     placement: 'right',
     trigger: 'click',
     content: ,
template: '
' + '
' + '

' + '
'
   });
   var DefaultType = _objectSpread({}, Tooltip.DefaultType, {
     content: '(string|element|function)'
   });
   var ClassName = {
     FADE: 'fade',
     SHOW: 'show'
   };
   var Selector = {
     TITLE: '.popover-header',
     CONTENT: '.popover-body'
   };
   var Event = {
     HIDE: "hide" + EVENT_KEY,
     HIDDEN: "hidden" + EVENT_KEY,
     SHOW: "show" + EVENT_KEY,
     SHOWN: "shown" + EVENT_KEY,
     INSERTED: "inserted" + EVENT_KEY,
     CLICK: "click" + EVENT_KEY,
     FOCUSIN: "focusin" + EVENT_KEY,
     FOCUSOUT: "focusout" + EVENT_KEY,
     MOUSEENTER: "mouseenter" + EVENT_KEY,
     MOUSELEAVE: "mouseleave" + EVENT_KEY
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var Popover =
   /*#__PURE__*/
   function (_Tooltip) {
     _inheritsLoose(Popover, _Tooltip);
     function Popover() {
       return _Tooltip.apply(this, arguments) || this;
     }
     var _proto = Popover.prototype;
     // Overrides
     _proto.isWithContent = function isWithContent() {
       return this.getTitle() || this._getContent();
     };
     _proto.addAttachmentClass = function addAttachmentClass(attachment) {
       $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
     };
     _proto.getTipElement = function getTipElement() {
       this.tip = this.tip || $$$1(this.config.template)[0];
       return this.tip;
     };
     _proto.setContent = function setContent() {
       var $tip = $$$1(this.getTipElement()); // We use append for html objects to maintain js events
       this.setElementContent($tip.find(Selector.TITLE), this.getTitle());
       var content = this._getContent();
       if (typeof content === 'function') {
         content = content.call(this.element);
       }
       this.setElementContent($tip.find(Selector.CONTENT), content);
       $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
     }; // Private


     _proto._getContent = function _getContent() {
       return this.element.getAttribute('data-content') || this.config.content;
     };
     _proto._cleanTipClass = function _cleanTipClass() {
       var $tip = $$$1(this.getTipElement());
       var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
       if (tabClass !== null && tabClass.length > 0) {
         $tip.removeClass(tabClass.join());
       }
     }; // Static


     Popover._jQueryInterface = function _jQueryInterface(config) {
       return this.each(function () {
         var data = $$$1(this).data(DATA_KEY);
         var _config = typeof config === 'object' ? config : null;
         if (!data && /destroy|hide/.test(config)) {
           return;
         }
         if (!data) {
           data = new Popover(this, _config);
           $$$1(this).data(DATA_KEY, data);
         }
         if (typeof config === 'string') {
           if (typeof data[config] === 'undefined') {
             throw new TypeError("No method named \"" + config + "\"");
           }
           data[config]();
         }
       });
     };
     _createClass(Popover, null, [{
       key: "VERSION",
       // Getters
       get: function get() {
         return VERSION;
       }
     }, {
       key: "Default",
       get: function get() {
         return Default;
       }
     }, {
       key: "NAME",
       get: function get() {
         return NAME;
       }
     }, {
       key: "DATA_KEY",
       get: function get() {
         return DATA_KEY;
       }
     }, {
       key: "Event",
       get: function get() {
         return Event;
       }
     }, {
       key: "EVENT_KEY",
       get: function get() {
         return EVENT_KEY;
       }
     }, {
       key: "DefaultType",
       get: function get() {
         return DefaultType;
       }
     }]);
     return Popover;
   }(Tooltip);
   /**
    * ------------------------------------------------------------------------
    * jQuery
    * ------------------------------------------------------------------------
    */


   $$$1.fn[NAME] = Popover._jQueryInterface;
   $$$1.fn[NAME].Constructor = Popover;
   $$$1.fn[NAME].noConflict = function () {
     $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
     return Popover._jQueryInterface;
   };
   return Popover;
 }($);
 /**
  * --------------------------------------------------------------------------
  * Bootstrap (v4.1.3): scrollspy.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  * --------------------------------------------------------------------------
  */
 var ScrollSpy = function ($$$1) {
   /**
    * ------------------------------------------------------------------------
    * Constants
    * ------------------------------------------------------------------------
    */
   var NAME = 'scrollspy';
   var VERSION = '4.1.3';
   var DATA_KEY = 'bs.scrollspy';
   var EVENT_KEY = "." + DATA_KEY;
   var DATA_API_KEY = '.data-api';
   var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
   var Default = {
     offset: 10,
     method: 'auto',
     target: 
   };
   var DefaultType = {
     offset: 'number',
     method: 'string',
     target: '(string|element)'
   };
   var Event = {
     ACTIVATE: "activate" + EVENT_KEY,
     SCROLL: "scroll" + EVENT_KEY,
     LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY
   };
   var ClassName = {
     DROPDOWN_ITEM: 'dropdown-item',
     DROPDOWN_MENU: 'dropdown-menu',
     ACTIVE: 'active'
   };
   var Selector = {
     DATA_SPY: '[data-spy="scroll"]',
     ACTIVE: '.active',
     NAV_LIST_GROUP: '.nav, .list-group',
     NAV_LINKS: '.nav-link',
     NAV_ITEMS: '.nav-item',
     LIST_ITEMS: '.list-group-item',
     DROPDOWN: '.dropdown',
     DROPDOWN_ITEMS: '.dropdown-item',
     DROPDOWN_TOGGLE: '.dropdown-toggle'
   };
   var OffsetMethod = {
     OFFSET: 'offset',
     POSITION: 'position'
     /**
      * ------------------------------------------------------------------------
      * Class Definition
      * ------------------------------------------------------------------------
      */
   };
   var ScrollSpy =
   /*#__PURE__*/
   function () {
     function ScrollSpy(element, config) {
       var _this = this;
       this._element = element;
       this._scrollElement = element.tagName === 'BODY' ? window : element;
       this._config = this._getConfig(config);
       this._selector = this._config.target + " " + Selector.NAV_LINKS + "," + (this._config.target + " " + Selector.LIST_ITEMS + ",") + (this._config.target + " " + Selector.DROPDOWN_ITEMS);
       this._offsets = [];
       this._targets = [];
       this._activeTarget = null;
       this._scrollHeight = 0;
       $$$1(this._scrollElement).on(Event.SCROLL, function (event) {
         return _this._process(event);
       });
       this.refresh();
       this._process();
     } // Getters


     var _proto = ScrollSpy.prototype;
     // Public
     _proto.refresh = function refresh() {
       var _this2 = this;
       var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
       var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
       var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
       this._offsets = [];
       this._targets = [];
       this._scrollHeight = this._getScrollHeight();
       var targets = [].slice.call(document.querySelectorAll(this._selector));
       targets.map(function (element) {
         var target;
         var targetSelector = Util.getSelectorFromElement(element);
         if (targetSelector) {
           target = document.querySelector(targetSelector);
         }
         if (target) {
           var targetBCR = target.getBoundingClientRect();
           if (targetBCR.width || targetBCR.height) {
             // TODO (fat): remove sketch reliance on jQuery position/offset
             return [$$$1(target)[offsetMethod]().top + offsetBase, targetSelector];
           }
         }
         return null;
       }).filter(function (item) {
         return item;
       }).sort(function (a, b) {
         return a[0] - b[0];
       }).forEach(function (item) {
         _this2._offsets.push(item[0]);
         _this2._targets.push(item[1]);
       });
     };
     _proto.dispose = function dispose() {
       $$$1.removeData(this._element, DATA_KEY);
       $$$1(this._scrollElement).off(EVENT_KEY);
       this._element = null;
       this._scrollElement = null;
       this._config = null;
       this._selector = null;
       this._offsets = null;
       this._targets = null;
       this._activeTarget = null;
       this._scrollHeight = null;
     }; // Private


     _proto._getConfig = function _getConfig(config) {
       config = _objectSpread({}, Default, typeof config === 'object' && config ? config : {});
       if (typeof config.target !== 'string') {
         var id = $$$1(config.target).attr('id');
         if (!id) {
           id = Util.getUID(NAME);
           $$$1(config.target).attr('id', id);
         }
         config.target = "#" + id;
       }
       Util.typeCheckConfig(NAME, config, DefaultType);
       return config;
     };
     _proto._getScrollTop = function _getScrollTop() {
       return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
     };
     _proto._getScrollHeight = function _getScrollHeight() {
       return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
     };
     _proto._getOffsetHeight = function _getOffsetHeight() {
       return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
     };
     _proto._process = function _process() {
       var scrollTop = this._getScrollTop() + this._config.offset;
       var scrollHeight = this._getScrollHeight();
       var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
       if (this._scrollHeight !== scrollHeight) {
         this.refresh();
       }
       if (scrollTop >= maxScroll) {
         var target = this._targets[this._targets.length - 1];
         if (this._activeTarget !== target) {
           this._activate(target);
         }
         return;
       }
       if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
         this._activeTarget = null;
         this._clear();
         return;
       }
       var offsetLength = this._offsets.length;
       for (var i = offsetLength; i--;) {
         var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
         if (isActiveTarget) {
           this._activate(this._targets[i]);
         }
       }
     };
     _proto._activate = function _activate(target) {
       this._activeTarget = target;
       this._clear();
       var queries = this._selector.split(','); // eslint-disable-next-line arrow-body-style


       queries = queries.map(function (selector) {
         return selector + "[data-target=\"" + target + "\"]," + (selector + "[href=\"" + target + "\"]");
       });
       var $link = $$$1([].slice.call(document.querySelectorAll(queries.join(','))));
       if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
         $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
         $link.addClass(ClassName.ACTIVE);
       } else {
         // Set triggered link as active
         $link.addClass(ClassName.ACTIVE); // Set triggered links parents as active
// With both
    and <nav> markup a parent is the previous sibling of any nav ancestor $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_LINKS + ", " + Selector.LIST_ITEMS).addClass(ClassName.ACTIVE); // Handle special case when .nav-link is inside .nav-item $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE); } $$$1(this._scrollElement).trigger(Event.ACTIVATE, { relatedTarget: target }); }; _proto._clear = function _clear() { var nodes = [].slice.call(document.querySelectorAll(this._selector)); $$$1(nodes).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE); }; // Static ScrollSpy._jQueryInterface = function _jQueryInterface(config) { return this.each(function () { var data = $$$1(this).data(DATA_KEY); var _config = typeof config === 'object' && config; if (!data) { data = new ScrollSpy(this, _config); $$$1(this).data(DATA_KEY, data); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { throw new TypeError("No method named \"" + config + "\""); } data[config](); } }); }; _createClass(ScrollSpy, null, [{ key: "VERSION", get: function get() { return VERSION; } }, { key: "Default", get: function get() { return Default; } }]); return ScrollSpy; }(); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ $$$1(window).on(Event.LOAD_DATA_API, function () { var scrollSpys = [].slice.call(document.querySelectorAll(Selector.DATA_SPY)); var scrollSpysLength = scrollSpys.length; for (var i = scrollSpysLength; i--;) { var $spy = $$$1(scrollSpys[i]); ScrollSpy._jQueryInterface.call($spy, $spy.data()); } }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ */ $$$1.fn[NAME] = ScrollSpy._jQueryInterface; $$$1.fn[NAME].Constructor = ScrollSpy; $$$1.fn[NAME].noConflict = function () { $$$1.fn[NAME] = JQUERY_NO_CONFLICT; return ScrollSpy._jQueryInterface; }; return ScrollSpy; }($); /** * -------------------------------------------------------------------------- * Bootstrap (v4.1.3): tab.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) * -------------------------------------------------------------------------- */ var Tab = function ($$$1) { /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME = 'tab'; var VERSION = '4.1.3'; var DATA_KEY = 'bs.tab'; var EVENT_KEY = "." + DATA_KEY; var DATA_API_KEY = '.data-api'; var JQUERY_NO_CONFLICT = $$$1.fn[NAME]; var Event = { HIDE: "hide" + EVENT_KEY, HIDDEN: "hidden" + EVENT_KEY, SHOW: "show" + EVENT_KEY, SHOWN: "shown" + EVENT_KEY, CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY }; var ClassName = { DROPDOWN_MENU: 'dropdown-menu', ACTIVE: 'active', DISABLED: 'disabled', FADE: 'fade', SHOW: 'show' }; var Selector = { DROPDOWN: '.dropdown', NAV_LIST_GROUP: '.nav, .list-group', ACTIVE: '.active', ACTIVE_UL: '> li > .active', DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]', DROPDOWN_TOGGLE: '.dropdown-toggle', DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active' /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ }; var Tab = /*#__PURE__*/ function () { function Tab(element) { this._element = element; } // Getters var _proto = Tab.prototype; // Public _proto.show = function show() { var _this = this; if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) { return; } var target; var previous; var listElement = $$$1(this._element).closest(Selector.NAV_LIST_GROUP)[0]; var selector = Util.getSelectorFromElement(this._element); if (listElement) { var itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE; previous = $$$1.makeArray($$$1(listElement).find(itemSelector)); previous = previous[previous.length - 1]; } var hideEvent = $$$1.Event(Event.HIDE, { relatedTarget: this._element }); var showEvent = $$$1.Event(Event.SHOW, { relatedTarget: previous }); if (previous) { $$$1(previous).trigger(hideEvent); } $$$1(this._element).trigger(showEvent); if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { return; } if (selector) { target = document.querySelector(selector); } this._activate(this._element, listElement); var complete = function complete() { var hiddenEvent = $$$1.Event(Event.HIDDEN, { relatedTarget: _this._element }); var shownEvent = $$$1.Event(Event.SHOWN, { relatedTarget: previous }); $$$1(previous).trigger(hiddenEvent); $$$1(_this._element).trigger(shownEvent); }; if (target) { this._activate(target, target.parentNode, complete); } else { complete(); } }; _proto.dispose = function dispose() { $$$1.removeData(this._element, DATA_KEY); this._element = null; }; // Private _proto._activate = function _activate(element, container, callback) { var _this2 = this; var activeElements; if (container.nodeName === 'UL') { activeElements = $$$1(container).find(Selector.ACTIVE_UL); } else { activeElements = $$$1(container).children(Selector.ACTIVE); } var active = activeElements[0]; var isTransitioning = callback && active && $$$1(active).hasClass(ClassName.FADE); var complete = function complete() { return _this2._transitionComplete(element, active, callback); }; if (active && isTransitioning) { var transitionDuration = Util.getTransitionDurationFromElement(active); $$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); } else { complete(); } }; _proto._transitionComplete = function _transitionComplete(element, active, callback) { if (active) { $$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE); var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0]; if (dropdownChild) { $$$1(dropdownChild).removeClass(ClassName.ACTIVE); } if (active.getAttribute('role') === 'tab') { active.setAttribute('aria-selected', false); } } $$$1(element).addClass(ClassName.ACTIVE); if (element.getAttribute('role') === 'tab') { element.setAttribute('aria-selected', true); } Util.reflow(element); $$$1(element).addClass(ClassName.SHOW); if (element.parentNode && $$$1(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) { var dropdownElement = $$$1(element).closest(Selector.DROPDOWN)[0]; if (dropdownElement) { var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector.DROPDOWN_TOGGLE)); $$$1(dropdownToggleList).addClass(ClassName.ACTIVE); } element.setAttribute('aria-expanded', true); } if (callback) { callback(); } }; // Static Tab._jQueryInterface = function _jQueryInterface(config) { return this.each(function () { var $this = $$$1(this); var data = $this.data(DATA_KEY); if (!data) { data = new Tab(this); $this.data(DATA_KEY, data); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { throw new TypeError("No method named \"" + config + "\""); } data[config](); } }); }; _createClass(Tab, null, [{ key: "VERSION", get: function get() { return VERSION; } }]); return Tab; }(); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) { event.preventDefault(); Tab._jQueryInterface.call($$$1(this), 'show'); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ */ $$$1.fn[NAME] = Tab._jQueryInterface; $$$1.fn[NAME].Constructor = Tab; $$$1.fn[NAME].noConflict = function () { $$$1.fn[NAME] = JQUERY_NO_CONFLICT; return Tab._jQueryInterface; }; return Tab; }($); /** * -------------------------------------------------------------------------- * Bootstrap (v4.1.3): index.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) * -------------------------------------------------------------------------- */ (function ($$$1) { if (typeof $$$1 === 'undefined') { throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); } var version = $$$1.fn.jquery.split(' ')[0].split('.'); var minMajor = 1; var ltMajor = 2; var minMinor = 9; var minPatch = 1; var maxMajor = 4; if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) { throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); } })($); exports.Util = Util; exports.Alert = Alert; exports.Button = Button; exports.Carousel = Carousel; exports.Collapse = Collapse; exports.Dropdown = Dropdown; exports.Modal = Modal; exports.Popover = Popover; exports.Scrollspy = ScrollSpy; exports.Tab = Tab; exports.Tooltip = Tooltip; Object.defineProperty(exports, '__esModule', { value: true }); }))); //# sourceMappingURL=bootstrap.bundle.js.map /*! * jQuery JavaScript Library v3.3.1 * https://jquery.com/ * * Includes Sizzle.js * https://sizzlejs.com/ * * Copyright JS Foundation and other contributors * Released under the MIT license * https://jquery.org/license * * Date: 2018-01-20T17:24Z */ ( function( global, factory ) { "use strict"; if ( typeof module === "object" && typeof module.exports === "object" ) { // For CommonJS and CommonJS-like environments where a proper `window` // is present, execute the factory and get jQuery. // For environments that do not have a `window` with a `document` // (such as Node.js), expose a factory as module.exports. // This accentuates the need for the creation of a real `window`. // e.g. var jQuery = require("jquery")(window); // See ticket #14549 for more info. module.exports = global.document ? factory( global, true ) : function( w ) { if ( !w.document ) { throw new Error( "jQuery requires a window with a document" ); } return factory( w ); }; } else { factory( global ); } // Pass this if window is not defined yet } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common // enough that all such attempts are guarded in a try block. "use strict"; var arr = []; var document = window.document; var getProto = Object.getPrototypeOf; var slice = arr.slice; var concat = arr.concat; var push = arr.push; var indexOf = arr.indexOf; var class2type = {}; var toString = class2type.toString; var hasOwn = class2type.hasOwnProperty; var fnToString = hasOwn.toString; var ObjectFunctionString = fnToString.call( Object ); var support = {}; var isFunction = function isFunction( obj ) { // Support: Chrome <=57, Firefox <=52 // In some browsers, typeof returns "function" for HTML <object> elements // (i.e., `typeof document.createElement( "object" ) === "function"`). // We don't want to classify *any* DOM node as a function. return typeof obj === "function" && typeof obj.nodeType !== "number"; }; var isWindow = function isWindow( obj ) { return obj != null && obj === obj.window; }; var preservedScriptAttributes = { type: true, src: true, noModule: true }; function DOMEval( code, doc, node ) { doc = doc || document; var i, script = doc.createElement( "script" ); script.text = code; if ( node ) { for ( i in preservedScriptAttributes ) { if ( node[ i ] ) { script[ i ] = node[ i ]; } } } doc.head.appendChild( script ).parentNode.removeChild( script ); } function toType( obj ) { if ( obj == null ) { return obj + ""; } // Support: Android <=2.3 only (functionish RegExp) return typeof obj === "object" || typeof obj === "function" ? class2type[ toString.call( obj ) ] || "object" : typeof obj; } /* global Symbol */ // Defining this global in .eslintrc.json would create a danger of using the global // unguarded in another place, it seems safer to define global only for this module var version = "3.3.1", // Define a local copy of jQuery jQuery = function( selector, context ) { // The jQuery object is actually just the init constructor 'enhanced' // Need init if jQuery is called (just allow error to be thrown if not included) return new jQuery.fn.init( selector, context ); }, // Support: Android <=4.0 only // Make sure we trim BOM and NBSP rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g; jQuery.fn = jQuery.prototype = { // The current version of jQuery being used jquery: version, constructor: jQuery, // The default length of a jQuery object is 0 length: 0, toArray: function() { return slice.call( this ); }, // Get the Nth element in the matched element set OR // Get the whole matched element set as a clean array get: function( num ) { // Return all the elements in a clean array if ( num == null ) { return slice.call( this ); } // Return just the one element from the set return num < 0 ? this[ num + this.length ] : this[ num ]; }, // Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems ) { // Build a new jQuery matched element set var ret = jQuery.merge( this.constructor(), elems ); // Add the old object onto the stack (as a reference) ret.prevObject = this; // Return the newly-formed element set return ret; }, // Execute a callback for every element in the matched set. each: function( callback ) { return jQuery.each( this, callback ); }, map: function( callback ) { return this.pushStack( jQuery.map( this, function( elem, i ) { return callback.call( elem, i, elem ); } ) ); }, slice: function() { return this.pushStack( slice.apply( this, arguments ) ); }, first: function() { return this.eq( 0 ); }, last: function() { return this.eq( -1 ); }, eq: function( i ) { var len = this.length, j = +i + ( i < 0 ? len : 0 ); return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); }, end: function() { return this.prevObject || this.constructor(); }, // For internal use only. // Behaves like an Array's method, not like a jQuery method. push: push, sort: arr.sort, splice: arr.splice }; jQuery.extend = jQuery.fn.extend = function() { var options, name, src, copy, copyIsArray, clone, target = arguments[ 0 ] || {}, i = 1, length = arguments.length, deep = false; // Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target; // Skip the boolean and the target target = arguments[ i ] || {}; i++; } // Handle case when target is a string or something (possible in deep copy) if ( typeof target !== "object" && !isFunction( target ) ) { target = {}; } // Extend jQuery itself if only one argument is passed if ( i === length ) { target = this; i--; } for ( ; i < length; i++ ) { // Only deal with non-null/undefined values if ( ( options = arguments[ i ] ) != null ) { // Extend the base object for ( name in options ) { src = target[ name ]; copy = options[ name ]; // Prevent never-ending loop if ( target === copy ) { continue; } // Recurse if we're merging plain objects or arrays if ( deep && copy && ( jQuery.isPlainObject( copy ) || ( copyIsArray = Array.isArray( copy ) ) ) ) { if ( copyIsArray ) { copyIsArray = false; clone = src && Array.isArray( src ) ? src : []; } else { clone = src && jQuery.isPlainObject( src ) ? src : {}; } // Never move original objects, clone them target[ name ] = jQuery.extend( deep, clone, copy ); // Don't bring in undefined values } else if ( copy !== undefined ) { target[ name ] = copy; } } } } // Return the modified object return target; }; jQuery.extend( { // Unique for each copy of jQuery on the page expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), // Assume jQuery is ready without the ready module isReady: true, error: function( msg ) { throw new Error( msg ); }, noop: function() {}, isPlainObject: function( obj ) { var proto, Ctor; // Detect obvious negatives // Use toString instead of jQuery.type to catch host objects if ( !obj || toString.call( obj ) !== "[object Object]" ) { return false; } proto = getProto( obj ); // Objects with no prototype (e.g., `Object.create( null )`) are plain if ( !proto ) { return true; } // Objects with prototype are plain iff they were constructed by a global Object function Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; }, isEmptyObject: function( obj ) { /* eslint-disable no-unused-vars */ // See https://github.com/eslint/eslint/issues/6125 var name; for ( name in obj ) { return false; } return true; }, // Evaluates a script in a global context globalEval: function( code ) { DOMEval( code ); }, each: function( obj, callback ) { var length, i = 0; if ( isArrayLike( obj ) ) { length = obj.length; for ( ; i < length; i++ ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } else { for ( i in obj ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } return obj; }, // Support: Android <=4.0 only trim: function( text ) { return text == null ? "" : ( text + "" ).replace( rtrim, "" ); }, // results is for internal usage only makeArray: function( arr, results ) { var ret = results || []; if ( arr != null ) { if ( isArrayLike( Object( arr ) ) ) { jQuery.merge( ret, typeof arr === "string" ? [ arr ] : arr ); } else { push.call( ret, arr ); } } return ret; }, inArray: function( elem, arr, i ) { return arr == null ? -1 : indexOf.call( arr, elem, i ); }, // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit merge: function( first, second ) { var len = +second.length, j = 0, i = first.length; for ( ; j < len; j++ ) { first[ i++ ] = second[ j ]; } first.length = i; return first; }, grep: function( elems, callback, invert ) { var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; // Go through the array, only saving the items // that pass the validator function for ( ; i < length; i++ ) { callbackInverse = !callback( elems[ i ], i ); if ( callbackInverse !== callbackExpect ) { matches.push( elems[ i ] ); } } return matches; }, // arg is for internal usage only map: function( elems, callback, arg ) { var length, value, i = 0, ret = []; // Go through the array, translating each of the items to their new values if ( isArrayLike( elems ) ) { length = elems.length; for ( ; i < length; i++ ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } // Go through every key on the object, } else { for ( i in elems ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } } // Flatten any nested arrays return concat.apply( [], ret ); }, // A global GUID counter for objects guid: 1, // jQuery.support is not used in Core but other projects attach their // properties to it so it needs to exist. support: support } ); if ( typeof Symbol === "function" ) { jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; } // Populate the class2type map jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), function( i, name ) { class2type[ "[object " + name + "]" ] = name.toLowerCase(); } ); function isArrayLike( obj ) { // Support: real iOS 8.2 only (not reproducible in simulator) // `in` check used to prevent JIT error (gh-2145) // hasOwn isn't used here due to false negatives // regarding Nodelist length in IE var length = !!obj && "length" in obj && obj.length, type = toType( obj ); if ( isFunction( obj ) || isWindow( obj ) ) { return false; } return type === "array" || length === 0 || typeof length === "number" && length > 0 && ( length - 1 ) in obj; } var Sizzle = /*! * Sizzle CSS Selector Engine v2.3.3 * https://sizzlejs.com/ * * Copyright jQuery Foundation and other contributors * Released under the MIT license * http://jquery.org/license * * Date: 2016-08-08 */ (function( window ) { var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, // Local document vars setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, // Instance-specific data expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; } return 0; }, // Instance methods hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, // Use a stripped-down indexOf as it's faster than native // https://jsperf.com/thor-indexof-vs-for/5 indexOf = function( list, elem ) { var i = 0, len = list.length; for ( ; i < len; i++ ) { if ( list[i] === elem ) { return i; } } return -1; }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", // Regular expressions // http://www.w3.org/TR/css3-selectors/#whitespace whitespace = "[\\x20\\t\\r\\n\\f]", // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2) "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: // 1. quoted (capture 3; capture 4 or capture 5) "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 2. simple (capture 6) "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 3. anything else (capture 2) ".*" + ")\\)|)", // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter rwhitespace = new RegExp( whitespace + "+", "g" ), rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), rpseudo = new RegExp( pseudos ), ridentifier = new RegExp( "^" + identifier + "$" ), matchExpr = { "ID": new RegExp( "^#(" + identifier + ")" ), "CLASS": new RegExp( "^\\.(" + identifier + ")" ), "TAG": new RegExp( "^(" + identifier + "|[*])" ), "ATTR": new RegExp( "^" + attributes ), "PSEUDO": new RegExp( "^" + pseudos ), "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), // For use in libraries implementing .is() // We use this for POS matching in `select` "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, // Easily-parseable/retrievable ID or TAG or CLASS selectors rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, // CSS escapes // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), funescape = function( _, escaped, escapedWhitespace ) { var high = "0x" + escaped - 0x10000; // NaN means non-codepoint // Support: Firefox<24 // Workaround erroneous numeric interpretation of +"0x" return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint String.fromCharCode( high + 0x10000 ) : // Supplemental Plane codepoint (surrogate pair) String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); }, // CSS string/identifier serialization // https://drafts.csswg.org/cssom/#common-serializing-idioms rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, fcssescape = function( ch, asCodePoint ) { if ( asCodePoint ) { // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER if ( ch === "\0" ) { return "\uFFFD"; } // Control characters and (dependent upon position) numbers get escaped as code points return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; } // Other potentially-special ASCII characters get backslash-escaped return "\\" + ch; }, // Used for iframes // See setDocument() // Removing the function wrapper causes a "Permission Denied" // error in IE unloadHandler = function() { setDocument(); }, disabledAncestor = addCombinator( function( elem ) { return elem.disabled === true && ("form" in elem || "label" in elem); }, { dir: "parentNode", next: "legend" } ); // Optimize for push.apply( _, NodeList ) try { push.apply( (arr = slice.call( preferredDoc.childNodes )), preferredDoc.childNodes ); // Support: Android<4.0 // Detect silently failing push.apply arr[ preferredDoc.childNodes.length ].nodeType; } catch ( e ) { push = { apply: arr.length ? // Leverage slice if possible function( target, els ) { push_native.apply( target, slice.call(els) ); } : // Support: IE<9 // Otherwise append directly function( target, els ) { var j = target.length, i = 0; // Can't trust NodeList.length while ( (target[j++] = els[i++]) ) {} target.length = j - 1; } }; } function Sizzle( selector, context, results, seed ) { var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, // nodeType defaults to 9, since context defaults to document nodeType = context ? context.nodeType : 9; results = results || []; // Return early from calls with invalid selector or context if ( typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { return results; } // Try to shortcut find operations (as opposed to filters) in HTML documents if ( !seed ) { if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { setDocument( context ); } context = context || document; if ( documentIsHTML ) { // If the selector is sufficiently simple, try using a "get*By*" DOM method // (excepting DocumentFragment context, where the methods don't exist) if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { // ID selector if ( (m = match[1]) ) { // Document context if ( nodeType === 9 ) { if ( (elem = context.getElementById( m )) ) { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( elem.id === m ) { results.push( elem ); return results; } } else { return results; } // Element context } else { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( newContext && (elem = newContext.getElementById( m )) && contains( context, elem ) && elem.id === m ) { results.push( elem ); return results; } } // Type selector } else if ( match[2] ) { push.apply( results, context.getElementsByTagName( selector ) ); return results; // Class selector } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) { push.apply( results, context.getElementsByClassName( m ) ); return results; } } // Take advantage of querySelectorAll if ( support.qsa && !compilerCache[ selector + " " ] && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { if ( nodeType !== 1 ) { newContext = context; newSelector = selector; // qSA looks outside Element context, which is not what we want // Thanks to Andrew Dupont for this workaround technique // Support: IE <=8 // Exclude object elements } else if ( context.nodeName.toLowerCase() !== "object" ) { // Capture the context ID, setting it first if necessary if ( (nid = context.getAttribute( "id" )) ) { nid = nid.replace( rcssescape, fcssescape ); } else { context.setAttribute( "id", (nid = expando) ); } // Prefix every selector in the list groups = tokenize( selector ); i = groups.length; while ( i-- ) { groups[i] = "#" + nid + " " + toSelector( groups[i] ); } newSelector = groups.join( "," ); // Expand context for sibling selectors newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; } if ( newSelector ) { try { push.apply( results, newContext.querySelectorAll( newSelector ) ); return results; } catch ( qsaError ) { } finally { if ( nid === expando ) { context.removeAttribute( "id" ); } } } } } } // All others return select( selector.replace( rtrim, "$1" ), context, results, seed ); } /** * Create key-value caches of limited size * @returns {function(string, object)} Returns the Object data after storing it on itself with * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) * deleting the oldest entry */ function createCache() { var keys = []; function cache( key, value ) { // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) if ( keys.push( key + " " ) > Expr.cacheLength ) { // Only keep the most recent entries delete cache[ keys.shift() ]; } return (cache[ key + " " ] = value); } return cache; } /** * Mark a function for special use by Sizzle * @param {Function} fn The function to mark */ function markFunction( fn ) { fn[ expando ] = true; return fn; } /** * Support testing using an element * @param {Function} fn Passed the created element and returns a boolean result */ function assert( fn ) { var el = document.createElement("fieldset"); try { return !!fn( el ); } catch (e) { return false; } finally { // Remove from its parent by default if ( el.parentNode ) { el.parentNode.removeChild( el ); } // release memory in IE el = null; } } /** * Adds the same handler for all of the specified attrs * @param {String} attrs Pipe-separated list of attributes * @param {Function} handler The method that will be applied */ function addHandle( attrs, handler ) { var arr = attrs.split("|"), i = arr.length; while ( i-- ) { Expr.attrHandle[ arr[i] ] = handler; } } /** * Checks document order of two siblings * @param {Element} a * @param {Element} b * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b */ function siblingCheck( a, b ) { var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes if ( diff ) { return diff; } // Check if b follows a if ( cur ) { while ( (cur = cur.nextSibling) ) { if ( cur === b ) { return -1; } } } return a ? 1 : -1; } /** * Returns a function to use in pseudos for input types * @param {String} type */ function createInputPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === type; }; } /** * Returns a function to use in pseudos for buttons * @param {String} type */ function createButtonPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && elem.type === type; }; } /** * Returns a function to use in pseudos for :enabled/:disabled * @param {Boolean} disabled true for :disabled; false for :enabled */ function createDisabledPseudo( disabled ) { // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable return function( elem ) { // Only certain elements can match :enabled or :disabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled if ( "form" in elem ) { // Check for inherited disabledness on relevant non-disabled elements: // * listed form-associated elements in a disabled fieldset // https://html.spec.whatwg.org/multipage/forms.html#category-listed // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled // * option elements in a disabled optgroup // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled // All such elements have a "form" property. if ( elem.parentNode && elem.disabled === false ) { // Option elements defer to a parent optgroup if present if ( "label" in elem ) { if ( "label" in elem.parentNode ) { return elem.parentNode.disabled === disabled; } else { return elem.disabled === disabled; } } // Support: IE 6 - 11 // Use the isDisabled shortcut property to check for disabled fieldset ancestors return elem.isDisabled === disabled || // Where there is no isDisabled, check manually /* jshint -W018 */ elem.isDisabled !== !disabled && disabledAncestor( elem ) === disabled; } return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property. // Some victims get caught in our net (label, legend, menu, track), but it shouldn't // even exist on them, let alone have a boolean value. } else if ( "label" in elem ) { return elem.disabled === disabled; } // Remaining elements are neither :enabled nor :disabled return false; }; } /** * Returns a function to use in pseudos for positionals * @param {Function} fn */ function createPositionalPseudo( fn ) { return markFunction(function( argument ) { argument = +argument; return markFunction(function( seed, matches ) { var j, matchIndexes = fn( [], seed.length, argument ), i = matchIndexes.length; // Match elements found at the specified indexes while ( i-- ) { if ( seed[ (j = matchIndexes[i]) ] ) { seed[j] = !(matches[j] = seed[j]); } } }); }); } /** * Checks a node for validity as a Sizzle context * @param {Element|Object=} context * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value */ function testContext( context ) { return context && typeof context.getElementsByTagName !== "undefined" && context; } // Expose support vars for convenience support = Sizzle.support = {}; /** * Detects XML nodes * @param {Element|Object} elem An element or a document * @returns {Boolean} True iff elem is a non-HTML XML node */ isXML = Sizzle.isXML = function( elem ) { // documentElement is verified for cases where it doesn't yet exist // (such as loading iframes in IE - #4833) var documentElement = elem && (elem.ownerDocument || elem).documentElement; return documentElement ? documentElement.nodeName !== "HTML" : false; }; /** * Sets document-related variables once based on the current document * @param {Element|Object} [doc] An element or document object to use to set the document * @returns {Object} Returns the current document */ setDocument = Sizzle.setDocument = function( node ) { var hasCompare, subWindow, doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { return document; } // Update global variables document = doc; docElem = document.documentElement; documentIsHTML = !isXML( document ); // Support: IE 9-11, Edge // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) if ( preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow ) { // Support: IE 11, Edge if ( subWindow.addEventListener ) { subWindow.addEventListener( "unload", unloadHandler, false ); // Support: IE 9 - 10 only } else if ( subWindow.attachEvent ) { subWindow.attachEvent( "onunload", unloadHandler ); } } /* Attributes ---------------------------------------------------------------------- */ // Support: IE<8 // Verify that getAttribute really returns attributes and not properties // (excepting IE8 booleans) support.attributes = assert(function( el ) { el.className = "i"; return !el.getAttribute("className"); }); /* getElement(s)By* ---------------------------------------------------------------------- */ // Check if getElementsByTagName("*") returns only elements support.getElementsByTagName = assert(function( el ) { el.appendChild( document.createComment("") ); return !el.getElementsByTagName("*").length; }); // Support: IE<9 support.getElementsByClassName = rnative.test( document.getElementsByClassName ); // Support: IE<10 // Check if getElementById returns elements by name // The broken getElementById methods don't pick up programmatically-set names, // so use a roundabout getElementsByName test support.getById = assert(function( el ) { docElem.appendChild( el ).id = expando; return !document.getElementsByName || !document.getElementsByName( expando ).length; }); // ID filter and find if ( support.getById ) { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { return elem.getAttribute("id") === attrId; }; }; Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var elem = context.getElementById( id ); return elem ? [ elem ] : []; } }; } else { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return node && node.value === attrId; }; }; // Support: IE 6 - 7 only // getElementById is not reliable as a find shortcut Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var node, i, elems, elem = context.getElementById( id ); if ( elem ) { // Verify the id attribute node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } // Fall back on getElementsByName elems = context.getElementsByName( id ); i = 0; while ( (elem = elems[i++]) ) { node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } } } return []; } }; } // Tag Expr.find["TAG"] = support.getElementsByTagName ? function( tag, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( tag ); // DocumentFragment nodes don't have gEBTN } else if ( support.qsa ) { return context.querySelectorAll( tag ); } } : function( tag, context ) { var elem, tmp = [], i = 0, // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too results = context.getElementsByTagName( tag ); // Filter out possible comments if ( tag === "*" ) { while ( (elem = results[i++]) ) { if ( elem.nodeType === 1 ) { tmp.push( elem ); } } return tmp; } return results; }; // Class Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { return context.getElementsByClassName( className ); } }; /* QSA/matchesSelector ---------------------------------------------------------------------- */ // QSA and matchesSelector support // matchesSelector(:active) reports false when true (IE9/Opera 11.5) rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21) // We allow this because of a bug in IE8/9 that throws an error // whenever `document.activeElement` is accessed on an iframe // So, we allow :focus to pass through QSA all the time to avoid the IE error // See https://bugs.jquery.com/ticket/13378 rbuggyQSA = []; if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { // Build QSA regex // Regex strategy adopted from Diego Perini assert(function( el ) { // Select is set to empty string on purpose // This is to test IE's treatment of not explicitly // setting a boolean content attribute, // since its presence should be enough // https://bugs.jquery.com/ticket/12359 docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=>" + "<option selected=></option></select>"; // Support: IE8, Opera 11-12.16 // Nothing should be selected when empty strings follow ^= or $= or *= // The test attribute must be unknown in Opera but "safe" for WinRT // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section if ( el.querySelectorAll("[msallowcapture^=]").length ) { rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:|\"\")" ); } // Support: IE8 // Boolean attributes and "value" are not treated correctly if ( !el.querySelectorAll("[selected]").length ) { rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { rbuggyQSA.push("~="); } // Webkit/Opera - :checked should return selected option elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // IE8 throws error here and will not see later tests if ( !el.querySelectorAll(":checked").length ) { rbuggyQSA.push(":checked"); } // Support: Safari 8+, iOS 8+ // https://bugs.webkit.org/show_bug.cgi?id=136851 // In-page `selector#id sibling-combinator selector` fails if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { rbuggyQSA.push(".#.+[+~]"); } }); assert(function( el ) { el.innerHTML = "<a href= disabled='disabled'></a>" + "<select disabled='disabled'><option/></select>"; // Support: Windows 8 Native Apps // The type and name attributes are restricted during .innerHTML assignment var input = document.createElement("input"); input.setAttribute( "type", "hidden" ); el.appendChild( input ).setAttribute( "name", "D" ); // Support: IE8 // Enforce case-sensitivity of name attribute if ( el.querySelectorAll("[name=d]").length ) { rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) // IE8 throws error here and will not see later tests if ( el.querySelectorAll(":enabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Support: IE9-11+ // IE's :disabled selector does not pick up the children of disabled fieldsets docElem.appendChild( el ).disabled = true; if ( el.querySelectorAll(":disabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Opera 10-11 does not throw on post-comma invalid pseudos el.querySelectorAll("*,:x"); rbuggyQSA.push(",.*:"); }); } if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector) )) ) { assert(function( el ) { // Check to see if it's possible to do matchesSelector // on a disconnected node (IE 9) support.disconnectedMatch = matches.call( el, "*" ); // This should fail with an exception // Gecko does not error, returns false instead matches.call( el, "[s!=]:x" ); rbuggyMatches.push( "!=", pseudos ); }); } rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); /* Contains ---------------------------------------------------------------------- */ hasCompare = rnative.test( docElem.compareDocumentPosition ); // Element contains another // Purposefully self-exclusive // As in, an element does not contain itself contains = hasCompare || rnative.test( docElem.contains ) ? function( a, b ) { var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; return a === bup || !!( bup && bup.nodeType === 1 && ( adown.contains ? adown.contains( bup ) : a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 )); } : function( a, b ) { if ( b ) { while ( (b = b.parentNode) ) { if ( b === a ) { return true; } } } return false; }; /* Sorting ---------------------------------------------------------------------- */ // Document order sorting sortOrder = hasCompare ? function( a, b ) { // Flag for duplicate removal if ( a === b ) { hasDuplicate = true; return 0; } // Sort on method existence if only one input has compareDocumentPosition var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; if ( compare ) { return compare; } // Calculate position if both inputs belong to the same document compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? a.compareDocumentPosition( b ) : // Otherwise we know they are disconnected 1; // Disconnected nodes if ( compare & 1 || (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { // Choose the first element that is related to our preferred document if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { return -1; } if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { return 1; } // Maintain original order return sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; } return compare & 4 ? -1 : 1; } : function( a, b ) { // Exit early if the nodes are identical if ( a === b ) { hasDuplicate = true; return 0; } var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; // Parentless nodes are either documents or disconnected if ( !aup || !bup ) { return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; // If the nodes are siblings, we can do a quick check } else if ( aup === bup ) { return siblingCheck( a, b ); } // Otherwise we need full lists of their ancestors for comparison cur = a; while ( (cur = cur.parentNode) ) { ap.unshift( cur ); } cur = b; while ( (cur = cur.parentNode) ) { bp.unshift( cur ); } // Walk down the tree looking for a discrepancy while ( ap[i] === bp[i] ) { i++; } return i ? // Do a sibling check if the nodes have a common ancestor siblingCheck( ap[i], bp[i] ) : // Otherwise nodes in our document sort first ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; }; return document; }; Sizzle.matches = function( expr, elements ) { return Sizzle( expr, null, null, elements ); }; Sizzle.matchesSelector = function( elem, expr ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } // Make sure that attribute selectors are quoted expr = expr.replace( rattributeQuotes, "='$1']" ); if ( support.matchesSelector && documentIsHTML && !compilerCache[ expr + " " ] && ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { try { var ret = matches.call( elem, expr ); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9 elem.document && elem.document.nodeType !== 11 ) { return ret; } } catch (e) {} } return Sizzle( expr, document, null, [ elem ] ).length > 0; }; Sizzle.contains = function( context, elem ) { // Set document vars if needed if ( ( context.ownerDocument || context ) !== document ) { setDocument( context ); } return contains( context, elem ); }; Sizzle.attr = function( elem, name ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } var fn = Expr.attrHandle[ name.toLowerCase() ], // Don't get fooled by Object.prototype properties (jQuery #13807) val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? fn( elem, name, !documentIsHTML ) : undefined; return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute( name ) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; }; Sizzle.escape = function( sel ) { return (sel + "").replace( rcssescape, fcssescape ); }; Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); }; /** * Document sorting and removing duplicates * @param {ArrayLike} results */ Sizzle.uniqueSort = function( results ) { var elem, duplicates = [], j = 0, i = 0; // Unless we *know* we can detect duplicates, assume their presence hasDuplicate = !support.detectDuplicates; sortInput = !support.sortStable && results.slice( 0 ); results.sort( sortOrder ); if ( hasDuplicate ) { while ( (elem = results[i++]) ) { if ( elem === results[ i ] ) { j = duplicates.push( i ); } } while ( j-- ) { results.splice( duplicates[ j ], 1 ); } } // Clear input after sorting to release objects // See https://github.com/jquery/sizzle/pull/225 sortInput = null; return results; }; /** * Utility function for retrieving the text value of an array of DOM nodes * @param {Array|Element} elem */ getText = Sizzle.getText = function( elem ) { var node, ret = "", i = 0, nodeType = elem.nodeType; if ( !nodeType ) { // If no nodeType, this is expected to be an array while ( (node = elem[i++]) ) { // Do not traverse comment nodes ret += getText( node ); } } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // Use textContent for elements // innerText usage removed for consistency of new lines (jQuery #11153) if ( typeof elem.textContent === "string" ) { return elem.textContent; } else { // Traverse its children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { ret += getText( elem ); } } } else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; } // Do not include comment or processing instruction nodes return ret; }; Expr = Sizzle.selectors = { // Can be adjusted by the user cacheLength: 50, createPseudo: markFunction, match: matchExpr, attrHandle: {}, find: {}, relative: { ">": { dir: "parentNode", first: true }, " ": { dir: "parentNode" }, "+": { dir: "previousSibling", first: true }, "~": { dir: "previousSibling" } }, preFilter: { "ATTR": function( match ) { match[1] = match[1].replace( runescape, funescape ); // Move the given value to match[3] whether quoted or unquoted match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); if ( match[2] === "~=" ) { match[3] = " " + match[3] + " "; } return match.slice( 0, 4 ); }, "CHILD": function( match ) { /* matches from matchExpr["CHILD"] 1 type (only|nth|...) 2 what (child|of-type) 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 4 xn-component of xn+y argument ([+-]?\d*n|) 5 sign of xn-component 6 x of xn-component 7 sign of y-component 8 y of y-component */ match[1] = match[1].toLowerCase(); if ( match[1].slice( 0, 3 ) === "nth" ) { // nth-* requires argument if ( !match[3] ) { Sizzle.error( match[0] ); } // numeric x and y parameters for Expr.filter.CHILD // remember that false/true cast respectively to 0/1 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); // other types prohibit arguments } else if ( match[3] ) { Sizzle.error( match[0] ); } return match; }, "PSEUDO": function( match ) { var excess, unquoted = !match[6] && match[2]; if ( matchExpr["CHILD"].test( match[0] ) ) { return null; } // Accept quoted arguments as-is if ( match[3] ) { match[2] = match[4] || match[5] || ""; // Strip excess characters from unquoted arguments } else if ( unquoted && rpseudo.test( unquoted ) && // Get excess from tokenize (recursively) (excess = tokenize( unquoted, true )) && // advance to the next closing parenthesis (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { // excess is a negative index match[0] = match[0].slice( 0, excess ); match[2] = unquoted.slice( 0, excess ); } // Return only captures needed by the pseudo filter method (type and argument) return match.slice( 0, 3 ); } }, filter: { "TAG": function( nodeNameSelector ) { var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); return nodeNameSelector === "*" ? function() { return true; } : function( elem ) { return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; }; }, "CLASS": function( className ) { var pattern = classCache[ className + " " ]; return pattern || (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && classCache( className, function( elem ) { return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); }); }, "ATTR": function( name, operator, check ) { return function( elem ) { var result = Sizzle.attr( elem, name ); if ( result == null ) { return operator === "!="; } if ( !operator ) { return true; } result += ""; return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf( check ) === 0 : operator === "*=" ? check && result.indexOf( check ) > -1 : operator === "$=" ? check && result.slice( -check.length ) === check : operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : false; }; }, "CHILD": function( type, what, argument, first, last ) { var simple = type.slice( 0, 3 ) !== "nth", forward = type.slice( -4 ) !== "last", ofType = what === "of-type"; return first === 1 && last === 0 ? // Shortcut for :nth-*(n) function( elem ) { return !!elem.parentNode; } : function( elem, context, xml ) { var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; if ( parent ) { // :(first|last|only)-(child|of-type) if ( simple ) { while ( dir ) { node = elem; while ( (node = node[ dir ]) ) { if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { return false; } } // Reverse direction for :only-* (if we haven't yet done so) start = dir = type === "only" && !start && "nextSibling"; } return true; } start = [ forward ? parent.firstChild : parent.lastChild ]; // non-xml :nth-child(...) stores cache data on `parent` if ( forward && useCache ) { // Seek `elem` from a previously-cached index // ...in a gzip-friendly way node = parent; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex && cache[ 2 ]; node = nodeIndex && parent.childNodes[ nodeIndex ]; while ( (node = ++nodeIndex && node && node[ dir ] || // Fallback to seeking `elem` from the start (diff = nodeIndex = 0) || start.pop()) ) { // When found, cache indexes on `parent` and break if ( node.nodeType === 1 && ++diff && node === elem ) { uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; break; } } } else { // Use previously-cached element index if available if ( useCache ) { // ...in a gzip-friendly way node = elem; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex; } // xml :nth-child(...) // or :nth-last-child(...) or :nth(-last)?-of-type(...) if ( diff === false ) { // Use the same loop as above to seek `elem` from the start while ( (node = ++nodeIndex && node && node[ dir ] || (diff = nodeIndex = 0) || start.pop()) ) { if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { // Cache the index of each encountered element if ( useCache ) { outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); uniqueCache[ type ] = [ dirruns, diff ]; } if ( node === elem ) { break; } } } } } // Incorporate the offset, then check against cycle size diff -= last; return diff === first || ( diff % first === 0 && diff / first >= 0 ); } }; }, "PSEUDO": function( pseudo, argument ) { // pseudo-class names are case-insensitive // http://www.w3.org/TR/selectors/#pseudo-classes // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters // Remember that setFilters inherits from pseudos var args, fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || Sizzle.error( "unsupported pseudo: " + pseudo ); // The user may use createPseudo to indicate that // arguments are needed to create the filter function // just as Sizzle does if ( fn[ expando ] ) { return fn( argument ); } // But maintain support for old signatures if ( fn.length > 1 ) { args = [ pseudo, pseudo, "", argument ]; return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? markFunction(function( seed, matches ) { var idx, matched = fn( seed, argument ), i = matched.length; while ( i-- ) { idx = indexOf( seed, matched[i] ); seed[ idx ] = !( matches[ idx ] = matched[i] ); } }) : function( elem ) { return fn( elem, 0, args ); }; } return fn; } }, pseudos: { // Potentially complex pseudos "not": markFunction(function( selector ) { // Trim the selector passed to compile // to avoid treating leading and trailing // spaces as combinators var input = [], results = [], matcher = compile( selector.replace( rtrim, "$1" ) ); return matcher[ expando ] ? markFunction(function( seed, matches, context, xml ) { var elem, unmatched = matcher( seed, null, xml, [] ), i = seed.length; // Match elements unmatched by `matcher` while ( i-- ) { if ( (elem = unmatched[i]) ) { seed[i] = !(matches[i] = elem); } } }) : function( elem, context, xml ) { input[0] = elem; matcher( input, null, xml, results ); // Don't keep the element (issue #299) input[0] = null; return !results.pop(); }; }), "has": markFunction(function( selector ) { return function( elem ) { return Sizzle( selector, elem ).length > 0; }; }), "contains": markFunction(function( text ) { text = text.replace( runescape, funescape ); return function( elem ) { return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; }; }), // "Whether an element is represented by a :lang() selector // is based solely on the element's language value // being equal to the identifier C, // or beginning with the identifier C immediately followed by "-". // The matching of C against the element's language value is performed case-insensitively. // The identifier C does not have to be a valid language name." // http://www.w3.org/TR/selectors/#lang-pseudo "lang": markFunction( function( lang ) { // lang value must be a valid identifier if ( !ridentifier.test(lang || "") ) { Sizzle.error( "unsupported lang: " + lang ); } lang = lang.replace( runescape, funescape ).toLowerCase(); return function( elem ) { var elemLang; do { if ( (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { elemLang = elemLang.toLowerCase(); return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; } } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); return false; }; }), // Miscellaneous "target": function( elem ) { var hash = window.location && window.location.hash; return hash && hash.slice( 1 ) === elem.id; }, "root": function( elem ) { return elem === docElem; }, "focus": function( elem ) { return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); }, // Boolean properties "enabled": createDisabledPseudo( false ), "disabled": createDisabledPseudo( true ), "checked": function( elem ) { // In CSS3, :checked should return both checked and selected elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked var nodeName = elem.nodeName.toLowerCase(); return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); }, "selected": function( elem ) { // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected === true; }, // Contents "empty": function( elem ) { // http://www.w3.org/TR/selectors/#empty-pseudo // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), // but not by others (comment: 8; processing instruction: 7; etc.) // nodeType < 6 works because attributes (2) do not appear as children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { if ( elem.nodeType < 6 ) { return false; } } return true; }, "parent": function( elem ) { return !Expr.pseudos["empty"]( elem ); }, // Element/input types "header": function( elem ) { return rheader.test( elem.nodeName ); }, "input": function( elem ) { return rinputs.test( elem.nodeName ); }, "button": function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === "button" || name === "button"; }, "text": function( elem ) { var attr; return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && // Support: IE<8 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); }, // Position-in-collection "first": createPositionalPseudo(function() { return [ 0 ]; }), "last": createPositionalPseudo(function( matchIndexes, length ) { return [ length - 1 ]; }), "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { return [ argument < 0 ? argument + length : argument ]; }), "even": createPositionalPseudo(function( matchIndexes, length ) { var i = 0; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "odd": createPositionalPseudo(function( matchIndexes, length ) { var i = 1; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; --i >= 0; ) { matchIndexes.push( i ); } return matchIndexes; }), "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; ++i < length; ) { matchIndexes.push( i ); } return matchIndexes; }) } }; Expr.pseudos["nth"] = Expr.pseudos["eq"]; // Add button/input type pseudos for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { Expr.pseudos[ i ] = createInputPseudo( i ); } for ( i in { submit: true, reset: true } ) { Expr.pseudos[ i ] = createButtonPseudo( i ); } // Easy API for creating new setFilters function setFilters() {} setFilters.prototype = Expr.filters = Expr.pseudos; Expr.setFilters = new setFilters(); tokenize = Sizzle.tokenize = function( selector, parseOnly ) { var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[ selector + " " ]; if ( cached ) { return parseOnly ? 0 : cached.slice( 0 ); } soFar = selector; groups = []; preFilters = Expr.preFilter; while ( soFar ) { // Comma and first run if ( !matched || (match = rcomma.exec( soFar )) ) { if ( match ) { // Don't consume trailing commas as valid soFar = soFar.slice( match[0].length ) || soFar; } groups.push( (tokens = []) ); } matched = false; // Combinators if ( (match = rcombinators.exec( soFar )) ) { matched = match.shift(); tokens.push({ value: matched, // Cast descendant combinators to space type: match[0].replace( rtrim, " " ) }); soFar = soFar.slice( matched.length ); } // Filters for ( type in Expr.filter ) { if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || (match = preFilters[ type ]( match ))) ) { matched = match.shift(); tokens.push({ value: matched, type: type, matches: match }); soFar = soFar.slice( matched.length ); } } if ( !matched ) { break; } } // Return the length of the invalid excess // if we're just parsing // Otherwise, throw an error or return tokens return parseOnly ? soFar.length : soFar ? Sizzle.error( selector ) : // Cache the tokens tokenCache( selector, groups ).slice( 0 ); }; function toSelector( tokens ) { var i = 0, len = tokens.length, selector = ""; for ( ; i < len; i++ ) { selector += tokens[i].value; } return selector; } function addCombinator( matcher, combinator, base ) { var dir = combinator.dir, skip = combinator.next, key = skip || dir, checkNonElements = base && key === "parentNode", doneName = done++; return combinator.first ? // Check against closest ancestor/preceding element function( elem, context, xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { return matcher( elem, context, xml ); } } return false; } : // Check against all ancestor/preceding elements function( elem, context, xml ) { var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching if ( xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { if ( matcher( elem, context, xml ) ) { return true; } } } } else { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { outerCache = elem[ expando ] || (elem[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {}); if ( skip && skip === elem.nodeName.toLowerCase() ) { elem = elem[ dir ] || elem; } else if ( (oldCache = uniqueCache[ key ]) && oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { // Assign to newCache so results back-propagate to previous elements return (newCache[ 2 ] = oldCache[ 2 ]); } else { // Reuse newcache so results back-propagate to previous elements uniqueCache[ key ] = newCache; // A match means we're done; a fail means we have to keep checking if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { return true; } } } } } return false; }; } function elementMatcher( matchers ) { return matchers.length > 1 ? function( elem, context, xml ) { var i = matchers.length; while ( i-- ) { if ( !matchers[i]( elem, context, xml ) ) { return false; } } return true; } : matchers[0]; } function multipleContexts( selector, contexts, results ) { var i = 0, len = contexts.length; for ( ; i < len; i++ ) { Sizzle( selector, contexts[i], results ); } return results; } function condense( unmatched, map, filter, context, xml ) { var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; for ( ; i < len; i++ ) { if ( (elem = unmatched[i]) ) { if ( !filter || filter( elem, context, xml ) ) { newUnmatched.push( elem ); if ( mapped ) { map.push( i ); } } } } return newUnmatched; } function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { if ( postFilter && !postFilter[ expando ] ) { postFilter = setMatcher( postFilter ); } if ( postFinder && !postFinder[ expando ] ) { postFinder = setMatcher( postFinder, postSelector ); } return markFunction(function( seed, results, context, xml ) { var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, // Get initial elements from seed or context elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), // Prefilter to get matcher input, preserving a map for seed-results synchronization matcherIn = preFilter && ( seed || !selector ) ? condense( elems, preMap, preFilter, context, xml ) : elems, matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, postFinder || ( seed ? preFilter : preexisting || postFilter ) ? // ...intermediate processing is necessary [] : // ...otherwise use results directly results : matcherIn; // Find primary matches if ( matcher ) { matcher( matcherIn, matcherOut, context, xml ); } // Apply postFilter if ( postFilter ) { temp = condense( matcherOut, postMap ); postFilter( temp, [], context, xml ); // Un-match failing elements by moving them back to matcherIn i = temp.length; while ( i-- ) { if ( (elem = temp[i]) ) { matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); } } } if ( seed ) { if ( postFinder || preFilter ) { if ( postFinder ) { // Get the final matcherOut by condensing this intermediate into postFinder contexts temp = []; i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) ) { // Restore matcherIn since elem is not yet a final match temp.push( (matcherIn[i] = elem) ); } } postFinder( null, (matcherOut = []), temp, xml ); } // Move matched elements from seed to results to keep them synchronized i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) && (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { seed[temp] = !(results[temp] = elem); } } } // Add elements to results, through postFinder if defined } else { matcherOut = condense( matcherOut === results ? matcherOut.splice( preexisting, matcherOut.length ) : matcherOut ); if ( postFinder ) { postFinder( null, results, matcherOut, xml ); } else { push.apply( results, matcherOut ); } } }); } function matcherFromTokens( tokens ) { var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[ tokens[0].type ], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, // The foundational matcher ensures that elements are reachable from top-level context(s) matchContext = addCombinator( function( elem ) { return elem === checkContext; }, implicitRelative, true ), matchAnyContext = addCombinator( function( elem ) { return indexOf( checkContext, elem ) > -1; }, implicitRelative, true ), matchers = [ function( elem, context, xml ) { var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( (checkContext = context).nodeType ? matchContext( elem, context, xml ) : matchAnyContext( elem, context, xml ) ); // Avoid hanging onto element (issue #299) checkContext = null; return ret; } ]; for ( ; i < len; i++ ) { if ( (matcher = Expr.relative[ tokens[i].type ]) ) { matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; } else { matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); // Return special upon seeing a positional matcher if ( matcher[ expando ] ) { // Find the next relative operator (if any) for proper handling j = ++i; for ( ; j < len; j++ ) { if ( Expr.relative[ tokens[j].type ] ) { break; } } return setMatcher( i > 1 && elementMatcher( matchers ), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*` tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) ).replace( rtrim, "$1" ), matcher, i < j && matcherFromTokens( tokens.slice( i, j ) ), j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), j < len && toSelector( tokens ) ); } matchers.push( matcher ); } } return elementMatcher( matchers ); } function matcherFromGroupMatchers( elementMatchers, setMatchers ) { var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( seed, context, xml, results, outermost ) { var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, // We must always have either seed elements or outermost context elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), // Use integer dirruns iff this is the outermost matcher dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length; if ( outermost ) { outermostContext = context === document || context || outermost; } // Add elements passing elementMatchers directly to results // Support: IE<9, Safari // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id for ( ; i !== len && (elem = elems[i]) != null; i++ ) { if ( byElement && elem ) { j = 0; if ( !context && elem.ownerDocument !== document ) { setDocument( elem ); xml = !documentIsHTML; } while ( (matcher = elementMatchers[j++]) ) { if ( matcher( elem, context || document, xml) ) { results.push( elem ); break; } } if ( outermost ) { dirruns = dirrunsUnique; } } // Track unmatched elements for set filters if ( bySet ) { // They will have gone through all possible matchers if ( (elem = !matcher && elem) ) { matchedCount--; } // Lengthen the array for every element, matched or not if ( seed ) { unmatched.push( elem ); } } } // `i` is now the count of elements visited above, and adding it to `matchedCount` // makes the latter nonnegative. matchedCount += i; // Apply set filters to unmatched elements // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` // equals `i`), unless we didn't visit _any_ elements in the above loop because we have // no element matchers and no seed. // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that // case, which will result in a "00" `matchedCount` that differs from `i` but is also // numerically zero. if ( bySet && i !== matchedCount ) { j = 0; while ( (matcher = setMatchers[j++]) ) { matcher( unmatched, setMatched, context, xml ); } if ( seed ) { // Reintegrate element matches to eliminate the need for sorting if ( matchedCount > 0 ) { while ( i-- ) { if ( !(unmatched[i] || setMatched[i]) ) { setMatched[i] = pop.call( results ); } } } // Discard index placeholder values to get only actual matches setMatched = condense( setMatched ); } // Add matches to results push.apply( results, setMatched ); // Seedless set matches succeeding multiple successful matchers stipulate sorting if ( outermost && !seed && setMatched.length > 0 && ( matchedCount + setMatchers.length ) > 1 ) { Sizzle.uniqueSort( results ); } } // Override manipulation of globals by nested matchers if ( outermost ) { dirruns = dirrunsUnique; outermostContext = contextBackup; } return unmatched; }; return bySet ? markFunction( superMatcher ) : superMatcher; } compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { var i, setMatchers = [], elementMatchers = [], cached = compilerCache[ selector + " " ]; if ( !cached ) { // Generate a function of recursive functions that can be used to check each element if ( !match ) { match = tokenize( selector ); } i = match.length; while ( i-- ) { cached = matcherFromTokens( match[i] ); if ( cached[ expando ] ) { setMatchers.push( cached ); } else { elementMatchers.push( cached ); } } // Cache the compiled function cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); // Save selector and tokenization cached.selector = selector; } return cached; }; /** * A low-level selection function that works with Sizzle's compiled * selector functions * @param {String|Function} selector A selector or a pre-compiled * selector function built with Sizzle.compile * @param {Element} context * @param {Array} [results] * @param {Array} [seed] A set of elements to match against */ select = Sizzle.select = function( selector, context, results, seed ) { var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize( (selector = compiled.selector || selector) ); results = results || []; // Try to minimize operations if there is only one selector in the list and no seed // (the latter of which guarantees us context) if ( match.length === 1 ) { // Reduce context if the leading compound selector is an ID tokens = match[0] = match[0].slice( 0 ); if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) { context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; if ( !context ) { return results; // Precompiled matchers will still verify ancestry, so step up a level } else if ( compiled ) { context = context.parentNode; } selector = selector.slice( tokens.shift().value.length ); } // Fetch a seed set for right-to-left matching i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; while ( i-- ) { token = tokens[i]; // Abort if we hit a combinator if ( Expr.relative[ (type = token.type) ] ) { break; } if ( (find = Expr.find[ type ]) ) { // Search, expanding context for leading sibling combinators if ( (seed = find( token.matches[0].replace( runescape, funescape ), rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context )) ) { // If seed is empty or no tokens remain, we can return early tokens.splice( i, 1 ); selector = seed.length && toSelector( tokens ); if ( !selector ) { push.apply( results, seed ); return results; } break; } } } } // Compile and execute a filtering function if one is not provided // Provide `match` to avoid retokenization if we modified the selector above ( compiled || compile( selector, match ) )( seed, context, !documentIsHTML, results, !context || rsibling.test( selector ) && testContext( context.parentNode ) || context ); return results; }; // One-time assignments // Sort stability support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; // Support: Chrome 14-35+ // Always assume duplicates if they aren't passed to the comparison function support.detectDuplicates = !!hasDuplicate; // Initialize against the default document setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // Detached nodes confoundingly follow *each other* support.sortDetached = assert(function( el ) { // Should return 1, but returns 4 (following) return el.compareDocumentPosition( document.createElement("fieldset") ) & 1; }); // Support: IE<8 // Prevent attribute/property "interpolation" // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx if ( !assert(function( el ) { el.innerHTML = "<a href='#'></a>"; return el.firstChild.getAttribute("href") === "#" ; }) ) { addHandle( "type|href|height|width", function( elem, name, isXML ) { if ( !isXML ) { return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); } }); } // Support: IE<9 // Use defaultValue in place of getAttribute("value") if ( !support.attributes || !assert(function( el ) { el.innerHTML = "<input/>"; el.firstChild.setAttribute( "value", "" ); return el.firstChild.getAttribute( "value" ) === ""; }) ) { addHandle( "value", function( elem, name, isXML ) { if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { return elem.defaultValue; } }); } // Support: IE<9 // Use getAttributeNode to fetch booleans when getAttribute lies if ( !assert(function( el ) { return el.getAttribute("disabled") == null; }) ) { addHandle( booleans, function( elem, name, isXML ) { var val; if ( !isXML ) { return elem[ name ] === true ? name.toLowerCase() : (val = elem.getAttributeNode( name )) && val.specified ? val.value : null; } }); } return Sizzle; })( window ); jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; // Deprecated jQuery.expr[ ":" ] = jQuery.expr.pseudos; jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains; jQuery.escapeSelector = Sizzle.escape; var dir = function( elem, dir, until ) { var matched = [], truncate = until !== undefined; while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { if ( elem.nodeType === 1 ) { if ( truncate && jQuery( elem ).is( until ) ) { break; } matched.push( elem ); } } return matched; }; var siblings = function( n, elem ) { var matched = []; for ( ; n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { matched.push( n ); } } return matched; }; var rneedsContext = jQuery.expr.match.needsContext; function nodeName( elem, name ) { return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); }; var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); // Implement the identical functionality for filter and not function winnow( elements, qualifier, not ) { if ( isFunction( qualifier ) ) { return jQuery.grep( elements, function( elem, i ) { return !!qualifier.call( elem, i, elem ) !== not; } ); } // Single element if ( qualifier.nodeType ) { return jQuery.grep( elements, function( elem ) { return ( elem === qualifier ) !== not; } ); } // Arraylike of elements (jQuery, arguments, Array) if ( typeof qualifier !== "string" ) { return jQuery.grep( elements, function( elem ) { return ( indexOf.call( qualifier, elem ) > -1 ) !== not; } ); } // Filtered directly for both simple and complex selectors return jQuery.filter( qualifier, elements, not ); } jQuery.filter = function( expr, elems, not ) { var elem = elems[ 0 ]; if ( not ) { expr = ":not(" + expr + ")"; } if ( elems.length === 1 && elem.nodeType === 1 ) { return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; } return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { return elem.nodeType === 1; } ) ); }; jQuery.fn.extend( { find: function( selector ) { var i, ret, len = this.length, self = this; if ( typeof selector !== "string" ) { return this.pushStack( jQuery( selector ).filter( function() { for ( i = 0; i < len; i++ ) { if ( jQuery.contains( self[ i ], this ) ) { return true; } } } ) ); } ret = this.pushStack( [] ); for ( i = 0; i < len; i++ ) { jQuery.find( selector, self[ i ], ret ); } return len > 1 ? jQuery.uniqueSort( ret ) : ret; }, filter: function( selector ) { return this.pushStack( winnow( this, selector || [], false ) ); }, not: function( selector ) { return this.pushStack( winnow( this, selector || [], true ) ); }, is: function( selector ) { return !!winnow( this, // If this is a positional/relative selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". typeof selector === "string" && rneedsContext.test( selector ) ? jQuery( selector ) : selector || [], false ).length; } } ); // Initialize a jQuery object // A central reference to the root jQuery(document) var rootjQuery, // A simple way to check for HTML strings // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) // Strict HTML recognition (#11290: must start with <) // Shortcut simple #id case for speed rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery.fn.init = function( selector, context, root ) { var match, elem; // HANDLE: $(""), $(null), $(undefined), $(false) if ( !selector ) { return this; } // Method init() accepts an alternate rootjQuery // so migrate can support jQuery.sub (gh-2101) root = root || rootjQuery; // Handle HTML strings if ( typeof selector === "string" ) { if ( selector[ 0 ] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) { // Assume that strings that start and end with <> are HTML and skip the regex check match = [ null, selector, null ]; } else { match = rquickExpr.exec( selector ); } // Match html or make sure no context is specified for #id if ( match && ( match[ 1 ] || !context ) ) { // HANDLE: $(html) -> $(array) if ( match[ 1 ] ) { context = context instanceof jQuery ? context[ 0 ] : context; // Option to run scripts is true for back-compat // Intentionally let the error be thrown if parseHTML is not present jQuery.merge( this, jQuery.parseHTML( match[ 1 ], context && context.nodeType ? context.ownerDocument || context : document, true ) ); // HANDLE: $(html, props) if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { for ( match in context ) { // Properties of context are called as methods if possible if ( isFunction( this[ match ] ) ) { this[ match ]( context[ match ] ); // ...and otherwise set as attributes } else { this.attr( match, context[ match ] ); } } } return this; // HANDLE: $(#id) } else { elem = document.getElementById( match[ 2 ] ); if ( elem ) { // Inject the element directly into the jQuery object this[ 0 ] = elem; this.length = 1; } return this; } // HANDLE: $(expr, $(...)) } else if ( !context || context.jquery ) { return ( context || root ).find( selector ); // HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr) } else { return this.constructor( context ).find( selector ); } // HANDLE: $(DOMElement) } else if ( selector.nodeType ) { this[ 0 ] = selector; this.length = 1; return this; // HANDLE: $(function) // Shortcut for document ready } else if ( isFunction( selector ) ) { return root.ready !== undefined ? root.ready( selector ) : // Execute immediately if ready is not present selector( jQuery ); } return jQuery.makeArray( selector, this ); }; // Give the init function the jQuery prototype for later instantiation init.prototype = jQuery.fn; // Initialize central reference rootjQuery = jQuery( document ); var rparentsprev = /^(?:parents|prev(?:Until|All))/, // Methods guaranteed to produce a unique set when starting from a unique set guaranteedUnique = { children: true, contents: true, next: true, prev: true }; jQuery.fn.extend( { has: function( target ) { var targets = jQuery( target, this ), l = targets.length; return this.filter( function() { var i = 0; for ( ; i < l; i++ ) { if ( jQuery.contains( this, targets[ i ] ) ) { return true; } } } ); }, closest: function( selectors, context ) { var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery( selectors ); // Positional selectors never match, since there's no _selection_ context if ( !rneedsContext.test( selectors ) ) { for ( ; i < l; i++ ) { for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { // Always skip document fragments if ( cur.nodeType < 11 && ( targets ? targets.index( cur ) > -1 : // Don't pass non-elements to Sizzle cur.nodeType === 1 && jQuery.find.matchesSelector( cur, selectors ) ) ) { matched.push( cur ); break; } } } } return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); }, // Determine the position of an element within the set index: function( elem ) { // No argument, return index in parent if ( !elem ) { return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; } // Index in selector if ( typeof elem === "string" ) { return indexOf.call( jQuery( elem ), this[ 0 ] ); } // Locate the position of the desired element return indexOf.call( this, // If it receives a jQuery object, the first element is used elem.jquery ? elem[ 0 ] : elem ); }, add: function( selector, context ) { return this.pushStack( jQuery.uniqueSort( jQuery.merge( this.get(), jQuery( selector, context ) ) ) ); }, addBack: function( selector ) { return this.add( selector == null ? this.prevObject : this.prevObject.filter( selector ) ); } } ); function sibling( cur, dir ) { while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} return cur; } jQuery.each( { parent: function( elem ) { var parent = elem.parentNode; return parent && parent.nodeType !== 11 ? parent : null; }, parents: function( elem ) { return dir( elem, "parentNode" ); }, parentsUntil: function( elem, i, until ) { return dir( elem, "parentNode", until ); }, next: function( elem ) { return sibling( elem, "nextSibling" ); }, prev: function( elem ) { return sibling( elem, "previousSibling" ); }, nextAll: function( elem ) { return dir( elem, "nextSibling" ); }, prevAll: function( elem ) { return dir( elem, "previousSibling" ); }, nextUntil: function( elem, i, until ) { return dir( elem, "nextSibling", until ); }, prevUntil: function( elem, i, until ) { return dir( elem, "previousSibling", until ); }, siblings: function( elem ) { return siblings( ( elem.parentNode || {} ).firstChild, elem ); }, children: function( elem ) { return siblings( elem.firstChild ); }, contents: function( elem ) { if ( nodeName( elem, "iframe" ) ) { return elem.contentDocument; } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only // Treat the template element as a regular one in browsers that // don't support it. if ( nodeName( elem, "template" ) ) { elem = elem.content || elem; } return jQuery.merge( [], elem.childNodes ); } }, function( name, fn ) { jQuery.fn[ name ] = function( until, selector ) { var matched = jQuery.map( this, fn, until ); if ( name.slice( -5 ) !== "Until" ) { selector = until; } if ( selector && typeof selector === "string" ) { matched = jQuery.filter( selector, matched ); } if ( this.length > 1 ) { // Remove duplicates if ( !guaranteedUnique[ name ] ) { jQuery.uniqueSort( matched ); } // Reverse order for parents* and prev-derivatives if ( rparentsprev.test( name ) ) { matched.reverse(); } } return this.pushStack( matched ); }; } ); var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); // Convert String-formatted options into Object-formatted ones function createOptions( options ) { var object = {}; jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { object[ flag ] = true; } ); return object; } /* * Create a callback list using the following parameters: * * options: an optional list of space-separated options that will change how * the callback list behaves or a more traditional option object * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible options: * * once: will ensure the callback list can only be fired once (like a Deferred) * * memory: will keep track of previous values and will call any callback added * after the list has been fired right away with the latest "memorized" * values (like a Deferred) * * unique: will ensure a callback can only be added once (no duplicate in the list) * * stopOnFalse: interrupt callings when a callback returns false * */ jQuery.Callbacks = function( options ) { // Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? createOptions( options ) : jQuery.extend( {}, options ); var // Flag to know if list is currently firing firing, // Last fire value for non-forgettable lists memory, // Flag to know if list was already fired fired, // Flag to prevent firing locked, // Actual callback list list = [], // Queue of execution data for repeatable lists queue = [], // Index of currently firing callback (modified by add/remove as needed) firingIndex = -1, // Fire callbacks fire = function() { // Enforce single-firing locked = locked || options.once; // Execute callbacks for all pending executions, // respecting firingIndex overrides and runtime changes fired = firing = true; for ( ; queue.length; firingIndex = -1 ) { memory = queue.shift(); while ( ++firingIndex < list.length ) { // Run callback and check for early termination if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && options.stopOnFalse ) { // Jump to end and forget the data so .add doesn't re-fire firingIndex = list.length; memory = false; } } } // Forget the data if we're done with it if ( !options.memory ) { memory = false; } firing = false; // Clean up if we're done firing for good if ( locked ) { // Keep an empty list if we have data for future add calls if ( memory ) { list = []; // Otherwise, this object is spent } else { list = ""; } } }, // Actual Callbacks object self = { // Add a callback or a collection of callbacks to the list add: function() { if ( list ) { // If we have memory from a past run, we should fire after adding if ( memory && !firing ) { firingIndex = list.length - 1; queue.push( memory ); } ( function add( args ) { jQuery.each( args, function( _, arg ) { if ( isFunction( arg ) ) { if ( !options.unique || !self.has( arg ) ) { list.push( arg ); } } else if ( arg && arg.length && toType( arg ) !== "string" ) { // Inspect recursively add( arg ); } } ); } )( arguments ); if ( memory && !firing ) { fire(); } } return this; }, // Remove a callback from the list remove: function() { jQuery.each( arguments, function( _, arg ) { var index; while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { list.splice( index, 1 ); // Handle firing indexes if ( index <= firingIndex ) { firingIndex--; } } } ); return this; }, // Check if a given callback is in the list. // If no argument is given, return whether or not list has callbacks attached. has: function( fn ) { return fn ? jQuery.inArray( fn, list ) > -1 : list.length > 0; }, // Remove all callbacks from the list empty: function() { if ( list ) { list = []; } return this; }, // Disable .fire and .add // Abort any current/pending executions // Clear all callbacks and values disable: function() { locked = queue = []; list = memory = ""; return this; }, disabled: function() { return !list; }, // Disable .fire // Also disable .add unless we have memory (since it would have no effect) // Abort any pending executions lock: function() { locked = queue = []; if ( !memory && !firing ) { list = memory = ""; } return this; }, locked: function() { return !!locked; }, // Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( !locked ) { args = args || []; args = [ context, args.slice ? args.slice() : args ]; queue.push( args ); if ( !firing ) { fire(); } } return this; }, // Call all the callbacks with the given arguments fire: function() { self.fireWith( this, arguments ); return this; }, // To know if the callbacks have already been called at least once fired: function() { return !!fired; } }; return self; }; function Identity( v ) { return v; } function Thrower( ex ) { throw ex; } function adoptValue( value, resolve, reject, noValue ) { var method; try { // Check for promise aspect first to privilege synchronous behavior if ( value && isFunction( ( method = value.promise ) ) ) { method.call( value ).done( resolve ).fail( reject ); // Other thenables } else if ( value && isFunction( ( method = value.then ) ) ) { method.call( value, resolve, reject ); // Other non-thenables } else { // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: // * false: [ value ].slice( 0 ) => resolve( value ) // * true: [ value ].slice( 1 ) => resolve() resolve.apply( undefined, [ value ].slice( noValue ) ); } // For Promises/A+, convert exceptions into rejections // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in // Deferred#then to conditionally suppress rejection. } catch ( value ) { // Support: Android 4.0 only // Strict mode functions invoked without .call/.apply get global-object context reject.apply( undefined, [ value ] ); } } jQuery.extend( { Deferred: function( func ) { var tuples = [ // action, add listener, callbacks, // ... .then handlers, argument index, [final state] [ "notify", "progress", jQuery.Callbacks( "memory" ), jQuery.Callbacks( "memory" ), 2 ], [ "resolve", "done", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 0, "resolved" ], [ "reject", "fail", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 1, "rejected" ] ], state = "pending", promise = { state: function() { return state; }, always: function() { deferred.done( arguments ).fail( arguments ); return this; }, "catch": function( fn ) { return promise.then( null, fn ); }, // Keep pipe for back-compat pipe: function( /* fnDone, fnFail, fnProgress */ ) { var fns = arguments; return jQuery.Deferred( function( newDefer ) { jQuery.each( tuples, function( i, tuple ) { // Map tuples (progress, done, fail) to arguments (done, fail, progress) var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; // deferred.progress(function() { bind to newDefer or newDefer.notify }) // deferred.done(function() { bind to newDefer or newDefer.resolve }) // deferred.fail(function() { bind to newDefer or newDefer.reject }) deferred[ tuple[ 1 ] ]( function() { var returned = fn && fn.apply( this, arguments ); if ( returned && isFunction( returned.promise ) ) { returned.promise() .progress( newDefer.notify ) .done( newDefer.resolve ) .fail( newDefer.reject ); } else { newDefer[ tuple[ 0 ] + "With" ]( this, fn ? [ returned ] : arguments ); } } ); } ); fns = null; } ).promise(); }, then: function( onFulfilled, onRejected, onProgress ) { var maxDepth = 0; function resolve( depth, deferred, handler, special ) { return function() { var that = this, args = arguments, mightThrow = function() { var returned, then; // Support: Promises/A+ section 2.3.3.3.3 // https://promisesaplus.com/#point-59 // Ignore double-resolution attempts if ( depth < maxDepth ) { return; } returned = handler.apply( that, args ); // Support: Promises/A+ section 2.3.1 // https://promisesaplus.com/#point-48 if ( returned === deferred.promise() ) { throw new TypeError( "Thenable self-resolution" ); } // Support: Promises/A+ sections 2.3.3.1, 3.5 // https://promisesaplus.com/#point-54 // https://promisesaplus.com/#point-75 // Retrieve `then` only once then = returned && // Support: Promises/A+ section 2.3.4 // https://promisesaplus.com/#point-64 // Only check objects and functions for thenability ( typeof returned === "object" || typeof returned === "function" ) && returned.then; // Handle a returned thenable if ( isFunction( then ) ) { // Special processors (notify) just wait for resolution if ( special ) { then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ) ); // Normal processors (resolve) also hook into progress } else { // ...and disregard older resolution values maxDepth++; then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ), resolve( maxDepth, deferred, Identity, deferred.notifyWith ) ); } // Handle all other returned values } else { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Identity ) { that = undefined; args = [ returned ]; } // Process the value(s) // Default process is resolve ( special || deferred.resolveWith )( that, args ); } }, // Only normal processors (resolve) catch and reject exceptions process = special ? mightThrow : function() { try { mightThrow(); } catch ( e ) { if ( jQuery.Deferred.exceptionHook ) { jQuery.Deferred.exceptionHook( e, process.stackTrace ); } // Support: Promises/A+ section 2.3.3.3.4.1 // https://promisesaplus.com/#point-61 // Ignore post-resolution exceptions if ( depth + 1 >= maxDepth ) { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Thrower ) { that = undefined; args = [ e ]; } deferred.rejectWith( that, args ); } } }; // Support: Promises/A+ section 2.3.3.3.1 // https://promisesaplus.com/#point-57 // Re-resolve promises immediately to dodge false rejection from // subsequent errors if ( depth ) { process(); } else { // Call an optional hook to record the stack, in case of exception // since it's otherwise lost when execution goes async if ( jQuery.Deferred.getStackHook ) { process.stackTrace = jQuery.Deferred.getStackHook(); } window.setTimeout( process ); } }; } return jQuery.Deferred( function( newDefer ) { // progress_handlers.add( ... ) tuples[ 0 ][ 3 ].add( resolve( 0, newDefer, isFunction( onProgress ) ? onProgress : Identity, newDefer.notifyWith ) ); // fulfilled_handlers.add( ... ) tuples[ 1 ][ 3 ].add( resolve( 0, newDefer, isFunction( onFulfilled ) ? onFulfilled : Identity ) ); // rejected_handlers.add( ... ) tuples[ 2 ][ 3 ].add( resolve( 0, newDefer, isFunction( onRejected ) ? onRejected : Thrower ) ); } ).promise(); }, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { return obj != null ? jQuery.extend( obj, promise ) : promise; } }, deferred = {}; // Add list-specific methods jQuery.each( tuples, function( i, tuple ) { var list = tuple[ 2 ], stateString = tuple[ 5 ]; // promise.progress = list.add // promise.done = list.add // promise.fail = list.add promise[ tuple[ 1 ] ] = list.add; // Handle state if ( stateString ) { list.add( function() { // state = "resolved" (i.e., fulfilled) // state = "rejected" state = stateString; }, // rejected_callbacks.disable // fulfilled_callbacks.disable tuples[ 3 - i ][ 2 ].disable, // rejected_handlers.disable // fulfilled_handlers.disable tuples[ 3 - i ][ 3 ].disable, // progress_callbacks.lock tuples[ 0 ][ 2 ].lock, // progress_handlers.lock tuples[ 0 ][ 3 ].lock ); } // progress_handlers.fire // fulfilled_handlers.fire // rejected_handlers.fire list.add( tuple[ 3 ].fire ); // deferred.notify = function() { deferred.notifyWith(...) } // deferred.resolve = function() { deferred.resolveWith(...) } // deferred.reject = function() { deferred.rejectWith(...) } deferred[ tuple[ 0 ] ] = function() { deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); return this; }; // deferred.notifyWith = list.fireWith // deferred.resolveWith = list.fireWith // deferred.rejectWith = list.fireWith deferred[ tuple[ 0 ] + "With" ] = list.fireWith; } ); // Make the deferred a promise promise.promise( deferred ); // Call given func if any if ( func ) { func.call( deferred, deferred ); } // All done! return deferred; }, // Deferred helper when: function( singleValue ) { var // count of uncompleted subordinates remaining = arguments.length, // count of unprocessed arguments i = remaining, // subordinate fulfillment data resolveContexts = Array( i ), resolveValues = slice.call( arguments ), // the master Deferred master = jQuery.Deferred(), // subordinate callback factory updateFunc = function( i ) { return function( value ) { resolveContexts[ i ] = this; resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; if ( !( --remaining ) ) { master.resolveWith( resolveContexts, resolveValues ); } }; }; // Single- and empty arguments are adopted like Promise.resolve if ( remaining <= 1 ) { adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, !remaining ); // Use .then() to unwrap secondary thenables (cf. gh-3000) if ( master.state() === "pending" || isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { return master.then(); } } // Multiple arguments are aggregated like Promise.all array elements while ( i-- ) { adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); } return master.promise(); } } ); // These usually indicate a programmer mistake during development, // warn about them ASAP rather than swallowing them by default. var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; jQuery.Deferred.exceptionHook = function( error, stack ) { // Support: IE 8 - 9 only // Console exists when dev tools are open, which can happen at any time if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); } }; jQuery.readyException = function( error ) { window.setTimeout( function() { throw error; } ); }; // The deferred used on DOM ready var readyList = jQuery.Deferred(); jQuery.fn.ready = function( fn ) { readyList .then( fn ) // Wrap jQuery.readyException in a function so that the lookup // happens at the time of error handling instead of callback // registration. .catch( function( error ) { jQuery.readyException( error ); } ); return this; }; jQuery.extend( { // Is the DOM ready to be used? Set to true once it occurs. isReady: false, // A counter to track how many items to wait for before // the ready event fires. See #6781 readyWait: 1, // Handle when the DOM is ready ready: function( wait ) { // Abort if there are pending holds or we're already ready if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { return; } // Remember that the DOM is ready jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be if ( wait !== true && --jQuery.readyWait > 0 ) { return; } // If there are functions bound, to execute readyList.resolveWith( document, [ jQuery ] ); } } ); jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method function completed() { document.removeEventListener( "DOMContentLoaded", completed ); window.removeEventListener( "load", completed ); jQuery.ready(); } // Catch cases where $(document).ready() is called // after the browser event has already occurred. // Support: IE <=9 - 10 only // Older IE sometimes signals "interactive" too soon if ( document.readyState === "complete" || ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { // Handle it asynchronously to allow scripts the opportunity to delay ready window.setTimeout( jQuery.ready ); } else { // Use the handy event callback document.addEventListener( "DOMContentLoaded", completed ); // A fallback to window.onload, that will always work window.addEventListener( "load", completed ); } // Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { var i = 0, len = elems.length, bulk = key == null; // Sets many values if ( toType( key ) === "object" ) { chainable = true; for ( i in key ) { access( elems, fn, i, key[ i ], true, emptyGet, raw ); } // Sets one value } else if ( value !== undefined ) { chainable = true; if ( !isFunction( value ) ) { raw = true; } if ( bulk ) { // Bulk operations run against the entire set if ( raw ) { fn.call( elems, value ); fn = null; // ...except when executing function values } else { bulk = fn; fn = function( elem, key, value ) { return bulk.call( jQuery( elem ), value ); }; } } if ( fn ) { for ( ; i < len; i++ ) { fn( elems[ i ], key, raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) ) ); } } } if ( chainable ) { return elems; } // Gets if ( bulk ) { return fn.call( elems ); } return len ? fn( elems[ 0 ], key ) : emptyGet; }; // Matches dashed string for camelizing var rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace() function fcamelCase( all, letter ) { return letter.toUpperCase(); } // Convert dashed to camelCase; used by the css and data modules // Support: IE <=9 - 11, Edge 12 - 15 // Microsoft forgot to hump their vendor prefix (#9572) function camelCase( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); } var acceptData = function( owner ) { // Accepts only: // - Node // - Node.ELEMENT_NODE // - Node.DOCUMENT_NODE // - Object // - Any return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); }; function Data() { this.expando = jQuery.expando + Data.uid++; } Data.uid = 1; Data.prototype = { cache: function( owner ) { // Check if the owner object already has a cache var value = owner[ this.expando ]; // If not, create one if ( !value ) { value = {}; // We can accept data for non-element nodes in modern browsers, // but we should not, see #8335. // Always return an empty object. if ( acceptData( owner ) ) { // If it is a node unlikely to be stringify-ed or looped over // use plain assignment if ( owner.nodeType ) { owner[ this.expando ] = value; // Otherwise secure it in a non-enumerable property // configurable must be true to allow the property to be // deleted when data is removed } else { Object.defineProperty( owner, this.expando, { value: value, configurable: true } ); } } } return value; }, set: function( owner, data, value ) { var prop, cache = this.cache( owner ); // Handle: [ owner, key, value ] args // Always use camelCase key (gh-2257) if ( typeof data === "string" ) { cache[ camelCase( data ) ] = value; // Handle: [ owner, { properties } ] args } else { // Copy the properties one-by-one to the cache object for ( prop in data ) { cache[ camelCase( prop ) ] = data[ prop ]; } } return cache; }, get: function( owner, key ) { return key === undefined ? this.cache( owner ) : // Always use camelCase key (gh-2257) owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; }, access: function( owner, key, value ) { // In cases where either: // // 1. No key was specified // 2. A string key was specified, but no value provided // // Take the "read" path and allow the get method to determine // which value to return, respectively either: // // 1. The entire cache object // 2. The data stored at the key // if ( key === undefined || ( ( key && typeof key === "string" ) && value === undefined ) ) { return this.get( owner, key ); } // When the key is not a string, or both a key and value // are specified, set or extend (existing objects) with either: // // 1. An object of properties // 2. A key and value // this.set( owner, key, value ); // Since the "set" path can have two possible entry points // return the expected data based on which path was taken[*] return value !== undefined ? value : key; }, remove: function( owner, key ) { var i, cache = owner[ this.expando ]; if ( cache === undefined ) { return; } if ( key !== undefined ) { // Support array or space separated string of keys if ( Array.isArray( key ) ) { // If key is an array of keys... // We always set camelCase keys, so remove that. key = key.map( camelCase ); } else { key = camelCase( key ); // If a key with the spaces exists, use it. // Otherwise, create an array by matching non-whitespace key = key in cache ? [ key ] : ( key.match( rnothtmlwhite ) || [] ); } i = key.length; while ( i-- ) { delete cache[ key[ i ] ]; } } // Remove the expando if there's no more data if ( key === undefined || jQuery.isEmptyObject( cache ) ) { // Support: Chrome <=35 - 45 // Webkit & Blink performance suffers when deleting properties // from DOM nodes, so set to undefined instead // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) if ( owner.nodeType ) { owner[ this.expando ] = undefined; } else { delete owner[ this.expando ]; } } }, hasData: function( owner ) { var cache = owner[ this.expando ]; return cache !== undefined && !jQuery.isEmptyObject( cache ); } }; var dataPriv = new Data(); var dataUser = new Data(); // Implementation Summary // // 1. Enforce API surface and semantic compatibility with 1.9.x branch // 2. Improve the module's maintainability by reducing the storage // paths to a single mechanism. // 3. Use the same single mechanism to support "private" and "user" data. // 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) // 5. Avoid exposing implementation details on user objects (eg. expando properties) // 6. Provide a clear path for implementation upgrade to WeakMap in 2014 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g; function getData( data ) { if ( data === "true" ) { return true; } if ( data === "false" ) { return false; } if ( data === "null" ) { return null; } // Only convert to a number if it doesn't change the string if ( data === +data + "" ) { return +data; } if ( rbrace.test( data ) ) { return JSON.parse( data ); } return data; } function dataAttr( elem, key, data ) { var name; // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = getData( data ); } catch ( e ) {} // Make sure we set the data so it isn't changed later dataUser.set( elem, key, data ); } else { data = undefined; } } return data; } jQuery.extend( { hasData: function( elem ) { return dataUser.hasData( elem ) || dataPriv.hasData( elem ); }, data: function( elem, name, data ) { return dataUser.access( elem, name, data ); }, removeData: function( elem, name ) { dataUser.remove( elem, name ); }, // TODO: Now that all calls to _data and _removeData have been replaced // with direct calls to dataPriv methods, these can be deprecated. _data: function( elem, name, data ) { return dataPriv.access( elem, name, data ); }, _removeData: function( elem, name ) { dataPriv.remove( elem, name ); } } ); jQuery.fn.extend( { data: function( key, value ) { var i, name, data, elem = this[ 0 ], attrs = elem && elem.attributes; // Gets all values if ( key === undefined ) { if ( this.length ) { data = dataUser.get( elem ); if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { i = attrs.length; while ( i-- ) { // Support: IE 11 only // The attrs elements can be null (#14894) if ( attrs[ i ] ) { name = attrs[ i ].name; if ( name.indexOf( "data-" ) === 0 ) { name = camelCase( name.slice( 5 ) ); dataAttr( elem, name, data[ name ] ); } } } dataPriv.set( elem, "hasDataAttrs", true ); } } return data; } // Sets multiple values if ( typeof key === "object" ) { return this.each( function() { dataUser.set( this, key ); } ); } return access( this, function( value ) { var data; // The calling jQuery object (element matches) is not empty // (and therefore has an element appears at this[ 0 ]) and the // `value` parameter was not undefined. An empty jQuery object // will result in `undefined` for elem = this[ 0 ] which will // throw an exception if an attempt to read a data cache is made. if ( elem && value === undefined ) { // Attempt to get data from the cache // The key will always be camelCased in Data data = dataUser.get( elem, key ); if ( data !== undefined ) { return data; } // Attempt to "discover" the data in // HTML5 custom data-* attrs data = dataAttr( elem, key ); if ( data !== undefined ) { return data; } // We tried really hard, but the data doesn't exist. return; } // Set the data... this.each( function() { // We always store the camelCased key dataUser.set( this, key, value ); } ); }, null, value, arguments.length > 1, null, true ); }, removeData: function( key ) { return this.each( function() { dataUser.remove( this, key ); } ); } } ); jQuery.extend( { queue: function( elem, type, data ) { var queue; if ( elem ) { type = ( type || "fx" ) + "queue"; queue = dataPriv.get( elem, type ); // Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !queue || Array.isArray( data ) ) { queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); } else { queue.push( data ); } } return queue || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = jQuery.queue( elem, type ), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks( elem, type ), next = function() { jQuery.dequeue( elem, type ); }; // If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift(); startLength--; } if ( fn ) { // Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); } // Clear up the last queue stop function delete hooks.stop; fn.call( elem, next, hooks ); } if ( !startLength && hooks ) { hooks.empty.fire(); } }, // Not public - generate a queueHooks object, or return the current one _queueHooks: function( elem, type ) { var key = type + "queueHooks"; return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { empty: jQuery.Callbacks( "once memory" ).add( function() { dataPriv.remove( elem, [ type + "queue", key ] ); } ) } ); } } ); jQuery.fn.extend( { queue: function( type, data ) { var setter = 2; if ( typeof type !== "string" ) { data = type; type = "fx"; setter--; } if ( arguments.length < setter ) { return jQuery.queue( this[ 0 ], type ); } return data === undefined ? this : this.each( function() { var queue = jQuery.queue( this, type, data ); // Ensure a hooks for this queue jQuery._queueHooks( this, type ); if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { jQuery.dequeue( this, type ); } } ); }, dequeue: function( type ) { return this.each( function() { jQuery.dequeue( this, type ); } ); }, clearQueue: function( type ) { return this.queue( type || "fx", [] ); }, // Get a promise resolved when queues of a certain type // are emptied (fx is the type by default) promise: function( type, obj ) { var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); } }; if ( typeof type !== "string" ) { obj = type; type = undefined; } type = type || "fx"; while ( i-- ) { tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); if ( tmp && tmp.empty ) { count++; tmp.empty.add( resolve ); } } resolve(); return defer.promise( obj ); } } ); var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; var isHiddenWithinTree = function( elem, el ) { // isHiddenWithinTree might be called from jQuery#filter function; // in that case, element will be second argument elem = el || elem; // Inline style trumps all return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style // Support: Firefox <=43 - 45 // Disconnected elements can have computed display: none, so first confirm that elem is // in the document. jQuery.contains( elem.ownerDocument, elem ) && jQuery.css( elem, "display" ) === "none"; }; var swap = function( elem, options, callback, args ) { var ret, name, old = {}; // Remember the old values, and insert the new ones for ( name in options ) { old[ name ] = elem.style[ name ]; elem.style[ name ] = options[ name ]; } ret = callback.apply( elem, args || [] ); // Revert the old values for ( name in options ) { elem.style[ name ] = old[ name ]; } return ret; }; function adjustCSS( elem, prop, valueParts, tween ) { var adjusted, scale, maxIterations = 20, currentValue = tween ? function() { return tween.cur(); } : function() { return jQuery.css( elem, prop, "" ); }, initial = currentValue(), unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), // Starting value computation is required for potential unit mismatches initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && rcssNum.exec( jQuery.css( elem, prop ) ); if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { // Support: Firefox <=54 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) initial = initial / 2; // Trust units reported by jQuery.css unit = unit || initialInUnit[ 3 ]; // Iteratively approximate from a nonzero starting point initialInUnit = +initial || 1; while ( maxIterations-- ) { // Evaluate and update our best guess (doubling guesses that zero out). // Finish if the scale equals or crosses 1 (making the old*new product non-positive). jQuery.style( elem, prop, initialInUnit + unit ); if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { maxIterations = 0; } initialInUnit = initialInUnit / scale; } initialInUnit = initialInUnit * 2; jQuery.style( elem, prop, initialInUnit + unit ); // Make sure we update the tween properties later on valueParts = valueParts || []; } if ( valueParts ) { initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified adjusted = valueParts[ 1 ] ? initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : +valueParts[ 2 ]; if ( tween ) { tween.unit = unit; tween.start = initialInUnit; tween.end = adjusted; } } return adjusted; } var defaultDisplayMap = {}; function getDefaultDisplay( elem ) { var temp, doc = elem.ownerDocument, nodeName = elem.nodeName, display = defaultDisplayMap[ nodeName ]; if ( display ) { return display; } temp = doc.body.appendChild( doc.createElement( nodeName ) ); display = jQuery.css( temp, "display" ); temp.parentNode.removeChild( temp ); if ( display === "none" ) { display = "block"; } defaultDisplayMap[ nodeName ] = display; return display; } function showHide( elements, show ) { var display, elem, values = [], index = 0, length = elements.length; // Determine new display value for elements that need to change for ( ; index < length; index++ ) { elem = elements[ index ]; if ( !elem.style ) { continue; } display = elem.style.display; if ( show ) { // Since we force visibility upon cascade-hidden elements, an immediate (and slow) // check is required in this first loop unless we have a nonempty display value (either // inline or about-to-be-restored) if ( display === "none" ) { values[ index ] = dataPriv.get( elem, "display" ) || null; if ( !values[ index ] ) { elem.style.display = ""; } } if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { values[ index ] = getDefaultDisplay( elem ); } } else { if ( display !== "none" ) { values[ index ] = "none"; // Remember what we're overwriting dataPriv.set( elem, "display", display ); } } } // Set the display of the elements in a second loop to avoid constant reflow for ( index = 0; index < length; index++ ) { if ( values[ index ] != null ) { elements[ index ].style.display = values[ index ]; } } return elements; } jQuery.fn.extend( { show: function() { return showHide( this, true ); }, hide: function() { return showHide( this ); }, toggle: function( state ) { if ( typeof state === "boolean" ) { return state ? this.show() : this.hide(); } return this.each( function() { if ( isHiddenWithinTree( this ) ) { jQuery( this ).show(); } else { jQuery( this ).hide(); } } ); } } ); var rcheckableType = ( /^(?:checkbox|radio)$/i ); var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i ); var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); // We have to close these tags to support XHTML (#13200) var wrapMap = { // Support: IE <=9 only option: [ 1, "<select multiple='multiple'>", "</select>" ], // XHTML parsers do not magically insert elements in the // same way that tag soup parsers do. So we cannot shorten // this by omitting <tbody> or other required elements. thead: [ 1, "", "
    " ], col: [ 2, "<colgroup>", "</colgroup>
    " ], tr: [ 2, "<tbody>", "</tbody>
    " ], td: [ 3, "<tbody>", "</tbody>
    " ],

    _default: [ 0, "", "" ] };

    // Support: IE <=9 only wrapMap.optgroup = wrapMap.option;

    wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td;


    function getAll( context, tag ) {

    // Support: IE <=9 - 11 only // Use typeof to avoid zero-argument method invocation on host objects (#15151) var ret;

    if ( typeof context.getElementsByTagName !== "undefined" ) { ret = context.getElementsByTagName( tag || "*" );

    } else if ( typeof context.querySelectorAll !== "undefined" ) { ret = context.querySelectorAll( tag || "*" );

    } else { ret = []; }

    if ( tag === undefined || tag && nodeName( context, tag ) ) { return jQuery.merge( [ context ], ret ); }

    return ret; }


    // Mark scripts as having already been evaluated function setGlobalEval( elems, refElements ) { var i = 0, l = elems.length;

    for ( ; i < l; i++ ) { dataPriv.set( elems[ i ], "globalEval", !refElements || dataPriv.get( refElements[ i ], "globalEval" ) ); } }


    var rhtml = /<|&#?\w+;/;

    function buildFragment( elems, context, scripts, selection, ignored ) { var elem, tmp, tag, wrap, contains, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length;

    for ( ; i < l; i++ ) { elem = elems[ i ];

    if ( elem || elem === 0 ) {

    // Add nodes directly if ( toType( elem ) === "object" ) {

    // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );

    // Convert non-html into a text node } else if ( !rhtml.test( elem ) ) { nodes.push( context.createTextNode( elem ) );

    // Convert html into DOM nodes } else { tmp = tmp || fragment.appendChild( context.createElement( "div" ) );

    // Deserialize a standard representation tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); wrap = wrapMap[ tag ] || wrapMap._default; tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];

    // Descend through wrappers to the right content j = wrap[ 0 ]; while ( j-- ) { tmp = tmp.lastChild; }

    // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, tmp.childNodes );

    // Remember the top-level container tmp = fragment.firstChild;

    // Ensure the created nodes are orphaned (#12392) tmp.textContent = ""; } } }

    // Remove wrapper from fragment fragment.textContent = "";

    i = 0; while ( ( elem = nodes[ i++ ] ) ) {

    // Skip elements already in the context collection (trac-4087) if ( selection && jQuery.inArray( elem, selection ) > -1 ) { if ( ignored ) { ignored.push( elem ); } continue; }

    contains = jQuery.contains( elem.ownerDocument, elem );

    // Append to fragment tmp = getAll( fragment.appendChild( elem ), "script" );

    // Preserve script evaluation history if ( contains ) { setGlobalEval( tmp ); }

    // Capture executables if ( scripts ) { j = 0; while ( ( elem = tmp[ j++ ] ) ) { if ( rscriptType.test( elem.type || "" ) ) { scripts.push( elem ); } } } }

    return fragment; }


    ( function() { var fragment = document.createDocumentFragment(), div = fragment.appendChild( document.createElement( "div" ) ), input = document.createElement( "input" );

    // Support: Android 4.0 - 4.3 only // Check state lost if the name is set (#11217) // Support: Windows Web Apps (WWA) // `name` and `type` must use .setAttribute for WWA (#14901) input.setAttribute( "type", "radio" ); input.setAttribute( "checked", "checked" ); input.setAttribute( "name", "t" );

    div.appendChild( input );

    // Support: Android <=4.1 only // Older WebKit doesn't clone checked state correctly in fragments support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;

    // Support: IE <=11 only // Make sure textarea (and checkbox) defaultValue is properly cloned div.innerHTML = "<textarea>x</textarea>"; support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; } )(); var documentElement = document.documentElement;


    var rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/;

    function returnTrue() { return true; }

    function returnFalse() { return false; }

    // Support: IE <=9 only // See #13393 for more info function safeActiveElement() { try { return document.activeElement; } catch ( err ) { } }

    function on( elem, types, selector, data, fn, one ) { var origFn, type;

    // Types can be a map of types/handlers if ( typeof types === "object" ) {

    // ( types-Object, selector, data ) if ( typeof selector !== "string" ) {

    // ( types-Object, data ) data = data || selector; selector = undefined; } for ( type in types ) { on( elem, type, selector, data, types[ type ], one ); } return elem; }

    if ( data == null && fn == null ) {

    // ( types, fn ) fn = selector; data = selector = undefined; } else if ( fn == null ) { if ( typeof selector === "string" ) {

    // ( types, selector, fn ) fn = data; data = undefined; } else {

    // ( types, data, fn ) fn = data; data = selector; selector = undefined; } } if ( fn === false ) { fn = returnFalse; } else if ( !fn ) { return elem; }

    if ( one === 1 ) { origFn = fn; fn = function( event ) {

    // Can use an empty set, since event contains the info jQuery().off( event ); return origFn.apply( this, arguments ); };

    // Use same guid so caller can remove using origFn fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); } return elem.each( function() { jQuery.event.add( this, types, fn, data, selector ); } ); }

    /*

    * Helper functions for managing events -- not part of the public interface.
    * Props to Dean Edwards' addEvent library for many of the ideas.
    */
    

    jQuery.event = {

    global: {},

    add: function( elem, types, handler, data, selector ) {

    var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get( elem );

    // Don't attach events to noData or text/comment nodes (but allow plain objects) if ( !elemData ) { return; }

    // Caller can pass in an object of custom data in lieu of the handler if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; selector = handleObjIn.selector; }

    // Ensure that invalid selectors throw exceptions at attach time // Evaluate against documentElement in case elem is a non-element node (e.g., document) if ( selector ) { jQuery.find.matchesSelector( documentElement, selector ); }

    // Make sure that the handler has a unique ID, used to find/remove it later if ( !handler.guid ) { handler.guid = jQuery.guid++; }

    // Init the element's event structure and main handler, if this is the first if ( !( events = elemData.events ) ) { events = elemData.events = {}; } if ( !( eventHandle = elemData.handle ) ) { eventHandle = elemData.handle = function( e ) {

    // Discard the second event of a jQuery.event.trigger() and // when an event is called after a page has unloaded return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply( elem, arguments ) : undefined; }; }

    // Handle multiple events separated by a space types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();

    // There *must* be a type, no attaching namespace-only handlers if ( !type ) { continue; }

    // If event changes its type, use the special event handlers for the changed type special = jQuery.event.special[ type ] || {};

    // If selector defined, determine special event api type, otherwise given type type = ( selector ? special.delegateType : special.bindType ) || type;

    // Update special based on newly reset type special = jQuery.event.special[ type ] || {};

    // handleObj is passed to all event handlers handleObj = jQuery.extend( { type: type, origType: origType, data: data, handler: handler, guid: handler.guid, selector: selector, needsContext: selector && jQuery.expr.match.needsContext.test( selector ), namespace: namespaces.join( "." ) }, handleObjIn );

    // Init the event handler queue if we're the first if ( !( handlers = events[ type ] ) ) { handlers = events[ type ] = []; handlers.delegateCount = 0;

    // Only use addEventListener if the special events handler returns false if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {

    if ( elem.addEventListener ) { elem.addEventListener( type, eventHandle ); } } }

    if ( special.add ) { special.add.call( elem, handleObj );

    if ( !handleObj.handler.guid ) { handleObj.handler.guid = handler.guid; } }

    // Add to the element's handler list, delegates in front if ( selector ) { handlers.splice( handlers.delegateCount++, 0, handleObj ); } else { handlers.push( handleObj ); }

    // Keep track of which events have ever been used, for event optimization jQuery.event.global[ type ] = true; }

    },

    // Detach an event or set of events from an element remove: function( elem, types, handler, selector, mappedTypes ) {

    var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );

    if ( !elemData || !( events = elemData.events ) ) { return; }

    // Once for each type.namespace in types; type may be omitted types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();

    // Unbind all events (on this namespace, if provided) for the element if ( !type ) { for ( type in events ) { jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); } continue; }

    special = jQuery.event.special[ type ] || {}; type = ( selector ? special.delegateType : special.bindType ) || type; handlers = events[ type ] || []; tmp = tmp[ 2 ] && new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );

    // Remove matching events origCount = j = handlers.length; while ( j-- ) { handleObj = handlers[ j ];

    if ( ( mappedTypes || origType === handleObj.origType ) && ( !handler || handler.guid === handleObj.guid ) && ( !tmp || tmp.test( handleObj.namespace ) ) && ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { handlers.splice( j, 1 );

    if ( handleObj.selector ) { handlers.delegateCount--; } if ( special.remove ) { special.remove.call( elem, handleObj ); } } }

    // Remove generic event handler if we removed something and no more handlers exist // (avoids potential for endless recursion during removal of special event handlers) if ( origCount && !handlers.length ) { if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {

    jQuery.removeEvent( elem, type, elemData.handle ); }

    delete events[ type ]; } }

    // Remove data and the expando if it's no longer used if ( jQuery.isEmptyObject( events ) ) { dataPriv.remove( elem, "handle events" ); } },

    dispatch: function( nativeEvent ) {

    // Make a writable jQuery.Event from the native event object var event = jQuery.event.fix( nativeEvent );

    var i, j, ret, matched, handleObj, handlerQueue, args = new Array( arguments.length ), handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], special = jQuery.event.special[ event.type ] || {};

    // Use the fix-ed jQuery.Event rather than the (read-only) native event args[ 0 ] = event;

    for ( i = 1; i < arguments.length; i++ ) { args[ i ] = arguments[ i ]; }

    event.delegateTarget = this;

    // Call the preDispatch hook for the mapped type, and let it bail if desired if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { return; }

    // Determine handlers handlerQueue = jQuery.event.handlers.call( this, event, handlers );

    // Run delegates first; they may want to stop propagation beneath us i = 0; while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { event.currentTarget = matched.elem;

    j = 0; while ( ( handleObj = matched.handlers[ j++ ] ) && !event.isImmediatePropagationStopped() ) {

    // Triggered event must either 1) have no namespace, or 2) have namespace(s) // a subset or equal to those in the bound event (both can have no namespace). if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {

    event.handleObj = handleObj; event.data = handleObj.data;

    ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || handleObj.handler ).apply( matched.elem, args );

    if ( ret !== undefined ) { if ( ( event.result = ret ) === false ) { event.preventDefault(); event.stopPropagation(); } } } } }

    // Call the postDispatch hook for the mapped type if ( special.postDispatch ) { special.postDispatch.call( this, event ); }

    return event.result; },

    handlers: function( event, handlers ) { var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;

    // Find delegate handlers if ( delegateCount &&

    // Support: IE <=9 // Black-hole SVG <use> instance trees (trac-13180) cur.nodeType &&

    // Support: Firefox <=42 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click // Support: IE 11 only // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) !( event.type === "click" && event.button >= 1 ) ) {

    for ( ; cur !== this; cur = cur.parentNode || this ) {

    // Don't check non-elements (#13208) // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { matchedHandlers = []; matchedSelectors = {}; for ( i = 0; i < delegateCount; i++ ) { handleObj = handlers[ i ];

    // Don't conflict with Object.prototype properties (#13203) sel = handleObj.selector + " ";

    if ( matchedSelectors[ sel ] === undefined ) { matchedSelectors[ sel ] = handleObj.needsContext ? jQuery( sel, this ).index( cur ) > -1 : jQuery.find( sel, this, null, [ cur ] ).length; } if ( matchedSelectors[ sel ] ) { matchedHandlers.push( handleObj ); } } if ( matchedHandlers.length ) { handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); } } } }

    // Add the remaining (directly-bound) handlers cur = this; if ( delegateCount < handlers.length ) { handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); }

    return handlerQueue; },

    addProp: function( name, hook ) { Object.defineProperty( jQuery.Event.prototype, name, { enumerable: true, configurable: true,

    get: isFunction( hook ) ? function() { if ( this.originalEvent ) { return hook( this.originalEvent ); } } : function() { if ( this.originalEvent ) { return this.originalEvent[ name ]; } },

    set: function( value ) { Object.defineProperty( this, name, { enumerable: true, configurable: true, writable: true, value: value } ); } } ); },

    fix: function( originalEvent ) { return originalEvent[ jQuery.expando ] ? originalEvent : new jQuery.Event( originalEvent ); },

    special: { load: {

    // Prevent triggered image.load events from bubbling to window.load noBubble: true }, focus: {

    // Fire native event if possible so blur/focus sequence is correct trigger: function() { if ( this !== safeActiveElement() && this.focus ) { this.focus(); return false; } }, delegateType: "focusin" }, blur: { trigger: function() { if ( this === safeActiveElement() && this.blur ) { this.blur(); return false; } }, delegateType: "focusout" }, click: {

    // For checkbox, fire native event so checked state will be right trigger: function() { if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) { this.click(); return false; } },

    // For cross-browser consistency, don't fire native .click() on links _default: function( event ) { return nodeName( event.target, "a" ); } },

    beforeunload: { postDispatch: function( event ) {

    // Support: Firefox 20+ // Firefox doesn't alert if the returnValue field is not set. if ( event.result !== undefined && event.originalEvent ) { event.originalEvent.returnValue = event.result; } } } } };

    jQuery.removeEvent = function( elem, type, handle ) {

    // This "if" is needed for plain objects if ( elem.removeEventListener ) { elem.removeEventListener( type, handle ); } };

    jQuery.Event = function( src, props ) {

    // Allow instantiation without the 'new' keyword if ( !( this instanceof jQuery.Event ) ) { return new jQuery.Event( src, props ); }

    // Event object if ( src && src.type ) { this.originalEvent = src; this.type = src.type;

    // Events bubbling up the document may have been marked as prevented // by a handler lower down the tree; reflect the correct value. this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined &&

    // Support: Android <=2.3 only src.returnValue === false ? returnTrue : returnFalse;

    // Create target properties // Support: Safari <=6 - 7 only // Target should not be a text node (#504, #13143) this.target = ( src.target && src.target.nodeType === 3 ) ? src.target.parentNode : src.target;

    this.currentTarget = src.currentTarget; this.relatedTarget = src.relatedTarget;

    // Event type } else { this.type = src; }

    // Put explicitly provided properties onto the event object if ( props ) { jQuery.extend( this, props ); }

    // Create a timestamp if incoming event doesn't have one this.timeStamp = src && src.timeStamp || Date.now();

    // Mark it as fixed this[ jQuery.expando ] = true; };

    // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = { constructor: jQuery.Event, isDefaultPrevented: returnFalse, isPropagationStopped: returnFalse, isImmediatePropagationStopped: returnFalse, isSimulated: false,

    preventDefault: function() { var e = this.originalEvent;

    this.isDefaultPrevented = returnTrue;

    if ( e && !this.isSimulated ) { e.preventDefault(); } }, stopPropagation: function() { var e = this.originalEvent;

    this.isPropagationStopped = returnTrue;

    if ( e && !this.isSimulated ) { e.stopPropagation(); } }, stopImmediatePropagation: function() { var e = this.originalEvent;

    this.isImmediatePropagationStopped = returnTrue;

    if ( e && !this.isSimulated ) { e.stopImmediatePropagation(); }

    this.stopPropagation(); } };

    // Includes all common event props including KeyEvent and MouseEvent specific props jQuery.each( { altKey: true, bubbles: true, cancelable: true, changedTouches: true, ctrlKey: true, detail: true, eventPhase: true, metaKey: true, pageX: true, pageY: true, shiftKey: true, view: true, "char": true, charCode: true, key: true, keyCode: true, button: true, buttons: true, clientX: true, clientY: true, offsetX: true, offsetY: true, pointerId: true, pointerType: true, screenX: true, screenY: true, targetTouches: true, toElement: true, touches: true,

    which: function( event ) { var button = event.button;

    // Add which for key events if ( event.which == null && rkeyEvent.test( event.type ) ) { return event.charCode != null ? event.charCode : event.keyCode; }

    // Add which for click: 1 === left; 2 === middle; 3 === right if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { if ( button & 1 ) { return 1; }

    if ( button & 2 ) { return 3; }

    if ( button & 4 ) { return 2; }

    return 0; }

    return event.which; } }, jQuery.event.addProp );

    // Create mouseenter/leave events using mouseover/out and event-time checks // so that event delegation works in jQuery. // Do the same for pointerenter/pointerleave and pointerover/pointerout // // Support: Safari 7 only // Safari sends mouseenter too often; see: // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 // for the description of the bug (it existed in older Chrome versions as well). jQuery.each( { mouseenter: "mouseover", mouseleave: "mouseout", pointerenter: "pointerover", pointerleave: "pointerout" }, function( orig, fix ) { jQuery.event.special[ orig ] = { delegateType: fix, bindType: fix,

    handle: function( event ) { var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj;

    // For mouseenter/leave call the handler if related is outside the target. // NB: No relatedTarget if the mouse left/entered the browser window if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { event.type = handleObj.origType; ret = handleObj.handler.apply( this, arguments ); event.type = fix; } return ret; } }; } );

    jQuery.fn.extend( {

    on: function( types, selector, data, fn ) { return on( this, types, selector, data, fn ); }, one: function( types, selector, data, fn ) { return on( this, types, selector, data, fn, 1 ); }, off: function( types, selector, fn ) { var handleObj, type; if ( types && types.preventDefault && types.handleObj ) {

    // ( event ) dispatched jQuery.Event handleObj = types.handleObj; jQuery( types.delegateTarget ).off( handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler ); return this; } if ( typeof types === "object" ) {

    // ( types-object [, selector] ) for ( type in types ) { this.off( type, selector, types[ type ] ); } return this; } if ( selector === false || typeof selector === "function" ) {

    // ( types [, fn] ) fn = selector; selector = undefined; } if ( fn === false ) { fn = returnFalse; } return this.each( function() { jQuery.event.remove( this, types, fn, selector ); } ); } } );


    var

    /* eslint-disable max-len */

    // See https://github.com/eslint/eslint/issues/3229 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,

    /* eslint-enable */

    // Support: IE <=10 - 11, Edge 12 - 13 only // In IE/Edge using regex groups here causes severe slowdowns. // See https://connect.microsoft.com/IE/feedback/details/1736512/ rnoInnerhtml = /<script|<style|<link/i,

    // checked="checked" or checked rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;

    // Prefer a tbody over its parent table for containing new rows function manipulationTarget( elem, content ) { if ( nodeName( elem, "table" ) && nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {

    return jQuery( elem ).children( "tbody" )[ 0 ] || elem; }

    return elem; }

    // Replace/restore the type attribute of script elements for safe DOM manipulation function disableScript( elem ) { elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; return elem; } function restoreScript( elem ) { if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { elem.type = elem.type.slice( 5 ); } else { elem.removeAttribute( "type" ); }

    return elem; }

    function cloneCopyEvent( src, dest ) { var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

    if ( dest.nodeType !== 1 ) { return; }

    // 1. Copy private data: events, handlers, etc. if ( dataPriv.hasData( src ) ) { pdataOld = dataPriv.access( src ); pdataCur = dataPriv.set( dest, pdataOld ); events = pdataOld.events;

    if ( events ) { delete pdataCur.handle; pdataCur.events = {};

    for ( type in events ) { for ( i = 0, l = events[ type ].length; i < l; i++ ) { jQuery.event.add( dest, type, events[ type ][ i ] ); } } } }

    // 2. Copy user data if ( dataUser.hasData( src ) ) { udataOld = dataUser.access( src ); udataCur = jQuery.extend( {}, udataOld );

    dataUser.set( dest, udataCur ); } }

    // Fix IE bugs, see support tests function fixInput( src, dest ) { var nodeName = dest.nodeName.toLowerCase();

    // Fails to persist the checked state of a cloned checkbox or radio button. if ( nodeName === "input" && rcheckableType.test( src.type ) ) { dest.checked = src.checked;

    // Fails to return the selected option to the default selected state when cloning options } else if ( nodeName === "input" || nodeName === "textarea" ) { dest.defaultValue = src.defaultValue; } }

    function domManip( collection, args, callback, ignored ) {

    // Flatten any nested arrays args = concat.apply( [], args );

    var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[ 0 ], valueIsFunction = isFunction( value );

    // We can't cloneNode fragments that contain checked, in WebKit if ( valueIsFunction || ( l > 1 && typeof value === "string" && !support.checkClone && rchecked.test( value ) ) ) { return collection.each( function( index ) { var self = collection.eq( index ); if ( valueIsFunction ) { args[ 0 ] = value.call( this, index, self.html() ); } domManip( self, args, callback, ignored ); } ); }

    if ( l ) { fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); first = fragment.firstChild;

    if ( fragment.childNodes.length === 1 ) { fragment = first; }

    // Require either new content or an interest in ignored elements to invoke the callback if ( first || ignored ) { scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); hasScripts = scripts.length;

    // Use the original fragment for the last item // instead of the first because it can end up // being emptied incorrectly in certain situations (#8070). for ( ; i < l; i++ ) { node = fragment;

    if ( i !== iNoClone ) { node = jQuery.clone( node, true, true );

    // Keep references to cloned scripts for later restoration if ( hasScripts ) {

    // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( scripts, getAll( node, "script" ) ); } }

    callback.call( collection[ i ], node, i ); }

    if ( hasScripts ) { doc = scripts[ scripts.length - 1 ].ownerDocument;

    // Reenable scripts jQuery.map( scripts, restoreScript );

    // Evaluate executable scripts on first document insertion for ( i = 0; i < hasScripts; i++ ) { node = scripts[ i ]; if ( rscriptType.test( node.type || "" ) && !dataPriv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) {

    if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {

    // Optional AJAX dependency, but won't run scripts if not present if ( jQuery._evalUrl ) { jQuery._evalUrl( node.src ); } } else { DOMEval( node.textContent.replace( rcleanScript, "" ), doc, node ); } } } } } }

    return collection; }

    function remove( elem, selector, keepData ) { var node, nodes = selector ? jQuery.filter( selector, elem ) : elem, i = 0;

    for ( ; ( node = nodes[ i ] ) != null; i++ ) { if ( !keepData && node.nodeType === 1 ) { jQuery.cleanData( getAll( node ) ); }

    if ( node.parentNode ) { if ( keepData && jQuery.contains( node.ownerDocument, node ) ) { setGlobalEval( getAll( node, "script" ) ); } node.parentNode.removeChild( node ); } }

    return elem; }

    jQuery.extend( { htmlPrefilter: function( html ) { return html.replace( rxhtmlTag, "<$1></$2>" ); },

    clone: function( elem, dataAndEvents, deepDataAndEvents ) { var i, l, srcElements, destElements, clone = elem.cloneNode( true ), inPage = jQuery.contains( elem.ownerDocument, elem );

    // Fix IE cloning issues if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) {

    // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 destElements = getAll( clone ); srcElements = getAll( elem );

    for ( i = 0, l = srcElements.length; i < l; i++ ) { fixInput( srcElements[ i ], destElements[ i ] ); } }

    // Copy the events from the original to the clone if ( dataAndEvents ) { if ( deepDataAndEvents ) { srcElements = srcElements || getAll( elem ); destElements = destElements || getAll( clone );

    for ( i = 0, l = srcElements.length; i < l; i++ ) { cloneCopyEvent( srcElements[ i ], destElements[ i ] ); } } else { cloneCopyEvent( elem, clone ); } }

    // Preserve script evaluation history destElements = getAll( clone, "script" ); if ( destElements.length > 0 ) { setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); }

    // Return the cloned set return clone; },

    cleanData: function( elems ) { var data, elem, type, special = jQuery.event.special, i = 0;

    for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { if ( acceptData( elem ) ) { if ( ( data = elem[ dataPriv.expando ] ) ) { if ( data.events ) { for ( type in data.events ) { if ( special[ type ] ) { jQuery.event.remove( elem, type );

    // This is a shortcut to avoid jQuery.event.remove's overhead } else { jQuery.removeEvent( elem, type, data.handle ); } } }

    // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataPriv.expando ] = undefined; } if ( elem[ dataUser.expando ] ) {

    // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataUser.expando ] = undefined; } } } } } );

    jQuery.fn.extend( { detach: function( selector ) { return remove( this, selector, true ); },

    remove: function( selector ) { return remove( this, selector ); },

    text: function( value ) { return access( this, function( value ) { return value === undefined ? jQuery.text( this ) : this.empty().each( function() { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { this.textContent = value; } } ); }, null, value, arguments.length ); },

    append: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.appendChild( elem ); } } ); },

    prepend: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.insertBefore( elem, target.firstChild ); } } ); },

    before: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this ); } } ); },

    after: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this.nextSibling ); } } ); },

    empty: function() { var elem, i = 0;

    for ( ; ( elem = this[ i ] ) != null; i++ ) { if ( elem.nodeType === 1 ) {

    // Prevent memory leaks jQuery.cleanData( getAll( elem, false ) );

    // Remove any remaining nodes elem.textContent = ""; } }

    return this; },

    clone: function( dataAndEvents, deepDataAndEvents ) { dataAndEvents = dataAndEvents == null ? false : dataAndEvents; deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

    return this.map( function() { return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); } ); },

    html: function( value ) { return access( this, function( value ) { var elem = this[ 0 ] || {}, i = 0, l = this.length;

    if ( value === undefined && elem.nodeType === 1 ) { return elem.innerHTML; }

    // See if we can take a shortcut and just use innerHTML if ( typeof value === "string" && !rnoInnerhtml.test( value ) && !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {

    value = jQuery.htmlPrefilter( value );

    try { for ( ; i < l; i++ ) { elem = this[ i ] || {};

    // Remove element nodes and prevent memory leaks if ( elem.nodeType === 1 ) { jQuery.cleanData( getAll( elem, false ) ); elem.innerHTML = value; } }

    elem = 0;

    // If using innerHTML throws an exception, use the fallback method } catch ( e ) {} }

    if ( elem ) { this.empty().append( value ); } }, null, value, arguments.length ); },

    replaceWith: function() { var ignored = [];

    // Make the changes, replacing each non-ignored context element with the new content return domManip( this, arguments, function( elem ) { var parent = this.parentNode;

    if ( jQuery.inArray( this, ignored ) < 0 ) { jQuery.cleanData( getAll( this ) ); if ( parent ) { parent.replaceChild( elem, this ); } }

    // Force callback invocation }, ignored ); } } );

    jQuery.each( { appendTo: "append", prependTo: "prepend", insertBefore: "before", insertAfter: "after", replaceAll: "replaceWith" }, function( name, original ) { jQuery.fn[ name ] = function( selector ) { var elems, ret = [], insert = jQuery( selector ), last = insert.length - 1, i = 0;

    for ( ; i <= last; i++ ) { elems = i === last ? this : this.clone( true ); jQuery( insert[ i ] )[ original ]( elems );

    // Support: Android <=4.0 only, PhantomJS 1 only // .get() because push.apply(_, arraylike) throws on ancient WebKit push.apply( ret, elems.get() ); }

    return this.pushStack( ret ); }; } ); var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );

    var getStyles = function( elem ) {

    // Support: IE <=11 only, Firefox <=30 (#15098, #14150) // IE throws on elements created in popups // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" var view = elem.ownerDocument.defaultView;

    if ( !view || !view.opener ) { view = window; }

    return view.getComputedStyle( elem ); };

    var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );


    ( function() {

    // Executing both pixelPosition & boxSizingReliable tests require only one layout // so they're executed at the same time to save the second computation. function computeStyleTests() {

    // This is a singleton, we need to execute it only once if ( !div ) { return; }

    container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0"; div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%"; documentElement.appendChild( container ).appendChild( div );

    var divStyle = window.getComputedStyle( div ); pixelPositionVal = divStyle.top !== "1%";

    // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;

    // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 // Some styles come back with percentage values, even though they shouldn't div.style.right = "60%"; pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;

    // Support: IE 9 - 11 only // Detect misreporting of content dimensions for box-sizing:border-box elements boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;

    // Support: IE 9 only // Detect overflow:scroll screwiness (gh-3699) div.style.position = "absolute"; scrollboxSizeVal = div.offsetWidth === 36 || "absolute";

    documentElement.removeChild( container );

    // Nullify the div so it wouldn't be stored in the memory and // it will also be a sign that checks already performed div = null; }

    function roundPixelMeasures( measure ) { return Math.round( parseFloat( measure ) ); }

    var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, reliableMarginLeftVal, container = document.createElement( "div" ), div = document.createElement( "div" );

    // Finish early in limited (non-browser) environments if ( !div.style ) { return; }

    // Support: IE <=9 - 11 only // Style of cloned element affects source element cloned (#8908) div.style.backgroundClip = "content-box"; div.cloneNode( true ).style.backgroundClip = ""; support.clearCloneStyle = div.style.backgroundClip === "content-box";

    jQuery.extend( support, { boxSizingReliable: function() { computeStyleTests(); return boxSizingReliableVal; }, pixelBoxStyles: function() { computeStyleTests(); return pixelBoxStylesVal; }, pixelPosition: function() { computeStyleTests(); return pixelPositionVal; }, reliableMarginLeft: function() { computeStyleTests(); return reliableMarginLeftVal; }, scrollboxSize: function() { computeStyleTests(); return scrollboxSizeVal; } } ); } )();


    function curCSS( elem, name, computed ) { var width, minWidth, maxWidth, ret,

    // Support: Firefox 51+ // Retrieving style before computed somehow // fixes an issue with getting wrong values // on detached elements style = elem.style;

    computed = computed || getStyles( elem );

    // getPropertyValue is needed for: // .css('filter') (IE 9 only, #12537) // .css('--customProperty) (#3144) if ( computed ) { ret = computed.getPropertyValue( name ) || computed[ name ];

    if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { ret = jQuery.style( elem, name ); }

    // A tribute to the "awesome hack by Dean Edwards" // Android Browser returns percentage for some values, // but width seems to be reliably pixels. // This is against the CSSOM draft spec: // https://drafts.csswg.org/cssom/#resolved-values if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {

    // Remember the original values width = style.width; minWidth = style.minWidth; maxWidth = style.maxWidth;

    // Put in the new values to get a computed value out style.minWidth = style.maxWidth = style.width = ret; ret = computed.width;

    // Revert the changed values style.width = width; style.minWidth = minWidth; style.maxWidth = maxWidth; } }

    return ret !== undefined ?

    // Support: IE <=9 - 11 only // IE returns zIndex value as an integer. ret + "" : ret; }


    function addGetHookIf( conditionFn, hookFn ) {

    // Define the hook, we'll check on the first run if it's really needed. return { get: function() { if ( conditionFn() ) {

    // Hook not needed (or it's not possible to use it due // to missing dependency), remove it. delete this.get; return; }

    // Hook needed; redefine it so that the support test is not executed again. return ( this.get = hookFn ).apply( this, arguments ); } }; }


    var

    // Swappable if display is none or starts with table // except "table", "table-cell", or "table-caption" // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display rdisplayswap = /^(none|table(?!-c[ea]).+)/, rcustomProp = /^--/, cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = { letterSpacing: "0", fontWeight: "400" },

    cssPrefixes = [ "Webkit", "Moz", "ms" ], emptyStyle = document.createElement( "div" ).style;

    // Return a css property mapped to a potentially vendor prefixed property function vendorPropName( name ) {

    // Shortcut for names that are not vendor prefixed if ( name in emptyStyle ) { return name; }

    // Check for vendor prefixed names var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), i = cssPrefixes.length;

    while ( i-- ) { name = cssPrefixes[ i ] + capName; if ( name in emptyStyle ) { return name; } } }

    // Return a property mapped along what jQuery.cssProps suggests or to // a vendor prefixed property. function finalPropName( name ) { var ret = jQuery.cssProps[ name ]; if ( !ret ) { ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name; } return ret; }

    function setPositiveNumber( elem, value, subtract ) {

    // Any relative (+/-) values have already been // normalized at this point var matches = rcssNum.exec( value ); return matches ?

    // Guard against undefined "subtract", e.g., when used as in cssHooks Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : value; }

    function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { var i = dimension === "width" ? 1 : 0, extra = 0, delta = 0;

    // Adjustment may not be necessary if ( box === ( isBorderBox ? "border" : "content" ) ) { return 0; }

    for ( ; i < 4; i += 2 ) {

    // Both box models exclude margin if ( box === "margin" ) { delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); }

    // If we get here with a content-box, we're seeking "padding" or "border" or "margin" if ( !isBorderBox ) {

    // Add padding delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

    // For "border" or "margin", add border if ( box !== "padding" ) { delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );

    // But still keep track of it otherwise } else { extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); }

    // If we get here with a border-box (content + padding + border), we're seeking "content" or // "padding" or "margin" } else {

    // For "content", subtract padding if ( box === "content" ) { delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); }

    // For "content" or "padding", subtract border if ( box !== "margin" ) { delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } } }

    // Account for positive content-box scroll gutter when requested by providing computedVal if ( !isBorderBox && computedVal >= 0 ) {

    // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border // Assuming integer scroll gutter, subtract the rest and round down delta += Math.max( 0, Math.ceil( elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - computedVal - delta - extra - 0.5 ) ); }

    return delta; }

    function getWidthOrHeight( elem, dimension, extra ) {

    // Start with computed style var styles = getStyles( elem ), val = curCSS( elem, dimension, styles ), isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box", valueIsBorderBox = isBorderBox;

    // Support: Firefox <=54 // Return a confounding non-pixel value or feign ignorance, as appropriate. if ( rnumnonpx.test( val ) ) { if ( !extra ) { return val; } val = "auto"; }

    // Check for style in case a browser which returns unreliable values // for getComputedStyle silently falls back to the reliable elem.style valueIsBorderBox = valueIsBorderBox && ( support.boxSizingReliable() || val === elem.style[ dimension ] );

    // Fall back to offsetWidth/offsetHeight when value is "auto" // This happens for inline elements with no explicit setting (gh-3571) // Support: Android <=4.1 - 4.3 only // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) if ( val === "auto" || !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) {

    val = elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ];

    // offsetWidth/offsetHeight provide border-box values valueIsBorderBox = true; }

    // Normalize "" and auto val = parseFloat( val ) || 0;

    // Adjust for the element's box model return ( val + boxModelAdjustment( elem, dimension, extra || ( isBorderBox ? "border" : "content" ), valueIsBorderBox, styles,

    // Provide the current computed size to request scroll gutter calculation (gh-3589) val ) ) + "px"; }

    jQuery.extend( {

    // Add in style property hooks for overriding the default // behavior of getting and setting a style property cssHooks: { opacity: { get: function( elem, computed ) { if ( computed ) {

    // We should always get a number back from opacity var ret = curCSS( elem, "opacity" ); return ret === "" ? "1" : ret; } } } },

    // Don't automatically add "px" to these possibly-unitless properties cssNumber: { "animationIterationCount": true, "columnCount": true, "fillOpacity": true, "flexGrow": true, "flexShrink": true, "fontWeight": true, "lineHeight": true, "opacity": true, "order": true, "orphans": true, "widows": true, "zIndex": true, "zoom": true },

    // Add in properties whose names you wish to fix before // setting or getting the value cssProps: {},

    // Get and set the style property on a DOM Node style: function( elem, name, value, extra ) {

    // Don't set styles on text and comment nodes if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { return; }

    // Make sure that we're working with the right name var ret, type, hooks, origName = camelCase( name ), isCustomProp = rcustomProp.test( name ), style = elem.style;

    // Make sure that we're working with the right name. We don't // want to query the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); }

    // Gets hook for the prefixed version, then unprefixed version hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

    // Check if we're setting a value if ( value !== undefined ) { type = typeof value;

    // Convert "+=" or "-=" to relative numbers (#7345) if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { value = adjustCSS( elem, name, ret );

    // Fixes bug #9237 type = "number"; }

    // Make sure that null and NaN values aren't set (#7116) if ( value == null || value !== value ) { return; }

    // If a number was passed in, add the unit (except for certain CSS properties) if ( type === "number" ) { value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); }

    // background-* props affect original clone's values if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { style[ name ] = "inherit"; }

    // If a hook was provided, use that value, otherwise just set the specified value if ( !hooks || !( "set" in hooks ) || ( value = hooks.set( elem, value, extra ) ) !== undefined ) {

    if ( isCustomProp ) { style.setProperty( name, value ); } else { style[ name ] = value; } }

    } else {

    // If a hook was provided get the non-computed value from there if ( hooks && "get" in hooks && ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {

    return ret; }

    // Otherwise just get the value from the style object return style[ name ]; } },

    css: function( elem, name, extra, styles ) { var val, num, hooks, origName = camelCase( name ), isCustomProp = rcustomProp.test( name );

    // Make sure that we're working with the right name. We don't // want to modify the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); }

    // Try prefixed name followed by the unprefixed name hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

    // If a hook was provided get the computed value from there if ( hooks && "get" in hooks ) { val = hooks.get( elem, true, extra ); }

    // Otherwise, if a way to get the computed value exists, use that if ( val === undefined ) { val = curCSS( elem, name, styles ); }

    // Convert "normal" to computed value if ( val === "normal" && name in cssNormalTransform ) { val = cssNormalTransform[ name ]; }

    // Make numeric if forced or a qualifier was provided and val looks numeric if ( extra === "" || extra ) { num = parseFloat( val ); return extra === true || isFinite( num ) ? num || 0 : val; }

    return val; } } );

    jQuery.each( [ "height", "width" ], function( i, dimension ) { jQuery.cssHooks[ dimension ] = { get: function( elem, computed, extra ) { if ( computed ) {

    // Certain elements can have dimension info if we invisibly show them // but it must have a current display style that would benefit return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&

    // Support: Safari 8+ // Table columns in Safari have non-zero offsetWidth & zero // getBoundingClientRect().width unless display is changed. // Support: IE <=11 only // Running getBoundingClientRect on a disconnected node // in IE throws an error. ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? swap( elem, cssShow, function() { return getWidthOrHeight( elem, dimension, extra ); } ) : getWidthOrHeight( elem, dimension, extra ); } },

    set: function( elem, value, extra ) { var matches, styles = getStyles( elem ), isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box", subtract = extra && boxModelAdjustment( elem, dimension, extra, isBorderBox, styles );

    // Account for unreliable border-box dimensions by comparing offset* to computed and // faking a content-box to get border and padding (gh-3699) if ( isBorderBox && support.scrollboxSize() === styles.position ) { subtract -= Math.ceil( elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - parseFloat( styles[ dimension ] ) - boxModelAdjustment( elem, dimension, "border", false, styles ) - 0.5 ); }

    // Convert to pixels if value adjustment is needed if ( subtract && ( matches = rcssNum.exec( value ) ) && ( matches[ 3 ] || "px" ) !== "px" ) {

    elem.style[ dimension ] = value; value = jQuery.css( elem, dimension ); }

    return setPositiveNumber( elem, value, subtract ); } }; } );

    jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, function( elem, computed ) { if ( computed ) { return ( parseFloat( curCSS( elem, "marginLeft" ) ) || elem.getBoundingClientRect().left - swap( elem, { marginLeft: 0 }, function() { return elem.getBoundingClientRect().left; } ) ) + "px"; } } );

    // These hooks are used by animate to expand properties jQuery.each( { margin: "", padding: "", border: "Width" }, function( prefix, suffix ) { jQuery.cssHooks[ prefix + suffix ] = { expand: function( value ) { var i = 0, expanded = {},

    // Assumes a single number if not a string parts = typeof value === "string" ? value.split( " " ) : [ value ];

    for ( ; i < 4; i++ ) { expanded[ prefix + cssExpand[ i ] + suffix ] = parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; }

    return expanded; } };

    if ( prefix !== "margin" ) { jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; } } );

    jQuery.fn.extend( { css: function( name, value ) { return access( this, function( elem, name, value ) { var styles, len, map = {}, i = 0;

    if ( Array.isArray( name ) ) { styles = getStyles( elem ); len = name.length;

    for ( ; i < len; i++ ) { map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); }

    return map; }

    return value !== undefined ? jQuery.style( elem, name, value ) : jQuery.css( elem, name ); }, name, value, arguments.length > 1 ); } } );


    function Tween( elem, options, prop, end, easing ) { return new Tween.prototype.init( elem, options, prop, end, easing ); } jQuery.Tween = Tween;

    Tween.prototype = { constructor: Tween, init: function( elem, options, prop, end, easing, unit ) { this.elem = elem; this.prop = prop; this.easing = easing || jQuery.easing._default; this.options = options; this.start = this.now = this.cur(); this.end = end; this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); }, cur: function() { var hooks = Tween.propHooks[ this.prop ];

    return hooks && hooks.get ? hooks.get( this ) : Tween.propHooks._default.get( this ); }, run: function( percent ) { var eased, hooks = Tween.propHooks[ this.prop ];

    if ( this.options.duration ) { this.pos = eased = jQuery.easing[ this.easing ]( percent, this.options.duration * percent, 0, 1, this.options.duration ); } else { this.pos = eased = percent; } this.now = ( this.end - this.start ) * eased + this.start;

    if ( this.options.step ) { this.options.step.call( this.elem, this.now, this ); }

    if ( hooks && hooks.set ) { hooks.set( this ); } else { Tween.propHooks._default.set( this ); } return this; } };

    Tween.prototype.init.prototype = Tween.prototype;

    Tween.propHooks = { _default: { get: function( tween ) { var result;

    // Use a property on the element directly when it is not a DOM element, // or when there is no matching style property that exists. if ( tween.elem.nodeType !== 1 || tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { return tween.elem[ tween.prop ]; }

    // Passing an empty string as a 3rd parameter to .css will automatically // attempt a parseFloat and fallback to a string if the parse fails. // Simple values such as "10px" are parsed to Float; // complex values such as "rotate(1rad)" are returned as-is. result = jQuery.css( tween.elem, tween.prop, "" );

    // Empty strings, null, undefined and "auto" are converted to 0. return !result || result === "auto" ? 0 : result; }, set: function( tween ) {

    // Use step hook for back compat. // Use cssHook if its there. // Use .style if available and use plain properties where available. if ( jQuery.fx.step[ tween.prop ] ) { jQuery.fx.step[ tween.prop ]( tween ); } else if ( tween.elem.nodeType === 1 && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); } else { tween.elem[ tween.prop ] = tween.now; } } } };

    // Support: IE <=9 only // Panic based approach to setting things on disconnected nodes Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { set: function( tween ) { if ( tween.elem.nodeType && tween.elem.parentNode ) { tween.elem[ tween.prop ] = tween.now; } } };

    jQuery.easing = { linear: function( p ) { return p; }, swing: function( p ) { return 0.5 - Math.cos( p * Math.PI ) / 2; }, _default: "swing" };

    jQuery.fx = Tween.prototype.init;

    // Back compat <1.8 extension point jQuery.fx.step = {};



    var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/;

    function schedule() { if ( inProgress ) { if ( document.hidden === false && window.requestAnimationFrame ) { window.requestAnimationFrame( schedule ); } else { window.setTimeout( schedule, jQuery.fx.interval ); }

    jQuery.fx.tick(); } }

    // Animations created synchronously will run synchronously function createFxNow() { window.setTimeout( function() { fxNow = undefined; } ); return ( fxNow = Date.now() ); }

    // Generate parameters to create a standard animation function genFx( type, includeWidth ) { var which, i = 0, attrs = { height: type };

    // If we include width, step value is 1 to do all cssExpand values, // otherwise step value is 2 to skip over Left and Right includeWidth = includeWidth ? 1 : 0; for ( ; i < 4; i += 2 - includeWidth ) { which = cssExpand[ i ]; attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; }

    if ( includeWidth ) { attrs.opacity = attrs.width = type; }

    return attrs; }

    function createTween( value, prop, animation ) { var tween, collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), index = 0, length = collection.length; for ( ; index < length; index++ ) { if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {

    // We're done with this property return tween; } } }

    function defaultPrefilter( elem, props, opts ) { var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width" in props || "height" in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree( elem ), dataShow = dataPriv.get( elem, "fxshow" );

    // Queue-skipping animations hijack the fx hooks if ( !opts.queue ) { hooks = jQuery._queueHooks( elem, "fx" ); if ( hooks.unqueued == null ) { hooks.unqueued = 0; oldfire = hooks.empty.fire; hooks.empty.fire = function() { if ( !hooks.unqueued ) { oldfire(); } }; } hooks.unqueued++;

    anim.always( function() {

    // Ensure the complete handler is called before this completes anim.always( function() { hooks.unqueued--; if ( !jQuery.queue( elem, "fx" ).length ) { hooks.empty.fire(); } } ); } ); }

    // Detect show/hide animations for ( prop in props ) { value = props[ prop ]; if ( rfxtypes.test( value ) ) { delete props[ prop ]; toggle = toggle || value === "toggle"; if ( value === ( hidden ? "hide" : "show" ) ) {

    // Pretend to be hidden if this is a "show" and // there is still data from a stopped show/hide if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { hidden = true;

    // Ignore all other no-op show/hide data } else { continue; } } orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); } }

    // Bail out if this is a no-op like .hide().hide() propTween = !jQuery.isEmptyObject( props ); if ( !propTween && jQuery.isEmptyObject( orig ) ) { return; }

    // Restrict "overflow" and "display" styles during box animations if ( isBox && elem.nodeType === 1 ) {

    // Support: IE <=9 - 11, Edge 12 - 15 // Record all 3 overflow attributes because IE does not infer the shorthand // from identically-valued overflowX and overflowY and Edge just mirrors // the overflowX value there. opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];

    // Identify a display type, preferring old show/hide data over the CSS cascade restoreDisplay = dataShow && dataShow.display; if ( restoreDisplay == null ) { restoreDisplay = dataPriv.get( elem, "display" ); } display = jQuery.css( elem, "display" ); if ( display === "none" ) { if ( restoreDisplay ) { display = restoreDisplay; } else {

    // Get nonempty value(s) by temporarily forcing visibility showHide( [ elem ], true ); restoreDisplay = elem.style.display || restoreDisplay; display = jQuery.css( elem, "display" ); showHide( [ elem ] ); } }

    // Animate inline elements as inline-block if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { if ( jQuery.css( elem, "float" ) === "none" ) {

    // Restore the original display value at the end of pure show/hide animations if ( !propTween ) { anim.done( function() { style.display = restoreDisplay; } ); if ( restoreDisplay == null ) { display = style.display; restoreDisplay = display === "none" ? "" : display; } } style.display = "inline-block"; } } }

    if ( opts.overflow ) { style.overflow = "hidden"; anim.always( function() { style.overflow = opts.overflow[ 0 ]; style.overflowX = opts.overflow[ 1 ]; style.overflowY = opts.overflow[ 2 ]; } ); }

    // Implement show/hide animations propTween = false; for ( prop in orig ) {

    // General show/hide setup for this element animation if ( !propTween ) { if ( dataShow ) { if ( "hidden" in dataShow ) { hidden = dataShow.hidden; } } else { dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); }

    // Store hidden/visible for toggle so `.stop().toggle()` "reverses" if ( toggle ) { dataShow.hidden = !hidden; }

    // Show elements before animating them if ( hidden ) { showHide( [ elem ], true ); }

    /* eslint-disable no-loop-func */

    anim.done( function() {

    /* eslint-enable no-loop-func */

    // The final step of a "hide" animation is actually hiding the element if ( !hidden ) { showHide( [ elem ] ); } dataPriv.remove( elem, "fxshow" ); for ( prop in orig ) { jQuery.style( elem, prop, orig[ prop ] ); } } ); }

    // Per-property setup propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); if ( !( prop in dataShow ) ) { dataShow[ prop ] = propTween.start; if ( hidden ) { propTween.end = propTween.start; propTween.start = 0; } } } }

    function propFilter( props, specialEasing ) { var index, name, easing, value, hooks;

    // camelCase, specialEasing and expand cssHook pass for ( index in props ) { name = camelCase( index ); easing = specialEasing[ name ]; value = props[ index ]; if ( Array.isArray( value ) ) { easing = value[ 1 ]; value = props[ index ] = value[ 0 ]; }

    if ( index !== name ) { props[ name ] = value; delete props[ index ]; }

    hooks = jQuery.cssHooks[ name ]; if ( hooks && "expand" in hooks ) { value = hooks.expand( value ); delete props[ name ];

    // Not quite $.extend, this won't overwrite existing keys. // Reusing 'index' because we have the correct "name" for ( index in value ) { if ( !( index in props ) ) { props[ index ] = value[ index ]; specialEasing[ index ] = easing; } } } else { specialEasing[ name ] = easing; } } }

    function Animation( elem, properties, options ) { var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred().always( function() {

    // Don't match elem in the :animated selector delete tick.elem; } ), tick = function() { if ( stopped ) { return false; } var currentTime = fxNow || createFxNow(), remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),

    // Support: Android 2.3 only // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length;

    for ( ; index < length; index++ ) { animation.tweens[ index ].run( percent ); }

    deferred.notifyWith( elem, [ animation, percent, remaining ] );

    // If there's more to do, yield if ( percent < 1 && length ) { return remaining; }

    // If this was an empty animation, synthesize a final progress notification if ( !length ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); }

    // Resolve the animation and report its conclusion deferred.resolveWith( elem, [ animation ] ); return false; }, animation = deferred.promise( { elem: elem, props: jQuery.extend( {}, properties ), opts: jQuery.extend( true, { specialEasing: {}, easing: jQuery.easing._default }, options ), originalProperties: properties, originalOptions: options, startTime: fxNow || createFxNow(), duration: options.duration, tweens: [], createTween: function( prop, end ) { var tween = jQuery.Tween( elem, animation.opts, prop, end, animation.opts.specialEasing[ prop ] || animation.opts.easing ); animation.tweens.push( tween ); return tween; }, stop: function( gotoEnd ) { var index = 0,

    // If we are going to the end, we want to run all the tweens // otherwise we skip this part length = gotoEnd ? animation.tweens.length : 0; if ( stopped ) { return this; } stopped = true; for ( ; index < length; index++ ) { animation.tweens[ index ].run( 1 ); }

    // Resolve when we played the last frame; otherwise, reject if ( gotoEnd ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); deferred.resolveWith( elem, [ animation, gotoEnd ] ); } else { deferred.rejectWith( elem, [ animation, gotoEnd ] ); } return this; } } ), props = animation.props;

    propFilter( props, animation.opts.specialEasing );

    for ( ; index < length; index++ ) { result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); if ( result ) { if ( isFunction( result.stop ) ) { jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = result.stop.bind( result ); } return result; } }

    jQuery.map( props, createTween, animation );

    if ( isFunction( animation.opts.start ) ) { animation.opts.start.call( elem, animation ); }

    // Attach callbacks from options animation .progress( animation.opts.progress ) .done( animation.opts.done, animation.opts.complete ) .fail( animation.opts.fail ) .always( animation.opts.always );

    jQuery.fx.timer( jQuery.extend( tick, { elem: elem, anim: animation, queue: animation.opts.queue } ) );

    return animation; }

    jQuery.Animation = jQuery.extend( Animation, {

    tweeners: { "*": [ function( prop, value ) { var tween = this.createTween( prop, value ); adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); return tween; } ] },

    tweener: function( props, callback ) { if ( isFunction( props ) ) { callback = props; props = [ "*" ]; } else { props = props.match( rnothtmlwhite ); }

    var prop, index = 0, length = props.length;

    for ( ; index < length; index++ ) { prop = props[ index ]; Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; Animation.tweeners[ prop ].unshift( callback ); } },

    prefilters: [ defaultPrefilter ],

    prefilter: function( callback, prepend ) { if ( prepend ) { Animation.prefilters.unshift( callback ); } else { Animation.prefilters.push( callback ); } } } );

    jQuery.speed = function( speed, easing, fn ) { var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { complete: fn || !fn && easing || isFunction( speed ) && speed, duration: speed, easing: fn && easing || easing && !isFunction( easing ) && easing };

    // Go to the end state if fx are off if ( jQuery.fx.off ) { opt.duration = 0;

    } else { if ( typeof opt.duration !== "number" ) { if ( opt.duration in jQuery.fx.speeds ) { opt.duration = jQuery.fx.speeds[ opt.duration ];

    } else { opt.duration = jQuery.fx.speeds._default; } } }

    // Normalize opt.queue - true/undefined/null -> "fx" if ( opt.queue == null || opt.queue === true ) { opt.queue = "fx"; }

    // Queueing opt.old = opt.complete;

    opt.complete = function() { if ( isFunction( opt.old ) ) { opt.old.call( this ); }

    if ( opt.queue ) { jQuery.dequeue( this, opt.queue ); } };

    return opt; };

    jQuery.fn.extend( { fadeTo: function( speed, to, easing, callback ) {

    // Show any hidden elements after setting opacity to 0 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()

    // Animate to the value specified .end().animate( { opacity: to }, speed, easing, callback ); }, animate: function( prop, speed, easing, callback ) { var empty = jQuery.isEmptyObject( prop ), optall = jQuery.speed( speed, easing, callback ), doAnimation = function() {

    // Operate on a copy of prop so per-property easing won't be lost var anim = Animation( this, jQuery.extend( {}, prop ), optall );

    // Empty animations, or finishing resolves immediately if ( empty || dataPriv.get( this, "finish" ) ) { anim.stop( true ); } }; doAnimation.finish = doAnimation;

    return empty || optall.queue === false ? this.each( doAnimation ) : this.queue( optall.queue, doAnimation ); }, stop: function( type, clearQueue, gotoEnd ) { var stopQueue = function( hooks ) { var stop = hooks.stop; delete hooks.stop; stop( gotoEnd ); };

    if ( typeof type !== "string" ) { gotoEnd = clearQueue; clearQueue = type; type = undefined; } if ( clearQueue && type !== false ) { this.queue( type || "fx", [] ); }

    return this.each( function() { var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery.timers, data = dataPriv.get( this );

    if ( index ) { if ( data[ index ] && data[ index ].stop ) { stopQueue( data[ index ] ); } } else { for ( index in data ) { if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { stopQueue( data[ index ] ); } } }

    for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && ( type == null || timers[ index ].queue === type ) ) {

    timers[ index ].anim.stop( gotoEnd ); dequeue = false; timers.splice( index, 1 ); } }

    // Start the next in the queue if the last step wasn't forced. // Timers currently will call their complete callbacks, which // will dequeue but only if they were gotoEnd. if ( dequeue || !gotoEnd ) { jQuery.dequeue( this, type ); } } ); }, finish: function( type ) { if ( type !== false ) { type = type || "fx"; } return this.each( function() { var index, data = dataPriv.get( this ), queue = data[ type + "queue" ], hooks = data[ type + "queueHooks" ], timers = jQuery.timers, length = queue ? queue.length : 0;

    // Enable finishing flag on private data data.finish = true;

    // Empty the queue first jQuery.queue( this, type, [] );

    if ( hooks && hooks.stop ) { hooks.stop.call( this, true ); }

    // Look for any active animations, and finish them for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && timers[ index ].queue === type ) { timers[ index ].anim.stop( true ); timers.splice( index, 1 ); } }

    // Look for any animations in the old queue and finish them for ( index = 0; index < length; index++ ) { if ( queue[ index ] && queue[ index ].finish ) { queue[ index ].finish.call( this ); } }

    // Turn off finishing flag delete data.finish; } ); } } );

    jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { var cssFn = jQuery.fn[ name ]; jQuery.fn[ name ] = function( speed, easing, callback ) { return speed == null || typeof speed === "boolean" ? cssFn.apply( this, arguments ) : this.animate( genFx( name, true ), speed, easing, callback ); }; } );

    // Generate shortcuts for custom animations jQuery.each( { slideDown: genFx( "show" ), slideUp: genFx( "hide" ), slideToggle: genFx( "toggle" ), fadeIn: { opacity: "show" }, fadeOut: { opacity: "hide" }, fadeToggle: { opacity: "toggle" } }, function( name, props ) { jQuery.fn[ name ] = function( speed, easing, callback ) { return this.animate( props, speed, easing, callback ); }; } );

    jQuery.timers = []; jQuery.fx.tick = function() { var timer, i = 0, timers = jQuery.timers;

    fxNow = Date.now();

    for ( ; i < timers.length; i++ ) { timer = timers[ i ];

    // Run the timer and safely remove it when done (allowing for external removal) if ( !timer() && timers[ i ] === timer ) { timers.splice( i--, 1 ); } }

    if ( !timers.length ) { jQuery.fx.stop(); } fxNow = undefined; };

    jQuery.fx.timer = function( timer ) { jQuery.timers.push( timer ); jQuery.fx.start(); };

    jQuery.fx.interval = 13; jQuery.fx.start = function() { if ( inProgress ) { return; }

    inProgress = true; schedule(); };

    jQuery.fx.stop = function() { inProgress = null; };

    jQuery.fx.speeds = { slow: 600, fast: 200,

    // Default speed _default: 400 };


    // Based off of the plugin by Clint Helfers, with permission. // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ jQuery.fn.delay = function( time, type ) { time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; type = type || "fx";

    return this.queue( type, function( next, hooks ) { var timeout = window.setTimeout( next, time ); hooks.stop = function() { window.clearTimeout( timeout ); }; } ); };


    ( function() { var input = document.createElement( "input" ), select = document.createElement( "select" ), opt = select.appendChild( document.createElement( "option" ) );

    input.type = "checkbox";

    // Support: Android <=4.3 only // Default value for a checkbox should be "on" support.checkOn = input.value !== "";

    // Support: IE <=11 only // Must access selectedIndex to make default options select support.optSelected = opt.selected;

    // Support: IE <=11 only // An input loses its value after becoming a radio input = document.createElement( "input" ); input.value = "t"; input.type = "radio"; support.radioValue = input.value === "t"; } )();


    var boolHook, attrHandle = jQuery.expr.attrHandle;

    jQuery.fn.extend( { attr: function( name, value ) { return access( this, jQuery.attr, name, value, arguments.length > 1 ); },

    removeAttr: function( name ) { return this.each( function() { jQuery.removeAttr( this, name ); } ); } } );

    jQuery.extend( { attr: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType;

    // Don't get/set attributes on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; }

    // Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return jQuery.prop( elem, name, value ); }

    // Attribute hooks are determined by the lowercase version // Grab necessary hook if one is defined if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { hooks = jQuery.attrHooks[ name.toLowerCase() ] || ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); }

    if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return; }

    if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; }

    elem.setAttribute( name, value + "" ); return value; }

    if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; }

    ret = jQuery.find.attr( elem, name );

    // Non-existent attributes return null, we normalize to undefined return ret == null ? undefined : ret; },

    attrHooks: { type: { set: function( elem, value ) { if ( !support.radioValue && value === "radio" && nodeName( elem, "input" ) ) { var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; } return value; } } } },

    removeAttr: function( elem, value ) { var name, i = 0,

    // Attribute names can contain non-HTML whitespace characters // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 attrNames = value && value.match( rnothtmlwhite );

    if ( attrNames && elem.nodeType === 1 ) { while ( ( name = attrNames[ i++ ] ) ) { elem.removeAttribute( name ); } } } } );

    // Hooks for boolean attributes boolHook = { set: function( elem, value, name ) { if ( value === false ) {

    // Remove boolean attributes when set to false jQuery.removeAttr( elem, name ); } else { elem.setAttribute( name, name ); } return name; } };

    jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { var getter = attrHandle[ name ] || jQuery.find.attr;

    attrHandle[ name ] = function( elem, name, isXML ) { var ret, handle, lowercaseName = name.toLowerCase();

    if ( !isXML ) {

    // Avoid an infinite loop by temporarily removing this function from the getter handle = attrHandle[ lowercaseName ]; attrHandle[ lowercaseName ] = ret; ret = getter( elem, name, isXML ) != null ? lowercaseName : null; attrHandle[ lowercaseName ] = handle; } return ret; }; } );



    var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i;

    jQuery.fn.extend( { prop: function( name, value ) { return access( this, jQuery.prop, name, value, arguments.length > 1 ); },

    removeProp: function( name ) { return this.each( function() { delete this[ jQuery.propFix[ name ] || name ]; } ); } } );

    jQuery.extend( { prop: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType;

    // Don't get/set properties on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; }

    if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {

    // Fix name and attach hooks name = jQuery.propFix[ name ] || name; hooks = jQuery.propHooks[ name ]; }

    if ( value !== undefined ) { if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; }

    return ( elem[ name ] = value ); }

    if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; }

    return elem[ name ]; },

    propHooks: { tabIndex: { get: function( elem ) {

    // Support: IE <=9 - 11 only // elem.tabIndex doesn't always return the // correct value when it hasn't been explicitly set // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ // Use proper attribute retrieval(#12072) var tabindex = jQuery.find.attr( elem, "tabindex" );

    if ( tabindex ) { return parseInt( tabindex, 10 ); }

    if ( rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ) { return 0; }

    return -1; } } },

    propFix: { "for": "htmlFor", "class": "className" } } );

    // Support: IE <=11 only // Accessing the selectedIndex property // forces the browser to respect setting selected // on the option // The getter ensures a default option is selected // when in an optgroup // eslint rule "no-unused-expressions" is disabled for this code // since it considers such accessions noop if ( !support.optSelected ) { jQuery.propHooks.selected = { get: function( elem ) {

    /* eslint no-unused-expressions: "off" */

    var parent = elem.parentNode; if ( parent && parent.parentNode ) { parent.parentNode.selectedIndex; } return null; }, set: function( elem ) {

    /* eslint no-unused-expressions: "off" */

    var parent = elem.parentNode; if ( parent ) { parent.selectedIndex;

    if ( parent.parentNode ) { parent.parentNode.selectedIndex; } } } }; }

    jQuery.each( [ "tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable" ], function() { jQuery.propFix[ this.toLowerCase() ] = this; } );



    // Strip and collapse whitespace according to HTML spec // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace function stripAndCollapse( value ) { var tokens = value.match( rnothtmlwhite ) || []; return tokens.join( " " ); }


    function getClass( elem ) { return elem.getAttribute && elem.getAttribute( "class" ) || ""; }

    function classesToArray( value ) { if ( Array.isArray( value ) ) { return value; } if ( typeof value === "string" ) { return value.match( rnothtmlwhite ) || []; } return []; }

    jQuery.fn.extend( { addClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;

    if ( isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); } ); }

    classes = classesToArray( value );

    if ( classes.length ) { while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );

    if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { if ( cur.indexOf( " " + clazz + " " ) < 0 ) { cur += clazz + " "; } }

    // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } }

    return this; },

    removeClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;

    if ( isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); } ); }

    if ( !arguments.length ) { return this.attr( "class", "" ); }

    classes = classesToArray( value );

    if ( classes.length ) { while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem );

    // This expression is here for better compressibility (see addClass) cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );

    if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) {

    // Remove *all* instances while ( cur.indexOf( " " + clazz + " " ) > -1 ) { cur = cur.replace( " " + clazz + " ", " " ); } }

    // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } }

    return this; },

    toggleClass: function( value, stateVal ) { var type = typeof value, isValidValue = type === "string" || Array.isArray( value );

    if ( typeof stateVal === "boolean" && isValidValue ) { return stateVal ? this.addClass( value ) : this.removeClass( value ); }

    if ( isFunction( value ) ) { return this.each( function( i ) { jQuery( this ).toggleClass( value.call( this, i, getClass( this ), stateVal ), stateVal ); } ); }

    return this.each( function() { var className, i, self, classNames;

    if ( isValidValue ) {

    // Toggle individual class names i = 0; self = jQuery( this ); classNames = classesToArray( value );

    while ( ( className = classNames[ i++ ] ) ) {

    // Check each className given, space separated list if ( self.hasClass( className ) ) { self.removeClass( className ); } else { self.addClass( className ); } }

    // Toggle whole class name } else if ( value === undefined || type === "boolean" ) { className = getClass( this ); if ( className ) {

    // Store className if set dataPriv.set( this, "__className__", className ); }

    // If the element has a class name or if we're passed `false`, // then remove the whole classname (if there was one, the above saved it). // Otherwise bring back whatever was previously saved (if anything), // falling back to the empty string if nothing was stored. if ( this.setAttribute ) { this.setAttribute( "class", className || value === false ? "" : dataPriv.get( this, "__className__" ) || "" ); } } } ); },

    hasClass: function( selector ) { var className, elem, i = 0;

    className = " " + selector + " "; while ( ( elem = this[ i++ ] ) ) { if ( elem.nodeType === 1 && ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { return true; } }

    return false; } } );



    var rreturn = /\r/g;

    jQuery.fn.extend( { val: function( value ) { var hooks, ret, valueIsFunction, elem = this[ 0 ];

    if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];

    if ( hooks && "get" in hooks && ( ret = hooks.get( elem, "value" ) ) !== undefined ) { return ret; }

    ret = elem.value;

    // Handle most common string cases if ( typeof ret === "string" ) { return ret.replace( rreturn, "" ); }

    // Handle cases where value is null/undef or number return ret == null ? "" : ret; }

    return; }

    valueIsFunction = isFunction( value );

    return this.each( function( i ) { var val;

    if ( this.nodeType !== 1 ) { return; }

    if ( valueIsFunction ) { val = value.call( this, i, jQuery( this ).val() ); } else { val = value; }

    // Treat null/undefined as ""; convert numbers to string if ( val == null ) { val = "";

    } else if ( typeof val === "number" ) { val += "";

    } else if ( Array.isArray( val ) ) { val = jQuery.map( val, function( value ) { return value == null ? "" : value + ""; } ); }

    hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];

    // If set returns undefined, fall back to normal setting if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { this.value = val; } } ); } } );

    jQuery.extend( { valHooks: { option: { get: function( elem ) {

    var val = jQuery.find.attr( elem, "value" ); return val != null ? val :

    // Support: IE <=10 - 11 only // option.text throws exceptions (#14686, #14858) // Strip and collapse whitespace // https://html.spec.whatwg.org/#strip-and-collapse-whitespace stripAndCollapse( jQuery.text( elem ) ); } }, select: { get: function( elem ) { var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length;

    if ( index < 0 ) { i = max;

    } else { i = one ? index : 0; }

    // Loop through all the selected options for ( ; i < max; i++ ) { option = options[ i ];

    // Support: IE <=9 only // IE8-9 doesn't update selected after form reset (#2551) if ( ( option.selected || i === index ) &&

    // Don't return options that are disabled or in a disabled optgroup !option.disabled && ( !option.parentNode.disabled || !nodeName( option.parentNode, "optgroup" ) ) ) {

    // Get the specific value for the option value = jQuery( option ).val();

    // We don't need an array for one selects if ( one ) { return value; }

    // Multi-Selects return an array values.push( value ); } }

    return values; },

    set: function( elem, value ) { var optionSet, option, options = elem.options, values = jQuery.makeArray( value ), i = options.length;

    while ( i-- ) { option = options[ i ];

    /* eslint-disable no-cond-assign */

    if ( option.selected = jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) { optionSet = true; }

    /* eslint-enable no-cond-assign */ }

    // Force browsers to behave consistently when non-matching value is set if ( !optionSet ) { elem.selectedIndex = -1; } return values; } } } } );

    // Radios and checkboxes getter/setter jQuery.each( [ "radio", "checkbox" ], function() { jQuery.valHooks[ this ] = { set: function( elem, value ) { if ( Array.isArray( value ) ) { return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); } } }; if ( !support.checkOn ) { jQuery.valHooks[ this ].get = function( elem ) { return elem.getAttribute( "value" ) === null ? "on" : elem.value; }; } } );



    // Return jQuery for attributes-only inclusion


    support.focusin = "onfocusin" in window;


    var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, stopPropagationCallback = function( e ) { e.stopPropagation(); };

    jQuery.extend( jQuery.event, {

    trigger: function( event, data, elem, onlyHandlers ) {

    var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, eventPath = [ elem || document ], type = hasOwn.call( event, "type" ) ? event.type : event, namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];

    cur = lastElement = tmp = elem = elem || document;

    // Don't do events on text and comment nodes if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; }

    // focus/blur morphs to focusin/out; ensure we're not firing them right now if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { return; }

    if ( type.indexOf( "." ) > -1 ) {

    // Namespaced trigger; create a regexp to match event type in handle() namespaces = type.split( "." ); type = namespaces.shift(); namespaces.sort(); } ontype = type.indexOf( ":" ) < 0 && "on" + type;

    // Caller can pass in a jQuery.Event object, Object, or just an event type string event = event[ jQuery.expando ] ? event : new jQuery.Event( type, typeof event === "object" && event );

    // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) event.isTrigger = onlyHandlers ? 2 : 3; event.namespace = namespaces.join( "." ); event.rnamespace = event.namespace ? new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : null;

    // Clean up the event in case it is being reused event.result = undefined; if ( !event.target ) { event.target = elem; }

    // Clone any incoming data and prepend the event, creating the handler arg list data = data == null ? [ event ] : jQuery.makeArray( data, [ event ] );

    // Allow special events to draw outside the lines special = jQuery.event.special[ type ] || {}; if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { return; }

    // Determine event propagation path in advance, per W3C events spec (#9951) // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {

    bubbleType = special.delegateType || type; if ( !rfocusMorph.test( bubbleType + type ) ) { cur = cur.parentNode; } for ( ; cur; cur = cur.parentNode ) { eventPath.push( cur ); tmp = cur; }

    // Only add window if we got to document (e.g., not plain obj or detached DOM) if ( tmp === ( elem.ownerDocument || document ) ) { eventPath.push( tmp.defaultView || tmp.parentWindow || window ); } }

    // Fire handlers on the event path i = 0; while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { lastElement = cur; event.type = i > 1 ? bubbleType : special.bindType || type;

    // jQuery handler handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && dataPriv.get( cur, "handle" ); if ( handle ) { handle.apply( cur, data ); }

    // Native handler handle = ontype && cur[ ontype ]; if ( handle && handle.apply && acceptData( cur ) ) { event.result = handle.apply( cur, data ); if ( event.result === false ) { event.preventDefault(); } } } event.type = type;

    // If nobody prevented the default action, do it now if ( !onlyHandlers && !event.isDefaultPrevented() ) {

    if ( ( !special._default || special._default.apply( eventPath.pop(), data ) === false ) && acceptData( elem ) ) {

    // Call a native DOM method on the target with the same name as the event. // Don't do default actions on window, that's where global variables be (#6170) if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {

    // Don't re-trigger an onFOO event when we call its FOO() method tmp = elem[ ontype ];

    if ( tmp ) { elem[ ontype ] = null; }

    // Prevent re-triggering of the same event, since we already bubbled it above jQuery.event.triggered = type;

    if ( event.isPropagationStopped() ) { lastElement.addEventListener( type, stopPropagationCallback ); }

    elem[ type ]();

    if ( event.isPropagationStopped() ) { lastElement.removeEventListener( type, stopPropagationCallback ); }

    jQuery.event.triggered = undefined;

    if ( tmp ) { elem[ ontype ] = tmp; } } } }

    return event.result; },

    // Piggyback on a donor event to simulate a different one // Used only for `focus(in | out)` events simulate: function( type, elem, event ) { var e = jQuery.extend( new jQuery.Event(), event, { type: type, isSimulated: true } );

    jQuery.event.trigger( e, null, elem ); }

    } );

    jQuery.fn.extend( {

    trigger: function( type, data ) { return this.each( function() { jQuery.event.trigger( type, data, this ); } ); }, triggerHandler: function( type, data ) { var elem = this[ 0 ]; if ( elem ) { return jQuery.event.trigger( type, data, elem, true ); } } } );


    // Support: Firefox <=44 // Firefox doesn't have focus(in | out) events // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 // // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 // focus(in | out) events fire after focus & blur events, // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 if ( !support.focusin ) { jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {

    // Attach a single capturing handler on the document while someone wants focusin/focusout var handler = function( event ) { jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); };

    jQuery.event.special[ fix ] = { setup: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix );

    if ( !attaches ) { doc.addEventListener( orig, handler, true ); } dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); }, teardown: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ) - 1;

    if ( !attaches ) { doc.removeEventListener( orig, handler, true ); dataPriv.remove( doc, fix );

    } else { dataPriv.access( doc, fix, attaches ); } } }; } ); } var location = window.location;

    var nonce = Date.now();

    var rquery = ( /\?/ );


    // Cross-browser xml parsing jQuery.parseXML = function( data ) { var xml; if ( !data || typeof data !== "string" ) { return null; }

    // Support: IE 9 - 11 only // IE throws on parseFromString with invalid input. try { xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); } catch ( e ) { xml = undefined; }

    if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { jQuery.error( "Invalid XML: " + data ); } return xml; };


    var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;

    function buildParams( prefix, obj, traditional, add ) { var name;

    if ( Array.isArray( obj ) ) {

    // Serialize array item. jQuery.each( obj, function( i, v ) { if ( traditional || rbracket.test( prefix ) ) {

    // Treat each array item as a scalar. add( prefix, v );

    } else {

    // Item is non-scalar (array or object), encode its numeric index. buildParams( prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", v, traditional, add ); } } );

    } else if ( !traditional && toType( obj ) === "object" ) {

    // Serialize object item. for ( name in obj ) { buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); }

    } else {

    // Serialize scalar item. add( prefix, obj ); } }

    // Serialize an array of form elements or a set of // key/values into a query string jQuery.param = function( a, traditional ) { var prefix, s = [], add = function( key, valueOrFunction ) {

    // If value is a function, invoke it and use its return value var value = isFunction( valueOrFunction ) ? valueOrFunction() : valueOrFunction;

    s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value == null ? "" : value ); };

    // If an array was passed in, assume that it is an array of form elements. if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {

    // Serialize the form elements jQuery.each( a, function() { add( this.name, this.value ); } );

    } else {

    // If traditional, encode the "old" way (the way 1.3.2 or older // did it), otherwise encode params recursively. for ( prefix in a ) { buildParams( prefix, a[ prefix ], traditional, add ); } }

    // Return the resulting serialization return s.join( "&" ); };

    jQuery.fn.extend( { serialize: function() { return jQuery.param( this.serializeArray() ); }, serializeArray: function() { return this.map( function() {

    // Can add propHook for "elements" to filter or add form elements var elements = jQuery.prop( this, "elements" ); return elements ? jQuery.makeArray( elements ) : this; } ) .filter( function() { var type = this.type;

    // Use .is( ":disabled" ) so that fieldset[disabled] works return this.name && !jQuery( this ).is( ":disabled" ) && rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && ( this.checked || !rcheckableType.test( type ) ); } ) .map( function( i, elem ) { var val = jQuery( this ).val();

    if ( val == null ) { return null; }

    if ( Array.isArray( val ) ) { return jQuery.map( val, function( val ) { return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ); }

    return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ).get(); } } );


    var r20 = /%20/g, rhash = /#.*$/, rantiCache = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,

    // #7653, #8125, #8152: local protocol detection rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//,

    /* Prefilters * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) * 2) These are called: * - BEFORE asking for a transport * - AFTER param serialization (s.data is a string if s.processData is true) * 3) key is the dataType * 4) the catchall symbol "*" can be used * 5) execution will start with transport dataType and THEN continue down to "*" if needed */ prefilters = {},

    /* Transports bindings * 1) key is the dataType * 2) the catchall symbol "*" can be used * 3) selection will start with transport dataType and THEN go to "*" if needed */ transports = {},

    // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression allTypes = "*/".concat( "*" ),

    // Anchor tag for parsing the document origin originAnchor = document.createElement( "a" ); originAnchor.href = location.href;

    // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport function addToPrefiltersOrTransports( structure ) {

    // dataTypeExpression is optional and defaults to "*" return function( dataTypeExpression, func ) {

    if ( typeof dataTypeExpression !== "string" ) { func = dataTypeExpression; dataTypeExpression = "*"; }

    var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];

    if ( isFunction( func ) ) {

    // For each dataType in the dataTypeExpression while ( ( dataType = dataTypes[ i++ ] ) ) {

    // Prepend if requested if ( dataType[ 0 ] === "+" ) { dataType = dataType.slice( 1 ) || "*"; ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );

    // Otherwise append } else { ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); } } } }; }

    // Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

    var inspected = {}, seekingTransport = ( structure === transports );

    function inspect( dataType ) { var selected; inspected[ dataType ] = true; jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {

    options.dataTypes.unshift( dataTypeOrTransport ); inspect( dataTypeOrTransport ); return false; } else if ( seekingTransport ) { return !( selected = dataTypeOrTransport ); } } ); return selected; }

    return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); }

    // A special extend for ajax options // that takes "flat" options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) { var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions || {};

    for ( key in src ) { if ( src[ key ] !== undefined ) { ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; } } if ( deep ) { jQuery.extend( true, target, deep ); }

    return target; }

    /* Handles responses to an ajax request:

    * - finds the right dataType (mediates between content-type and expected dataType)
    * - returns the corresponding response
    */
    

    function ajaxHandleResponses( s, jqXHR, responses ) {

    var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes;

    // Remove auto dataType and get content-type in the process while ( dataTypes[ 0 ] === "*" ) { dataTypes.shift(); if ( ct === undefined ) { ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); } }

    // Check if we're dealing with a known content-type if ( ct ) { for ( type in contents ) { if ( contents[ type ] && contents[ type ].test( ct ) ) { dataTypes.unshift( type ); break; } } }

    // Check to see if we have a response for the expected dataType if ( dataTypes[ 0 ] in responses ) { finalDataType = dataTypes[ 0 ]; } else {

    // Try convertible dataTypes for ( type in responses ) { if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { finalDataType = type; break; } if ( !firstDataType ) { firstDataType = type; } }

    // Or just use first one finalDataType = finalDataType || firstDataType; }

    // If we found a dataType // We add the dataType to the list if needed // and return the corresponding response if ( finalDataType ) { if ( finalDataType !== dataTypes[ 0 ] ) { dataTypes.unshift( finalDataType ); } return responses[ finalDataType ]; } }

    /* Chain conversions given the request and the original response

    * Also sets the responseXXX fields on the jqXHR instance
    */
    

    function ajaxConvert( s, response, jqXHR, isSuccess ) { var conv2, current, conv, tmp, prev, converters = {},

    // Work with a copy of dataTypes in case we need to modify it for conversion dataTypes = s.dataTypes.slice();

    // Create converters map with lowercased keys if ( dataTypes[ 1 ] ) { for ( conv in s.converters ) { converters[ conv.toLowerCase() ] = s.converters[ conv ]; } }

    current = dataTypes.shift();

    // Convert to each sequential dataType while ( current ) {

    if ( s.responseFields[ current ] ) { jqXHR[ s.responseFields[ current ] ] = response; }

    // Apply the dataFilter if provided if ( !prev && isSuccess && s.dataFilter ) { response = s.dataFilter( response, s.dataType ); }

    prev = current; current = dataTypes.shift();

    if ( current ) {

    // There's only work to do if current dataType is non-auto if ( current === "*" ) {

    current = prev;

    // Convert response if prev dataType is non-auto and differs from current } else if ( prev !== "*" && prev !== current ) {

    // Seek a direct converter conv = converters[ prev + " " + current ] || converters[ "* " + current ];

    // If none found, seek a pair if ( !conv ) { for ( conv2 in converters ) {

    // If conv2 outputs current tmp = conv2.split( " " ); if ( tmp[ 1 ] === current ) {

    // If prev can be converted to accepted input conv = converters[ prev + " " + tmp[ 0 ] ] || converters[ "* " + tmp[ 0 ] ]; if ( conv ) {

    // Condense equivalence converters if ( conv === true ) { conv = converters[ conv2 ];

    // Otherwise, insert the intermediate dataType } else if ( converters[ conv2 ] !== true ) { current = tmp[ 0 ]; dataTypes.unshift( tmp[ 1 ] ); } break; } } } }

    // Apply converter (if not an equivalence) if ( conv !== true ) {

    // Unless errors are allowed to bubble, catch and return them if ( conv && s.throws ) { response = conv( response ); } else { try { response = conv( response ); } catch ( e ) { return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; } } } } } }

    return { state: "success", data: response }; }

    jQuery.extend( {

    // Counter for holding the number of active queries active: 0,

    // Last-Modified header cache for next request lastModified: {}, etag: {},

    ajaxSettings: { url: location.href, type: "GET", isLocal: rlocalProtocol.test( location.protocol ), global: true, processData: true, async: true, contentType: "application/x-www-form-urlencoded; charset=UTF-8",

    /* timeout: 0, data: null, dataType: null, username: null, password: null, cache: null, throws: false, traditional: false, headers: {}, */

    accepts: { "*": allTypes, text: "text/plain", html: "text/html", xml: "application/xml, text/xml", json: "application/json, text/javascript" },

    contents: { xml: /\bxml\b/, html: /\bhtml/, json: /\bjson\b/ },

    responseFields: { xml: "responseXML", text: "responseText", json: "responseJSON" },

    // Data converters // Keys separate source (or catchall "*") and destination types with a single space converters: {

    // Convert anything to text "* text": String,

    // Text to html (true = no transformation) "text html": true,

    // Evaluate text as a json expression "text json": JSON.parse,

    // Parse text as xml "text xml": jQuery.parseXML },

    // For options that shouldn't be deep extended: // you can add your own custom options here if // and when you create one that shouldn't be // deep extended (see ajaxExtend) flatOptions: { url: true, context: true } },

    // Creates a full fledged settings object into target // with both ajaxSettings and settings fields. // If target is omitted, writes into ajaxSettings. ajaxSetup: function( target, settings ) { return settings ?

    // Building a settings object ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :

    // Extending ajaxSettings ajaxExtend( jQuery.ajaxSettings, target ); },

    ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), ajaxTransport: addToPrefiltersOrTransports( transports ),

    // Main method ajax: function( url, options ) {

    // If url is an object, simulate pre-1.5 signature if ( typeof url === "object" ) { options = url; url = undefined; }

    // Force options to be an object options = options || {};

    var transport,

    // URL without anti-cache param cacheURL,

    // Response headers responseHeadersString, responseHeaders,

    // timeout handle timeoutTimer,

    // Url cleanup var urlAnchor,

    // Request state (becomes false upon send and true upon completion) completed,

    // To know if global events are to be dispatched fireGlobals,

    // Loop variable i,

    // uncached part of the url uncached,

    // Create the final options object s = jQuery.ajaxSetup( {}, options ),

    // Callbacks context callbackContext = s.context || s,

    // Context for global events is callbackContext if it is a DOM node or jQuery collection globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ? jQuery( callbackContext ) : jQuery.event,

    // Deferreds deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks( "once memory" ),

    // Status-dependent callbacks statusCode = s.statusCode || {},

    // Headers (they are sent all at once) requestHeaders = {}, requestHeadersNames = {},

    // Default abort message strAbort = "canceled",

    // Fake xhr jqXHR = { readyState: 0,

    // Builds headers hashtable if needed getResponseHeader: function( key ) { var match; if ( completed ) { if ( !responseHeaders ) { responseHeaders = {}; while ( ( match = rheaders.exec( responseHeadersString ) ) ) { responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; } } match = responseHeaders[ key.toLowerCase() ]; } return match == null ? null : match; },

    // Raw string getAllResponseHeaders: function() { return completed ? responseHeadersString : null; },

    // Caches the header setRequestHeader: function( name, value ) { if ( completed == null ) { name = requestHeadersNames[ name.toLowerCase() ] = requestHeadersNames[ name.toLowerCase() ] || name; requestHeaders[ name ] = value; } return this; },

    // Overrides response content-type header overrideMimeType: function( type ) { if ( completed == null ) { s.mimeType = type; } return this; },

    // Status-dependent callbacks statusCode: function( map ) { var code; if ( map ) { if ( completed ) {

    // Execute the appropriate callbacks jqXHR.always( map[ jqXHR.status ] ); } else {

    // Lazy-add the new callbacks in a way that preserves old ones for ( code in map ) { statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; } } } return this; },

    // Cancel the request abort: function( statusText ) { var finalText = statusText || strAbort; if ( transport ) { transport.abort( finalText ); } done( 0, finalText ); return this; } };

    // Attach deferreds deferred.promise( jqXHR );

    // Add protocol if not provided (prefilters might expect it) // Handle falsy url in the settings object (#10093: consistency with old signature) // We also use the url parameter if available s.url = ( ( url || s.url || location.href ) + "" ) .replace( rprotocol, location.protocol + "//" );

    // Alias method option to type as per ticket #12004 s.type = options.method || options.type || s.method || s.type;

    // Extract dataTypes list s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];

    // A cross-domain request is in order when the origin doesn't match the current origin. if ( s.crossDomain == null ) { urlAnchor = document.createElement( "a" );

    // Support: IE <=8 - 11, Edge 12 - 15 // IE throws exception on accessing the href property if url is malformed, // e.g. http://example.com:80x/ try { urlAnchor.href = s.url;

    // Support: IE <=8 - 11 only // Anchor's host property isn't correctly set when s.url is relative urlAnchor.href = urlAnchor.href; s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host; } catch ( e ) {

    // If there is an error parsing the URL, assume it is crossDomain, // it can be rejected by the transport if it is invalid s.crossDomain = true; } }

    // Convert data if not already a string if ( s.data && s.processData && typeof s.data !== "string" ) { s.data = jQuery.param( s.data, s.traditional ); }

    // Apply prefilters inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

    // If request was aborted inside a prefilter, stop there if ( completed ) { return jqXHR; }

    // We can fire global events as of now if asked to // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) fireGlobals = jQuery.event && s.global;

    // Watch for a new set of requests if ( fireGlobals && jQuery.active++ === 0 ) { jQuery.event.trigger( "ajaxStart" ); }

    // Uppercase the type s.type = s.type.toUpperCase();

    // Determine if request has content s.hasContent = !rnoContent.test( s.type );

    // Save the URL in case we're toying with the If-Modified-Since // and/or If-None-Match header later on // Remove hash to simplify url manipulation cacheURL = s.url.replace( rhash, "" );

    // More options handling for requests with no content if ( !s.hasContent ) {

    // Remember the hash so we can put it back uncached = s.url.slice( cacheURL.length );

    // If data is available and should be processed, append data to url if ( s.data && ( s.processData || typeof s.data === "string" ) ) { cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;

    // #9682: remove data so that it's not used in an eventual retry delete s.data; }

    // Add or update anti-cache param if needed if ( s.cache === false ) { cacheURL = cacheURL.replace( rantiCache, "$1" ); uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; }

    // Put hash and anti-cache on the URL that will be requested (gh-1732) s.url = cacheURL + uncached;

    // Change '%20' to '+' if this is encoded form body content (gh-2658) } else if ( s.data && s.processData && ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { s.data = s.data.replace( r20, "+" ); }

    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { if ( jQuery.lastModified[ cacheURL ] ) { jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); } if ( jQuery.etag[ cacheURL ] ) { jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); } }

    // Set the correct header, if data is being sent if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { jqXHR.setRequestHeader( "Content-Type", s.contentType ); }

    // Set the Accepts header for the server, depending on the dataType jqXHR.setRequestHeader( "Accept", s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? s.accepts[ s.dataTypes[ 0 ] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : s.accepts[ "*" ] );

    // Check for headers option for ( i in s.headers ) { jqXHR.setRequestHeader( i, s.headers[ i ] ); }

    // Allow custom headers/mimetypes and early abort if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {

    // Abort if not done already and return return jqXHR.abort(); }

    // Aborting is no longer a cancellation strAbort = "abort";

    // Install callbacks on deferreds completeDeferred.add( s.complete ); jqXHR.done( s.success ); jqXHR.fail( s.error );

    // Get transport transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

    // If no transport, we auto-abort if ( !transport ) { done( -1, "No Transport" ); } else { jqXHR.readyState = 1;

    // Send global event if ( fireGlobals ) { globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); }

    // If request was aborted inside ajaxSend, stop there if ( completed ) { return jqXHR; }

    // Timeout if ( s.async && s.timeout > 0 ) { timeoutTimer = window.setTimeout( function() { jqXHR.abort( "timeout" ); }, s.timeout ); }

    try { completed = false; transport.send( requestHeaders, done ); } catch ( e ) {

    // Rethrow post-completion exceptions if ( completed ) { throw e; }

    // Propagate others as results done( -1, e ); } }

    // Callback for when everything is done function done( status, nativeStatusText, responses, headers ) { var isSuccess, success, error, response, modified, statusText = nativeStatusText;

    // Ignore repeat invocations if ( completed ) { return; }

    completed = true;

    // Clear timeout if it exists if ( timeoutTimer ) { window.clearTimeout( timeoutTimer ); }

    // Dereference transport for early garbage collection // (no matter how long the jqXHR object will be used) transport = undefined;

    // Cache response headers responseHeadersString = headers || "";

    // Set readyState jqXHR.readyState = status > 0 ? 4 : 0;

    // Determine if successful isSuccess = status >= 200 && status < 300 || status === 304;

    // Get response data if ( responses ) { response = ajaxHandleResponses( s, jqXHR, responses ); }

    // Convert no matter what (that way responseXXX fields are always set) response = ajaxConvert( s, response, jqXHR, isSuccess );

    // If successful, handle type chaining if ( isSuccess ) {

    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { modified = jqXHR.getResponseHeader( "Last-Modified" ); if ( modified ) { jQuery.lastModified[ cacheURL ] = modified; } modified = jqXHR.getResponseHeader( "etag" ); if ( modified ) { jQuery.etag[ cacheURL ] = modified; } }

    // if no content if ( status === 204 || s.type === "HEAD" ) { statusText = "nocontent";

    // if not modified } else if ( status === 304 ) { statusText = "notmodified";

    // If we have data, let's convert it } else { statusText = response.state; success = response.data; error = response.error; isSuccess = !error; } } else {

    // Extract error from statusText and normalize for non-aborts error = statusText; if ( status || !statusText ) { statusText = "error"; if ( status < 0 ) { status = 0; } } }

    // Set data for the fake xhr object jqXHR.status = status; jqXHR.statusText = ( nativeStatusText || statusText ) + "";

    // Success/Error if ( isSuccess ) { deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); } else { deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); }

    // Status-dependent callbacks jqXHR.statusCode( statusCode ); statusCode = undefined;

    if ( fireGlobals ) { globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", [ jqXHR, s, isSuccess ? success : error ] ); }

    // Complete completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

    if ( fireGlobals ) { globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );

    // Handle the global AJAX counter if ( !( --jQuery.active ) ) { jQuery.event.trigger( "ajaxStop" ); } } }

    return jqXHR; },

    getJSON: function( url, data, callback ) { return jQuery.get( url, data, callback, "json" ); },

    getScript: function( url, callback ) { return jQuery.get( url, undefined, callback, "script" ); } } );

    jQuery.each( [ "get", "post" ], function( i, method ) { jQuery[ method ] = function( url, data, callback, type ) {

    // Shift arguments if data argument was omitted if ( isFunction( data ) ) { type = type || callback; callback = data; data = undefined; }

    // The url can be an options object (which then must have .url) return jQuery.ajax( jQuery.extend( { url: url, type: method, dataType: type, data: data, success: callback }, jQuery.isPlainObject( url ) && url ) ); }; } );


    jQuery._evalUrl = function( url ) { return jQuery.ajax( { url: url,

    // Make this explicit, since user can override this through ajaxSetup (#11264) type: "GET", dataType: "script", cache: true, async: false, global: false, "throws": true } ); };


    jQuery.fn.extend( { wrapAll: function( html ) { var wrap;

    if ( this[ 0 ] ) { if ( isFunction( html ) ) { html = html.call( this[ 0 ] ); }

    // The elements to wrap the target around wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );

    if ( this[ 0 ].parentNode ) { wrap.insertBefore( this[ 0 ] ); }

    wrap.map( function() { var elem = this;

    while ( elem.firstElementChild ) { elem = elem.firstElementChild; }

    return elem; } ).append( this ); }

    return this; },

    wrapInner: function( html ) { if ( isFunction( html ) ) { return this.each( function( i ) { jQuery( this ).wrapInner( html.call( this, i ) ); } ); }

    return this.each( function() { var self = jQuery( this ), contents = self.contents();

    if ( contents.length ) { contents.wrapAll( html );

    } else { self.append( html ); } } ); },

    wrap: function( html ) { var htmlIsFunction = isFunction( html );

    return this.each( function( i ) { jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); } ); },

    unwrap: function( selector ) { this.parent( selector ).not( "body" ).each( function() { jQuery( this ).replaceWith( this.childNodes ); } ); return this; } } );


    jQuery.expr.pseudos.hidden = function( elem ) { return !jQuery.expr.pseudos.visible( elem ); }; jQuery.expr.pseudos.visible = function( elem ) { return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); };



    jQuery.ajaxSettings.xhr = function() { try { return new window.XMLHttpRequest(); } catch ( e ) {} };

    var xhrSuccessStatus = {

    // File protocol always yields status code 0, assume 200 0: 200,

    // Support: IE <=9 only // #1450: sometimes IE returns 1223 when it should be 204 1223: 204 }, xhrSupported = jQuery.ajaxSettings.xhr();

    support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); support.ajax = xhrSupported = !!xhrSupported;

    jQuery.ajaxTransport( function( options ) { var callback, errorCallback;

    // Cross domain only allowed if supported through XMLHttpRequest if ( support.cors || xhrSupported && !options.crossDomain ) { return { send: function( headers, complete ) { var i, xhr = options.xhr();

    xhr.open( options.type, options.url, options.async, options.username, options.password );

    // Apply custom fields if provided if ( options.xhrFields ) { for ( i in options.xhrFields ) { xhr[ i ] = options.xhrFields[ i ]; } }

    // Override mime type if needed if ( options.mimeType && xhr.overrideMimeType ) { xhr.overrideMimeType( options.mimeType ); }

    // X-Requested-With header // For cross-domain requests, seeing as conditions for a preflight are // akin to a jigsaw puzzle, we simply never set it to be sure. // (it can always be set on a per-request basis or even using ajaxSetup) // For same-domain requests, won't change header if already provided. if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { headers[ "X-Requested-With" ] = "XMLHttpRequest"; }

    // Set headers for ( i in headers ) { xhr.setRequestHeader( i, headers[ i ] ); }

    // Callback callback = function( type ) { return function() { if ( callback ) { callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;

    if ( type === "abort" ) { xhr.abort(); } else if ( type === "error" ) {

    // Support: IE <=9 only // On a manual native abort, IE9 throws // errors on any property access that is not readyState if ( typeof xhr.status !== "number" ) { complete( 0, "error" ); } else { complete(

    // File: protocol always yields status 0; see #8605, #14207 xhr.status, xhr.statusText ); } } else { complete( xhrSuccessStatus[ xhr.status ] || xhr.status, xhr.statusText,

    // Support: IE <=9 only // IE9 has no XHR2 but throws on binary (trac-11426) // For XHR2 non-text, let the caller handle it (gh-2498) ( xhr.responseType || "text" ) !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders() ); } } }; };

    // Listen to events xhr.onload = callback(); errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );

    // Support: IE 9 only // Use onreadystatechange to replace onabort // to handle uncaught aborts if ( xhr.onabort !== undefined ) { xhr.onabort = errorCallback; } else { xhr.onreadystatechange = function() {

    // Check readyState before timeout as it changes if ( xhr.readyState === 4 ) {

    // Allow onerror to be called first, // but that will not handle a native abort // Also, save errorCallback to a variable // as xhr.onerror cannot be accessed window.setTimeout( function() { if ( callback ) { errorCallback(); } } ); } }; }

    // Create the abort callback callback = callback( "abort" );

    try {

    // Do send the request (this may raise an exception) xhr.send( options.hasContent && options.data || null ); } catch ( e ) {

    // #14683: Only rethrow if this hasn't been notified as an error yet if ( callback ) { throw e; } } },

    abort: function() { if ( callback ) { callback(); } } }; } } );



    // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) jQuery.ajaxPrefilter( function( s ) { if ( s.crossDomain ) { s.contents.script = false; } } );

    // Install script dataType jQuery.ajaxSetup( { accepts: { script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript" }, contents: { script: /\b(?:java|ecma)script\b/ }, converters: { "text script": function( text ) { jQuery.globalEval( text ); return text; } } } );

    // Handle cache's special case and crossDomain jQuery.ajaxPrefilter( "script", function( s ) { if ( s.cache === undefined ) { s.cache = false; } if ( s.crossDomain ) { s.type = "GET"; } } );

    // Bind script tag hack transport jQuery.ajaxTransport( "script", function( s ) {

    // This transport only deals with cross domain requests if ( s.crossDomain ) { var script, callback; return { send: function( _, complete ) { script = jQuery( "<script>" ).prop( { charset: s.scriptCharset, src: s.url } ).on( "load error", callback = function( evt ) { script.remove(); callback = null; if ( evt ) { complete( evt.type === "error" ? 404 : 200, evt.type ); } } );

    // Use native DOM manipulation to avoid our domManip AJAX trickery document.head.appendChild( script[ 0 ] ); }, abort: function() { if ( callback ) { callback(); } } }; } } );



    var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/;

    // Default jsonp settings jQuery.ajaxSetup( { jsonp: "callback", jsonpCallback: function() { var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); this[ callback ] = true; return callback; } } );

    // Detect, normalize options and install callbacks for jsonp requests jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

    var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? "url" : typeof s.data === "string" && ( s.contentType || "" ) .indexOf( "application/x-www-form-urlencoded" ) === 0 && rjsonp.test( s.data ) && "data" );

    // Handle iff the expected data type is "jsonp" or we have a parameter to set if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {

    // Get callback name, remembering preexisting value associated with it callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback;

    // Insert callback into url or form data if ( jsonProp ) { s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); } else if ( s.jsonp !== false ) { s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; }

    // Use data converter to retrieve json after script execution s.converters[ "script json" ] = function() { if ( !responseContainer ) { jQuery.error( callbackName + " was not called" ); } return responseContainer[ 0 ]; };

    // Force json dataType s.dataTypes[ 0 ] = "json";

    // Install callback overwritten = window[ callbackName ]; window[ callbackName ] = function() { responseContainer = arguments; };

    // Clean-up function (fires after converters) jqXHR.always( function() {

    // If previous value didn't exist - remove it if ( overwritten === undefined ) { jQuery( window ).removeProp( callbackName );

    // Otherwise restore preexisting value } else { window[ callbackName ] = overwritten; }

    // Save back as free if ( s[ callbackName ] ) {

    // Make sure that re-using the options doesn't screw things around s.jsonpCallback = originalSettings.jsonpCallback;

    // Save the callback name for future use oldCallbacks.push( callbackName ); }

    // Call if it was a function and we have a response if ( responseContainer && isFunction( overwritten ) ) { overwritten( responseContainer[ 0 ] ); }

    responseContainer = overwritten = undefined; } );

    // Delegate to script return "script"; } } );



    // Support: Safari 8 only // In Safari 8 documents created via document.implementation.createHTMLDocument // collapse sibling forms: the second one becomes a child of the first one. // Because of that, this security measure has to be disabled in Safari 8. // https://bugs.webkit.org/show_bug.cgi?id=137337 support.createHTMLDocument = ( function() { var body = document.implementation.createHTMLDocument( "" ).body; body.innerHTML = "<form></form><form></form>"; return body.childNodes.length === 2; } )();


    // Argument "data" should be string of html // context (optional): If specified, the fragment will be created in this context, // defaults to document // keepScripts (optional): If true, will include scripts passed in the html string jQuery.parseHTML = function( data, context, keepScripts ) { if ( typeof data !== "string" ) { return []; } if ( typeof context === "boolean" ) { keepScripts = context; context = false; }

    var base, parsed, scripts;

    if ( !context ) {

    // Stop scripts or inline event handlers from being executed immediately // by using document.implementation if ( support.createHTMLDocument ) { context = document.implementation.createHTMLDocument( "" );

    // Set the base href for the created document // so any parsed elements with URLs // are based on the document's URL (gh-2965) base = context.createElement( "base" ); base.href = document.location.href; context.head.appendChild( base ); } else { context = document; } }

    parsed = rsingleTag.exec( data ); scripts = !keepScripts && [];

    // Single tag if ( parsed ) { return [ context.createElement( parsed[ 1 ] ) ]; }

    parsed = buildFragment( [ data ], context, scripts );

    if ( scripts && scripts.length ) { jQuery( scripts ).remove(); }

    return jQuery.merge( [], parsed.childNodes ); };


    /**

    * Load a url into a page
    */
    

    jQuery.fn.load = function( url, params, callback ) { var selector, type, response, self = this, off = url.indexOf( " " );

    if ( off > -1 ) { selector = stripAndCollapse( url.slice( off ) ); url = url.slice( 0, off ); }

    // If it's a function if ( isFunction( params ) ) {

    // We assume that it's the callback callback = params; params = undefined;

    // Otherwise, build a param string } else if ( params && typeof params === "object" ) { type = "POST"; }

    // If we have elements to modify, make the request if ( self.length > 0 ) { jQuery.ajax( { url: url,

    // If "type" variable is undefined, then "GET" method will be used. // Make value of this field explicit since // user can override it through ajaxSetup method type: type || "GET", dataType: "html", data: params } ).done( function( responseText ) {

    // Save response for use in complete callback response = arguments;

    self.html( selector ?

    // If a selector was specified, locate the right elements in a dummy div // Exclude scripts to avoid IE 'Permission Denied' errors

    jQuery( "
    " ).append( jQuery.parseHTML( responseText ) ).find( selector ) :

    // Otherwise use the full result responseText );

    // If the request succeeds, this function gets "data", "status", "jqXHR" // but they are ignored because response was set above. // If it fails, this function gets "jqXHR", "status", "error" } ).always( callback && function( jqXHR, status ) { self.each( function() { callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); } ); } ); }

    return this; };



    // Attach a bunch of functions for handling common AJAX events jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) { jQuery.fn[ type ] = function( fn ) { return this.on( type, fn ); }; } );



    jQuery.expr.pseudos.animated = function( elem ) { return jQuery.grep( jQuery.timers, function( fn ) { return elem === fn.elem; } ).length; };



    jQuery.offset = { setOffset: function( elem, options, i ) { var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery.css( elem, "position" ), curElem = jQuery( elem ), props = {};

    // Set position first, in-case top/left are set even on static elem if ( position === "static" ) { elem.style.position = "relative"; }

    curOffset = curElem.offset(); curCSSTop = jQuery.css( elem, "top" ); curCSSLeft = jQuery.css( elem, "left" ); calculatePosition = ( position === "absolute" || position === "fixed" ) && ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;

    // Need to be able to calculate position if either // top or left is auto and position is either absolute or fixed if ( calculatePosition ) { curPosition = curElem.position(); curTop = curPosition.top; curLeft = curPosition.left;

    } else { curTop = parseFloat( curCSSTop ) || 0; curLeft = parseFloat( curCSSLeft ) || 0; }

    if ( isFunction( options ) ) {

    // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); }

    if ( options.top != null ) { props.top = ( options.top - curOffset.top ) + curTop; } if ( options.left != null ) { props.left = ( options.left - curOffset.left ) + curLeft; }

    if ( "using" in options ) { options.using.call( elem, props );

    } else { curElem.css( props ); } } };

    jQuery.fn.extend( {

    // offset() relates an element's border box to the document origin offset: function( options ) {

    // Preserve chaining for setter if ( arguments.length ) { return options === undefined ? this : this.each( function( i ) { jQuery.offset.setOffset( this, options, i ); } ); }

    var rect, win, elem = this[ 0 ];

    if ( !elem ) { return; }

    // Return zeros for disconnected and hidden (display: none) elements (gh-2310) // Support: IE <=11 only // Running getBoundingClientRect on a // disconnected node in IE throws an error if ( !elem.getClientRects().length ) { return { top: 0, left: 0 }; }

    // Get document-relative position by adding viewport scroll to viewport-relative gBCR rect = elem.getBoundingClientRect(); win = elem.ownerDocument.defaultView; return { top: rect.top + win.pageYOffset, left: rect.left + win.pageXOffset }; },

    // position() relates an element's margin box to its offset parent's padding box // This corresponds to the behavior of CSS absolute positioning position: function() { if ( !this[ 0 ] ) { return; }

    var offsetParent, offset, doc, elem = this[ 0 ], parentOffset = { top: 0, left: 0 };

    // position:fixed elements are offset from the viewport, which itself always has zero offset if ( jQuery.css( elem, "position" ) === "fixed" ) {

    // Assume position:fixed implies availability of getBoundingClientRect offset = elem.getBoundingClientRect();

    } else { offset = this.offset();

    // Account for the *real* offset parent, which can be the document or its root element // when a statically positioned element is identified doc = elem.ownerDocument; offsetParent = elem.offsetParent || doc.documentElement; while ( offsetParent && ( offsetParent === doc.body || offsetParent === doc.documentElement ) && jQuery.css( offsetParent, "position" ) === "static" ) {

    offsetParent = offsetParent.parentNode; } if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {

    // Incorporate borders into its offset, since they are outside its content origin parentOffset = jQuery( offsetParent ).offset(); parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true ); parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true ); } }

    // Subtract parent offsets and element margins return { top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) }; },

    // This method will return documentElement in the following cases: // 1) For the element inside the iframe without offsetParent, this method will return // documentElement of the parent window // 2) For the hidden or detached element // 3) For body or html element, i.e. in case of the html node - it will return itself // // but those exceptions were never presented as a real life use-cases // and might be considered as more preferable results. // // This logic, however, is not guaranteed and can change at any point in the future offsetParent: function() { return this.map( function() { var offsetParent = this.offsetParent;

    while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) { offsetParent = offsetParent.offsetParent; }

    return offsetParent || documentElement; } ); } } );

    // Create scrollLeft and scrollTop methods jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { var top = "pageYOffset" === prop;

    jQuery.fn[ method ] = function( val ) { return access( this, function( elem, method, val ) {

    // Coalesce documents and windows var win; if ( isWindow( elem ) ) { win = elem; } else if ( elem.nodeType === 9 ) { win = elem.defaultView; }

    if ( val === undefined ) { return win ? win[ prop ] : elem[ method ]; }

    if ( win ) { win.scrollTo( !top ? val : win.pageXOffset, top ? val : win.pageYOffset );

    } else { elem[ method ] = val; } }, method, val, arguments.length ); }; } );

    // Support: Safari <=7 - 9.1, Chrome <=37 - 49 // Add the top/left cssHooks using jQuery.fn.position // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 // getComputedStyle returns percent when specified for top/left/bottom/right; // rather than make the css module depend on the offset module, just check for it here jQuery.each( [ "top", "left" ], function( i, prop ) { jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, function( elem, computed ) { if ( computed ) { computed = curCSS( elem, prop );

    // If curCSS returns percentage, fallback to offset return rnumnonpx.test( computed ) ? jQuery( elem ).position()[ prop ] + "px" : computed; } } ); } );


    // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {

    // Margin is only for outerHeight, outerWidth jQuery.fn[ funcName ] = function( margin, value ) { var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );

    return access( this, function( elem, type, value ) { var doc;

    if ( isWindow( elem ) ) {

    // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) return funcName.indexOf( "outer" ) === 0 ? elem[ "inner" + name ] : elem.document.documentElement[ "client" + name ]; }

    // Get document width or height if ( elem.nodeType === 9 ) { doc = elem.documentElement;

    // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], // whichever is greatest return Math.max( elem.body[ "scroll" + name ], doc[ "scroll" + name ], elem.body[ "offset" + name ], doc[ "offset" + name ], doc[ "client" + name ] ); }

    return value === undefined ?

    // Get width or height on the element, requesting but not forcing parseFloat jQuery.css( elem, type, extra ) :

    // Set width or height on the element jQuery.style( elem, type, value, extra ); }, type, chainable ? margin : undefined, chainable ); }; } ); } );


    jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu" ).split( " " ), function( i, name ) {

    // Handle event binding jQuery.fn[ name ] = function( data, fn ) { return arguments.length > 0 ? this.on( name, null, data, fn ) : this.trigger( name ); }; } );

    jQuery.fn.extend( { hover: function( fnOver, fnOut ) { return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); } } );



    jQuery.fn.extend( {

    bind: function( types, data, fn ) { return this.on( types, null, data, fn ); }, unbind: function( types, fn ) { return this.off( types, null, fn ); },

    delegate: function( selector, types, data, fn ) { return this.on( types, selector, data, fn ); }, undelegate: function( selector, types, fn ) {

    // ( namespace ) or ( selector, types [, fn] ) return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); } } );

    // Bind a function to a context, optionally partially applying any // arguments. // jQuery.proxy is deprecated to promote standards (specifically Function#bind) // However, it is not slated for removal any time soon jQuery.proxy = function( fn, context ) { var tmp, args, proxy;

    if ( typeof context === "string" ) { tmp = fn[ context ]; context = fn; fn = tmp; }

    // Quick check to determine if target is callable, in the spec // this throws a TypeError, but we will just return undefined. if ( !isFunction( fn ) ) { return undefined; }

    // Simulated bind args = slice.call( arguments, 2 ); proxy = function() { return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); };

    // Set the guid of unique handler to the same of original handler, so it can be removed proxy.guid = fn.guid = fn.guid || jQuery.guid++;

    return proxy; };

    jQuery.holdReady = function( hold ) { if ( hold ) { jQuery.readyWait++; } else { jQuery.ready( true ); } }; jQuery.isArray = Array.isArray; jQuery.parseJSON = JSON.parse; jQuery.nodeName = nodeName; jQuery.isFunction = isFunction; jQuery.isWindow = isWindow; jQuery.camelCase = camelCase; jQuery.type = toType;

    jQuery.now = Date.now;

    jQuery.isNumeric = function( obj ) {

    // As of jQuery 3.0, isNumeric is limited to // strings and numbers (primitives or objects) // that can be coerced to finite numbers (gh-2662) var type = jQuery.type( obj ); return ( type === "number" || type === "string" ) &&

    // parseFloat NaNs numeric-cast false positives ("") // ...but misinterprets leading-number strings, particularly hex literals ("0x...") // subtraction forces infinities to NaN !isNaN( obj - parseFloat( obj ) ); };



    // Register as a named AMD module, since jQuery can be concatenated with other // files that may use define, but not via a proper concatenation script that // understands anonymous AMD modules. A named AMD is safest and most robust // way to register. Lowercase jquery is used because AMD module names are // derived from file names, and jQuery is normally delivered in a lowercase // file name. Do this after creating the global so that if an AMD module wants // to call noConflict to hide this version of jQuery, it will work.

    // Note that for maximum portability, libraries that are not jQuery should // declare themselves as anonymous modules, and avoid setting a global if an // AMD loader is present. jQuery is a special case. For more information, see // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon

    if ( typeof define === "function" && define.amd ) { define( "jquery", [], function() { return jQuery; } ); }



    var

    // Map over jQuery in case of overwrite _jQuery = window.jQuery,

    // Map over the $ in case of overwrite _$ = window.$;

    jQuery.noConflict = function( deep ) { if ( window.$ === jQuery ) { window.$ = _$; }

    if ( deep && window.jQuery === jQuery ) { window.jQuery = _jQuery; }

    return jQuery; };

    // Expose jQuery and $ identifiers, even in AMD // (#7102#comment:10, https://github.com/jquery/jquery/pull/557) // and CommonJS for browser emulators (#13566) if ( !noGlobal ) { window.jQuery = window.$ = jQuery; }



    return jQuery;

    } );