angelakuo/citydogshare

View on GitHub
public/assets/jquery2-25ca496239ae8641a09627c8aace5863e7676e465fbb4ce81bc7eb78c4d15627.js

Summary

Maintainability
F
1 mo
Test Coverage

File jquery2-25ca496239ae8641a09627c8aace5863e7676e465fbb4ce81bc7eb78c4d15627.js has 6373 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * jQuery JavaScript Library v2.2.4
 * http://jquery.com/
 *
 * Includes Sizzle.js

    Function Sizzle has 1387 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    (function( window ) {
    
    var i,
        support,
        Expr,

      Function ajax has 249 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          ajax: function( url, options ) {
      
              // If url is an object, simulate pre-1.5 signature
              if ( typeof url === "object" ) {
                  options = url;

        Function setDocument has 218 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        setDocument = Sizzle.setDocument = function( node ) {
            var hasCompare, parent,
                doc = node ? node.ownerDocument || node : preferredDoc;
        
            // Return early if doc is invalid or already selected

          Consider simplifying this complex logical expression.
          Open

                      if ( event.pageX == null && original.clientX != null ) {
                          eventDoc = event.target.ownerDocument || document;
                          doc = eventDoc.documentElement;
                          body = eventDoc.body;
          
          

            Function Callbacks has 121 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            jQuery.Callbacks = function( options ) {
            
                // Convert options from String-formatted to Object-formatted if needed
                // (we check in cache first)
                options = typeof options === "string" ?

              Function defaultPrefilter has 99 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              function defaultPrefilter( elem, props, opts ) {
                  /* jshint validthis: true */
                  var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
                      anim = this,
                      orig = {},

                Function Animation has 92 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                function Animation( elem, properties, options ) {
                    var result,
                        stopped,
                        index = 0,
                        length = Animation.prefilters.length,

                  Function trigger has 87 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      trigger: function( event, data, elem, onlyHandlers ) {
                  
                          var i, cur, tmp, bubbleType, ontype, handle, special,
                              eventPath = [ elem || document ],
                              type = hasOwn.call( event, "type" ) ? event.type : event,

                    Function Sizzle has 81 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    function Sizzle( selector, context, results, seed ) {
                        var m, i, elem, nid, nidselect, match, groups, newSelector,
                            newContext = context && context.ownerDocument,
                    
                            // nodeType defaults to 9, since context defaults to document

                      Function CHILD has 80 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                              "CHILD": function( type, what, argument, first, last ) {
                                  var simple = type.slice( 0, 3 ) !== "nth",
                                      forward = type.slice( -4 ) !== "last",
                                      ofType = what === "of-type";
                      
                      

                        Function send has 76 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                                    send: function( headers, complete ) {
                                        var i,
                                            xhr = options.xhr();
                        
                                        xhr.open(

                          Function matcherFromGroupMatchers has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
                              var bySet = setMatchers.length > 0,
                                  byElement = elementMatchers.length > 0,
                                  superMatcher = function( seed, context, xml, results, outermost ) {
                                      var elem, j, matcher,

                            Function add has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                add: function( elem, types, handler, data, selector ) {
                            
                                    var handleObjIn, eventHandle, tmp,
                                        events, t, handleObj,
                                        special, handlers, type, namespaces, origType,

                              Function done has 67 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                      function done( status, nativeStatusText, responses, headers ) {
                                          var isSuccess, success, error, response, modified,
                                              statusText = nativeStatusText;
                              
                                          // Called once

                                Consider simplifying this complex logical expression.
                                Open

                                                        if ( forward && useCache ) {
                                
                                                            // Seek `elem` from a previously-cached index
                                
                                                            // ...in a gzip-friendly way

                                  Function setMatcher has 66 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
                                      if ( postFilter && !postFilter[ expando ] ) {
                                          postFilter = setMatcher( postFilter );
                                      }
                                      if ( postFinder && !postFinder[ expando ] ) {

                                    Function superMatcher has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                            superMatcher = function( seed, context, xml, results, outermost ) {
                                                var elem, j, matcher,
                                                    matchedCount = 0,
                                                    i = "0",
                                                    unmatched = seed && [],

                                      Function Deferred has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          Deferred: function( func ) {
                                              var tuples = [
                                      
                                                      // action, add listener, listener list, final state
                                                      [ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],

                                        Function init has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            init = jQuery.fn.init = function( selector, context, root ) {
                                                var match, elem;
                                        
                                                // HANDLE: $(""), $(null), $(undefined), $(false)
                                                if ( !selector ) {

                                          Function ajaxConvert has 59 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                          function ajaxConvert( s, response, jqXHR, isSuccess ) {
                                              var conv2, current, conv, tmp, prev,
                                                  converters = {},
                                          
                                                  // Work with a copy of dataTypes in case we need to modify it for conversion

                                            Function domManip has 58 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                            function domManip( collection, args, callback, ignored ) {
                                            
                                                // Flatten any nested arrays
                                                args = concat.apply( [], args );
                                            
                                            

                                              Function data has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                  data: function( key, value ) {
                                                      var i, name, data,
                                                          elem = this[ 0 ],
                                                          attrs = elem && elem.attributes;
                                              
                                              

                                                Function remove has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                    remove: function( elem, types, handler, selector, mappedTypes ) {
                                                
                                                        var j, origCount, tmp,
                                                            events, t, handleObj,
                                                            special, handlers, type, namespaces, origType,

                                                  Function buildFragment has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                  function buildFragment( elems, context, scripts, selection, ignored ) {
                                                      var elem, tmp, tag, wrap, contains, j,
                                                          fragment = context.createDocumentFragment(),
                                                          nodes = [],
                                                          i = 0,

                                                    Consider simplifying this complex logical expression.
                                                    Open

                                                                    if ( ( mappedTypes || origType === handleObj.origType ) &&
                                                                        ( !handler || handler.guid === handleObj.guid ) &&
                                                                        ( !tmp || tmp.test( handleObj.namespace ) ) &&
                                                                        ( !selector || selector === handleObj.selector ||
                                                                            selector === "**" && handleObj.selector ) ) {

                                                      Function select has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                      select = Sizzle.select = function( selector, context, results, seed ) {
                                                          var i, tokens, token, type, find,
                                                              compiled = typeof selector === "function" && selector,
                                                              match = !seed && tokenize( (selector = compiled.selector || selector) );
                                                      
                                                      

                                                        Function matcherFromTokens has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                        function matcherFromTokens( tokens ) {
                                                            var checkContext, matcher, j,
                                                                len = tokens.length,
                                                                leadingRelative = Expr.relative[ tokens[0].type ],
                                                                implicitRelative = leadingRelative || Expr.relative[" "],

                                                          Function tokenize has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                          tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
                                                              var matched, match, tokens, type,
                                                                  soFar, groups, preFilters,
                                                                  cached = tokenCache[ selector + " " ];
                                                          
                                                          

                                                            Function val has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                                val: function( value ) {
                                                                    var hooks, ret, isFunction,
                                                                        elem = this[ 0 ];
                                                            
                                                                    if ( !arguments.length ) {

                                                              Function showHide has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                              function showHide( elements, show ) {
                                                                  var display, elem, hidden,
                                                                      values = [],
                                                                      index = 0,
                                                                      length = elements.length;

                                                                Function extend has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                jQuery.extend = jQuery.fn.extend = function() {
                                                                    var options, name, src, copy, copyIsArray, clone,
                                                                        target = arguments[ 0 ] || {},
                                                                        i = 1,
                                                                        length = arguments.length,

                                                                  Function stop has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                      stop: function( type, clearQueue, gotoEnd ) {
                                                                          var stopQueue = function( hooks ) {
                                                                              var stop = hooks.stop;
                                                                              delete hooks.stop;
                                                                              stop( gotoEnd );

                                                                    Function on has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                    function on( elem, types, selector, data, fn, one ) {
                                                                        var origFn, type;
                                                                    
                                                                        // Types can be a map of types/handlers
                                                                        if ( typeof types === "object" ) {

                                                                      Function addCombinator has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                      Open

                                                                      function addCombinator( matcher, combinator, base ) {
                                                                          var dir = combinator.dir,
                                                                              checkNonElements = base && dir === "parentNode",
                                                                              doneName = done++;
                                                                      
                                                                      

                                                                        Function access has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                        var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
                                                                            var i = 0,
                                                                                len = elems.length,
                                                                                bulk = key == null;
                                                                        
                                                                        

                                                                          Function toggleClass has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                              toggleClass: function( value, stateVal ) {
                                                                                  var type = typeof value;
                                                                          
                                                                                  if ( typeof stateVal === "boolean" && type === "string" ) {
                                                                                      return stateVal ? this.addClass( value ) : this.removeClass( value );

                                                                            Function when has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                            Open

                                                                                when: function( subordinate /* , ..., subordinateN */ ) {
                                                                                    var i = 0,
                                                                                        resolveValues = slice.call( arguments ),
                                                                                        length = resolveValues.length,
                                                                            
                                                                            

                                                                              Function ajaxHandleResponses has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                              function ajaxHandleResponses( s, jqXHR, responses ) {
                                                                              
                                                                                  var ct, type, finalDataType, firstDataType,
                                                                                      contents = s.contents,
                                                                                      dataTypes = s.dataTypes;

                                                                                Function dispatch has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                Open

                                                                                    dispatch: function( event ) {
                                                                                
                                                                                        // Make a writable jQuery.Event from the native event object
                                                                                        event = jQuery.event.fix( event );
                                                                                
                                                                                

                                                                                  Function style has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                      style: function( elem, name, value, extra ) {
                                                                                  
                                                                                          // Don't set styles on text and comment nodes
                                                                                          if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
                                                                                              return;

                                                                                    Function adjustCSS has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                    Open

                                                                                    function adjustCSS( elem, prop, valueParts, tween ) {
                                                                                        var adjusted,
                                                                                            scale = 1,
                                                                                            maxIterations = 20,
                                                                                            currentValue = tween ?

                                                                                      Function load has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                      Open

                                                                                      jQuery.fn.load = function( url, params, callback ) {
                                                                                          if ( typeof url !== "string" && _load ) {
                                                                                              return _load.apply( this, arguments );
                                                                                          }
                                                                                      
                                                                                      

                                                                                        Function setOffset has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                            setOffset: function( elem, options, i ) {
                                                                                                var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
                                                                                                    position = jQuery.css( elem, "position" ),
                                                                                                    curElem = jQuery( elem ),
                                                                                                    props = {};

                                                                                          Consider simplifying this complex logical expression.
                                                                                          Open

                                                                                              if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
                                                                                          
                                                                                                  // Trust units reported by jQuery.css
                                                                                                  unit = unit || initialInUnit[ 3 ];
                                                                                          
                                                                                          

                                                                                            Function remove has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                            Open

                                                                                                remove: function( owner, key ) {
                                                                                                    var i, name, camel,
                                                                                                        cache = owner[ this.expando ];
                                                                                            
                                                                                                    if ( cache === undefined ) {

                                                                                              Function handlers has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                              Open

                                                                                                  handlers: function( event, handlers ) {
                                                                                                      var i, matches, sel, handleObj,
                                                                                                          handlerQueue = [],
                                                                                                          delegateCount = handlers.delegateCount,
                                                                                                          cur = event.target;

                                                                                                Function removeClass has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                Open

                                                                                                    removeClass: function( value ) {
                                                                                                        var classes, elem, cur, curValue, clazz, j, finalValue,
                                                                                                            i = 0;
                                                                                                
                                                                                                        if ( jQuery.isFunction( value ) ) {

                                                                                                  Function attr has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                      attr: function( elem, name, value ) {
                                                                                                          var ret, hooks,
                                                                                                              nType = elem.nodeType;
                                                                                                  
                                                                                                          // Don't get/set attributes on text, comment and attribute nodes

                                                                                                    Function off has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                        off: function( types, selector, fn ) {
                                                                                                            var handleObj, type;
                                                                                                            if ( types && types.preventDefault && types.handleObj ) {
                                                                                                    
                                                                                                                // ( event )  dispatched jQuery.Event

                                                                                                      Function finish has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                          finish: function( type ) {
                                                                                                              if ( type !== false ) {
                                                                                                                  type = type || "fx";
                                                                                                              }
                                                                                                              return this.each( function() {

                                                                                                        Function addClass has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                        Open

                                                                                                            addClass: function( value ) {
                                                                                                                var classes, elem, cur, curValue, clazz, j, finalValue,
                                                                                                                    i = 0;
                                                                                                        
                                                                                                                if ( jQuery.isFunction( value ) ) {

                                                                                                          Function fix has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                          Open

                                                                                                              fix: function( event ) {
                                                                                                                  if ( event[ jQuery.expando ] ) {
                                                                                                                      return event;
                                                                                                                  }
                                                                                                          
                                                                                                          

                                                                                                            Function clone has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                                clone: function( elem, dataAndEvents, deepDataAndEvents ) {
                                                                                                                    var i, l, srcElements, destElements,
                                                                                                                        clone = elem.cloneNode( true ),
                                                                                                                        inPage = jQuery.contains( elem.ownerDocument, elem );
                                                                                                            
                                                                                                            

                                                                                                              Function propFilter has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                              function propFilter( props, specialEasing ) {
                                                                                                                  var index, name, easing, value, hooks;
                                                                                                              
                                                                                                                  // camelCase, specialEasing and expand cssHook pass
                                                                                                                  for ( index in props ) {

                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                Open

                                                                                                                        if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
                                                                                                                                support.getById && context.nodeType === 9 && documentIsHTML &&
                                                                                                                                Expr.relative[ tokens[1].type ] ) {
                                                                                                                
                                                                                                                            context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];

                                                                                                                  Consider simplifying this complex logical expression.
                                                                                                                  Open

                                                                                                                      if ( support.matchesSelector && documentIsHTML &&
                                                                                                                          !compilerCache[ expr + " " ] &&
                                                                                                                          ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
                                                                                                                          ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
                                                                                                                  
                                                                                                                  

                                                                                                                    Function access has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                    Open

                                                                                                                    var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {

                                                                                                                      Function on has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                      Open

                                                                                                                      function on( elem, types, selector, data, fn, one ) {

                                                                                                                        Function init has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                        Open

                                                                                                                            init: function( elem, options, prop, end, easing, unit ) {

                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                          Open

                                                                                                                                              if ( nodeType === 9 ) {
                                                                                                                                                  if ( (elem = context.getElementById( m )) ) {
                                                                                                                          
                                                                                                                                                      // Support: IE, Opera, Webkit
                                                                                                                                                      // TODO: identify versions

                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                            Open

                                                                                                                                                if ( hasScripts ) {
                                                                                                                            
                                                                                                                                                    // Support: Android<4.1, PhantomJS<2
                                                                                                                                                    // push.apply(_, arraylike) throws on ancient WebKit
                                                                                                                                                    jQuery.merge( scripts, getAll( node, "script" ) );

                                                                                                                              Function setMatcher has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                              Open

                                                                                                                              function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {

                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                Open

                                                                                                                                                        if ( (elem = matcherOut[i]) ) {
                                                                                                                                                            // Restore matcherIn since elem is not yet a final match
                                                                                                                                                            temp.push( (matcherIn[i] = elem) );
                                                                                                                                                        }

                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                  Open

                                                                                                                                                      if ( rscriptType.test( node.type || "" ) &&
                                                                                                                                                          !dataPriv.access( node, "globalEval" ) &&
                                                                                                                                                          jQuery.contains( doc, node ) ) {
                                                                                                                                  
                                                                                                                                                          if ( node.src ) {

                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                    Open

                                                                                                                                                            if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
                                                                                                                                                                cur += clazz + " ";
                                                                                                                                                            }

                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                      Open

                                                                                                                                                              if ( nid === expando ) {
                                                                                                                                                                  context.removeAttribute( "id" );
                                                                                                                                                              }

                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                        Open

                                                                                                                                                            if ( Expr.relative[ tokens[j].type ] ) {
                                                                                                                                                                break;
                                                                                                                                                            }

                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                          Open

                                                                                                                                                                  for ( type in data.events ) {
                                                                                                                                                                      if ( special[ type ] ) {
                                                                                                                                                                          jQuery.event.remove( elem, type );
                                                                                                                                          
                                                                                                                                                                      // This is a shortcut to avoid jQuery.event.remove's overhead

                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                            Open

                                                                                                                                                                        if ( !(unmatched[i] || setMatched[i]) ) {
                                                                                                                                                                            setMatched[i] = pop.call( results );
                                                                                                                                                                        }

                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                              Open

                                                                                                                                                              } else if ( copy !== undefined ) {
                                                                                                                                                                  target[ name ] = copy;
                                                                                                                                                              }

                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                Open

                                                                                                                                                                                    if ( ofType ?
                                                                                                                                                                                        node.nodeName.toLowerCase() === name :
                                                                                                                                                                                        node.nodeType === 1 ) {
                                                                                                                                                
                                                                                                                                                                                        return false;

                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                  Open

                                                                                                                                                                          if ( ( event.result = ret ) === false ) {
                                                                                                                                                                              event.preventDefault();
                                                                                                                                                                              event.stopPropagation();
                                                                                                                                                                          }

                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                    Open

                                                                                                                                                                            if ( matches[ sel ] ) {
                                                                                                                                                                                matches.push( handleObj );
                                                                                                                                                                            }

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

                                                                                                                                                                                          if ( ( ofType ?
                                                                                                                                                                                              node.nodeName.toLowerCase() === name :
                                                                                                                                                                                              node.nodeType === 1 ) &&
                                                                                                                                                                                              ++diff ) {
                                                                                                                                                      
                                                                                                                                                      

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

                                                                                                                                                                                for ( match in context ) {
                                                                                                                                                        
                                                                                                                                                                                    // Properties of context are called as methods if possible
                                                                                                                                                                                    if ( jQuery.isFunction( this[ match ] ) ) {
                                                                                                                                                                                        this[ match ]( context[ match ] );

                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                          Open

                                                                                                                                                                              for ( conv2 in converters ) {
                                                                                                                                                          
                                                                                                                                                                                  // If conv2 outputs current
                                                                                                                                                                                  tmp = conv2.split( " " );
                                                                                                                                                                                  if ( tmp[ 1 ] === current ) {

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

                                                                                                                                                                                    while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
                                                                                                                                                                                        cur = cur.replace( " " + clazz + " ", " " );
                                                                                                                                                                                    }

                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                              Open

                                                                                                                                                                                  if ( (nid = context.getAttribute( "id" )) ) {
                                                                                                                                                                                      nid = nid.replace( rescape, "\\$&" );
                                                                                                                                                                                  } else {
                                                                                                                                                                                      context.setAttribute( "id", (nid = expando) );
                                                                                                                                                                                  }

                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                Open

                                                                                                                                                                                            if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
                                                                                                                                                                                                return true;
                                                                                                                                                                                            }

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

                                                                                                                                                                                          if ( attrs[ i ] ) {
                                                                                                                                                                                              name = attrs[ i ].name;
                                                                                                                                                                                              if ( name.indexOf( "data-" ) === 0 ) {
                                                                                                                                                                                                  name = jQuery.camelCase( name.slice( 5 ) );
                                                                                                                                                                                                  dataAttr( elem, name, data[ name ] );

                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                    Open

                                                                                                                                                                                            if ( matches[ sel ] === undefined ) {
                                                                                                                                                                                                matches[ sel ] = handleObj.needsContext ?
                                                                                                                                                                                                    jQuery( sel, this ).index( cur ) > -1 :
                                                                                                                                                                                                    jQuery.find( sel, this, null, [ cur ] ).length;
                                                                                                                                                                                            }

                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                      Open

                                                                                                                                                                                          while ( i-- ) {
                                                                                                                                                                                              groups[i] = nidselect + " " + toSelector( groups[i] );
                                                                                                                                                                                          }

                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                        Open

                                                                                                                                                                                            if ( copyIsArray ) {
                                                                                                                                                                                                copyIsArray = false;
                                                                                                                                                                                                clone = src && jQuery.isArray( src ) ? src : [];
                                                                                                                                                                        
                                                                                                                                                                                            } else {

                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                          Open

                                                                                                                                                                                          } else if ( match[2] ) {
                                                                                                                                                                                              push.apply( results, context.getElementsByTagName( selector ) );
                                                                                                                                                                                              return results;
                                                                                                                                                                          
                                                                                                                                                                                          // Class selector

                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                            Open

                                                                                                                                                                                                if ( !selector ) {
                                                                                                                                                                                                    push.apply( results, seed );
                                                                                                                                                                                                    return results;
                                                                                                                                                                                                }

                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                              Open

                                                                                                                                                                                                  if ( conv && s.throws ) {
                                                                                                                                                                                                      response = conv( response );
                                                                                                                                                                                                  } else {
                                                                                                                                                                                                      try {
                                                                                                                                                                                                          response = conv( response );

                                                                                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                                                                                Open

                                                                                                                                                                                        if ( delegateCount && cur.nodeType &&
                                                                                                                                                                                            ( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
                                                                                                                                                                                
                                                                                                                                                                                            for ( ; cur !== this; cur = cur.parentNode || this ) {
                                                                                                                                                                                
                                                                                                                                                                                

                                                                                                                                                                                  Consider simplifying this complex logical expression.
                                                                                                                                                                                  Open

                                                                                                                                                                                              if ( matcher[ expando ] ) {
                                                                                                                                                                                                  // Find the next relative operator (if any) for proper handling
                                                                                                                                                                                                  j = ++i;
                                                                                                                                                                                                  for ( ; j < len; j++ ) {
                                                                                                                                                                                                      if ( Expr.relative[ tokens[j].type ] ) {

                                                                                                                                                                                    Function Tween has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                    Open

                                                                                                                                                                                    function Tween( elem, options, prop, end, easing ) {

                                                                                                                                                                                      Function buildFragment has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                      Open

                                                                                                                                                                                      function buildFragment( elems, context, scripts, selection, ignored ) {

                                                                                                                                                                                        Function augmentWidthOrHeight has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                        Open

                                                                                                                                                                                        function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {

                                                                                                                                                                                          Function superMatcher has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                          Open

                                                                                                                                                                                                  superMatcher = function( seed, context, xml, results, outermost ) {

                                                                                                                                                                                            Function add has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                            Open

                                                                                                                                                                                                add: function( elem, types, handler, data, selector ) {

                                                                                                                                                                                              Function condense has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                              Open

                                                                                                                                                                                              function condense( unmatched, map, filter, context, xml ) {

                                                                                                                                                                                                Function remove has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                Open

                                                                                                                                                                                                    remove: function( elem, types, handler, selector, mappedTypes ) {

                                                                                                                                                                                                  Function CHILD has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                  Open

                                                                                                                                                                                                          "CHILD": function( type, what, argument, first, last ) {

                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                                        return results;

                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                      Open

                                                                                                                                                                                                          return select( selector.replace( rtrim, "$1" ), context, results, seed );

                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                                return jQuery.makeArray( selector, this );

                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                          Open

                                                                                                                                                                                                                  return compare & 4 ? -1 : 1;

                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                    return results;

                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                          return root.ready !== undefined ?
                                                                                                                                                                                                                              root.ready( selector ) :
                                                                                                                                                                                                              
                                                                                                                                                                                                                              // Execute immediately if ready is not present
                                                                                                                                                                                                                              selector( jQuery );

                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                        return ret == null ? undefined : ret;

                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                          return elem[ name ];

                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                return sortInput ?
                                                                                                                                                                                                                                    ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
                                                                                                                                                                                                                                    0;

                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                      return this.constructor( context ).find( selector );

                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                            return results;

                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                      return value;

                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                        return ret;

                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                          return this;

                                                                                                                                                                                                                                There are no issues that match your filters.

                                                                                                                                                                                                                                Category
                                                                                                                                                                                                                                Status