* jQuery JavaScript Library v2.2.4
* Copyright jQuery Foundation and other contributors
* Released under the MIT license
* http://jquery.org/license
* Date: 2016-05-20T17:23Z
(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 ) {
// Can't be in strict mode, several libs including ASP.NET trace
// the stack via arguments.caller.callee and Firefox dies if
// you try to trace through "use strict" call chains. (#13335)
var document = window.document;
var indexOf = arr.indexOf;
var toString = class2type.toString;
var hasOwn = class2type.hasOwnProperty;
// 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 );
// Make sure we trim BOM and NBSP
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
// Matches dashed string for camelizing
rdashAlpha = /-([\da-z])/gi,
// Used by jQuery.camelCase as callback to replace()
fcamelCase = function( all, letter ) {
return letter.toUpperCase();
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
// Start with an empty selector
// 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 just the one element from the set
( num < 0 ? this[ num + this.length ] : this[ num ] ) :
// Return all the elements in a clean array
// 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.context = this.context;
// 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 ) );
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" && !jQuery.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 never-ending loop
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
( copyIsArray = jQuery.isArray( copy ) ) ) ) {
clone = src && jQuery.isArray( src ) ? src : [];
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 ) {
// 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
isFunction: function( obj ) {
return jQuery.type( obj ) === "function";
isWindow: function( obj ) {
return obj != null && obj === obj.window;
isNumeric: function( obj ) {
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
// subtraction forces infinities to NaN
// adding 1 corrects loss of precision from parseFloat (#15100)
var realStringObj = obj && obj.toString();
return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;
isPlainObject: function( obj ) {
// - Any object or value whose internal [[Class]] property is not "[object Object]"
if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
// Not own constructor property must be Object
!hasOwn.call( obj, "constructor" ) &&
!hasOwn.call( obj.constructor.prototype || {}, "isPrototypeOf" ) ) {
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own
return key === undefined || hasOwn.call( obj, key );
isEmptyObject: function( obj ) {
// Support: Android<4.0, iOS<6 (functionish RegExp)
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call( obj ) ] || "object" :
// Evaluates a script in a global context
globalEval: function( code ) {
code = jQuery.trim( code );
// If the code includes a valid, prologue position
// strict mode pragma, execute code by injecting a
// script tag into the document.
if ( code.indexOf( "use strict" ) === 1 ) {
script = document.createElement( "script" );
document.head.appendChild( script ).parentNode.removeChild( script );
// Otherwise, avoid the DOM node creation, insertion
// and removal by using an indirect global eval
// Convert dashed to camelCase; used by the css and data modules
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function( string ) {
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
nodeName: function( elem, name ) {
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
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 ) {
( text + "" ).replace( rtrim, "" );
// 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 );
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
return concat.apply( [], ret );
// A global GUID counter for objects
// Bind a function to a context, optionally partially applying any
proxy: function( fn, context ) {
if ( typeof context === "string" ) {
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if ( !jQuery.isFunction( fn ) ) {
args = slice.call( arguments, 2 );
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