jquery.js
About this file
Refer to jQuery JS Library for documentation.
Code Check Report
38:50 warning Function has a complexity of 28 complexity
111:10 error Use '===' to compare with null no-eq-null
111:14 error Expected '!==' and instead saw '!=' eqeqeq
175:36 warning Function has a complexity of 21 complexity
205:8 error Use '===' to compare with null no-eq-null
205:35 error Expected '!==' and instead saw '!=' eqeqeq
208:4 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
271:10 error Use '===' to compare with null no-eq-null
271:14 error Expected '!==' and instead saw '!=' eqeqeq
271:29 error Expected '===' and instead saw '==' eqeqeq
286:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
292:17 warning Method 'isPlainObject' has a complexity of 13 complexity
319:4 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
326:22 error Empty block statement no-empty
332:8 error Use '===' to compare with null no-eq-null
332:12 error Expected '===' and instead saw '==' eqeqeq
349:5 error unnecessary '.call()' no-useless-call
387:10 error Use '===' to compare with null no-eq-null
387:15 error Expected '===' and instead saw '==' eqeqeq
396:8 error Use '===' to compare with null no-eq-null
396:12 error Expected '!==' and instead saw '!=' eqeqeq
410:11 warning Method 'inArray' has a complexity of 8 complexity
444:8 error Comparing to itself is potentially pointless no-self-compare
465:23 error Expected return with your callback function callback-return
484:13 error Expected return with your callback function callback-return
486:10 error Use '===' to compare with null no-eq-null
486:16 error Expected '!==' and instead saw '!=' eqeqeq
493:4 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
494:13 error Expected return with your callback function callback-return
496:10 error Use '===' to compare with null no-eq-null
496:16 error Expected '!==' and instead saw '!=' eqeqeq
563:1 warning Function 'isArrayLike' has a complexity of 9 complexity
590:1 error Move the invocation into the parens that contain the function wrap-iife
590:2 warning Function has a complexity of 9 complexity
726:10 error Comparing to itself is potentially pointless no-self-compare
751:2 error Expected an assignment or function call and instead saw an expression no-unused-expressions
766:39 error Empty block statement no-empty
772:1 warning Function 'Sizzle' has a complexity of 43 complexity
891:27 error Empty block statement no-empty
976:1 warning Function 'siblingCheck' has a complexity of 12 complexity
1072:36 warning Function has a complexity of 24 complexity
1315:3 warning Function has a complexity of 8 complexity
1340:2 warning Function has a complexity of 17 complexity
1381:2 warning Function has a complexity of 16 complexity
1442:26 warning Function has a complexity of 15 complexity
1466:15 error Empty block statement no-empty
1480:15 warning Function has a complexity of 10 complexity
1542:28 warning Function has a complexity of 10 complexity
1607:12 warning Method 'CHILD' has a complexity of 8 complexity
1639:13 warning Method 'PSEUDO' has a complexity of 10 complexity
1690:11 warning Function has a complexity of 14 complexity
1693:10 error Use '===' to compare with null no-eq-null
1693:17 error Expected '===' and instead saw '==' eqeqeq
1725:5 warning Function has a complexity of 49 complexity
1938:11 warning Function has a complexity of 7 complexity
1987:5 error Expected an assignment or function call and instead saw an expression no-unused-expressions
2032:7 error Use '===' to compare with null no-eq-null
2032:40 error Expected '===' and instead saw '==' eqeqeq
2085:1 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
2088:1 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
2097:30 warning Function has a complexity of 16 complexity
2190:3 warning Function has a complexity of 15 complexity
2260:12 error Use '===' to compare with null no-eq-null
2260:16 error Expected '!==' and instead saw '!=' eqeqeq
2283:22 warning Function has a complexity of 28 complexity
2369:1 warning Function 'matcherFromTokens' has a complexity of 14 complexity
2430:18 warning Function has a complexity of 36 complexity
2440:33 error Use '===' to compare with null no-eq-null
2440:47 error Expected '===' and instead saw '==' eqeqeq
2450:25 error Use '===' to compare with null no-eq-null
2450:41 error Expected '!==' and instead saw '!=' eqeqeq
2577:26 warning Function has a complexity of 28 complexity
2698:9 error Use '===' to compare with null no-eq-null
2698:38 error Expected '===' and instead saw '==' eqeqeq
2866:26 warning Function has a complexity of 29 complexity
3013:11 warning Method 'closest' has a complexity of 12 complexity
3072:20 error Use '===' to compare with null no-eq-null
3072:29 error Expected '===' and instead saw '==' eqeqeq
3127:22 warning Function has a complexity of 7 complexity
3219:10 warning Function has a complexity of 8 complexity
3276:6 error Move the invocation into the parens that contain the function wrap-iife
3277:26 warning Function has a complexity of 7 complexity
3432:13 error Use '===' to compare with null no-eq-null
3432:17 error Expected '!==' and instead saw '!=' eqeqeq
3480:8 warning Method 'when' has a complexity of 10 complexity
3621:24 warning Function has a complexity of 10 complexity
3659:11 error Use '===' to compare with null no-eq-null
3659:31 error Expected '===' and instead saw '==' eqeqeq
3660:18 error Empty block statement no-empty
3663:5 error Move the invocation into the parens that contain the function wrap-iife
3697:1 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
3747:1 error Move the invocation into the parens that contain the function wrap-iife
3779:1 warning Function 'dataAttr' has a complexity of 10 complexity
3799:18 error Empty block statement no-empty
3829:1 warning Function 'internalData' has a complexity of 24 complexity
3909:8 error Use '===' to compare with null no-eq-null
3909:12 error Expected '===' and instead saw '==' eqeqeq
3921:1 warning Function 'internalRemoveData' has a complexity of 19 complexity
4002:45 error Expected '!==' and instead saw '!=' eqeqeq
4049:8 warning Method 'data' has a complexity of 12 complexity
4111:9 warning Method 'queue' has a complexity of 7 complexity
4130:11 warning Method 'dequeue' has a complexity of 7 complexity
4247:1 error Move the invocation into the parens that contain the function wrap-iife
4251:8 error Use '===' to compare with null no-eq-null
4251:28 error Expected '!==' and instead saw '!=' eqeqeq
4314:1 warning Function 'adjustCSS' has a complexity of 22 complexity
4375:14 warning Function has a complexity of 13 complexity
4378:10 error Use '===' to compare with null no-eq-null
4378:14 error Expected '===' and instead saw '==' eqeqeq
4383:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
4459:1 error Move the invocation into the parens that contain the function wrap-iife
4548:1 warning Function 'getAll' has a complexity of 13 complexity
4559:4 error Use '===' to compare with null no-eq-null
4559:24 error Expected '!==' and instead saw '!=' eqeqeq
4580:10 error Use '===' to compare with null no-eq-null
4580:30 error Expected '!==' and instead saw '!=' eqeqeq
4599:1 warning Function 'buildFragment' has a complexity of 34 complexity
4732:1 error Move the invocation into the parens that contain the function wrap-iife
4737:2 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
4772:18 error Empty block statement no-empty
4775:1 warning Function 'on' has a complexity of 13 complexity
4788:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
4794:7 error Use '===' to compare with null no-eq-null
4794:12 error Expected '===' and instead saw '==' eqeqeq
4794:23 error Use '===' to compare with null no-eq-null
4794:26 error Expected '===' and instead saw '==' eqeqeq
4799:14 error Use '===' to compare with null no-eq-null
4799:17 error Expected '===' and instead saw '==' eqeqeq
4844:7 warning Method 'add' has a complexity of 25 complexity
4964:10 warning Method 'remove' has a complexity of 34 complexity
4985:5 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
5041:11 warning Method 'trigger' has a complexity of 53 complexity
5088:10 error Use '===' to compare with null no-eq-null
5088:15 error Expected '===' and instead saw '==' eqeqeq
5186:12 warning Method 'dispatch' has a complexity of 17 complexity
5246:12 warning Method 'handlers' has a complexity of 17 complexity
5262:16 error Expected '!==' and instead saw '!=' eqeqeq
5299:7 warning Method 'fix' has a complexity of 11 complexity
5356:9 error Use '===' to compare with null no-eq-null
5356:21 error Expected '===' and instead saw '==' eqeqeq
5357:19 error Use '===' to compare with null no-eq-null
5357:37 error Expected '!==' and instead saw '!=' eqeqeq
5367:11 warning Method 'filter' has a complexity of 28 complexity
5373:9 error Use '===' to compare with null no-eq-null
5373:21 error Expected '===' and instead saw '==' eqeqeq
5373:32 error Use '===' to compare with null no-eq-null
5373:49 error Expected '!==' and instead saw '!=' eqeqeq
5516:16 warning Function has a complexity of 10 complexity
5821:7 warning Method 'off' has a complexity of 10 complexity
5839:4 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
5914:1 warning Function 'cloneCopyEvent' has a complexity of 7 complexity
5928:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
5941:1 warning Function 'fixCloneNodeIssues' has a complexity of 18 complexity
5955:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
6009:1 warning Function 'domManip' has a complexity of 24 complexity
6106:1 warning Function 'remove' has a complexity of 8 complexity
6111:10 error Use '===' to compare with null no-eq-null
6111:30 error Expected '!==' and instead saw '!=' eqeqeq
6133:9 warning Method 'clone' has a complexity of 18 complexity
6156:17 error Use '===' to compare with null no-eq-null
6156:43 error Expected '!==' and instead saw '!=' eqeqeq
6171:18 error Use '===' to compare with null no-eq-null
6171:44 error Expected '!==' and instead saw '!=' eqeqeq
6191:13 warning Method 'cleanData' has a complexity of 12 complexity
6199:11 error Use '===' to compare with null no-eq-null
6199:31 error Expected '!==' and instead saw '!=' eqeqeq
6306:11 error Use '===' to compare with null no-eq-null
6306:30 error Expected '!==' and instead saw '!=' eqeqeq
6329:19 error Use '===' to compare with null no-eq-null
6329:33 error Expected '===' and instead saw '==' eqeqeq
6330:23 error Use '===' to compare with null no-eq-null
6330:41 error Expected '===' and instead saw '==' eqeqeq
6338:24 warning Function has a complexity of 17 complexity
6371:19 error Empty block statement no-empty
6498:2 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
6506:2 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
6518:1 error Move the invocation into the parens that contain the function wrap-iife
6556:9 error Use '===' to compare with null no-eq-null
6556:26 error Expected '===' and instead saw '==' eqeqeq
6566:9 error Use '===' to compare with null no-eq-null
6566:26 error Expected '===' and instead saw '==' eqeqeq
6575:9 error Use '===' to compare with null no-eq-null
6575:26 error Expected '===' and instead saw '==' eqeqeq
6582:9 error Use '===' to compare with null no-eq-null
6582:26 error Expected '===' and instead saw '==' eqeqeq
6591:9 error Use '===' to compare with null no-eq-null
6591:26 error Expected '===' and instead saw '==' eqeqeq
6600:9 error Use '===' to compare with null no-eq-null
6600:26 error Expected '===' and instead saw '==' eqeqeq
6607:2 warning Function 'computeStyleTests' has a complexity of 9 complexity
6711:11 warning Function has a complexity of 12 complexity
6765:11 warning Function has a complexity of 14 complexity
6774:8 error Use '===' to compare with null no-eq-null
6774:12 error Expected '===' and instead saw '==' eqeqeq
6881:1 warning Function 'showHide' has a complexity of 19 complexity
6947:1 warning Function 'augmentWidthOrHeight' has a complexity of 10 complexity
6991:1 warning Function 'getWidthOrHeight' has a complexity of 13 complexity
7003:19 error Use '===' to compare with null no-eq-null
7003:23 error Expected '===' and instead saw '==' eqeqeq
7007:19 error Use '===' to compare with null no-eq-null
7007:23 error Expected '===' and instead saw '==' eqeqeq
7080:9 warning Method 'style' has a complexity of 28 complexity
7112:9 error Use '===' to compare with null no-eq-null
7112:15 error Expected '===' and instead saw '==' eqeqeq
7112:26 error Comparing to itself is potentially pointless no-self-compare
7136:19 error Empty block statement no-empty
7153:7 warning Method 'css' has a complexity of 14 complexity
7233:8 warning Method 'set' has a complexity of 13 complexity
7433:5 error Use '===' to compare with null no-eq-null
7433:30 error Expected '!==' and instead saw '!=' eqeqeq
7433:41 error Use '===' to compare with null no-eq-null
7433:72 error Expected '===' and instead saw '==' eqeqeq
7453:7 error Use '===' to compare with null no-eq-null
7453:57 error Expected '!==' and instead saw '!=' eqeqeq
7540:1 warning Function 'defaultPrefilter' has a complexity of 38 complexity
7552:8 error Use '===' to compare with null no-eq-null
7552:23 error Expected '===' and instead saw '==' eqeqeq
7617:2 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
7663:4 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
7667:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
7685:1 warning Function 'propFilter' has a complexity of 8 complexity
7689:2 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
7732:10 warning Function has a complexity of 7 complexity
7878:16 warning Function has a complexity of 16 complexity
7891:7 error Use '===' to compare with null no-eq-null
7891:17 error Expected '===' and instead saw '==' eqeqeq
7955:21 warning Function has a complexity of 15 complexity
7957:13 error Use '===' to compare with null no-eq-null
7957:18 error Expected '!==' and instead saw '!=' eqeqeq
7975:8 error Use '===' to compare with null no-eq-null
7975:13 error Expected '===' and instead saw '==' eqeqeq
7995:21 warning Function has a complexity of 10 complexity
8037:10 error Use '===' to compare with null no-eq-null
8037:16 error Expected '===' and instead saw '==' eqeqeq
8126:1 error Move the invocation into the parens that contain the function wrap-iife
8193:7 warning Method 'val' has a complexity of 9 complexity
8218:6 error Use '===' to compare with null no-eq-null
8218:10 error Expected '===' and instead saw '==' eqeqeq
8226:21 warning Function has a complexity of 10 complexity
8240:9 error Use '===' to compare with null no-eq-null
8240:13 error Expected '===' and instead saw '==' eqeqeq
8246:13 error Use '===' to compare with null no-eq-null
8246:19 error Expected '===' and instead saw '==' eqeqeq
8265:12 error Use '===' to compare with null no-eq-null
8265:16 error Expected '!==' and instead saw '!=' eqeqeq
8276:9 warning Method 'get' has a complexity of 14 complexity
8338:8 error Expected an assignment or function call and instead saw an expression no-unused-expressions
8395:8 warning Method 'attr' has a complexity of 18 complexity
8439:10 error Use '===' to compare with null no-eq-null
8439:14 error Expected '===' and instead saw '==' eqeqeq
8461:14 warning Method 'removeAttr' has a complexity of 11 complexity
8497:7 warning Method 'set' has a complexity of 7 complexity
8528:11 error Use '===' to compare with null no-eq-null
8528:39 error Expected '!==' and instead saw '!=' eqeqeq
8666:18 error Empty block statement no-empty
8672:8 warning Method 'prop' has a complexity of 14 complexity
8756:5 error Expected an assignment or function call and instead saw an expression no-unused-expressions
8760:6 error Expected an assignment or function call and instead saw an expression no-unused-expressions
8768:5 error Expected an assignment or function call and instead saw an expression no-unused-expressions
8771:6 error Expected an assignment or function call and instead saw an expression no-unused-expressions
8808:12 warning Method 'addClass' has a complexity of 11 complexity
8846:15 warning Method 'removeClass' has a complexity of 12 complexity
8908:21 warning Function has a complexity of 11 complexity
9044:5 error The Function constructor is eval no-new-func
9050:19 warning Function has a complexity of 8 complexity
9118:9 warning Function has a complexity of 9 complexity
9178:1 warning Function 'ajaxExtend' has a complexity of 7 complexity
9198:1 warning Function 'ajaxHandleResponses' has a complexity of 16 complexity
9227:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
9255:1 warning Function 'ajaxConvert' has a complexity of 25 complexity
9264:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
9301:6 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
9444:8 warning Method 'ajax' has a complexity of 58 complexity
9525:13 error Use '===' to compare with null no-eq-null
9525:19 error Expected '===' and instead saw '==' eqeqeq
9556:8 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
9601:8 error Use '===' to compare with null no-eq-null
9601:22 error Expected '===' and instead saw '==' eqeqeq
9690:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
9706:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
9753:3 warning Function 'done' has a complexity of 25 complexity
9989:1 warning Function 'filterHidden' has a complexity of 7 complexity
10043:48 error Use '===' to compare with null no-eq-null
10043:50 error Expected '!==' and instead saw '!=' eqeqeq
10054:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
10067:16 warning Function has a complexity of 7 complexity
10073:53 error Use '===' to compare with null no-eq-null
10073:59 error Expected '===' and instead saw '==' eqeqeq
10094:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
10125:11 error Use '===' to compare with null no-eq-null
10125:15 error Expected '===' and instead saw '==' eqeqeq
10181:3 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
10202:11 warning Method 'send' has a complexity of 13 complexity
10218:7 error The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype guard-for-in
10257:17 warning Function has a complexity of 14 complexity
10321:7 error Expected return with your callback function callback-return
10337:7 error Expected return with your callback function callback-return
10349:16 error Empty block statement no-empty
10355:16 error Empty block statement no-empty
10430:8 error Expected return with your callback function callback-return
10466:37 warning Function has a complexity of 13 complexity
10551:20 warning Function has a complexity of 9 complexity
10585:18 warning Function has a complexity of 10 complexity
10691:13 warning Method 'setOffset' has a complexity of 11 complexity
10725:8 error Use '===' to compare with null no-eq-null
10725:20 error Expected '!==' and instead saw '!=' eqeqeq
10728:8 error Use '===' to compare with null no-eq-null
10728:21 error Expected '!==' and instead saw '!=' eqeqeq
10741:10 warning Method 'offset' has a complexity of 11 complexity
10836:24 warning Function has a complexity of 7 complexity
10885:27 warning Function has a complexity of 7 complexity
✖ 311 problems (208 errors, 103 warnings)
9 errors and 0 warnings potentially fixable with the `--fix` option.
Documentation drawn from source code
/*!
* jQuery JavaScript Library v1.12.4
*
* Includes Sizzle.js
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license
*
* Date: 2016-05-20T17:17Z
*/
(function( global, factory ) {
function( w ) {
}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
jQuery = function( selector, context ) {
fcamelCase = function( all, letter ) {
toArray: function() {
get: function( num ) {
pushStack: function( elems ) {
each: function( callback ) {
map: function( callback ) {
return this.pushStack( jQuery.map( this, function( elem, i ) {
slice: function() {
first: function() {
last: function() {
eq: function( i ) {
end: function() {
jQuery.extend = jQuery.fn.extend = function() {
error: function( msg ) {
noop: function() {},
isFunction: function( obj ) {
return jQuery.type( obj ) === "function";
isArray: Array.isArray || function( obj ) {
isWindow: function( obj ) {
/* jshint eqeqeq: false */
isNumeric: function( obj ) {
isEmptyObject: function( obj ) {
isPlainObject: function( obj ) {
type: function( obj ) {
return typeof obj === "object" || typeof obj === "function" ?
globalEval: function( data ) {
( window.execScript || function( data ) {
camelCase: function( string ) {
nodeName: function( elem, name ) {
each: function( obj, callback ) {
trim: function( text ) {
makeArray: function( arr, results ) {
inArray: function( elem, arr, i ) {
merge: function( first, second ) {
grep: function( elems, callback, invert ) {
map: function( elems, callback, arg ) {
proxy: function( fn, context ) {
proxy = function() {
now: function() {
/* jshint ignore: start */
if ( typeof Symbol === "function" ) {
/* jshint ignore: end */
function( i, name ) {
function isArrayLike( obj ) {
if ( type === "function" || jQuery.isWindow( obj ) ) {
/*!
* Sizzle CSS Selector Engine v2.2.1
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license
*
* Date: 2015-10-17
*/
(function( window ) {
sortOrder = function( a, b ) {
indexOf = function( list, elem ) {
funescape = function( _, escaped, escapedWhitespace ) {
unloadHandler = function() {
function( target, els ) {
function( target, els ) {
function Sizzle( selector, 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() {
function cache( key, value ) {
/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/
function markFunction( fn ) {
/**
* Support testing using an element
* @param {Function} fn Passed the created div and expects a boolean result
*/
function assert( fn ) {
/**
* 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 ) {
/**
* 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 ) {
/**
* Returns a function to use in pseudos for input types
* @param {String} type
*/
function createInputPseudo( type ) {
return function( elem ) {
/**
* Returns a function to use in pseudos for buttons
* @param {String} type
*/
function createButtonPseudo( type ) {
return function( elem ) {
/**
* Returns a function to use in pseudos for positionals
* @param {Function} fn
*/
function createPositionalPseudo( fn ) {
return markFunction(function( argument ) {
return markFunction(function( seed, matches ) {
/**
* 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 ) {
/**
* 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 ) {
/**
* 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 ) {
/* Attributes
---------------------------------------------------------------------- */
support.attributes = assert(function( div ) {
/* getElement(s)By*
---------------------------------------------------------------------- */
support.getElementsByTagName = assert(function( div ) {
support.getById = assert(function( div ) {
Expr.find["ID"] = function( id, context ) {
Expr.filter["ID"] = function( id ) {
return function( elem ) {
Expr.filter["ID"] = function( id ) {
return function( elem ) {
function( tag, context ) {
function( tag, context ) {
Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
/* QSA/matchesSelector
---------------------------------------------------------------------- */
assert(function( div ) {
assert(function( div ) {
assert(function( div ) {
/* Contains
---------------------------------------------------------------------- */
function( a, b ) {
function( a, b ) {
/* Sorting
---------------------------------------------------------------------- */
function( a, b ) {
function( a, b ) {
Sizzle.matches = function( expr, elements ) {
Sizzle.matchesSelector = function( elem, expr ) {
Sizzle.contains = function( context, elem ) {
Sizzle.attr = function( elem, name ) {
Sizzle.error = function( msg ) {
/**
* Document sorting and removing duplicates
* @param {ArrayLike} results
*/
Sizzle.uniqueSort = function( results ) {
/**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/
getText = Sizzle.getText = function( elem ) {
"ATTR": function( match ) {
"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
*/
"PSEUDO": function( match ) {
"TAG": function( nodeNameSelector ) {
function() { return true; } :
function( elem ) {
"CLASS": function( className ) {
classCache( className, function( elem ) {
"ATTR": function( name, operator, check ) {
return function( elem ) {
"CHILD": function( type, what, argument, first, last ) {
function( elem ) {
function( elem, context, xml ) {
"PSEUDO": function( pseudo, argument ) {
markFunction(function( seed, matches ) {
function( elem ) {
"not": markFunction(function( selector ) {
markFunction(function( seed, matches, context, xml ) {
function( elem, context, xml ) {
"has": markFunction(function( selector ) {
return function( elem ) {
"contains": markFunction(function( text ) {
return function( elem ) {
"lang": markFunction( function( lang ) {
return function( elem ) {
"target": function( elem ) {
"root": function( elem ) {
"focus": function( elem ) {
"enabled": function( elem ) {
"disabled": function( elem ) {
"checked": function( elem ) {
"selected": function( elem ) {
"empty": function( elem ) {
"parent": function( elem ) {
"header": function( elem ) {
"input": function( elem ) {
"button": function( elem ) {
"text": function( elem ) {
"first": createPositionalPseudo(function() {
"last": createPositionalPseudo(function( matchIndexes, length ) {
"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
"even": createPositionalPseudo(function( matchIndexes, length ) {
"odd": createPositionalPseudo(function( matchIndexes, length ) {
"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
function setFilters() {}
tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
function toSelector( tokens ) {
function addCombinator( matcher, combinator, base ) {
function( elem, context, xml ) {
function( elem, context, xml ) {
function elementMatcher( matchers ) {
function( elem, context, xml ) {
function multipleContexts( selector, contexts, results ) {
function condense( unmatched, map, filter, context, xml ) {
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
return markFunction(function( seed, results, context, xml ) {
function matcherFromTokens( tokens ) {
matchContext = addCombinator( function( elem ) {
matchAnyContext = addCombinator( function( elem ) {
matchers = [ function( elem, context, xml ) {
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
superMatcher = function( seed, context, xml, results, outermost ) {
compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
/**
* 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 ) {
compiled = typeof selector === "function" && selector,
support.sortDetached = assert(function( div1 ) {
if ( !assert(function( div ) {
addHandle( "type|href|height|width", function( elem, name, isXML ) {
if ( !support.attributes || !assert(function( div ) {
addHandle( "value", function( elem, name, isXML ) {
if ( !assert(function( div ) {
addHandle( booleans, function( elem, name, isXML ) {
var dir = function( elem, dir, until ) {
var siblings = function( n, elem ) {
function winnow( elements, qualifier, not ) {
return jQuery.grep( elements, function( elem, i ) {
/* jshint -W018 */
return jQuery.grep( elements, function( elem ) {
return jQuery.grep( elements, function( elem ) {
jQuery.filter = function( expr, elems, not ) {
jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
find: function( selector ) {
return this.pushStack( jQuery( selector ).filter( function() {
filter: function( selector ) {
not: function( selector ) {
is: function( selector ) {
init = jQuery.fn.init = function( selector, context, root ) {
has: function( target ) {
return this.filter( function() {
closest: function( selectors, context ) {
index: function( elem ) {
add: function( selector, context ) {
addBack: function( selector ) {
function sibling( cur, dir ) {
parent: function( elem ) {
parents: function( elem ) {
parentsUntil: function( elem, i, until ) {
next: function( elem ) {
prev: function( elem ) {
nextAll: function( elem ) {
prevAll: function( elem ) {
nextUntil: function( elem, i, until ) {
prevUntil: function( elem, i, until ) {
siblings: function( elem ) {
children: function( elem ) {
contents: function( elem ) {
}, function( name, fn ) {
jQuery.fn[ name ] = function( until, selector ) {
function createOptions( options ) {
jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
/*
* 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 ) {
fire = function() {
add: function() {
( function add( args ) {
jQuery.each( args, function( _, arg ) {
remove: function() {
jQuery.each( arguments, function( _, arg ) {
has: function( fn ) {
empty: function() {
disable: function() {
disabled: function() {
lock: function() {
locked: function() {
fireWith: function( context, args ) {
fire: function() {
fired: function() {
Deferred: function( func ) {
state: function() {
always: function() {
then: function( /* fnDone, fnFail, fnProgress */ ) {
return jQuery.Deferred( function( newDefer ) {
jQuery.each( tuples, function( i, tuple ) {
deferred[ tuple[ 1 ] ]( function() {
promise: function( obj ) {
jQuery.each( tuples, function( i, tuple ) {
list.add( function() {
deferred[ tuple[ 0 ] ] = function() {
when: function( subordinate /* , ..., subordinateN */ ) {
updateFunc = function( i, contexts, values ) {
return function( value ) {
jQuery.fn.ready = function( fn ) {
holdReady: function( hold ) {
ready: function( wait ) {
/**
* Clean-up method for dom ready events
*/
function detach() {
/**
* The ready event handler and self cleanup method
*/
function completed() {
jQuery.ready.promise = function( obj ) {
( function doScrollCheck() {
jQuery( function() {
( function() {
var acceptData = function( elem ) {
function dataAttr( elem, key, data ) {
function isEmptyDataObject( obj ) {
function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
if ( typeof name === "object" || typeof name === "function" ) {
function internalRemoveData( elem, name, pvt ) {
/* jshint eqeqeq: false */
/* jshint eqeqeq: true */
hasData: function( elem ) {
data: function( elem, name, data ) {
removeData: function( elem, name ) {
_data: function( elem, name, data ) {
_removeData: function( elem, name ) {
data: function( key, value ) {
return this.each( function() {
this.each( function() {
removeData: function( key ) {
return this.each( function() {
queue: function( elem, type, data ) {
dequeue: function( elem, type ) {
next = function() {
_queueHooks: function( elem, type ) {
empty: jQuery.Callbacks( "once memory" ).add( function() {
queue: function( type, data ) {
this.each( function() {
dequeue: function( type ) {
return this.each( function() {
clearQueue: function( type ) {
promise: function( type, obj ) {
resolve = function() {
( function() {
support.shrinkWrapBlocks = function() {
var isHidden = function( elem, el ) {
function adjustCSS( elem, prop, valueParts, tween ) {
function() { return tween.cur(); } :
function() { return jQuery.css( elem, prop, "" ); },
var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
fn = function( elem, key, value ) {
function createSafeFragment( document ) {
( function() {
function getAll( context, tag ) {
function setGlobalEval( elems, refElements ) {
function fixDefaultChecked( elem ) {
function buildFragment( elems, context, scripts, selection, ignored ) {
( function() {
function returnTrue() {
function returnFalse() {
function safeActiveElement() {
function on( elem, types, selector, data, fn, one ) {
fn = function( event ) {
return elem.each( function() {
/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/
add: function( elem, types, handler, data, selector ) {
eventHandle = elemData.handle = function( e ) {
remove: function( elem, types, handler, selector, mappedTypes ) {
trigger: function( event, data, elem, onlyHandlers ) {
dispatch: function( event ) {
handlers: function( event, handlers ) {
/* jshint eqeqeq: false */
/* jshint eqeqeq: true */
fix: function( event ) {
filter: function( event, original ) {
filter: function( event, original ) {
trigger: function() {
trigger: function() {
trigger: function() {
_default: function( event ) {
postDispatch: function( event ) {
simulate: function( type, elem, event ) {
function( elem, type, handle ) {
function( elem, type, handle ) {
jQuery.Event = function( src, props ) {
preventDefault: function() {
stopPropagation: function() {
stopImmediatePropagation: function() {
}, function( orig, fix ) {
handle: function( event ) {
setup: function() {
jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
jQuery.event.add( form, "submit._submit", function( event ) {
postDispatch: function( event ) {
teardown: function() {
setup: function() {
jQuery.event.add( this, "propertychange._change", function( event ) {
jQuery.event.add( this, "click._change", function( event ) {
jQuery.event.add( this, "beforeactivate._change", function( e ) {
jQuery.event.add( elem, "change._change", function( event ) {
handle: function( event ) {
teardown: function() {
jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
var handler = function( event ) {
setup: function() {
teardown: function() {
on: function( types, selector, data, fn ) {
one: function( types, selector, data, fn ) {
off: function( types, selector, fn ) {
if ( selector === false || typeof selector === "function" ) {
return this.each( function() {
trigger: function( type, data ) {
return this.each( function() {
triggerHandler: function( type, data ) {
function manipulationTarget( elem, content ) {
function disableScript( elem ) {
function restoreScript( elem ) {
function cloneCopyEvent( src, dest ) {
function fixCloneNodeIssues( src, dest ) {
function domManip( collection, args, callback, ignored ) {
return collection.each( function( index ) {
function remove( elem, selector, keepData ) {
htmlPrefilter: function( html ) {
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
cleanData: function( elems, /* internal */ forceAcceptData ) {
detach: function( selector ) {
remove: function( selector ) {
text: function( value ) {
return access( this, function( value ) {
append: function() {
return domManip( this, arguments, function( elem ) {
prepend: function() {
return domManip( this, arguments, function( elem ) {
before: function() {
return domManip( this, arguments, function( elem ) {
after: function() {
return domManip( this, arguments, function( elem ) {
empty: function() {
clone: function( dataAndEvents, deepDataAndEvents ) {
return this.map( function() {
html: function( value ) {
return access( this, function( value ) {
replaceWith: function() {
return domManip( this, arguments, function( elem ) {
}, function( name, original ) {
jQuery.fn[ name ] = function( selector ) {
/**
* Retrieve the actual display of a element
* @param {String} name nodeName of the element
* @param {Object} doc Document object
*/
function actualDisplay( name, doc ) {
/**
* Try to determine the default display value of an element
* @param {String} nodeName
*/
function defaultDisplay( nodeName ) {
var swap = function( elem, options, callback, args ) {
( function() {
reliableHiddenOffsets: function() {
boxSizingReliable: function() {
pixelMarginRight: function() {
pixelPosition: function() {
reliableMarginRight: function() {
reliableMarginLeft: function() {
function computeStyleTests() {
getStyles = function( elem ) {
curCSS = function( elem, name, computed ) {
getStyles = function( elem ) {
curCSS = function( elem, name, computed ) {
function addGetHookIf( conditionFn, hookFn ) {
get: function() {
function vendorPropName( name ) {
function showHide( elements, show ) {
function setPositiveNumber( elem, value, subtract ) {
function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
function getWidthOrHeight( elem, name, extra ) {
get: function( elem, computed ) {
style: function( elem, name, value, extra ) {
css: function( elem, name, extra, styles ) {
jQuery.each( [ "height", "width" ], function( i, name ) {
get: function( elem, computed, extra ) {
swap( elem, cssShow, function() {
set: function( elem, value, extra ) {
get: function( elem, computed ) {
set: function( elem, value ) {
function( elem, computed ) {
function( elem, computed ) {
swap( elem, { marginLeft: 0 }, function() {
}, function( prefix, suffix ) {
expand: function( value ) {
css: function( name, value ) {
return access( this, function( elem, name, value ) {
show: function() {
hide: function() {
toggle: function( state ) {
return this.each( function() {
function Tween( elem, options, prop, end, easing ) {
init: function( elem, options, prop, end, easing, unit ) {
cur: function() {
run: function( percent ) {
get: function( tween ) {
set: function( tween ) {
set: function( tween ) {
linear: function( p ) {
swing: function( p ) {
function createFxNow() {
window.setTimeout( function() {
function genFx( type, includeWidth ) {
function createTween( value, prop, animation ) {
function defaultPrefilter( elem, props, opts ) {
/* jshint validthis: true */
hooks.empty.fire = function() {
anim.always( function() {
anim.always( function() {
anim.always( function() {
anim.done( function() {
anim.done( function() {
function propFilter( props, specialEasing ) {
function Animation( elem, properties, options ) {
deferred = jQuery.Deferred().always( function() {
tick = function() {
createTween: function( prop, end ) {
stop: function( gotoEnd ) {
"*": [ function( prop, value ) {
tweener: function( props, callback ) {
prefilter: function( callback, prepend ) {
jQuery.speed = function( speed, easing, fn ) {
opt.complete = function() {
fadeTo: function( speed, to, easing, callback ) {
animate: function( prop, speed, easing, callback ) {
doAnimation = function() {
stop: function( type, clearQueue, gotoEnd ) {
var stopQueue = function( hooks ) {
return this.each( function() {
finish: function( type ) {
return this.each( function() {
jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
jQuery.fn[ name ] = function( speed, easing, callback ) {
}, function( name, props ) {
jQuery.fn[ name ] = function( speed, easing, callback ) {
jQuery.fx.tick = function() {
jQuery.fx.timer = function( timer ) {
jQuery.fx.start = function() {
jQuery.fx.stop = function() {
jQuery.fn.delay = function( time, type ) {
return this.queue( type, function( next, hooks ) {
hooks.stop = function() {
( function() {
val: function( value ) {
return this.each( function( i ) {
val = jQuery.map( val, function( value ) {
get: function( elem ) {
get: function( elem ) {
set: function( elem, value ) {
jQuery.each( [ "radio", "checkbox" ], function() {
set: function( elem, value ) {
jQuery.valHooks[ this ].get = function( elem ) {
attr: function( name, value ) {
removeAttr: function( name ) {
return this.each( function() {
attr: function( elem, name, value ) {
set: function( elem, value ) {
removeAttr: function( elem, value ) {
set: function( elem, value, name ) {
jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
attrHandle[ name ] = function( elem, name, isXML ) {
attrHandle[ name ] = function( elem, name, isXML ) {
set: function( elem, value, name ) {
set: function( elem, value, name ) {
function( elem, name, isXML ) {
get: function( elem, name ) {
set: function( elem, value, name ) {
jQuery.each( [ "width", "height" ], function( i, name ) {
set: function( elem, value ) {
get: function( elem ) {
set: function( elem, value ) {
prop: function( name, value ) {
removeProp: function( name ) {
return this.each( function() {
prop: function( elem, name, value ) {
get: function( elem ) {
jQuery.each( [ "href", "src" ], function( i, name ) {
get: function( elem ) {
get: function( elem ) {
set: function( elem ) {
], function() {
function getClass( elem ) {
addClass: function( value ) {
return this.each( function( j ) {
removeClass: function( value ) {
return this.each( function( j ) {
toggleClass: function( value, stateVal ) {
return this.each( function( i ) {
return this.each( function() {
hasClass: function( selector ) {
function( i, name ) {
jQuery.fn[ name ] = function( data, fn ) {
hover: function( fnOver, fnOut ) {
jQuery.parseJSON = function( data ) {
return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {
jQuery.parseXML = function( data ) {
/* 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
*/
/* 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
*/
function addToPrefiltersOrTransports( structure ) {
return function( dataTypeExpression, func ) {
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
function inspect( dataType ) {
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
function ajaxExtend( target, src ) {
/* 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 ) {
/* Chain conversions given the request and the original response
* Also sets the responseXXX fields on the jqXHR instance
*/
function ajaxConvert( s, response, jqXHR, isSuccess ) {
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false,
traditional: false,
headers: {},
*/
ajaxSetup: function( target, settings ) {
ajax: function( url, options ) {
getResponseHeader: function( key ) {
getAllResponseHeaders: function() {
setRequestHeader: function( name, value ) {
overrideMimeType: function( type ) {
statusCode: function( map ) {
abort: function( statusText ) {
timeoutTimer = window.setTimeout( function() {
function done( status, nativeStatusText, responses, headers ) {
getJSON: function( url, data, callback ) {
getScript: function( url, callback ) {
jQuery.each( [ "get", "post" ], function( i, method ) {
jQuery[ method ] = function( url, data, callback, type ) {
jQuery._evalUrl = function( url ) {
wrapAll: function( html ) {
return this.each( function( i ) {
wrap.map( function() {
wrapInner: function( html ) {
return this.each( function( i ) {
return this.each( function() {
wrap: function( html ) {
return this.each( function( i ) {
unwrap: function() {
return this.parent().each( function() {
function getDisplay( elem ) {
function filterHidden( elem ) {
jQuery.expr.filters.hidden = function( elem ) {
jQuery.expr.filters.visible = function( elem ) {
function buildParams( prefix, obj, traditional, add ) {
jQuery.each( obj, function( i, v ) {
jQuery.param = function( a, traditional ) {
add = function( key, value ) {
jQuery.each( a, function() {
serialize: function() {
serializeArray: function() {
return this.map( function() {
.filter( function() {
.map( function( i, elem ) {
jQuery.map( val, function( val ) {
function() {
window.attachEvent( "onunload", function() {
jQuery.ajaxTransport( function( options ) {
send: function( headers, complete ) {
callback = function( _, isAbort ) {
abort: function() {
function createStandardXHR() {
function createActiveXHR() {
"text script": function( text ) {
jQuery.ajaxPrefilter( "script", function( s ) {
jQuery.ajaxTransport( "script", function( s ) {
send: function( _, callback ) {
script.onload = script.onreadystatechange = function( _, isAbort ) {
abort: function() {
jsonpCallback: function() {
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
s.converters[ "script json" ] = function() {
window[ callbackName ] = function() {
jqXHR.always( function() {
jQuery.parseHTML = function( data, context, keepScripts ) {
/**
* Load a url into a page
*/
jQuery.fn.load = function( url, params, callback ) {
} ).done( function( responseText ) {
} ).always( callback && function( jqXHR, status ) {
self.each( function() {
], function( i, type ) {
jQuery.fn[ type ] = function( fn ) {
jQuery.expr.filters.animated = function( elem ) {
return jQuery.grep( jQuery.timers, function( fn ) {
/**
* Gets a window from an element
*/
function getWindow( elem ) {
setOffset: function( elem, options, i ) {
offset: function( options ) {
this.each( function( i ) {
position: function() {
offsetParent: function() {
return this.map( function() {
jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
jQuery.fn[ method ] = function( val ) {
return access( this, function( elem, method, val ) {
jQuery.each( [ "top", "left" ], function( i, prop ) {
function( elem, computed ) {
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
function( defaultExtra, funcName ) {
jQuery.fn[ funcName ] = function( margin, value ) {
return access( this, function( elem, type, value ) {
bind: function( types, data, fn ) {
unbind: function( types, fn ) {
delegate: function( selector, types, data, fn ) {
undelegate: function( selector, types, fn ) {
jQuery.fn.size = function() {
if ( typeof define === "function" && define.amd ) {
define( "jquery", [], function() {
jQuery.noConflict = function( deep ) {