12 ], function( arr, document, slice, concat, push, indexOf, class2type, toString, hasOwn, support ) {
17 // Define a local copy of jQuery
18 jQuery = function( selector, context ) {
20 // The jQuery object is actually just the init constructor 'enhanced'
21 // Need init if jQuery is called (just allow error to be thrown if not included)
22 return new jQuery.fn.init( selector, context );
25 // Support: Android<4.1
26 // Make sure we trim BOM and NBSP
27 rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
29 // Matches dashed string for camelizing
31 rdashAlpha = /-([\da-z])/gi,
33 // Used by jQuery.camelCase as callback to replace()
34 fcamelCase = function( all, letter ) {
35 return letter.toUpperCase();
38 jQuery.fn = jQuery.prototype = {
40 // The current version of jQuery being used
45 // Start with an empty selector
48 // The default length of a jQuery object is 0
52 return slice.call( this );
55 // Get the Nth element in the matched element set OR
56 // Get the whole matched element set as a clean array
57 get: function( num ) {
60 // Return just the one element from the set
61 ( num < 0 ? this[ num + this.length ] : this[ num ] ) :
63 // Return all the elements in a clean array
67 // Take an array of elements and push it onto the stack
68 // (returning the new matched element set)
69 pushStack: function( elems ) {
71 // Build a new jQuery matched element set
72 var ret = jQuery.merge( this.constructor(), elems );
74 // Add the old object onto the stack (as a reference)
75 ret.prevObject = this;
76 ret.context = this.context;
78 // Return the newly-formed element set
82 // Execute a callback for every element in the matched set.
83 each: function( callback ) {
84 return jQuery.each( this, callback );
87 map: function( callback ) {
88 return this.pushStack( jQuery.map( this, function( elem, i ) {
89 return callback.call( elem, i, elem );
94 return this.pushStack( slice.apply( this, arguments ) );
102 return this.eq( -1 );
106 var len = this.length,
107 j = +i + ( i < 0 ? len : 0 );
108 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
112 return this.prevObject || this.constructor();
115 // For internal use only.
116 // Behaves like an Array's method, not like a jQuery method.
122 jQuery.extend = jQuery.fn.extend = function() {
123 var options, name, src, copy, copyIsArray, clone,
124 target = arguments[ 0 ] || {},
126 length = arguments.length,
129 // Handle a deep copy situation
130 if ( typeof target === "boolean" ) {
133 // Skip the boolean and the target
134 target = arguments[ i ] || {};
138 // Handle case when target is a string or something (possible in deep copy)
139 if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
143 // Extend jQuery itself if only one argument is passed
144 if ( i === length ) {
149 for ( ; i < length; i++ ) {
151 // Only deal with non-null/undefined values
152 if ( ( options = arguments[ i ] ) != null ) {
154 // Extend the base object
155 for ( name in options ) {
156 src = target[ name ];
157 copy = options[ name ];
159 // Prevent never-ending loop
160 if ( target === copy ) {
164 // Recurse if we're merging plain objects or arrays
165 if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
166 ( copyIsArray = jQuery.isArray( copy ) ) ) ) {
170 clone = src && jQuery.isArray( src ) ? src : [];
173 clone = src && jQuery.isPlainObject( src ) ? src : {};
176 // Never move original objects, clone them
177 target[ name ] = jQuery.extend( deep, clone, copy );
179 // Don't bring in undefined values
180 } else if ( copy !== undefined ) {
181 target[ name ] = copy;
187 // Return the modified object
193 // Unique for each copy of jQuery on the page
194 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
196 // Assume jQuery is ready without the ready module
199 error: function( msg ) {
200 throw new Error( msg );
205 isFunction: function( obj ) {
206 return jQuery.type( obj ) === "function";
209 isArray: Array.isArray,
211 isWindow: function( obj ) {
212 return obj != null && obj === obj.window;
215 isNumeric: function( obj ) {
217 // parseFloat NaNs numeric-cast false positives (null|true|false|"")
218 // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
219 // subtraction forces infinities to NaN
220 // adding 1 corrects loss of precision from parseFloat (#15100)
221 var realStringObj = obj && obj.toString();
222 return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;
225 isPlainObject: function( obj ) {
228 // Not plain objects:
229 // - Any object or value whose internal [[Class]] property is not "[object Object]"
232 if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
236 // Not own constructor property must be Object
237 if ( obj.constructor &&
238 !hasOwn.call( obj, "constructor" ) &&
239 !hasOwn.call( obj.constructor.prototype || {}, "isPrototypeOf" ) ) {
243 // Own properties are enumerated firstly, so to speed up,
244 // if last one is own, then all properties are own
245 for ( key in obj ) {}
247 return key === undefined || hasOwn.call( obj, key );
250 isEmptyObject: function( obj ) {
252 for ( name in obj ) {
258 type: function( obj ) {
263 // Support: Android<4.0, iOS<6 (functionish RegExp)
264 return typeof obj === "object" || typeof obj === "function" ?
265 class2type[ toString.call( obj ) ] || "object" :
269 // Evaluates a script in a global context
270 globalEval: function( code ) {
274 code = jQuery.trim( code );
278 // If the code includes a valid, prologue position
279 // strict mode pragma, execute code by injecting a
280 // script tag into the document.
281 if ( code.indexOf( "use strict" ) === 1 ) {
282 script = document.createElement( "script" );
284 document.head.appendChild( script ).parentNode.removeChild( script );
287 // Otherwise, avoid the DOM node creation, insertion
288 // and removal by using an indirect global eval
295 // Convert dashed to camelCase; used by the css and data modules
297 // Microsoft forgot to hump their vendor prefix (#9572)
298 camelCase: function( string ) {
299 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
302 nodeName: function( elem, name ) {
303 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
306 each: function( obj, callback ) {
309 if ( isArrayLike( obj ) ) {
311 for ( ; i < length; i++ ) {
312 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
318 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
327 // Support: Android<4.1
328 trim: function( text ) {
329 return text == null ?
331 ( text + "" ).replace( rtrim, "" );
334 // results is for internal usage only
335 makeArray: function( arr, results ) {
336 var ret = results || [];
339 if ( isArrayLike( Object( arr ) ) ) {
341 typeof arr === "string" ?
345 push.call( ret, arr );
352 inArray: function( elem, arr, i ) {
353 return arr == null ? -1 : indexOf.call( arr, elem, i );
356 merge: function( first, second ) {
357 var len = +second.length,
361 for ( ; j < len; j++ ) {
362 first[ i++ ] = second[ j ];
370 grep: function( elems, callback, invert ) {
374 length = elems.length,
375 callbackExpect = !invert;
377 // Go through the array, only saving the items
378 // that pass the validator function
379 for ( ; i < length; i++ ) {
380 callbackInverse = !callback( elems[ i ], i );
381 if ( callbackInverse !== callbackExpect ) {
382 matches.push( elems[ i ] );
389 // arg is for internal usage only
390 map: function( elems, callback, arg ) {
395 // Go through the array, translating each of the items to their new values
396 if ( isArrayLike( elems ) ) {
397 length = elems.length;
398 for ( ; i < length; i++ ) {
399 value = callback( elems[ i ], i, arg );
401 if ( value != null ) {
406 // Go through every key on the object,
409 value = callback( elems[ i ], i, arg );
411 if ( value != null ) {
417 // Flatten any nested arrays
418 return concat.apply( [], ret );
421 // A global GUID counter for objects
424 // Bind a function to a context, optionally partially applying any
426 proxy: function( fn, context ) {
427 var tmp, args, proxy;
429 if ( typeof context === "string" ) {
435 // Quick check to determine if target is callable, in the spec
436 // this throws a TypeError, but we will just return undefined.
437 if ( !jQuery.isFunction( fn ) ) {
442 args = slice.call( arguments, 2 );
444 return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
447 // Set the guid of unique handler to the same of original handler, so it can be removed
448 proxy.guid = fn.guid = fn.guid || jQuery.guid++;
455 // jQuery.support is not used in Core but other projects attach their
456 // properties to it so it needs to exist.
460 // JSHint would error on this code due to the Symbol not being defined in ES5.
461 // Defining this global in .jshintrc would create a danger of using the global
462 // unguarded in another place, it seems safer to just disable JSHint for these
464 /* jshint ignore: start */
465 if ( typeof Symbol === "function" ) {
466 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
468 /* jshint ignore: end */
470 // Populate the class2type map
471 jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
472 function( i, name ) {
473 class2type[ "[object " + name + "]" ] = name.toLowerCase();
476 function isArrayLike( obj ) {
478 // Support: iOS 8.2 (not reproducible in simulator)
479 // `in` check used to prevent JIT error (gh-2145)
480 // hasOwn isn't used here due to false negatives
481 // regarding Nodelist length in IE
482 var length = !!obj && "length" in obj && obj.length,
483 type = jQuery.type( obj );
485 if ( type === "function" || jQuery.isWindow( obj ) ) {
489 return type === "array" || length === 0 ||
490 typeof length === "number" && length > 0 && ( length - 1 ) in obj;