angelakuo/citydogshare

View on GitHub
public/assets/jquery-bd7ddd393353a8d2480a622e80342adf488fb6006d667e8b42e4c0073393abee.js

Summary

Maintainability
F
1 mo
Test Coverage

File jquery-bd7ddd393353a8d2480a622e80342adf488fb6006d667e8b42e4c0073393abee.js has 7071 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * jQuery JavaScript Library v1.12.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 248 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 105 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 trigger has 93 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

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

                  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 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 buildFragment has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        function buildFragment( elems, context, scripts, selection, ignored ) {
                            var j, elem, contains,
                                tmp, tag, tbody, wrap,
                                l = elems.length,
                        
                        

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

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

                            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 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 send has 66 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

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

                                      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 init has 63 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 domManip has 63 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

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

                                            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 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 remove has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

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

                                                  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 internalRemoveData has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                    function internalRemoveData( elem, name, pvt ) {
                                                        if ( !acceptData( elem ) ) {
                                                            return;
                                                        }
                                                    
                                                    

                                                      Function internalData has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                      function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
                                                          if ( !acceptData( elem ) ) {
                                                              return;
                                                          }
                                                      
                                                      

                                                        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 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 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 val has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

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

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

                                                                    function computeStyleTests() {
                                                                        var contents, divStyle,
                                                                            documentElement = document.documentElement;
                                                                
                                                                        // Setup

                                                                  Consider simplifying this complex logical expression.
                                                                  Open

                                                                              if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
                                                                                  ( support.htmlSerialize || !rnoshimcache.test( value )  ) &&
                                                                                  ( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
                                                                                  !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
                                                                  
                                                                  

                                                                    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 extend has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                      Open

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

                                                                        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 showHide has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

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

                                                                            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 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,
                                                                                      length = elems.length,
                                                                                      bulk = key == null;
                                                                              
                                                                              

                                                                                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 style has 37 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 ajaxHandleResponses has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                    Open

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

                                                                                      Function toggleClass has 37 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 clone has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                            clone: function( elem, dataAndEvents, deepDataAndEvents ) {
                                                                                                var destElements, node, clone, i, srcElements,
                                                                                                    inPage = jQuery.contains( elem.ownerDocument, elem );
                                                                                        
                                                                                                if ( support.html5Clone || jQuery.isXMLDoc( elem ) ||

                                                                                          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 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 data has 32 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 fixCloneNodeIssues has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                      function fixCloneNodeIssues( src, dest ) {
                                                                                                          var nodeName, e, data;
                                                                                                      
                                                                                                          // We do not need to do anything for non-Elements
                                                                                                          if ( dest.nodeType !== 1 ) {

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

                                                                                                            cleanData: function( elems, /* internal */ forceAcceptData ) {
                                                                                                                var elem, type, id, data,
                                                                                                                    i = 0,
                                                                                                                    internalKey = jQuery.expando,
                                                                                                                    cache = jQuery.cache,

                                                                                                          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 promise has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                            jQuery.ready.promise = function( obj ) {
                                                                                                                if ( !readyList ) {
                                                                                                            
                                                                                                                    readyList = jQuery.Deferred();
                                                                                                            
                                                                                                            

                                                                                                              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 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 html has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                  Open

                                                                                                                      html: function( value ) {
                                                                                                                          return access( this, function( value ) {
                                                                                                                              var elem = this[ 0 ] || {},
                                                                                                                                  i = 0,
                                                                                                                                  l = this.length;

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

                                                                                                                        fix: function( event ) {
                                                                                                                            if ( event[ jQuery.expando ] ) {
                                                                                                                                return 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 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 setup has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                            Open

                                                                                                                                    setup: function() {
                                                                                                                            
                                                                                                                                        if ( rformElems.test( this.nodeName ) ) {
                                                                                                                            
                                                                                                                                            // IE doesn't fire change on a check/radio until blur; trigger it on click

                                                                                                                              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 ) {

                                                                                                                                Function getWidthOrHeight has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                Open

                                                                                                                                function getWidthOrHeight( elem, name, extra ) {
                                                                                                                                
                                                                                                                                    // Start with offset property, which is equivalent to the border-box value
                                                                                                                                    var valueIsBorderBox = true,
                                                                                                                                        val = name === "width" ? elem.offsetWidth : elem.offsetHeight,

                                                                                                                                  Function offset has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                  Open

                                                                                                                                      offset: function( options ) {
                                                                                                                                          if ( arguments.length ) {
                                                                                                                                              return options === undefined ?
                                                                                                                                                  this :
                                                                                                                                                  this.each( function( i ) {

                                                                                                                                    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 ) {

                                                                                                                                          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 ( !selector ) {
                                                                                                                                                                    push.apply( results, seed );
                                                                                                                                                                    return results;
                                                                                                                                                                }

                                                                                                                                              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

                                                                                                                                                                          if ( !attributes && typeof elem.removeAttribute !== "undefined" ) {
                                                                                                                                                                              elem.removeAttribute( internalKey );
                                                                                                                                                  
                                                                                                                                                                          // Webkit & Blink performance suffers when deleting properties
                                                                                                                                                                          // from DOM nodes, so set to undefined instead

                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                    Open

                                                                                                                                                                                    if ( xhr.readyState !== 4 ) {
                                                                                                                                                                                        xhr.abort();
                                                                                                                                                                                    }

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

                                                                                                                                                                                      if ( typeof xhr.responseText === "string" ) {
                                                                                                                                                                                          responses.text = xhr.responseText;
                                                                                                                                                                                      }

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

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

                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                          Open

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

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

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

                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                              Open

                                                                                                                                                                                  if ( conv && s[ "throws" ] ) { // jscs:ignore requireDotNotation
                                                                                                                                                                                      response = conv( response );
                                                                                                                                                                                  } else {
                                                                                                                                                                                      try {
                                                                                                                                                                                          response = conv( response );

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

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

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

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

                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                    Open

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

                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                      Open

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

                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                        Open

                                                                                                                                                                                            while ( j-- ) {
                                                                                                                                                                                                if ( jQuery.nodeName( ( tbody = elem.childNodes[ j ] ), "tbody" ) &&
                                                                                                                                                                                                    !tbody.childNodes.length ) {
                                                                                                                                                                        
                                                                                                                                                                                                    elem.removeChild( tbody );

                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                          Open

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

                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                            Open

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

                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                              Open

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

                                                                                                                                                                                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 ( nid === expando ) {
                                                                                                                                                                                                              context.removeAttribute( "id" );
                                                                                                                                                                                                          }

                                                                                                                                                                                    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 ( copyIsArray ) {
                                                                                                                                                                                                              copyIsArray = false;
                                                                                                                                                                                                              clone = src && jQuery.isArray( src ) ? src : [];
                                                                                                                                                                                      
                                                                                                                                                                                                          } else {

                                                                                                                                                                                        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 ( name in thisCache ) {
                                                                                                                                                                                                                  name = [ name ];
                                                                                                                                                                                                              } else {
                                                                                                                                                                                                                  name = name.split( " " );
                                                                                                                                                                                                              }

                                                                                                                                                                                            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" ) );

                                                                                                                                                                                              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

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

                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                  Open

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

                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    if ( !status && options.isLocal && !options.crossDomain ) {
                                                                                                                                                                                                                                        status = responses.text ? 200 : 404;
                                                                                                                                                                                                    
                                                                                                                                                                                                                                    // IE - #1450: sometimes returns 1223 when it should be 204
                                                                                                                                                                                                                                    } else if ( status === 1223 ) {

                                                                                                                                                                                                      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

                                                                                                                                                                                                                                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

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

                                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                                            Open

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

                                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                      if ( elem.id !== match[ 2 ] ) {
                                                                                                                                                                                                                                          return rootjQuery.find( selector );
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                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

                                                                                                                                                                                                                  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 ] ) {

                                                                                                                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                        if ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&
                                                                                                                                                                                                                            data === undefined && typeof name === "string" ) {
                                                                                                                                                                                                                            return;
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                                                                                                                      Open

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

                                                                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                if ( window.getComputedStyle ) {
                                                                                                                                                                                                                                    divStyle = window.getComputedStyle( div );
                                                                                                                                                                                                                                    pixelPositionVal = ( divStyle || {} ).top !== "1%";
                                                                                                                                                                                                                                    reliableMarginLeftVal = ( divStyle || {} ).marginLeft === "2px";
                                                                                                                                                                                                                                    boxSizingReliableVal = ( divStyle || { width: "4px" } ).width === "4px";

                                                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( !support.opacity ) {
                                                                                                                                                                                                                              jQuery.cssHooks.opacity = {
                                                                                                                                                                                                                                  get: function( elem, computed ) {
                                                                                                                                                                                                                          
                                                                                                                                                                                                                                      // IE uses filters for opacity

                                                                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                    if ( s.crossDomain == null ) {
                                                                                                                                                                                                                                        parts = rurl.exec( s.url.toLowerCase() );
                                                                                                                                                                                                                                        s.crossDomain = !!( parts &&
                                                                                                                                                                                                                                            ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
                                                                                                                                                                                                                                                ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==

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

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

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

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

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

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

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

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

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

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

                                                                                                                                                                                                                                        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 add has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                            Open

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

                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                  return results;

                                                                                                                                                                                                                                                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 value;

                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                return typeof 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 elem[ name ];

                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                return key === undefined || hasOwn.call( obj, key );

                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  return jQuery.makeArray( selector, this );

                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                            return ( context || root ).find( selector );

                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                          return this;

                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                        return ret == null ? undefined : ret;

                                                                                                                                                                                                                                                                  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 results;

                                                                                                                                                                                                                                                                      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 this.constructor( context ).find( selector );

                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                        return ret;

                                                                                                                                                                                                                                                                              There are no issues that match your filters.

                                                                                                                                                                                                                                                                              Category
                                                                                                                                                                                                                                                                              Status