angelakuo/citydogshare

View on GitHub
public/assets/jquery3-d4bd3e85283a3dca94d4167d510fa09702db65cbbcbd798b3ace19480bc43025.js

Summary

Maintainability
F
1 mo
Test Coverage

File jquery3-d4bd3e85283a3dca94d4167d510fa09702db65cbbcbd798b3ace19480bc43025.js has 6521 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*eslint-disable no-unused-vars*/
/*!
 * jQuery JavaScript Library v3.1.0
 * https://jquery.com/
 *

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

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

      Function ajax has 251 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 225 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

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

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

              Deferred: function( func ) {
                  var tuples = [
          
                          // action, add listener, callbacks,
                          // ... .then handlers, argument index, [final state]

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

            function defaultPrefilter( elem, props, opts ) {
                var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
                    isBox = "width" in props || "height" in props,
                    anim = this,
                    orig = {},

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

                                then: function( onFulfilled, onRejected, onProgress ) {
                                    var maxDepth = 0;
                                    function resolve( depth, deferred, handler, special ) {
                                        return function() {
                                            var that = this,

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

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

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

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

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

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

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

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

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

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

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

                                                    function resolve( depth, deferred, handler, special ) {
                                                        return function() {
                                                            var that = this,
                                                                args = arguments,
                                                                mightThrow = function() {

                                  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;
                                  
                                              // Ignore repeat invocations

                                    Consider simplifying this complex logical expression.
                                    Open

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

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

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

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

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

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

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

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

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

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

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

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

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

                                                    Consider simplifying this complex logical expression.
                                                    Open

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

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

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

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

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

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

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

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

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

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

                                                                function addCombinator( matcher, combinator, base ) {
                                                                    var dir = combinator.dir,
                                                                        skip = combinator.next,
                                                                        key = skip || dir,
                                                                        checkNonElements = base && key === "parentNode",

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                                                                                                                  mightThrow = function() {
                                                                                                                      var returned, then;
                                                                                  
                                                                                                                      // Support: Promises/A+ section 2.3.3.3.3
                                                                                                                      // https://promisesaplus.com/#point-59

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

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

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

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

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

                                                                                                jQuery.fn.load = function( url, params, callback ) {
                                                                                                    var selector, type, response,
                                                                                                        self = this,
                                                                                                        off = url.indexOf( " " );
                                                                                                
                                                                                                

                                                                                                  Function attr has 29 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 getWidthOrHeight has 28 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 val,
                                                                                                            valueIsBorderBox = true,

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

                                                                                                            jQuery.parseHTML = function( data, context, keepScripts ) {
                                                                                                                if ( typeof data !== "string" ) {
                                                                                                                    return [];
                                                                                                                }
                                                                                                                if ( typeof context === "boolean" ) {

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

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

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

                                                                                                                      when: function( singleValue ) {
                                                                                                                          var
                                                                                                                  
                                                                                                                              // count of uncompleted subordinates
                                                                                                                              remaining = arguments.length,

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

                                                                                                                        offset: function( options ) {
                                                                                                                    
                                                                                                                            // Preserve chaining for setter
                                                                                                                            if ( arguments.length ) {
                                                                                                                                return options === undefined ?

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

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

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

                                                                                                                        jQuery.speed = function( speed, easing, fn ) {
                                                                                                                            var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
                                                                                                                                complete: fn || !fn && easing ||
                                                                                                                                    jQuery.isFunction( speed ) && speed,
                                                                                                                                duration: speed,

                                                                                                                          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

                                                                                                                                                        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 ( 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 ] ) {
                                                                                                                                                                matches.push( handleObj );
                                                                                                                                                            }

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

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

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

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

                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                          Open

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

                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                            Open

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

                                                                                                                                              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

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

                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                  Open

                                                                                                                                                                          if ( (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 ( !(unmatched[i] || setMatched[i]) ) {
                                                                                                                                                                                    setMatched[i] = pop.call( results );
                                                                                                                                                                                }

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

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

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

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

                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                          Open

                                                                                                                                                                              if ( (nid = context.getAttribute( "id" )) ) {
                                                                                                                                                                                  nid = nid.replace( rcssescape, fcssescape );
                                                                                                                                                                              } else {
                                                                                                                                                                                  context.setAttribute( "id", (nid = expando) );
                                                                                                                                                                              }

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

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

                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                              Open

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

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

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

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

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

                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                    Open

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

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

                                                                                                                                                                          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 ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
                                                                                                                                                                                                            return true;
                                                                                                                                                                                                        }

                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                              Open

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

                                                                                                                                                                                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 ( restoreDisplay == null ) {
                                                                                                                                                                                                          display = style.display;
                                                                                                                                                                                                          restoreDisplay = display === "none" ? "" : display;
                                                                                                                                                                                                      }

                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                    Open

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

                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                      Open

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

                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                        Open

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

                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                          Open

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

                                                                                                                                                                                            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 ( delegateCount && cur.nodeType &&
                                                                                                                                                                                                          ( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
                                                                                                                                                                                              
                                                                                                                                                                                                          for ( ; cur !== this; cur = cur.parentNode || this ) {
                                                                                                                                                                                              
                                                                                                                                                                                              

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

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

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

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

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

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

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

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

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

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

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

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

                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                        return results;

                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                              return ret;

                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                            return ret == null ? undefined : ret;

                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                      Open

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

                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                            return results;

                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                  return elem[ name ];

                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                        return value;

                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                  return results;

                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                        return jQuery.makeArray( selector, this );

                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                              return this;

                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            return rect;

                                                                                                                                                                                                                                      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 sortInput ?
                                                                                                                                                                                                                                                        ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
                                                                                                                                                                                                                                                        0;

                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                          Open

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

                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                    return compare & 4 ? -1 : 1;

                                                                                                                                                                                                                                              There are no issues that match your filters.

                                                                                                                                                                                                                                              Category
                                                                                                                                                                                                                                              Status