* jQuery JavaScript Library v1.12.4
* Copyright jQuery Foundation and other contributors
* Released under the MIT license
* http://jquery.org/license
* Date: 2016-05-20T17:17Z
(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 slice = deletedIds.slice;
var concat = deletedIds.concat;
var push = deletedIds.push;
var indexOf = deletedIds.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 );
// Support: Android<4.1, IE<9
// 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.
splice: deletedIds.splice
jQuery.extend = jQuery.fn.extend = function() {
var src, copyIsArray, copy, name, options, 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
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
return jQuery.type( obj ) === "function";
isArray: Array.isArray || function( obj ) {
return jQuery.type( obj ) === "array";
isWindow: function( obj ) {
/* jshint eqeqeq: false */
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;
isEmptyObject: function( obj ) {
isPlainObject: function( obj ) {
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if ( !obj || 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" ) ) {
// IE8,9 Will throw exceptions on certain host objects #9897
// Handle iteration over inherited properties before own properties.
if ( !support.ownFirst ) {
return hasOwn.call( obj, key );
// 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 );
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call( obj ) ] || "object" :
// Workarounds based on findings by Jim Driscoll
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
globalEval: function( data ) {
if ( data && jQuery.trim( data ) ) {
// We use execScript on Internet Explorer
// We use an anonymous function so that context is window
// rather than jQuery in Firefox
( window.execScript || function( data ) {
window[ "eval" ].call( window, data ); // jscs:ignore requireDotNotation
// 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 ) {
// Support: Android<4.1, IE<9
( 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 indexOf.call( arr, elem, i );
i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
// Skip accessing in sparse arrays
if ( i in arr && arr[ i ] === elem ) {
merge: function( first, second ) {
var len = +second.length,
first[ i++ ] = second[ j++ ];
// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
while ( second[ j ] !== undefined ) {
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 );