* jQuery JavaScript Library v3.5.1
* Copyright JS Foundation and other contributors
* Released under the MIT license
* https://jquery.org/license
* Date: 2020-05-04T22:49Z
( function( global, factory ) {
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 ) :
throw new Error( "jQuery requires a window with a document" );
// 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.
var getProto = Object.getPrototypeOf;
var flat = arr.flat ? function( array ) {
return arr.flat.call( array );
return arr.concat.apply( [], array );
var indexOf = arr.indexOf;
var toString = class2type.toString;
var hasOwn = class2type.hasOwnProperty;
var fnToString = hasOwn.toString;
var ObjectFunctionString = fnToString.call( Object );
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 document = window.document;
var preservedScriptAttributes = {
function DOMEval( code, node, doc ) {
script = doc.createElement( "script" );
for ( i in preservedScriptAttributes ) {
// Support: Firefox 64+, Edge 18+
// Some browsers don't support the "nonce" property on scripts.
// On the other hand, just using `getAttribute` is not enough as
// the `nonce` attribute is reset to an empty string whenever it
// becomes browsing-context connected.
// See https://github.com/whatwg/html/issues/2369
// See https://html.spec.whatwg.org/#nonce-attributes
// The `node.getAttribute` check was added for the sake of
// `jQuery.globalEval` so that it can fake a nonce-containing node
val = node[ i ] || node.getAttribute && node.getAttribute( i );
script.setAttribute( i, val );
doc.head.appendChild( script ).parentNode.removeChild( script );
// Support: Android <=2.3 only (functionish RegExp)
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call( obj ) ] || "object" :
// 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
// 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 );
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
// The default length of a jQuery object is 0
return slice.call( this );
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
// Return all the elements in a clean array
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)
// Return the newly-formed element set
// 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 );
return this.pushStack( slice.apply( this, arguments ) );
return this.pushStack( jQuery.grep( this, function( _elem, i ) {
return this.pushStack( jQuery.grep( this, function( _elem, i ) {
j = +i + ( i < 0 ? len : 0 );
return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
return this.prevObject || this.constructor();
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[ 0 ] || {},
length = arguments.length,
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
// Skip the boolean and the target
target = arguments[ i ] || {};
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !isFunction( target ) ) {
// Extend jQuery itself if only one argument is passed
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
if ( ( options = arguments[ i ] ) != null ) {
// Extend the base object
for ( name in options ) {
// Prevent Object.prototype pollution
// Prevent never-ending loop
if ( name === "__proto__" || target === copy ) {
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
( copyIsArray = Array.isArray( copy ) ) ) ) {
// Ensure proper type for the source value
if ( copyIsArray && !Array.isArray( src ) ) {
} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
// Return the modified object
// 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
isPlainObject: function( obj ) {
// Detect obvious negatives
// Use toString instead of jQuery.type to catch host objects
if ( !obj || toString.call( obj ) !== "[object Object]" ) {
// Objects with no prototype (e.g., `Object.create( null )`) are plain
// 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 ) {
// Evaluates a script in a provided context; falls back to the global one
globalEval: function( code, options, doc ) {
DOMEval( code, { nonce: options && options.nonce }, doc );
each: function( obj, callback ) {
if ( isArrayLike( obj ) ) {
for ( ; i < length; i++ ) {
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
// results is for internal usage only
makeArray: function( arr, results ) {
if ( isArrayLike( Object( arr ) ) ) {
typeof arr === "string" ?
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,
first[ i++ ] = second[ j ];
grep: function( elems, callback, invert ) {
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 ] );
// arg is for internal usage only
map: function( elems, callback, arg ) {
// Go through the array, translating each of the items to their new values
if ( isArrayLike( elems ) ) {
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
// Go through every key on the object,
value = callback( elems[ i ], i, arg );
// Flatten any nested arrays
// A global GUID counter for objects
// jQuery.support is not used in Core but other projects attach their
// properties to it so it needs to exist.
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( " " ),
class2type[ "[object " + name + "]" ] = name.toLowerCase();